![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to if_en.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Net/2] / Net2 / arch / vax / if|
Return to if_en.c CVS log | Up to [Net/2] / Net2 / arch / vax / if |
1.1 root 1: /*
2: * Copyright (c) 1982, 1986 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_en.c 7.7 (Berkeley) 12/16/90
34: */
35:
36: #include "en.h"
37: #if NEN > 0
38:
39: /*
40: * Xerox prototype (3 Mb) Ethernet interface driver.
41: */
42: #include "../include/pte.h"
43:
44: #include "sys/param.h"
45: #include "sys/systm.h"
46: #include "sys/mbuf.h"
47: #include "sys/buf.h"
48: #include "sys/protosw.h"
49: #include "sys/socket.h"
50: #include "sys/vmmac.h"
51: #include "sys/errno.h"
52: #include "sys/ioctl.h"
53:
54: #include "net/if.h"
55: #include "net/netisr.h"
56: #include "net/route.h"
57:
58: #ifdef INET
59: #include "netinet/in.h"
60: #include "netinet/in_systm.h"
61: #include "netinet/in_var.h"
62: #include "netinet/ip.h"
63: #endif
64:
65: #ifdef PUP
66: #include "netpup/pup.h"
67: #include "netpup/ether.h"
68: #endif
69:
70: #ifdef NS
71: #include "netns/ns.h"
72: #include "netns/ns_if.h"
73: #endif
74:
75: #include "../include/cpu.h"
76: #include "../include/mtpr.h"
77: #include "if_en.h"
78: #include "if_enreg.h"
79: #include "if_uba.h"
80: #include "../uba/ubareg.h"
81: #include "../uba/ubavar.h"
82:
83: #define ENMTU (1024+512)
84: #define ENMRU (1024+512+16) /* 16 is enough to receive trailer */
85:
86: int enprobe(), enattach(), enrint(), enxint(), encollide();
87: struct uba_device *eninfo[NEN];
88: u_short enstd[] = { 0 };
89: struct uba_driver endriver =
90: { enprobe, 0, enattach, 0, enstd, "en", eninfo };
91: #define ENUNIT(x) minor(x)
92:
93: int eninit(),oldenoutput(),enreset(),enioctl(), enstart();
94:
95: #ifdef notdef
96: /*
97: * If you need to byte swap IP's in the system, define
98: * this and do a SIOCSIFFLAGS at boot time.
99: */
100: #define ENF_SWABIPS 0x1000
101: #endif
102:
103: /*
104: * Ethernet software status per interface.
105: *
106: * Each interface is referenced by a network interface structure,
107: * es_if, which the routing code uses to locate the interface.
108: * This structure contains the output queue for the interface, its address, ...
109: * We also have, for each interface, a UBA interface structure, which
110: * contains information about the UNIBUS resources held by the interface:
111: * map registers, buffered data paths, etc. Information is cached in this
112: * structure for use by the if_uba.c routines in running the interface
113: * efficiently.
114: */
115: struct en_softc {
116: struct ifnet es_if; /* network-visible interface */
117: struct ifuba es_ifuba; /* UNIBUS resources */
118: short es_host; /* hardware host number */
119: short es_delay; /* current output delay */
120: short es_mask; /* mask for current output delay */
121: short es_lastx; /* host last transmitted to */
122: short es_oactive; /* is output active? */
123: short es_olen; /* length of last output */
124: short es_nsactive; /* is interface enabled for ns? */
125: } en_softc[NEN];
126:
127: /*
128: * Do output DMA to determine interface presence and
129: * interrupt vector. DMA is too short to disturb other hosts.
130: */
131: enprobe(reg)
132: caddr_t reg;
133: {
134: register int br, cvec; /* r11, r10 value-result */
135: register struct endevice *addr = (struct endevice *)reg;
136:
137: #ifdef lint
138: br = 0; cvec = br; br = cvec;
139: enrint(0); enxint(0); encollide(0);
140: #endif
141: addr->en_istat = 0;
142: addr->en_owc = -1;
143: addr->en_oba = 0;
144: addr->en_ostat = EN_IEN|EN_GO;
145: DELAY(100000);
146: addr->en_ostat = 0;
147: return (1);
148: }
149:
150: /*
151: * Interface exists: make available by filling in network interface
152: * record. System will initialize the interface when it is ready
153: * to accept packets.
154: */
155: enattach(ui)
156: struct uba_device *ui;
157: {
158: register struct en_softc *es = &en_softc[ui->ui_unit];
159:
160: es->es_if.if_unit = ui->ui_unit;
161: es->es_if.if_name = "en";
162: es->es_if.if_mtu = ENMTU;
163: es->es_if.if_flags = IFF_BROADCAST;
164: es->es_if.if_init = eninit;
165: es->es_if.if_output = oldenoutput;
166: es->es_if.if_start = enstart;
167: es->es_if.if_ioctl = enioctl;
168: es->es_if.if_reset = enreset;
169: es->es_ifuba.ifu_flags = UBA_NEEDBDP | UBA_NEED16 | UBA_CANTWAIT;
170: #if defined(VAX750)
171: /* don't chew up 750 bdp's */
172: if (cpu == VAX_750 && ui->ui_unit > 0)
173: es->es_ifuba.ifu_flags &= ~UBA_NEEDBDP;
174: #endif
175: if_attach(&es->es_if);
176: }
177:
178: /*
179: * Reset of interface after UNIBUS reset.
180: * If interface is on specified uba, reset its state.
181: */
182: enreset(unit, uban)
183: int unit, uban;
184: {
185: register struct uba_device *ui;
186:
187: if (unit >= NEN || (ui = eninfo[unit]) == 0 || ui->ui_alive == 0 ||
188: ui->ui_ubanum != uban)
189: return;
190: printf(" en%d", unit);
191: eninit(unit);
192: }
193:
194: /*
195: * Initialization of interface; clear recorded pending
196: * operations, and reinitialize UNIBUS usage.
197: */
198: eninit(unit)
199: int unit;
200: {
201: register struct en_softc *es = &en_softc[unit];
202: register struct uba_device *ui = eninfo[unit];
203: register struct endevice *addr;
204: int s;
205:
206: if (es->es_if.if_addrlist == (struct ifaddr *)0)
207: return;
208: if (if_ubainit(&es->es_ifuba, ui->ui_ubanum,
209: sizeof (struct en_header), (int)btoc(ENMRU)) == 0) {
210: printf("en%d: can't initialize\n", unit);
211: es->es_if.if_flags &= ~IFF_UP;
212: return;
213: }
214: addr = (struct endevice *)ui->ui_addr;
215: addr->en_istat = addr->en_ostat = 0;
216:
217: /*
218: * Hang a receive and start any
219: * pending writes by faking a transmit complete.
220: */
221: s = splimp();
222: addr->en_iba = es->es_ifuba.ifu_r.ifrw_info;
223: addr->en_iwc = -(sizeof (struct en_header) + ENMRU) >> 1;
224: addr->en_istat = EN_IEN|EN_GO;
225: es->es_oactive = 1;
226: es->es_if.if_flags |= IFF_RUNNING;
227: enxint(unit);
228: splx(s);
229: }
230:
231: int enalldelay = 0;
232: int enlastdel = 50;
233: int enlastmask = (~0) << 5;
234:
235: /*
236: * Start or restart output on interface.
237: * If interface is already active, then this is a retransmit
238: * after a collision, and just restuff registers and delay.
239: * If interface is not already active, get another datagram
240: * to send off of the interface queue, and map it to the interface
241: * before starting the output.
242: */
243: enstart(dev)
244: dev_t dev;
245: {
246: int unit = ENUNIT(dev);
247: struct uba_device *ui = eninfo[unit];
248: register struct en_softc *es = &en_softc[unit];
249: register struct endevice *addr;
250: register struct en_header *en;
251: struct mbuf *m;
252: int dest;
253:
254: if (es->es_oactive)
255: goto restart;
256:
257: /*
258: * Not already active: dequeue another request
259: * and map it to the UNIBUS. If no more requests,
260: * just return.
261: */
262: IF_DEQUEUE(&es->es_if.if_snd, m);
263: if (m == 0) {
264: es->es_oactive = 0;
265: return;
266: }
267: en = mtod(m, struct en_header *);
268: dest = en->en_dhost;
269: en->en_shost = es->es_host;
270: es->es_olen = if_wubaput(&es->es_ifuba, m);
271: #ifdef ENF_SWABIPS
272: /*
273: * The Xerox interface does word at a time DMA, so
274: * someone must do byte swapping of user data if high
275: * and low ender machines are to communicate. It doesn't
276: * belong here, but certain people depend on it, so...
277: *
278: * Should swab everybody, but this is a kludge anyway.
279: */
280: if (es->es_if.if_flags & ENF_SWABIPS) {
281: en = (struct en_header *)es->es_ifuba.ifu_w.ifrw_addr;
282: if (en->en_type == ENTYPE_IP)
283: enswab((caddr_t)(en + 1), (caddr_t)(en + 1),
284: es->es_olen - sizeof (struct en_header) + 1);
285: }
286: #endif
287:
288: /*
289: * Ethernet cannot take back-to-back packets (no
290: * buffering in interface. To help avoid overrunning
291: * receivers, enforce a small delay (about 1ms) in interface:
292: * * between all packets when enalldelay
293: * * whenever last packet was broadcast
294: * * whenever this packet is to same host as last packet
295: */
296: if (enalldelay || es->es_lastx == 0 || es->es_lastx == dest) {
297: es->es_delay = enlastdel;
298: es->es_mask = enlastmask;
299: }
300: es->es_lastx = dest;
301:
302: restart:
303: /*
304: * Have request mapped to UNIBUS for transmission.
305: * Purge any stale data from this BDP, and start the otput.
306: */
307: if (es->es_ifuba.ifu_flags & UBA_NEEDBDP)
308: UBAPURGE(es->es_ifuba.ifu_uba, es->es_ifuba.ifu_w.ifrw_bdp);
309: addr = (struct endevice *)ui->ui_addr;
310: addr->en_oba = (int)es->es_ifuba.ifu_w.ifrw_info;
311: addr->en_odelay = es->es_delay;
312: addr->en_owc = -((es->es_olen + 1) >> 1);
313: addr->en_ostat = EN_IEN|EN_GO;
314: es->es_oactive = 1;
315: }
316:
317: /*
318: * Ethernet interface transmitter interrupt.
319: * Start another output if more data to send.
320: */
321: enxint(unit)
322: int unit;
323: {
324: register struct uba_device *ui = eninfo[unit];
325: register struct en_softc *es = &en_softc[unit];
326: register struct endevice *addr = (struct endevice *)ui->ui_addr;
327:
328: if (es->es_oactive == 0)
329: return;
330: if (es->es_mask && (addr->en_ostat&EN_OERROR)) {
331: es->es_if.if_oerrors++;
332: endocoll(unit);
333: return;
334: }
335: es->es_if.if_opackets++;
336: es->es_oactive = 0;
337: es->es_delay = 0;
338: es->es_mask = ~0;
339: if (es->es_ifuba.ifu_xtofree) {
340: m_freem(es->es_ifuba.ifu_xtofree);
341: es->es_ifuba.ifu_xtofree = 0;
342: }
343: if (es->es_if.if_snd.ifq_head == 0) {
344: es->es_lastx = 256; /* putatively illegal */
345: return;
346: }
347: enstart(unit);
348: }
349:
350: /*
351: * Collision on ethernet interface. Do exponential
352: * backoff, and retransmit. If have backed off all
353: * the way print warning diagnostic, and drop packet.
354: */
355: encollide(unit)
356: int unit;
357: {
358: struct en_softc *es = &en_softc[unit];
359:
360: es->es_if.if_collisions++;
361: if (es->es_oactive == 0)
362: return;
363: endocoll(unit);
364: }
365:
366: endocoll(unit)
367: int unit;
368: {
369: register struct en_softc *es = &en_softc[unit];
370:
371: /*
372: * Es_mask is a 16 bit number with n low zero bits, with
373: * n the number of backoffs. When es_mask is 0 we have
374: * backed off 16 times, and give up.
375: */
376: if (es->es_mask == 0) {
377: printf("en%d: send error\n", unit);
378: enxint(unit);
379: return;
380: }
381: /*
382: * Another backoff. Restart with delay based on n low bits
383: * of the interval timer.
384: */
385: es->es_mask <<= 1;
386: es->es_delay = mfpr(ICR) &~ es->es_mask;
387: enstart(unit);
388: }
389:
390: #ifdef notdef
391: struct sockproto enproto = { AF_ETHERLINK };
392: struct sockaddr_en endst = { sizeof(endst), AF_ETHERLINK };
393: struct sockaddr_en ensrc = { sizeof(ensrc), AF_ETHERLINK };
394: #endif
395: /*
396: * Ethernet interface receiver interrupt.
397: * If input error just drop packet.
398: * Otherwise purge input buffered data path and examine
399: * packet to determine type. If can't determine length
400: * from type, then have to drop packet. Othewise decapsulate
401: * packet based on type and pass to type specific higher-level
402: * input routine.
403: */
404: enrint(unit)
405: int unit;
406: {
407: register struct en_softc *es = &en_softc[unit];
408: struct endevice *addr = (struct endevice *)eninfo[unit]->ui_addr;
409: register struct en_header *en;
410: struct mbuf *m;
411: int len; short resid;
412: register struct ifqueue *inq;
413: int off, s;
414:
415: es->es_if.if_ipackets++;
416:
417: /*
418: * Purge BDP; drop if input error indicated.
419: */
420: if (es->es_ifuba.ifu_flags & UBA_NEEDBDP)
421: UBAPURGE(es->es_ifuba.ifu_uba, es->es_ifuba.ifu_r.ifrw_bdp);
422: if (addr->en_istat&EN_IERROR) {
423: es->es_if.if_ierrors++;
424: goto setup;
425: }
426:
427: /*
428: * Calculate input data length.
429: * Get pointer to ethernet header (in input buffer).
430: * Deal with trailer protocol: if type is PUP trailer
431: * get true type from first 16-bit word past data.
432: * Remember that type was trailer by setting off.
433: */
434: resid = addr->en_iwc;
435: if (resid)
436: resid |= 0176000;
437: len = (((sizeof (struct en_header) + ENMRU) >> 1) + resid) << 1;
438: len -= sizeof (struct en_header);
439: if (len > ENMRU)
440: goto setup; /* sanity */
441: en = (struct en_header *)(es->es_ifuba.ifu_r.ifrw_addr);
442: en->en_type = ntohs(en->en_type);
443: #define endataaddr(en, off, type) ((type)(((caddr_t)((en)+1)+(off))))
444: if (en->en_type >= ENTYPE_TRAIL &&
445: en->en_type < ENTYPE_TRAIL+ENTYPE_NTRAILER) {
446: off = (en->en_type - ENTYPE_TRAIL) * 512;
447: if (off > ENMTU)
448: goto setup; /* sanity */
449: en->en_type = ntohs(*endataaddr(en, off, u_short *));
450: resid = ntohs(*(endataaddr(en, off+2, u_short *)));
451: if (off + resid > len)
452: goto setup; /* sanity */
453: len = off + resid;
454: } else
455: off = 0;
456: if (len == 0)
457: goto setup;
458: #ifdef ENF_SWABIPS
459: if (es->es_if.if_flags & ENF_SWABIPS && en->en_type == ENTYPE_IP)
460: enswab((caddr_t)(en + 1), (caddr_t)(en + 1), len);
461: #endif
462: /*
463: * Pull packet off interface. Off is nonzero if packet
464: * has trailing header; if_rubaget will then force this header
465: * information to be at the front, but we still have to drop
466: * the type and length which are at the front of any trailer data.
467: */
468: m = if_rubaget(&es->es_ifuba, len, off, &es->es_if);
469: if (m == 0)
470: goto setup;
471: switch (en->en_type) {
472:
473: #ifdef INET
474: case ENTYPE_IP:
475: schednetisr(NETISR_IP);
476: inq = &ipintrq;
477: break;
478: #endif
479: #ifdef PUP
480: case ENTYPE_PUP:
481: rpup_input(m);
482: goto setup;
483: #endif
484: #ifdef NS
485: case ETHERTYPE_NS:
486: if (es->es_nsactive) {
487: schednetisr(NETISR_NS);
488: inq = &nsintrq;
489: } else {
490: m_freem(m);
491: goto setup;
492: }
493: break;
494: #endif
495:
496: default:
497: #ifdef notdef
498: enproto.sp_protocol = en->en_type;
499: endst.sen_host = en->en_dhost;
500: endst.sen_net = ensrc.sen_net = es->es_if.if_net;
501: ensrc.sen_host = en->en_shost;
502: raw_input(m, &enproto,
503: (struct sockaddr *)&ensrc, (struct sockaddr *)&endst);
504: #else
505: m_freem(m);
506: #endif
507: goto setup;
508: }
509:
510: s = splimp();
511: if (IF_QFULL(inq)) {
512: IF_DROP(inq);
513: m_freem(m);
514: } else
515: IF_ENQUEUE(inq, m);
516: splx(s);
517:
518: setup:
519: /*
520: * Reset for next packet.
521: */
522: addr->en_iba = es->es_ifuba.ifu_r.ifrw_info;
523: addr->en_iwc = -(sizeof (struct en_header) + ENMRU) >> 1;
524: addr->en_istat = EN_IEN|EN_GO;
525: }
526:
527: /*
528: * Ethernet output routine.
529: * Encapsulate a packet of type family for the local net.
530: * Use trailer local net encapsulation if enough data in first
531: * packet leaves a multiple of 512 bytes of data in remainder.
532: */
533: oldenoutput(ifp, m0, dst)
534: struct ifnet *ifp;
535: struct mbuf *m0;
536: struct sockaddr *dst;
537: {
538: int type, dest, s, error;
539: register struct mbuf *m = m0;
540: register struct en_header *en;
541: register int off;
542:
543: if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING)) {
544: error = ENETDOWN;
545: goto bad;
546: }
547: switch (dst->sa_family) {
548:
549: #ifdef INET
550: case AF_INET:
551: {
552: struct in_addr in;
553:
554: in = ((struct sockaddr_in *)dst)->sin_addr;
555: if (in_broadcast(in))
556: dest = EN_BROADCAST;
557: else
558: dest = in_lnaof(in);
559: }
560: if (dest >= 0x100) {
561: error = EPERM; /* ??? */
562: goto bad;
563: }
564: off = m->m_pkthdr.len - m->m_len;
565: /* need per host negotiation */
566: if ((ifp->if_flags & IFF_NOTRAILERS) == 0)
567: if (off > 0 && (off & 0x1ff) == 0 &&
568: (m->m_flags & M_EXT) == 0 &&
569: m->m_data >= m->m_pktdat + 2 * sizeof (u_short)) {
570: type = ENTYPE_TRAIL + (off>>9);
571: m->m_data -= 2 * sizeof (u_short);
572: m->m_len += 2 * sizeof (u_short);
573: *mtod(m, u_short *) = htons((u_short)ENTYPE_IP);
574: *(mtod(m, u_short *) + 1) = ntohs((u_short)m->m_len);
575: goto gottrailertype;
576: }
577: type = ENTYPE_IP;
578: off = 0;
579: goto gottype;
580: #endif
581: #ifdef NS
582: case AF_NS:
583: {
584: u_char *up;
585:
586: type = ETHERTYPE_NS;
587: up = ((struct sockaddr_ns *)dst)->sns_addr.x_host.c_host;
588: if (*up & 1)
589: dest = EN_BROADCAST;
590: else
591: dest = up[5];
592:
593: off = 0;
594: goto gottype;
595: }
596: #endif
597: #ifdef PUP
598: case AF_PUP:
599: dest = ((struct sockaddr_pup *)dst)->spup_host;
600: type = ENTYPE_PUP;
601: off = 0;
602: goto gottype;
603: #endif
604:
605: #ifdef notdef
606: case AF_ETHERLINK:
607: goto gotheader;
608: #endif
609:
610: default:
611: printf("en%d: can't handle af%d\n", ifp->if_unit,
612: dst->sa_family);
613: error = EAFNOSUPPORT;
614: goto bad;
615: }
616:
617: gottrailertype:
618: /*
619: * Packet to be sent as trailer: move first packet
620: * (control information) to end of chain.
621: */
622: while (m->m_next)
623: m = m->m_next;
624: m->m_next = m0;
625: m = m0->m_next;
626: m0->m_next = 0;
627: m0 = m;
628:
629: gottype:
630: /*
631: * Add local net header. If no space in first mbuf,
632: * allocate another.
633: */
634: M_PREPEND(m, sizeof (struct en_header), M_DONTWAIT);
635: if (m == NULL)
636: return (ENOBUFS);
637: en = mtod(m, struct en_header *);
638: /* add en_shost later */
639: en->en_dhost = dest;
640: en->en_type = htons((u_short)type);
641:
642: #ifdef notdef
643: gotheader:
644: #endif
645: /*
646: * Queue message on interface, and start output if interface
647: * not yet active.
648: */
649: s = splimp();
650: if (IF_QFULL(&ifp->if_snd)) {
651: IF_DROP(&ifp->if_snd);
652: error = ENOBUFS;
653: goto qfull;
654: }
655: IF_ENQUEUE(&ifp->if_snd, m);
656: if (en_softc[ifp->if_unit].es_oactive == 0)
657: enstart(ifp->if_unit);
658: splx(s);
659: return (0);
660: qfull:
661: m0 = m;
662: splx(s);
663: bad:
664: m_freem(m0);
665: return (error);
666: }
667:
668: /*
669: * Process an ioctl request.
670: */
671: enioctl(ifp, cmd, data)
672: register struct ifnet *ifp;
673: int cmd;
674: caddr_t data;
675: {
676: register struct en_softc *es = ((struct en_softc *)ifp);
677: struct ifaddr *ifa = (struct ifaddr *) data;
678: int s = splimp(), error = 0;
679: struct endevice *enaddr;
680:
681: switch (cmd) {
682:
683: case SIOCSIFADDR:
684: enaddr = (struct endevice *)eninfo[ifp->if_unit]->ui_addr;
685: es->es_host = (~enaddr->en_addr) & 0xff;
686: /*
687: * Attempt to check agreement of protocol address
688: * and board address.
689: */
690: switch (ifa->ifa_addr->sa_family) {
691: case AF_INET:
692: if (in_lnaof(IA_SIN(ifa)->sin_addr) != es->es_host)
693: return (EADDRNOTAVAIL);
694: break;
695: #ifdef NS
696: case AF_NS:
697: if (IA_SNS(ifa)->sns_addr.x_host.c_host[5]
698: != es->es_host)
699: return (EADDRNOTAVAIL);
700: es->es_nsactive = 1;
701: break;
702: #endif
703: }
704: ifp->if_flags |= IFF_UP;
705: if ((ifp->if_flags & IFF_RUNNING) == 0)
706: eninit(ifp->if_unit);
707: break;
708:
709: default:
710: error = EINVAL;
711: break;
712: }
713: splx(s);
714: return (error);
715: }
716:
717: #ifdef ENF_SWABIPS
718: /*
719: * Swab bytes
720: * Jeffrey Mogul, Stanford
721: */
722: enswab(from, to, n)
723: register unsigned char *from, *to;
724: register int n;
725: {
726: register unsigned long temp;
727:
728: if ((n <= 0) || (n > 0xFFFF)) {
729: printf("enswab: bad len %d\n", n);
730: return;
731: }
732:
733: n >>= 1; n++;
734: #define STEP {temp = *from++;*to++ = *from++;*to++ = temp;}
735: /* round to multiple of 8 */
736: while ((--n) & 07)
737: STEP;
738: n >>= 3;
739: while (--n >= 0) {
740: STEP; STEP; STEP; STEP;
741: STEP; STEP; STEP; STEP;
742: }
743: }
744: #endif
745: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.