![[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] / 43BSD / sys / netimp|
Return to if_imp.c CVS log | Up to [CSRG BSD Unix] / 43BSD / sys / netimp |
1.1 ! root 1: /* ! 2: * Copyright (c) 1982, 1986 Regents of the University of California. ! 3: * All rights reserved. The Berkeley software License Agreement ! 4: * specifies the terms and conditions for redistribution. ! 5: * ! 6: * @(#)if_imp.c 7.1 (Berkeley) 6/4/86 ! 7: */ ! 8: ! 9: #include "imp.h" ! 10: #if NIMP > 0 ! 11: /* ! 12: * ARPANET IMP interface driver. ! 13: * ! 14: * The IMP-host protocol is handled here, leaving ! 15: * hardware specifics to the lower level interface driver. ! 16: */ ! 17: #include "../machine/pte.h" ! 18: ! 19: #include "param.h" ! 20: #include "systm.h" ! 21: #include "mbuf.h" ! 22: #include "buf.h" ! 23: #include "protosw.h" ! 24: #include "socket.h" ! 25: #include "vmmac.h" ! 26: #include "time.h" ! 27: #include "kernel.h" ! 28: #include "errno.h" ! 29: #include "ioctl.h" ! 30: ! 31: #include "../vax/cpu.h" ! 32: #include "../vax/mtpr.h" ! 33: #include "../vaxuba/ubareg.h" ! 34: #include "../vaxuba/ubavar.h" ! 35: ! 36: #include "../net/if.h" ! 37: #include "../net/route.h" ! 38: ! 39: #include "../net/netisr.h" ! 40: #include "../netinet/in.h" ! 41: #include "../netinet/in_systm.h" ! 42: #include "../netinet/in_var.h" ! 43: #include "../netinet/ip.h" ! 44: #include "../netinet/ip_var.h" ! 45: /* define IMPLEADERS here to get leader printing code */ ! 46: #include "if_imp.h" ! 47: #include "if_imphost.h" ! 48: ! 49: /* ! 50: * IMP software status per interface. ! 51: * (partially shared with the hardware specific module) ! 52: * ! 53: * Each interface is referenced by a network interface structure, ! 54: * imp_if, which the routing code uses to locate the interface. ! 55: * This structure contains the output queue for the interface, its ! 56: * address, ... IMP specific structures used in connecting the ! 57: * IMP software modules to the hardware specific interface routines ! 58: * are stored here. The common structures are made visible to the ! 59: * interface driver by passing a pointer to the hardware routine ! 60: * at "attach" time. ! 61: * ! 62: * NOTE: imp_if and imp_cb are assumed adjacent in hardware code. ! 63: */ ! 64: struct imp_softc { ! 65: struct ifnet imp_if; /* network visible interface */ ! 66: struct impcb imp_cb; /* hooks to hardware module */ ! 67: u_char imp_state; /* current state of IMP */ ! 68: char imp_dropcnt; /* used during initialization */ ! 69: } imp_softc[NIMP]; ! 70: ! 71: struct ifqueue impintrq; ! 72: int impqmaxlen = IFQ_MAXLEN; ! 73: ! 74: /* ! 75: * Messages from IMP regarding why ! 76: * it's going down. ! 77: */ ! 78: static char *impmessage[] = { ! 79: "in 30 seconds", ! 80: "for hardware PM", ! 81: "to reload software", ! 82: "for emergency reset" ! 83: }; ! 84: ! 85: #define HOSTDEADTIMER 10 /* How long to wait when down */ ! 86: ! 87: int impdown(), impinit(), impioctl(), impoutput(); ! 88: ! 89: /* ! 90: * IMP attach routine. Called from hardware device attach routine ! 91: * at configuration time with a pointer to the UNIBUS device structure. ! 92: * Sets up local state and returns pointer to base of ifnet+impcb ! 93: * structures. This is then used by the device's attach routine ! 94: * set up its back pointers. ! 95: */ ! 96: impattach(ui, reset) ! 97: struct uba_device *ui; ! 98: int (*reset)(); ! 99: { ! 100: struct imp_softc *sc; ! 101: register struct ifnet *ifp; ! 102: ! 103: #ifdef lint ! 104: impintr(); ! 105: #endif ! 106: if (ui->ui_unit >= NIMP) { ! 107: printf("imp%d: not configured\n", ui->ui_unit); ! 108: return (0); ! 109: } ! 110: sc = &imp_softc[ui->ui_unit]; ! 111: ifp = &sc->imp_if; ! 112: /* UNIT COULD BE AMBIGUOUS */ ! 113: ifp->if_unit = ui->ui_unit; ! 114: ifp->if_name = "imp"; ! 115: ifp->if_mtu = IMPMTU - sizeof(struct imp_leader); ! 116: ifp->if_reset = reset; ! 117: ifp->if_init = impinit; ! 118: ifp->if_ioctl = impioctl; ! 119: ifp->if_output = impoutput; ! 120: /* reset is handled at the hardware level */ ! 121: if_attach(ifp); ! 122: return ((int)ifp); ! 123: } ! 124: ! 125: /* ! 126: * IMP initialization routine: call hardware module to ! 127: * setup UNIBUS resources, init state and get ready for ! 128: * NOOPs the IMP should send us, and that we want to drop. ! 129: */ ! 130: impinit(unit) ! 131: int unit; ! 132: { ! 133: int s = splimp(); ! 134: register struct imp_softc *sc = &imp_softc[unit]; ! 135: ! 136: if (sc->imp_if.if_addrlist == 0) ! 137: return; ! 138: if ((*sc->imp_cb.ic_init)(unit) == 0) { ! 139: sc->imp_state = IMPS_DOWN; ! 140: sc->imp_if.if_flags &= ~IFF_UP; ! 141: splx(s); ! 142: return; ! 143: } ! 144: sc->imp_state = IMPS_INIT; ! 145: impnoops(sc); ! 146: impintrq.ifq_maxlen = impqmaxlen; ! 147: splx(s); ! 148: } ! 149: ! 150: #ifdef IMPLEADERS ! 151: int impprintfs = 0; ! 152: #endif ! 153: ! 154: /* ! 155: * ARPAnet 1822 input routine. ! 156: * Called from hardware input interrupt routine to handle 1822 ! 157: * IMP-host messages. Type 0 messages (non-control) are ! 158: * passed to higher level protocol processors on the basis ! 159: * of link number. Other type messages (control) are handled here. ! 160: */ ! 161: impinput(unit, m) ! 162: int unit; ! 163: register struct mbuf *m; ! 164: { ! 165: register struct imp_leader *ip; ! 166: register struct imp_softc *sc = &imp_softc[unit]; ! 167: struct ifnet *ifp; ! 168: register struct host *hp; ! 169: register struct ifqueue *inq; ! 170: struct control_leader *cp; ! 171: struct in_addr addr; ! 172: struct mbuf *next; ! 173: struct sockaddr_in *sin; ! 174: ! 175: /* ! 176: * Pull the interface pointer out of the mbuf ! 177: * and save for later; adjust mbuf to look at rest of data. ! 178: */ ! 179: ifp = *(mtod(m, struct ifnet **)); ! 180: IF_ADJ(m); ! 181: /* verify leader length. */ ! 182: if (m->m_len < sizeof(struct control_leader) && ! 183: (m = m_pullup(m, sizeof(struct control_leader))) == 0) ! 184: return; ! 185: cp = mtod(m, struct control_leader *); ! 186: if (cp->dl_mtype == IMPTYPE_DATA) ! 187: if (m->m_len < sizeof(struct imp_leader) && ! 188: (m = m_pullup(m, sizeof(struct imp_leader))) == 0) ! 189: return; ! 190: ip = mtod(m, struct imp_leader *); ! 191: #ifdef IMPLEADERS ! 192: if (impprintfs) ! 193: printleader("impinput", ip); ! 194: #endif ! 195: inq = &impintrq; ! 196: ! 197: /* check leader type */ ! 198: if (ip->il_format != IMP_NFF) { ! 199: sc->imp_if.if_collisions++; /* XXX */ ! 200: goto rawlinkin; ! 201: } ! 202: ! 203: if (ip->il_mtype != IMPTYPE_DATA) { ! 204: /* If not data packet, build IP addr from leader (BRL) */ ! 205: imp_leader_to_addr(&addr, ip, &sc->imp_if); ! 206: } ! 207: ! 208: switch (ip->il_mtype) { ! 209: ! 210: case IMPTYPE_DATA: ! 211: /* ! 212: * Data for a protocol. Dispatch to the appropriate ! 213: * protocol routine (running at software interrupt). ! 214: * If this isn't a raw interface, advance pointer ! 215: * into mbuf past leader. ! 216: */ ! 217: switch (ip->il_link) { ! 218: ! 219: case IMPLINK_IP: ! 220: m->m_len -= sizeof(struct imp_leader); ! 221: m->m_off += sizeof(struct imp_leader); ! 222: schednetisr(NETISR_IP); ! 223: inq = &ipintrq; ! 224: break; ! 225: ! 226: default: ! 227: break; ! 228: } ! 229: break; ! 230: ! 231: /* ! 232: * IMP leader error. Reset the IMP and discard the packet. ! 233: */ ! 234: case IMPTYPE_BADLEADER: ! 235: /* ! 236: * According to 1822 document, this message ! 237: * will be generated in response to the ! 238: * first noop sent to the IMP after ! 239: * the host resets the IMP interface. ! 240: */ ! 241: if (sc->imp_state != IMPS_INIT) { ! 242: impmsg(sc, "leader error"); ! 243: hostreset(((struct in_ifaddr *)&sc->imp_if.if_addrlist)->ia_net); ! 244: impnoops(sc); ! 245: } ! 246: break; ! 247: ! 248: /* ! 249: * IMP going down. Print message, and if not immediate, ! 250: * set off a timer to insure things will be reset at the ! 251: * appropriate time. ! 252: */ ! 253: case IMPTYPE_DOWN: ! 254: if (sc->imp_state < IMPS_INIT) ! 255: break; ! 256: if ((ip->il_link & IMP_DMASK) == 0) { ! 257: sc->imp_state = IMPS_GOINGDOWN; ! 258: timeout(impdown, (caddr_t)sc, 30 * hz); ! 259: } ! 260: impmsg(sc, "going down %s", ! 261: (u_int)impmessage[ip->il_link&IMP_DMASK]); ! 262: break; ! 263: ! 264: /* ! 265: * A NOP usually seen during the initialization sequence. ! 266: * Compare the local address with that in the message. ! 267: * Reset the local address notion if it doesn't match. ! 268: */ ! 269: case IMPTYPE_NOOP: ! 270: if (sc->imp_state == IMPS_DOWN) { ! 271: sc->imp_state = IMPS_INIT; ! 272: sc->imp_dropcnt = IMP_DROPCNT; ! 273: } ! 274: if (sc->imp_state == IMPS_INIT && --sc->imp_dropcnt > 0) ! 275: break; ! 276: sin = (struct sockaddr_in *)&sc->imp_if.if_addrlist->ifa_addr; ! 277: if (ip->il_imp != 0) { ! 278: struct in_addr leader_addr; ! 279: ! 280: imp_leader_to_addr(&leader_addr, ip, &sc->imp_if); ! 281: if (sin->sin_addr.s_addr != leader_addr.s_addr) { ! 282: impmsg(sc, "address reset to x%x (%d/%d)", ! 283: ntohl(leader_addr.s_addr), ! 284: (u_int)ip->il_host, ! 285: ntohs(ip->il_imp)); ! 286: sin->sin_addr.s_addr = leader_addr.s_addr; ! 287: } ! 288: } ! 289: sc->imp_state = IMPS_UP; ! 290: sc->imp_if.if_flags |= IFF_UP; ! 291: break; ! 292: ! 293: /* ! 294: * RFNM or INCOMPLETE message, send next ! 295: * message on the q. We could pass incomplete's ! 296: * up to the next level, but this currently isn't ! 297: * needed. ! 298: */ ! 299: case IMPTYPE_RFNM: ! 300: case IMPTYPE_INCOMPLETE: ! 301: if (hp = hostlookup(addr)) { ! 302: hp->h_timer = HOSTTIMER; ! 303: if (hp->h_rfnm == 0) ! 304: hp->h_flags &= ~HF_INUSE; ! 305: else if (next = hostdeque(hp)) ! 306: (void) impsnd(&sc->imp_if, next); ! 307: } ! 308: goto drop; ! 309: ! 310: /* ! 311: * Host or IMP can't be reached. Flush any packets ! 312: * awaiting transmission and release the host structure. ! 313: * Enqueue for notifying protocols at software interrupt time. ! 314: */ ! 315: case IMPTYPE_HOSTDEAD: ! 316: case IMPTYPE_HOSTUNREACH: ! 317: if (hp = hostlookup(addr)) { ! 318: hp->h_flags |= (1 << (int)ip->il_mtype); ! 319: hostfree(hp); ! 320: hp->h_timer = HOSTDEADTIMER; ! 321: } ! 322: break; ! 323: ! 324: /* ! 325: * Error in data. Clear RFNM status for this host and send ! 326: * noops to the IMP to clear the interface. ! 327: */ ! 328: case IMPTYPE_BADDATA: ! 329: impmsg(sc, "data error"); ! 330: if (hp = hostlookup(addr)) ! 331: hp->h_rfnm = 0; ! 332: impnoops(sc); ! 333: break; ! 334: ! 335: /* ! 336: * Interface reset. ! 337: */ ! 338: case IMPTYPE_RESET: ! 339: impmsg(sc, "interface reset"); ! 340: /* clear RFNM counts */ ! 341: hostreset(((struct in_ifaddr *)&sc->imp_if.if_addrlist)->ia_net); ! 342: impnoops(sc); ! 343: break; ! 344: ! 345: default: ! 346: sc->imp_if.if_collisions++; /* XXX */ ! 347: break; ! 348: } ! 349: ! 350: rawlinkin: ! 351: if (inq == &impintrq) ! 352: schednetisr(NETISR_IMP); ! 353: /* ! 354: * Re-insert interface pointer in the mbuf chain ! 355: * for the next protocol up. ! 356: */ ! 357: if (M_HASCL(m) && (mtod(m, int) & CLOFSET) < sizeof(struct ifnet *)) { ! 358: struct mbuf *n; ! 359: ! 360: MGET(n, M_DONTWAIT, MT_HEADER); ! 361: if (n == 0) ! 362: goto drop; ! 363: n->m_next = m; ! 364: m = n; ! 365: m->m_len = 0; ! 366: m->m_off = MMINOFF + sizeof(struct ifnet *); ! 367: } ! 368: m->m_off -= sizeof(struct ifnet *); ! 369: m->m_len += sizeof(struct ifnet *); ! 370: *(mtod(m, struct ifnet **)) = ifp; ! 371: ! 372: if (IF_QFULL(inq)) { ! 373: IF_DROP(inq); ! 374: goto drop; ! 375: } ! 376: IF_ENQUEUE(inq, m); ! 377: return; ! 378: ! 379: drop: ! 380: m_freem(m); ! 381: } ! 382: ! 383: /* ! 384: * Bring the IMP down after notification. ! 385: */ ! 386: impdown(sc) ! 387: struct imp_softc *sc; ! 388: { ! 389: int s = splimp(); ! 390: ! 391: sc->imp_state = IMPS_DOWN; ! 392: impmsg(sc, "marked down"); ! 393: hostreset(((struct in_ifaddr *)&sc->imp_if.if_addrlist)->ia_net); ! 394: if_down(&sc->imp_if); ! 395: splx(s); ! 396: } ! 397: ! 398: /*VARARGS2*/ ! 399: impmsg(sc, fmt, a1, a2, a3) ! 400: struct imp_softc *sc; ! 401: char *fmt; ! 402: u_int a1; ! 403: { ! 404: ! 405: printf("imp%d: ", sc->imp_if.if_unit); ! 406: printf(fmt, a1, a2, a3); ! 407: printf("\n"); ! 408: } ! 409: ! 410: struct sockproto impproto = { PF_IMPLINK }; ! 411: struct sockaddr_in impdst = { AF_IMPLINK }; ! 412: struct sockaddr_in impsrc = { AF_IMPLINK }; ! 413: ! 414: /* ! 415: * Pick up the IMP "error" messages enqueued earlier, ! 416: * passing these up to the higher level protocol ! 417: * and the raw interface. ! 418: */ ! 419: impintr() ! 420: { ! 421: register struct mbuf *m; ! 422: register struct control_leader *cp; ! 423: struct ifnet *ifp; ! 424: int s; ! 425: ! 426: for (;;) { ! 427: s = splimp(); ! 428: IF_DEQUEUEIF(&impintrq, m, ifp); ! 429: splx(s); ! 430: if (m == 0) ! 431: return; ! 432: ! 433: cp = mtod(m, struct control_leader *); ! 434: imp_leader_to_addr(&impsrc.sin_addr, (struct imp_leader *)cp, ! 435: ifp); ! 436: impproto.sp_protocol = cp->dl_link; ! 437: impdst.sin_addr = IA_SIN(ifp->if_addrlist)->sin_addr; ! 438: ! 439: if (cp->dl_mtype == IMPTYPE_HOSTDEAD || ! 440: cp->dl_mtype == IMPTYPE_HOSTUNREACH) ! 441: switch (cp->dl_link) { ! 442: ! 443: case IMPLINK_IP: ! 444: pfctlinput((int)cp->dl_mtype, ! 445: (struct sockaddr *)&impsrc); ! 446: break; ! 447: default: ! 448: raw_ctlinput((int)cp->dl_mtype, ! 449: (struct sockaddr *)&impsrc); ! 450: break; ! 451: } ! 452: ! 453: raw_input(m, &impproto, (struct sockaddr *)&impsrc, ! 454: (struct sockaddr *)&impdst); ! 455: } ! 456: } ! 457: ! 458: /* ! 459: * ARPAnet 1822 output routine. ! 460: * Called from higher level protocol routines to set up messages for ! 461: * transmission to the imp. Sets up the header and calls impsnd to ! 462: * enqueue the message for this IMP's hardware driver. ! 463: */ ! 464: impoutput(ifp, m0, dst) ! 465: register struct ifnet *ifp; ! 466: struct mbuf *m0; ! 467: struct sockaddr *dst; ! 468: { ! 469: register struct imp_leader *imp; ! 470: register struct mbuf *m = m0; ! 471: int dlink, len; ! 472: int error = 0; ! 473: ! 474: /* ! 475: * Don't even try if the IMP is unavailable. ! 476: */ ! 477: if (imp_softc[ifp->if_unit].imp_state != IMPS_UP) { ! 478: error = ENETDOWN; ! 479: goto drop; ! 480: } ! 481: ! 482: switch (dst->sa_family) { ! 483: ! 484: case AF_INET: { ! 485: struct ip *ip = mtod(m, struct ip *); ! 486: ! 487: dlink = IMPLINK_IP; ! 488: len = ntohs((u_short)ip->ip_len); ! 489: break; ! 490: } ! 491: ! 492: case AF_IMPLINK: ! 493: len = 0; ! 494: do ! 495: len += m->m_len; ! 496: while (m = m->m_next); ! 497: m = m0; ! 498: goto leaderexists; ! 499: ! 500: default: ! 501: printf("imp%d: can't handle af%d\n", ifp->if_unit, ! 502: dst->sa_family); ! 503: error = EAFNOSUPPORT; ! 504: goto drop; ! 505: } ! 506: ! 507: /* ! 508: * Add IMP leader. If there's not enough space in the ! 509: * first mbuf, allocate another. If that should fail, we ! 510: * drop this sucker. ! 511: */ ! 512: if (m->m_off > MMAXOFF || ! 513: MMINOFF + sizeof(struct imp_leader) > m->m_off) { ! 514: m = m_get(M_DONTWAIT, MT_HEADER); ! 515: if (m == 0) { ! 516: error = ENOBUFS; ! 517: goto drop; ! 518: } ! 519: m->m_next = m0; ! 520: m->m_len = sizeof(struct imp_leader); ! 521: } else { ! 522: m->m_off -= sizeof(struct imp_leader); ! 523: m->m_len += sizeof(struct imp_leader); ! 524: } ! 525: imp = mtod(m, struct imp_leader *); ! 526: imp->il_format = IMP_NFF; ! 527: imp->il_mtype = IMPTYPE_DATA; ! 528: imp_addr_to_leader(imp, ! 529: ((struct sockaddr_in *)dst)->sin_addr.s_addr); /* BRL */ ! 530: imp->il_length = htons((u_short)len << 3); /* BRL */ ! 531: imp->il_link = dlink; ! 532: imp->il_flags = imp->il_htype = imp->il_subtype = 0; ! 533: ! 534: leaderexists: ! 535: return (impsnd(ifp, m)); ! 536: drop: ! 537: m_freem(m0); ! 538: return (error); ! 539: } ! 540: ! 541: /* ! 542: * Put a message on an interface's output queue. ! 543: * Perform RFNM counting: no more than 8 message may be ! 544: * in flight to any one host. ! 545: */ ! 546: impsnd(ifp, m) ! 547: struct ifnet *ifp; ! 548: struct mbuf *m; ! 549: { ! 550: register struct imp_leader *ip; ! 551: register struct host *hp; ! 552: struct impcb *icp; ! 553: int s, error; ! 554: ! 555: ip = mtod(m, struct imp_leader *); ! 556: ! 557: /* ! 558: * Do RFNM counting for data messages ! 559: * (no more than 8 outstanding to any host) ! 560: */ ! 561: s = splimp(); ! 562: if (ip->il_mtype == IMPTYPE_DATA) { ! 563: struct in_addr addr; ! 564: ! 565: imp_leader_to_addr(&addr, ip, ifp); /* BRL */ ! 566: if ((hp = hostlookup(addr)) == 0) ! 567: hp = hostenter(addr); ! 568: if (hp && (hp->h_flags & (HF_DEAD|HF_UNREACH))) { ! 569: error = hp->h_flags&HF_DEAD ? EHOSTDOWN : EHOSTUNREACH; ! 570: hp->h_flags &= ~HF_INUSE; ! 571: goto bad; ! 572: } ! 573: ! 574: /* ! 575: * If IMP would block, queue until RFNM ! 576: */ ! 577: if (hp) { ! 578: #ifndef NORFNM ! 579: if (hp->h_rfnm < 8) ! 580: #endif ! 581: { ! 582: hp->h_timer = HOSTTIMER; ! 583: hp->h_rfnm++; ! 584: goto enque; ! 585: } ! 586: if (hp->h_qcnt < 8) { /* high water mark */ ! 587: HOST_ENQUE(hp, m); ! 588: goto start; ! 589: } ! 590: } ! 591: error = ENOBUFS; ! 592: goto bad; ! 593: } ! 594: enque: ! 595: if (IF_QFULL(&ifp->if_snd)) { ! 596: IF_DROP(&ifp->if_snd); ! 597: error = ENOBUFS; ! 598: if (ip->il_mtype == IMPTYPE_DATA) ! 599: hp->h_rfnm--; ! 600: bad: ! 601: m_freem(m); ! 602: splx(s); ! 603: return (error); ! 604: } ! 605: IF_ENQUEUE(&ifp->if_snd, m); ! 606: start: ! 607: icp = &imp_softc[ifp->if_unit].imp_cb; ! 608: if (icp->ic_oactive == 0) ! 609: (*icp->ic_start)(ifp->if_unit); ! 610: splx(s); ! 611: return (0); ! 612: } ! 613: ! 614: /* ! 615: * Put three 1822 NOOPs at the head of the output queue. ! 616: * Part of host-IMP initialization procedure. ! 617: * (Should return success/failure, but noone knows ! 618: * what to do with this, so why bother?) ! 619: * This routine is always called at splimp, so we don't ! 620: * protect the call to IF_PREPEND. ! 621: */ ! 622: impnoops(sc) ! 623: register struct imp_softc *sc; ! 624: { ! 625: register i; ! 626: register struct mbuf *m; ! 627: register struct control_leader *cp; ! 628: ! 629: sc->imp_dropcnt = IMP_DROPCNT; ! 630: for (i = 0; i < IMP_DROPCNT + 1; i++) { ! 631: if ((m = m_getclr(M_DONTWAIT, MT_HEADER)) == 0) ! 632: return; ! 633: m->m_len = sizeof(struct control_leader); ! 634: cp = mtod(m, struct control_leader *); ! 635: cp->dl_format = IMP_NFF; ! 636: cp->dl_link = i; ! 637: cp->dl_mtype = IMPTYPE_NOOP; ! 638: IF_PREPEND(&sc->imp_if.if_snd, m); ! 639: } ! 640: if (sc->imp_cb.ic_oactive == 0) ! 641: (*sc->imp_cb.ic_start)(sc->imp_if.if_unit); ! 642: } ! 643: ! 644: /* ! 645: * Process an ioctl request. ! 646: */ ! 647: impioctl(ifp, cmd, data) ! 648: register struct ifnet *ifp; ! 649: int cmd; ! 650: caddr_t data; ! 651: { ! 652: struct ifaddr *ifa = (struct ifaddr *) data; ! 653: int s = splimp(), error = 0; ! 654: ! 655: switch (cmd) { ! 656: ! 657: case SIOCSIFADDR: ! 658: if (ifa->ifa_addr.sa_family != AF_INET) { ! 659: error = EINVAL; ! 660: break; ! 661: } ! 662: if ((ifp->if_flags & IFF_RUNNING) == 0) ! 663: impinit(ifp->if_unit); ! 664: break; ! 665: ! 666: default: ! 667: error = EINVAL; ! 668: } ! 669: splx(s); ! 670: return (error); ! 671: } ! 672: ! 673: #ifdef IMPLEADERS ! 674: printleader(routine, ip) ! 675: char *routine; ! 676: register struct imp_leader *ip; ! 677: { ! 678: printf("%s: ", routine); ! 679: printbyte((char *)ip, 12); ! 680: printf("<fmt=%x,net=%x,flags=%x,mtype=", ip->il_format, ip->il_network, ! 681: ip->il_flags); ! 682: if (ip->il_mtype <= IMPTYPE_READY) ! 683: printf("%s,", impleaders[ip->il_mtype]); ! 684: else ! 685: printf("%x,", ip->il_mtype); ! 686: printf("htype=%x,host=%x,imp=%x,link=", ip->il_htype, ip->il_host, ! 687: ntohs(ip->il_imp)); ! 688: if (ip->il_link == IMPLINK_IP) ! 689: printf("ip,"); ! 690: else ! 691: printf("%x,", ip->il_link); ! 692: printf("subtype=%x,len=%x>\n",ip->il_subtype,ntohs(ip->il_length)>>3); ! 693: } ! 694: ! 695: printbyte(cp, n) ! 696: register char *cp; ! 697: int n; ! 698: { ! 699: register i, j, c; ! 700: ! 701: for (i=0; i<n; i++) { ! 702: c = *cp++; ! 703: for (j=0; j<2; j++) ! 704: putchar("0123456789abcdef"[(c>>((1-j)*4))&0xf], 0); ! 705: putchar(' ', 0); ! 706: } ! 707: putchar('\n', 0); ! 708: } ! 709: #endif ! 710: ! 711: /* ! 712: * Routine to convert from IMP Leader to InterNet Address. ! 713: * ! 714: * This procedure is necessary because IMPs may be assigned Class A, B, or C ! 715: * network numbers, but only have 8 bits in the leader to reflect the ! 716: * IMP "network number". The strategy is to take the network number from ! 717: * the ifnet structure, and blend in the host-on-imp and imp-on-net numbers ! 718: * from the leader. ! 719: * ! 720: * There is no support for "Logical Hosts". ! 721: * ! 722: * Class A: Net.Host.0.Imp ! 723: * Class B: Net.net.Host.Imp ! 724: * Class C: Net.net.net.(Host4|Imp4) ! 725: */ ! 726: imp_leader_to_addr(ap, ip, ifp) ! 727: struct in_addr *ap; ! 728: register struct imp_leader *ip; ! 729: struct ifnet *ifp; ! 730: { ! 731: register u_long final; ! 732: register struct sockaddr_in *sin; ! 733: int imp = ntohs(ip->il_imp); ! 734: ! 735: sin = (struct sockaddr_in *)(&ifp->if_addrlist->ifa_addr); ! 736: final = ntohl(sin->sin_addr.s_addr); ! 737: ! 738: if (IN_CLASSA(final)) { ! 739: final &= IN_CLASSA_NET; ! 740: final |= (imp & 0xFF) | ((ip->il_host & 0xFF)<<16); ! 741: } else if (IN_CLASSB(final)) { ! 742: final &= IN_CLASSB_NET; ! 743: final |= (imp & 0xFF) | ((ip->il_host & 0xFF)<<8); ! 744: } else { ! 745: final &= IN_CLASSC_NET; ! 746: final |= (imp & 0x0F) | ((ip->il_host & 0x0F)<<4); ! 747: } ! 748: ap->s_addr = htonl(final); ! 749: } ! 750: ! 751: /* ! 752: * Function to take InterNet address and fill in IMP leader fields. ! 753: */ ! 754: imp_addr_to_leader(imp, a) ! 755: register struct imp_leader *imp; ! 756: u_long a; ! 757: { ! 758: register u_long addr = ntohl(a); ! 759: ! 760: imp->il_network = 0; /* !! */ ! 761: ! 762: if (IN_CLASSA(addr)) { ! 763: imp->il_host = ((addr>>16) & 0xFF); ! 764: imp->il_imp = addr & 0xFF; ! 765: } else if (IN_CLASSB(addr)) { ! 766: imp->il_host = ((addr>>8) & 0xFF); ! 767: imp->il_imp = addr & 0xFF; ! 768: } else { ! 769: imp->il_host = ((addr>>4) & 0xF); ! 770: imp->il_imp = addr & 0xF; ! 771: } ! 772: imp->il_imp = htons(imp->il_imp); ! 773: } ! 774: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.