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