![[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 [Apple Darwin 0.x] / kernel / bsd / net|
Return to if_sl.c CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / net |
1.1 ! root 1: /* ! 2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved. ! 3: * ! 4: * @APPLE_LICENSE_HEADER_START@ ! 5: * ! 6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights ! 7: * Reserved. This file contains Original Code and/or Modifications of ! 8: * Original Code as defined in and that are subject to the Apple Public ! 9: * Source License Version 1.1 (the "License"). You may not use this file ! 10: * except in compliance with the License. Please obtain a copy of the ! 11: * License at http://www.apple.com/publicsource and read it before using ! 12: * this file. ! 13: * ! 14: * The Original Code and all software distributed under the License are ! 15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER ! 16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, ! 17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, ! 18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the ! 19: * License for the specific language governing rights and limitations ! 20: * under the License. ! 21: * ! 22: * @APPLE_LICENSE_HEADER_END@ ! 23: */ ! 24: ! 25: /* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */ ! 26: /* ! 27: * Copyright (c) 1987, 1989, 1992, 1993 ! 28: * The Regents of the University of California. All rights reserved. ! 29: * ! 30: * Redistribution and use in source and binary forms, with or without ! 31: * modification, are permitted provided that the following conditions ! 32: * are met: ! 33: * 1. Redistributions of source code must retain the above copyright ! 34: * notice, this list of conditions and the following disclaimer. ! 35: * 2. Redistributions in binary form must reproduce the above copyright ! 36: * notice, this list of conditions and the following disclaimer in the ! 37: * documentation and/or other materials provided with the distribution. ! 38: * 3. All advertising materials mentioning features or use of this software ! 39: * must display the following acknowledgement: ! 40: * This product includes software developed by the University of ! 41: * California, Berkeley and its contributors. ! 42: * 4. Neither the name of the University nor the names of its contributors ! 43: * may be used to endorse or promote products derived from this software ! 44: * without specific prior written permission. ! 45: * ! 46: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ! 47: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ! 48: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ! 49: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE ! 50: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ! 51: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ! 52: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ! 53: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ! 54: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ! 55: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ! 56: * SUCH DAMAGE. ! 57: * ! 58: * @(#)if_sl.c 8.9 (Berkeley) 1/9/95 ! 59: */ ! 60: ! 61: /* ! 62: * Serial Line interface ! 63: * ! 64: * Rick Adams ! 65: * Center for Seismic Studies ! 66: * 1300 N 17th Street, Suite 1450 ! 67: * Arlington, Virginia 22209 ! 68: * (703)276-7900 ! 69: * [email protected] ! 70: * seismo!rick ! 71: * ! 72: * Pounded on heavily by Chris Torek ([email protected], umcp-cs!chris). ! 73: * N.B.: this belongs in netinet, not net, the way it stands now. ! 74: * Should have a link-layer type designation, but wouldn't be ! 75: * backwards-compatible. ! 76: * ! 77: * Converted to 4.3BSD Beta by Chris Torek. ! 78: * Other changes made at Berkeley, based in part on code by Kirk Smith. ! 79: * W. Jolitz added slip abort. ! 80: * ! 81: * Hacked almost beyond recognition by Van Jacobson ([email protected]). ! 82: * Added priority queuing for "interactive" traffic; hooks for TCP ! 83: * header compression; ICMP filtering (at 2400 baud, some cretin ! 84: * pinging you can use up all your bandwidth). Made low clist behavior ! 85: * more robust and slightly less likely to hang serial line. ! 86: * Sped up a bunch of things. ! 87: * ! 88: * Note that splimp() is used throughout to block both (tty) input ! 89: * interrupts and network activity; thus, splimp must be >= spltty. ! 90: */ ! 91: ! 92: #include "sl.h" ! 93: #if NSL > 0 ! 94: ! 95: #include "bpfilter.h" ! 96: ! 97: #include <sys/param.h> ! 98: #include <sys/proc.h> ! 99: #include <sys/mbuf.h> ! 100: #include <sys/buf.h> ! 101: #include <sys/dkstat.h> ! 102: #include <sys/socket.h> ! 103: #include <sys/ioctl.h> ! 104: #include <sys/file.h> ! 105: #include <sys/tty.h> ! 106: #include <sys/kernel.h> ! 107: #include <sys/conf.h> ! 108: ! 109: #include <machine/cpu.h> ! 110: ! 111: #include <net/if.h> ! 112: #include <net/if_types.h> ! 113: #include <net/netisr.h> ! 114: #include <net/route.h> ! 115: ! 116: #if INET ! 117: #include <netinet/in.h> ! 118: #include <netinet/in_systm.h> ! 119: #include <netinet/in_var.h> ! 120: #include <netinet/ip.h> ! 121: #else ! 122: Huh? Slip without inet? ! 123: #endif ! 124: ! 125: #include <net/slcompress.h> ! 126: #include <net/if_slvar.h> ! 127: #include <net/slip.h> ! 128: ! 129: #if NBPFILTER > 0 ! 130: #include <sys/time.h> ! 131: #include <net/bpf.h> ! 132: #endif ! 133: ! 134: /* ! 135: * SLMAX is a hard limit on input packet size. To simplify the code ! 136: * and improve performance, we require that packets fit in an mbuf ! 137: * cluster, and if we get a compressed packet, there's enough extra ! 138: * room to expand the header into a max length tcp/ip header (128 ! 139: * bytes). So, SLMAX can be at most ! 140: * MCLBYTES - 128 ! 141: * ! 142: * SLMTU is a hard limit on output packet size. To insure good ! 143: * interactive response, SLMTU wants to be the smallest size that ! 144: * amortizes the header cost. (Remember that even with ! 145: * type-of-service queuing, we have to wait for any in-progress ! 146: * packet to finish. I.e., we wait, on the average, 1/2 * mtu / ! 147: * cps, where cps is the line speed in characters per second. ! 148: * E.g., 533ms wait for a 1024 byte MTU on a 9600 baud line. The ! 149: * average compressed header size is 6-8 bytes so any MTU > 90 ! 150: * bytes will give us 90% of the line bandwidth. A 100ms wait is ! 151: * tolerable (500ms is not), so want an MTU around 296. (Since TCP ! 152: * will send 256 byte segments (to allow for 40 byte headers), the ! 153: * typical packet size on the wire will be around 260 bytes). In ! 154: * 4.3tahoe+ systems, we can set an MTU in a route so we do that & ! 155: * leave the interface MTU relatively high (so we don't IP fragment ! 156: * when acting as a gateway to someone using a stupid MTU). ! 157: * ! 158: * Similar considerations apply to SLIP_HIWAT: It's the amount of ! 159: * data that will be queued 'downstream' of us (i.e., in clists ! 160: * waiting to be picked up by the tty output interrupt). If we ! 161: * queue a lot of data downstream, it's immune to our t.o.s. queuing. ! 162: * E.g., if SLIP_HIWAT is 1024, the interactive traffic in mixed ! 163: * telnet/ftp will see a 1 sec wait, independent of the mtu (the ! 164: * wait is dependent on the ftp window size but that's typically ! 165: * 1k - 4k). So, we want SLIP_HIWAT just big enough to amortize ! 166: * the cost (in idle time on the wire) of the tty driver running ! 167: * off the end of its clists & having to call back slstart for a ! 168: * new packet. For a tty interface with any buffering at all, this ! 169: * cost will be zero. Even with a totally brain dead interface (like ! 170: * the one on a typical workstation), the cost will be <= 1 character ! 171: * time. So, setting SLIP_HIWAT to ~100 guarantees that we'll lose ! 172: * at most 1% while maintaining good interactive response. ! 173: */ ! 174: #if NBPFILTER > 0 ! 175: #define BUFOFFSET (128+sizeof(struct ifnet **)+SLIP_HDRLEN) ! 176: #else ! 177: #define BUFOFFSET (128+sizeof(struct ifnet **)) ! 178: #endif ! 179: #define SLMAX (MCLBYTES - BUFOFFSET) ! 180: #define SLBUFSIZE (SLMAX + BUFOFFSET) ! 181: #define SLMTU 296 ! 182: #define SLIP_HIWAT roundup(50,CBSIZE) ! 183: ! 184: /* ! 185: * SLIP ABORT ESCAPE MECHANISM: ! 186: * (inspired by HAYES modem escape arrangement) ! 187: * 1sec escape 1sec escape 1sec escape { 1sec escape 1sec escape } ! 188: * within window time signals a "soft" exit from slip mode by remote end ! 189: * if the IFF_DEBUG flag is on. ! 190: */ ! 191: #define ABT_ESC '\033' /* can't be t_intr - distant host must know it*/ ! 192: #define ABT_IDLE 1 /* in seconds - idle before an escape */ ! 193: #define ABT_COUNT 3 /* count of escapes for abort */ ! 194: #define ABT_WINDOW (ABT_COUNT*2+2) /* in seconds - time to count */ ! 195: ! 196: struct sl_softc sl_softc[NSL]; ! 197: ! 198: #define FRAME_END 0xc0 /* Frame End */ ! 199: #define FRAME_ESCAPE 0xdb /* Frame Esc */ ! 200: #define TRANS_FRAME_END 0xdc /* transposed frame end */ ! 201: #define TRANS_FRAME_ESCAPE 0xdd /* transposed frame esc */ ! 202: ! 203: static int slinit __P((struct sl_softc *)); ! 204: static struct mbuf *sl_btom __P((struct sl_softc *, int)); ! 205: ! 206: /* ! 207: * Called from boot code to establish sl interfaces. ! 208: */ ! 209: void ! 210: slattach() ! 211: { ! 212: register struct sl_softc *sc; ! 213: register int i = 0; ! 214: ! 215: for (sc = sl_softc; i < NSL; sc++) { ! 216: sc->sc_if.if_name = "sl"; ! 217: sc->sc_if.if_next = NULL; ! 218: sc->sc_if.if_unit = i++; ! 219: sc->sc_if.if_mtu = SLMTU; ! 220: sc->sc_if.if_flags = ! 221: IFF_POINTOPOINT | SC_AUTOCOMP | IFF_MULTICAST; ! 222: sc->sc_if.if_type = IFT_SLIP; ! 223: sc->sc_if.if_ioctl = slioctl; ! 224: sc->sc_if.if_output = sloutput; ! 225: sc->sc_if.if_snd.ifq_maxlen = 50; ! 226: sc->sc_fastq.ifq_maxlen = 32; ! 227: if_attach(&sc->sc_if); ! 228: #if NBPFILTER > 0 ! 229: bpfattach(&sc->sc_bpf, &sc->sc_if, DLT_SLIP, SLIP_HDRLEN); ! 230: #endif ! 231: } ! 232: } ! 233: ! 234: static int ! 235: slinit(sc) ! 236: register struct sl_softc *sc; ! 237: { ! 238: register caddr_t p; ! 239: ! 240: if (sc->sc_ep == (u_char *) 0) { ! 241: MCLALLOC(p, M_WAIT); ! 242: if (p) ! 243: sc->sc_ep = (u_char *)p + SLBUFSIZE; ! 244: else { ! 245: printf("sl%d: can't allocate buffer\n", sc - sl_softc); ! 246: sc->sc_if.if_flags &= ~IFF_UP; ! 247: return (0); ! 248: } ! 249: } ! 250: sc->sc_buf = sc->sc_ep - SLMAX; ! 251: sc->sc_mp = sc->sc_buf; ! 252: sl_compress_init(&sc->sc_comp, -1); ! 253: return (1); ! 254: } ! 255: ! 256: /* ! 257: * Line specific open routine. ! 258: * Attach the given tty to the first available sl unit. ! 259: */ ! 260: /* ARGSUSED */ ! 261: int ! 262: slopen(dev, tp) ! 263: dev_t dev; ! 264: register struct tty *tp; ! 265: { ! 266: struct proc *p = curproc; /* XXX */ ! 267: register struct sl_softc *sc; ! 268: register int nsl; ! 269: int error; ! 270: int s; ! 271: ! 272: if (error = suser(p->p_ucred, &p->p_acflag)) ! 273: return (error); ! 274: ! 275: if (tp->t_line == SLIPDISC) ! 276: return (0); ! 277: ! 278: for (nsl = NSL, sc = sl_softc; --nsl >= 0; sc++) ! 279: if (sc->sc_ttyp == NULL) { ! 280: if (slinit(sc) == 0) ! 281: return (ENOBUFS); ! 282: tp->t_sc = (caddr_t)sc; ! 283: sc->sc_ttyp = tp; ! 284: sc->sc_if.if_baudrate = tp->t_ospeed; ! 285: ttyflush(tp, FREAD | FWRITE); ! 286: ! 287: /* ! 288: * make sure tty output queue is large enough ! 289: * to hold a full-sized packet (including frame ! 290: * end, and a possible extra frame end). full-sized ! 291: * packet occupies a max of 2*SLMTU bytes (because ! 292: * of possible escapes), and add two on for frame ! 293: * ends. ! 294: */ ! 295: s = spltty(); ! 296: if (tp->t_outq.c_cn < 2*SLMTU+2) { ! 297: sc->sc_oldbufsize = tp->t_outq.c_cn; ! 298: sc->sc_oldbufquot = tp->t_outq.c_cq != 0; ! 299: ! 300: clfree(&tp->t_outq); ! 301: error = clalloc(&tp->t_outq, 3*SLMTU, 0); ! 302: if (error) { ! 303: splx(s); ! 304: return(error); ! 305: } ! 306: } else ! 307: sc->sc_oldbufsize = sc->sc_oldbufquot = 0; ! 308: splx(s); ! 309: ! 310: return (0); ! 311: } ! 312: return (ENXIO); ! 313: } ! 314: ! 315: /* ! 316: * Line specific close routine. ! 317: * Detach the tty from the sl unit. ! 318: */ ! 319: void ! 320: slclose(tp) ! 321: struct tty *tp; ! 322: { ! 323: register struct sl_softc *sc; ! 324: int s; ! 325: ! 326: ttywflush(tp); ! 327: s = splimp(); /* actually, max(spltty, splnet) */ ! 328: tp->t_line = 0; ! 329: tp->t_state = 0; ! 330: sc = (struct sl_softc *)tp->t_sc; ! 331: if (sc != NULL) { ! 332: if_down(&sc->sc_if); ! 333: sc->sc_ttyp = NULL; ! 334: tp->t_sc = NULL; ! 335: MCLFREE((caddr_t)(sc->sc_ep - SLBUFSIZE)); ! 336: sc->sc_ep = 0; ! 337: sc->sc_mp = 0; ! 338: sc->sc_buf = 0; ! 339: } ! 340: /* if necessary, install a new outq buffer of the appropriate size */ ! 341: if (sc->sc_oldbufsize != 0) { ! 342: clfree(&tp->t_outq); ! 343: clalloc(&tp->t_outq, sc->sc_oldbufsize, sc->sc_oldbufquot); ! 344: } ! 345: splx(s); ! 346: } ! 347: ! 348: /* ! 349: * Line specific (tty) ioctl routine. ! 350: * Provide a way to get the sl unit number. ! 351: */ ! 352: /* ARGSUSED */ ! 353: int ! 354: sltioctl(tp, cmd, data, flag) ! 355: struct tty *tp; ! 356: u_long cmd; ! 357: caddr_t data; ! 358: int flag; ! 359: { ! 360: struct sl_softc *sc = (struct sl_softc *)tp->t_sc; ! 361: ! 362: switch (cmd) { ! 363: case SLIOCGUNIT: ! 364: *(int *)data = sc->sc_if.if_unit; ! 365: break; ! 366: ! 367: default: ! 368: return (-1); ! 369: } ! 370: return (0); ! 371: } ! 372: ! 373: /* ! 374: * Queue a packet. Start transmission if not active. ! 375: * Compression happens in slstart; if we do it here, IP TOS ! 376: * will cause us to not compress "background" packets, because ! 377: * ordering gets trashed. It can be done for all packets in slstart. ! 378: */ ! 379: int ! 380: sloutput(ifp, m, dst, rtp) ! 381: struct ifnet *ifp; ! 382: register struct mbuf *m; ! 383: struct sockaddr *dst; ! 384: struct rtentry *rtp; ! 385: { ! 386: register struct sl_softc *sc = &sl_softc[ifp->if_unit]; ! 387: register struct ip *ip; ! 388: register struct ifqueue *ifq; ! 389: int s; ! 390: ! 391: /* ! 392: * `Cannot happen' (see slioctl). Someday we will extend ! 393: * the line protocol to support other address families. ! 394: */ ! 395: if (dst->sa_family != AF_INET) { ! 396: printf("sl%d: af%d not supported\n", sc->sc_if.if_unit, ! 397: dst->sa_family); ! 398: m_freem(m); ! 399: sc->sc_if.if_noproto++; ! 400: return (EAFNOSUPPORT); ! 401: } ! 402: ! 403: if (sc->sc_ttyp == NULL) { ! 404: m_freem(m); ! 405: return (ENETDOWN); /* sort of */ ! 406: } ! 407: if ((sc->sc_ttyp->t_state & TS_CARR_ON) == 0 && ! 408: (sc->sc_ttyp->t_cflag & CLOCAL) == 0) { ! 409: m_freem(m); ! 410: return (EHOSTUNREACH); ! 411: } ! 412: ifq = &sc->sc_if.if_snd; ! 413: ip = mtod(m, struct ip *); ! 414: if (sc->sc_if.if_flags & SC_NOICMP && ip->ip_p == IPPROTO_ICMP) { ! 415: m_freem(m); ! 416: return (ENETRESET); /* XXX ? */ ! 417: } ! 418: if (ip->ip_tos & IPTOS_LOWDELAY) ! 419: ifq = &sc->sc_fastq; ! 420: s = splimp(); ! 421: if (sc->sc_oqlen && sc->sc_ttyp->t_outq.c_cc == sc->sc_oqlen) { ! 422: /* if output's been stalled for too long, and restart */ ! 423: timersub(&time, &sc->sc_if.if_lastchange, &tv); ! 424: if (tv.tv_sec > 0) { ! 425: sc->sc_otimeout++; ! 426: slstart(sc->sc_ttyp); ! 427: } ! 428: } ! 429: if (IF_QFULL(ifq)) { ! 430: IF_DROP(ifq); ! 431: m_freem(m); ! 432: splx(s); ! 433: sc->sc_if.if_oerrors++; ! 434: return (ENOBUFS); ! 435: } ! 436: IF_ENQUEUE(ifq, m); ! 437: sc->sc_if.if_lastchange = time; ! 438: if ((sc->sc_oqlen = sc->sc_ttyp->t_outq.c_cc) == 0) ! 439: slstart(sc->sc_ttyp); ! 440: splx(s); ! 441: return (0); ! 442: } ! 443: ! 444: /* ! 445: * Start output on interface. Get another datagram ! 446: * to send from the interface queue and map it to ! 447: * the interface before starting output. ! 448: */ ! 449: void ! 450: slstart(tp) ! 451: register struct tty *tp; ! 452: { ! 453: register struct sl_softc *sc = (struct sl_softc *)tp->t_sc; ! 454: register struct mbuf *m; ! 455: register u_char *cp; ! 456: register struct ip *ip; ! 457: int s; ! 458: struct mbuf *m2; ! 459: #if NBPFILTER > 0 ! 460: u_char bpfbuf[SLMTU + SLIP_HDRLEN]; ! 461: register int len; ! 462: #endif ! 463: ! 464: for (;;) { ! 465: /* ! 466: * If there is more in the output queue, just send it now. ! 467: * We are being called in lieu of ttstart and must do what ! 468: * it would. ! 469: */ ! 470: if (tp->t_outq.c_cc != 0) { ! 471: (*tp->t_oproc)(tp); ! 472: if (tp->t_outq.c_cc > SLIP_HIWAT) ! 473: return; ! 474: } ! 475: /* ! 476: * This happens briefly when the line shuts down. ! 477: */ ! 478: if (sc == NULL) ! 479: return; ! 480: ! 481: /* ! 482: * Do not remove the packet from the IP queue if it ! 483: * doesn't look like the packet will fit into the ! 484: * current serial output queue, with a packet full of ! 485: * escapes this could be as bad as SLMTU*2+2. ! 486: */ ! 487: if (tp->t_outq.c_cn - tp->t_outq.c_cc < 2*SLMTU+2) ! 488: return; ! 489: ! 490: /* ! 491: * Get a packet and send it to the interface. ! 492: */ ! 493: s = splimp(); ! 494: IF_DEQUEUE(&sc->sc_fastq, m); ! 495: if (m) ! 496: sc->sc_if.if_omcasts++; /* XXX */ ! 497: else ! 498: IF_DEQUEUE(&sc->sc_if.if_snd, m); ! 499: splx(s); ! 500: if (m == NULL) ! 501: return; ! 502: ! 503: /* ! 504: * We do the header compression here rather than in sloutput ! 505: * because the packets will be out of order if we are using TOS ! 506: * queueing, and the connection id compression will get ! 507: * munged when this happens. ! 508: */ ! 509: #if NBPFILTER > 0 ! 510: if (sc->sc_bpf) { ! 511: /* ! 512: * We need to save the TCP/IP header before it's ! 513: * compressed. To avoid complicated code, we just ! 514: * copy the entire packet into a stack buffer (since ! 515: * this is a serial line, packets should be short ! 516: * and/or the copy should be negligible cost compared ! 517: * to the packet transmission time). ! 518: */ ! 519: register struct mbuf *m1 = m; ! 520: register u_char *cp = bpfbuf + SLIP_HDRLEN; ! 521: ! 522: len = 0; ! 523: do { ! 524: register int mlen = m1->m_len; ! 525: ! 526: bcopy(mtod(m1, caddr_t), cp, mlen); ! 527: cp += mlen; ! 528: len += mlen; ! 529: } while (m1 = m1->m_next); ! 530: } ! 531: #endif ! 532: if ((ip = mtod(m, struct ip *))->ip_p == IPPROTO_TCP) { ! 533: if (sc->sc_if.if_flags & SC_COMPRESS) ! 534: *mtod(m, u_char *) |= sl_compress_tcp(m, ip, ! 535: &sc->sc_comp, 1); ! 536: } ! 537: #if NBPFILTER > 0 ! 538: if (sc->sc_bpf) { ! 539: /* ! 540: * Put the SLIP pseudo-"link header" in place. The ! 541: * compressed header is now at the beginning of the ! 542: * mbuf. ! 543: */ ! 544: bpfbuf[SLX_DIR] = SLIPDIR_OUT; ! 545: bcopy(mtod(m, caddr_t), &bpfbuf[SLX_CHDR], CHDR_LEN); ! 546: BPF_TAP(sc->sc_bpf, bpfbuf, len + SLIP_HDRLEN); ! 547: } ! 548: #endif ! 549: sc->sc_if.if_lastchange = time; ! 550: ! 551: /* ! 552: * The extra FRAME_END will start up a new packet, and thus ! 553: * will flush any accumulated garbage. We do this whenever ! 554: * the line may have been idle for some time. ! 555: */ ! 556: if (tp->t_outq.c_cc == 0) { ! 557: ++sc->sc_if.if_obytes; ! 558: (void) putc(FRAME_END, &tp->t_outq); ! 559: } ! 560: ! 561: while (m) { ! 562: register u_char *ep; ! 563: ! 564: cp = mtod(m, u_char *); ep = cp + m->m_len; ! 565: while (cp < ep) { ! 566: /* ! 567: * Find out how many bytes in the string we can ! 568: * handle without doing something special. ! 569: */ ! 570: register u_char *bp = cp; ! 571: ! 572: while (cp < ep) { ! 573: switch (*cp++) { ! 574: case FRAME_ESCAPE: ! 575: case FRAME_END: ! 576: --cp; ! 577: goto out; ! 578: } ! 579: } ! 580: out: ! 581: if (cp > bp) { ! 582: /* ! 583: * Put n characters at once ! 584: * into the tty output queue. ! 585: */ ! 586: if (b_to_q((u_char *)bp, cp - bp, ! 587: &tp->t_outq)) ! 588: break; ! 589: sc->sc_if.if_obytes += cp - bp; ! 590: } ! 591: /* ! 592: * If there are characters left in the mbuf, ! 593: * the first one must be special.. ! 594: * Put it out in a different form. ! 595: */ ! 596: if (cp < ep) { ! 597: if (putc(FRAME_ESCAPE, &tp->t_outq)) ! 598: break; ! 599: if (putc(*cp++ == FRAME_ESCAPE ? ! 600: TRANS_FRAME_ESCAPE : TRANS_FRAME_END, ! 601: &tp->t_outq)) { ! 602: (void) unputc(&tp->t_outq); ! 603: break; ! 604: } ! 605: sc->sc_if.if_obytes += 2; ! 606: } ! 607: } ! 608: MFREE(m, m2); ! 609: m = m2; ! 610: } ! 611: ! 612: if (putc(FRAME_END, &tp->t_outq)) { ! 613: /* ! 614: * Not enough room. Remove a char to make room ! 615: * and end the packet normally. ! 616: * If you get many collisions (more than one or two ! 617: * a day) you probably do not have enough clists ! 618: * and you should increase "nclist" in param.c. ! 619: */ ! 620: (void) unputc(&tp->t_outq); ! 621: (void) putc(FRAME_END, &tp->t_outq); ! 622: sc->sc_if.if_collisions++; ! 623: } else { ! 624: ++sc->sc_if.if_obytes; ! 625: sc->sc_if.if_opackets++; ! 626: } ! 627: } ! 628: } ! 629: ! 630: /* ! 631: * Copy data buffer to mbuf chain; add ifnet pointer. ! 632: */ ! 633: static struct mbuf * ! 634: sl_btom(sc, len) ! 635: register struct sl_softc *sc; ! 636: register int len; ! 637: { ! 638: register struct mbuf *m; ! 639: ! 640: MGETHDR(m, M_DONTWAIT, MT_DATA); ! 641: if (m == NULL) ! 642: return (NULL); ! 643: ! 644: /* ! 645: * If we have more than MHLEN bytes, it's cheaper to ! 646: * queue the cluster we just filled & allocate a new one ! 647: * for the input buffer. Otherwise, fill the mbuf we ! 648: * allocated above. Note that code in the input routine ! 649: * guarantees that packet will fit in a cluster. ! 650: */ ! 651: if (len >= MHLEN) { ! 652: MCLGET(m, M_DONTWAIT); ! 653: if ((m->m_flags & M_EXT) == 0) { ! 654: /* ! 655: * we couldn't get a cluster - if memory's this ! 656: * low, it's time to start dropping packets. ! 657: */ ! 658: (void) m_free(m); ! 659: return (NULL); ! 660: } ! 661: sc->sc_ep = mtod(m, u_char *) + SLBUFSIZE; ! 662: m->m_data = (caddr_t)sc->sc_buf; ! 663: m->m_ext.ext_buf = (caddr_t)((long)sc->sc_buf &~ MCLOFSET); ! 664: } else ! 665: bcopy((caddr_t)sc->sc_buf, mtod(m, caddr_t), len); ! 666: ! 667: m->m_len = len; ! 668: m->m_pkthdr.len = len; ! 669: m->m_pkthdr.rcvif = &sc->sc_if; ! 670: return (m); ! 671: } ! 672: ! 673: /* ! 674: * tty interface receiver interrupt. ! 675: */ ! 676: void ! 677: slinput(c, tp) ! 678: register int c; ! 679: register struct tty *tp; ! 680: { ! 681: register struct sl_softc *sc; ! 682: register struct mbuf *m; ! 683: register int len; ! 684: int s; ! 685: #if NBPFILTER > 0 ! 686: u_char chdr[CHDR_LEN]; ! 687: #endif ! 688: ! 689: tk_nin++; ! 690: sc = (struct sl_softc *)tp->t_sc; ! 691: if (sc == NULL) ! 692: return; ! 693: if (c & TTY_ERRORMASK || ((tp->t_state & TS_CARR_ON) == 0 && ! 694: (tp->t_cflag & CLOCAL) == 0)) { ! 695: sc->sc_flags |= SC_ERROR; ! 696: return; ! 697: } ! 698: c &= TTY_CHARMASK; ! 699: ! 700: ++sc->sc_if.if_ibytes; ! 701: ! 702: if (sc->sc_if.if_flags & IFF_DEBUG) { ! 703: ! 704: if (c == ABT_ESC) { ! 705: /* ! 706: * If we have a previous abort, see whether ! 707: * this one is within the time limit. ! 708: */ ! 709: if (sc->sc_abortcount && ! 710: time.tv_sec >= sc->sc_starttime + ABT_WINDOW) ! 711: sc->sc_abortcount = 0; ! 712: /* ! 713: * If we see an abort after "idle" time, count it; ! 714: * record when the first abort escape arrived. ! 715: */ ! 716: if (time.tv_sec >= sc->sc_lasttime + ABT_IDLE) { ! 717: if (++sc->sc_abortcount == 1) ! 718: sc->sc_starttime = time.tv_sec; ! 719: if (sc->sc_abortcount >= ABT_COUNT) { ! 720: slclose(tp); ! 721: return; ! 722: } ! 723: } ! 724: } else ! 725: sc->sc_abortcount = 0; ! 726: sc->sc_lasttime = time.tv_sec; ! 727: } ! 728: ! 729: switch (c) { ! 730: ! 731: case TRANS_FRAME_ESCAPE: ! 732: if (sc->sc_escape) ! 733: c = FRAME_ESCAPE; ! 734: break; ! 735: ! 736: case TRANS_FRAME_END: ! 737: if (sc->sc_escape) ! 738: c = FRAME_END; ! 739: break; ! 740: ! 741: case FRAME_ESCAPE: ! 742: sc->sc_escape = 1; ! 743: return; ! 744: ! 745: case FRAME_END: ! 746: if(sc->sc_flags & SC_ERROR) { ! 747: sc->sc_flags &= ~SC_ERROR; ! 748: goto newpack; ! 749: } ! 750: len = sc->sc_mp - sc->sc_buf; ! 751: if (len < 3) ! 752: /* less than min length packet - ignore */ ! 753: goto newpack; ! 754: ! 755: #if NBPFILTER > 0 ! 756: if (sc->sc_bpf) { ! 757: /* ! 758: * Save the compressed header, so we ! 759: * can tack it on later. Note that we ! 760: * will end up copying garbage in some ! 761: * cases but this is okay. We remember ! 762: * where the buffer started so we can ! 763: * compute the new header length. ! 764: */ ! 765: bcopy(sc->sc_buf, chdr, CHDR_LEN); ! 766: } ! 767: #endif ! 768: ! 769: if ((c = (*sc->sc_buf & 0xf0)) != (IPVERSION << 4)) { ! 770: if (c & 0x80) ! 771: c = TYPE_COMPRESSED_TCP; ! 772: else if (c == TYPE_UNCOMPRESSED_TCP) ! 773: *sc->sc_buf &= 0x4f; /* XXX */ ! 774: /* ! 775: * We've got something that's not an IP packet. ! 776: * If compression is enabled, try to decompress it. ! 777: * Otherwise, if `auto-enable' compression is on and ! 778: * it's a reasonable packet, decompress it and then ! 779: * enable compression. Otherwise, drop it. ! 780: */ ! 781: if (sc->sc_if.if_flags & SC_COMPRESS) { ! 782: len = sl_uncompress_tcp(&sc->sc_buf, len, ! 783: (u_int)c, &sc->sc_comp); ! 784: if (len <= 0) ! 785: goto error; ! 786: } else if ((sc->sc_if.if_flags & SC_AUTOCOMP) && ! 787: c == TYPE_UNCOMPRESSED_TCP && len >= 40) { ! 788: len = sl_uncompress_tcp(&sc->sc_buf, len, ! 789: (u_int)c, &sc->sc_comp); ! 790: if (len <= 0) ! 791: goto error; ! 792: sc->sc_if.if_flags |= SC_COMPRESS; ! 793: } else ! 794: goto error; ! 795: } ! 796: #if NBPFILTER > 0 ! 797: if (sc->sc_bpf) { ! 798: /* ! 799: * Put the SLIP pseudo-"link header" in place. ! 800: * We couldn't do this any earlier since ! 801: * decompression probably moved the buffer ! 802: * pointer. Then, invoke BPF. ! 803: */ ! 804: register u_char *hp = sc->sc_buf - SLIP_HDRLEN; ! 805: ! 806: hp[SLX_DIR] = SLIPDIR_IN; ! 807: bcopy(chdr, &hp[SLX_CHDR], CHDR_LEN); ! 808: BPF_TAP(sc->sc_bpf, hp, len + SLIP_HDRLEN); ! 809: } ! 810: #endif ! 811: m = sl_btom(sc, len); ! 812: if (m == NULL) ! 813: goto error; ! 814: ! 815: sc->sc_if.if_ipackets++; ! 816: sc->sc_if.if_lastchange = time; ! 817: s = splimp(); ! 818: if (IF_QFULL(&ipintrq)) { ! 819: IF_DROP(&ipintrq); ! 820: sc->sc_if.if_ierrors++; ! 821: sc->sc_if.if_iqdrops++; ! 822: m_freem(m); ! 823: } else { ! 824: IF_ENQUEUE(&ipintrq, m); ! 825: schednetisr(NETISR_IP); ! 826: } ! 827: splx(s); ! 828: goto newpack; ! 829: } ! 830: if (sc->sc_mp < sc->sc_ep) { ! 831: *sc->sc_mp++ = c; ! 832: sc->sc_escape = 0; ! 833: return; ! 834: } ! 835: ! 836: /* can't put lower; would miss an extra frame */ ! 837: sc->sc_flags |= SC_ERROR; ! 838: ! 839: error: ! 840: sc->sc_if.if_ierrors++; ! 841: newpack: ! 842: sc->sc_mp = sc->sc_buf = sc->sc_ep - SLMAX; ! 843: sc->sc_escape = 0; ! 844: } ! 845: ! 846: /* ! 847: * Process an ioctl request. ! 848: */ ! 849: int ! 850: slioctl(ifp, cmd, data) ! 851: register struct ifnet *ifp; ! 852: u_long cmd; ! 853: caddr_t data; ! 854: { ! 855: register struct ifaddr *ifa = (struct ifaddr *)data; ! 856: register struct ifreq *ifr; ! 857: register int s = splimp(), error = 0; ! 858: ! 859: switch (cmd) { ! 860: ! 861: case SIOCSIFADDR: ! 862: if (ifa->ifa_addr->sa_family == AF_INET) ! 863: ifp->if_flags |= IFF_UP; ! 864: else ! 865: error = EAFNOSUPPORT; ! 866: break; ! 867: ! 868: case SIOCSIFDSTADDR: ! 869: if (ifa->ifa_addr->sa_family != AF_INET) ! 870: error = EAFNOSUPPORT; ! 871: break; ! 872: ! 873: case SIOCADDMULTI: ! 874: case SIOCDELMULTI: ! 875: ifr = (struct ifreq *)data; ! 876: if (ifr == 0) { ! 877: error = EAFNOSUPPORT; /* XXX */ ! 878: break; ! 879: } ! 880: switch (ifr->ifr_addr.sa_family) { ! 881: ! 882: #if INET ! 883: case AF_INET: ! 884: break; ! 885: #endif ! 886: ! 887: default: ! 888: error = EAFNOSUPPORT; ! 889: break; ! 890: } ! 891: break; ! 892: ! 893: default: ! 894: error = EINVAL; ! 895: } ! 896: splx(s); ! 897: return (error); ! 898: } ! 899: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.