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