![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to clnp_subr.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / bsd / netiso|
Return to clnp_subr.c CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / netiso |
1.1 ! root 1: /* ! 2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved. ! 3: * ! 4: * @APPLE_LICENSE_HEADER_START@ ! 5: * ! 6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights ! 7: * Reserved. This file contains Original Code and/or Modifications of ! 8: * Original Code as defined in and that are subject to the Apple Public ! 9: * Source License Version 1.1 (the "License"). You may not use this file ! 10: * except in compliance with the License. Please obtain a copy of the ! 11: * License at http://www.apple.com/publicsource and read it before using ! 12: * this file. ! 13: * ! 14: * The Original Code and all software distributed under the License are ! 15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER ! 16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, ! 17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, ! 18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the ! 19: * License for the specific language governing rights and limitations ! 20: * under the License. ! 21: * ! 22: * @APPLE_LICENSE_HEADER_END@ ! 23: */ ! 24: ! 25: /*- ! 26: * Copyright (c) 1991, 1993 ! 27: * The Regents of the University of California. All rights reserved. ! 28: * ! 29: * Redistribution and use in source and binary forms, with or without ! 30: * modification, are permitted provided that the following conditions ! 31: * are met: ! 32: * 1. Redistributions of source code must retain the above copyright ! 33: * notice, this list of conditions and the following disclaimer. ! 34: * 2. Redistributions in binary form must reproduce the above copyright ! 35: * notice, this list of conditions and the following disclaimer in the ! 36: * documentation and/or other materials provided with the distribution. ! 37: * 3. All advertising materials mentioning features or use of this software ! 38: * must display the following acknowledgement: ! 39: * This product includes software developed by the University of ! 40: * California, Berkeley and its contributors. ! 41: * 4. Neither the name of the University nor the names of its contributors ! 42: * may be used to endorse or promote products derived from this software ! 43: * without specific prior written permission. ! 44: * ! 45: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ! 46: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ! 47: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ! 48: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE ! 49: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ! 50: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ! 51: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ! 52: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ! 53: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ! 54: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ! 55: * SUCH DAMAGE. ! 56: * ! 57: * @(#)clnp_subr.c 8.1 (Berkeley) 6/10/93 ! 58: */ ! 59: ! 60: /*********************************************************** ! 61: Copyright IBM Corporation 1987 ! 62: ! 63: All Rights Reserved ! 64: ! 65: Permission to use, copy, modify, and distribute this software and its ! 66: documentation for any purpose and without fee is hereby granted, ! 67: provided that the above copyright notice appear in all copies and that ! 68: both that copyright notice and this permission notice appear in ! 69: supporting documentation, and that the name of IBM not be ! 70: used in advertising or publicity pertaining to distribution of the ! 71: software without specific, written prior permission. ! 72: ! 73: IBM DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ! 74: ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL ! 75: IBM BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ! 76: ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, ! 77: WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ! 78: ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS ! 79: SOFTWARE. ! 80: ! 81: ******************************************************************/ ! 82: ! 83: /* ! 84: * ARGO Project, Computer Sciences Dept., University of Wisconsin - Madison ! 85: */ ! 86: ! 87: #if ISO ! 88: ! 89: #include <sys/param.h> ! 90: #include <sys/mbuf.h> ! 91: #include <sys/domain.h> ! 92: #include <sys/protosw.h> ! 93: #include <sys/socket.h> ! 94: #include <sys/socketvar.h> ! 95: #include <sys/errno.h> ! 96: #include <sys/time.h> ! 97: ! 98: #include <net/if.h> ! 99: #include <net/route.h> ! 100: #include <net/if_dl.h> ! 101: ! 102: #include <netiso/iso.h> ! 103: #include <netiso/iso_var.h> ! 104: #include <netiso/iso_pcb.h> ! 105: #include <netiso/iso_snpac.h> ! 106: #include <netiso/clnp.h> ! 107: #include <netiso/clnp_stat.h> ! 108: #include <netiso/argo_debug.h> ! 109: ! 110: /* ! 111: * FUNCTION: clnp_data_ck ! 112: * ! 113: * PURPOSE: Check that the amount of data in the mbuf chain is ! 114: * at least as much as the clnp header would have us ! 115: * expect. Trim mbufs if longer than expected, drop ! 116: * packet if shorter than expected. ! 117: * ! 118: * RETURNS: success - ptr to mbuf chain ! 119: * failure - 0 ! 120: * ! 121: * SIDE EFFECTS: ! 122: * ! 123: * NOTES: ! 124: */ ! 125: struct mbuf * ! 126: clnp_data_ck(m, length) ! 127: register struct mbuf *m; /* ptr to mbuf chain containing hdr & data */ ! 128: int length; /* length (in bytes) of packet */ ! 129: { ! 130: register int len; /* length of data */ ! 131: register struct mbuf *mhead; /* ptr to head of chain */ ! 132: ! 133: len = -length; ! 134: mhead = m; ! 135: for (;;) { ! 136: len += m->m_len; ! 137: if (m->m_next == 0) ! 138: break; ! 139: m = m->m_next; ! 140: } ! 141: if (len != 0) { ! 142: if (len < 0) { ! 143: INCSTAT(cns_toosmall); ! 144: clnp_discard(mhead, GEN_INCOMPLETE); ! 145: return 0; ! 146: } ! 147: if (len <= m->m_len) ! 148: m->m_len -= len; ! 149: else ! 150: m_adj(mhead, -len); ! 151: } ! 152: return mhead; ! 153: } ! 154: ! 155: #ifdef notdef ! 156: /* ! 157: * FUNCTION: clnp_extract_addr ! 158: * ! 159: * PURPOSE: Extract the source and destination address from the ! 160: * supplied buffer. Place them in the supplied address buffers. ! 161: * If insufficient data is supplied, then fail. ! 162: * ! 163: * RETURNS: success - Address of first byte in the packet past ! 164: * the address part. ! 165: * failure - 0 ! 166: * ! 167: * SIDE EFFECTS: ! 168: * ! 169: * NOTES: ! 170: */ ! 171: caddr_t ! 172: clnp_extract_addr(bufp, buflen, srcp, destp) ! 173: caddr_t bufp; /* ptr to buffer containing addresses */ ! 174: int buflen; /* length of buffer */ ! 175: register struct iso_addr *srcp; /* ptr to source address buffer */ ! 176: register struct iso_addr *destp; /* ptr to destination address buffer */ ! 177: { ! 178: int len; /* argument to bcopy */ ! 179: ! 180: /* ! 181: * check that we have enough data. Plus1 is for length octet ! 182: */ ! 183: if ((u_char)*bufp + 1 > buflen) { ! 184: return((caddr_t)0); ! 185: } ! 186: len = destp->isoa_len = (u_char)*bufp++; ! 187: (void) bcopy(bufp, (caddr_t)destp, len); ! 188: buflen -= len; ! 189: bufp += len; ! 190: ! 191: /* ! 192: * check that we have enough data. Plus1 is for length octet ! 193: */ ! 194: if ((u_char)*bufp + 1 > buflen) { ! 195: return((caddr_t)0); ! 196: } ! 197: len = srcp->isoa_len = (u_char)* bufp++; ! 198: (void) bcopy(bufp, (caddr_t)srcp, len); ! 199: bufp += len; ! 200: ! 201: /* ! 202: * Insure that the addresses make sense ! 203: */ ! 204: if (iso_ck_addr(srcp) && iso_ck_addr(destp)) ! 205: return bufp; ! 206: else ! 207: return (caddr_t) 0; ! 208: } ! 209: #endif /* notdef */ ! 210: ! 211: /* ! 212: * FUNCTION: clnp_ours ! 213: * ! 214: * PURPOSE: Decide whether the supplied packet is destined for ! 215: * us, or that it should be forwarded on. ! 216: * ! 217: * RETURNS: packet is for us - 1 ! 218: * packet is not for us - 0 ! 219: * ! 220: * SIDE EFFECTS: ! 221: * ! 222: * NOTES: ! 223: */ ! 224: clnp_ours(dst) ! 225: register struct iso_addr *dst; /* ptr to destination address */ ! 226: { ! 227: register struct iso_ifaddr *ia; /* scan through interface addresses */ ! 228: ! 229: for (ia = iso_ifaddr; ia; ia = ia->ia_next) { ! 230: IFDEBUG(D_ROUTE) ! 231: printf("clnp_ours: ia_sis x%x, dst x%x\n", &ia->ia_addr, ! 232: dst); ! 233: ENDDEBUG ! 234: /* ! 235: * XXX Warning: ! 236: * We are overloading siso_tlen in the if's address, as an nsel length. ! 237: */ ! 238: if (dst->isoa_len == ia->ia_addr.siso_nlen && ! 239: bcmp((caddr_t)ia->ia_addr.siso_addr.isoa_genaddr, ! 240: (caddr_t)dst->isoa_genaddr, ! 241: ia->ia_addr.siso_nlen - ia->ia_addr.siso_tlen) == 0) ! 242: return 1; ! 243: } ! 244: return 0; ! 245: } ! 246: ! 247: /* Dec bit set if ifp qlen is greater than congest_threshold */ ! 248: int congest_threshold = 0; ! 249: ! 250: /* ! 251: * FUNCTION: clnp_forward ! 252: * ! 253: * PURPOSE: Forward the datagram passed ! 254: * clnpintr guarantees that the header will be ! 255: * contigious (a cluster mbuf will be used if necessary). ! 256: * ! 257: * If oidx is NULL, no options are present. ! 258: * ! 259: * RETURNS: nothing ! 260: * ! 261: * SIDE EFFECTS: ! 262: * ! 263: * NOTES: ! 264: */ ! 265: clnp_forward(m, len, dst, oidx, seg_off, inbound_shp) ! 266: struct mbuf *m; /* pkt to forward */ ! 267: int len; /* length of pkt */ ! 268: struct iso_addr *dst; /* destination address */ ! 269: struct clnp_optidx *oidx; /* option index */ ! 270: int seg_off;/* offset of segmentation part */ ! 271: struct snpa_hdr *inbound_shp; /* subnetwork header of inbound packet */ ! 272: { ! 273: struct clnp_fixed *clnp; /* ptr to fixed part of header */ ! 274: int error; /* return value of route function */ ! 275: struct sockaddr *next_hop; /* next hop for dgram */ ! 276: struct ifnet *ifp; /* ptr to outgoing interface */ ! 277: struct iso_ifaddr *ia = 0;/* ptr to iso name for ifp */ ! 278: struct route_iso route; /* filled in by clnp_route */ ! 279: extern int iso_systype; ! 280: ! 281: clnp = mtod(m, struct clnp_fixed *); ! 282: bzero((caddr_t)&route, sizeof(route)); /* MUST be done before "bad:" */ ! 283: ! 284: /* ! 285: * Don't forward multicast or broadcast packets ! 286: */ ! 287: if ((inbound_shp) && (IS_MULTICAST(inbound_shp->snh_dhost))) { ! 288: IFDEBUG(D_FORWARD) ! 289: printf("clnp_forward: dropping multicast packet\n"); ! 290: ENDDEBUG ! 291: clnp->cnf_type &= ~CNF_ERR_OK; /* so we don't generate an ER */ ! 292: clnp_discard(m, 0); ! 293: INCSTAT(cns_cantforward); ! 294: goto done; ! 295: } ! 296: ! 297: IFDEBUG(D_FORWARD) ! 298: printf("clnp_forward: %d bytes, to %s, options x%x\n", len, ! 299: clnp_iso_addrp(dst), oidx); ! 300: ENDDEBUG ! 301: ! 302: /* ! 303: * Decrement ttl, and if zero drop datagram ! 304: * Can't compare ttl as less than zero 'cause its a unsigned ! 305: */ ! 306: if ((clnp->cnf_ttl == 0) || (--clnp->cnf_ttl == 0)) { ! 307: IFDEBUG(D_FORWARD) ! 308: printf("clnp_forward: discarding datagram because ttl is zero\n"); ! 309: ENDDEBUG ! 310: INCSTAT(cns_ttlexpired); ! 311: clnp_discard(m, TTL_EXPTRANSIT); ! 312: goto done; ! 313: } ! 314: /* ! 315: * Route packet; special case for source rt ! 316: */ ! 317: if CLNPSRCRT_VALID(oidx) { ! 318: /* ! 319: * Update src route first ! 320: */ ! 321: clnp_update_srcrt(m, oidx); ! 322: error = clnp_srcroute(m, oidx, &route, &next_hop, &ia, dst); ! 323: } else { ! 324: error = clnp_route(dst, &route, 0, &next_hop, &ia); ! 325: } ! 326: if (error || ia == 0) { ! 327: IFDEBUG(D_FORWARD) ! 328: printf("clnp_forward: can't route packet (errno %d)\n", error); ! 329: ENDDEBUG ! 330: clnp_discard(m, ADDR_DESTUNREACH); ! 331: INCSTAT(cns_cantforward); ! 332: goto done; ! 333: } ! 334: ifp = ia->ia_ifp; ! 335: ! 336: IFDEBUG(D_FORWARD) ! 337: printf("clnp_forward: packet routed to %s\n", ! 338: clnp_iso_addrp(&((struct sockaddr_iso *)next_hop)->siso_addr)); ! 339: ENDDEBUG ! 340: ! 341: INCSTAT(cns_forward); ! 342: ! 343: /* ! 344: * If we are an intermediate system and ! 345: * we are routing outbound on the same ifp that the packet ! 346: * arrived upon, and we know the next hop snpa, ! 347: * then generate a redirect request ! 348: */ ! 349: if ((iso_systype & SNPA_IS) && (inbound_shp) && ! 350: (ifp == inbound_shp->snh_ifp)) ! 351: esis_rdoutput(inbound_shp, m, oidx, dst, route.ro_rt); ! 352: /* ! 353: * If options are present, update them ! 354: */ ! 355: if (oidx) { ! 356: struct iso_addr *mysrc = &ia->ia_addr.siso_addr; ! 357: if (mysrc == NULL) { ! 358: clnp_discard(m, ADDR_DESTUNREACH); ! 359: INCSTAT(cns_cantforward); ! 360: clnp_stat.cns_forward--; ! 361: goto done; ! 362: } else { ! 363: (void) clnp_dooptions(m, oidx, ifp, mysrc); ! 364: } ! 365: } ! 366: ! 367: #ifdef DECBIT ! 368: if (ifp->if_snd.ifq_len > congest_threshold) { ! 369: /* ! 370: * Congestion! Set the Dec Bit and thank Dave Oran ! 371: */ ! 372: IFDEBUG(D_FORWARD) ! 373: printf("clnp_forward: congestion experienced\n"); ! 374: ENDDEBUG ! 375: if ((oidx) && (oidx->cni_qos_formatp)) { ! 376: caddr_t qosp = CLNP_OFFTOOPT(m, oidx->cni_qos_formatp); ! 377: u_char qos = *qosp; ! 378: IFDEBUG(D_FORWARD) ! 379: printf("clnp_forward: setting congestion bit (qos x%x)\n", qos); ! 380: ENDDEBUG ! 381: if ((qos & CLNPOVAL_GLOBAL) == CLNPOVAL_GLOBAL) { ! 382: qos |= CLNPOVAL_CONGESTED; ! 383: INCSTAT(cns_congest_set); ! 384: *qosp = qos; ! 385: } ! 386: } ! 387: } ! 388: #endif /* DECBIT */ ! 389: ! 390: /* ! 391: * Dispatch the datagram if it is small enough, otherwise fragment ! 392: */ ! 393: if (len <= SN_MTU(ifp, route.ro_rt)) { ! 394: iso_gen_csum(m, CLNP_CKSUM_OFF, (int)clnp->cnf_hdr_len); ! 395: (void) (*ifp->if_output)(ifp, m, next_hop, route.ro_rt); ! 396: } else { ! 397: (void) clnp_fragment(ifp, m, next_hop, len, seg_off, /* flags */0, route.ro_rt); ! 398: } ! 399: ! 400: done: ! 401: /* ! 402: * Free route ! 403: */ ! 404: if (route.ro_rt != NULL) { ! 405: RTFREE(route.ro_rt); ! 406: } ! 407: } ! 408: ! 409: #ifdef notdef ! 410: /* ! 411: * FUNCTION: clnp_insert_addr ! 412: * ! 413: * PURPOSE: Insert the address part into a clnp datagram. ! 414: * ! 415: * RETURNS: Address of first byte after address part in datagram. ! 416: * ! 417: * SIDE EFFECTS: ! 418: * ! 419: * NOTES: Assume that there is enough space for the address part. ! 420: */ ! 421: caddr_t ! 422: clnp_insert_addr(bufp, srcp, dstp) ! 423: caddr_t bufp; /* address of where addr part goes */ ! 424: register struct iso_addr *srcp; /* ptr to src addr */ ! 425: register struct iso_addr *dstp; /* ptr to dst addr */ ! 426: { ! 427: *bufp++ = dstp->isoa_len; ! 428: (void) bcopy((caddr_t)dstp, bufp, dstp->isoa_len); ! 429: bufp += dstp->isoa_len; ! 430: ! 431: *bufp++ = srcp->isoa_len; ! 432: (void) bcopy((caddr_t)srcp, bufp, srcp->isoa_len); ! 433: bufp += srcp->isoa_len; ! 434: ! 435: return bufp; ! 436: } ! 437: ! 438: #endif /* notdef */ ! 439: ! 440: /* ! 441: * FUNCTION: clnp_route ! 442: * ! 443: * PURPOSE: Route a clnp datagram to the first hop toward its ! 444: * destination. In many cases, the first hop will be ! 445: * the destination. The address of a route ! 446: * is specified. If a routing entry is present in ! 447: * that route, and it is still up to the same destination, ! 448: * then no further action is necessary. Otherwise, a ! 449: * new routing entry will be allocated. ! 450: * ! 451: * RETURNS: route found - 0 ! 452: * unix error code ! 453: * ! 454: * SIDE EFFECTS: ! 455: * ! 456: * NOTES: It is up to the caller to free the routing entry ! 457: * allocated in route. ! 458: */ ! 459: clnp_route(dst, ro, flags, first_hop, ifa) ! 460: struct iso_addr *dst; /* ptr to datagram destination */ ! 461: register struct route_iso *ro; /* existing route structure */ ! 462: int flags; /* flags for routing */ ! 463: struct sockaddr **first_hop; /* result: fill in with ptr to firsthop */ ! 464: struct iso_ifaddr **ifa; /* result: fill in with ptr to interface */ ! 465: { ! 466: if (flags & SO_DONTROUTE) { ! 467: struct iso_ifaddr *ia; ! 468: ! 469: if (ro->ro_rt) { ! 470: RTFREE(ro->ro_rt); ! 471: ro->ro_rt = 0; ! 472: } ! 473: bzero((caddr_t)&ro->ro_dst, sizeof(ro->ro_dst)); ! 474: bcopy((caddr_t)dst, (caddr_t)&ro->ro_dst.siso_addr, ! 475: 1 + (unsigned)dst->isoa_len); ! 476: ro->ro_dst.siso_family = AF_ISO; ! 477: ro->ro_dst.siso_len = sizeof(ro->ro_dst); ! 478: ia = iso_localifa(&ro->ro_dst); ! 479: if (ia == 0) ! 480: return EADDRNOTAVAIL; ! 481: if (ifa) ! 482: *ifa = ia; ! 483: if (first_hop) ! 484: *first_hop = (struct sockaddr *)&ro->ro_dst; ! 485: return 0; ! 486: } ! 487: /* ! 488: * If there is a cached route, check that it is still up and to ! 489: * the same destination. If not, free it and try again. ! 490: */ ! 491: if (ro->ro_rt && ((ro->ro_rt->rt_flags & RTF_UP) == 0 || ! 492: (Bcmp(ro->ro_dst.siso_data, dst->isoa_genaddr, dst->isoa_len)))) { ! 493: IFDEBUG(D_ROUTE) ! 494: printf("clnp_route: freeing old route: ro->ro_rt 0x%x\n", ! 495: ro->ro_rt); ! 496: printf("clnp_route: old route refcnt: 0x%x\n", ! 497: ro->ro_rt->rt_refcnt); ! 498: ENDDEBUG ! 499: ! 500: /* free old route entry */ ! 501: RTFREE(ro->ro_rt); ! 502: ro->ro_rt = (struct rtentry *)0; ! 503: } else { ! 504: IFDEBUG(D_ROUTE) ! 505: printf("clnp_route: OK route exists\n"); ! 506: ENDDEBUG ! 507: } ! 508: ! 509: if (ro->ro_rt == 0) { ! 510: /* set up new route structure */ ! 511: bzero((caddr_t)&ro->ro_dst, sizeof(ro->ro_dst)); ! 512: ro->ro_dst.siso_len = sizeof(ro->ro_dst); ! 513: ro->ro_dst.siso_family = AF_ISO; ! 514: Bcopy(dst, &ro->ro_dst.siso_addr, 1 + dst->isoa_len); ! 515: /* allocate new route */ ! 516: IFDEBUG(D_ROUTE) ! 517: printf("clnp_route: allocating new route to %s\n", ! 518: clnp_iso_addrp(dst)); ! 519: ENDDEBUG ! 520: rtalloc((struct route *)ro); ! 521: } ! 522: if (ro->ro_rt == 0) ! 523: return(ENETUNREACH); /* rtalloc failed */ ! 524: ro->ro_rt->rt_use++; ! 525: if (ifa) ! 526: if ((*ifa = (struct iso_ifaddr *)ro->ro_rt->rt_ifa) == 0) ! 527: panic("clnp_route"); ! 528: if (first_hop) { ! 529: if (ro->ro_rt->rt_flags & RTF_GATEWAY) ! 530: *first_hop = ro->ro_rt->rt_gateway; ! 531: else ! 532: *first_hop = (struct sockaddr *)&ro->ro_dst; ! 533: } ! 534: return(0); ! 535: } ! 536: ! 537: /* ! 538: * FUNCTION: clnp_srcroute ! 539: * ! 540: * PURPOSE: Source route the datagram. If complete source ! 541: * routing is specified but not possible, then ! 542: * return an error. If src routing is terminated, then ! 543: * try routing on destination. ! 544: * Usage of first_hop, ! 545: * ifp, and error return is identical to clnp_route. ! 546: * ! 547: * RETURNS: 0 or unix error code ! 548: * ! 549: * SIDE EFFECTS: ! 550: * ! 551: * NOTES: Remember that option index pointers are really ! 552: * offsets from the beginning of the mbuf. ! 553: */ ! 554: clnp_srcroute(options, oidx, ro, first_hop, ifa, final_dst) ! 555: struct mbuf *options; /* ptr to options */ ! 556: struct clnp_optidx *oidx; /* index to options */ ! 557: struct route_iso *ro; /* route structure */ ! 558: struct sockaddr **first_hop; /* RETURN: fill in with ptr to firsthop */ ! 559: struct iso_ifaddr **ifa; /* RETURN: fill in with ptr to interface */ ! 560: struct iso_addr *final_dst; /* final destination */ ! 561: { ! 562: struct iso_addr dst; /* first hop specified by src rt */ ! 563: int error = 0; /* return code */ ! 564: ! 565: /* ! 566: * Check if we have run out of routes ! 567: * If so, then try to route on destination. ! 568: */ ! 569: if CLNPSRCRT_TERM(oidx, options) { ! 570: dst.isoa_len = final_dst->isoa_len; ! 571: bcopy(final_dst->isoa_genaddr, dst.isoa_genaddr, dst.isoa_len); ! 572: } else { ! 573: /* ! 574: * setup dst based on src rt specified ! 575: */ ! 576: dst.isoa_len = CLNPSRCRT_CLEN(oidx, options); ! 577: bcopy(CLNPSRCRT_CADDR(oidx, options), dst.isoa_genaddr, dst.isoa_len); ! 578: } ! 579: ! 580: /* ! 581: * try to route it ! 582: */ ! 583: error = clnp_route(&dst, ro, 0, first_hop, ifa); ! 584: if (error != 0) ! 585: return error; ! 586: ! 587: /* ! 588: * If complete src rt, first hop must be equal to dst ! 589: */ ! 590: if ((CLNPSRCRT_TYPE(oidx, options) == CLNPOVAL_COMPRT) && ! 591: (!iso_addrmatch1(&(*(struct sockaddr_iso **)first_hop)->siso_addr,&dst))){ ! 592: IFDEBUG(D_OPTIONS) ! 593: printf("clnp_srcroute: complete src route failed\n"); ! 594: ENDDEBUG ! 595: return EHOSTUNREACH; /* RAH? would like ESRCRTFAILED */ ! 596: } ! 597: ! 598: return error; ! 599: } ! 600: ! 601: /* ! 602: * FUNCTION: clnp_echoreply ! 603: * ! 604: * PURPOSE: generate an echo reply packet and transmit ! 605: * ! 606: * RETURNS: result of clnp_output ! 607: * ! 608: * SIDE EFFECTS: ! 609: */ ! 610: clnp_echoreply(ec_m, ec_len, ec_src, ec_dst, ec_oidxp) ! 611: struct mbuf *ec_m; /* echo request */ ! 612: int ec_len; /* length of ec */ ! 613: struct sockaddr_iso *ec_src; /* src of ec */ ! 614: struct sockaddr_iso *ec_dst; /* destination of ec (i.e., us) */ ! 615: struct clnp_optidx *ec_oidxp; /* options index to ec packet */ ! 616: { ! 617: struct isopcb isopcb; ! 618: int flags = CLNP_NOCACHE|CLNP_ECHOR; ! 619: int ret; ! 620: ! 621: /* fill in fake isopcb to pass to output function */ ! 622: bzero(&isopcb, sizeof(isopcb)); ! 623: isopcb.isop_laddr = ec_dst; ! 624: isopcb.isop_faddr = ec_src; ! 625: ! 626: /* forget copying the options for now. If implemented, need only ! 627: * copy record route option, but it must be reset to zero length */ ! 628: ! 629: ret = clnp_output(ec_m, &isopcb, ec_len, flags); ! 630: ! 631: IFDEBUG(D_OUTPUT) ! 632: printf("clnp_echoreply: output returns %d\n", ret); ! 633: ENDDEBUG ! 634: return ret; ! 635: } ! 636: ! 637: /* ! 638: * FUNCTION: clnp_badmtu ! 639: * ! 640: * PURPOSE: print notice of route with mtu not initialized. ! 641: * ! 642: * RETURNS: mtu of ifp. ! 643: * ! 644: * SIDE EFFECTS: prints notice, slows down system. ! 645: */ ! 646: clnp_badmtu(ifp, rt, line, file) ! 647: struct ifnet *ifp; /* outgoing interface */ ! 648: struct rtentry *rt; /* dst route */ ! 649: int line; /* where the dirty deed occured */ ! 650: char *file; /* where the dirty deed occured */ ! 651: { ! 652: printf("sending on route 0x%x with no mtu, line %d of file %s\n", ! 653: rt, line, file); ! 654: #ifdef ARGO_DEBUG ! 655: printf("route dst is "); ! 656: dump_isoaddr(rt_key(rt)); ! 657: #endif ! 658: return ifp->if_mtu; ! 659: } ! 660: ! 661: /* ! 662: * FUNCTION: clnp_ypocb - backwards bcopy ! 663: * ! 664: * PURPOSE: bcopy starting at end of src rather than beginning. ! 665: * ! 666: * RETURNS: none ! 667: * ! 668: * SIDE EFFECTS: ! 669: * ! 670: * NOTES: No attempt has been made to make this efficient ! 671: */ ! 672: clnp_ypocb(from, to, len) ! 673: caddr_t from; /* src buffer */ ! 674: caddr_t to; /* dst buffer */ ! 675: u_int len; /* number of bytes */ ! 676: { ! 677: while (len--) ! 678: *(to + len) = *(from + len); ! 679: } ! 680: #endif /* ISO */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.