![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to esis.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 esis.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: * @(#)esis.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: #if ISO ! 85: ! 86: #include <sys/param.h> ! 87: #include <sys/systm.h> ! 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/kernel.h> ! 95: ! 96: #include <net/if.h> ! 97: #include <net/if_dl.h> ! 98: #include <net/route.h> ! 99: #include <net/raw_cb.h> ! 100: ! 101: #include <netiso/iso.h> ! 102: #include <netiso/iso_pcb.h> ! 103: #include <netiso/iso_var.h> ! 104: #include <netiso/iso_snpac.h> ! 105: #include <netiso/clnl.h> ! 106: #include <netiso/clnp.h> ! 107: #include <netiso/clnp_stat.h> ! 108: #include <netiso/esis.h> ! 109: #include <netiso/argo_debug.h> ! 110: ! 111: /* ! 112: * Global variables to esis implementation ! 113: * ! 114: * esis_holding_time - the holding time (sec) parameter for outgoing pdus ! 115: * esis_config_time - the frequency (sec) that hellos are generated ! 116: * esis_esconfig_time - suggested es configuration time placed in the ! 117: * ish. ! 118: * ! 119: */ ! 120: struct rawcb esis_pcb; ! 121: void esis_config(), snpac_age(); ! 122: int esis_sendspace = 2048; ! 123: int esis_recvspace = 2048; ! 124: short esis_holding_time = ESIS_HT; ! 125: short esis_config_time = ESIS_CONFIG; ! 126: short esis_esconfig_time = ESIS_CONFIG; ! 127: extern int iso_systype; ! 128: struct sockaddr_dl esis_dl = { sizeof(esis_dl), AF_LINK }; ! 129: extern char all_es_snpa[], all_is_snpa[]; ! 130: ! 131: #define EXTEND_PACKET(m, mhdr, cp)\ ! 132: if (((m)->m_next = m_getclr(M_DONTWAIT, MT_HEADER)) == NULL) {\ ! 133: esis_stat.es_nomem++;\ ! 134: m_freem(mhdr);\ ! 135: return;\ ! 136: } else {\ ! 137: (m) = (m)->m_next;\ ! 138: (cp) = mtod((m), caddr_t);\ ! 139: } ! 140: /* ! 141: * FUNCTION: esis_init ! 142: * ! 143: * PURPOSE: Initialize the kernel portion of esis protocol ! 144: * ! 145: * RETURNS: nothing ! 146: * ! 147: * SIDE EFFECTS: ! 148: * ! 149: * NOTES: ! 150: */ ! 151: esis_init() ! 152: { ! 153: extern struct clnl_protosw clnl_protox[256]; ! 154: int esis_input(), isis_input(); ! 155: #ifdef ISO_X25ESIS ! 156: int x25esis_input(); ! 157: #endif /* ISO_X25ESIS */ ! 158: ! 159: esis_pcb.rcb_next = esis_pcb.rcb_prev = &esis_pcb; ! 160: llinfo_llc.lc_next = llinfo_llc.lc_prev = &llinfo_llc; ! 161: ! 162: timeout(snpac_age, (caddr_t)0, hz); ! 163: timeout(esis_config, (caddr_t)0, hz); ! 164: ! 165: clnl_protox[ISO9542_ESIS].clnl_input = esis_input; ! 166: clnl_protox[ISO10589_ISIS].clnl_input = isis_input; ! 167: #ifdef ISO_X25ESIS ! 168: clnl_protox[ISO9542X25_ESIS].clnl_input = x25esis_input; ! 169: #endif /* ISO_X25ESIS */ ! 170: } ! 171: ! 172: /* ! 173: * FUNCTION: esis_usrreq ! 174: * ! 175: * PURPOSE: Handle user level esis requests ! 176: * ! 177: * RETURNS: 0 or appropriate errno ! 178: * ! 179: * SIDE EFFECTS: ! 180: * ! 181: */ ! 182: /*ARGSUSED*/ ! 183: esis_usrreq(so, req, m, nam, control) ! 184: struct socket *so; /* socket: used only to get to this code */ ! 185: int req; /* request */ ! 186: struct mbuf *m; /* data for request */ ! 187: struct mbuf *nam; /* optional name */ ! 188: struct mbuf *control; /* optional control */ ! 189: { ! 190: struct rawcb *rp = sotorawcb(so); ! 191: int error = 0; ! 192: ! 193: if ((so->so_state & SS_PRIV) == 0) { ! 194: error = EACCES; ! 195: goto release; ! 196: } ! 197: if (rp == NULL && req != PRU_ATTACH) { ! 198: error = EINVAL; ! 199: goto release; ! 200: } ! 201: ! 202: switch (req) { ! 203: case PRU_ATTACH: ! 204: if (rp != NULL) { ! 205: error = EINVAL; ! 206: break; ! 207: } ! 208: MALLOC(rp, struct rawcb *, sizeof(*rp), M_PCB, M_WAITOK); ! 209: if (so->so_pcb = (caddr_t)rp) { ! 210: bzero(so->so_pcb, sizeof(*rp)); ! 211: insque(rp, &esis_pcb); ! 212: rp->rcb_socket = so; ! 213: error = soreserve(so, esis_sendspace, esis_recvspace); ! 214: } else ! 215: error = ENOBUFS; ! 216: break; ! 217: ! 218: case PRU_SEND: ! 219: if (nam == NULL) { ! 220: error = EINVAL; ! 221: break; ! 222: } ! 223: /* error checking here */ ! 224: error = isis_output(mtod(nam,struct sockaddr_dl *), m); ! 225: m = NULL; ! 226: break; ! 227: ! 228: case PRU_DETACH: ! 229: raw_detach(rp); ! 230: break; ! 231: ! 232: case PRU_SHUTDOWN: ! 233: socantsendmore(so); ! 234: break; ! 235: ! 236: case PRU_ABORT: ! 237: soisdisconnected(so); ! 238: raw_detach(rp); ! 239: break; ! 240: ! 241: case PRU_SENSE: ! 242: return (0); ! 243: ! 244: default: ! 245: return (EOPNOTSUPP); ! 246: } ! 247: release: ! 248: if (m != NULL) ! 249: m_freem(m); ! 250: ! 251: return (error); ! 252: } ! 253: ! 254: /* ! 255: * FUNCTION: esis_input ! 256: * ! 257: * PURPOSE: Process an incoming esis packet ! 258: * ! 259: * RETURNS: nothing ! 260: * ! 261: * SIDE EFFECTS: ! 262: * ! 263: * NOTES: ! 264: */ ! 265: esis_input(m0, shp) ! 266: struct mbuf *m0; /* ptr to first mbuf of pkt */ ! 267: struct snpa_hdr *shp; /* subnetwork header */ ! 268: { ! 269: register struct esis_fixed *pdu = mtod(m0, struct esis_fixed *); ! 270: register int type; ! 271: ! 272: /* ! 273: * check checksum if necessary ! 274: */ ! 275: if (ESIS_CKSUM_REQUIRED(pdu) && iso_check_csum(m0, (int)pdu->esis_hdr_len)) { ! 276: esis_stat.es_badcsum++; ! 277: goto bad; ! 278: } ! 279: ! 280: /* check version */ ! 281: if (pdu->esis_vers != ESIS_VERSION) { ! 282: esis_stat.es_badvers++; ! 283: goto bad; ! 284: } ! 285: type = pdu->esis_type & 0x1f; ! 286: switch (type) { ! 287: case ESIS_ESH: ! 288: esis_eshinput(m0, shp); ! 289: break; ! 290: ! 291: case ESIS_ISH: ! 292: esis_ishinput(m0, shp); ! 293: break; ! 294: ! 295: case ESIS_RD: ! 296: esis_rdinput(m0, shp); ! 297: break; ! 298: ! 299: default: ! 300: esis_stat.es_badtype++; ! 301: } ! 302: ! 303: bad: ! 304: if (esis_pcb.rcb_next != &esis_pcb) ! 305: isis_input(m0, shp); ! 306: else ! 307: m_freem(m0); ! 308: } ! 309: ! 310: /* ! 311: * FUNCTION: esis_rdoutput ! 312: * ! 313: * PURPOSE: Transmit a redirect pdu ! 314: * ! 315: * RETURNS: nothing ! 316: * ! 317: * SIDE EFFECTS: ! 318: * ! 319: * NOTES: Assumes there is enough space for fixed part of header, ! 320: * DA, BSNPA and NET in first mbuf. ! 321: */ ! 322: esis_rdoutput(inbound_shp, inbound_m, inbound_oidx, rd_dstnsap, rt) ! 323: struct snpa_hdr *inbound_shp; /* snpa hdr from incoming packet */ ! 324: struct mbuf *inbound_m; /* incoming pkt itself */ ! 325: struct clnp_optidx *inbound_oidx; /* clnp options assoc with incoming pkt */ ! 326: struct iso_addr *rd_dstnsap; /* ultimate destination of pkt */ ! 327: struct rtentry *rt; /* snpa cache info regarding next hop of ! 328: pkt */ ! 329: { ! 330: struct mbuf *m, *m0; ! 331: caddr_t cp; ! 332: struct esis_fixed *pdu; ! 333: int len, total_len = 0; ! 334: struct sockaddr_iso siso; ! 335: struct ifnet *ifp = inbound_shp->snh_ifp; ! 336: struct sockaddr_dl *sdl; ! 337: struct iso_addr *rd_gwnsap; ! 338: ! 339: if (rt->rt_flags & RTF_GATEWAY) { ! 340: rd_gwnsap = &((struct sockaddr_iso *)rt->rt_gateway)->siso_addr; ! 341: rt = rtalloc1(rt->rt_gateway, 0); ! 342: } else ! 343: rd_gwnsap = &((struct sockaddr_iso *)rt_key(rt))->siso_addr; ! 344: if (rt == 0 || (sdl = (struct sockaddr_dl *)rt->rt_gateway) == 0 || ! 345: sdl->sdl_family != AF_LINK) { ! 346: /* maybe we should have a function that you ! 347: could put in the iso_ifaddr structure ! 348: which could translate iso_addrs into snpa's ! 349: where there is a known mapping for that address type */ ! 350: esis_stat.es_badtype++; ! 351: return; ! 352: } ! 353: esis_stat.es_rdsent++; ! 354: IFDEBUG(D_ESISOUTPUT) ! 355: printf("esis_rdoutput: ifp x%x (%s%d), ht %d, m x%x, oidx x%x\n", ! 356: ifp, ifp->if_name, ifp->if_unit, esis_holding_time, inbound_m, ! 357: inbound_oidx); ! 358: printf("\tdestination: %s\n", clnp_iso_addrp(rd_dstnsap)); ! 359: printf("\tredirected toward:%s\n", clnp_iso_addrp(rd_gwnsap)); ! 360: ENDDEBUG ! 361: ! 362: if ((m0 = m = m_gethdr(M_DONTWAIT, MT_HEADER)) == NULL) { ! 363: esis_stat.es_nomem++; ! 364: return; ! 365: } ! 366: bzero(mtod(m, caddr_t), MHLEN); ! 367: ! 368: pdu = mtod(m, struct esis_fixed *); ! 369: cp = (caddr_t)(pdu + 1); /*pointer arith.; 1st byte after header */ ! 370: len = sizeof(struct esis_fixed); ! 371: ! 372: /* ! 373: * Build fixed part of header ! 374: */ ! 375: pdu->esis_proto_id = ISO9542_ESIS; ! 376: pdu->esis_vers = ESIS_VERSION; ! 377: pdu->esis_type = ESIS_RD; ! 378: HTOC(pdu->esis_ht_msb, pdu->esis_ht_lsb, esis_holding_time); ! 379: ! 380: /* Insert destination address */ ! 381: (void) esis_insert_addr(&cp, &len, rd_dstnsap, m, 0); ! 382: ! 383: /* Insert the snpa of better next hop */ ! 384: *cp++ = sdl->sdl_alen; ! 385: bcopy(LLADDR(sdl), cp, sdl->sdl_alen); ! 386: cp += sdl->sdl_alen; ! 387: len += (sdl->sdl_alen + 1); ! 388: ! 389: /* ! 390: * If the next hop is not the destination, then it ought to be ! 391: * an IS and it should be inserted next. Else, set the ! 392: * NETL to 0 ! 393: */ ! 394: /* PHASE2 use mask from ifp of outgoing interface */ ! 395: if (!iso_addrmatch1(rd_dstnsap, rd_gwnsap)) { ! 396: /* this should not happen: ! 397: if ((nhop_sc->sc_flags & SNPA_IS) == 0) { ! 398: printf("esis_rdoutput: next hop is not dst and not an IS\n"); ! 399: m_freem(m0); ! 400: return; ! 401: } */ ! 402: (void) esis_insert_addr(&cp, &len, rd_gwnsap, m, 0); ! 403: } else { ! 404: *cp++ = 0; /* NETL */ ! 405: len++; ! 406: } ! 407: m->m_len = len; ! 408: ! 409: /* ! 410: * PHASE2 ! 411: * If redirect is to an IS, add an address mask. The mask to be ! 412: * used should be the mask present in the routing entry used to ! 413: * forward the original data packet. ! 414: */ ! 415: ! 416: /* ! 417: * Copy Qos, priority, or security options present in original npdu ! 418: */ ! 419: if (inbound_oidx) { ! 420: /* THIS CODE IS CURRENTLY (mostly) UNTESTED */ ! 421: int optlen = 0; ! 422: if (inbound_oidx->cni_qos_formatp) ! 423: optlen += (inbound_oidx->cni_qos_len + 2); ! 424: if (inbound_oidx->cni_priorp) /* priority option is 1 byte long */ ! 425: optlen += 3; ! 426: if (inbound_oidx->cni_securep) ! 427: optlen += (inbound_oidx->cni_secure_len + 2); ! 428: if (M_TRAILINGSPACE(m) < optlen) { ! 429: EXTEND_PACKET(m, m0, cp); ! 430: m->m_len = 0; ! 431: /* assumes MLEN > optlen */ ! 432: } ! 433: /* assume MLEN-len > optlen */ ! 434: /* ! 435: * When copying options, copy from ptr - 2 in order to grab ! 436: * the option code and length ! 437: */ ! 438: if (inbound_oidx->cni_qos_formatp) { ! 439: bcopy(mtod(inbound_m, caddr_t) + inbound_oidx->cni_qos_formatp - 2, ! 440: cp, (unsigned)(inbound_oidx->cni_qos_len + 2)); ! 441: cp += inbound_oidx->cni_qos_len + 2; ! 442: } ! 443: if (inbound_oidx->cni_priorp) { ! 444: bcopy(mtod(inbound_m, caddr_t) + inbound_oidx->cni_priorp - 2, ! 445: cp, 3); ! 446: cp += 3; ! 447: } ! 448: if (inbound_oidx->cni_securep) { ! 449: bcopy(mtod(inbound_m, caddr_t) + inbound_oidx->cni_securep - 2, cp, ! 450: (unsigned)(inbound_oidx->cni_secure_len + 2)); ! 451: cp += inbound_oidx->cni_secure_len + 2; ! 452: } ! 453: m->m_len += optlen; ! 454: len += optlen; ! 455: } ! 456: ! 457: pdu->esis_hdr_len = m0->m_pkthdr.len = len; ! 458: iso_gen_csum(m0, ESIS_CKSUM_OFF, (int)pdu->esis_hdr_len); ! 459: ! 460: bzero((caddr_t)&siso, sizeof(siso)); ! 461: siso.siso_family = AF_ISO; ! 462: siso.siso_data[0] = AFI_SNA; ! 463: siso.siso_nlen = 6 + 1; /* should be taken from snpa_hdr */ ! 464: /* +1 is for AFI */ ! 465: bcopy(inbound_shp->snh_shost, siso.siso_data + 1, 6); ! 466: (ifp->if_output)(ifp, m0, (struct sockaddr *)&siso, 0); ! 467: } ! 468: ! 469: /* ! 470: * FUNCTION: esis_insert_addr ! 471: * ! 472: * PURPOSE: Insert an iso_addr into a buffer ! 473: * ! 474: * RETURNS: true if buffer was big enough, else false ! 475: * ! 476: * SIDE EFFECTS: Increment buf & len according to size of iso_addr ! 477: * ! 478: * NOTES: Plus 1 here is for length byte ! 479: */ ! 480: esis_insert_addr(buf, len, isoa, m, nsellen) ! 481: register caddr_t *buf; /* ptr to buffer to put address into */ ! 482: int *len; /* ptr to length of buffer so far */ ! 483: register struct iso_addr *isoa; /* ptr to address */ ! 484: register struct mbuf *m; /* determine if there remains space */ ! 485: int nsellen; ! 486: { ! 487: register int newlen, result = 0; ! 488: ! 489: isoa->isoa_len -= nsellen; ! 490: newlen = isoa->isoa_len + 1; ! 491: if (newlen <= M_TRAILINGSPACE(m)) { ! 492: bcopy((caddr_t)isoa, *buf, newlen); ! 493: *len += newlen; ! 494: *buf += newlen; ! 495: m->m_len += newlen; ! 496: result = 1; ! 497: } ! 498: isoa->isoa_len += nsellen; ! 499: return (result); ! 500: } ! 501: ! 502: #define ESIS_EXTRACT_ADDR(d, b) { d = (struct iso_addr *)(b); b += (1 + *b); \ ! 503: if (b > buflim) {esis_stat.es_toosmall++; goto bad;}} ! 504: #define ESIS_NEXT_OPTION(b) { b += (2 + b[1]); \ ! 505: if (b > buflim) {esis_stat.es_toosmall++; goto bad;}} ! 506: int ESHonly = 0; ! 507: /* ! 508: ! 509: /* ! 510: * FUNCTION: esis_eshinput ! 511: * ! 512: * PURPOSE: Process an incoming ESH pdu ! 513: * ! 514: * RETURNS: nothing ! 515: * ! 516: * SIDE EFFECTS: ! 517: * ! 518: * NOTES: ! 519: */ ! 520: esis_eshinput(m, shp) ! 521: struct mbuf *m; /* esh pdu */ ! 522: struct snpa_hdr *shp; /* subnetwork header */ ! 523: { ! 524: struct esis_fixed *pdu = mtod(m, struct esis_fixed *); ! 525: u_short ht; /* holding time */ ! 526: struct iso_addr *nsap; ! 527: int naddr; ! 528: u_char *buf = (u_char *)(pdu + 1); ! 529: u_char *buflim = pdu->esis_hdr_len + (u_char *)pdu; ! 530: int new_entry = 0; ! 531: ! 532: esis_stat.es_eshrcvd++; ! 533: ! 534: CTOH(pdu->esis_ht_msb, pdu->esis_ht_lsb, ht); ! 535: ! 536: naddr = *buf++; ! 537: if (buf >= buflim) ! 538: goto bad; ! 539: if (naddr == 1) { ! 540: ESIS_EXTRACT_ADDR(nsap, buf); ! 541: new_entry = snpac_add(shp->snh_ifp, ! 542: nsap, shp->snh_shost, SNPA_ES, ht, 0); ! 543: } else { ! 544: int nsellength = 0, nlen = 0; ! 545: { ! 546: /* See if we want to compress out multiple nsaps differing ! 547: only by nsel */ ! 548: register struct ifaddr *ifa = shp->snh_ifp->if_addrlist; ! 549: for (; ifa; ifa = ifa->ifa_next) ! 550: if (ifa->ifa_addr->sa_family == AF_ISO) { ! 551: nsellength = ((struct iso_ifaddr *)ifa)->ia_addr.siso_tlen; ! 552: break; ! 553: } ! 554: } ! 555: IFDEBUG(D_ESISINPUT) ! 556: printf("esis_eshinput: esh: ht %d, naddr %d nsellength %d\n", ! 557: ht, naddr, nsellength); ! 558: ENDDEBUG ! 559: while (naddr-- > 0) { ! 560: struct iso_addr *nsap2; u_char *buf2; ! 561: ESIS_EXTRACT_ADDR(nsap, buf); ! 562: /* see if there is at least one more nsap in ESH differing ! 563: only by nsel */ ! 564: if (nsellength != 0) for (buf2 = buf; buf2 < buflim;) { ! 565: ESIS_EXTRACT_ADDR(nsap2, buf2); ! 566: IFDEBUG(D_ESISINPUT) ! 567: printf("esis_eshinput: comparing %s ", ! 568: clnp_iso_addrp(nsap)); ! 569: printf("and %s\n", clnp_iso_addrp(nsap2)); ! 570: ENDDEBUG ! 571: if (Bcmp(nsap->isoa_genaddr, nsap2->isoa_genaddr, ! 572: nsap->isoa_len - nsellength) == 0) { ! 573: nlen = nsellength; ! 574: break; ! 575: } ! 576: } ! 577: new_entry |= snpac_add(shp->snh_ifp, ! 578: nsap, shp->snh_shost, SNPA_ES, ht, nlen); ! 579: nlen = 0; ! 580: } ! 581: } ! 582: IFDEBUG(D_ESISINPUT) ! 583: printf("esis_eshinput: nsap %s is %s\n", ! 584: clnp_iso_addrp(nsap), new_entry ? "new" : "old"); ! 585: ENDDEBUG ! 586: if (new_entry && (iso_systype & SNPA_IS)) ! 587: esis_shoutput(shp->snh_ifp, ESIS_ISH, esis_holding_time, ! 588: shp->snh_shost, 6, (struct iso_addr *)0); ! 589: bad: ! 590: return; ! 591: } ! 592: ! 593: /* ! 594: * FUNCTION: esis_ishinput ! 595: * ! 596: * PURPOSE: process an incoming ISH pdu ! 597: * ! 598: * RETURNS: ! 599: * ! 600: * SIDE EFFECTS: ! 601: * ! 602: * NOTES: ! 603: */ ! 604: esis_ishinput(m, shp) ! 605: struct mbuf *m; /* esh pdu */ ! 606: struct snpa_hdr *shp; /* subnetwork header */ ! 607: { ! 608: struct esis_fixed *pdu = mtod(m, struct esis_fixed *); ! 609: u_short ht, newct; /* holding time */ ! 610: struct iso_addr *nsap; /* Network Entity Title */ ! 611: register u_char *buf = (u_char *) (pdu + 1); ! 612: register u_char *buflim = pdu->esis_hdr_len + (u_char *)pdu; ! 613: int new_entry; ! 614: ! 615: esis_stat.es_ishrcvd++; ! 616: CTOH(pdu->esis_ht_msb, pdu->esis_ht_lsb, ht); ! 617: ! 618: IFDEBUG(D_ESISINPUT) ! 619: printf("esis_ishinput: ish: ht %d\n", ht); ! 620: ENDDEBUG ! 621: if (ESHonly) ! 622: goto bad; ! 623: ! 624: ESIS_EXTRACT_ADDR(nsap, buf); ! 625: ! 626: while (buf < buflim) { ! 627: switch (*buf) { ! 628: case ESISOVAL_ESCT: ! 629: if (iso_systype & SNPA_IS) ! 630: break; ! 631: if (buf[1] != 2) ! 632: goto bad; ! 633: CTOH(buf[2], buf[3], newct); ! 634: if (esis_config_time != newct) { ! 635: untimeout(esis_config,0); ! 636: esis_config_time = newct; ! 637: esis_config(); ! 638: } ! 639: break; ! 640: ! 641: default: ! 642: printf("Unknown ISH option: %x\n", *buf); ! 643: } ! 644: ESIS_NEXT_OPTION(buf); ! 645: } ! 646: new_entry = snpac_add(shp->snh_ifp, nsap, shp->snh_shost, SNPA_IS, ht, 0); ! 647: IFDEBUG(D_ESISINPUT) ! 648: printf("esis_ishinput: nsap %s is %s\n", ! 649: clnp_iso_addrp(nsap), new_entry ? "new" : "old"); ! 650: ENDDEBUG ! 651: ! 652: if (new_entry) ! 653: esis_shoutput(shp->snh_ifp, ! 654: iso_systype & SNPA_ES ? ESIS_ESH : ESIS_ISH, ! 655: esis_holding_time, shp->snh_shost, 6, (struct iso_addr *)0); ! 656: bad: ! 657: return; ! 658: } ! 659: ! 660: /* ! 661: * FUNCTION: esis_rdinput ! 662: * ! 663: * PURPOSE: Process an incoming RD pdu ! 664: * ! 665: * RETURNS: ! 666: * ! 667: * SIDE EFFECTS: ! 668: * ! 669: * NOTES: ! 670: */ ! 671: esis_rdinput(m0, shp) ! 672: struct mbuf *m0; /* esh pdu */ ! 673: struct snpa_hdr *shp; /* subnetwork header */ ! 674: { ! 675: struct esis_fixed *pdu = mtod(m0, struct esis_fixed *); ! 676: u_short ht; /* holding time */ ! 677: struct iso_addr *da, *net = 0, *netmask = 0, *snpamask = 0; ! 678: register struct iso_addr *bsnpa; ! 679: register u_char *buf = (u_char *)(pdu + 1); ! 680: register u_char *buflim = pdu->esis_hdr_len + (u_char *)pdu; ! 681: ! 682: esis_stat.es_rdrcvd++; ! 683: ! 684: /* intermediate systems ignore redirects */ ! 685: if (iso_systype & SNPA_IS) ! 686: return; ! 687: if (ESHonly) ! 688: return; ! 689: ! 690: CTOH(pdu->esis_ht_msb, pdu->esis_ht_lsb, ht); ! 691: if (buf >= buflim) ! 692: return; ! 693: ! 694: /* Extract DA */ ! 695: ESIS_EXTRACT_ADDR(da, buf); ! 696: ! 697: /* Extract better snpa */ ! 698: ESIS_EXTRACT_ADDR(bsnpa, buf); ! 699: ! 700: /* Extract NET if present */ ! 701: if (buf < buflim) { ! 702: if (*buf == 0) ! 703: buf++; /* no NET present, skip NETL anyway */ ! 704: else ! 705: ESIS_EXTRACT_ADDR(net, buf); ! 706: } ! 707: ! 708: /* process options */ ! 709: while (buf < buflim) { ! 710: switch (*buf) { ! 711: case ESISOVAL_SNPAMASK: ! 712: if (snpamask) /* duplicate */ ! 713: return; ! 714: snpamask = (struct iso_addr *)(buf + 1); ! 715: break; ! 716: ! 717: case ESISOVAL_NETMASK: ! 718: if (netmask) /* duplicate */ ! 719: return; ! 720: netmask = (struct iso_addr *)(buf + 1); ! 721: break; ! 722: ! 723: default: ! 724: printf("Unknown option in ESIS RD (0x%x)\n", buf[-1]); ! 725: } ! 726: ESIS_NEXT_OPTION(buf); ! 727: } ! 728: ! 729: IFDEBUG(D_ESISINPUT) ! 730: printf("esis_rdinput: rd: ht %d, da %s\n", ht, clnp_iso_addrp(da)); ! 731: if (net) ! 732: printf("\t: net %s\n", clnp_iso_addrp(net)); ! 733: ENDDEBUG ! 734: /* ! 735: * If netl is zero, then redirect is to an ES. We need to add an entry ! 736: * to the snpa cache for (destination, better snpa). ! 737: * If netl is not zero, then the redirect is to an IS. In this ! 738: * case, add an snpa cache entry for (net, better snpa). ! 739: * ! 740: * If the redirect is to an IS, add a route entry towards that ! 741: * IS. ! 742: */ ! 743: if (net == 0 || net->isoa_len == 0 || snpamask) { ! 744: /* redirect to an ES */ ! 745: snpac_add(shp->snh_ifp, da, ! 746: bsnpa->isoa_genaddr, SNPA_ES, ht, 0); ! 747: } else { ! 748: snpac_add(shp->snh_ifp, net, ! 749: bsnpa->isoa_genaddr, SNPA_IS, ht, 0); ! 750: snpac_addrt(shp->snh_ifp, da, net, netmask); ! 751: } ! 752: bad: ; /* Needed by ESIS_NEXT_OPTION */ ! 753: } ! 754: ! 755: /* ! 756: * FUNCTION: esis_config ! 757: * ! 758: * PURPOSE: Report configuration ! 759: * ! 760: * RETURNS: ! 761: * ! 762: * SIDE EFFECTS: ! 763: * ! 764: * NOTES: Called every esis_config_time seconds ! 765: */ ! 766: void ! 767: esis_config() ! 768: { ! 769: register struct ifnet *ifp; ! 770: ! 771: timeout(esis_config, (caddr_t)0, hz * esis_config_time); ! 772: ! 773: /* ! 774: * Report configuration for each interface that ! 775: * - is UP ! 776: * - has BROADCAST capability ! 777: * - has an ISO address ! 778: */ ! 779: /* Todo: a better way would be to construct the esh or ish ! 780: * once and copy it out for all devices, possibly calling ! 781: * a method in the iso_ifaddr structure to encapsulate and ! 782: * transmit it. This could work to advantage for non-broadcast media ! 783: */ ! 784: ! 785: for (ifp = ifnet; ifp; ifp = ifp->if_next) { ! 786: if ((ifp->if_flags & IFF_UP) && ! 787: (ifp->if_flags & IFF_BROADCAST)) { ! 788: /* search for an ISO address family */ ! 789: struct ifaddr *ia; ! 790: ! 791: for (ia = ifp->if_addrlist; ia; ia = ia->ifa_next) { ! 792: if (ia->ifa_addr->sa_family == AF_ISO) { ! 793: esis_shoutput(ifp, ! 794: iso_systype & SNPA_ES ? ESIS_ESH : ESIS_ISH, ! 795: esis_holding_time, ! 796: (caddr_t)(iso_systype & SNPA_ES ? all_is_snpa : ! 797: all_es_snpa), 6, (struct iso_addr *)0); ! 798: break; ! 799: } ! 800: } ! 801: } ! 802: } ! 803: } ! 804: ! 805: /* ! 806: * FUNCTION: esis_shoutput ! 807: * ! 808: * PURPOSE: Transmit an esh or ish pdu ! 809: * ! 810: * RETURNS: nothing ! 811: * ! 812: * SIDE EFFECTS: ! 813: * ! 814: * NOTES: ! 815: */ ! 816: esis_shoutput(ifp, type, ht, sn_addr, sn_len, isoa) ! 817: struct ifnet *ifp; ! 818: int type; ! 819: short ht; ! 820: caddr_t sn_addr; ! 821: int sn_len; ! 822: struct iso_addr *isoa; ! 823: { ! 824: struct mbuf *m, *m0; ! 825: caddr_t cp, naddrp; ! 826: int naddr = 0; ! 827: struct esis_fixed *pdu; ! 828: struct iso_ifaddr *ia; ! 829: int len; ! 830: struct sockaddr_iso siso; ! 831: ! 832: if (type == ESIS_ESH) ! 833: esis_stat.es_eshsent++; ! 834: else if (type == ESIS_ISH) ! 835: esis_stat.es_ishsent++; ! 836: else { ! 837: printf("esis_shoutput: bad pdu type\n"); ! 838: return; ! 839: } ! 840: ! 841: IFDEBUG(D_ESISOUTPUT) ! 842: int i; ! 843: printf("esis_shoutput: ifp x%x (%s%d), %s, ht %d, to: [%d] ", ! 844: ifp, ifp->if_name, ifp->if_unit, type == ESIS_ESH ? "esh" : "ish", ! 845: ht, sn_len); ! 846: for (i=0; i<sn_len; i++) ! 847: printf("%x%c", *(sn_addr+i), i < (sn_len-1) ? ':' : ' '); ! 848: printf("\n"); ! 849: ENDDEBUG ! 850: ! 851: if ((m0 = m = m_gethdr(M_DONTWAIT, MT_HEADER)) == NULL) { ! 852: esis_stat.es_nomem++; ! 853: return; ! 854: } ! 855: bzero(mtod(m, caddr_t), MHLEN); ! 856: ! 857: pdu = mtod(m, struct esis_fixed *); ! 858: naddrp = cp = (caddr_t)(pdu + 1); ! 859: len = sizeof(struct esis_fixed); ! 860: ! 861: /* ! 862: * Build fixed part of header ! 863: */ ! 864: pdu->esis_proto_id = ISO9542_ESIS; ! 865: pdu->esis_vers = ESIS_VERSION; ! 866: pdu->esis_type = type; ! 867: HTOC(pdu->esis_ht_msb, pdu->esis_ht_lsb, ht); ! 868: ! 869: if (type == ESIS_ESH) { ! 870: cp++; ! 871: len++; ! 872: } ! 873: ! 874: m->m_len = len; ! 875: if (isoa) { ! 876: /* ! 877: * Here we are responding to a clnp packet sent to an NSAP ! 878: * that is ours which was sent to the MAC addr all_es's. ! 879: * It is possible that we did not specifically advertise this ! 880: * NSAP, even though it is ours, so we will respond ! 881: * directly to the sender that we are here. If we do have ! 882: * multiple NSEL's we'll tack them on so he can compress them out. ! 883: */ ! 884: (void) esis_insert_addr(&cp, &len, isoa, m, 0); ! 885: naddr = 1; ! 886: } ! 887: for (ia = iso_ifaddr; ia; ia = ia->ia_next) { ! 888: int nsellen = (type == ESIS_ISH ? ia->ia_addr.siso_tlen : 0); ! 889: int n = ia->ia_addr.siso_nlen; ! 890: register struct iso_ifaddr *ia2; ! 891: ! 892: if (type == ESIS_ISH && naddr > 0) ! 893: break; ! 894: for (ia2 = iso_ifaddr; ia2 != ia; ia2 = ia2->ia_next) ! 895: if (Bcmp(ia->ia_addr.siso_data, ia2->ia_addr.siso_data, n) == 0) ! 896: break; ! 897: if (ia2 != ia) ! 898: continue; /* Means we have previously copied this nsap */ ! 899: if (isoa && Bcmp(ia->ia_addr.siso_data, isoa->isoa_genaddr, n) == 0) { ! 900: isoa = 0; ! 901: continue; /* Ditto */ ! 902: } ! 903: IFDEBUG(D_ESISOUTPUT) ! 904: printf("esis_shoutput: adding NSAP %s\n", ! 905: clnp_iso_addrp(&ia->ia_addr.siso_addr)); ! 906: ENDDEBUG ! 907: if (!esis_insert_addr(&cp, &len, ! 908: &ia->ia_addr.siso_addr, m, nsellen)) { ! 909: EXTEND_PACKET(m, m0, cp); ! 910: (void) esis_insert_addr(&cp, &len, &ia->ia_addr.siso_addr, m, ! 911: nsellen); ! 912: } ! 913: naddr++; ! 914: } ! 915: ! 916: if (type == ESIS_ESH) ! 917: *naddrp = naddr; ! 918: else { ! 919: /* add suggested es config timer option to ISH */ ! 920: if (M_TRAILINGSPACE(m) < 4) { ! 921: printf("esis_shoutput: extending packet\n"); ! 922: EXTEND_PACKET(m, m0, cp); ! 923: } ! 924: *cp++ = ESISOVAL_ESCT; ! 925: *cp++ = 2; ! 926: HTOC(*cp, *(cp+1), esis_esconfig_time); ! 927: len += 4; ! 928: m->m_len += 4; ! 929: IFDEBUG(D_ESISOUTPUT) ! 930: printf("m0 0x%x, m 0x%x, data 0x%x, len %d, cp 0x%x\n", ! 931: m0, m, m->m_data, m->m_len, cp); ! 932: ENDDEBUG ! 933: } ! 934: ! 935: m0->m_pkthdr.len = len; ! 936: pdu->esis_hdr_len = len; ! 937: iso_gen_csum(m0, ESIS_CKSUM_OFF, (int)pdu->esis_hdr_len); ! 938: ! 939: bzero((caddr_t)&siso, sizeof(siso)); ! 940: siso.siso_family = AF_ISO; ! 941: siso.siso_data[0] = AFI_SNA; ! 942: siso.siso_nlen = sn_len + 1; ! 943: bcopy(sn_addr, siso.siso_data + 1, (unsigned)sn_len); ! 944: (ifp->if_output)(ifp, m0, (struct sockaddr *)&siso, 0); ! 945: } ! 946: ! 947: /* ! 948: * FUNCTION: isis_input ! 949: * ! 950: * PURPOSE: Process an incoming isis packet ! 951: * ! 952: * RETURNS: nothing ! 953: * ! 954: * SIDE EFFECTS: ! 955: * ! 956: * NOTES: ! 957: */ ! 958: isis_input(m0, shp) ! 959: struct mbuf *m0; /* ptr to first mbuf of pkt */ ! 960: struct snpa_hdr *shp; /* subnetwork header */ ! 961: { ! 962: register int type; ! 963: register struct rawcb *rp, *first_rp = 0; ! 964: struct ifnet *ifp = shp->snh_ifp; ! 965: char workbuf[16]; ! 966: struct mbuf *mm; ! 967: ! 968: IFDEBUG(D_ISISINPUT) ! 969: int i; ! 970: ! 971: printf("isis_input: pkt on ifp x%x (%s%d): from:", ifp, ! 972: ifp->if_name, ifp->if_unit); ! 973: for (i=0; i<6; i++) ! 974: printf("%x%c", shp->snh_shost[i]&0xff, (i<5) ? ':' : ' '); ! 975: printf(" to:"); ! 976: for (i=0; i<6; i++) ! 977: printf("%x%c", shp->snh_dhost[i]&0xff, (i<5) ? ':' : ' '); ! 978: printf("\n"); ! 979: ENDDEBUG ! 980: esis_dl.sdl_alen = ifp->if_addrlen; ! 981: esis_dl.sdl_index = ifp->if_index; ! 982: bcopy(shp->snh_shost, (caddr_t)esis_dl.sdl_data, esis_dl.sdl_alen); ! 983: for (rp = esis_pcb.rcb_next; rp != &esis_pcb; rp = rp->rcb_next) { ! 984: if (first_rp == 0) { ! 985: first_rp = rp; ! 986: continue; ! 987: } ! 988: if (mm = m_copy(m0, 0, M_COPYALL)) { /*can't block at interrupt level */ ! 989: if (sbappendaddr(&rp->rcb_socket->so_rcv, ! 990: &esis_dl, mm, (struct mbuf *)0) != 0) { ! 991: sorwakeup(rp->rcb_socket); ! 992: } else { ! 993: IFDEBUG(D_ISISINPUT) ! 994: printf("Error in sbappenaddr, mm = 0x%x\n", mm); ! 995: ENDDEBUG ! 996: m_freem(mm); ! 997: } ! 998: } ! 999: } ! 1000: if (first_rp && sbappendaddr(&first_rp->rcb_socket->so_rcv, ! 1001: &esis_dl, m0, (struct mbuf *)0) != 0) { ! 1002: sorwakeup(first_rp->rcb_socket); ! 1003: return; ! 1004: } ! 1005: m_freem(m0); ! 1006: } ! 1007: ! 1008: isis_output(sdl, m) ! 1009: register struct sockaddr_dl *sdl; ! 1010: struct mbuf *m; ! 1011: { ! 1012: register struct ifnet *ifp; ! 1013: struct ifaddr *ifa, *ifa_ifwithnet(); ! 1014: struct sockaddr_iso siso; ! 1015: int error = 0; ! 1016: unsigned sn_len; ! 1017: ! 1018: ifa = ifa_ifwithnet((struct sockaddr *)sdl); /* get ifp from sdl */ ! 1019: if (ifa == 0) { ! 1020: IFDEBUG(D_ISISOUTPUT) ! 1021: printf("isis_output: interface not found\n"); ! 1022: ENDDEBUG ! 1023: error = EINVAL; ! 1024: goto release; ! 1025: } ! 1026: ifp = ifa->ifa_ifp; ! 1027: sn_len = sdl->sdl_alen; ! 1028: IFDEBUG(D_ISISOUTPUT) ! 1029: u_char *cp = (u_char *)LLADDR(sdl), *cplim = cp + sn_len; ! 1030: printf("isis_output: ifp 0x%x (%s%d), to: ", ! 1031: ifp, ifp->if_name, ifp->if_unit); ! 1032: while (cp < cplim) { ! 1033: printf("%x", *cp++); ! 1034: printf("%c", (cp < cplim) ? ':' : ' '); ! 1035: } ! 1036: printf("\n"); ! 1037: ENDDEBUG ! 1038: bzero((caddr_t)&siso, sizeof(siso)); ! 1039: siso.siso_family = AF_ISO; /* This convention may be useful for X.25 */ ! 1040: siso.siso_data[0] = AFI_SNA; ! 1041: siso.siso_nlen = sn_len + 1; ! 1042: bcopy(LLADDR(sdl), siso.siso_data + 1, sn_len); ! 1043: error = (ifp->if_output)(ifp, m, (struct sockaddr *)&siso, 0); ! 1044: if (error) { ! 1045: IFDEBUG(D_ISISOUTPUT) ! 1046: printf("isis_output: error from ether_output is %d\n", error); ! 1047: ENDDEBUG ! 1048: } ! 1049: return (error); ! 1050: ! 1051: release: ! 1052: if (m != NULL) ! 1053: m_freem(m); ! 1054: return(error); ! 1055: } ! 1056: ! 1057: ! 1058: /* ! 1059: * FUNCTION: esis_ctlinput ! 1060: * ! 1061: * PURPOSE: Handle the PRC_IFDOWN transition ! 1062: * ! 1063: * RETURNS: nothing ! 1064: * ! 1065: * SIDE EFFECTS: ! 1066: * ! 1067: * NOTES: Calls snpac_flush for interface specified. ! 1068: * The loop through iso_ifaddr is stupid because ! 1069: * back in if_down, we knew the ifp... ! 1070: */ ! 1071: esis_ctlinput(req, siso) ! 1072: int req; /* request: we handle only PRC_IFDOWN */ ! 1073: struct sockaddr_iso *siso; /* address of ifp */ ! 1074: { ! 1075: register struct iso_ifaddr *ia; /* scan through interface addresses */ ! 1076: ! 1077: if (req == PRC_IFDOWN) ! 1078: for (ia = iso_ifaddr; ia; ia = ia->ia_next) { ! 1079: if (iso_addrmatch(IA_SIS(ia), siso)) ! 1080: snpac_flushifp(ia->ia_ifp); ! 1081: } ! 1082: } ! 1083: ! 1084: #endif /* ISO */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.