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