![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to iso_snpac.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_snpac.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_snpac.c 8.1 (Berkeley) 6/10/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: #include <sys/param.h> ! 85: #include <sys/systm.h> ! 86: ! 87: #if ISO ! 88: #include <sys/mbuf.h> ! 89: #include <sys/domain.h> ! 90: #include <sys/protosw.h> ! 91: #include <sys/socket.h> ! 92: #include <sys/socketvar.h> ! 93: #include <sys/errno.h> ! 94: #include <sys/ioctl.h> ! 95: #include <sys/syslog.h> ! 96: #include <sys/malloc.h> ! 97: ! 98: #include <net/if.h> ! 99: #include <net/if_dl.h> ! 100: #include <net/route.h> ! 101: ! 102: #include <netiso/iso.h> ! 103: #include <netiso/iso_var.h> ! 104: #include <netiso/iso_snpac.h> ! 105: #include <netiso/clnp.h> ! 106: #include <netiso/clnp_stat.h> ! 107: #include <netiso/esis.h> ! 108: #include <netiso/argo_debug.h> ! 109: ! 110: int iso_systype = SNPA_ES; /* default to be an ES */ ! 111: extern short esis_holding_time, esis_config_time, esis_esconfig_time; ! 112: extern struct timeval time; ! 113: extern void esis_config(); ! 114: extern int hz; ! 115: static void snpac_fixdstandmask(); ! 116: ! 117: struct sockaddr_iso blank_siso = {sizeof(blank_siso), AF_ISO}; ! 118: extern u_long iso_hashchar(); ! 119: static struct sockaddr_iso ! 120: dst = {sizeof(dst), AF_ISO}, ! 121: gte = {sizeof(dst), AF_ISO}, ! 122: src = {sizeof(dst), AF_ISO}, ! 123: msk = {sizeof(dst), AF_ISO}, ! 124: zmk = {0}; ! 125: #define zsi blank_siso ! 126: #define zero_isoa zsi.siso_addr ! 127: #define zap_isoaddr(a, b) {Bzero(&a.siso_addr, sizeof(*r)); r = b; \ ! 128: Bcopy(r, &a.siso_addr, 1 + (r)->isoa_len);} ! 129: #define S(x) ((struct sockaddr *)&(x)) ! 130: ! 131: static struct sockaddr_dl blank_dl = {sizeof(blank_dl), AF_LINK}; ! 132: static struct sockaddr_dl gte_dl; ! 133: #define zap_linkaddr(a, b, c, i) \ ! 134: (*a = blank_dl, bcopy(b, a->sdl_data, a->sdl_alen = c), a->sdl_index = i) ! 135: ! 136: /* ! 137: * We only keep track of a single IS at a time. ! 138: */ ! 139: struct rtentry *known_is; ! 140: ! 141: /* ! 142: * Addresses taken from NBS agreements, December 1987. ! 143: * ! 144: * These addresses assume on-the-wire transmission of least significant ! 145: * bit first. This is the method used by 802.3. When these ! 146: * addresses are passed to the token ring driver, (802.5), they ! 147: * must be bit-swaped because 802.5 transmission order is MSb first. ! 148: * ! 149: * Furthermore, according to IBM Austin, these addresses are not ! 150: * true token ring multicast addresses. More work is necessary ! 151: * to get multicast to work right on token ring. ! 152: * ! 153: * Currently, the token ring driver does not handle multicast, so ! 154: * these addresses are converted into the broadcast address in ! 155: * lan_output() That means that if these multicast addresses change ! 156: * the token ring driver must be altered. ! 157: */ ! 158: char all_es_snpa[] = { 0x09, 0x00, 0x2b, 0x00, 0x00, 0x04 }; ! 159: char all_is_snpa[] = { 0x09, 0x00, 0x2b, 0x00, 0x00, 0x05 }; ! 160: char all_l1is_snpa[] = {0x01, 0x80, 0xc2, 0x00, 0x00, 0x14}; ! 161: char all_l2is_snpa[] = {0x01, 0x80, 0xc2, 0x00, 0x00, 0x15}; ! 162: ! 163: union sockunion { ! 164: struct sockaddr_iso siso; ! 165: struct sockaddr_dl sdl; ! 166: struct sockaddr sa; ! 167: }; ! 168: ! 169: /* ! 170: * FUNCTION: llc_rtrequest ! 171: * ! 172: * PURPOSE: Manage routing table entries specific to LLC for ISO. ! 173: * ! 174: * NOTES: This does a lot of obscure magic; ! 175: */ ! 176: llc_rtrequest(req, rt, sa) ! 177: int req; ! 178: register struct rtentry *rt; ! 179: struct sockaddr *sa; ! 180: { ! 181: register union sockunion *gate = (union sockunion *)rt->rt_gateway; ! 182: register struct llinfo_llc *lc = (struct llinfo_llc *)rt->rt_llinfo, *lc2; ! 183: struct rtentry *rt2; ! 184: struct ifnet *ifp = rt->rt_ifp; ! 185: int addrlen = ifp->if_addrlen; ! 186: #define LLC_SIZE 3 /* XXXXXX do this right later */ ! 187: ! 188: IFDEBUG (D_SNPA) ! 189: printf("llc_rtrequest(%d, %x, %x)\n", req, rt, sa); ! 190: ENDDEBUG ! 191: if (rt->rt_flags & RTF_GATEWAY) ! 192: return; ! 193: else switch (req) { ! 194: case RTM_ADD: ! 195: /* ! 196: * Case 1: This route may come from a route to iface with mask ! 197: * or from a default route. ! 198: */ ! 199: if (rt->rt_flags & RTF_CLONING) { ! 200: iso_setmcasts(ifp, req); ! 201: rt_setgate(rt, rt_key(rt), &blank_dl); ! 202: return; ! 203: } ! 204: if (lc != 0) ! 205: return; /* happens on a route change */ ! 206: /* FALLTHROUGH */ ! 207: case RTM_RESOLVE: ! 208: /* ! 209: * Case 2: This route may come from cloning, or a manual route ! 210: * add with a LL address. ! 211: */ ! 212: if (gate->sdl.sdl_family != AF_LINK) { ! 213: log(LOG_DEBUG, "llc_rtrequest: got non-link non-gateway route\n"); ! 214: break; ! 215: } ! 216: R_Malloc(lc, struct llinfo_llc *, sizeof (*lc)); ! 217: rt->rt_llinfo = (caddr_t)lc; ! 218: if (lc == 0) { ! 219: log(LOG_DEBUG, "llc_rtrequest: malloc failed\n"); ! 220: break; ! 221: } ! 222: Bzero(lc, sizeof(*lc)); ! 223: lc->lc_rt = rt; ! 224: rt->rt_flags |= RTF_LLINFO; ! 225: insque(lc, &llinfo_llc); ! 226: if (gate->sdl.sdl_alen == sizeof(struct esis_req) + addrlen) { ! 227: gate->sdl.sdl_alen -= sizeof(struct esis_req); ! 228: bcopy(addrlen + LLADDR(&gate->sdl), ! 229: (caddr_t)&lc->lc_er, sizeof(lc->lc_er)); ! 230: } else if (gate->sdl.sdl_alen == addrlen) ! 231: lc->lc_flags = (SNPA_ES | SNPA_VALID | SNPA_PERM); ! 232: break; ! 233: case RTM_DELETE: ! 234: if (rt->rt_flags & RTF_CLONING) ! 235: iso_setmcasts(ifp, req); ! 236: if (lc == 0) ! 237: return; ! 238: remque(lc); ! 239: Free(lc); ! 240: rt->rt_llinfo = 0; ! 241: rt->rt_flags &= ~RTF_LLINFO; ! 242: break; ! 243: } ! 244: if (rt->rt_rmx.rmx_mtu == 0) { ! 245: rt->rt_rmx.rmx_mtu = rt->rt_ifp->if_mtu - LLC_SIZE; ! 246: } ! 247: } ! 248: /* ! 249: * FUNCTION: iso_setmcasts ! 250: * ! 251: * PURPOSE: Enable/Disable ESIS/ISIS multicast reception on interfaces. ! 252: * ! 253: * NOTES: This also does a lot of obscure magic; ! 254: */ ! 255: iso_setmcasts(ifp, req) ! 256: struct ifnet *ifp; ! 257: int req; ! 258: { ! 259: static char *addrlist[] = ! 260: { all_es_snpa, all_is_snpa, all_l1is_snpa, all_l2is_snpa, 0}; ! 261: struct ifreq ifr; ! 262: register caddr_t *cpp; ! 263: int doreset = 0; ! 264: ! 265: bzero((caddr_t)&ifr, sizeof(ifr)); ! 266: for (cpp = (caddr_t *)addrlist; *cpp; cpp++) { ! 267: bcopy(*cpp, (caddr_t)ifr.ifr_addr.sa_data, 6); ! 268: if (req == RTM_ADD) ! 269: if (ether_addmulti(&ifr, (struct arpcom *)ifp) == ENETRESET) ! 270: doreset++; ! 271: else ! 272: if (ether_delmulti(&ifr, (struct arpcom *)ifp) == ENETRESET) ! 273: doreset++; ! 274: } ! 275: if (doreset) { ! 276: if (ifp->if_reset) ! 277: (*ifp->if_reset)(ifp->if_unit); ! 278: else ! 279: printf("iso_setmcasts: %s%d needs reseting to receive iso mcasts\n", ! 280: ifp->if_name, ifp->if_unit); ! 281: } ! 282: } ! 283: /* ! 284: * FUNCTION: iso_snparesolve ! 285: * ! 286: * PURPOSE: Resolve an iso address into snpa address ! 287: * ! 288: * RETURNS: 0 if addr is resolved ! 289: * errno if addr is unknown ! 290: * ! 291: * SIDE EFFECTS: ! 292: * ! 293: * NOTES: Now that we have folded the snpa cache into the routing ! 294: * table, we know there is no snpa address known for this ! 295: * destination. If we know of a default IS, then the address ! 296: * of the IS is returned. If no IS is known, then return the ! 297: * multi-cast address for "all ES" for this interface. ! 298: * ! 299: * NB: the last case described above constitutes the ! 300: * query configuration function 9542, sec 6.5 ! 301: * A mechanism is needed to prevent this function from ! 302: * being invoked if the system is an IS. ! 303: */ ! 304: iso_snparesolve(ifp, dest, snpa, snpa_len) ! 305: struct ifnet *ifp; /* outgoing interface */ ! 306: struct sockaddr_iso *dest; /* destination */ ! 307: caddr_t snpa; /* RESULT: snpa to be used */ ! 308: int *snpa_len; /* RESULT: length of snpa */ ! 309: { ! 310: struct llinfo_llc *sc; /* ptr to snpa table entry */ ! 311: caddr_t found_snpa; ! 312: int addrlen; ! 313: ! 314: /* ! 315: * This hack allows us to send esis packets that have the destination snpa ! 316: * addresss embedded in the destination nsap address ! 317: */ ! 318: if (dest->siso_data[0] == AFI_SNA) { ! 319: /* ! 320: * This is a subnetwork address. Return it immediately ! 321: */ ! 322: IFDEBUG(D_SNPA) ! 323: printf("iso_snparesolve: return SN address\n"); ! 324: ENDDEBUG ! 325: addrlen = dest->siso_nlen - 1; /* subtract size of AFI */ ! 326: found_snpa = (caddr_t) dest->siso_data + 1; ! 327: /* ! 328: * If we are an IS, we can't do much with the packet; ! 329: * Check if we know about an IS. ! 330: */ ! 331: } else if (iso_systype != SNPA_IS && known_is != 0 && ! 332: (sc = (struct llinfo_llc *)known_is->rt_llinfo) && ! 333: (sc->lc_flags & SNPA_VALID)) { ! 334: register struct sockaddr_dl *sdl = ! 335: (struct sockaddr_dl *)(known_is->rt_gateway); ! 336: found_snpa = LLADDR(sdl); ! 337: addrlen = sdl->sdl_alen; ! 338: } else if (ifp->if_flags & IFF_BROADCAST) { ! 339: /* ! 340: * no IS, no match. Return "all es" multicast address for this ! 341: * interface, as per Query Configuration Function (9542 sec 6.5) ! 342: * ! 343: * Note: there is a potential problem here. If the destination ! 344: * is on the subnet and it does not respond with a ESH, but ! 345: * does send back a TP CC, a connection could be established ! 346: * where we always transmit the CLNP packet to "all es" ! 347: */ ! 348: addrlen = ifp->if_addrlen; ! 349: found_snpa = (caddr_t)all_es_snpa; ! 350: } else ! 351: return (ENETUNREACH); ! 352: bcopy(found_snpa, snpa, *snpa_len = addrlen); ! 353: return (0); ! 354: } ! 355: ! 356: ! 357: /* ! 358: * FUNCTION: snpac_free ! 359: * ! 360: * PURPOSE: free an entry in the iso address map table ! 361: * ! 362: * RETURNS: nothing ! 363: * ! 364: * SIDE EFFECTS: ! 365: * ! 366: * NOTES: If there is a route entry associated with cache ! 367: * entry, then delete that as well ! 368: */ ! 369: snpac_free(lc) ! 370: register struct llinfo_llc *lc; /* entry to free */ ! 371: { ! 372: register struct rtentry *rt = lc->lc_rt; ! 373: register struct iso_addr *r; ! 374: ! 375: if (known_is == rt) ! 376: known_is = 0; ! 377: if (rt && (rt->rt_flags & RTF_UP) && ! 378: (rt->rt_flags & (RTF_DYNAMIC | RTF_MODIFIED))) { ! 379: RTFREE(rt); ! 380: rtrequest(RTM_DELETE, rt_key(rt), rt->rt_gateway, rt_mask(rt), ! 381: rt->rt_flags, (struct rtentry **)0); ! 382: RTFREE(rt); ! 383: } ! 384: } ! 385: ! 386: /* ! 387: * FUNCTION: snpac_add ! 388: * ! 389: * PURPOSE: Add an entry to the snpa cache ! 390: * ! 391: * RETURNS: ! 392: * ! 393: * SIDE EFFECTS: ! 394: * ! 395: * NOTES: If entry already exists, then update holding time. ! 396: */ ! 397: snpac_add(ifp, nsap, snpa, type, ht, nsellength) ! 398: struct ifnet *ifp; /* interface info is related to */ ! 399: struct iso_addr *nsap; /* nsap to add */ ! 400: caddr_t snpa; /* translation */ ! 401: char type; /* SNPA_IS or SNPA_ES */ ! 402: u_short ht; /* holding time (in seconds) */ ! 403: int nsellength; /* nsaps may differ only in trailing bytes */ ! 404: { ! 405: register struct llinfo_llc *lc; ! 406: register struct rtentry *rt; ! 407: struct rtentry *mrt = 0; ! 408: register struct iso_addr *r; /* for zap_isoaddr macro */ ! 409: int snpalen = min(ifp->if_addrlen, MAX_SNPALEN); ! 410: int new_entry = 0, index = ifp->if_index, iftype = ifp->if_type; ! 411: ! 412: IFDEBUG(D_SNPA) ! 413: printf("snpac_add(%x, %x, %x, %x, %x, %x)\n", ! 414: ifp, nsap, snpa, type, ht, nsellength); ! 415: ENDDEBUG ! 416: zap_isoaddr(dst, nsap); ! 417: rt = rtalloc1(S(dst), 0); ! 418: IFDEBUG(D_SNPA) ! 419: printf("snpac_add: rtalloc1 returns %x\n", rt); ! 420: ENDDEBUG ! 421: if (rt == 0) { ! 422: struct sockaddr *netmask; ! 423: int flags; ! 424: add: ! 425: if (nsellength) { ! 426: netmask = S(msk); flags = RTF_UP; ! 427: snpac_fixdstandmask(nsellength); ! 428: } else { ! 429: netmask = 0; flags = RTF_UP | RTF_HOST; ! 430: } ! 431: new_entry = 1; ! 432: zap_linkaddr((>e_dl), snpa, snpalen, index); ! 433: gte_dl.sdl_type = iftype; ! 434: if (rtrequest(RTM_ADD, S(dst), S(gte_dl), netmask, flags, &mrt) || ! 435: mrt == 0) ! 436: return (0); ! 437: rt = mrt; ! 438: rt->rt_refcnt--; ! 439: } else { ! 440: register struct sockaddr_dl *sdl = (struct sockaddr_dl *)rt->rt_gateway; ! 441: rt->rt_refcnt--; ! 442: if ((rt->rt_flags & RTF_LLINFO) == 0) ! 443: goto add; ! 444: if (nsellength && (rt->rt_flags & RTF_HOST)) { ! 445: if (rt->rt_refcnt == 0) { ! 446: rtrequest(RTM_DELETE, S(dst), (struct sockaddr *)0, ! 447: (struct sockaddr *)0, 0, (struct rtentry *)0); ! 448: rt = 0; ! 449: goto add; ! 450: } else { ! 451: static struct iso_addr nsap2; register char *cp; ! 452: nsap2 = *nsap; ! 453: cp = nsap2.isoa_genaddr + nsap->isoa_len - nsellength; ! 454: while (cp < (char *)(1 + &nsap2)) ! 455: *cp++ = 0; ! 456: (void) snpac_add(ifp, &nsap2, snpa, type, ht, nsellength); ! 457: } ! 458: } ! 459: if (sdl->sdl_family != AF_LINK || sdl->sdl_alen == 0) { ! 460: int old_sdl_len = sdl->sdl_len; ! 461: if (old_sdl_len < sizeof(*sdl)) { ! 462: log(LOG_DEBUG, "snpac_add: cant make room for lladdr\n"); ! 463: return (0); ! 464: } ! 465: zap_linkaddr(sdl, snpa, snpalen, index); ! 466: sdl->sdl_len = old_sdl_len; ! 467: sdl->sdl_type = iftype; ! 468: new_entry = 1; ! 469: } ! 470: } ! 471: if ((lc = (struct llinfo_llc *)rt->rt_llinfo) == 0) ! 472: panic("snpac_rtrequest"); ! 473: rt->rt_rmx.rmx_expire = ht + time.tv_sec; ! 474: lc->lc_flags = SNPA_VALID | type; ! 475: if ((type & SNPA_IS) && !(iso_systype & SNPA_IS)) ! 476: snpac_logdefis(rt); ! 477: return (new_entry); ! 478: } ! 479: ! 480: static void ! 481: snpac_fixdstandmask(nsellength) ! 482: { ! 483: register char *cp = msk.siso_data, *cplim; ! 484: ! 485: cplim = cp + (dst.siso_nlen -= nsellength); ! 486: msk.siso_len = cplim - (char *)&msk; ! 487: msk.siso_nlen = 0; ! 488: while (cp < cplim) ! 489: *cp++ = -1; ! 490: while (cp < (char *)msk.siso_pad) ! 491: *cp++ = 0; ! 492: for (cp = dst.siso_data + dst.siso_nlen; cp < (char *)dst.siso_pad; ) ! 493: *cp++ = 0; ! 494: } ! 495: ! 496: /* ! 497: * FUNCTION: snpac_ioctl ! 498: * ! 499: * PURPOSE: Set/Get the system type and esis parameters ! 500: * ! 501: * RETURNS: 0 on success, or unix error code ! 502: * ! 503: * SIDE EFFECTS: ! 504: * ! 505: * NOTES: ! 506: */ ! 507: snpac_ioctl (so, cmd, data) ! 508: struct socket *so; ! 509: int cmd; /* ioctl to process */ ! 510: caddr_t data; /* data for the cmd */ ! 511: { ! 512: register struct systype_req *rq = (struct systype_req *)data; ! 513: ! 514: IFDEBUG(D_IOCTL) ! 515: if (cmd == SIOCSSTYPE) ! 516: printf("snpac_ioctl: cmd set, type x%x, ht %d, ct %d\n", ! 517: rq->sr_type, rq->sr_holdt, rq->sr_configt); ! 518: else ! 519: printf("snpac_ioctl: cmd get\n"); ! 520: ENDDEBUG ! 521: ! 522: if (cmd == SIOCSSTYPE) { ! 523: if ((so->so_state & SS_PRIV) == 0) ! 524: return (EPERM); ! 525: if ((rq->sr_type & (SNPA_ES|SNPA_IS)) == (SNPA_ES|SNPA_IS)) ! 526: return(EINVAL); ! 527: if (rq->sr_type & SNPA_ES) { ! 528: iso_systype = SNPA_ES; ! 529: } else if (rq->sr_type & SNPA_IS) { ! 530: iso_systype = SNPA_IS; ! 531: } else { ! 532: return(EINVAL); ! 533: } ! 534: esis_holding_time = rq->sr_holdt; ! 535: esis_config_time = rq->sr_configt; ! 536: if (esis_esconfig_time != rq->sr_esconfigt) { ! 537: untimeout(esis_config, (caddr_t)0); ! 538: esis_esconfig_time = rq->sr_esconfigt; ! 539: esis_config(); ! 540: } ! 541: } else if (cmd == SIOCGSTYPE) { ! 542: rq->sr_type = iso_systype; ! 543: rq->sr_holdt = esis_holding_time; ! 544: rq->sr_configt = esis_config_time; ! 545: rq->sr_esconfigt = esis_esconfig_time; ! 546: } else { ! 547: return (EINVAL); ! 548: } ! 549: return (0); ! 550: } ! 551: ! 552: /* ! 553: * FUNCTION: snpac_logdefis ! 554: * ! 555: * PURPOSE: Mark the IS passed as the default IS ! 556: * ! 557: * RETURNS: nothing ! 558: * ! 559: * SIDE EFFECTS: ! 560: * ! 561: * NOTES: ! 562: */ ! 563: snpac_logdefis(sc) ! 564: register struct rtentry *sc; ! 565: { ! 566: register struct iso_addr *r; ! 567: register struct sockaddr_dl *sdl = (struct sockaddr_dl *)sc->rt_gateway; ! 568: register struct rtentry *rt; ! 569: ! 570: if (known_is == sc || !(sc->rt_flags & RTF_HOST)) ! 571: return; ! 572: if (known_is) { ! 573: RTFREE(known_is); ! 574: } ! 575: known_is = sc; ! 576: RTHOLD(sc); ! 577: rt = rtalloc1((struct sockaddr *)&zsi, 0); ! 578: if (rt == 0) ! 579: rtrequest(RTM_ADD, S(zsi), rt_key(sc), S(zmk), ! 580: RTF_DYNAMIC|RTF_GATEWAY, 0); ! 581: else { ! 582: if ((rt->rt_flags & RTF_DYNAMIC) && ! 583: (rt->rt_flags & RTF_GATEWAY) && rt_mask(rt)->sa_len == 0) ! 584: rt_setgate(rt, rt_key(rt), rt_key(sc)); ! 585: } ! 586: } ! 587: ! 588: /* ! 589: * FUNCTION: snpac_age ! 590: * ! 591: * PURPOSE: Time out snpac entries ! 592: * ! 593: * RETURNS: ! 594: * ! 595: * SIDE EFFECTS: ! 596: * ! 597: * NOTES: When encountering an entry for the first time, snpac_age ! 598: * may delete up to SNPAC_AGE too many seconds. Ie. ! 599: * if the entry is added a moment before snpac_age is ! 600: * called, the entry will immediately have SNPAC_AGE ! 601: * seconds taken off the holding time, even though ! 602: * it has only been held a brief moment. ! 603: * ! 604: * The proper way to do this is set an expiry timeval ! 605: * equal to current time + holding time. Then snpac_age ! 606: * would time out entries where expiry date is older ! 607: * than the current time. ! 608: */ ! 609: void ! 610: snpac_age() ! 611: { ! 612: register struct llinfo_llc *lc, *nlc; ! 613: register struct rtentry *rt; ! 614: ! 615: timeout(snpac_age, (caddr_t)0, SNPAC_AGE * hz); ! 616: ! 617: for (lc = llinfo_llc.lc_next; lc != & llinfo_llc; lc = nlc) { ! 618: nlc = lc->lc_next; ! 619: if (lc->lc_flags & SNPA_VALID) { ! 620: rt = lc->lc_rt; ! 621: if (rt->rt_rmx.rmx_expire && rt->rt_rmx.rmx_expire < time.tv_sec) ! 622: snpac_free(lc); ! 623: } ! 624: } ! 625: } ! 626: ! 627: /* ! 628: * FUNCTION: snpac_ownmulti ! 629: * ! 630: * PURPOSE: Determine if the snpa address is a multicast address ! 631: * of the same type as the system. ! 632: * ! 633: * RETURNS: true or false ! 634: * ! 635: * SIDE EFFECTS: ! 636: * ! 637: * NOTES: Used by interface drivers when not in eavesdrop mode ! 638: * as interm kludge until ! 639: * real multicast addresses can be configured ! 640: */ ! 641: snpac_ownmulti(snpa, len) ! 642: caddr_t snpa; ! 643: u_int len; ! 644: { ! 645: return (((iso_systype & SNPA_ES) && ! 646: (!bcmp(snpa, (caddr_t)all_es_snpa, len))) || ! 647: ((iso_systype & SNPA_IS) && ! 648: (!bcmp(snpa, (caddr_t)all_is_snpa, len)))); ! 649: } ! 650: ! 651: /* ! 652: * FUNCTION: snpac_flushifp ! 653: * ! 654: * PURPOSE: Flush entries associated with specific ifp ! 655: * ! 656: * RETURNS: nothing ! 657: * ! 658: * SIDE EFFECTS: ! 659: * ! 660: * NOTES: ! 661: */ ! 662: snpac_flushifp(ifp) ! 663: struct ifnet *ifp; ! 664: { ! 665: register struct llinfo_llc *lc; ! 666: ! 667: for (lc = llinfo_llc.lc_next; lc != & llinfo_llc; lc = lc->lc_next) { ! 668: if (lc->lc_rt->rt_ifp == ifp && (lc->lc_flags & SNPA_VALID)) ! 669: snpac_free(lc); ! 670: } ! 671: } ! 672: ! 673: /* ! 674: * FUNCTION: snpac_rtrequest ! 675: * ! 676: * PURPOSE: Make a routing request ! 677: * ! 678: * RETURNS: nothing ! 679: * ! 680: * SIDE EFFECTS: ! 681: * ! 682: * NOTES: In the future, this should make a request of a user ! 683: * level routing daemon. ! 684: */ ! 685: snpac_rtrequest(req, host, gateway, netmask, flags, ret_nrt) ! 686: int req; ! 687: struct iso_addr *host; ! 688: struct iso_addr *gateway; ! 689: struct iso_addr *netmask; ! 690: short flags; ! 691: struct rtentry **ret_nrt; ! 692: { ! 693: register struct iso_addr *r; ! 694: ! 695: IFDEBUG(D_SNPA) ! 696: printf("snpac_rtrequest: "); ! 697: if (req == RTM_ADD) ! 698: printf("add"); ! 699: else if (req == RTM_DELETE) ! 700: printf("delete"); ! 701: else ! 702: printf("unknown command"); ! 703: printf(" dst: %s\n", clnp_iso_addrp(host)); ! 704: printf("\tgateway: %s\n", clnp_iso_addrp(gateway)); ! 705: ENDDEBUG ! 706: ! 707: ! 708: zap_isoaddr(dst, host); ! 709: zap_isoaddr(gte, gateway); ! 710: if (netmask) { ! 711: zap_isoaddr(msk, netmask); ! 712: msk.siso_nlen = 0; ! 713: msk.siso_len = msk.siso_pad - (u_char *)&msk; ! 714: } ! 715: ! 716: rtrequest(req, S(dst), S(gte), (netmask ? S(msk) : (struct sockaddr *)0), ! 717: flags, ret_nrt); ! 718: } ! 719: ! 720: /* ! 721: * FUNCTION: snpac_addrt ! 722: * ! 723: * PURPOSE: Associate a routing entry with an snpac entry ! 724: * ! 725: * RETURNS: nothing ! 726: * ! 727: * SIDE EFFECTS: ! 728: * ! 729: * NOTES: If a cache entry exists for gateway, then ! 730: * make a routing entry (host, gateway) and associate ! 731: * with gateway. ! 732: * ! 733: * If a route already exists and is different, first delete ! 734: * it. ! 735: * ! 736: * This could be made more efficient by checking ! 737: * the existing route before adding a new one. ! 738: */ ! 739: snpac_addrt(ifp, host, gateway, netmask) ! 740: struct ifnet *ifp; ! 741: struct iso_addr *host, *gateway, *netmask; ! 742: { ! 743: register struct iso_addr *r; ! 744: ! 745: zap_isoaddr(dst, host); ! 746: zap_isoaddr(gte, gateway); ! 747: if (netmask) { ! 748: zap_isoaddr(msk, netmask); ! 749: msk.siso_nlen = 0; ! 750: msk.siso_len = msk.siso_pad - (u_char *)&msk; ! 751: rtredirect(S(dst), S(gte), S(msk), RTF_DONE, S(gte), 0); ! 752: } else ! 753: rtredirect(S(dst), S(gte), (struct sockaddr *)0, ! 754: RTF_DONE | RTF_HOST, S(gte), 0); ! 755: } ! 756: #endif /* ISO */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.