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