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