![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to iso.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 iso.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: * @(#)iso.c 8.2 (Berkeley) 11/15/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: * iso.c: miscellaneous routines to support the iso address family ! 85: */ ! 86: ! 87: #include <sys/param.h> ! 88: #include <sys/systm.h> ! 89: #include <sys/ioctl.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/malloc.h> ! 97: ! 98: #include <net/if.h> ! 99: #include <net/route.h> ! 100: ! 101: #include <netiso/iso.h> ! 102: #include <netiso/iso_var.h> ! 103: #include <netiso/iso_snpac.h> ! 104: #include <netiso/iso_pcb.h> ! 105: #include <netiso/clnp.h> ! 106: #include <netiso/argo_debug.h> ! 107: #if TUBA ! 108: #include <netiso/tuba_table.h> ! 109: #endif ! 110: ! 111: #if ISO ! 112: ! 113: int iso_interfaces = 0; /* number of external interfaces */ ! 114: extern struct ifnet loif; /* loopback interface */ ! 115: int ether_output(); ! 116: void llc_rtrequest(); ! 117: ! 118: /* ! 119: * FUNCTION: iso_addrmatch1 ! 120: * ! 121: * PURPOSE: decide if the two iso_addrs passed are equal ! 122: * ! 123: * RETURNS: true if the addrs match, false if they do not ! 124: * ! 125: * SIDE EFFECTS: ! 126: * ! 127: * NOTES: ! 128: */ ! 129: iso_addrmatch1(isoaa, isoab) ! 130: register struct iso_addr *isoaa, *isoab; /* addresses to check */ ! 131: { ! 132: u_int compare_len; ! 133: ! 134: IFDEBUG(D_ROUTE) ! 135: printf("iso_addrmatch1: comparing lengths: %d to %d\n", isoaa->isoa_len, ! 136: isoab->isoa_len); ! 137: printf("a:\n"); ! 138: dump_buf(isoaa->isoa_genaddr, isoaa->isoa_len); ! 139: printf("b:\n"); ! 140: dump_buf(isoab->isoa_genaddr, isoab->isoa_len); ! 141: ENDDEBUG ! 142: ! 143: if ((compare_len = isoaa->isoa_len) != isoab->isoa_len) { ! 144: IFDEBUG(D_ROUTE) ! 145: printf("iso_addrmatch1: returning false because of lengths\n"); ! 146: ENDDEBUG ! 147: return 0; ! 148: } ! 149: ! 150: #ifdef notdef ! 151: /* TODO : generalize this to all afis with masks */ ! 152: if( isoaa->isoa_afi == AFI_37 ) { ! 153: /* must not compare 2 least significant digits, or for ! 154: * that matter, the DSP ! 155: */ ! 156: compare_len = ADDR37_IDI_LEN - 1; ! 157: } ! 158: #endif ! 159: ! 160: IFDEBUG(D_ROUTE) ! 161: int i; ! 162: char *a, *b; ! 163: ! 164: a = isoaa->isoa_genaddr; ! 165: b = isoab->isoa_genaddr; ! 166: ! 167: for (i=0; i<compare_len; i++) { ! 168: printf("<%x=%x>", a[i]&0xff, b[i]&0xff); ! 169: if (a[i] != b[i]) { ! 170: printf("\naddrs are not equal at byte %d\n", i); ! 171: return(0); ! 172: } ! 173: } ! 174: printf("\n"); ! 175: printf("addrs are equal\n"); ! 176: return (1); ! 177: ENDDEBUG ! 178: return (!bcmp(isoaa->isoa_genaddr, isoab->isoa_genaddr, compare_len)); ! 179: } ! 180: ! 181: /* ! 182: * FUNCTION: iso_addrmatch ! 183: * ! 184: * PURPOSE: decide if the two sockadrr_isos passed are equal ! 185: * ! 186: * RETURNS: true if the addrs match, false if they do not ! 187: * ! 188: * SIDE EFFECTS: ! 189: * ! 190: * NOTES: ! 191: */ ! 192: iso_addrmatch(sisoa, sisob) ! 193: struct sockaddr_iso *sisoa, *sisob; /* addresses to check */ ! 194: { ! 195: return(iso_addrmatch1(&sisoa->siso_addr, &sisob->siso_addr)); ! 196: } ! 197: #ifdef notdef ! 198: /* ! 199: * FUNCTION: iso_netmatch ! 200: * ! 201: * PURPOSE: similar to iso_addrmatch but takes sockaddr_iso ! 202: * as argument. ! 203: * ! 204: * RETURNS: true if same net, false if not ! 205: * ! 206: * SIDE EFFECTS: ! 207: * ! 208: * NOTES: ! 209: */ ! 210: iso_netmatch(sisoa, sisob) ! 211: struct sockaddr_iso *sisoa, *sisob; ! 212: { ! 213: u_char bufa[sizeof(struct sockaddr_iso)]; ! 214: u_char bufb[sizeof(struct sockaddr_iso)]; ! 215: register int lena, lenb; ! 216: ! 217: lena = iso_netof(&sisoa->siso_addr, bufa); ! 218: lenb = iso_netof(&sisob->siso_addr, bufb); ! 219: ! 220: IFDEBUG(D_ROUTE) ! 221: printf("iso_netmatch: comparing lengths: %d to %d\n", lena, lenb); ! 222: printf("a:\n"); ! 223: dump_buf(bufa, lena); ! 224: printf("b:\n"); ! 225: dump_buf(bufb, lenb); ! 226: ENDDEBUG ! 227: ! 228: return ((lena == lenb) && (!bcmp(bufa, bufb, lena))); ! 229: } ! 230: #endif /* notdef */ ! 231: ! 232: /* ! 233: * FUNCTION: iso_hashchar ! 234: * ! 235: * PURPOSE: Hash all character in the buffer specified into ! 236: * a long. Return the long. ! 237: * ! 238: * RETURNS: The hash value. ! 239: * ! 240: * SIDE EFFECTS: ! 241: * ! 242: * NOTES: The hash is achieved by exclusive ORing 4 byte ! 243: * quantities. ! 244: */ ! 245: u_long ! 246: iso_hashchar(buf, len) ! 247: register caddr_t buf; /* buffer to pack from */ ! 248: register int len; /* length of buffer */ ! 249: { ! 250: register u_long h = 0; ! 251: register int i; ! 252: ! 253: for (i=0; i<len; i+=4) { ! 254: register u_long l = 0; ! 255: ! 256: if ((len - i) < 4) { ! 257: /* buffer not multiple of 4 */ ! 258: switch (len - i) { ! 259: case 3: ! 260: l |= buf[i+2] << 8; ! 261: case 2: ! 262: l |= buf[i+1] << 16; ! 263: case 1: ! 264: l |= buf[i] << 24; ! 265: break; ! 266: default: ! 267: printf("iso_hashchar: unexpected value x%x\n", len - i); ! 268: break; ! 269: } ! 270: } else { ! 271: l |= buf[i] << 24; ! 272: l |= buf[i+1] << 16; ! 273: l |= buf[i+2] << 8; ! 274: l |= buf[i+3]; ! 275: } ! 276: ! 277: h ^= l; ! 278: } ! 279: ! 280: h ^= (u_long) (len % 4); ! 281: ! 282: return(h); ! 283: } ! 284: #ifdef notdef ! 285: /* ! 286: * FUNCTION: iso_hash ! 287: * ! 288: * PURPOSE: Fill in fields of afhash structure based upon addr passed. ! 289: * ! 290: * RETURNS: none ! 291: * ! 292: * SIDE EFFECTS: ! 293: * ! 294: * NOTES: ! 295: */ ! 296: iso_hash(siso, hp) ! 297: struct sockaddr_iso *siso; /* address to perform hash on */ ! 298: struct afhash *hp; /* RETURN: hash info here */ ! 299: { ! 300: u_long buf[sizeof(struct sockaddr_iso)+1/4]; ! 301: register int bufsize; ! 302: ! 303: ! 304: bzero(buf, sizeof(buf)); ! 305: ! 306: bufsize = iso_netof(&siso->siso_addr, buf); ! 307: hp->afh_nethash = iso_hashchar((caddr_t)buf, bufsize); ! 308: ! 309: IFDEBUG(D_ROUTE) ! 310: printf("iso_hash: iso_netof: bufsize = %d\n", bufsize); ! 311: ENDDEBUG ! 312: ! 313: hp->afh_hosthash = iso_hashchar((caddr_t)&siso->siso_addr, ! 314: siso->siso_addr.isoa_len); ! 315: ! 316: IFDEBUG(D_ROUTE) ! 317: printf("iso_hash: %s: nethash = x%x, hosthash = x%x\n", ! 318: clnp_iso_addrp(&siso->siso_addr), hp->afh_nethash, ! 319: hp->afh_hosthash); ! 320: ENDDEBUG ! 321: } ! 322: /* ! 323: * FUNCTION: iso_netof ! 324: * ! 325: * PURPOSE: Extract the network portion of the iso address. ! 326: * The network portion of the iso address varies depending ! 327: * on the type of address. The network portion of the ! 328: * address will include the IDP. The network portion is: ! 329: * ! 330: * TYPE DESC ! 331: * t37 The AFI and x.121 (IDI) ! 332: * osinet The AFI, orgid, snetid ! 333: * rfc986 The AFI, vers and network part of ! 334: * internet address. ! 335: * ! 336: * RETURNS: number of bytes placed into buf. ! 337: * ! 338: * SIDE EFFECTS: ! 339: * ! 340: * NOTES: Buf is assumed to be big enough ! 341: */ ! 342: iso_netof(isoa, buf) ! 343: struct iso_addr *isoa; /* address */ ! 344: caddr_t buf; /* RESULT: network portion of address here */ ! 345: { ! 346: u_int len = 1; /* length of afi */ ! 347: ! 348: switch (isoa->isoa_afi) { ! 349: case AFI_37: ! 350: /* ! 351: * Due to classic x.25 tunnel vision, there is no ! 352: * net portion of an x.121 address. For our purposes ! 353: * the AFI will do, so that all x.25 -type addresses ! 354: * map to the single x.25 SNPA. (Cannot have more than ! 355: * one, obviously). ! 356: */ ! 357: ! 358: break; ! 359: ! 360: /* case AFI_OSINET:*/ ! 361: case AFI_RFC986: { ! 362: u_short idi; /* value of idi */ ! 363: ! 364: /* osinet and rfc986 have idi in the same place */ ! 365: CTOH(isoa->rfc986_idi[0], isoa->rfc986_idi[1], idi); ! 366: ! 367: if (idi == IDI_OSINET) ! 368: /* ! 369: * Network portion of OSINET address can only be the IDI. Clearly, ! 370: * with one x25 interface, one could get to several orgids, and ! 371: * several snetids. ! 372: len += (ADDROSINET_IDI_LEN + OVLOSINET_ORGID_LEN + ! 373: OVLOSINET_SNETID_LEN); ! 374: */ ! 375: len += ADDROSINET_IDI_LEN; ! 376: else if (idi == IDI_RFC986) { ! 377: u_long inetaddr; ! 378: struct ovl_rfc986 *o986 = (struct ovl_rfc986 *)isoa; ! 379: ! 380: /* bump len to include idi and version (1 byte) */ ! 381: len += ADDRRFC986_IDI_LEN + 1; ! 382: ! 383: /* get inet addr long aligned */ ! 384: bcopy(o986->o986_inetaddr, &inetaddr, sizeof(inetaddr)); ! 385: inetaddr = ntohl(inetaddr); /* convert to host byte order */ ! 386: ! 387: IFDEBUG(D_ROUTE) ! 388: printf("iso_netof: isoa "); ! 389: dump_buf(isoa, sizeof(*isoa)); ! 390: printf("iso_netof: inetaddr 0x%x ", inetaddr); ! 391: ENDDEBUG ! 392: ! 393: /* bump len by size of network portion of inet address */ ! 394: if (IN_CLASSA(inetaddr)) { ! 395: len += 4-IN_CLASSA_NSHIFT/8; ! 396: IFDEBUG(D_ROUTE) ! 397: printf("iso_netof: class A net len is now %d\n", len); ! 398: ENDDEBUG ! 399: } else if (IN_CLASSB(inetaddr)) { ! 400: len += 4-IN_CLASSB_NSHIFT/8; ! 401: IFDEBUG(D_ROUTE) ! 402: printf("iso_netof: class B net len is now %d\n", len); ! 403: ENDDEBUG ! 404: } else { ! 405: len += 4-IN_CLASSC_NSHIFT/8; ! 406: IFDEBUG(D_ROUTE) ! 407: printf("iso_netof: class C net len is now %d\n", len); ! 408: ENDDEBUG ! 409: } ! 410: } else ! 411: len = 0; ! 412: } break; ! 413: ! 414: default: ! 415: len = 0; ! 416: } ! 417: ! 418: bcopy((caddr_t)isoa, buf, len); ! 419: IFDEBUG(D_ROUTE) ! 420: printf("iso_netof: isoa "); ! 421: dump_buf(isoa, len); ! 422: printf("iso_netof: net "); ! 423: dump_buf(buf, len); ! 424: ENDDEBUG ! 425: return len; ! 426: } ! 427: #endif /* notdef */ ! 428: /* ! 429: * Generic iso control operations (ioctl's). ! 430: * Ifp is 0 if not an interface-specific ioctl. ! 431: */ ! 432: /* ARGSUSED */ ! 433: iso_control(so, cmd, data, ifp) ! 434: struct socket *so; ! 435: int cmd; ! 436: caddr_t data; ! 437: register struct ifnet *ifp; ! 438: { ! 439: register struct iso_ifreq *ifr = (struct iso_ifreq *)data; ! 440: register struct iso_ifaddr *ia = 0; ! 441: register struct ifaddr *ifa; ! 442: struct iso_ifaddr *oia; ! 443: struct iso_aliasreq *ifra = (struct iso_aliasreq *)data; ! 444: int error, hostIsNew, maskIsNew; ! 445: ! 446: /* ! 447: * Find address for this interface, if it exists. ! 448: */ ! 449: if (ifp) ! 450: for (ia = iso_ifaddr; ia; ia = ia->ia_next) ! 451: if (ia->ia_ifp == ifp) ! 452: break; ! 453: ! 454: switch (cmd) { ! 455: ! 456: case SIOCAIFADDR_ISO: ! 457: case SIOCDIFADDR_ISO: ! 458: if (ifra->ifra_addr.siso_family == AF_ISO) ! 459: for (oia = ia; ia; ia = ia->ia_next) { ! 460: if (ia->ia_ifp == ifp && ! 461: SAME_ISOADDR(&ia->ia_addr, &ifra->ifra_addr)) ! 462: break; ! 463: } ! 464: if ((so->so_state & SS_PRIV) == 0) ! 465: return (EPERM); ! 466: if (ifp == 0) ! 467: panic("iso_control"); ! 468: if (ia == (struct iso_ifaddr *)0) { ! 469: struct iso_ifaddr *nia; ! 470: if (cmd == SIOCDIFADDR_ISO) ! 471: return (EADDRNOTAVAIL); ! 472: #if TUBA ! 473: /* XXXXXX can't be done in the proto init routines */ ! 474: if (tuba_tree == 0) ! 475: tuba_table_init(); ! 476: #endif ! 477: MALLOC(nia, struct iso_ifaddr *, sizeof(*nia), ! 478: M_IFADDR, M_WAITOK); ! 479: if (nia == (struct iso_ifaddr *)0) ! 480: return (ENOBUFS); ! 481: bzero((caddr_t)nia, sizeof(*nia)); ! 482: if (ia = iso_ifaddr) { ! 483: for ( ; ia->ia_next; ia = ia->ia_next) ! 484: ; ! 485: ia->ia_next = nia; ! 486: } else ! 487: iso_ifaddr = nia; ! 488: ia = nia; ! 489: if (ifa = ifp->if_addrlist) { ! 490: for ( ; ifa->ifa_next; ifa = ifa->ifa_next) ! 491: ; ! 492: ifa->ifa_next = (struct ifaddr *) ia; ! 493: } else ! 494: ifp->if_addrlist = (struct ifaddr *) ia; ! 495: ia->ia_ifa.ifa_addr = (struct sockaddr *)&ia->ia_addr; ! 496: ia->ia_ifa.ifa_dstaddr ! 497: = (struct sockaddr *)&ia->ia_dstaddr; ! 498: ia->ia_ifa.ifa_netmask ! 499: = (struct sockaddr *)&ia->ia_sockmask; ! 500: ia->ia_ifp = ifp; ! 501: if (ifp != &loif) ! 502: iso_interfaces++; ! 503: } ! 504: break; ! 505: ! 506: #define cmdbyte(x) (((x) >> 8) & 0xff) ! 507: default: ! 508: if (cmdbyte(cmd) == 'a') ! 509: return (snpac_ioctl(so, cmd, data)); ! 510: if (ia == (struct iso_ifaddr *)0) ! 511: return (EADDRNOTAVAIL); ! 512: break; ! 513: } ! 514: switch (cmd) { ! 515: ! 516: case SIOCGIFADDR_ISO: ! 517: ifr->ifr_Addr = ia->ia_addr; ! 518: break; ! 519: ! 520: case SIOCGIFDSTADDR_ISO: ! 521: if ((ifp->if_flags & IFF_POINTOPOINT) == 0) ! 522: return (EINVAL); ! 523: ifr->ifr_Addr = ia->ia_dstaddr; ! 524: break; ! 525: ! 526: case SIOCGIFNETMASK_ISO: ! 527: ifr->ifr_Addr = ia->ia_sockmask; ! 528: break; ! 529: ! 530: case SIOCAIFADDR_ISO: ! 531: maskIsNew = 0; hostIsNew = 1; error = 0; ! 532: if (ia->ia_addr.siso_family == AF_ISO) { ! 533: if (ifra->ifra_addr.siso_len == 0) { ! 534: ifra->ifra_addr = ia->ia_addr; ! 535: hostIsNew = 0; ! 536: } else if (SAME_ISOADDR(&ia->ia_addr, &ifra->ifra_addr)) ! 537: hostIsNew = 0; ! 538: } ! 539: if (ifra->ifra_mask.siso_len) { ! 540: iso_ifscrub(ifp, ia); ! 541: ia->ia_sockmask = ifra->ifra_mask; ! 542: maskIsNew = 1; ! 543: } ! 544: if ((ifp->if_flags & IFF_POINTOPOINT) && ! 545: (ifra->ifra_dstaddr.siso_family == AF_ISO)) { ! 546: iso_ifscrub(ifp, ia); ! 547: ia->ia_dstaddr = ifra->ifra_dstaddr; ! 548: maskIsNew = 1; /* We lie; but the effect's the same */ ! 549: } ! 550: if (ifra->ifra_addr.siso_family == AF_ISO && ! 551: (hostIsNew || maskIsNew)) { ! 552: error = iso_ifinit(ifp, ia, &ifra->ifra_addr, 0); ! 553: } ! 554: if (ifra->ifra_snpaoffset) ! 555: ia->ia_snpaoffset = ifra->ifra_snpaoffset; ! 556: return (error); ! 557: ! 558: case SIOCDIFADDR_ISO: ! 559: iso_ifscrub(ifp, ia); ! 560: if ((ifa = ifp->if_addrlist) == (struct ifaddr *)ia) ! 561: ifp->if_addrlist = ifa->ifa_next; ! 562: else { ! 563: while (ifa->ifa_next && ! 564: (ifa->ifa_next != (struct ifaddr *)ia)) ! 565: ifa = ifa->ifa_next; ! 566: if (ifa->ifa_next) ! 567: ifa->ifa_next = ((struct ifaddr *)ia)->ifa_next; ! 568: else ! 569: printf("Couldn't unlink isoifaddr from ifp\n"); ! 570: } ! 571: oia = ia; ! 572: if (oia == (ia = iso_ifaddr)) { ! 573: iso_ifaddr = ia->ia_next; ! 574: } else { ! 575: while (ia->ia_next && (ia->ia_next != oia)) { ! 576: ia = ia->ia_next; ! 577: } ! 578: if (ia->ia_next) ! 579: ia->ia_next = oia->ia_next; ! 580: else ! 581: printf("Didn't unlink isoifadr from list\n"); ! 582: } ! 583: IFAFREE((&oia->ia_ifa)); ! 584: break; ! 585: ! 586: default: ! 587: if (ifp == 0 || ifp->if_ioctl == 0) ! 588: return (EOPNOTSUPP); ! 589: return ((*ifp->if_ioctl)(ifp, cmd, data)); ! 590: } ! 591: return (0); ! 592: } ! 593: ! 594: /* ! 595: * Delete any existing route for an interface. ! 596: */ ! 597: iso_ifscrub(ifp, ia) ! 598: register struct ifnet *ifp; ! 599: register struct iso_ifaddr *ia; ! 600: { ! 601: int nsellength = ia->ia_addr.siso_tlen; ! 602: if ((ia->ia_flags & IFA_ROUTE) == 0) ! 603: return; ! 604: ia->ia_addr.siso_tlen = 0; ! 605: if (ifp->if_flags & IFF_LOOPBACK) ! 606: rtinit(&(ia->ia_ifa), (int)RTM_DELETE, RTF_HOST); ! 607: else if (ifp->if_flags & IFF_POINTOPOINT) ! 608: rtinit(&(ia->ia_ifa), (int)RTM_DELETE, RTF_HOST); ! 609: else { ! 610: rtinit(&(ia->ia_ifa), (int)RTM_DELETE, 0); ! 611: } ! 612: ia->ia_addr.siso_tlen = nsellength; ! 613: ia->ia_flags &= ~IFA_ROUTE; ! 614: } ! 615: ! 616: /* ! 617: * Initialize an interface's internet address ! 618: * and routing table entry. ! 619: */ ! 620: iso_ifinit(ifp, ia, siso, scrub) ! 621: register struct ifnet *ifp; ! 622: register struct iso_ifaddr *ia; ! 623: struct sockaddr_iso *siso; ! 624: { ! 625: struct sockaddr_iso oldaddr; ! 626: int s = splimp(), error, nsellength; ! 627: ! 628: oldaddr = ia->ia_addr; ! 629: ia->ia_addr = *siso; ! 630: /* ! 631: * Give the interface a chance to initialize ! 632: * if this is its first address, ! 633: * and to validate the address if necessary. ! 634: */ ! 635: if (ifp->if_ioctl && ! 636: (error = (*ifp->if_ioctl)(ifp, SIOCSIFADDR, (caddr_t)ia))) { ! 637: splx(s); ! 638: ia->ia_addr = oldaddr; ! 639: return (error); ! 640: } ! 641: if (scrub) { ! 642: ia->ia_ifa.ifa_addr = (struct sockaddr *)&oldaddr; ! 643: iso_ifscrub(ifp, ia); ! 644: ia->ia_ifa.ifa_addr = (struct sockaddr *)&ia->ia_addr; ! 645: } ! 646: /* XXX -- The following is here temporarily out of laziness ! 647: in not changing every ethernet driver's if_ioctl routine */ ! 648: if (ifp->if_output == ether_output) { ! 649: ia->ia_ifa.ifa_rtrequest = llc_rtrequest; ! 650: ia->ia_ifa.ifa_flags |= RTF_CLONING; ! 651: } ! 652: /* ! 653: * Add route for the network. ! 654: */ ! 655: nsellength = ia->ia_addr.siso_tlen; ! 656: ia->ia_addr.siso_tlen = 0; ! 657: if (ifp->if_flags & IFF_LOOPBACK) { ! 658: ia->ia_ifa.ifa_dstaddr = ia->ia_ifa.ifa_addr; ! 659: error = rtinit(&(ia->ia_ifa), (int)RTM_ADD, RTF_HOST|RTF_UP); ! 660: } else if (ifp->if_flags & IFF_POINTOPOINT && ! 661: ia->ia_dstaddr.siso_family == AF_ISO) ! 662: error = rtinit(&(ia->ia_ifa), (int)RTM_ADD, RTF_HOST|RTF_UP); ! 663: else { ! 664: rt_maskedcopy(ia->ia_ifa.ifa_addr, ia->ia_ifa.ifa_dstaddr, ! 665: ia->ia_ifa.ifa_netmask); ! 666: ia->ia_dstaddr.siso_nlen = ! 667: min(ia->ia_addr.siso_nlen, (ia->ia_sockmask.siso_len - 6)); ! 668: error = rtinit(&(ia->ia_ifa), (int)RTM_ADD, RTF_UP); ! 669: } ! 670: ia->ia_addr.siso_tlen = nsellength; ! 671: ia->ia_flags |= IFA_ROUTE; ! 672: splx(s); ! 673: return (error); ! 674: } ! 675: #ifdef notdef ! 676: ! 677: struct ifaddr * ! 678: iso_ifwithidi(addr) ! 679: register struct sockaddr *addr; ! 680: { ! 681: register struct ifnet *ifp; ! 682: register struct ifaddr *ifa; ! 683: register u_int af = addr->sa_family; ! 684: ! 685: if (af != AF_ISO) ! 686: return (0); ! 687: IFDEBUG(D_ROUTE) ! 688: printf(">>> iso_ifwithidi addr\n"); ! 689: dump_isoaddr( (struct sockaddr_iso *)(addr)); ! 690: printf("\n"); ! 691: ENDDEBUG ! 692: for (ifp = ifnet; ifp; ifp = ifp->if_next) { ! 693: IFDEBUG(D_ROUTE) ! 694: printf("iso_ifwithidi ifnet %s\n", ifp->if_name); ! 695: ENDDEBUG ! 696: for (ifa = ifp->if_addrlist; ifa; ifa = ifa->ifa_next) { ! 697: IFDEBUG(D_ROUTE) ! 698: printf("iso_ifwithidi address "); ! 699: dump_isoaddr( (struct sockaddr_iso *)(ifa->ifa_addr)); ! 700: ENDDEBUG ! 701: if (ifa->ifa_addr->sa_family != addr->sa_family) ! 702: continue; ! 703: ! 704: #define IFA_SIS(ifa)\ ! 705: ((struct sockaddr_iso *)((ifa)->ifa_addr)) ! 706: ! 707: IFDEBUG(D_ROUTE) ! 708: printf(" af same, args to iso_eqtype:\n"); ! 709: printf("0x%x ", IFA_SIS(ifa)->siso_addr); ! 710: printf(" 0x%x\n", ! 711: &(((struct sockaddr_iso *)addr)->siso_addr)); ! 712: ENDDEBUG ! 713: ! 714: if (iso_eqtype(&(IFA_SIS(ifa)->siso_addr), ! 715: &(((struct sockaddr_iso *)addr)->siso_addr))) { ! 716: IFDEBUG(D_ROUTE) ! 717: printf("ifa_ifwithidi: ifa found\n"); ! 718: ENDDEBUG ! 719: return (ifa); ! 720: } ! 721: IFDEBUG(D_ROUTE) ! 722: printf(" iso_eqtype failed\n"); ! 723: ENDDEBUG ! 724: } ! 725: } ! 726: return ((struct ifaddr *)0); ! 727: } ! 728: ! 729: #endif /* notdef */ ! 730: /* ! 731: * FUNCTION: iso_ck_addr ! 732: * ! 733: * PURPOSE: return true if the iso_addr passed is ! 734: * within the legal size limit for an iso address. ! 735: * ! 736: * RETURNS: true or false ! 737: * ! 738: * SIDE EFFECTS: ! 739: * ! 740: */ ! 741: iso_ck_addr(isoa) ! 742: struct iso_addr *isoa; /* address to check */ ! 743: { ! 744: return (isoa->isoa_len <= 20); ! 745: ! 746: } ! 747: ! 748: #ifdef notdef ! 749: /* ! 750: * FUNCTION: iso_eqtype ! 751: * ! 752: * PURPOSE: Determine if two iso addresses are of the same type. ! 753: * This is flaky. Really we should consider all type 47 addrs to be the ! 754: * same - but there do exist different structures for 47 addrs. ! 755: * Gosip adds a 3rd. ! 756: * ! 757: * RETURNS: true if the addresses are the same type ! 758: * ! 759: * SIDE EFFECTS: ! 760: * ! 761: * NOTES: By type, I mean rfc986, t37, or osinet ! 762: * ! 763: * This will first compare afis. If they match, then ! 764: * if the addr is not t37, the idis must be compared. ! 765: */ ! 766: iso_eqtype(isoaa, isoab) ! 767: struct iso_addr *isoaa; /* first addr to check */ ! 768: struct iso_addr *isoab; /* other addr to check */ ! 769: { ! 770: if (isoaa->isoa_afi == isoab->isoa_afi) { ! 771: if (isoaa->isoa_afi == AFI_37) ! 772: return(1); ! 773: else ! 774: return (!bcmp(&isoaa->isoa_u, &isoab->isoa_u, 2)); ! 775: } ! 776: return(0); ! 777: } ! 778: #endif /* notdef */ ! 779: /* ! 780: * FUNCTION: iso_localifa() ! 781: * ! 782: * PURPOSE: Find an interface addresss having a given destination ! 783: * or at least matching the net. ! 784: * ! 785: * RETURNS: ptr to an interface address ! 786: * ! 787: * SIDE EFFECTS: ! 788: * ! 789: * NOTES: ! 790: */ ! 791: struct iso_ifaddr * ! 792: iso_localifa(siso) ! 793: register struct sockaddr_iso *siso; ! 794: { ! 795: register struct iso_ifaddr *ia; ! 796: register char *cp1, *cp2, *cp3; ! 797: register struct ifnet *ifp; ! 798: struct iso_ifaddr *ia_maybe = 0; ! 799: /* ! 800: * We make one pass looking for both net matches and an exact ! 801: * dst addr. ! 802: */ ! 803: for (ia = iso_ifaddr; ia; ia = ia->ia_next) { ! 804: if ((ifp = ia->ia_ifp) == 0 || ((ifp->if_flags & IFF_UP) == 0)) ! 805: continue; ! 806: if (ifp->if_flags & IFF_POINTOPOINT) { ! 807: if ((ia->ia_dstaddr.siso_family == AF_ISO) && ! 808: SAME_ISOADDR(&ia->ia_dstaddr, siso)) ! 809: return (ia); ! 810: else ! 811: if (SAME_ISOADDR(&ia->ia_addr, siso)) ! 812: ia_maybe = ia; ! 813: continue; ! 814: } ! 815: if (ia->ia_sockmask.siso_len) { ! 816: char *cplim = ia->ia_sockmask.siso_len + (char *)&ia->ia_sockmask; ! 817: cp1 = ia->ia_sockmask.siso_data; ! 818: cp2 = siso->siso_data; ! 819: cp3 = ia->ia_addr.siso_data; ! 820: while (cp1 < cplim) ! 821: if (*cp1++ & (*cp2++ ^ *cp3++)) ! 822: goto next; ! 823: ia_maybe = ia; ! 824: } ! 825: if (SAME_ISOADDR(&ia->ia_addr, siso)) ! 826: return ia; ! 827: next:; ! 828: } ! 829: return ia_maybe; ! 830: } ! 831: ! 832: #if TPCONS ! 833: #include <netiso/cons.h> ! 834: #endif /* TPCONS */ ! 835: /* ! 836: * FUNCTION: iso_nlctloutput ! 837: * ! 838: * PURPOSE: Set options at the network level ! 839: * ! 840: * RETURNS: E* ! 841: * ! 842: * SIDE EFFECTS: ! 843: * ! 844: * NOTES: This could embody some of the functions of ! 845: * rclnp_ctloutput and cons_ctloutput. ! 846: */ ! 847: iso_nlctloutput(cmd, optname, pcb, m) ! 848: int cmd; /* command:set or get */ ! 849: int optname; /* option of interest */ ! 850: caddr_t pcb; /* nl pcb */ ! 851: struct mbuf *m; /* data for set, buffer for get */ ! 852: { ! 853: struct isopcb *isop = (struct isopcb *)pcb; ! 854: int error = 0; /* return value */ ! 855: caddr_t data; /* data for option */ ! 856: int data_len; /* data's length */ ! 857: ! 858: IFDEBUG(D_ISO) ! 859: printf("iso_nlctloutput: cmd %x, opt %x, pcb %x, m %x\n", ! 860: cmd, optname, pcb, m); ! 861: ENDDEBUG ! 862: ! 863: if ((cmd != PRCO_GETOPT) && (cmd != PRCO_SETOPT)) ! 864: return(EOPNOTSUPP); ! 865: ! 866: data = mtod(m, caddr_t); ! 867: data_len = (m)->m_len; ! 868: ! 869: IFDEBUG(D_ISO) ! 870: printf("iso_nlctloutput: data is:\n"); ! 871: dump_buf(data, data_len); ! 872: ENDDEBUG ! 873: ! 874: switch (optname) { ! 875: ! 876: #if TPCONS ! 877: case CONSOPT_X25CRUD: ! 878: if (cmd == PRCO_GETOPT) { ! 879: error = EOPNOTSUPP; ! 880: break; ! 881: } ! 882: ! 883: if (data_len > MAXX25CRUDLEN) { ! 884: error = EINVAL; ! 885: break; ! 886: } ! 887: ! 888: IFDEBUG(D_ISO) ! 889: printf("iso_nlctloutput: setting x25 crud\n"); ! 890: ENDDEBUG ! 891: ! 892: bcopy(data, (caddr_t)isop->isop_x25crud, (unsigned)data_len); ! 893: isop->isop_x25crud_len = data_len; ! 894: break; ! 895: #endif /* TPCONS */ ! 896: ! 897: default: ! 898: error = EOPNOTSUPP; ! 899: } ! 900: if (cmd == PRCO_SETOPT) ! 901: m_freem(m); ! 902: return error; ! 903: } ! 904: #endif /* ISO */ ! 905: ! 906: #ifdef ARGO_DEBUG ! 907: ! 908: /* ! 909: * FUNCTION: dump_isoaddr ! 910: * ! 911: * PURPOSE: debugging ! 912: * ! 913: * RETURNS: nada ! 914: * ! 915: */ ! 916: dump_isoaddr(s) ! 917: struct sockaddr_iso *s; ! 918: { ! 919: char *clnp_saddr_isop(); ! 920: register int i; ! 921: ! 922: if( s->siso_family == AF_ISO) { ! 923: printf("ISO address: suffixlen %d, %s\n", ! 924: s->siso_tlen, clnp_saddr_isop(s)); ! 925: } else if( s->siso_family == AF_INET) { ! 926: /* hack */ ! 927: struct sockaddr_in *sin = (struct sockaddr_in *)s; ! 928: ! 929: printf("%d.%d.%d.%d: %d", ! 930: (sin->sin_addr.s_addr>>24)&0xff, ! 931: (sin->sin_addr.s_addr>>16)&0xff, ! 932: (sin->sin_addr.s_addr>>8)&0xff, ! 933: (sin->sin_addr.s_addr)&0xff, ! 934: sin->sin_port); ! 935: } ! 936: } ! 937: ! 938: #endif /* ARGO_DEBUG */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.