![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to clnp_output.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Net/2] / Net2 / netiso|
Return to clnp_output.c CVS log | Up to [Net/2] / Net2 / netiso |
1.1 ! root 1: /*- ! 2: * Copyright (c) 1991 The Regents of the University of California. ! 3: * All rights reserved. ! 4: * ! 5: * Redistribution and use in source and binary forms, with or without ! 6: * modification, are permitted provided that the following conditions ! 7: * are met: ! 8: * 1. Redistributions of source code must retain the above copyright ! 9: * notice, this list of conditions and the following disclaimer. ! 10: * 2. Redistributions in binary form must reproduce the above copyright ! 11: * notice, this list of conditions and the following disclaimer in the ! 12: * documentation and/or other materials provided with the distribution. ! 13: * 3. All advertising materials mentioning features or use of this software ! 14: * must display the following acknowledgement: ! 15: * This product includes software developed by the University of ! 16: * California, Berkeley and its contributors. ! 17: * 4. Neither the name of the University nor the names of its contributors ! 18: * may be used to endorse or promote products derived from this software ! 19: * without specific prior written permission. ! 20: * ! 21: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ! 22: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ! 23: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ! 24: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE ! 25: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ! 26: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ! 27: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ! 28: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ! 29: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ! 30: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ! 31: * SUCH DAMAGE. ! 32: * ! 33: * @(#)clnp_output.c 7.10 (Berkeley) 5/6/91 ! 34: */ ! 35: ! 36: /*********************************************************** ! 37: Copyright IBM Corporation 1987 ! 38: ! 39: All Rights Reserved ! 40: ! 41: Permission to use, copy, modify, and distribute this software and its ! 42: documentation for any purpose and without fee is hereby granted, ! 43: provided that the above copyright notice appear in all copies and that ! 44: both that copyright notice and this permission notice appear in ! 45: supporting documentation, and that the name of IBM not be ! 46: used in advertising or publicity pertaining to distribution of the ! 47: software without specific, written prior permission. ! 48: ! 49: IBM DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ! 50: ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL ! 51: IBM BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ! 52: ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, ! 53: WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ! 54: ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS ! 55: SOFTWARE. ! 56: ! 57: ******************************************************************/ ! 58: ! 59: /* ! 60: * ARGO Project, Computer Sciences Dept., University of Wisconsin - Madison ! 61: */ ! 62: /* $Header: /var/src/sys/netiso/RCS/clnp_output.c,v 5.0 89/02/08 12:00:15 hagens Exp $ */ ! 63: /* $Source: /var/src/sys/netiso/RCS/clnp_output.c,v $ */ ! 64: ! 65: #include "param.h" ! 66: #include "mbuf.h" ! 67: #include "domain.h" ! 68: #include "protosw.h" ! 69: #include "socket.h" ! 70: #include "socketvar.h" ! 71: #include "errno.h" ! 72: #include "time.h" ! 73: ! 74: #include "../net/if.h" ! 75: #include "../net/route.h" ! 76: ! 77: #include "iso.h" ! 78: #include "iso_var.h" ! 79: #include "iso_pcb.h" ! 80: #include "clnp.h" ! 81: #include "clnp_stat.h" ! 82: #include "argo_debug.h" ! 83: ! 84: static struct clnp_fixed dt_template = { ! 85: ISO8473_CLNP, /* network identifier */ ! 86: 0, /* length */ ! 87: ISO8473_V1, /* version */ ! 88: CLNP_TTL, /* ttl */ ! 89: CLNP_DT|CNF_SEG_OK|CNF_ERR_OK, /* type */ ! 90: 0, /* segment length */ ! 91: 0 /* checksum */ ! 92: }; ! 93: ! 94: static struct clnp_fixed raw_template = { ! 95: ISO8473_CLNP, /* network identifier */ ! 96: 0, /* length */ ! 97: ISO8473_V1, /* version */ ! 98: CLNP_TTL, /* ttl */ ! 99: CLNP_RAW|CNF_SEG_OK|CNF_ERR_OK, /* type */ ! 100: 0, /* segment length */ ! 101: 0 /* checksum */ ! 102: }; ! 103: ! 104: static struct clnp_fixed echo_template = { ! 105: ISO8473_CLNP, /* network identifier */ ! 106: 0, /* length */ ! 107: ISO8473_V1, /* version */ ! 108: CLNP_TTL, /* ttl */ ! 109: CLNP_EC|CNF_SEG_OK|CNF_ERR_OK, /* type */ ! 110: 0, /* segment length */ ! 111: 0 /* checksum */ ! 112: }; ! 113: ! 114: #ifdef DECBIT ! 115: u_char qos_option[] = {CLNPOVAL_QOS, 1, ! 116: CLNPOVAL_GLOBAL|CLNPOVAL_SEQUENCING|CLNPOVAL_LOWDELAY}; ! 117: #endif DECBIT ! 118: ! 119: int clnp_id = 0; /* id for segmented dgrams */ ! 120: ! 121: /* ! 122: * FUNCTION: clnp_output ! 123: * ! 124: * PURPOSE: output the data in the mbuf as a clnp datagram ! 125: * ! 126: * The data specified by m0 is sent as a clnp datagram. ! 127: * The mbuf chain m0 will be freed when this routine has ! 128: * returned. ! 129: * ! 130: * If options is non-null, it points to an mbuf which contains ! 131: * options to be sent with the datagram. The options must ! 132: * be formatted in the mbuf according to clnp rules. Options ! 133: * will not be freed. ! 134: * ! 135: * Datalen specifies the length of the data in m0. ! 136: * ! 137: * Src and dst are the addresses for the packet. ! 138: * ! 139: * If route is non-null, it is used as the route for ! 140: * the packet. ! 141: * ! 142: * By default, a DT is sent. However, if flags & CNLP_SEND_ER ! 143: * then an ER will be sent. If flags & CLNP_SEND_RAW, then ! 144: * the packet will be send as raw clnp. ! 145: * ! 146: * RETURNS: 0 success ! 147: * appropriate error code ! 148: * ! 149: * SIDE EFFECTS: none ! 150: * ! 151: * NOTES: ! 152: * Flags are interpretated as follows: ! 153: * CLNP_NO_SEG - do not allow this pkt to be segmented. ! 154: * CLNP_NO_ER - have pkt request ER suppression. ! 155: * CLNP_SEND_RAW - send pkt as RAW DT rather than TP DT ! 156: * CLNP_NO_CKSUM - don't compute clnp checksum ! 157: * CLNP_ECHO - send as ECHO packet ! 158: * ! 159: * When checking for a cached packet, clnp checks ! 160: * that the route taken is still up. It does not ! 161: * check that the route is still to the same destination. ! 162: * This means that any entity that alters an existing ! 163: * route for an isopcb (such as when a redirect arrives) ! 164: * must invalidate the clnp cache. It might be perferable ! 165: * to have clnp check that the route has the same dest, but ! 166: * by avoiding this check, we save a call to iso_addrmatch1. ! 167: */ ! 168: clnp_output(m0, isop, datalen, flags) ! 169: struct mbuf *m0; /* data for the packet */ ! 170: struct isopcb *isop; /* iso pcb */ ! 171: int datalen; /* number of bytes of data in m0 */ ! 172: int flags; /* flags */ ! 173: { ! 174: int error = 0; /* return value of function */ ! 175: register struct mbuf *m = m0; /* mbuf for clnp header chain */ ! 176: register struct clnp_fixed *clnp; /* ptr to fixed part of hdr */ ! 177: register caddr_t hoff; /* offset into header */ ! 178: int total_len; /* total length of packet */ ! 179: struct iso_addr *src; /* ptr to source address */ ! 180: struct iso_addr *dst; /* ptr to destination address */ ! 181: struct clnp_cache clc; /* storage for cache information */ ! 182: struct clnp_cache *clcp = NULL; /* ptr to clc */ ! 183: int hdrlen = 0; ! 184: ! 185: dst = &isop->isop_faddr->siso_addr; ! 186: if (isop->isop_laddr == 0) { ! 187: struct iso_ifaddr *ia = 0; ! 188: clnp_route(dst, &isop->isop_route, flags, 0, &ia); ! 189: if (ia == 0 || ia->ia_ifa.ifa_addr->sa_family != AF_ISO) ! 190: return (ENETUNREACH); ! 191: src = &ia->ia_addr.siso_addr; ! 192: } else ! 193: src = &isop->isop_laddr->siso_addr; ! 194: ! 195: IFDEBUG(D_OUTPUT) ! 196: printf("clnp_output: to %s", clnp_iso_addrp(dst)); ! 197: printf(" from %s of %d bytes\n", clnp_iso_addrp(src), datalen); ! 198: printf("\toptions x%x, flags x%x, isop_clnpcache x%x\n", ! 199: isop->isop_options, flags, isop->isop_clnpcache); ! 200: ENDDEBUG ! 201: ! 202: if (isop->isop_clnpcache != NULL) { ! 203: clcp = mtod(isop->isop_clnpcache, struct clnp_cache *); ! 204: } ! 205: ! 206: /* ! 207: * Check if cache is valid ... ! 208: */ ! 209: IFDEBUG(D_OUTPUT) ! 210: printf("clnp_output: ck cache: clcp %x\n", clcp); ! 211: if (clcp != NULL) { ! 212: printf("\tclc_dst %s\n", clnp_iso_addrp(&clcp->clc_dst)); ! 213: printf("\tisop_opts x%x, clc_opts x%x\n", isop->isop_options, ! 214: clcp->clc_options); ! 215: if (isop->isop_route.ro_rt) ! 216: printf("\tro_rt x%x, rt_flags x%x\n", ! 217: isop->isop_route.ro_rt, isop->isop_route.ro_rt->rt_flags); ! 218: printf("\tflags x%x, clc_flags x%x\n", flags, clcp->clc_flags); ! 219: printf("\tclc_hdr x%x\n", clcp->clc_hdr); ! 220: } ! 221: ENDDEBUG ! 222: if ((clcp != NULL) && /* cache exists */ ! 223: (isop->isop_options == clcp->clc_options) && /* same options */ ! 224: (iso_addrmatch1(dst, &clcp->clc_dst)) && /* dst still same */ ! 225: (isop->isop_route.ro_rt != NULL) && /* route exists */ ! 226: (isop->isop_route.ro_rt == clcp->clc_rt) && /* and is cached */ ! 227: (isop->isop_route.ro_rt->rt_flags & RTF_UP) && /* route still up */ ! 228: (flags == clcp->clc_flags) && /* same flags */ ! 229: (clcp->clc_hdr != NULL)) { /* hdr mbuf exists */ ! 230: /* ! 231: * The cache is valid ! 232: */ ! 233: ! 234: IFDEBUG(D_OUTPUT) ! 235: printf("clnp_output: using cache\n"); ! 236: ENDDEBUG ! 237: ! 238: m = m_copy(clcp->clc_hdr, 0, (int)M_COPYALL); ! 239: if (m == NULL) { ! 240: /* ! 241: * No buffers left to copy cached packet header. Use ! 242: * the cached packet header this time, and ! 243: * mark the hdr as vacant ! 244: */ ! 245: m = clcp->clc_hdr; ! 246: clcp->clc_hdr = NULL; ! 247: } ! 248: m->m_next = m0; /* ASSUMES pkt hdr is 1 mbuf long */ ! 249: clnp = mtod(m, struct clnp_fixed *); ! 250: } else { ! 251: struct clnp_optidx *oidx = NULL; /* index to clnp options */ ! 252: ! 253: /* ! 254: * The cache is not valid. Allocate an mbuf (if necessary) ! 255: * to hold cached info. If one is not available, then ! 256: * don't bother with the cache ! 257: */ ! 258: INCSTAT(cns_cachemiss); ! 259: if (flags & CLNP_NOCACHE) { ! 260: clcp = &clc; ! 261: } else { ! 262: if (isop->isop_clnpcache == NULL) { ! 263: /* ! 264: * There is no clnpcache. Allocate an mbuf to hold one ! 265: */ ! 266: if ((isop->isop_clnpcache = m_get(M_DONTWAIT, MT_HEADER)) ! 267: == NULL) { ! 268: /* ! 269: * No mbufs available. Pretend that we don't want ! 270: * caching this time. ! 271: */ ! 272: IFDEBUG(D_OUTPUT) ! 273: printf("clnp_output: no mbufs to allocate to cache\n"); ! 274: ENDDEBUG ! 275: flags |= CLNP_NOCACHE; ! 276: clcp = &clc; ! 277: } else { ! 278: clcp = mtod(isop->isop_clnpcache, struct clnp_cache *); ! 279: } ! 280: } else { ! 281: /* ! 282: * A clnpcache mbuf exists. If the clc_hdr is not null, ! 283: * we must free it, as a new one is about to be created. ! 284: */ ! 285: clcp = mtod(isop->isop_clnpcache, struct clnp_cache *); ! 286: if (clcp->clc_hdr != NULL) { ! 287: /* ! 288: * The clc_hdr is not null but a clnpcache mbuf exists. ! 289: * This means that there was a cache, but the existing ! 290: * copy of the hdr is no longer valid. Free it now ! 291: * before we lose the pointer to it. ! 292: */ ! 293: IFDEBUG(D_OUTPUT) ! 294: printf("clnp_output: freeing old clc_hdr 0x%x\n", ! 295: clcp->clc_hdr); ! 296: ENDDEBUG ! 297: m_free(clcp->clc_hdr); ! 298: IFDEBUG(D_OUTPUT) ! 299: printf("clnp_output: freed old clc_hdr (done)\n"); ! 300: ENDDEBUG ! 301: } ! 302: } ! 303: } ! 304: IFDEBUG(D_OUTPUT) ! 305: printf("clnp_output: NEW clcp x%x\n",clcp); ! 306: ENDDEBUG ! 307: bzero((caddr_t)clcp, sizeof(struct clnp_cache)); ! 308: ! 309: if (isop->isop_optindex) ! 310: oidx = mtod(isop->isop_optindex, struct clnp_optidx *); ! 311: ! 312: /* ! 313: * Don't allow packets with security, quality of service, ! 314: * priority, or error report options to be sent. ! 315: */ ! 316: if ((isop->isop_options) && (oidx)) { ! 317: if ((oidx->cni_securep) || ! 318: (oidx->cni_priorp) || ! 319: (oidx->cni_qos_formatp) || ! 320: (oidx->cni_er_reason != ER_INVALREAS)) { ! 321: IFDEBUG(D_OUTPUT) ! 322: printf("clnp_output: pkt dropped - option unsupported\n"); ! 323: ENDDEBUG ! 324: m_freem(m0); ! 325: return(EINVAL); ! 326: } ! 327: } ! 328: ! 329: /* ! 330: * Don't allow any invalid flags to be set ! 331: */ ! 332: if ((flags & (CLNP_VFLAGS)) != flags) { ! 333: IFDEBUG(D_OUTPUT) ! 334: printf("clnp_output: packet dropped - flags unsupported\n"); ! 335: ENDDEBUG ! 336: INCSTAT(cns_odropped); ! 337: m_freem(m0); ! 338: return(EINVAL); ! 339: } ! 340: ! 341: /* ! 342: * Don't allow funny lengths on dst; src may be zero in which ! 343: * case we insert the source address based upon the interface ! 344: */ ! 345: if ((src->isoa_len > sizeof(struct iso_addr)) || ! 346: (dst->isoa_len == 0) || ! 347: (dst->isoa_len > sizeof(struct iso_addr))) { ! 348: m_freem(m0); ! 349: INCSTAT(cns_odropped); ! 350: return(ENAMETOOLONG); ! 351: } ! 352: ! 353: /* ! 354: * Grab mbuf to contain header ! 355: */ ! 356: MGETHDR(m, M_DONTWAIT, MT_HEADER); ! 357: if (m == 0) { ! 358: m_freem(m0); ! 359: INCSTAT(cns_odropped); ! 360: return(ENOBUFS); ! 361: } ! 362: INCSTAT(cns_sent); ! 363: m->m_next = m0; ! 364: clnp = mtod(m, struct clnp_fixed *); ! 365: clcp->clc_segoff = 0; ! 366: ! 367: /* ! 368: * Fill in all of fixed hdr except lengths and checksum ! 369: */ ! 370: if (flags & CLNP_SEND_RAW) { ! 371: *clnp = raw_template; ! 372: } else if (flags & CLNP_ECHO) { ! 373: *clnp = echo_template; ! 374: } else { ! 375: *clnp = dt_template; ! 376: } ! 377: if (flags & CLNP_NO_SEG) ! 378: clnp->cnf_type &= ~CNF_SEG_OK; ! 379: if (flags & CLNP_NO_ER) ! 380: clnp->cnf_type &= ~CNF_ERR_OK; ! 381: ! 382: /* ! 383: * Route packet; special case for source rt ! 384: */ ! 385: if ((isop->isop_options) && CLNPSRCRT_VALID(oidx)) { ! 386: IFDEBUG(D_OUTPUT) ! 387: printf("clnp_output: calling clnp_srcroute\n"); ! 388: ENDDEBUG ! 389: error = clnp_srcroute(isop->isop_options, oidx, &isop->isop_route, ! 390: &clcp->clc_firsthop, &clcp->clc_ifa, dst); ! 391: } else { ! 392: IFDEBUG(D_OUTPUT) ! 393: ENDDEBUG ! 394: error = clnp_route(dst, &isop->isop_route, flags, ! 395: &clcp->clc_firsthop, &clcp->clc_ifa); ! 396: } ! 397: if (error || (clcp->clc_ifa == 0)) { ! 398: IFDEBUG(D_OUTPUT) ! 399: printf("clnp_output: route failed, errno %d\n", error); ! 400: printf("@clcp:\n"); ! 401: dump_buf(clcp, sizeof (struct clnp_cache)); ! 402: ENDDEBUG ! 403: goto bad; ! 404: } ! 405: clcp->clc_rt = isop->isop_route.ro_rt; /* XXX */ ! 406: clcp->clc_ifp = clcp->clc_ifa->ia_ifp; /* XXX */ ! 407: ! 408: IFDEBUG(D_OUTPUT) ! 409: printf("clnp_output: packet routed to %s\n", ! 410: clnp_iso_addrp( ! 411: &((struct sockaddr_iso *)clcp->clc_firsthop)->siso_addr)); ! 412: ENDDEBUG ! 413: ! 414: /* ! 415: * If src address is not yet specified, use address of ! 416: * interface. NOTE: this will now update the laddr field in ! 417: * the isopcb. Is this desirable? RAH? ! 418: */ ! 419: if (src->isoa_len == 0) { ! 420: src = &(clcp->clc_ifa->ia_addr.siso_addr); ! 421: IFDEBUG(D_OUTPUT) ! 422: printf("clnp_output: new src %s\n", clnp_iso_addrp(src)); ! 423: ENDDEBUG ! 424: } ! 425: ! 426: /* ! 427: * Insert the source and destination address, ! 428: */ ! 429: hoff = (caddr_t)clnp + sizeof(struct clnp_fixed); ! 430: CLNP_INSERT_ADDR(hoff, *dst); ! 431: CLNP_INSERT_ADDR(hoff, *src); ! 432: ! 433: /* ! 434: * Leave room for the segment part, if segmenting is selected ! 435: */ ! 436: if (clnp->cnf_type & CNF_SEG_OK) { ! 437: clcp->clc_segoff = hoff - (caddr_t)clnp; ! 438: hoff += sizeof(struct clnp_segment); ! 439: } ! 440: ! 441: clnp->cnf_hdr_len = m->m_len = (u_char)(hoff - (caddr_t)clnp); ! 442: hdrlen = clnp->cnf_hdr_len; ! 443: ! 444: #ifdef DECBIT ! 445: /* ! 446: * Add the globally unique QOS (with room for congestion experienced ! 447: * bit). I can safely assume that this option is not in the options ! 448: * mbuf below because I checked that the option was not specified ! 449: * previously ! 450: */ ! 451: if ((m->m_len + sizeof(qos_option)) < MLEN) { ! 452: bcopy((caddr_t)qos_option, hoff, sizeof(qos_option)); ! 453: clnp->cnf_hdr_len += sizeof(qos_option); ! 454: hdrlen += sizeof(qos_option); ! 455: m->m_len += sizeof(qos_option); ! 456: } ! 457: #endif DECBIT ! 458: ! 459: /* ! 460: * If an options mbuf is present, concatenate a copy to the hdr mbuf. ! 461: */ ! 462: if (isop->isop_options) { ! 463: struct mbuf *opt_copy = m_copy(isop->isop_options, 0, (int)M_COPYALL); ! 464: if (opt_copy == NULL) { ! 465: error = ENOBUFS; ! 466: goto bad; ! 467: } ! 468: /* Link in place */ ! 469: opt_copy->m_next = m->m_next; ! 470: m->m_next = opt_copy; ! 471: ! 472: /* update size of header */ ! 473: clnp->cnf_hdr_len += opt_copy->m_len; ! 474: hdrlen += opt_copy->m_len; ! 475: } ! 476: ! 477: if (hdrlen > CLNP_HDR_MAX) { ! 478: error = EMSGSIZE; ! 479: goto bad; ! 480: } ! 481: ! 482: /* ! 483: * Now set up the cache entry in the pcb ! 484: */ ! 485: if ((flags & CLNP_NOCACHE) == 0) { ! 486: if (clcp->clc_hdr = m_copy(m, 0, (int)clnp->cnf_hdr_len)) { ! 487: clcp->clc_dst = *dst; ! 488: clcp->clc_flags = flags; ! 489: clcp->clc_options = isop->isop_options; ! 490: } ! 491: } ! 492: } ! 493: /* ! 494: * If small enough for interface, send directly ! 495: * Fill in segmentation part of hdr if using the full protocol ! 496: */ ! 497: total_len = clnp->cnf_hdr_len + datalen; ! 498: if (clnp->cnf_type & CNF_SEG_OK) { ! 499: struct clnp_segment seg_part; /* segment part of hdr */ ! 500: seg_part.cng_id = htons(clnp_id++); ! 501: seg_part.cng_off = htons(0); ! 502: seg_part.cng_tot_len = htons(total_len); ! 503: (void) bcopy((caddr_t)&seg_part, (caddr_t) clnp + clcp->clc_segoff, ! 504: sizeof(seg_part)); ! 505: } ! 506: if (total_len <= SN_MTU(clcp->clc_ifp, clcp->clc_rt)) { ! 507: HTOC(clnp->cnf_seglen_msb, clnp->cnf_seglen_lsb, total_len); ! 508: m->m_pkthdr.len = total_len; ! 509: /* ! 510: * Compute clnp checksum (on header only) ! 511: */ ! 512: if (flags & CLNP_NO_CKSUM) { ! 513: HTOC(clnp->cnf_cksum_msb, clnp->cnf_cksum_lsb, 0); ! 514: } else { ! 515: iso_gen_csum(m, CLNP_CKSUM_OFF, (int)clnp->cnf_hdr_len); ! 516: } ! 517: ! 518: IFDEBUG(D_DUMPOUT) ! 519: struct mbuf *mdump = m; ! 520: printf("clnp_output: sending dg:\n"); ! 521: while (mdump != NULL) { ! 522: dump_buf(mtod(mdump, caddr_t), mdump->m_len); ! 523: mdump = mdump->m_next; ! 524: } ! 525: ENDDEBUG ! 526: ! 527: error = SN_OUTPUT(clcp, m); ! 528: goto done; ! 529: } else { ! 530: /* ! 531: * Too large for interface; fragment if possible. ! 532: */ ! 533: error = clnp_fragment(clcp->clc_ifp, m, clcp->clc_firsthop, ! 534: total_len, clcp->clc_segoff, flags, clcp->clc_rt); ! 535: goto done; ! 536: } ! 537: bad: ! 538: m_freem(m); ! 539: done: ! 540: if (error) { ! 541: clnp_stat.cns_sent--; ! 542: clnp_stat.cns_odropped++; ! 543: } ! 544: return (error); ! 545: } ! 546: ! 547: int clnp_ctloutput() ! 548: { ! 549: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.