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