Annotation of sys/net/ppp_tty.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: ppp_tty.c,v 1.20 2003/12/10 07:22:42 itojun Exp $ */
! 2: /* $NetBSD: ppp_tty.c,v 1.12 1997/03/24 21:23:10 christos Exp $ */
! 3:
! 4: /*
! 5: * ppp_tty.c - Point-to-Point Protocol (PPP) driver for asynchronous
! 6: * tty devices.
! 7: *
! 8: * Copyright (c) 1984-2000 Carnegie Mellon University. All rights reserved.
! 9: *
! 10: * Redistribution and use in source and binary forms, with or without
! 11: * modification, are permitted provided that the following conditions
! 12: * are met:
! 13: *
! 14: * 1. Redistributions of source code must retain the above copyright
! 15: * notice, this list of conditions and the following disclaimer.
! 16: *
! 17: * 2. Redistributions in binary form must reproduce the above copyright
! 18: * notice, this list of conditions and the following disclaimer in
! 19: * the documentation and/or other materials provided with the
! 20: * distribution.
! 21: *
! 22: * 3. The name "Carnegie Mellon University" must not be used to
! 23: * endorse or promote products derived from this software without
! 24: * prior written permission. For permission or any legal
! 25: * details, please contact
! 26: * Office of Technology Transfer
! 27: * Carnegie Mellon University
! 28: * 5000 Forbes Avenue
! 29: * Pittsburgh, PA 15213-3890
! 30: * (412) 268-4387, fax: (412) 268-7395
! 31: * tech-transfer@andrew.cmu.edu
! 32: *
! 33: * 4. Redistributions of any form whatsoever must retain the following
! 34: * acknowledgment:
! 35: * "This product includes software developed by Computing Services
! 36: * at Carnegie Mellon University (http://www.cmu.edu/computing/)."
! 37: *
! 38: * CARNEGIE MELLON UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO
! 39: * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
! 40: * AND FITNESS, IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY BE LIABLE
! 41: * FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
! 42: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
! 43: * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
! 44: * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
! 45: *
! 46: * Based on:
! 47: * @(#)if_sl.c 7.6.1.2 (Berkeley) 2/15/89
! 48: *
! 49: * Copyright (c) 1987 Regents of the University of California.
! 50: * All rights reserved.
! 51: *
! 52: * Redistribution and use in source and binary forms are permitted
! 53: * provided that the above copyright notice and this paragraph are
! 54: * duplicated in all such forms and that any documentation,
! 55: * advertising materials, and other materials related to such
! 56: * distribution and use acknowledge that the software was developed
! 57: * by the University of California, Berkeley. The name of the
! 58: * University may not be used to endorse or promote products derived
! 59: * from this software without specific prior written permission.
! 60: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
! 61: * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
! 62: * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
! 63: *
! 64: * Serial Line interface
! 65: *
! 66: * Rick Adams
! 67: * Center for Seismic Studies
! 68: * 1300 N 17th Street, Suite 1450
! 69: * Arlington, Virginia 22209
! 70: * (703)276-7900
! 71: * rick@seismo.ARPA
! 72: * seismo!rick
! 73: *
! 74: * Pounded on heavily by Chris Torek (chris@mimsy.umd.edu, umcp-cs!chris).
! 75: * Converted to 4.3BSD Beta by Chris Torek.
! 76: * Other changes made at Berkeley, based in part on code by Kirk Smith.
! 77: *
! 78: * Converted to 4.3BSD+ 386BSD by Brad Parker (brad@cayman.com)
! 79: * Added VJ tcp header compression; more unified ioctls
! 80: *
! 81: * Extensively modified by Paul Mackerras (paulus@cs.anu.edu.au).
! 82: * Cleaned up a lot of the mbuf-related code to fix bugs that
! 83: * caused system crashes and packet corruption. Changed pppstart
! 84: * so that it doesn't just give up with a collision if the whole
! 85: * packet doesn't fit in the output ring buffer.
! 86: *
! 87: * Added priority queueing for interactive IP packets, following
! 88: * the model of if_sl.c, plus hooks for bpf.
! 89: * Paul Mackerras (paulus@cs.anu.edu.au).
! 90: */
! 91:
! 92: /* from if_sl.c,v 1.11 84/10/04 12:54:47 rick Exp */
! 93: /* from NetBSD: if_ppp.c,v 1.15.2.2 1994/07/28 05:17:58 cgd Exp */
! 94:
! 95: #include "ppp.h"
! 96: #if NPPP > 0
! 97:
! 98: #define VJC
! 99: #define PPP_COMPRESS
! 100:
! 101: #include <sys/param.h>
! 102: #include <sys/proc.h>
! 103: #include <sys/mbuf.h>
! 104: #include <sys/dkstat.h>
! 105: #include <sys/socket.h>
! 106: #include <sys/ioctl.h>
! 107: #include <sys/file.h>
! 108: #include <sys/tty.h>
! 109: #include <sys/kernel.h>
! 110: #include <sys/conf.h>
! 111: #include <sys/vnode.h>
! 112: #include <sys/systm.h>
! 113:
! 114: #include <net/if.h>
! 115: #include <net/if_types.h>
! 116:
! 117: #ifdef VJC
! 118: #include <netinet/in.h>
! 119: #include <netinet/in_systm.h>
! 120: #include <netinet/ip.h>
! 121: #include <net/slcompress.h>
! 122: #endif
! 123:
! 124: #include <net/bpf.h>
! 125: #include <net/ppp_defs.h>
! 126: #include <net/if_ppp.h>
! 127: #include <net/if_pppvar.h>
! 128:
! 129: int pppopen(dev_t dev, struct tty *tp);
! 130: int pppclose(struct tty *tp, int flag);
! 131: int pppread(struct tty *tp, struct uio *uio, int flag);
! 132: int pppwrite(struct tty *tp, struct uio *uio, int flag);
! 133: int ppptioctl(struct tty *tp, u_long cmd, caddr_t data, int flag,
! 134: struct proc *);
! 135: int pppinput(int c, struct tty *tp);
! 136: int pppstart(struct tty *tp, int);
! 137:
! 138: u_int16_t pppfcs(u_int16_t fcs, u_char *cp, int len);
! 139: void pppasyncstart(struct ppp_softc *);
! 140: void pppasyncctlp(struct ppp_softc *);
! 141: void pppasyncrelinq(struct ppp_softc *);
! 142: void ppp_timeout(void *);
! 143: void pppgetm(struct ppp_softc *sc);
! 144: void pppdumpb(u_char *b, int l);
! 145: void ppplogchar(struct ppp_softc *, int);
! 146:
! 147: /*
! 148: * Some useful mbuf macros not in mbuf.h.
! 149: */
! 150: #define M_IS_CLUSTER(m) ((m)->m_flags & M_EXT)
! 151:
! 152: #define M_DATASTART(m) \
! 153: (M_IS_CLUSTER(m) ? (m)->m_ext.ext_buf : \
! 154: (m)->m_flags & M_PKTHDR ? (m)->m_pktdat : (m)->m_dat)
! 155:
! 156: #define M_DATASIZE(m) \
! 157: (M_IS_CLUSTER(m) ? (m)->m_ext.ext_size : \
! 158: (m)->m_flags & M_PKTHDR ? MHLEN: MLEN)
! 159:
! 160: /*
! 161: * Does c need to be escaped?
! 162: */
! 163: #define ESCAPE_P(c) (sc->sc_asyncmap[(c) >> 5] & (1 << ((c) & 0x1F)))
! 164:
! 165: /*
! 166: * Procedures for using an async tty interface for PPP.
! 167: */
! 168:
! 169: /* This is a NetBSD-1.0 or later kernel. */
! 170: #define CCOUNT(q) ((q)->c_cc)
! 171:
! 172: #define PPP_LOWAT 100 /* Process more output when < LOWAT on queue */
! 173: #define PPP_HIWAT 400 /* Don't start a new packet if HIWAT on queue */
! 174:
! 175: /*
! 176: * Line specific open routine for async tty devices.
! 177: * Attach the given tty to the first available ppp unit.
! 178: * Called from device open routine or ttioctl.
! 179: */
! 180: /* ARGSUSED */
! 181: int
! 182: pppopen(dev, tp)
! 183: dev_t dev;
! 184: struct tty *tp;
! 185: {
! 186: struct proc *p = curproc; /* XXX */
! 187: struct ppp_softc *sc;
! 188: int error, s;
! 189:
! 190: if ((error = suser(p, 0)) != 0)
! 191: return (error);
! 192:
! 193: s = spltty();
! 194:
! 195: if (tp->t_line == PPPDISC) {
! 196: sc = (struct ppp_softc *) tp->t_sc;
! 197: if (sc != NULL && sc->sc_devp == (void *) tp) {
! 198: splx(s);
! 199: return (0);
! 200: }
! 201: }
! 202:
! 203: if ((sc = pppalloc(p->p_pid)) == NULL) {
! 204: splx(s);
! 205: return ENXIO;
! 206: }
! 207:
! 208: if (sc->sc_relinq)
! 209: (*sc->sc_relinq)(sc); /* get previous owner to relinquish the unit */
! 210:
! 211: timeout_set(&sc->sc_timo, ppp_timeout, sc);
! 212: sc->sc_ilen = 0;
! 213: sc->sc_m = NULL;
! 214: bzero(sc->sc_asyncmap, sizeof(sc->sc_asyncmap));
! 215: sc->sc_asyncmap[0] = 0xffffffff;
! 216: sc->sc_asyncmap[3] = 0x60000000;
! 217: sc->sc_rasyncmap = 0;
! 218: sc->sc_devp = (void *) tp;
! 219: sc->sc_start = pppasyncstart;
! 220: sc->sc_ctlp = pppasyncctlp;
! 221: sc->sc_relinq = pppasyncrelinq;
! 222: sc->sc_outm = NULL;
! 223: pppgetm(sc);
! 224: sc->sc_if.if_flags |= IFF_RUNNING;
! 225: sc->sc_if.if_baudrate = tp->t_ospeed;
! 226:
! 227: tp->t_sc = (caddr_t) sc;
! 228: ttyflush(tp, FREAD | FWRITE);
! 229:
! 230: splx(s);
! 231: return (0);
! 232: }
! 233:
! 234: /*
! 235: * Line specific close routine, called from device close routine
! 236: * and from ttioctl.
! 237: * Detach the tty from the ppp unit.
! 238: * Mimics part of ttyclose().
! 239: */
! 240: int
! 241: pppclose(tp, flag)
! 242: struct tty *tp;
! 243: int flag;
! 244: {
! 245: struct ppp_softc *sc;
! 246: int s;
! 247:
! 248: s = spltty();
! 249: ttyflush(tp, FREAD|FWRITE);
! 250: tp->t_line = 0;
! 251: sc = (struct ppp_softc *) tp->t_sc;
! 252: if (sc != NULL) {
! 253: tp->t_sc = NULL;
! 254: if (tp == (struct tty *) sc->sc_devp) {
! 255: pppasyncrelinq(sc);
! 256: pppdealloc(sc);
! 257: }
! 258: }
! 259: splx(s);
! 260: return 0;
! 261: }
! 262:
! 263: /*
! 264: * Relinquish the interface unit to another device.
! 265: */
! 266: void
! 267: pppasyncrelinq(sc)
! 268: struct ppp_softc *sc;
! 269: {
! 270: int s;
! 271:
! 272: s = spltty();
! 273: if (sc->sc_outm) {
! 274: m_freem(sc->sc_outm);
! 275: sc->sc_outm = NULL;
! 276: }
! 277: if (sc->sc_m) {
! 278: m_freem(sc->sc_m);
! 279: sc->sc_m = NULL;
! 280: }
! 281: if (sc->sc_flags & SC_TIMEOUT) {
! 282: timeout_del(&sc->sc_timo);
! 283: sc->sc_flags &= ~SC_TIMEOUT;
! 284: }
! 285: splx(s);
! 286: }
! 287:
! 288: /*
! 289: * Line specific (tty) read routine.
! 290: */
! 291: int
! 292: pppread(tp, uio, flag)
! 293: struct tty *tp;
! 294: struct uio *uio;
! 295: int flag;
! 296: {
! 297: struct ppp_softc *sc = (struct ppp_softc *)tp->t_sc;
! 298: struct mbuf *m, *m0;
! 299: int s;
! 300: int error = 0;
! 301:
! 302: if (sc == NULL)
! 303: return 0;
! 304: /*
! 305: * Loop waiting for input, checking that nothing disasterous
! 306: * happens in the meantime.
! 307: */
! 308: s = spltty();
! 309: for (;;) {
! 310: if (tp != (struct tty *) sc->sc_devp || tp->t_line != PPPDISC) {
! 311: splx(s);
! 312: return 0;
! 313: }
! 314: if (sc->sc_inq.ifq_head != NULL)
! 315: break;
! 316: if ((tp->t_state & TS_CARR_ON) == 0 && (tp->t_cflag & CLOCAL) == 0
! 317: && (tp->t_state & TS_ISOPEN)) {
! 318: splx(s);
! 319: return 0; /* end of file */
! 320: }
! 321: if (tp->t_state & TS_ASYNC || flag & IO_NDELAY) {
! 322: splx(s);
! 323: return (EWOULDBLOCK);
! 324: }
! 325: error = ttysleep(tp, (caddr_t)&tp->t_rawq, TTIPRI|PCATCH, ttyin, 0);
! 326: if (error) {
! 327: splx(s);
! 328: return error;
! 329: }
! 330: }
! 331:
! 332: /* Pull place-holder byte out of canonical queue */
! 333: getc(&tp->t_canq);
! 334:
! 335: /* Get the packet from the input queue */
! 336: IF_DEQUEUE(&sc->sc_inq, m0);
! 337: splx(s);
! 338:
! 339: for (m = m0; m && uio->uio_resid; m = m->m_next)
! 340: if ((error = uiomove(mtod(m, u_char *), m->m_len, uio)) != 0)
! 341: break;
! 342: m_freem(m0);
! 343: return (error);
! 344: }
! 345:
! 346: /*
! 347: * Line specific (tty) write routine.
! 348: */
! 349: int
! 350: pppwrite(tp, uio, flag)
! 351: struct tty *tp;
! 352: struct uio *uio;
! 353: int flag;
! 354: {
! 355: struct ppp_softc *sc = (struct ppp_softc *)tp->t_sc;
! 356: struct mbuf *m, *m0, **mp;
! 357: struct sockaddr dst;
! 358: int len, error;
! 359:
! 360: if ((tp->t_state & TS_CARR_ON) == 0 && (tp->t_cflag & CLOCAL) == 0)
! 361: return 0; /* wrote 0 bytes */
! 362: if (tp->t_line != PPPDISC)
! 363: return (EINVAL);
! 364: if (sc == NULL || tp != (struct tty *) sc->sc_devp)
! 365: return EIO;
! 366: if (uio->uio_resid > sc->sc_if.if_mtu + PPP_HDRLEN ||
! 367: uio->uio_resid < PPP_HDRLEN)
! 368: return (EMSGSIZE);
! 369: for (mp = &m0; uio->uio_resid; mp = &m->m_next) {
! 370: if (mp == &m0) {
! 371: MGETHDR(m, M_WAIT, MT_DATA);
! 372: m->m_pkthdr.len = uio->uio_resid - PPP_HDRLEN;
! 373: m->m_pkthdr.rcvif = NULL;
! 374: } else
! 375: MGET(m, M_WAIT, MT_DATA);
! 376: *mp = m;
! 377: m->m_len = 0;
! 378: if (uio->uio_resid >= MCLBYTES / 2)
! 379: MCLGET(m, M_DONTWAIT);
! 380: len = M_TRAILINGSPACE(m);
! 381: if (len > uio->uio_resid)
! 382: len = uio->uio_resid;
! 383: if ((error = uiomove(mtod(m, u_char *), len, uio)) != 0) {
! 384: m_freem(m0);
! 385: return (error);
! 386: }
! 387: m->m_len = len;
! 388: }
! 389: dst.sa_family = AF_UNSPEC;
! 390: bcopy(mtod(m0, u_char *), dst.sa_data, PPP_HDRLEN);
! 391: m0->m_data += PPP_HDRLEN;
! 392: m0->m_len -= PPP_HDRLEN;
! 393: return ((*sc->sc_if.if_output)(&sc->sc_if, m0, &dst, (struct rtentry *)0));
! 394: }
! 395:
! 396: /*
! 397: * Line specific (tty) ioctl routine.
! 398: * This discipline requires that tty device drivers call
! 399: * the line specific l_ioctl routine from their ioctl routines.
! 400: */
! 401: /* ARGSUSED */
! 402: int
! 403: ppptioctl(tp, cmd, data, flag, p)
! 404: struct tty *tp;
! 405: u_long cmd;
! 406: caddr_t data;
! 407: int flag;
! 408: struct proc *p;
! 409: {
! 410: struct ppp_softc *sc = (struct ppp_softc *) tp->t_sc;
! 411: int error, s;
! 412:
! 413: if (sc == NULL || tp != (struct tty *) sc->sc_devp)
! 414: return -1;
! 415:
! 416: error = 0;
! 417: switch (cmd) {
! 418: case PPPIOCSASYNCMAP:
! 419: if ((error = suser(p, 0)) != 0)
! 420: break;
! 421: sc->sc_asyncmap[0] = *(u_int *)data;
! 422: break;
! 423:
! 424: case PPPIOCGASYNCMAP:
! 425: *(u_int *)data = sc->sc_asyncmap[0];
! 426: break;
! 427:
! 428: case PPPIOCSRASYNCMAP:
! 429: if ((error = suser(p, 0)) != 0)
! 430: break;
! 431: sc->sc_rasyncmap = *(u_int *)data;
! 432: break;
! 433:
! 434: case PPPIOCGRASYNCMAP:
! 435: *(u_int *)data = sc->sc_rasyncmap;
! 436: break;
! 437:
! 438: case PPPIOCSXASYNCMAP:
! 439: if ((error = suser(p, 0)) != 0)
! 440: break;
! 441: s = spltty();
! 442: bcopy(data, sc->sc_asyncmap, sizeof(sc->sc_asyncmap));
! 443: sc->sc_asyncmap[1] = 0; /* mustn't escape 0x20 - 0x3f */
! 444: sc->sc_asyncmap[2] &= ~0x40000000; /* mustn't escape 0x5e */
! 445: sc->sc_asyncmap[3] |= 0x60000000; /* must escape 0x7d, 0x7e */
! 446: splx(s);
! 447: break;
! 448:
! 449: case PPPIOCGXASYNCMAP:
! 450: bcopy(sc->sc_asyncmap, data, sizeof(sc->sc_asyncmap));
! 451: break;
! 452:
! 453: default:
! 454: error = pppioctl(sc, cmd, data, flag, p);
! 455: if (error == 0 && cmd == PPPIOCSMRU)
! 456: pppgetm(sc);
! 457: }
! 458:
! 459: return error;
! 460: }
! 461:
! 462: /*
! 463: * FCS lookup table as calculated by genfcstab.
! 464: */
! 465: static u_int16_t fcstab[256] = {
! 466: 0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
! 467: 0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
! 468: 0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
! 469: 0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
! 470: 0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
! 471: 0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
! 472: 0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
! 473: 0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
! 474: 0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
! 475: 0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
! 476: 0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
! 477: 0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
! 478: 0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
! 479: 0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
! 480: 0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
! 481: 0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
! 482: 0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
! 483: 0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
! 484: 0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
! 485: 0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
! 486: 0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
! 487: 0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
! 488: 0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
! 489: 0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
! 490: 0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
! 491: 0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
! 492: 0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
! 493: 0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
! 494: 0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
! 495: 0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
! 496: 0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
! 497: 0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
! 498: };
! 499:
! 500: /*
! 501: * Calculate a new FCS given the current FCS and the new data.
! 502: */
! 503: u_int16_t
! 504: pppfcs(fcs, cp, len)
! 505: u_int16_t fcs;
! 506: u_char *cp;
! 507: int len;
! 508: {
! 509: while (len--)
! 510: fcs = PPP_FCS(fcs, *cp++);
! 511: return (fcs);
! 512: }
! 513:
! 514: /*
! 515: * This gets called from pppoutput when a new packet is
! 516: * put on a queue, at splsoftnet.
! 517: */
! 518: void
! 519: pppasyncstart(sc)
! 520: struct ppp_softc *sc;
! 521: {
! 522: struct tty *tp = (struct tty *) sc->sc_devp;
! 523: struct mbuf *m;
! 524: int len;
! 525: u_char *start, *stop, *cp;
! 526: int n, ndone, done, idle;
! 527: struct mbuf *m2;
! 528: int s;
! 529:
! 530: idle = 0;
! 531: while (CCOUNT(&tp->t_outq) < PPP_HIWAT) {
! 532: /*
! 533: * See if we have an existing packet partly sent.
! 534: * If not, get a new packet and start sending it.
! 535: */
! 536: m = sc->sc_outm;
! 537: if (m == NULL) {
! 538: /*
! 539: * Get another packet to be sent.
! 540: */
! 541: m = ppp_dequeue(sc);
! 542: if (m == NULL) {
! 543: idle = 1;
! 544: break;
! 545: }
! 546:
! 547: /*
! 548: * The extra PPP_FLAG will start up a new packet, and thus
! 549: * will flush any accumulated garbage. We do this whenever
! 550: * the line may have been idle for some time.
! 551: */
! 552: if (CCOUNT(&tp->t_outq) == 0) {
! 553: ++sc->sc_stats.ppp_obytes;
! 554: (void) putc(PPP_FLAG, &tp->t_outq);
! 555: }
! 556:
! 557: /* Calculate the FCS for the first mbuf's worth. */
! 558: sc->sc_outfcs = pppfcs(PPP_INITFCS, mtod(m, u_char *), m->m_len);
! 559: }
! 560:
! 561: for (;;) {
! 562: start = mtod(m, u_char *);
! 563: len = m->m_len;
! 564: stop = start + len;
! 565: while (len > 0) {
! 566: /*
! 567: * Find out how many bytes in the string we can
! 568: * handle without doing something special.
! 569: */
! 570: for (cp = start; cp < stop; cp++)
! 571: if (ESCAPE_P(*cp))
! 572: break;
! 573: n = cp - start;
! 574: if (n) {
! 575: /* NetBSD (0.9 or later), 4.3-Reno or similar. */
! 576: ndone = n - b_to_q(start, n, &tp->t_outq);
! 577: len -= ndone;
! 578: start += ndone;
! 579: sc->sc_stats.ppp_obytes += ndone;
! 580:
! 581: if (ndone < n)
! 582: break; /* packet doesn't fit */
! 583: }
! 584: /*
! 585: * If there are characters left in the mbuf,
! 586: * the first one must be special.
! 587: * Put it out in a different form.
! 588: */
! 589: if (len) {
! 590: s = spltty();
! 591: if (putc(PPP_ESCAPE, &tp->t_outq)) {
! 592: splx(s);
! 593: break;
! 594: }
! 595: if (putc(*start ^ PPP_TRANS, &tp->t_outq)) {
! 596: (void) unputc(&tp->t_outq);
! 597: splx(s);
! 598: break;
! 599: }
! 600: splx(s);
! 601: sc->sc_stats.ppp_obytes += 2;
! 602: start++;
! 603: len--;
! 604: }
! 605: }
! 606:
! 607: /*
! 608: * If we didn't empty this mbuf, remember where we're up to.
! 609: * If we emptied the last mbuf, try to add the FCS and closing
! 610: * flag, and if we can't, leave sc_outm pointing to m, but with
! 611: * m->m_len == 0, to remind us to output the FCS and flag later.
! 612: */
! 613: done = len == 0;
! 614: if (done && m->m_next == NULL) {
! 615: u_char *p, *q;
! 616: int c;
! 617: u_char endseq[8];
! 618:
! 619: /*
! 620: * We may have to escape the bytes in the FCS.
! 621: */
! 622: p = endseq;
! 623: c = ~sc->sc_outfcs & 0xFF;
! 624: if (ESCAPE_P(c)) {
! 625: *p++ = PPP_ESCAPE;
! 626: *p++ = c ^ PPP_TRANS;
! 627: } else
! 628: *p++ = c;
! 629: c = (~sc->sc_outfcs >> 8) & 0xFF;
! 630: if (ESCAPE_P(c)) {
! 631: *p++ = PPP_ESCAPE;
! 632: *p++ = c ^ PPP_TRANS;
! 633: } else
! 634: *p++ = c;
! 635: *p++ = PPP_FLAG;
! 636:
! 637: /*
! 638: * Try to output the FCS and flag. If the bytes
! 639: * don't all fit, back out.
! 640: */
! 641: s = spltty();
! 642: for (q = endseq; q < p; ++q)
! 643: if (putc(*q, &tp->t_outq)) {
! 644: done = 0;
! 645: for (; q > endseq; --q)
! 646: unputc(&tp->t_outq);
! 647: break;
! 648: }
! 649: splx(s);
! 650: if (done)
! 651: sc->sc_stats.ppp_obytes += q - endseq;
! 652: }
! 653:
! 654: if (!done) {
! 655: /* remember where we got to */
! 656: m->m_data = start;
! 657: m->m_len = len;
! 658: break;
! 659: }
! 660:
! 661: /* Finished with this mbuf; free it and move on. */
! 662: MFREE(m, m2);
! 663: m = m2;
! 664: if (m == NULL) {
! 665: /* Finished a packet */
! 666: break;
! 667: }
! 668: sc->sc_outfcs = pppfcs(sc->sc_outfcs, mtod(m, u_char *), m->m_len);
! 669: }
! 670:
! 671: /*
! 672: * If m == NULL, we have finished a packet.
! 673: * If m != NULL, we've either done as much work this time
! 674: * as we need to, or else we've filled up the output queue.
! 675: */
! 676: sc->sc_outm = m;
! 677: if (m)
! 678: break;
! 679: }
! 680:
! 681: /* Call pppstart to start output again if necessary. */
! 682: s = spltty();
! 683: pppstart(tp, 0);
! 684:
! 685: /*
! 686: * This timeout is needed for operation on a pseudo-tty,
! 687: * because the pty code doesn't call pppstart after it has
! 688: * drained the t_outq.
! 689: */
! 690: if (!idle && (sc->sc_flags & SC_TIMEOUT) == 0) {
! 691: timeout_add(&sc->sc_timo, 1);
! 692: sc->sc_flags |= SC_TIMEOUT;
! 693: }
! 694:
! 695: splx(s);
! 696: }
! 697:
! 698: /*
! 699: * This gets called when a received packet is placed on
! 700: * the inq, at splsoftnet.
! 701: */
! 702: void
! 703: pppasyncctlp(sc)
! 704: struct ppp_softc *sc;
! 705: {
! 706: struct tty *tp;
! 707: int s;
! 708:
! 709: /* Put a placeholder byte in canq for ttpoll()/ttnread(). */
! 710: s = spltty();
! 711: tp = (struct tty *) sc->sc_devp;
! 712: putc(0, &tp->t_canq);
! 713: ttwakeup(tp);
! 714: splx(s);
! 715: }
! 716:
! 717: /*
! 718: * Start output on async tty interface. If the transmit queue
! 719: * has drained sufficiently, arrange for pppasyncstart to be
! 720: * called later at splsoftnet.
! 721: */
! 722: int
! 723: pppstart(tp, force)
! 724: struct tty *tp;
! 725: int force;
! 726: {
! 727: struct ppp_softc *sc = (struct ppp_softc *) tp->t_sc;
! 728:
! 729: /*
! 730: * If there is stuff in the output queue, send it now.
! 731: * We are being called in lieu of ttstart and must do what it would.
! 732: */
! 733: if (tp->t_oproc != NULL)
! 734: (*tp->t_oproc)(tp);
! 735:
! 736: #ifdef ALTQ
! 737: /*
! 738: * if ALTQ is enabled, don't invoke NETISR_PPP.
! 739: * pppintr() could loop without doing anything useful
! 740: * under rate-limiting.
! 741: */
! 742: if (ALTQ_IS_ENABLED(&sc->sc_if.if_snd))
! 743: return 0;
! 744: #endif
! 745: /*
! 746: * If the transmit queue has drained and the tty has not hung up
! 747: * or been disconnected from the ppp unit, then tell if_ppp.c that
! 748: * we need more output.
! 749: */
! 750: if ((CCOUNT(&tp->t_outq) < PPP_LOWAT || force)
! 751: && !((tp->t_state & TS_CARR_ON) == 0 && (tp->t_cflag & CLOCAL) == 0)
! 752: && sc != NULL && tp == (struct tty *) sc->sc_devp) {
! 753: ppp_restart(sc);
! 754: }
! 755:
! 756: return 0;
! 757: }
! 758:
! 759: /*
! 760: * Timeout routine - try to start some more output.
! 761: */
! 762: void
! 763: ppp_timeout(x)
! 764: void *x;
! 765: {
! 766: struct ppp_softc *sc = (struct ppp_softc *) x;
! 767: struct tty *tp = (struct tty *) sc->sc_devp;
! 768: int s;
! 769:
! 770: s = spltty();
! 771: sc->sc_flags &= ~SC_TIMEOUT;
! 772: pppstart(tp, 1);
! 773: splx(s);
! 774: }
! 775:
! 776: /*
! 777: * Allocate enough mbuf to handle current MRU.
! 778: */
! 779: void
! 780: pppgetm(sc)
! 781: struct ppp_softc *sc;
! 782: {
! 783: struct mbuf *m, **mp;
! 784: int len;
! 785: int s;
! 786:
! 787: s = spltty();
! 788: mp = &sc->sc_m;
! 789: for (len = sc->sc_mru + PPP_HDRLEN + PPP_FCSLEN; len > 0; ){
! 790: if ((m = *mp) == NULL) {
! 791: MGETHDR(m, M_DONTWAIT, MT_DATA);
! 792: if (m == NULL)
! 793: break;
! 794: *mp = m;
! 795: MCLGET(m, M_DONTWAIT);
! 796: }
! 797: len -= M_DATASIZE(m);
! 798: mp = &m->m_next;
! 799: }
! 800: splx(s);
! 801: }
! 802:
! 803: /*
! 804: * tty interface receiver interrupt.
! 805: */
! 806: static unsigned int paritytab[8] = {
! 807: 0x96696996, 0x69969669, 0x69969669, 0x96696996,
! 808: 0x69969669, 0x96696996, 0x96696996, 0x69969669
! 809: };
! 810:
! 811: int
! 812: pppinput(c, tp)
! 813: int c;
! 814: struct tty *tp;
! 815: {
! 816: struct ppp_softc *sc;
! 817: struct mbuf *m;
! 818: int ilen, s;
! 819:
! 820: sc = (struct ppp_softc *) tp->t_sc;
! 821: if (sc == NULL || tp != (struct tty *) sc->sc_devp)
! 822: return 0;
! 823:
! 824: ++tk_nin;
! 825: ++sc->sc_stats.ppp_ibytes;
! 826:
! 827: if (c & TTY_FE) {
! 828: /* framing error or overrun on this char - abort packet */
! 829: if (sc->sc_flags & SC_DEBUG)
! 830: printf("%s: bad char %x\n", sc->sc_if.if_xname, c);
! 831: goto flush;
! 832: }
! 833:
! 834: c &= 0xff;
! 835:
! 836: /*
! 837: * Handle software flow control of output.
! 838: */
! 839: if (tp->t_iflag & IXON) {
! 840: if (c == tp->t_cc[VSTOP] && tp->t_cc[VSTOP] != _POSIX_VDISABLE) {
! 841: if ((tp->t_state & TS_TTSTOP) == 0) {
! 842: tp->t_state |= TS_TTSTOP;
! 843: (*cdevsw[major(tp->t_dev)].d_stop)(tp, 0);
! 844: }
! 845: return 0;
! 846: }
! 847: if (c == tp->t_cc[VSTART] && tp->t_cc[VSTART] != _POSIX_VDISABLE) {
! 848: tp->t_state &= ~TS_TTSTOP;
! 849: if (tp->t_oproc != NULL)
! 850: (*tp->t_oproc)(tp);
! 851: return 0;
! 852: }
! 853: }
! 854:
! 855: s = spltty();
! 856: if (c & 0x80)
! 857: sc->sc_flags |= SC_RCV_B7_1;
! 858: else
! 859: sc->sc_flags |= SC_RCV_B7_0;
! 860: if (paritytab[c >> 5] & (1 << (c & 0x1F)))
! 861: sc->sc_flags |= SC_RCV_ODDP;
! 862: else
! 863: sc->sc_flags |= SC_RCV_EVNP;
! 864: splx(s);
! 865:
! 866: if (sc->sc_flags & SC_LOG_RAWIN)
! 867: ppplogchar(sc, c);
! 868:
! 869: if (c == PPP_FLAG) {
! 870: ilen = sc->sc_ilen;
! 871: sc->sc_ilen = 0;
! 872:
! 873: if (sc->sc_rawin_count > 0)
! 874: ppplogchar(sc, -1);
! 875:
! 876: /*
! 877: * If SC_ESCAPED is set, then we've seen the packet
! 878: * abort sequence "}~".
! 879: */
! 880: if (sc->sc_flags & (SC_FLUSH | SC_ESCAPED)
! 881: || (ilen > 0 && sc->sc_fcs != PPP_GOODFCS)) {
! 882: s = spltty();
! 883: sc->sc_flags |= SC_PKTLOST; /* note the dropped packet */
! 884: if ((sc->sc_flags & (SC_FLUSH | SC_ESCAPED)) == 0){
! 885: if (sc->sc_flags & SC_DEBUG)
! 886: printf("%s: bad fcs %x\n", sc->sc_if.if_xname,
! 887: sc->sc_fcs);
! 888: sc->sc_if.if_ierrors++;
! 889: sc->sc_stats.ppp_ierrors++;
! 890: } else
! 891: sc->sc_flags &= ~(SC_FLUSH | SC_ESCAPED);
! 892: splx(s);
! 893: return 0;
! 894: }
! 895:
! 896: if (ilen < PPP_HDRLEN + PPP_FCSLEN) {
! 897: if (ilen) {
! 898: if (sc->sc_flags & SC_DEBUG)
! 899: printf("%s: too short (%d)\n", sc->sc_if.if_xname, ilen);
! 900: s = spltty();
! 901: sc->sc_if.if_ierrors++;
! 902: sc->sc_stats.ppp_ierrors++;
! 903: sc->sc_flags |= SC_PKTLOST;
! 904: splx(s);
! 905: }
! 906: return 0;
! 907: }
! 908:
! 909: /*
! 910: * Remove FCS trailer. Somewhat painful...
! 911: */
! 912: ilen -= 2;
! 913: if (--sc->sc_mc->m_len == 0) {
! 914: for (m = sc->sc_m; m->m_next != sc->sc_mc; m = m->m_next)
! 915: ;
! 916: sc->sc_mc = m;
! 917: }
! 918: sc->sc_mc->m_len--;
! 919:
! 920: /* excise this mbuf chain */
! 921: m = sc->sc_m;
! 922: sc->sc_m = sc->sc_mc->m_next;
! 923: sc->sc_mc->m_next = NULL;
! 924:
! 925: ppppktin(sc, m, sc->sc_flags & SC_PKTLOST);
! 926: if (sc->sc_flags & SC_PKTLOST) {
! 927: s = spltty();
! 928: sc->sc_flags &= ~SC_PKTLOST;
! 929: splx(s);
! 930: }
! 931:
! 932: pppgetm(sc);
! 933: return 0;
! 934: }
! 935:
! 936: if (sc->sc_flags & SC_FLUSH) {
! 937: if (sc->sc_flags & SC_LOG_FLUSH)
! 938: ppplogchar(sc, c);
! 939: return 0;
! 940: }
! 941:
! 942: if (c < 0x20 && (sc->sc_rasyncmap & (1 << c)))
! 943: return 0;
! 944:
! 945: s = spltty();
! 946: if (sc->sc_flags & SC_ESCAPED) {
! 947: sc->sc_flags &= ~SC_ESCAPED;
! 948: c ^= PPP_TRANS;
! 949: } else if (c == PPP_ESCAPE) {
! 950: sc->sc_flags |= SC_ESCAPED;
! 951: splx(s);
! 952: return 0;
! 953: }
! 954: splx(s);
! 955:
! 956: /*
! 957: * Initialize buffer on first octet received.
! 958: * First octet could be address or protocol (when compressing
! 959: * address/control).
! 960: * Second octet is control.
! 961: * Third octet is first or second (when compressing protocol)
! 962: * octet of protocol.
! 963: * Fourth octet is second octet of protocol.
! 964: */
! 965: if (sc->sc_ilen == 0) {
! 966: /* reset the first input mbuf */
! 967: if (sc->sc_m == NULL) {
! 968: pppgetm(sc);
! 969: if (sc->sc_m == NULL) {
! 970: if (sc->sc_flags & SC_DEBUG)
! 971: printf("%s: no input mbufs!\n", sc->sc_if.if_xname);
! 972: goto flush;
! 973: }
! 974: }
! 975: m = sc->sc_m;
! 976: m->m_len = 0;
! 977: m->m_data = M_DATASTART(sc->sc_m);
! 978: sc->sc_mc = m;
! 979: sc->sc_mp = mtod(m, char *);
! 980: sc->sc_fcs = PPP_INITFCS;
! 981: if (c != PPP_ALLSTATIONS) {
! 982: if (sc->sc_flags & SC_REJ_COMP_AC) {
! 983: if (sc->sc_flags & SC_DEBUG)
! 984: printf("%s: garbage received: 0x%x (need 0xFF)\n",
! 985: sc->sc_if.if_xname, c);
! 986: goto flush;
! 987: }
! 988: *sc->sc_mp++ = PPP_ALLSTATIONS;
! 989: *sc->sc_mp++ = PPP_UI;
! 990: sc->sc_ilen += 2;
! 991: m->m_len += 2;
! 992: }
! 993: }
! 994: if (sc->sc_ilen == 1 && c != PPP_UI) {
! 995: if (sc->sc_flags & SC_DEBUG)
! 996: printf("%s: missing UI (0x3), got 0x%x\n",
! 997: sc->sc_if.if_xname, c);
! 998: goto flush;
! 999: }
! 1000: if (sc->sc_ilen == 2 && (c & 1) == 1) {
! 1001: /* a compressed protocol */
! 1002: *sc->sc_mp++ = 0;
! 1003: sc->sc_ilen++;
! 1004: sc->sc_mc->m_len++;
! 1005: }
! 1006: if (sc->sc_ilen == 3 && (c & 1) == 0) {
! 1007: if (sc->sc_flags & SC_DEBUG)
! 1008: printf("%s: bad protocol %x\n", sc->sc_if.if_xname,
! 1009: (sc->sc_mp[-1] << 8) + c);
! 1010: goto flush;
! 1011: }
! 1012:
! 1013: /* packet beyond configured mru? */
! 1014: if (++sc->sc_ilen > sc->sc_mru + PPP_HDRLEN + PPP_FCSLEN) {
! 1015: if (sc->sc_flags & SC_DEBUG)
! 1016: printf("%s: packet too big\n", sc->sc_if.if_xname);
! 1017: goto flush;
! 1018: }
! 1019:
! 1020: /* is this mbuf full? */
! 1021: m = sc->sc_mc;
! 1022: if (M_TRAILINGSPACE(m) <= 0) {
! 1023: if (m->m_next == NULL) {
! 1024: pppgetm(sc);
! 1025: if (m->m_next == NULL) {
! 1026: if (sc->sc_flags & SC_DEBUG)
! 1027: printf("%s: too few input mbufs!\n", sc->sc_if.if_xname);
! 1028: goto flush;
! 1029: }
! 1030: }
! 1031: sc->sc_mc = m = m->m_next;
! 1032: m->m_len = 0;
! 1033: m->m_data = M_DATASTART(m);
! 1034: sc->sc_mp = mtod(m, char *);
! 1035: }
! 1036:
! 1037: ++m->m_len;
! 1038: *sc->sc_mp++ = c;
! 1039: sc->sc_fcs = PPP_FCS(sc->sc_fcs, c);
! 1040: return 0;
! 1041:
! 1042: flush:
! 1043: if (!(sc->sc_flags & SC_FLUSH)) {
! 1044: s = spltty();
! 1045: sc->sc_if.if_ierrors++;
! 1046: sc->sc_stats.ppp_ierrors++;
! 1047: sc->sc_flags |= SC_FLUSH;
! 1048: splx(s);
! 1049: if (sc->sc_flags & SC_LOG_FLUSH)
! 1050: ppplogchar(sc, c);
! 1051: }
! 1052: return 0;
! 1053: }
! 1054:
! 1055: #define MAX_DUMP_BYTES 128
! 1056:
! 1057: void
! 1058: ppplogchar(sc, c)
! 1059: struct ppp_softc *sc;
! 1060: int c;
! 1061: {
! 1062: if (c >= 0)
! 1063: sc->sc_rawin[sc->sc_rawin_count++] = c;
! 1064: if (sc->sc_rawin_count >= sizeof(sc->sc_rawin)
! 1065: || (c < 0 && sc->sc_rawin_count > 0)) {
! 1066: printf("%s input: ", sc->sc_if.if_xname);
! 1067: pppdumpb(sc->sc_rawin, sc->sc_rawin_count);
! 1068: sc->sc_rawin_count = 0;
! 1069: }
! 1070: }
! 1071:
! 1072: void
! 1073: pppdumpb(b, l)
! 1074: u_char *b;
! 1075: int l;
! 1076: {
! 1077: char buf[3*MAX_DUMP_BYTES+4];
! 1078: char *bp = buf;
! 1079: static char digits[] = "0123456789abcdef";
! 1080:
! 1081: while (l--) {
! 1082: if (bp >= buf + sizeof(buf) - 3) {
! 1083: *bp++ = '>';
! 1084: break;
! 1085: }
! 1086: *bp++ = digits[*b >> 4]; /* convert byte to ascii hex */
! 1087: *bp++ = digits[*b++ & 0xf];
! 1088: *bp++ = ' ';
! 1089: }
! 1090:
! 1091: *bp = 0;
! 1092: printf("%s\n", buf);
! 1093: }
! 1094:
! 1095: #endif /* NPPP > 0 */
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to ppp_tty.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / net