![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to if_imp.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Net/2] / Net2 / netimp|
Return to if_imp.c CVS log | Up to [Net/2] / Net2 / netimp |
1.1 ! root 1: /* ! 2: * Copyright (c) 1982, 1986, 1988 Regents of the University of California. ! 3: * All rights reserved. ! 4: * ! 5: * Redistribution and use in source and binary forms, with or without ! 6: * modification, are permitted provided that the following conditions ! 7: * are met: ! 8: * 1. Redistributions of source code must retain the above copyright ! 9: * notice, this list of conditions and the following disclaimer. ! 10: * 2. Redistributions in binary form must reproduce the above copyright ! 11: * notice, this list of conditions and the following disclaimer in the ! 12: * documentation and/or other materials provided with the distribution. ! 13: * 3. All advertising materials mentioning features or use of this software ! 14: * must display the following acknowledgement: ! 15: * This product includes software developed by the University of ! 16: * California, Berkeley and its contributors. ! 17: * 4. Neither the name of the University nor the names of its contributors ! 18: * may be used to endorse or promote products derived from this software ! 19: * without specific prior written permission. ! 20: * ! 21: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ! 22: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ! 23: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ! 24: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE ! 25: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ! 26: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ! 27: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ! 28: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ! 29: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ! 30: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ! 31: * SUCH DAMAGE. ! 32: * ! 33: * @(#)if_imp.c 7.13 (Berkeley) 6/28/90 ! 34: */ ! 35: ! 36: #include "imp.h" ! 37: #if NIMP > 0 ! 38: /* ! 39: * ARPANET IMP (PSN) interface driver. ! 40: * ! 41: * The IMP-host protocol (AHIP) is handled here, leaving ! 42: * hardware specifics to the lower level interface driver. ! 43: */ ! 44: #include "param.h" ! 45: #include "systm.h" ! 46: #include "mbuf.h" ! 47: #include "buf.h" ! 48: #include "protosw.h" ! 49: #include "socket.h" ! 50: #include "time.h" ! 51: #include "kernel.h" ! 52: #include "errno.h" ! 53: #include "ioctl.h" ! 54: #include "syslog.h" ! 55: ! 56: #include "machine/mtpr.h" ! 57: ! 58: #include "../net/if.h" ! 59: #include "../net/netisr.h" ! 60: #include "../netinet/in.h" ! 61: #include "../netinet/in_systm.h" ! 62: #include "../netinet/in_var.h" ! 63: #include "../netinet/ip.h" ! 64: #include "../netinet/ip_var.h" ! 65: #define IMPMESSAGES ! 66: /* define IMPLEADERS here to get leader printing code */ ! 67: #include "if_imp.h" ! 68: #include "if_imphost.h" ! 69: ! 70: struct imp_softc imp_softc[NIMP]; ! 71: #ifndef lint ! 72: int nimp = NIMP; /* for netstat */ ! 73: #endif ! 74: struct ifqueue impintrq; ! 75: int impqmaxlen = IFQ_MAXLEN; ! 76: int imphqlen = 12 + IMP_MAXHOSTMSG; /* max packets to queue per host */ ! 77: ! 78: int imppri = LOG_ERR; ! 79: #ifdef IMPLEADERS ! 80: int impprintfs = 0; ! 81: #endif ! 82: #ifdef IMPINIT ! 83: int imptraceinit = 0; ! 84: #endif ! 85: ! 86: ! 87: #define HOSTDEADTIMER (30 * PR_SLOWHZ) /* How long to wait when down */ ! 88: ! 89: int impdown(), impinit(), impioctl(), impoutput(), imptimo(); ! 90: ! 91: /* ! 92: * IMP attach routine. Called from hardware device attach routine ! 93: * at configuration time with a pointer to the device structure. ! 94: * Sets up local state and returns pointer to base of ifnet+impcb ! 95: * structures. This is then used by the device's attach routine ! 96: * set up its back pointers. ! 97: */ ! 98: struct imp_softc * ! 99: impattach(hwname, hwunit, reset) ! 100: char *hwname; ! 101: int hwunit; ! 102: int (*reset)(); ! 103: { ! 104: struct imp_softc *sc; ! 105: register struct ifnet *ifp; ! 106: static int impunit; ! 107: ! 108: #ifdef lint ! 109: impintr(); ! 110: #endif ! 111: if (impunit >= NIMP) { ! 112: printf("imp%d: not configured\n", impunit++); ! 113: return (0); ! 114: } ! 115: sc = &imp_softc[impunit]; ! 116: ifp = &sc->imp_if; ! 117: sc->imp_cb.ic_hwname = hwname; ! 118: sc->imp_cb.ic_hwunit = hwunit; ! 119: ifp->if_unit = impunit; ! 120: ifp->if_name = "imp"; ! 121: ifp->if_mtu = IMPMTU - sizeof(struct imp_leader); ! 122: ifp->if_reset = reset; ! 123: ifp->if_init = impinit; ! 124: ifp->if_ioctl = impioctl; ! 125: ifp->if_output = impoutput; ! 126: ifp->if_watchdog = imptimo; ! 127: if_attach(ifp); ! 128: impunit++; ! 129: return (sc); ! 130: } ! 131: ! 132: /* ! 133: * IMP initialization routine: call hardware module to ! 134: * setup resources, init state and get ready for ! 135: * NOOPs the IMP should send us, and that we want to drop. ! 136: */ ! 137: impinit(unit) ! 138: int unit; ! 139: { ! 140: int s; ! 141: register struct imp_softc *sc = &imp_softc[unit]; ! 142: ! 143: if (sc->imp_if.if_addrlist == 0) ! 144: return; ! 145: s = splimp(); ! 146: #ifdef IMPINIT ! 147: if (imptraceinit) ! 148: log(imppri, "impinit\n"); ! 149: #endif ! 150: sc->imp_state = IMPS_WINIT; ! 151: if ((*sc->imp_cb.ic_init)(sc->imp_cb.ic_hwunit) == 0) ! 152: sc->imp_if.if_flags &= ~IFF_UP; ! 153: impintrq.ifq_maxlen = impqmaxlen; ! 154: splx(s); ! 155: } ! 156: ! 157: /* ! 158: * ARPAnet 1822/AHIP input routine. ! 159: * Called from hardware input interrupt routine to handle 1822 ! 160: * IMP-host messages. Data messages are passed to higher-level ! 161: * protocol processors on the basis of link number. ! 162: * Other type messages (control) are handled here. ! 163: */ ! 164: impinput(unit, m) ! 165: int unit; ! 166: register struct mbuf *m; ! 167: { ! 168: register struct control_leader *cp; ! 169: #define ip ((struct imp_leader *)cp) ! 170: register struct imp_softc *sc = &imp_softc[unit]; ! 171: struct ifnet *ifp; ! 172: register struct host *hp; ! 173: register struct ifqueue *inq; ! 174: struct sockaddr_in *sin; ! 175: int s; ! 176: ! 177: /* ! 178: * Pull the interface pointer out of the mbuf ! 179: * and save for later; adjust mbuf to look at rest of data. ! 180: */ ! 181: if ((m->m_flags && M_PKTHDR) == 0) ! 182: panic("No header in impinput"); ! 183: ifp = m->m_pkthdr.rcvif; ! 184: /* verify leader length. */ ! 185: if (m->m_len < sizeof(struct control_leader) && ! 186: (m = m_pullup(m, sizeof(struct control_leader))) == 0) ! 187: return; ! 188: cp = mtod(m, struct control_leader *); ! 189: if (cp->dl_mtype == IMPTYPE_DATA && ! 190: m->m_len < sizeof(struct imp_leader)) { ! 191: if ((m = m_pullup(m, sizeof(struct imp_leader))) == 0) ! 192: return; ! 193: cp = mtod(m, struct control_leader *); ! 194: } ! 195: #ifdef IMPLEADERS ! 196: if (impprintfs) ! 197: printleader("impinput", ip); ! 198: #endif ! 199: inq = &impintrq; ! 200: ! 201: /* check leader type */ ! 202: if (cp->dl_format != IMP_NFF) { ! 203: /* ! 204: * We get 1822L NOOPs and RESET ! 205: * at initialization. ! 206: */ ! 207: #ifdef IMPINIT ! 208: if (imptraceinit) ! 209: log(imppri, "input, format %x mtype %d\n", ! 210: cp->dl_format, cp->dl_mtype); ! 211: #endif ! 212: if (cp->dl_format != IMP_1822L_I2H || ! 213: (cp->dl_mtype != IMPTYPE_NOOP && ! 214: cp->dl_mtype != IMPTYPE_RESET)) { ! 215: sc->imp_garbage++; ! 216: sc->imp_if.if_collisions++; /* XXX */ ! 217: } ! 218: } else switch (cp->dl_mtype) { ! 219: ! 220: case IMPTYPE_DATA: ! 221: /* ! 222: * Data for a protocol. Dispatch to the appropriate ! 223: * protocol routine (running at software interrupt). ! 224: * If this isn't a raw interface, advance pointer ! 225: * into mbuf past leader. ! 226: */ ! 227: switch (cp->dl_link) { ! 228: ! 229: case IMPLINK_IP: ! 230: m->m_len -= sizeof(struct imp_leader); ! 231: if (m->m_flags & M_PKTHDR) ! 232: m->m_pkthdr.len -= sizeof(struct imp_leader); ! 233: m->m_data += sizeof(struct imp_leader); ! 234: schednetisr(NETISR_IP); ! 235: inq = &ipintrq; ! 236: break; ! 237: ! 238: default: ! 239: break; ! 240: } ! 241: break; ! 242: ! 243: /* ! 244: * IMP leader error. Reset the IMP and discard the packet. ! 245: */ ! 246: case IMPTYPE_BADLEADER: ! 247: /* ! 248: * According to 1822 document, this message ! 249: * will be generated in response to the ! 250: * first noop sent to the IMP after ! 251: * the host resets the IMP interface. ! 252: */ ! 253: #ifdef IMPINIT ! 254: if (imptraceinit) ! 255: log(imppri, "badleader\n"); ! 256: #endif ! 257: if (sc->imp_state != IMPS_INIT) { ! 258: impmsg(sc, "leader error"); ! 259: sc->imp_msgready = 0; ! 260: hostreset(unit); ! 261: impnoops(sc); ! 262: sc->imp_garbage++; ! 263: } ! 264: break; ! 265: ! 266: /* ! 267: * IMP going down. Print message, and if not immediate, ! 268: * set off a timer to insure things will be reset at the ! 269: * appropriate time. ! 270: */ ! 271: case IMPTYPE_DOWN: ! 272: { int type, when; ! 273: ! 274: type = cp->dl_link & IMP_DMASK; ! 275: when = (cp->dl_link & IMPDOWN_WHENMASK) >> IMPDOWN_WHENSHIFT; ! 276: #ifdef IMPINIT ! 277: if (imptraceinit) ! 278: log(imppri, "input DOWN %s %d\n", ! 279: impmessage[type], when * IMPDOWN_WHENUNIT); ! 280: #endif ! 281: if (type != IMPDOWN_GOING && when) ! 282: impmsg(sc, "going down %s in %d minutes", ! 283: (u_int)impmessage[type], when * IMPDOWN_WHENUNIT); ! 284: else ! 285: impmsg(sc, "going down %s", (u_int)impmessage[type]); ! 286: if (sc->imp_state != IMPS_UP) ! 287: break; ! 288: if (type == IMPDOWN_GOING) { ! 289: sc->imp_state = IMPS_GOINGDOWN; ! 290: timeout(impdown, (caddr_t)sc, IMPTV_DOWN * hz); ! 291: } else if (when == 0) ! 292: sc->imp_state = IMPS_WINIT; ! 293: sc->imp_dropcnt = 0; ! 294: break; ! 295: } ! 296: ! 297: /* ! 298: * A NOP, usually seen during the initialization sequence. ! 299: * Compare the local address with that in the message. ! 300: * Reset the local address notion if it doesn't match. ! 301: */ ! 302: case IMPTYPE_NOOP: ! 303: #ifdef IMPINIT ! 304: if (imptraceinit) ! 305: log(imppri, "noop\n"); ! 306: #endif ! 307: if (sc->imp_state == IMPS_WINIT) { ! 308: sc->imp_dropcnt = 0; ! 309: impnoops(sc); ! 310: sc->imp_state = IMPS_INIT; ! 311: } ! 312: sc->imp_dropcnt++; ! 313: if (sc->imp_state == IMPS_INIT && cp->dl_imp != 0) { ! 314: struct in_addr leader_addr; ! 315: ! 316: sin = (struct sockaddr_in *)&sc->imp_if.if_addrlist->ifa_addr; ! 317: imp_leader_to_addr(&leader_addr, cp, &sc->imp_if); ! 318: if (sin->sin_addr.s_addr != leader_addr.s_addr) { ! 319: impmsg(sc, "address reset to x%x (%d/%d)", ! 320: ntohl(leader_addr.s_addr), ! 321: (u_int)cp->dl_host, ! 322: ntohs(cp->dl_imp)); ! 323: sin->sin_addr.s_addr = leader_addr.s_addr; ! 324: } ! 325: } ! 326: break; ! 327: ! 328: /* ! 329: * RFNM or INCOMPLETE message, decrement rfnm count ! 330: * and prepare to send next message. ! 331: * If the rfnm allows another queued ! 332: * message to be sent, bump msgready ! 333: * and start IMP if idle. ! 334: * We could pass incomplete's up to the next level, ! 335: * but this currently isn't needed. ! 336: * Pass "bad" incompletes and rfnms to the raw socket. ! 337: */ ! 338: case IMPTYPE_INCOMPLETE: ! 339: sc->imp_incomplete++; ! 340: /* FALL THROUGH */ ! 341: case IMPTYPE_RFNM: ! 342: if ((hp = hostlookup((int)cp->dl_imp, (int)cp->dl_host, ! 343: unit)) == 0 || hp->h_rfnm == 0) { ! 344: sc->imp_badrfnm++; ! 345: if (hp) ! 346: hostfree(hp); ! 347: break; ! 348: } ! 349: imprestarthost(sc, hp); ! 350: if (cp->dl_mtype == IMPTYPE_RFNM) ! 351: goto drop; ! 352: break; ! 353: ! 354: /* ! 355: * Host or IMP can't be reached. Flush any packets ! 356: * awaiting transmission and release the host structure. ! 357: * Enqueue for notifying protocols at software interrupt time. ! 358: */ ! 359: case IMPTYPE_HOSTDEAD: ! 360: case IMPTYPE_HOSTUNREACH: ! 361: if (hp = hostlookup((int)cp->dl_imp, (int)cp->dl_host, unit)) { ! 362: hp->h_flags |= (1 << (int)cp->dl_mtype); ! 363: sc->imp_msgready -= ! 364: MIN(hp->h_qcnt, IMP_MAXHOSTMSG - hp->h_rfnm); ! 365: hp->h_rfnm = 0; ! 366: hostflush(hp); ! 367: hp->h_timer = HOSTDEADTIMER; ! 368: } ! 369: break; ! 370: ! 371: /* ! 372: * Error in data. Clear RFNM status for this host and send ! 373: * noops to the IMP to clear the interface. ! 374: */ ! 375: case IMPTYPE_BADDATA: ! 376: impmsg(sc, "data error"); ! 377: if (hp = hostlookup((int)cp->dl_imp, (int)cp->dl_host, unit)) { ! 378: sc->imp_msgready -= ! 379: MIN(hp->h_qcnt, IMP_MAXHOSTMSG - hp->h_rfnm); ! 380: if (hp->h_rfnm) ! 381: hostrelease(hp); ! 382: else ! 383: hostfree(hp); ! 384: } ! 385: impnoops(sc); ! 386: break; ! 387: ! 388: /* ! 389: * Interface reset. ! 390: */ ! 391: case IMPTYPE_RESET: ! 392: #ifdef IMPINIT ! 393: if (imptraceinit) ! 394: log(imppri, "reset complete\n"); ! 395: #endif ! 396: if (sc->imp_state != IMPS_INIT) { ! 397: impmsg(sc, "interface reset"); ! 398: impnoops(sc); ! 399: } ! 400: /* clear RFNM counts */ ! 401: sc->imp_msgready = 0; ! 402: hostreset(unit); ! 403: if (sc->imp_state != IMPS_DOWN) { ! 404: sc->imp_state = IMPS_UP; ! 405: sc->imp_if.if_flags |= IFF_UP; ! 406: #ifdef IMPINIT ! 407: if (imptraceinit) ! 408: log(imppri, "IMP UP\n"); ! 409: #endif ! 410: } ! 411: break; ! 412: ! 413: default: ! 414: sc->imp_garbage++; ! 415: sc->imp_if.if_collisions++; /* XXX */ ! 416: break; ! 417: } ! 418: ! 419: if (inq == &impintrq) ! 420: schednetisr(NETISR_IMP); ! 421: s = splimp(); ! 422: if (!IF_QFULL(inq)) { ! 423: IF_ENQUEUE(inq, m); ! 424: splx(s); ! 425: return; ! 426: } ! 427: splx(s); ! 428: IF_DROP(inq); ! 429: drop: ! 430: m_freem(m); ! 431: #undef ip ! 432: } ! 433: ! 434: /* ! 435: * Bring the IMP down after notification. ! 436: */ ! 437: impdown(sc) ! 438: struct imp_softc *sc; ! 439: { ! 440: int s = splimp(); ! 441: ! 442: if (sc->imp_state == IMPS_GOINGDOWN) { ! 443: sc->imp_state = IMPS_WINIT; ! 444: impmsg(sc, "marked down"); ! 445: sc->imp_msgready = 0; ! 446: hostreset(sc->imp_if.if_unit); ! 447: if_down(&sc->imp_if); ! 448: } ! 449: #ifdef IMPINIT ! 450: else if (imptraceinit) ! 451: log(imppri, "impdown, state now %d (ignored)\n", sc->imp_state); ! 452: #endif ! 453: splx(s); ! 454: } ! 455: ! 456: /*VARARGS2*/ ! 457: impmsg(sc, fmt, a1) ! 458: struct imp_softc *sc; ! 459: char *fmt; ! 460: u_int a1; ! 461: { ! 462: ! 463: log(imppri, "imp%d: %r\n", sc->imp_if.if_unit, fmt, &a1); ! 464: } ! 465: ! 466: struct sockproto impproto = { PF_IMPLINK }; ! 467: struct sockaddr_in impdst = { sizeof (impdst), AF_INET }; ! 468: struct sockaddr_in impsrc = { sizeof (impsrc), AF_INET }; ! 469: ! 470: /* ! 471: * Pick up the IMP "error" messages enqueued earlier, ! 472: * passing these up to the higher level protocol ! 473: * and the raw interface. ! 474: */ ! 475: impintr() ! 476: { ! 477: register struct mbuf *m; ! 478: register struct control_leader *cp; ! 479: struct ifnet *ifp; ! 480: int s, code; ! 481: ! 482: for (;;) { ! 483: s = splimp(); ! 484: IF_DEQUEUEIF(&impintrq, m, ifp); ! 485: splx(s); ! 486: if (m == 0) ! 487: return; ! 488: ! 489: cp = mtod(m, struct control_leader *); ! 490: imp_leader_to_addr(&impsrc.sin_addr, cp, ifp); ! 491: impproto.sp_protocol = cp->dl_link; ! 492: impdst.sin_addr = IA_SIN(ifp->if_addrlist)->sin_addr; ! 493: ! 494: if (cp->dl_mtype == IMPTYPE_HOSTDEAD || ! 495: cp->dl_mtype == IMPTYPE_HOSTUNREACH) { ! 496: code = (cp->dl_mtype == IMPTYPE_HOSTDEAD) ? ! 497: PRC_HOSTDEAD : PRC_UNREACH_HOST; ! 498: switch (cp->dl_link) { ! 499: ! 500: case IMPLINK_IP: ! 501: pfctlinput(code, (struct sockaddr *)&impsrc); ! 502: break; ! 503: default: ! 504: raw_ctlinput(code, (struct sockaddr *)&impsrc); ! 505: break; ! 506: } ! 507: } ! 508: ! 509: raw_input(m, &impproto, (struct sockaddr *)&impsrc, ! 510: (struct sockaddr *)&impdst); ! 511: } ! 512: } ! 513: ! 514: /* ! 515: * ARPAnet 1822 output routine. ! 516: * Called from higher level protocol routines to set up messages for ! 517: * transmission to the imp. Sets up the header and calls impsnd to ! 518: * enqueue the message for this IMP's hardware driver. ! 519: */ ! 520: impoutput(ifp, m0, dst) ! 521: register struct ifnet *ifp; ! 522: struct mbuf *m0; ! 523: struct sockaddr *dst; ! 524: { ! 525: register struct imp_leader *imp; ! 526: register struct mbuf *m = m0; ! 527: caddr_t pkt = mtod(m, caddr_t); ! 528: int error = 0; ! 529: ! 530: /* ! 531: * Don't even try if the IMP is unavailable. ! 532: */ ! 533: if (!IMPS_RUNNING(imp_softc[ifp->if_unit].imp_state)) { ! 534: error = ENETDOWN; ! 535: goto drop; ! 536: } ! 537: ! 538: /* ! 539: * If AF_IMPLINK, leader exists; just send. ! 540: * Otherwise, construct leader according to address family. ! 541: */ ! 542: if (dst->sa_family != AF_IMPLINK) { ! 543: /* ! 544: * Add IMP leader. If there's not enough space in the ! 545: * first mbuf, allocate another. If that should fail, we ! 546: * drop this sucker. ! 547: */ ! 548: M_PREPEND(m, sizeof(struct imp_leadr), M_DONTWAIT); ! 549: imp = mtod(m, struct imp_leader *); ! 550: imp->il_format = IMP_NFF; ! 551: imp->il_mtype = IMPTYPE_DATA; ! 552: imp->il_flags = 0; ! 553: imp->il_htype = 0; ! 554: imp->il_subtype = 0; ! 555: ! 556: switch (dst->sa_family) { ! 557: ! 558: case AF_INET: ! 559: imp->il_link = IMPLINK_IP; ! 560: imp_addr_to_leader((struct control_leader *)imp, ! 561: ((struct sockaddr_in *)dst)->sin_addr.s_addr); ! 562: imp->il_length = htons(ntohs((u_short) ! 563: ((struct ip *)pkt)->ip_len) << 3); ! 564: break; ! 565: ! 566: default: ! 567: printf("imp%d: can't handle af%d\n", ifp->if_unit, ! 568: dst->sa_family); ! 569: error = EAFNOSUPPORT; ! 570: m0 = m; ! 571: goto drop; ! 572: } ! 573: } ! 574: return (impsnd(ifp, m)); ! 575: drop: ! 576: m_freem(m0); ! 577: return (error); ! 578: } ! 579: ! 580: /* ! 581: * Put a message on an interface's output queue. ! 582: * Perform RFNM counting: no more than 8 message may be ! 583: * in flight to any one host. ! 584: */ ! 585: impsnd(ifp, m) ! 586: struct ifnet *ifp; ! 587: struct mbuf *m; ! 588: { ! 589: register struct control_leader *imp; ! 590: register struct host *hp; ! 591: register struct imp_softc *sc = &imp_softc[ifp->if_unit]; ! 592: int s, error = 0; ! 593: ! 594: imp = mtod(m, struct control_leader *); ! 595: ! 596: /* ! 597: * Do RFNM counting for data messages ! 598: * (no more than 8 outstanding to any host). ! 599: * Queue data messages per host if 8 are already outstanding ! 600: * or if the hardware interface is already doing output. ! 601: * Increment imp_msgready if the message could be sent now, ! 602: * but must be queued because the imp output is busy. ! 603: */ ! 604: s = splimp(); ! 605: if (imp->dl_mtype == IMPTYPE_DATA) { ! 606: hp = hostenter((int)imp->dl_imp, (int)imp->dl_host, ! 607: ifp->if_unit); ! 608: if (hp) { ! 609: if (hp->h_flags & (HF_DEAD|HF_UNREACH)) ! 610: error = hp->h_flags & HF_DEAD ? ! 611: EHOSTDOWN : EHOSTUNREACH; ! 612: else if (hp->h_rfnm < IMP_MAXHOSTMSG && ! 613: sc->imp_cb.ic_oactive == 0) { ! 614: /* ! 615: * Send without queuing; ! 616: * adjust rfnm count and timer. ! 617: */ ! 618: if (hp->h_rfnm++ == 0) ! 619: hp->h_timer = RFNMTIMER; ! 620: goto send; ! 621: } else if (hp->h_rfnm + hp->h_qcnt < imphqlen) { ! 622: HOST_ENQUE(hp, m); ! 623: if (hp->h_rfnm + hp->h_qcnt <= IMP_MAXHOSTMSG) ! 624: sc->imp_msgready++; ! 625: } else { ! 626: error = ENOBUFS; ! 627: IF_DROP(&ifp->if_snd); ! 628: } ! 629: } else ! 630: error = ENOBUFS; ! 631: } else if (sc->imp_cb.ic_oactive == 0) ! 632: goto send; ! 633: else ! 634: IF_ENQUEUE(&ifp->if_snd, m); ! 635: ! 636: splx(s); ! 637: if (error) ! 638: m_freem(m); ! 639: return (error); ! 640: ! 641: send: ! 642: sc->imp_if.if_timer = IMP_OTIMER; ! 643: (*sc->imp_cb.ic_output)(sc->imp_cb.ic_hwunit, m); ! 644: splx(s); ! 645: return (0); ! 646: } ! 647: ! 648: /* ! 649: * Start another output operation on IMP; called from hardware ! 650: * transmit-complete interrupt routine at splimp or from imp routines ! 651: * when output is not in progress. If there are any packets on shared ! 652: * output queue, send them, otherwise send the next data packet for a host. ! 653: * Host data packets are sent round-robin based on destination by walking ! 654: * the host list. ! 655: */ ! 656: impstart(sc) ! 657: register struct imp_softc *sc; ! 658: { ! 659: register struct mbuf *m; ! 660: int first = 1; /* XXX */ ! 661: register struct host *hp; ! 662: int index; ! 663: ! 664: IF_DEQUEUE(&sc->imp_if.if_snd, m); ! 665: if (m) { ! 666: sc->imp_if.if_timer = IMP_OTIMER; ! 667: (*sc->imp_cb.ic_output)(sc->imp_cb.ic_hwunit, m); ! 668: return; ! 669: } ! 670: if (sc->imp_msgready) { ! 671: if ((m = sc->imp_hostq) == 0 && (m = sc->imp_hosts) == 0) ! 672: panic("imp msgready"); ! 673: index = sc->imp_hostent; ! 674: for (hp = &mtod(m, struct hmbuf *)->hm_hosts[index]; ; ! 675: hp++, index++) { ! 676: if (index >= HPMBUF) { ! 677: if ((m = m->m_next) == 0) ! 678: m = sc->imp_hosts; ! 679: index = 0; ! 680: hp = mtod(m, struct hmbuf *)->hm_hosts; ! 681: first = 0; /* XXX */ ! 682: } ! 683: if (hp->h_qcnt && hp->h_rfnm < IMP_MAXHOSTMSG) { ! 684: /* ! 685: * Found host entry with another message ! 686: * to send. Deliver it to the IMP. ! 687: * Start with succeeding host next time. ! 688: */ ! 689: impstarthost(sc, hp); ! 690: sc->imp_hostq = m; ! 691: sc->imp_hostent = index + 1; ! 692: return; ! 693: } ! 694: if (m == sc->imp_hostq && !first && ! 695: index + 1 >= sc->imp_hostent) { /* XXX */ ! 696: log(imppri, "imp: can't find %d msgready\n", ! 697: sc->imp_msgready); ! 698: sc->imp_msgready = 0; ! 699: break; ! 700: } ! 701: } ! 702: } ! 703: sc->imp_if.if_timer = 0; ! 704: } ! 705: ! 706: /* ! 707: * Restart output for a host that has received a RFNM ! 708: * or incomplete or has timed out while waiting for a RFNM. ! 709: * Must be called at splimp. ! 710: */ ! 711: imprestarthost(sc, hp) ! 712: register struct imp_softc *sc; ! 713: struct host *hp; ! 714: { ! 715: ! 716: if (--hp->h_rfnm > 0) ! 717: hp->h_timer = RFNMTIMER; ! 718: /* ! 719: * If the RFNM moved a queued message into the window, ! 720: * update msgready and start IMP if idle. ! 721: */ ! 722: if (hp->h_qcnt > IMP_MAXHOSTMSG - 1 - hp->h_rfnm) { ! 723: sc->imp_msgready++; ! 724: if (sc->imp_cb.ic_oactive == 0) ! 725: impstarthost(sc, hp); ! 726: } ! 727: if (hp->h_rfnm == 0 && hp->h_qcnt == 0) ! 728: hostidle(hp); ! 729: } ! 730: ! 731: /* ! 732: * Send the next message queued for a host ! 733: * when ready to send another message to the IMP. ! 734: * Called only when output is not in progress. ! 735: * Bump RFNM counter and start RFNM timer ! 736: * when we send the message to the IMP. ! 737: * Must be called at splimp. ! 738: */ ! 739: impstarthost(sc, hp) ! 740: register struct imp_softc *sc; ! 741: register struct host *hp; ! 742: { ! 743: struct mbuf *m; ! 744: ! 745: if (hp->h_rfnm++ == 0) ! 746: hp->h_timer = RFNMTIMER; ! 747: HOST_DEQUE(hp, m); ! 748: sc->imp_if.if_timer = IMP_OTIMER; ! 749: (*sc->imp_cb.ic_output)(sc->imp_cb.ic_hwunit, m); ! 750: sc->imp_msgready--; ! 751: } ! 752: ! 753: /* ! 754: * "Watchdog" timeout. When the output timer expires, ! 755: * we assume we have been blocked by the imp. ! 756: * No need to restart, just collect statistics. ! 757: */ ! 758: imptimo(unit) ! 759: int unit; ! 760: { ! 761: ! 762: imp_softc[unit].imp_block++; ! 763: } ! 764: ! 765: /* ! 766: * Put three 1822 NOOPs at the head of the output queue. ! 767: * Part of host-IMP initialization procedure. ! 768: * (Should return success/failure, but noone knows ! 769: * what to do with this, so why bother?) ! 770: * This routine is always called at splimp, so we don't ! 771: * protect the call to IF_PREPEND. ! 772: */ ! 773: impnoops(sc) ! 774: register struct imp_softc *sc; ! 775: { ! 776: register i; ! 777: register struct mbuf *m; ! 778: register struct control_leader *cp; ! 779: ! 780: #ifdef IMPINIT ! 781: if (imptraceinit) ! 782: log(imppri, "impnoops\n"); ! 783: #endif ! 784: for (i = 0; i < IMP_NOOPCNT; i++) { ! 785: if ((m = m_getclr(M_DONTWAIT, MT_HEADER)) == 0) ! 786: return; ! 787: m->m_len = sizeof(struct control_leader); ! 788: cp = mtod(m, struct control_leader *); ! 789: cp->dl_format = IMP_NFF; ! 790: cp->dl_link = i; ! 791: cp->dl_mtype = IMPTYPE_NOOP; ! 792: IF_PREPEND(&sc->imp_if.if_snd, m); ! 793: } ! 794: if (sc->imp_cb.ic_oactive == 0) ! 795: impstart(sc); ! 796: } ! 797: ! 798: /* ! 799: * Process an ioctl request. ! 800: */ ! 801: impioctl(ifp, cmd, data) ! 802: register struct ifnet *ifp; ! 803: int cmd; ! 804: caddr_t data; ! 805: { ! 806: struct ifaddr *ifa = (struct ifaddr *) data; ! 807: int s = splimp(), error = 0; ! 808: #define sc ((struct imp_softc *)ifp) ! 809: ! 810: switch (cmd) { ! 811: ! 812: case SIOCSIFADDR: ! 813: if (ifa->ifa_addr.sa_family != AF_INET) { ! 814: error = EINVAL; ! 815: break; ! 816: } ! 817: if ((ifp->if_flags & IFF_UP) == 0) ! 818: impinit(ifp->if_unit); ! 819: break; ! 820: ! 821: case SIOCSIFFLAGS: ! 822: if ((ifp->if_flags & IFF_UP) == 0 && ! 823: sc->imp_state != IMPS_DOWN) { ! 824: if (sc->imp_cb.ic_down && ! 825: (*sc->imp_cb.ic_down)(sc->imp_cb.ic_hwunit)) { ! 826: sc->imp_state = IMPS_DOWN; ! 827: sc->imp_msgready = 0; ! 828: hostreset(ifp->if_unit); ! 829: if_down(ifp); ! 830: } ! 831: } else if (ifp->if_flags & IFF_UP && sc->imp_state == IMPS_DOWN) ! 832: impinit(ifp->if_unit); ! 833: break; ! 834: ! 835: default: ! 836: error = EINVAL; ! 837: break; ! 838: } ! 839: splx(s); ! 840: return (error); ! 841: } ! 842: ! 843: #ifdef IMPLEADERS ! 844: printleader(routine, ip) ! 845: char *routine; ! 846: register struct imp_leader *ip; ! 847: { ! 848: printf("%s: ", routine); ! 849: printbyte((char *)ip, 12); ! 850: printf("<fmt=%x,net=%x,flags=%x,mtype=", ip->il_format, ip->il_network, ! 851: ip->il_flags); ! 852: if (ip->il_mtype <= IMPTYPE_READY) ! 853: printf("%s,", impleaders[ip->il_mtype]); ! 854: else ! 855: printf("%x,", ip->il_mtype); ! 856: printf("htype=%x,host=%x,imp=%x,link=", ip->il_htype, ip->il_host, ! 857: ntohs(ip->il_imp)); ! 858: if (ip->il_link == IMPLINK_IP) ! 859: printf("ip,"); ! 860: else ! 861: printf("%x,", ip->il_link); ! 862: printf("subtype=%x,len=%x>\n",ip->il_subtype,ntohs(ip->il_length)>>3); ! 863: } ! 864: ! 865: printbyte(cp, n) ! 866: register char *cp; ! 867: int n; ! 868: { ! 869: register i, j, c; ! 870: ! 871: for (i=0; i<n; i++) { ! 872: c = *cp++; ! 873: for (j=0; j<2; j++) ! 874: putchar("0123456789abcdef"[(c>>((1-j)*4))&0xf], 0); ! 875: putchar(' ', 0); ! 876: } ! 877: putchar('\n', 0); ! 878: } ! 879: #endif ! 880: ! 881: /* ! 882: * Routine to convert from IMP Leader to InterNet Address. ! 883: * ! 884: * This procedure is necessary because IMPs may be assigned Class A, B, or C ! 885: * network numbers, but only have 8 bits in the leader to reflect the ! 886: * IMP "network number". The strategy is to take the network number from ! 887: * the ifnet structure, and blend in the host-on-imp and imp-on-net numbers ! 888: * from the leader. ! 889: * ! 890: * There is no support for "Logical Hosts". ! 891: * ! 892: * Class A: Net.Host.0.Imp ! 893: * Class B: Net.net.Host.Imp ! 894: * Class C: Net.net.net.(Host4|Imp4) ! 895: */ ! 896: imp_leader_to_addr(ap, cp, ifp) ! 897: struct in_addr *ap; ! 898: register struct control_leader *cp; ! 899: struct ifnet *ifp; ! 900: { ! 901: register u_long final; ! 902: register struct sockaddr_in *sin; ! 903: int imp = ntohs(cp->dl_imp); ! 904: ! 905: sin = (struct sockaddr_in *)(&ifp->if_addrlist->ifa_addr); ! 906: final = ntohl(sin->sin_addr.s_addr); ! 907: ! 908: if (IN_CLASSA(final)) { ! 909: final &= IN_CLASSA_NET; ! 910: final |= (imp & 0xFF) | ((cp->dl_host & 0xFF)<<16); ! 911: } else if (IN_CLASSB(final)) { ! 912: final &= IN_CLASSB_NET; ! 913: final |= (imp & 0xFF) | ((cp->dl_host & 0xFF)<<8); ! 914: } else { ! 915: final &= IN_CLASSC_NET; ! 916: final |= (imp & 0x0F) | ((cp->dl_host & 0x0F)<<4); ! 917: } ! 918: ap->s_addr = htonl(final); ! 919: } ! 920: ! 921: /* ! 922: * Function to take InterNet address and fill in IMP leader fields. ! 923: */ ! 924: imp_addr_to_leader(imp, a) ! 925: register struct control_leader *imp; ! 926: u_long a; ! 927: { ! 928: register u_long addr = ntohl(a); ! 929: ! 930: imp->dl_network = 0; /* !! */ ! 931: ! 932: if (IN_CLASSA(addr)) { ! 933: imp->dl_host = ((addr>>16) & 0xFF); ! 934: imp->dl_imp = addr & 0xFF; ! 935: } else if (IN_CLASSB(addr)) { ! 936: imp->dl_host = ((addr>>8) & 0xFF); ! 937: imp->dl_imp = addr & 0xFF; ! 938: } else { ! 939: imp->dl_host = ((addr>>4) & 0xF); ! 940: imp->dl_imp = addr & 0xF; ! 941: } ! 942: imp->dl_imp = htons(imp->dl_imp); ! 943: } ! 944: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.