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