![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to clnp_input.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / bsd / netiso|
Return to clnp_input.c CVS log | Up to [Apple XNU] / XNU / bsd / netiso |
1.1 ! root 1: /* ! 2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved. ! 3: * ! 4: * @APPLE_LICENSE_HEADER_START@ ! 5: * ! 6: * The contents of this file constitute Original Code as defined in and ! 7: * are subject to the Apple Public Source License Version 1.1 (the ! 8: * "License"). You may not use this file except in compliance with the ! 9: * License. Please obtain a copy of the License at ! 10: * http://www.apple.com/publicsource and read it before using this file. ! 11: * ! 12: * This Original Code and all software distributed under the License are ! 13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER ! 14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, ! 15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, ! 16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the ! 17: * License for the specific language governing rights and limitations ! 18: * under the License. ! 19: * ! 20: * @APPLE_LICENSE_HEADER_END@ ! 21: */ ! 22: /*- ! 23: * Copyright (c) 1991, 1993 ! 24: * The Regents of the University of California. All rights reserved. ! 25: * ! 26: * Redistribution and use in source and binary forms, with or without ! 27: * modification, are permitted provided that the following conditions ! 28: * are met: ! 29: * 1. Redistributions of source code must retain the above copyright ! 30: * notice, this list of conditions and the following disclaimer. ! 31: * 2. Redistributions in binary form must reproduce the above copyright ! 32: * notice, this list of conditions and the following disclaimer in the ! 33: * documentation and/or other materials provided with the distribution. ! 34: * 3. All advertising materials mentioning features or use of this software ! 35: * must display the following acknowledgement: ! 36: * This product includes software developed by the University of ! 37: * California, Berkeley and its contributors. ! 38: * 4. Neither the name of the University nor the names of its contributors ! 39: * may be used to endorse or promote products derived from this software ! 40: * without specific prior written permission. ! 41: * ! 42: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ! 43: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ! 44: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ! 45: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE ! 46: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ! 47: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ! 48: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ! 49: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ! 50: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ! 51: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ! 52: * SUCH DAMAGE. ! 53: * ! 54: * @(#)clnp_input.c 8.1 (Berkeley) 6/10/93 ! 55: */ ! 56: ! 57: /*********************************************************** ! 58: Copyright IBM Corporation 1987 ! 59: ! 60: All Rights Reserved ! 61: ! 62: Permission to use, copy, modify, and distribute this software and its ! 63: documentation for any purpose and without fee is hereby granted, ! 64: provided that the above copyright notice appear in all copies and that ! 65: both that copyright notice and this permission notice appear in ! 66: supporting documentation, and that the name of IBM not be ! 67: used in advertising or publicity pertaining to distribution of the ! 68: software without specific, written prior permission. ! 69: ! 70: IBM DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ! 71: ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL ! 72: IBM BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ! 73: ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, ! 74: WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ! 75: ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS ! 76: SOFTWARE. ! 77: ! 78: ******************************************************************/ ! 79: ! 80: /* ! 81: * ARGO Project, Computer Sciences Dept., University of Wisconsin - Madison ! 82: */ ! 83: ! 84: #include <sys/param.h> ! 85: #include <sys/mbuf.h> ! 86: #include <sys/domain.h> ! 87: #include <sys/protosw.h> ! 88: #include <sys/socket.h> ! 89: #include <sys/socketvar.h> ! 90: #include <sys/errno.h> ! 91: #include <sys/time.h> ! 92: ! 93: #include <net/if.h> ! 94: #include <net/if_types.h> ! 95: #include <net/route.h> ! 96: ! 97: #include <netiso/iso.h> ! 98: #include <netiso/iso_var.h> ! 99: #include <netiso/iso_snpac.h> ! 100: #include <netiso/clnp.h> ! 101: #include <netiso/clnl.h> ! 102: #include <netiso/esis.h> ! 103: #include <netinet/in_systm.h> ! 104: #include <netinet/ip.h> ! 105: #include <netinet/if_ether.h> ! 106: #include <netiso/eonvar.h> ! 107: #include <netiso/clnp_stat.h> ! 108: #include <netiso/argo_debug.h> ! 109: ! 110: #if ISO ! 111: u_char clnp_protox[ISOPROTO_MAX]; ! 112: struct clnl_protosw clnl_protox[256]; ! 113: int clnpqmaxlen = IFQ_MAXLEN; /* RAH? why is this a variable */ ! 114: struct mbuf *clnp_data_ck(); ! 115: ! 116: int clnp_input(); ! 117: ! 118: int esis_input(); ! 119: ! 120: #ifdef ISO_X25ESIS ! 121: int x25esis_input(); ! 122: #endif /* ISO_X25ESIS */ ! 123: ! 124: /* ! 125: * FUNCTION: clnp_init ! 126: * ! 127: * PURPOSE: clnp initialization. Fill in clnp switch tables. ! 128: * ! 129: * RETURNS: none ! 130: * ! 131: * SIDE EFFECTS: fills in clnp_protox table with correct offsets into ! 132: * the isosw table. ! 133: * ! 134: * NOTES: ! 135: */ ! 136: clnp_init() ! 137: { ! 138: register struct protosw *pr; ! 139: ! 140: /* ! 141: * CLNP protox initialization ! 142: */ ! 143: if ((pr = pffindproto(PF_ISO, ISOPROTO_RAW, SOCK_RAW)) == 0) ! 144: printf("clnl_init: no raw CLNP\n"); ! 145: else ! 146: clnp_protox[ISOPROTO_RAW] = pr - isosw; ! 147: ! 148: if ((pr = pffindproto(PF_ISO, ISOPROTO_TP, SOCK_SEQPACKET)) == 0) ! 149: printf("clnl_init: no tp/clnp\n"); ! 150: else ! 151: clnp_protox[ISOPROTO_TP] = pr - isosw; ! 152: ! 153: /* ! 154: * CLNL protox initialization ! 155: */ ! 156: clnl_protox[ISO8473_CLNP].clnl_input = clnp_input; ! 157: ! 158: clnlintrq.ifq_maxlen = clnpqmaxlen; ! 159: } ! 160: ! 161: /* ! 162: * FUNCTION: clnlintr ! 163: * ! 164: * PURPOSE: Process a packet on the clnl input queue ! 165: * ! 166: * RETURNS: nothing. ! 167: * ! 168: * SIDE EFFECTS: ! 169: * ! 170: * NOTES: ! 171: */ ! 172: clnlintr() ! 173: { ! 174: register struct mbuf *m; /* ptr to first mbuf of pkt */ ! 175: register struct clnl_fixed *clnl; /* ptr to fixed part of clnl hdr */ ! 176: int s; /* save and restore priority */ ! 177: struct clnl_protosw *clnlsw;/* ptr to protocol switch */ ! 178: struct snpa_hdr sh; /* subnetwork hdr */ ! 179: ! 180: /* ! 181: * Get next datagram off clnl input queue ! 182: */ ! 183: next: ! 184: s = splimp(); ! 185: /* IF_DEQUEUESNPAHDR(&clnlintrq, m, sh);*/ ! 186: IF_DEQUEUE(&clnlintrq, m); ! 187: splx(s); ! 188: ! 189: ! 190: if (m == 0) /* nothing to do */ ! 191: return; ! 192: if ((m->m_flags & M_PKTHDR) == 0 || m->m_pkthdr.rcvif == 0) { ! 193: m_freem(m); ! 194: goto next; ! 195: } else { ! 196: register struct ifaddr *ifa; ! 197: for (ifa = m->m_pkthdr.rcvif->if_addrlist; ifa; ifa = ifa->ifa_next) ! 198: if (ifa->ifa_addr->sa_family == AF_ISO) ! 199: break; ! 200: if (ifa == 0) { ! 201: m_freem(m); ! 202: goto next; ! 203: } ! 204: } ! 205: bzero((caddr_t)&sh, sizeof(sh)); ! 206: sh.snh_flags = m->m_flags & (M_MCAST|M_BCAST); ! 207: switch((sh.snh_ifp = m->m_pkthdr.rcvif)->if_type) { ! 208: extern int ether_output(); ! 209: case IFT_EON: ! 210: bcopy(mtod(m, caddr_t), (caddr_t)sh.snh_dhost, sizeof(u_long)); ! 211: bcopy(sizeof(u_long) + mtod(m, caddr_t), ! 212: (caddr_t)sh.snh_shost, sizeof(u_long)); ! 213: sh.snh_dhost[4] = mtod(m, u_char *)[sizeof(struct ip) + ! 214: _offsetof(struct eon_hdr, eonh_class)]; ! 215: m->m_data += EONIPLEN; ! 216: m->m_len -= EONIPLEN; ! 217: m->m_pkthdr.len -= EONIPLEN; ! 218: break; ! 219: ! 220: default: ! 221: if (sh.snh_ifp->if_output == ether_output) { ! 222: bcopy((caddr_t)(mtod(m, struct ether_header *)->ether_dhost), ! 223: (caddr_t)sh.snh_dhost, 2*sizeof(sh.snh_dhost)); ! 224: m->m_data += sizeof (struct ether_header); ! 225: m->m_len -= sizeof (struct ether_header); ! 226: m->m_pkthdr.len -= sizeof (struct ether_header); ! 227: } ! 228: } ! 229: IFDEBUG(D_INPUT) ! 230: int i; ! 231: printf("clnlintr: src:"); ! 232: for (i=0; i<6; i++) ! 233: printf("%x%c", sh.snh_shost[i] & 0xff, (i<5) ? ':' : ' '); ! 234: printf(" dst:"); ! 235: for (i=0; i<6; i++) ! 236: printf("%x%c", sh.snh_dhost[i] & 0xff, (i<5) ? ':' : ' '); ! 237: printf("\n"); ! 238: ENDDEBUG ! 239: ! 240: /* ! 241: * Get the fixed part of the clnl header into the first mbuf. ! 242: * Drop the packet if this fails. ! 243: * Do not call m_pullup if we have a cluster mbuf or the ! 244: * data is not there. ! 245: */ ! 246: if ((IS_CLUSTER(m) || (m->m_len < sizeof(struct clnl_fixed))) && ! 247: ((m = m_pullup(m, sizeof(struct clnl_fixed))) == 0)) { ! 248: INCSTAT(cns_toosmall); /* TODO: use clnl stats */ ! 249: goto next; /* m_pullup discards mbuf */ ! 250: } ! 251: ! 252: clnl = mtod(m, struct clnl_fixed *); ! 253: ! 254: /* ! 255: * Drop packet if the length of the header is not reasonable. ! 256: */ ! 257: if ((clnl->cnf_hdr_len < CLNP_HDR_MIN) || ! 258: (clnl->cnf_hdr_len > CLNP_HDR_MAX)) { ! 259: INCSTAT(cns_badhlen); /* TODO: use clnl stats */ ! 260: m_freem(m); ! 261: goto next; ! 262: } ! 263: ! 264: /* ! 265: * If the header is not contained in this mbuf, make it so. ! 266: * Drop packet if this fails. ! 267: * Note: m_pullup will allocate a cluster mbuf if necessary ! 268: */ ! 269: if (clnl->cnf_hdr_len > m->m_len) { ! 270: if ((m = m_pullup(m, (int)clnl->cnf_hdr_len)) == 0) { ! 271: INCSTAT(cns_badhlen); /* TODO: use clnl stats */ ! 272: goto next; /* m_pullup discards mbuf */ ! 273: } ! 274: clnl = mtod(m, struct clnl_fixed *); ! 275: } ! 276: ! 277: clnlsw = &clnl_protox[clnl->cnf_proto_id]; ! 278: ! 279: ! 280: if (clnlsw->clnl_input) ! 281: (*clnlsw->clnl_input) (m, &sh); ! 282: else ! 283: m_freem(m); ! 284: ! 285: goto next; ! 286: } ! 287: ! 288: /* ! 289: * FUNCTION: clnp_input ! 290: * ! 291: * PURPOSE: process an incoming clnp packet ! 292: * ! 293: * RETURNS: nothing ! 294: * ! 295: * SIDE EFFECTS: increments fields of clnp_stat structure. ! 296: * ! 297: * NOTES: ! 298: * TODO: I would like to make seg_part a pointer into the mbuf, but ! 299: * will it be correctly aligned? ! 300: */ ! 301: clnp_input(m, shp) ! 302: struct mbuf *m; /* ptr to first mbuf of pkt */ ! 303: struct snpa_hdr *shp; /* subnetwork header */ ! 304: { ! 305: register struct clnp_fixed *clnp; /* ptr to fixed part of header */ ! 306: struct sockaddr_iso source; /* source address of pkt */ ! 307: struct sockaddr_iso target; /* destination address of pkt */ ! 308: #define src source.siso_addr ! 309: #define dst target.siso_addr ! 310: caddr_t hoff; /* current offset in packet */ ! 311: caddr_t hend; /* address of end of header info */ ! 312: struct clnp_segment seg_part; /* segment part of hdr */ ! 313: int seg_off=0; /* offset of segment part of hdr */ ! 314: int seg_len;/* length of packet data&hdr in bytes */ ! 315: struct clnp_optidx oidx, *oidxp = NULL; /* option index */ ! 316: extern int iso_systype; /* used by ESIS config resp */ ! 317: extern struct sockaddr_iso blank_siso; /* used for initializing */ ! 318: int need_afrin = 0; ! 319: /* true if congestion experienced */ ! 320: /* which means you need afrin nose */ ! 321: /* spray. How clever! */ ! 322: ! 323: IFDEBUG(D_INPUT) ! 324: printf( ! 325: "clnp_input: proccessing dg; First mbuf m_len %d, m_type x%x, %s\n", ! 326: m->m_len, m->m_type, IS_CLUSTER(m) ? "cluster" : "normal"); ! 327: ENDDEBUG ! 328: need_afrin = 0; ! 329: ! 330: /* ! 331: * If no iso addresses have been set, there is nothing ! 332: * to do with the packet. ! 333: */ ! 334: if (iso_ifaddr == NULL) { ! 335: clnp_discard(m, ADDR_DESTUNREACH); ! 336: return; ! 337: } ! 338: ! 339: INCSTAT(cns_total); ! 340: clnp = mtod(m, struct clnp_fixed *); ! 341: ! 342: IFDEBUG(D_DUMPIN) ! 343: struct mbuf *mhead; ! 344: int total_len = 0; ! 345: printf("clnp_input: clnp header:\n"); ! 346: dump_buf(mtod(m, caddr_t), clnp->cnf_hdr_len); ! 347: printf("clnp_input: mbuf chain:\n"); ! 348: for (mhead = m; mhead != NULL; mhead=mhead->m_next) { ! 349: printf("m x%x, len %d\n", mhead, mhead->m_len); ! 350: total_len += mhead->m_len; ! 351: } ! 352: printf("clnp_input: total length of mbuf chain %d:\n", total_len); ! 353: ENDDEBUG ! 354: ! 355: /* ! 356: * Compute checksum (if necessary) and drop packet if ! 357: * checksum does not match ! 358: */ ! 359: if (CKSUM_REQUIRED(clnp) && iso_check_csum(m, (int)clnp->cnf_hdr_len)) { ! 360: INCSTAT(cns_badcsum); ! 361: clnp_discard(m, GEN_BADCSUM); ! 362: return; ! 363: } ! 364: ! 365: if (clnp->cnf_vers != ISO8473_V1) { ! 366: INCSTAT(cns_badvers); ! 367: clnp_discard(m, DISC_UNSUPPVERS); ! 368: return; ! 369: } ! 370: ! 371: ! 372: /* check mbuf data length: clnp_data_ck will free mbuf upon error */ ! 373: CTOH(clnp->cnf_seglen_msb, clnp->cnf_seglen_lsb, seg_len); ! 374: if ((m = clnp_data_ck(m, seg_len)) == 0) ! 375: return; ! 376: ! 377: clnp = mtod(m, struct clnp_fixed *); ! 378: hend = (caddr_t)clnp + clnp->cnf_hdr_len; ! 379: ! 380: /* ! 381: * extract the source and destination address ! 382: * drop packet on failure ! 383: */ ! 384: source = target = blank_siso; ! 385: ! 386: hoff = (caddr_t)clnp + sizeof(struct clnp_fixed); ! 387: CLNP_EXTRACT_ADDR(dst, hoff, hend); ! 388: if (hoff == (caddr_t)0) { ! 389: INCSTAT(cns_badaddr); ! 390: clnp_discard(m, GEN_INCOMPLETE); ! 391: return; ! 392: } ! 393: CLNP_EXTRACT_ADDR(src, hoff, hend); ! 394: if (hoff == (caddr_t)0) { ! 395: INCSTAT(cns_badaddr); ! 396: clnp_discard(m, GEN_INCOMPLETE); ! 397: return; ! 398: } ! 399: ! 400: IFDEBUG(D_INPUT) ! 401: printf("clnp_input: from %s", clnp_iso_addrp(&src)); ! 402: printf(" to %s\n", clnp_iso_addrp(&dst)); ! 403: ENDDEBUG ! 404: ! 405: /* ! 406: * extract the segmentation information, if it is present. ! 407: * drop packet on failure ! 408: */ ! 409: if (((clnp->cnf_type & CNF_TYPE) != CLNP_ER) && ! 410: (clnp->cnf_type & CNF_SEG_OK)) { ! 411: if (hoff + sizeof(struct clnp_segment) > hend) { ! 412: INCSTAT(cns_noseg); ! 413: clnp_discard(m, GEN_INCOMPLETE); ! 414: return; ! 415: } else { ! 416: (void) bcopy(hoff, (caddr_t)&seg_part, sizeof(struct clnp_segment)); ! 417: /* make sure segmentation fields are in host order */ ! 418: seg_part.cng_id = ntohs(seg_part.cng_id); ! 419: seg_part.cng_off = ntohs(seg_part.cng_off); ! 420: seg_part.cng_tot_len = ntohs(seg_part.cng_tot_len); ! 421: seg_off = hoff - (caddr_t)clnp; ! 422: hoff += sizeof(struct clnp_segment); ! 423: } ! 424: } ! 425: ! 426: /* ! 427: * process options if present. If clnp_opt_sanity returns ! 428: * false (indicating an error was found in the options) or ! 429: * an unsupported option was found ! 430: * then drop packet and emit an ER. ! 431: */ ! 432: if (hoff < hend) { ! 433: int errcode; ! 434: ! 435: oidxp = &oidx; ! 436: errcode = clnp_opt_sanity(m, hoff, hend-hoff, oidxp); ! 437: ! 438: /* we do not support security */ ! 439: if ((errcode == 0) && (oidxp->cni_securep)) ! 440: errcode = DISC_UNSUPPSECURE; ! 441: ! 442: /* the er option is valid with ER pdus only */ ! 443: if ((errcode == 0) && (oidxp->cni_er_reason != ER_INVALREAS) && ! 444: ((clnp->cnf_type & CNF_TYPE) != CLNP_ER)) ! 445: errcode = DISC_UNSUPPOPT; ! 446: ! 447: #ifdef DECBIT ! 448: /* check if the congestion experienced bit is set */ ! 449: if (oidxp->cni_qos_formatp) { ! 450: caddr_t qosp = CLNP_OFFTOOPT(m, oidxp->cni_qos_formatp); ! 451: u_char qos = *qosp; ! 452: ! 453: need_afrin = ((qos & (CLNPOVAL_GLOBAL|CLNPOVAL_CONGESTED)) == ! 454: (CLNPOVAL_GLOBAL|CLNPOVAL_CONGESTED)); ! 455: if (need_afrin) ! 456: INCSTAT(cns_congest_rcvd); ! 457: } ! 458: #endif /* DECBIT */ ! 459: ! 460: if (errcode != 0) { ! 461: clnp_discard(m, (char)errcode); ! 462: IFDEBUG(D_INPUT) ! 463: printf("clnp_input: dropped (err x%x) due to bad options\n", ! 464: errcode); ! 465: ENDDEBUG ! 466: return; ! 467: } ! 468: } ! 469: ! 470: /* ! 471: * check if this packet is for us. if not, then forward ! 472: */ ! 473: if (clnp_ours(&dst) == 0) { ! 474: IFDEBUG(D_INPUT) ! 475: printf("clnp_input: forwarding packet not for us\n"); ! 476: ENDDEBUG ! 477: clnp_forward(m, seg_len, &dst, oidxp, seg_off, shp); ! 478: return; ! 479: } ! 480: ! 481: /* ! 482: * ESIS Configuration Response Function ! 483: * ! 484: * If the packet received was sent to the multicast address ! 485: * all end systems, then send an esh to the source ! 486: */ ! 487: if ((shp->snh_flags & M_MCAST) && (iso_systype == SNPA_ES)) { ! 488: extern short esis_holding_time; ! 489: ! 490: esis_shoutput(shp->snh_ifp, ESIS_ESH, esis_holding_time, ! 491: shp->snh_shost, 6, &dst); ! 492: } ! 493: ! 494: /* ! 495: * If this is a fragment, then try to reassemble it. If clnp_reass ! 496: * returns non NULL, the packet has been reassembled, and should ! 497: * be give to TP. Otherwise the fragment has been delt with ! 498: * by the reassembly code (either stored or deleted). In either case ! 499: * we should have nothing more to do with it. ! 500: */ ! 501: if (((clnp->cnf_type & CNF_TYPE) != CLNP_ER) && ! 502: (clnp->cnf_type & CNF_SEG_OK) && ! 503: (seg_len != seg_part.cng_tot_len)) { ! 504: struct mbuf *m0; ! 505: ! 506: if ((m0 = clnp_reass(m, &src, &dst, &seg_part)) != NULL) { ! 507: m = m0; ! 508: clnp = mtod(m, struct clnp_fixed *); ! 509: INCSTAT(cns_reassembled); ! 510: } else { ! 511: return; ! 512: } ! 513: } ! 514: ! 515: /* ! 516: * give the packet to the higher layer ! 517: * ! 518: * Note: the total length of packet ! 519: * is the total length field of the segmentation part, ! 520: * or, if absent, the segment length field of the ! 521: * header. ! 522: */ ! 523: INCSTAT(cns_delivered); ! 524: switch (clnp->cnf_type & CNF_TYPE) { ! 525: case CLNP_ER: ! 526: /* ! 527: * This ER must have the er option. ! 528: * If the option is not present, discard datagram. ! 529: */ ! 530: if (oidxp == NULL || oidxp->cni_er_reason == ER_INVALREAS) { ! 531: clnp_discard(m, GEN_HDRSYNTAX); ! 532: } else { ! 533: clnp_er_input(m, &src, oidxp->cni_er_reason); ! 534: } ! 535: break; ! 536: ! 537: case CLNP_DT: ! 538: (*isosw[clnp_protox[ISOPROTO_TP]].pr_input)(m, &source, &target, ! 539: clnp->cnf_hdr_len, need_afrin); ! 540: break; ! 541: ! 542: case CLNP_RAW: ! 543: case CLNP_ECR: ! 544: IFDEBUG(D_INPUT) ! 545: printf("clnp_input: raw input of %d bytes\n", ! 546: clnp->cnf_type & CNF_SEG_OK ? seg_part.cng_tot_len : seg_len); ! 547: ENDDEBUG ! 548: (*isosw[clnp_protox[ISOPROTO_RAW]].pr_input)(m, &source, &target, ! 549: clnp->cnf_hdr_len); ! 550: break; ! 551: ! 552: case CLNP_EC: ! 553: IFDEBUG(D_INPUT) ! 554: printf("clnp_input: echoing packet\n"); ! 555: ENDDEBUG ! 556: (void)clnp_echoreply(m, ! 557: (clnp->cnf_type & CNF_SEG_OK ? (int)seg_part.cng_tot_len : seg_len), ! 558: &source, &target, oidxp); ! 559: break; ! 560: ! 561: default: ! 562: printf("clnp_input: unknown clnp pkt type %d\n", ! 563: clnp->cnf_type & CNF_TYPE); ! 564: clnp_stat.cns_delivered--; ! 565: clnp_stat.cns_noproto++; ! 566: clnp_discard(m, GEN_HDRSYNTAX); ! 567: break; ! 568: } ! 569: } ! 570: #endif /* ISO */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.