![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to if_sl.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / sys / net|
Return to if_sl.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sys / net |
1.1 root 1: /*
2: * Copyright (c) 1987, 1989 Regents of the University of California.
3: * All rights reserved.
4: *
5: * Redistribution is only permitted until one year after the first shipment
6: * of 4.4BSD by the Regents. Otherwise, redistribution and use in source and
7: * binary forms are permitted provided that: (1) source distributions retain
8: * this entire copyright notice and comment, and (2) distributions including
9: * binaries display the following acknowledgement: This product includes
10: * software developed by the University of California, Berkeley and its
11: * contributors'' in the documentation or other materials provided with the
12: * distribution and in all advertising materials mentioning features or use
13: * of this software. Neither the name of the University nor the names of
14: * its contributors may be used to endorse or promote products derived from
15: * this software without specific prior written permission.
16: * THIS SOFTWARE IS PROVIDED AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
17: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
18: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
19: *
20: * @(#)if_sl.c 7.21 (Berkeley) 6/28/90
21: */
22:
23: /*
24: * Serial Line interface
25: *
26: * Rick Adams
27: * Center for Seismic Studies
28: * 1300 N 17th Street, Suite 1450
29: * Arlington, Virginia 22209
30: * (703)276-7900
31: * [email protected]
32: * seismo!rick
33: *
34: * Pounded on heavily by Chris Torek ([email protected], umcp-cs!chris).
35: * N.B.: this belongs in netinet, not net, the way it stands now.
36: * Should have a link-layer type designation, but wouldn't be
37: * backwards-compatible.
38: *
39: * Converted to 4.3BSD Beta by Chris Torek.
40: * Other changes made at Berkeley, based in part on code by Kirk Smith.
41: * W. Jolitz added slip abort.
42: *
43: * Hacked almost beyond recognition by Van Jacobson ([email protected]).
44: * Added priority queuing for "interactive" traffic; hooks for TCP
45: * header compression; ICMP filtering (at 2400 baud, some cretin
46: * pinging you can use up all your bandwidth). Made low clist behavior
47: * more robust and slightly less likely to hang serial line.
48: * Sped up a bunch of things.
49: *
50: * Note that splimp() is used throughout to block both (tty) input
51: * interrupts and network activity; thus, splimp must be >= spltty.
52: */
53:
54: /* $Header: if_sl.c,v 1.7 89/05/31 02:24:52 van Exp $ */
55: /* from if_sl.c,v 1.11 84/10/04 12:54:47 rick Exp */
56:
57: #include "sl.h"
58: #if NSL > 0
59:
60: #include "param.h"
61: #include "user.h"
62: #include "mbuf.h"
63: #include "buf.h"
64: #include "dkstat.h"
65: #include "socket.h"
66: #include "ioctl.h"
67: #include "file.h"
68: #include "tty.h"
69: #include "kernel.h"
70: #include "conf.h"
71: #include "errno.h"
72:
73: #include "if.h"
74: #include "if_types.h"
75: #include "netisr.h"
76: #include "route.h"
77: #if INET
78: #include "../netinet/in.h"
79: #include "../netinet/in_systm.h"
80: #include "../netinet/in_var.h"
81: #include "../netinet/ip.h"
82: #endif
83:
84: #include "machine/mtpr.h"
85:
86: #include "slcompress.h"
87: #include "if_slvar.h"
88:
89: /*
90: * SLMAX is a hard limit on input packet size. To simplify the code
91: * and improve performance, we require that packets fit in an mbuf
92: * cluster, and if we get a compressed packet, there's enough extra
93: * room to expand the header into a max length tcp/ip header (128
94: * bytes). So, SLMAX can be at most
95: * MCLBYTES - 128
96: *
97: * SLMTU is a hard limit on output packet size. To insure good
98: * interactive response, SLMTU wants to be the smallest size that
99: * amortizes the header cost. (Remember that even with
100: * type-of-service queuing, we have to wait for any in-progress
101: * packet to finish. I.e., we wait, on the average, 1/2 * mtu /
102: * cps, where cps is the line speed in characters per second.
103: * E.g., 533ms wait for a 1024 byte MTU on a 9600 baud line. The
104: * average compressed header size is 6-8 bytes so any MTU > 90
105: * bytes will give us 90% of the line bandwidth. A 100ms wait is
106: * tolerable (500ms is not), so want an MTU around 296. (Since TCP
107: * will send 256 byte segments (to allow for 40 byte headers), the
108: * typical packet size on the wire will be around 260 bytes). In
109: * 4.3tahoe+ systems, we can set an MTU in a route so we do that &
110: * leave the interface MTU relatively high (so we don't IP fragment
111: * when acting as a gateway to someone using a stupid MTU).
112: *
113: * Similar considerations apply to SLIP_HIWAT: It's the amount of
114: * data that will be queued 'downstream' of us (i.e., in clists
115: * waiting to be picked up by the tty output interrupt). If we
116: * queue a lot of data downstream, it's immune to our t.o.s. queuing.
117: * E.g., if SLIP_HIWAT is 1024, the interactive traffic in mixed
118: * telnet/ftp will see a 1 sec wait, independent of the mtu (the
119: * wait is dependent on the ftp window size but that's typically
120: * 1k - 4k). So, we want SLIP_HIWAT just big enough to amortize
121: * the cost (in idle time on the wire) of the tty driver running
122: * off the end of its clists & having to call back slstart for a
123: * new packet. For a tty interface with any buffering at all, this
124: * cost will be zero. Even with a totally brain dead interface (like
125: * the one on a typical workstation), the cost will be <= 1 character
126: * time. So, setting SLIP_HIWAT to ~100 guarantees that we'll lose
127: * at most 1% while maintaining good interactive response.
128: */
129: #define BUFOFFSET 128
130: #define SLMAX (MCLBYTES - BUFOFFSET)
131: #define SLBUFSIZE (SLMAX + BUFOFFSET)
132: #define SLMTU 296
133: #define SLIP_HIWAT roundup(50,CBSIZE)
134: #define CLISTRESERVE 1024 /* Can't let clists get too low */
135:
136: /*
137: * SLIP ABORT ESCAPE MECHANISM:
138: * (inspired by HAYES modem escape arrangement)
139: * 1sec escape 1sec escape 1sec escape { 1sec escape 1sec escape }
140: * signals a "soft" exit from slip mode by usermode process
141: */
142:
143: #define ABT_ESC '\033' /* can't be t_intr - distant host must know it*/
144: #define ABT_WAIT 1 /* in seconds - idle before an escape & after */
145: #define ABT_RECYCLE (5*2+2) /* in seconds - time window processing abort */
146:
147: #define ABT_SOFT 3 /* count of escapes */
148:
149: /*
150: * The following disgusting hack gets around the problem that IP TOS
151: * can't be set yet. We want to put "interactive" traffic on a high
152: * priority queue. To decide if traffic is interactive, we check that
153: * a) it is TCP and b) one of its ports is telnet, rlogin or ftp control.
154: */
155: static u_short interactive_ports[8] = {
156: 0, 513, 0, 0,
157: 0, 21, 0, 23,
158: };
159: #define INTERACTIVE(p) (interactive_ports[(p) & 7] == (p))
160:
161: struct sl_softc sl_softc[NSL];
162:
163: #define FRAME_END 0xc0 /* Frame End */
164: #define FRAME_ESCAPE 0xdb /* Frame Esc */
165: #define TRANS_FRAME_END 0xdc /* transposed frame end */
166: #define TRANS_FRAME_ESCAPE 0xdd /* transposed frame esc */
167:
168: #define t_sc T_LINEP
169:
170: int sloutput(), slioctl(), ttrstrt();
171: extern struct timeval time;
172:
173: /*
174: * Called from boot code to establish sl interfaces.
175: */
176: slattach()
177: {
178: register struct sl_softc *sc;
179: register int i = 0;
180:
181: for (sc = sl_softc; i < NSL; sc++) {
182: sc->sc_if.if_name = "sl";
183: sc->sc_if.if_unit = i++;
184: sc->sc_if.if_mtu = SLMTU;
185: sc->sc_if.if_flags = IFF_POINTOPOINT;
186: sc->sc_if.if_type = IFT_SLIP;
187: sc->sc_if.if_ioctl = slioctl;
188: sc->sc_if.if_output = sloutput;
189: sc->sc_if.if_snd.ifq_maxlen = 50;
190: sc->sc_fastq.ifq_maxlen = 32;
191: if_attach(&sc->sc_if);
192: }
193: }
194:
195: static int
196: slinit(sc)
197: register struct sl_softc *sc;
198: {
199: register caddr_t p;
200:
201: if (sc->sc_ep == (u_char *) 0) {
202: MCLALLOC(p, M_WAIT);
203: if (p)
204: sc->sc_ep = (u_char *)p + SLBUFSIZE;
205: else {
206: printf("sl%d: can't allocate buffer\n", sc - sl_softc);
207: sc->sc_if.if_flags &= ~IFF_UP;
208: return (0);
209: }
210: }
211: sc->sc_buf = sc->sc_ep - SLMAX;
212: sc->sc_mp = sc->sc_buf;
213: sl_compress_init(&sc->sc_comp);
214: return (1);
215: }
216:
217: /*
218: * Line specific open routine.
219: * Attach the given tty to the first available sl unit.
220: */
221: /* ARGSUSED */
222: slopen(dev, tp)
223: dev_t dev;
224: register struct tty *tp;
225: {
226: register struct sl_softc *sc;
227: register int nsl;
228: int error;
229:
230: if (error = suser(u.u_cred, &u.u_acflag))
231: return (error);
232:
233: if (tp->t_line == SLIPDISC)
234: return (0);
235:
236: for (nsl = NSL, sc = sl_softc; --nsl >= 0; sc++)
237: if (sc->sc_ttyp == NULL) {
238: if (slinit(sc) == 0)
239: return (ENOBUFS);
240: tp->t_sc = (caddr_t)sc;
241: sc->sc_ttyp = tp;
242: sc->sc_if.if_baudrate = tp->t_ospeed;
243: ttyflush(tp, FREAD | FWRITE);
244: return (0);
245: }
246: return (ENXIO);
247: }
248:
249: /*
250: * Line specific close routine.
251: * Detach the tty from the sl unit.
252: * Mimics part of ttyclose().
253: */
254: slclose(tp)
255: struct tty *tp;
256: {
257: register struct sl_softc *sc;
258: int s;
259:
260: ttywflush(tp);
261: s = splimp(); /* actually, max(spltty, splnet) */
262: tp->t_line = 0;
263: sc = (struct sl_softc *)tp->t_sc;
264: if (sc != NULL) {
265: if_down(&sc->sc_if);
266: sc->sc_ttyp = NULL;
267: tp->t_sc = NULL;
268: MCLFREE((caddr_t)(sc->sc_ep - SLBUFSIZE));
269: sc->sc_ep = 0;
270: sc->sc_mp = 0;
271: sc->sc_buf = 0;
272: }
273: splx(s);
274: }
275:
276: /*
277: * Line specific (tty) ioctl routine.
278: * Provide a way to get the sl unit number.
279: */
280: /* ARGSUSED */
281: sltioctl(tp, cmd, data, flag)
282: struct tty *tp;
283: caddr_t data;
284: {
285: struct sl_softc *sc = (struct sl_softc *)tp->t_sc;
286: int s;
287:
288: switch (cmd) {
289: case TIOCGETD: /* XXX */
290: case SLIOGUNIT:
291: *(int *)data = sc->sc_if.if_unit;
292: break;
293:
294: case SLIOCGFLAGS:
295: *(int *)data = sc->sc_flags;
296: break;
297:
298: case SLIOCSFLAGS:
299: #define SC_MASK 0xffff
300: s = splimp();
301: sc->sc_flags =
302: (sc->sc_flags &~ SC_MASK) | ((*(int *)data) & SC_MASK);
303: splx(s);
304: break;
305:
306: default:
307: return (-1);
308: }
309: return (0);
310: }
311:
312: /*
313: * Queue a packet. Start transmission if not active.
314: */
315: sloutput(ifp, m, dst)
316: struct ifnet *ifp;
317: register struct mbuf *m;
318: struct sockaddr *dst;
319: {
320: register struct sl_softc *sc = &sl_softc[ifp->if_unit];
321: register struct ip *ip;
322: register struct ifqueue *ifq;
323: int s;
324:
325: /*
326: * `Cannot happen' (see slioctl). Someday we will extend
327: * the line protocol to support other address families.
328: */
329: if (dst->sa_family != AF_INET) {
330: printf("sl%d: af%d not supported\n", sc->sc_if.if_unit,
331: dst->sa_family);
332: m_freem(m);
333: return (EAFNOSUPPORT);
334: }
335:
336: if (sc->sc_ttyp == NULL) {
337: m_freem(m);
338: return (ENETDOWN); /* sort of */
339: }
340: if ((sc->sc_ttyp->t_state & TS_CARR_ON) == 0) {
341: m_freem(m);
342: return (EHOSTUNREACH);
343: }
344: ifq = &sc->sc_if.if_snd;
345: if ((ip = mtod(m, struct ip *))->ip_p == IPPROTO_TCP) {
346: register int p = ((int *)ip)[ip->ip_hl];
347:
348: if (INTERACTIVE(p & 0xffff) || INTERACTIVE(p >> 16)) {
349: ifq = &sc->sc_fastq;
350: p = 1;
351: } else
352: p = 0;
353:
354: if (sc->sc_flags & SC_COMPRESS) {
355: /*
356: * The last parameter turns off connection id
357: * compression for background traffic: Since
358: * fastq traffic can jump ahead of the background
359: * traffic, we don't know what order packets will
360: * go on the line.
361: */
362: p = sl_compress_tcp(m, ip, &sc->sc_comp, p);
363: *mtod(m, u_char *) |= p;
364: }
365: } else if (sc->sc_flags & SC_NOICMP && ip->ip_p == IPPROTO_ICMP) {
366: m_freem(m);
367: return (0);
368: }
369: s = splimp();
370: if (IF_QFULL(ifq)) {
371: IF_DROP(ifq);
372: m_freem(m);
373: splx(s);
374: sc->sc_if.if_oerrors++;
375: return (ENOBUFS);
376: }
377: IF_ENQUEUE(ifq, m);
378: sc->sc_if.if_lastchange = time;
379: if (sc->sc_ttyp->t_outq.c_cc == 0)
380: slstart(sc->sc_ttyp);
381: splx(s);
382: return (0);
383: }
384:
385: /*
386: * Start output on interface. Get another datagram
387: * to send from the interface queue and map it to
388: * the interface before starting output.
389: */
390: slstart(tp)
391: register struct tty *tp;
392: {
393: register struct sl_softc *sc = (struct sl_softc *)tp->t_sc;
394: register struct mbuf *m;
395: register u_char *cp;
396: int s;
397: struct mbuf *m2;
398: extern int cfreecount;
399:
400: for (;;) {
401: /*
402: * If there is more in the output queue, just send it now.
403: * We are being called in lieu of ttstart and must do what
404: * it would.
405: */
406: if (tp->t_outq.c_cc != 0) {
407: (*tp->t_oproc)(tp);
408: if (tp->t_outq.c_cc > SLIP_HIWAT)
409: return;
410: }
411: /*
412: * This happens briefly when the line shuts down.
413: */
414: if (sc == NULL)
415: return;
416:
417: /*
418: * Get a packet and send it to the interface.
419: */
420: s = splimp();
421: IF_DEQUEUE(&sc->sc_fastq, m);
422: if (m == NULL)
423: IF_DEQUEUE(&sc->sc_if.if_snd, m);
424: splx(s);
425: if (m == NULL)
426: return;
427: sc->sc_if.if_lastchange = time;
428: /*
429: * If system is getting low on clists, just flush our
430: * output queue (if the stuff was important, it'll get
431: * retransmitted).
432: */
433: if (cfreecount < CLISTRESERVE + SLMTU) {
434: m_freem(m);
435: sc->sc_if.if_collisions++;
436: continue;
437: }
438:
439: /*
440: * The extra FRAME_END will start up a new packet, and thus
441: * will flush any accumulated garbage. We do this whenever
442: * the line may have been idle for some time.
443: */
444: if (tp->t_outq.c_cc == 0) {
445: ++sc->sc_bytessent;
446: (void) putc(FRAME_END, &tp->t_outq);
447: }
448:
449: while (m) {
450: register u_char *ep;
451:
452: cp = mtod(m, u_char *); ep = cp + m->m_len;
453: while (cp < ep) {
454: /*
455: * Find out how many bytes in the string we can
456: * handle without doing something special.
457: */
458: register u_char *bp = cp;
459:
460: while (cp < ep) {
461: switch (*cp++) {
462: case FRAME_ESCAPE:
463: case FRAME_END:
464: --cp;
465: goto out;
466: }
467: }
468: out:
469: if (cp > bp) {
470: /*
471: * Put n characters at once
472: * into the tty output queue.
473: */
474: if (b_to_q((char *)bp, cp - bp, &tp->t_outq))
475: break;
476: sc->sc_bytessent += cp - bp;
477: }
478: /*
479: * If there are characters left in the mbuf,
480: * the first one must be special..
481: * Put it out in a different form.
482: */
483: if (cp < ep) {
484: if (putc(FRAME_ESCAPE, &tp->t_outq))
485: break;
486: if (putc(*cp++ == FRAME_ESCAPE ?
487: TRANS_FRAME_ESCAPE : TRANS_FRAME_END,
488: &tp->t_outq)) {
489: (void) unputc(&tp->t_outq);
490: break;
491: }
492: sc->sc_bytessent += 2;
493: }
494: }
495: MFREE(m, m2);
496: m = m2;
497: }
498:
499: if (putc(FRAME_END, &tp->t_outq)) {
500: /*
501: * Not enough room. Remove a char to make room
502: * and end the packet normally.
503: * If you get many collisions (more than one or two
504: * a day) you probably do not have enough clists
505: * and you should increase "nclist" in param.c.
506: */
507: (void) unputc(&tp->t_outq);
508: (void) putc(FRAME_END, &tp->t_outq);
509: sc->sc_if.if_collisions++;
510: } else {
511: ++sc->sc_bytessent;
512: sc->sc_if.if_opackets++;
513: }
514: sc->sc_if.if_obytes = sc->sc_bytessent;
515: }
516: }
517:
518: /*
519: * Copy data buffer to mbuf chain; add ifnet pointer.
520: */
521: static struct mbuf *
522: sl_btom(sc, len)
523: register struct sl_softc *sc;
524: register int len;
525: {
526: register struct mbuf *m;
527:
528: MGETHDR(m, M_DONTWAIT, MT_DATA);
529: if (m == NULL)
530: return (NULL);
531:
532: /*
533: * If we have more than MHLEN bytes, it's cheaper to
534: * queue the cluster we just filled & allocate a new one
535: * for the input buffer. Otherwise, fill the mbuf we
536: * allocated above. Note that code in the input routine
537: * guarantees that packet will fit in a cluster.
538: */
539: if (len >= MHLEN) {
540: MCLGET(m, M_DONTWAIT);
541: if ((m->m_flags & M_EXT) == 0) {
542: /*
543: * we couldn't get a cluster - if memory's this
544: * low, it's time to start dropping packets.
545: */
546: (void) m_free(m);
547: return (NULL);
548: }
549: sc->sc_ep = mtod(m, u_char *) + SLBUFSIZE;
550: m->m_data = (caddr_t)sc->sc_buf;
551: m->m_ext.ext_buf = (caddr_t)((int)sc->sc_buf &~ MCLOFSET);
552: } else
553: bcopy((caddr_t)sc->sc_buf, mtod(m, caddr_t), len);
554:
555: m->m_len = len;
556: m->m_pkthdr.len = len;
557: m->m_pkthdr.rcvif = &sc->sc_if;
558: return (m);
559: }
560:
561: /*
562: * tty interface receiver interrupt.
563: */
564: slinput(c, tp)
565: register int c;
566: register struct tty *tp;
567: {
568: register struct sl_softc *sc;
569: register struct mbuf *m;
570: register int len;
571: int s;
572:
573: tk_nin++;
574: sc = (struct sl_softc *)tp->t_sc;
575: if (sc == NULL)
576: return;
577: if (!(tp->t_state&TS_CARR_ON)) /* XXX */
578: return;
579:
580: ++sc->sc_bytesrcvd;
581: ++sc->sc_if.if_ibytes;
582: c &= 0xff; /* XXX */
583:
584: #ifdef ABT_ESC
585: if (sc->sc_flags & SC_ABORT) {
586: /* if we see an abort after "idle" time, count it */
587: if (c == ABT_ESC && time.tv_sec >= sc->sc_lasttime + ABT_WAIT) {
588: sc->sc_abortcount++;
589: /* record when the first abort escape arrived */
590: if (sc->sc_abortcount == 1)
591: sc->sc_starttime = time.tv_sec;
592: }
593: /*
594: * if we have an abort, see that we have not run out of time,
595: * or that we have an "idle" time after the complete escape
596: * sequence
597: */
598: if (sc->sc_abortcount) {
599: if (time.tv_sec >= sc->sc_starttime + ABT_RECYCLE)
600: sc->sc_abortcount = 0;
601: if (sc->sc_abortcount >= ABT_SOFT &&
602: time.tv_sec >= sc->sc_lasttime + ABT_WAIT) {
603: slclose(tp);
604: return;
605: }
606: }
607: sc->sc_lasttime = time.tv_sec;
608: }
609: #endif
610:
611: switch (c) {
612:
613: case TRANS_FRAME_ESCAPE:
614: if (sc->sc_escape)
615: c = FRAME_ESCAPE;
616: break;
617:
618: case TRANS_FRAME_END:
619: if (sc->sc_escape)
620: c = FRAME_END;
621: break;
622:
623: case FRAME_ESCAPE:
624: sc->sc_escape = 1;
625: return;
626:
627: case FRAME_END:
628: len = sc->sc_mp - sc->sc_buf;
629: if (len < 3)
630: /* less than min length packet - ignore */
631: goto newpack;
632:
633: if ((c = (*sc->sc_buf & 0xf0)) != (IPVERSION << 4)) {
634: if (c & 0x80)
635: c = TYPE_COMPRESSED_TCP;
636: else if (c == TYPE_UNCOMPRESSED_TCP)
637: *sc->sc_buf &= 0x4f; /* XXX */
638: /*
639: * We've got something that's not an IP packet.
640: * If compression is enabled, try to decompress it.
641: * Otherwise, if `auto-enable' compression is on and
642: * it's a reasonable packet, decompress it and then
643: * enable compression. Otherwise, drop it.
644: */
645: if (sc->sc_flags & SC_COMPRESS) {
646: len = sl_uncompress_tcp(&sc->sc_buf, len,
647: (u_int)c, &sc->sc_comp);
648: if (len <= 0)
649: goto error;
650: } else if ((sc->sc_flags & SC_AUTOCOMP) &&
651: c == TYPE_UNCOMPRESSED_TCP && len >= 40) {
652: len = sl_uncompress_tcp(&sc->sc_buf, len,
653: (u_int)c, &sc->sc_comp);
654: if (len <= 0)
655: goto error;
656: sc->sc_flags |= SC_COMPRESS;
657: } else
658: goto error;
659: }
660: m = sl_btom(sc, len);
661: if (m == NULL)
662: goto error;
663:
664: sc->sc_if.if_ipackets++;
665: sc->sc_if.if_lastchange = time;
666: s = splimp();
667: if (IF_QFULL(&ipintrq)) {
668: IF_DROP(&ipintrq);
669: sc->sc_if.if_ierrors++;
670: sc->sc_if.if_iqdrops++;
671: m_freem(m);
672: } else {
673: IF_ENQUEUE(&ipintrq, m);
674: schednetisr(NETISR_IP);
675: }
676: splx(s);
677: goto newpack;
678: }
679: if (sc->sc_mp < sc->sc_ep) {
680: *sc->sc_mp++ = c;
681: sc->sc_escape = 0;
682: return;
683: }
684: error:
685: sc->sc_if.if_ierrors++;
686: newpack:
687: sc->sc_mp = sc->sc_buf = sc->sc_ep - SLMAX;
688: sc->sc_escape = 0;
689: }
690:
691: /*
692: * Process an ioctl request.
693: */
694: slioctl(ifp, cmd, data)
695: register struct ifnet *ifp;
696: int cmd;
697: caddr_t data;
698: {
699: register struct ifaddr *ifa = (struct ifaddr *)data;
700: int s = splimp(), error = 0;
701:
702: switch (cmd) {
703:
704: case SIOCSIFADDR:
705: if (ifa->ifa_addr->sa_family == AF_INET)
706: ifp->if_flags |= IFF_UP;
707: else
708: error = EAFNOSUPPORT;
709: break;
710:
711: case SIOCSIFDSTADDR:
712: if (ifa->ifa_addr->sa_family != AF_INET)
713: error = EAFNOSUPPORT;
714: break;
715:
716: default:
717: error = EINVAL;
718: }
719: splx(s);
720: return (error);
721: }
722: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.