| 1 | /* $NetBSD: ppp_tty.c,v 1.63 2016/10/02 14:17:07 christos Exp $ */ |
| 2 | /* Id: ppp_tty.c,v 1.3 1996/07/01 01:04:11 paulus 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 <sys/cdefs.h> |
| 96 | __KERNEL_RCSID(0, "$NetBSD: ppp_tty.c,v 1.63 2016/10/02 14:17:07 christos Exp $" ); |
| 97 | |
| 98 | #ifdef _KERNEL_OPT |
| 99 | #include "ppp.h" |
| 100 | #include "opt_ppp.h" |
| 101 | #endif |
| 102 | #define VJC |
| 103 | #define PPP_COMPRESS |
| 104 | |
| 105 | #include <sys/param.h> |
| 106 | #include <sys/proc.h> |
| 107 | #include <sys/mbuf.h> |
| 108 | #include <sys/dkstat.h> |
| 109 | #include <sys/socket.h> |
| 110 | #include <sys/ioctl.h> |
| 111 | #include <sys/file.h> |
| 112 | #include <sys/tty.h> |
| 113 | #include <sys/kernel.h> |
| 114 | #include <sys/conf.h> |
| 115 | #include <sys/vnode.h> |
| 116 | #include <sys/systm.h> |
| 117 | #include <sys/kauth.h> |
| 118 | |
| 119 | #include <net/if.h> |
| 120 | #include <net/if_types.h> |
| 121 | |
| 122 | #ifdef VJC |
| 123 | #include <netinet/in.h> |
| 124 | #include <netinet/in_systm.h> |
| 125 | #include <netinet/ip.h> |
| 126 | #include <net/slcompress.h> |
| 127 | #endif |
| 128 | |
| 129 | #include <net/bpf.h> |
| 130 | #include <net/ppp_defs.h> |
| 131 | #include <net/if_ppp.h> |
| 132 | #include <net/if_pppvar.h> |
| 133 | |
| 134 | static int pppopen(dev_t dev, struct tty *tp); |
| 135 | static int pppclose(struct tty *tp, int flag); |
| 136 | static int pppread(struct tty *tp, struct uio *uio, int flag); |
| 137 | static int pppwrite(struct tty *tp, struct uio *uio, int flag); |
| 138 | static int ppptioctl(struct tty *tp, u_long cmd, void *data, int flag, |
| 139 | struct lwp *); |
| 140 | static int pppinput(int c, struct tty *tp); |
| 141 | static int pppstart(struct tty *tp); |
| 142 | |
| 143 | struct linesw ppp_disc = { /* XXX should be static */ |
| 144 | .l_name = "ppp" , |
| 145 | .l_open = pppopen, |
| 146 | .l_close = pppclose, |
| 147 | .l_read = pppread, |
| 148 | .l_write = pppwrite, |
| 149 | .l_ioctl = ppptioctl, |
| 150 | .l_rint = pppinput, |
| 151 | .l_start = pppstart, |
| 152 | .l_modem = ttymodem, |
| 153 | .l_poll = ttpoll |
| 154 | }; |
| 155 | |
| 156 | static void ppprcvframe(struct ppp_softc *sc, struct mbuf *m); |
| 157 | static uint16_t pppfcs(uint16_t fcs, const uint8_t *cp, int len); |
| 158 | static void pppsyncstart(struct ppp_softc *sc); |
| 159 | static void pppasyncstart(struct ppp_softc *); |
| 160 | static void pppasyncctlp(struct ppp_softc *); |
| 161 | static void pppasyncrelinq(struct ppp_softc *); |
| 162 | static void ppp_timeout(void *); |
| 163 | static void pppgetm(struct ppp_softc *sc); |
| 164 | static void pppdumpb(u_char *b, int l); |
| 165 | static void ppplogchar(struct ppp_softc *, int); |
| 166 | static void pppdumpframe(struct ppp_softc *sc, struct mbuf* m, int xmit); |
| 167 | |
| 168 | /* |
| 169 | * Some useful mbuf macros not in mbuf.h. |
| 170 | */ |
| 171 | #define M_IS_CLUSTER(m) ((m)->m_flags & M_EXT) |
| 172 | |
| 173 | #define M_DATASTART(m) \ |
| 174 | (M_IS_CLUSTER(m) ? (m)->m_ext.ext_buf : \ |
| 175 | (m)->m_flags & M_PKTHDR ? (m)->m_pktdat : (m)->m_dat) |
| 176 | |
| 177 | #define M_DATASIZE(m) \ |
| 178 | (M_IS_CLUSTER(m) ? (m)->m_ext.ext_size : \ |
| 179 | (m)->m_flags & M_PKTHDR ? MHLEN: MLEN) |
| 180 | |
| 181 | /* |
| 182 | * Does c need to be escaped? |
| 183 | */ |
| 184 | #define ESCAPE_P(c) (sc->sc_asyncmap[(c) >> 5] & (1 << ((c) & 0x1F))) |
| 185 | |
| 186 | /* |
| 187 | * Procedures for using an async tty interface for PPP. |
| 188 | */ |
| 189 | |
| 190 | /* This is a NetBSD-1.0 or later kernel. */ |
| 191 | #define CCOUNT(q) ((q)->c_cc) |
| 192 | |
| 193 | #define PPP_LOWAT 100 /* Process more output when < LOWAT on queue */ |
| 194 | #define PPP_HIWAT 400 /* Don't start a new packet if HIWAT on que */ |
| 195 | |
| 196 | /* |
| 197 | * Line specific open routine for async tty devices. |
| 198 | * Attach the given tty to the first available ppp unit. |
| 199 | * Called from device open routine or ttioctl. |
| 200 | */ |
| 201 | /* ARGSUSED */ |
| 202 | static int |
| 203 | pppopen(dev_t dev, struct tty *tp) |
| 204 | { |
| 205 | struct lwp *l = curlwp; /* XXX */ |
| 206 | struct ppp_softc *sc; |
| 207 | int error, s; |
| 208 | |
| 209 | error = kauth_authorize_network(l->l_cred, KAUTH_NETWORK_INTERFACE_PPP, |
| 210 | KAUTH_REQ_NETWORK_INTERFACE_PPP_ADD, NULL, NULL, NULL); |
| 211 | if (error) |
| 212 | return (error); |
| 213 | |
| 214 | s = spltty(); |
| 215 | |
| 216 | if (tp->t_linesw == &ppp_disc) { |
| 217 | sc = (struct ppp_softc *) tp->t_sc; |
| 218 | if (sc != NULL && sc->sc_devp == (void *) tp) { |
| 219 | splx(s); |
| 220 | return (0); |
| 221 | } |
| 222 | } |
| 223 | |
| 224 | if ((sc = pppalloc(l->l_proc->p_pid)) == NULL) { |
| 225 | splx(s); |
| 226 | return ENXIO; |
| 227 | } |
| 228 | |
| 229 | if (sc->sc_relinq) |
| 230 | (*sc->sc_relinq)(sc); /* get previous owner to relinquish the unit */ |
| 231 | |
| 232 | /* Switch DLT to PPP-over-serial. */ |
| 233 | bpf_change_type(&sc->sc_if, DLT_PPP_SERIAL, PPP_HDRLEN); |
| 234 | |
| 235 | sc->sc_ilen = 0; |
| 236 | sc->sc_m = NULL; |
| 237 | memset(sc->sc_asyncmap, 0, sizeof(sc->sc_asyncmap)); |
| 238 | sc->sc_asyncmap[0] = 0xffffffff; |
| 239 | sc->sc_asyncmap[3] = 0x60000000; |
| 240 | sc->sc_rasyncmap = 0; |
| 241 | sc->sc_devp = (void *) tp; |
| 242 | sc->sc_start = pppasyncstart; |
| 243 | sc->sc_ctlp = pppasyncctlp; |
| 244 | sc->sc_relinq = pppasyncrelinq; |
| 245 | sc->sc_outm = NULL; |
| 246 | pppgetm(sc); |
| 247 | sc->sc_if.if_flags |= IFF_RUNNING; |
| 248 | sc->sc_if.if_baudrate = tp->t_ospeed; |
| 249 | |
| 250 | tp->t_sc = (void *) sc; |
| 251 | mutex_spin_enter(&tty_lock); |
| 252 | ttyflush(tp, FREAD | FWRITE); |
| 253 | mutex_spin_exit(&tty_lock); |
| 254 | |
| 255 | splx(s); |
| 256 | return (0); |
| 257 | } |
| 258 | |
| 259 | /* |
| 260 | * Line specific close routine, called from device close routine |
| 261 | * and from ttioctl. |
| 262 | * Detach the tty from the ppp unit. |
| 263 | * Mimics part of ttyclose(). |
| 264 | */ |
| 265 | static int |
| 266 | pppclose(struct tty *tp, int flag) |
| 267 | { |
| 268 | struct ppp_softc *sc; |
| 269 | int s; |
| 270 | |
| 271 | s = spltty(); |
| 272 | mutex_spin_enter(&tty_lock); |
| 273 | ttyflush(tp, FREAD|FWRITE); |
| 274 | mutex_spin_exit(&tty_lock); /* XXX */ |
| 275 | ttyldisc_release(tp->t_linesw); |
| 276 | tp->t_linesw = ttyldisc_default(); |
| 277 | sc = (struct ppp_softc *) tp->t_sc; |
| 278 | if (sc != NULL) { |
| 279 | tp->t_sc = NULL; |
| 280 | if (tp == (struct tty *) sc->sc_devp) { |
| 281 | pppasyncrelinq(sc); |
| 282 | pppdealloc(sc); |
| 283 | } |
| 284 | } |
| 285 | splx(s); |
| 286 | return 0; |
| 287 | } |
| 288 | |
| 289 | /* |
| 290 | * Relinquish the interface unit to another device. |
| 291 | */ |
| 292 | static void |
| 293 | pppasyncrelinq(struct ppp_softc *sc) |
| 294 | { |
| 295 | int s; |
| 296 | |
| 297 | /* Change DLT to back none. */ |
| 298 | bpf_change_type(&sc->sc_if, DLT_NULL, 0); |
| 299 | |
| 300 | s = spltty(); |
| 301 | if (sc->sc_outm) { |
| 302 | m_freem(sc->sc_outm); |
| 303 | sc->sc_outm = NULL; |
| 304 | } |
| 305 | if (sc->sc_m) { |
| 306 | m_freem(sc->sc_m); |
| 307 | sc->sc_m = NULL; |
| 308 | } |
| 309 | if (sc->sc_flags & SC_TIMEOUT) { |
| 310 | callout_stop(&sc->sc_timo_ch); |
| 311 | sc->sc_flags &= ~SC_TIMEOUT; |
| 312 | } |
| 313 | splx(s); |
| 314 | } |
| 315 | |
| 316 | /* |
| 317 | * Line specific (tty) read routine. |
| 318 | */ |
| 319 | static int |
| 320 | pppread(struct tty *tp, struct uio *uio, int flag) |
| 321 | { |
| 322 | struct ppp_softc *sc = (struct ppp_softc *)tp->t_sc; |
| 323 | struct mbuf *m, *m0; |
| 324 | int error = 0; |
| 325 | |
| 326 | if (sc == NULL) |
| 327 | return 0; |
| 328 | /* |
| 329 | * Loop waiting for input, checking that nothing disasterous |
| 330 | * happens in the meantime. |
| 331 | */ |
| 332 | mutex_spin_enter(&tty_lock); |
| 333 | for (;;) { |
| 334 | if (tp != (struct tty *) sc->sc_devp || |
| 335 | tp->t_linesw != &ppp_disc) { |
| 336 | mutex_spin_exit(&tty_lock); |
| 337 | return 0; |
| 338 | } |
| 339 | if (sc->sc_inq.ifq_head != NULL) |
| 340 | break; |
| 341 | if ((tp->t_state & TS_CARR_ON) == 0 && (tp->t_cflag & CLOCAL) == 0 |
| 342 | && (tp->t_state & TS_ISOPEN)) { |
| 343 | mutex_spin_exit(&tty_lock); |
| 344 | return 0; /* end of file */ |
| 345 | } |
| 346 | if (tp->t_state & TS_ASYNC || flag & IO_NDELAY) { |
| 347 | mutex_spin_exit(&tty_lock); |
| 348 | return (EWOULDBLOCK); |
| 349 | } |
| 350 | error = ttysleep(tp, &tp->t_rawcv, true, 0); |
| 351 | if (error) { |
| 352 | mutex_spin_exit(&tty_lock); |
| 353 | return error; |
| 354 | } |
| 355 | } |
| 356 | |
| 357 | /* Pull place-holder byte out of canonical queue */ |
| 358 | getc(&tp->t_canq); |
| 359 | |
| 360 | /* Get the packet from the input queue */ |
| 361 | IF_DEQUEUE(&sc->sc_inq, m0); |
| 362 | mutex_spin_exit(&tty_lock); |
| 363 | |
| 364 | for (m = m0; m && uio->uio_resid; m = m->m_next) |
| 365 | if ((error = uiomove(mtod(m, u_char *), m->m_len, uio)) != 0) |
| 366 | break; |
| 367 | m_freem(m0); |
| 368 | return (error); |
| 369 | } |
| 370 | |
| 371 | /* |
| 372 | * Line specific (tty) write routine. |
| 373 | */ |
| 374 | static int |
| 375 | pppwrite(struct tty *tp, struct uio *uio, int flag) |
| 376 | { |
| 377 | struct ppp_softc *sc = (struct ppp_softc *)tp->t_sc; |
| 378 | struct mbuf *m, *m0; |
| 379 | struct sockaddr dst; |
| 380 | int len, error; |
| 381 | |
| 382 | if ((tp->t_state & TS_CARR_ON) == 0 && (tp->t_cflag & CLOCAL) == 0) |
| 383 | return 0; /* wrote 0 bytes */ |
| 384 | if (tp->t_linesw != &ppp_disc) |
| 385 | return (EINVAL); |
| 386 | if (sc == NULL || tp != (struct tty *) sc->sc_devp) |
| 387 | return EIO; |
| 388 | if (uio->uio_resid > sc->sc_if.if_mtu + PPP_HDRLEN || |
| 389 | uio->uio_resid < PPP_HDRLEN) |
| 390 | return (EMSGSIZE); |
| 391 | |
| 392 | MGETHDR(m0, M_WAIT, MT_DATA); |
| 393 | if (m0 == NULL) |
| 394 | return ENOBUFS; |
| 395 | |
| 396 | m0->m_len = 0; |
| 397 | m0->m_pkthdr.len = uio->uio_resid; |
| 398 | m_reset_rcvif(m0); |
| 399 | |
| 400 | if (uio->uio_resid >= MCLBYTES / 2) |
| 401 | MCLGET(m0, M_DONTWAIT); |
| 402 | |
| 403 | for (m = m0; uio->uio_resid;) { |
| 404 | len = M_TRAILINGSPACE(m); |
| 405 | if (len > uio->uio_resid) |
| 406 | len = uio->uio_resid; |
| 407 | if ((error = uiomove(mtod(m, u_char *), len, uio)) != 0) { |
| 408 | m_freem(m0); |
| 409 | return (error); |
| 410 | } |
| 411 | m->m_len = len; |
| 412 | |
| 413 | if (uio->uio_resid == 0) |
| 414 | break; |
| 415 | |
| 416 | MGET(m->m_next, M_WAIT, MT_DATA); |
| 417 | if (m->m_next == NULL) { |
| 418 | m_freem(m0); |
| 419 | return ENOBUFS; |
| 420 | } |
| 421 | m = m->m_next; |
| 422 | m->m_len = 0; |
| 423 | } |
| 424 | dst.sa_family = AF_UNSPEC; |
| 425 | bcopy(mtod(m0, u_char *), dst.sa_data, PPP_HDRLEN); |
| 426 | m_adj(m0, PPP_HDRLEN); |
| 427 | return if_output_lock(&sc->sc_if, &sc->sc_if, m0, &dst, (struct rtentry *)0); |
| 428 | } |
| 429 | |
| 430 | /* |
| 431 | * Line specific (tty) ioctl routine. |
| 432 | * This discipline requires that tty device drivers call |
| 433 | * the line specific l_ioctl routine from their ioctl routines. |
| 434 | */ |
| 435 | /* ARGSUSED */ |
| 436 | static int |
| 437 | ppptioctl(struct tty *tp, u_long cmd, void *data, int flag, struct lwp *l) |
| 438 | { |
| 439 | struct ppp_softc *sc = (struct ppp_softc *) tp->t_sc; |
| 440 | int error, s; |
| 441 | |
| 442 | if (sc == NULL || tp != (struct tty *) sc->sc_devp) |
| 443 | return (EPASSTHROUGH); |
| 444 | |
| 445 | error = 0; |
| 446 | switch (cmd) { |
| 447 | case TIOCRCVFRAME: |
| 448 | ppprcvframe(sc,*((struct mbuf **)data)); |
| 449 | break; |
| 450 | |
| 451 | case PPPIOCSASYNCMAP: |
| 452 | if ((error = kauth_authorize_device_tty(l->l_cred, |
| 453 | KAUTH_DEVICE_TTY_PRIVSET, tp)) != 0) |
| 454 | break; |
| 455 | sc->sc_asyncmap[0] = *(u_int *)data; |
| 456 | break; |
| 457 | |
| 458 | case PPPIOCGASYNCMAP: |
| 459 | *(u_int *)data = sc->sc_asyncmap[0]; |
| 460 | break; |
| 461 | |
| 462 | case PPPIOCSRASYNCMAP: |
| 463 | if ((error = kauth_authorize_device_tty(l->l_cred, |
| 464 | KAUTH_DEVICE_TTY_PRIVSET, tp)) != 0) |
| 465 | break; |
| 466 | sc->sc_rasyncmap = *(u_int *)data; |
| 467 | break; |
| 468 | |
| 469 | case PPPIOCGRASYNCMAP: |
| 470 | *(u_int *)data = sc->sc_rasyncmap; |
| 471 | break; |
| 472 | |
| 473 | case PPPIOCSXASYNCMAP: |
| 474 | if ((error = kauth_authorize_device_tty(l->l_cred, |
| 475 | KAUTH_DEVICE_TTY_PRIVSET, tp)) != 0) |
| 476 | break; |
| 477 | s = spltty(); |
| 478 | bcopy(data, sc->sc_asyncmap, sizeof(sc->sc_asyncmap)); |
| 479 | sc->sc_asyncmap[1] = 0; /* mustn't escape 0x20 - 0x3f */ |
| 480 | sc->sc_asyncmap[2] &= ~0x40000000; /* mustn't escape 0x5e */ |
| 481 | sc->sc_asyncmap[3] |= 0x60000000; /* must escape 0x7d, 0x7e */ |
| 482 | splx(s); |
| 483 | break; |
| 484 | |
| 485 | case PPPIOCGXASYNCMAP: |
| 486 | bcopy(sc->sc_asyncmap, data, sizeof(sc->sc_asyncmap)); |
| 487 | break; |
| 488 | |
| 489 | default: |
| 490 | error = pppioctl(sc, cmd, data, flag, l); |
| 491 | if (error == 0 && cmd == PPPIOCSMRU) |
| 492 | pppgetm(sc); |
| 493 | } |
| 494 | |
| 495 | return error; |
| 496 | } |
| 497 | |
| 498 | /* receive a complete ppp frame from device in synchronous |
| 499 | * hdlc mode. caller gives up ownership of mbuf |
| 500 | */ |
| 501 | static void |
| 502 | ppprcvframe(struct ppp_softc *sc, struct mbuf *m) |
| 503 | { |
| 504 | int len, s; |
| 505 | struct mbuf *n; |
| 506 | u_char hdr[4]; |
| 507 | int hlen,count; |
| 508 | |
| 509 | for (n=m,len=0;n != NULL;n = n->m_next) |
| 510 | len += n->m_len; |
| 511 | if (len==0) { |
| 512 | m_freem(m); |
| 513 | return; |
| 514 | } |
| 515 | |
| 516 | /* extract PPP header from mbuf chain (1 to 4 bytes) */ |
| 517 | for (n=m,hlen=0;n!=NULL && hlen<sizeof(hdr);n=n->m_next) { |
| 518 | count = (sizeof(hdr)-hlen) < n->m_len ? |
| 519 | sizeof(hdr)-hlen : n->m_len; |
| 520 | bcopy(mtod(n,u_char*),&hdr[hlen],count); |
| 521 | hlen+=count; |
| 522 | } |
| 523 | |
| 524 | s = spltty(); |
| 525 | |
| 526 | /* if AFCF compressed then prepend AFCF */ |
| 527 | if (hdr[0] != PPP_ALLSTATIONS) { |
| 528 | if (sc->sc_flags & SC_REJ_COMP_AC) { |
| 529 | if (sc->sc_flags & SC_DEBUG) |
| 530 | printf( |
| 531 | "%s: garbage received: 0x%x (need 0xFF)\n" , |
| 532 | sc->sc_if.if_xname, hdr[0]); |
| 533 | goto bail; |
| 534 | } |
| 535 | M_PREPEND(m,2,M_DONTWAIT); |
| 536 | if (m==NULL) { |
| 537 | splx(s); |
| 538 | return; |
| 539 | } |
| 540 | hdr[3] = hdr[1]; |
| 541 | hdr[2] = hdr[0]; |
| 542 | hdr[0] = PPP_ALLSTATIONS; |
| 543 | hdr[1] = PPP_UI; |
| 544 | len += 2; |
| 545 | } |
| 546 | |
| 547 | /* if protocol field compressed, add MSB of protocol field = 0 */ |
| 548 | if (hdr[2] & 1) { |
| 549 | /* a compressed protocol */ |
| 550 | M_PREPEND(m,1,M_DONTWAIT); |
| 551 | if (m==NULL) { |
| 552 | splx(s); |
| 553 | return; |
| 554 | } |
| 555 | hdr[3] = hdr[2]; |
| 556 | hdr[2] = 0; |
| 557 | len++; |
| 558 | } |
| 559 | |
| 560 | /* valid LSB of protocol field has bit0 set */ |
| 561 | if (!(hdr[3] & 1)) { |
| 562 | if (sc->sc_flags & SC_DEBUG) |
| 563 | printf("%s: bad protocol %x\n" , sc->sc_if.if_xname, |
| 564 | (hdr[2] << 8) + hdr[3]); |
| 565 | goto bail; |
| 566 | } |
| 567 | |
| 568 | /* packet beyond configured mru? */ |
| 569 | if (len > sc->sc_mru + PPP_HDRLEN) { |
| 570 | if (sc->sc_flags & SC_DEBUG) |
| 571 | printf("%s: packet too big\n" , sc->sc_if.if_xname); |
| 572 | goto bail; |
| 573 | } |
| 574 | |
| 575 | /* add expanded 4 byte header to mbuf chain */ |
| 576 | for (n=m,hlen=0;n!=NULL && hlen<sizeof(hdr);n=n->m_next) { |
| 577 | count = (sizeof(hdr)-hlen) < n->m_len ? |
| 578 | sizeof(hdr)-hlen : n->m_len; |
| 579 | bcopy(&hdr[hlen],mtod(n,u_char*),count); |
| 580 | hlen+=count; |
| 581 | } |
| 582 | |
| 583 | /* if_ppp.c requires the PPP header and IP header */ |
| 584 | /* to be contiguous */ |
| 585 | count = len < MHLEN ? len : MHLEN; |
| 586 | if (m->m_len < count) { |
| 587 | m = m_pullup(m,count); |
| 588 | if (m==NULL) |
| 589 | goto bail; |
| 590 | } |
| 591 | |
| 592 | sc->sc_stats.ppp_ibytes += len; |
| 593 | |
| 594 | if (sc->sc_flags & SC_LOG_RAWIN) |
| 595 | pppdumpframe(sc,m,0); |
| 596 | |
| 597 | ppppktin(sc, m, 0); |
| 598 | splx(s); |
| 599 | return; |
| 600 | bail: |
| 601 | m_freem(m); |
| 602 | splx(s); |
| 603 | } |
| 604 | |
| 605 | /* |
| 606 | * FCS lookup table as calculated by genfcstab. |
| 607 | */ |
| 608 | static const uint16_t fcstab[256] = { |
| 609 | 0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf, |
| 610 | 0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7, |
| 611 | 0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e, |
| 612 | 0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876, |
| 613 | 0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd, |
| 614 | 0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5, |
| 615 | 0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c, |
| 616 | 0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974, |
| 617 | 0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb, |
| 618 | 0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3, |
| 619 | 0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a, |
| 620 | 0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72, |
| 621 | 0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9, |
| 622 | 0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1, |
| 623 | 0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738, |
| 624 | 0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70, |
| 625 | 0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7, |
| 626 | 0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff, |
| 627 | 0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036, |
| 628 | 0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e, |
| 629 | 0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5, |
| 630 | 0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd, |
| 631 | 0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134, |
| 632 | 0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c, |
| 633 | 0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3, |
| 634 | 0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb, |
| 635 | 0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232, |
| 636 | 0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a, |
| 637 | 0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1, |
| 638 | 0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9, |
| 639 | 0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330, |
| 640 | 0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78 |
| 641 | }; |
| 642 | |
| 643 | /* |
| 644 | * Calculate a new FCS given the current FCS and the new data. |
| 645 | */ |
| 646 | static uint16_t |
| 647 | pppfcs(uint16_t fcs, const uint8_t *cp, int len) |
| 648 | { |
| 649 | while (len--) |
| 650 | fcs = PPP_FCS(fcs, *cp++); |
| 651 | return (fcs); |
| 652 | } |
| 653 | |
| 654 | /* This gets called at splsoftnet from pppasyncstart at various times |
| 655 | * when there is data ready to be sent. |
| 656 | */ |
| 657 | static void |
| 658 | pppsyncstart(struct ppp_softc *sc) |
| 659 | { |
| 660 | struct tty *tp = (struct tty *) sc->sc_devp; |
| 661 | struct mbuf *m, *n; |
| 662 | const struct cdevsw *cdev; |
| 663 | int len; |
| 664 | |
| 665 | for(m = sc->sc_outm;;) { |
| 666 | if (m == NULL) { |
| 667 | m = ppp_dequeue(sc); /* get new packet */ |
| 668 | if (m == NULL) |
| 669 | break; /* no more packets */ |
| 670 | if (sc->sc_flags & SC_DEBUG) |
| 671 | pppdumpframe(sc,m,1); |
| 672 | } |
| 673 | for(n=m,len=0;n!=NULL;n=n->m_next) |
| 674 | len += n->m_len; |
| 675 | |
| 676 | /* call device driver IOCTL to transmit a frame */ |
| 677 | cdev = cdevsw_lookup(tp->t_dev); |
| 678 | if (cdev == NULL || |
| 679 | (*cdev->d_ioctl)(tp->t_dev, TIOCXMTFRAME, (void *)&m, |
| 680 | 0, 0)) { |
| 681 | /* busy or error, set as current packet */ |
| 682 | sc->sc_outm = m; |
| 683 | break; |
| 684 | } |
| 685 | sc->sc_outm = m = NULL; |
| 686 | sc->sc_stats.ppp_obytes += len; |
| 687 | } |
| 688 | } |
| 689 | |
| 690 | /* |
| 691 | * This gets called at splsoftnet from if_ppp.c at various times |
| 692 | * when there is data ready to be sent. |
| 693 | */ |
| 694 | static void |
| 695 | pppasyncstart(struct ppp_softc *sc) |
| 696 | { |
| 697 | struct tty *tp = (struct tty *) sc->sc_devp; |
| 698 | struct mbuf *m; |
| 699 | int len; |
| 700 | u_char *start, *stop, *cp; |
| 701 | int n, ndone, done, idle; |
| 702 | struct mbuf *m2; |
| 703 | |
| 704 | if (sc->sc_flags & SC_SYNC){ |
| 705 | pppsyncstart(sc); |
| 706 | return; |
| 707 | } |
| 708 | |
| 709 | mutex_spin_enter(&tty_lock); |
| 710 | |
| 711 | idle = 0; |
| 712 | while (CCOUNT(&tp->t_outq) < PPP_HIWAT) { |
| 713 | /* |
| 714 | * See if we have an existing packet partly sent. |
| 715 | * If not, get a new packet and start sending it. |
| 716 | */ |
| 717 | m = sc->sc_outm; |
| 718 | if (m == NULL) { |
| 719 | /* |
| 720 | * Get another packet to be sent. |
| 721 | */ |
| 722 | m = ppp_dequeue(sc); |
| 723 | if (m == NULL) { |
| 724 | idle = 1; |
| 725 | break; |
| 726 | } |
| 727 | |
| 728 | /* |
| 729 | * The extra PPP_FLAG will start up a new packet, and thus |
| 730 | * will flush any accumulated garbage. We do this whenever |
| 731 | * the line may have been idle for some time. |
| 732 | */ |
| 733 | if (CCOUNT(&tp->t_outq) == 0) { |
| 734 | ++sc->sc_stats.ppp_obytes; |
| 735 | (void) putc(PPP_FLAG, &tp->t_outq); |
| 736 | } |
| 737 | |
| 738 | /* Calculate the FCS for the first mbuf's worth. */ |
| 739 | sc->sc_outfcs = pppfcs(PPP_INITFCS, mtod(m, uint8_t *), m->m_len); |
| 740 | } |
| 741 | |
| 742 | for (;;) { |
| 743 | start = mtod(m, u_char *); |
| 744 | len = m->m_len; |
| 745 | stop = start + len; |
| 746 | while (len > 0) { |
| 747 | /* |
| 748 | * Find out how many bytes in the string we can |
| 749 | * handle without doing something special. |
| 750 | */ |
| 751 | for (cp = start; cp < stop; cp++) |
| 752 | if (ESCAPE_P(*cp)) |
| 753 | break; |
| 754 | n = cp - start; |
| 755 | if (n) { |
| 756 | /* NetBSD (0.9 or later), 4.3-Reno or similar. */ |
| 757 | ndone = n - b_to_q(start, n, &tp->t_outq); |
| 758 | len -= ndone; |
| 759 | start += ndone; |
| 760 | sc->sc_stats.ppp_obytes += ndone; |
| 761 | |
| 762 | if (ndone < n) |
| 763 | break; /* packet doesn't fit */ |
| 764 | } |
| 765 | /* |
| 766 | * If there are characters left in the mbuf, |
| 767 | * the first one must be special. |
| 768 | * Put it out in a different form. |
| 769 | */ |
| 770 | if (len) { |
| 771 | if (putc(PPP_ESCAPE, &tp->t_outq)) |
| 772 | break; |
| 773 | if (putc(*start ^ PPP_TRANS, &tp->t_outq)) { |
| 774 | (void) unputc(&tp->t_outq); |
| 775 | break; |
| 776 | } |
| 777 | sc->sc_stats.ppp_obytes += 2; |
| 778 | start++; |
| 779 | len--; |
| 780 | } |
| 781 | } |
| 782 | |
| 783 | /* |
| 784 | * If we didn't empty this mbuf, remember where we're up to. |
| 785 | * If we emptied the last mbuf, try to add the FCS and closing |
| 786 | * flag, and if we can't, leave sc_outm pointing to m, but with |
| 787 | * m->m_len == 0, to remind us to output the FCS and flag later. |
| 788 | */ |
| 789 | done = len == 0; |
| 790 | if (done && m->m_next == NULL) { |
| 791 | u_char *p, *q; |
| 792 | int c; |
| 793 | u_char endseq[8]; |
| 794 | |
| 795 | /* |
| 796 | * We may have to escape the bytes in the FCS. |
| 797 | */ |
| 798 | p = endseq; |
| 799 | c = ~sc->sc_outfcs & 0xFF; |
| 800 | if (ESCAPE_P(c)) { |
| 801 | *p++ = PPP_ESCAPE; |
| 802 | *p++ = c ^ PPP_TRANS; |
| 803 | } else |
| 804 | *p++ = c; |
| 805 | c = (~sc->sc_outfcs >> 8) & 0xFF; |
| 806 | if (ESCAPE_P(c)) { |
| 807 | *p++ = PPP_ESCAPE; |
| 808 | *p++ = c ^ PPP_TRANS; |
| 809 | } else |
| 810 | *p++ = c; |
| 811 | *p++ = PPP_FLAG; |
| 812 | |
| 813 | /* |
| 814 | * Try to output the FCS and flag. If the bytes |
| 815 | * don't all fit, back out. |
| 816 | */ |
| 817 | for (q = endseq; q < p; ++q) |
| 818 | if (putc(*q, &tp->t_outq)) { |
| 819 | done = 0; |
| 820 | for (; q > endseq; --q) |
| 821 | unputc(&tp->t_outq); |
| 822 | break; |
| 823 | } |
| 824 | if (done) |
| 825 | sc->sc_stats.ppp_obytes += q - endseq; |
| 826 | } |
| 827 | |
| 828 | if (!done) { |
| 829 | /* remember where we got to */ |
| 830 | m->m_data = start; |
| 831 | m->m_len = len; |
| 832 | break; |
| 833 | } |
| 834 | |
| 835 | /* Finished with this mbuf; free it and move on. */ |
| 836 | m = m2 = m_free(m); |
| 837 | if (m == NULL) { |
| 838 | /* Finished a packet */ |
| 839 | break; |
| 840 | } |
| 841 | sc->sc_outfcs = pppfcs(sc->sc_outfcs, mtod(m, uint8_t *), m->m_len); |
| 842 | } |
| 843 | |
| 844 | /* |
| 845 | * If m == NULL, we have finished a packet. |
| 846 | * If m != NULL, we've either done as much work this time |
| 847 | * as we need to, or else we've filled up the output queue. |
| 848 | */ |
| 849 | sc->sc_outm = m; |
| 850 | if (m) |
| 851 | break; |
| 852 | } |
| 853 | |
| 854 | /* Call pppstart to start output again if necessary. */ |
| 855 | pppstart(tp); |
| 856 | |
| 857 | /* |
| 858 | * This timeout is needed for operation on a pseudo-tty, |
| 859 | * because the pty code doesn't call pppstart after it has |
| 860 | * drained the t_outq. |
| 861 | */ |
| 862 | if (!idle && (sc->sc_flags & SC_TIMEOUT) == 0) { |
| 863 | callout_reset(&sc->sc_timo_ch, 1, ppp_timeout, sc); |
| 864 | sc->sc_flags |= SC_TIMEOUT; |
| 865 | } |
| 866 | |
| 867 | mutex_spin_exit(&tty_lock); |
| 868 | } |
| 869 | |
| 870 | /* |
| 871 | * This gets called when a received packet is placed on |
| 872 | * the inq, at splsoftnet. |
| 873 | */ |
| 874 | static void |
| 875 | pppasyncctlp(struct ppp_softc *sc) |
| 876 | { |
| 877 | struct tty *tp; |
| 878 | |
| 879 | /* Put a placeholder byte in canq for ttselect()/ttnread(). */ |
| 880 | mutex_spin_enter(&tty_lock); |
| 881 | tp = (struct tty *) sc->sc_devp; |
| 882 | putc(0, &tp->t_canq); |
| 883 | ttwakeup(tp); |
| 884 | mutex_spin_exit(&tty_lock); |
| 885 | } |
| 886 | |
| 887 | /* |
| 888 | * Start output on async tty interface. If the transmit queue |
| 889 | * has drained sufficiently, arrange for pppasyncstart to be |
| 890 | * called later at splsoftnet. |
| 891 | * Called at spltty or higher. |
| 892 | */ |
| 893 | static int |
| 894 | pppstart(struct tty *tp) |
| 895 | { |
| 896 | struct ppp_softc *sc = (struct ppp_softc *) tp->t_sc; |
| 897 | |
| 898 | /* |
| 899 | * If there is stuff in the output queue, send it now. |
| 900 | * We are being called in lieu of ttstart and must do what it would. |
| 901 | */ |
| 902 | if (tp->t_oproc != NULL) |
| 903 | (*tp->t_oproc)(tp); |
| 904 | |
| 905 | /* |
| 906 | * If the transmit queue has drained and the tty has not hung up |
| 907 | * or been disconnected from the ppp unit, then tell if_ppp.c that |
| 908 | * we need more output. |
| 909 | */ |
| 910 | if ((CCOUNT(&tp->t_outq) >= PPP_LOWAT) |
| 911 | && ((sc == NULL) || (sc->sc_flags & SC_TIMEOUT))) |
| 912 | return 0; |
| 913 | #ifdef ALTQ |
| 914 | /* |
| 915 | * if ALTQ is enabled, don't invoke NETISR_PPP. |
| 916 | * pppintr() could loop without doing anything useful |
| 917 | * under rate-limiting. |
| 918 | */ |
| 919 | if (ALTQ_IS_ENABLED(&sc->sc_if.if_snd)) |
| 920 | return 0; |
| 921 | #endif |
| 922 | if (!((tp->t_state & TS_CARR_ON) == 0 && (tp->t_cflag & CLOCAL) == 0) |
| 923 | && sc != NULL && tp == (struct tty *) sc->sc_devp) { |
| 924 | ppp_restart(sc); |
| 925 | } |
| 926 | |
| 927 | return 0; |
| 928 | } |
| 929 | |
| 930 | /* |
| 931 | * Timeout routine - try to start some more output. |
| 932 | */ |
| 933 | static void |
| 934 | ppp_timeout(void *x) |
| 935 | { |
| 936 | struct ppp_softc *sc = (struct ppp_softc *) x; |
| 937 | struct tty *tp = (struct tty *) sc->sc_devp; |
| 938 | |
| 939 | mutex_spin_enter(&tty_lock); |
| 940 | sc->sc_flags &= ~SC_TIMEOUT; |
| 941 | pppstart(tp); |
| 942 | mutex_spin_exit(&tty_lock); |
| 943 | } |
| 944 | |
| 945 | /* |
| 946 | * Allocate enough mbuf to handle current MRU. |
| 947 | */ |
| 948 | static void |
| 949 | pppgetm(struct ppp_softc *sc) |
| 950 | { |
| 951 | struct mbuf *m, **mp; |
| 952 | int len; |
| 953 | |
| 954 | mp = &sc->sc_m; |
| 955 | for (len = sc->sc_mru + PPP_HDRLEN + PPP_FCSLEN; len > 0; ){ |
| 956 | if ((m = *mp) == NULL) { |
| 957 | MGETHDR(m, M_DONTWAIT, MT_DATA); |
| 958 | if (m == NULL) |
| 959 | break; |
| 960 | *mp = m; |
| 961 | MCLGET(m, M_DONTWAIT); |
| 962 | } |
| 963 | len -= M_DATASIZE(m); |
| 964 | mp = &m->m_next; |
| 965 | } |
| 966 | } |
| 967 | |
| 968 | /* |
| 969 | * tty interface receiver interrupt. |
| 970 | */ |
| 971 | static const unsigned paritytab[8] = { |
| 972 | 0x96696996, 0x69969669, 0x69969669, 0x96696996, |
| 973 | 0x69969669, 0x96696996, 0x96696996, 0x69969669 |
| 974 | }; |
| 975 | |
| 976 | static int |
| 977 | pppinput(int c, struct tty *tp) |
| 978 | { |
| 979 | struct ppp_softc *sc; |
| 980 | struct mbuf *m; |
| 981 | int ilen, s; |
| 982 | int result; |
| 983 | |
| 984 | sc = (struct ppp_softc *) tp->t_sc; |
| 985 | if (sc == NULL || tp != (struct tty *) sc->sc_devp) |
| 986 | return 0; |
| 987 | |
| 988 | ++tk_nin; |
| 989 | ++sc->sc_stats.ppp_ibytes; |
| 990 | |
| 991 | if (c & TTY_FE) { |
| 992 | /* framing error or overrun on this char - abort packet */ |
| 993 | if (sc->sc_flags & SC_DEBUG) |
| 994 | printf("%s: bad char %x\n" , sc->sc_if.if_xname, c); |
| 995 | goto flush; |
| 996 | } |
| 997 | |
| 998 | c &= 0xff; |
| 999 | |
| 1000 | /* |
| 1001 | * Handle software flow control of output. |
| 1002 | */ |
| 1003 | result = tty_try_xonxoff(tp, c); |
| 1004 | if (result == 0) { |
| 1005 | /* Character was recognized and consumed. */ |
| 1006 | return 0; |
| 1007 | } |
| 1008 | /* Character wasn't consumed, continue processing it. */ |
| 1009 | |
| 1010 | s = spltty(); |
| 1011 | if (c & 0x80) |
| 1012 | sc->sc_flags |= SC_RCV_B7_1; |
| 1013 | else |
| 1014 | sc->sc_flags |= SC_RCV_B7_0; |
| 1015 | if (paritytab[c >> 5] & (1 << (c & 0x1F))) |
| 1016 | sc->sc_flags |= SC_RCV_ODDP; |
| 1017 | else |
| 1018 | sc->sc_flags |= SC_RCV_EVNP; |
| 1019 | splx(s); |
| 1020 | |
| 1021 | ppplogchar(sc, c); |
| 1022 | |
| 1023 | if (c == PPP_FLAG) { |
| 1024 | ilen = sc->sc_ilen; |
| 1025 | sc->sc_ilen = 0; |
| 1026 | |
| 1027 | if ((sc->sc_flags & SC_LOG_RAWIN) && sc->sc_rawin.count > 0) |
| 1028 | ppplogchar(sc, -1); |
| 1029 | |
| 1030 | /* |
| 1031 | * If SC_ESCAPED is set, then we've seen the packet |
| 1032 | * abort sequence "}~". |
| 1033 | */ |
| 1034 | if (sc->sc_flags & (SC_FLUSH | SC_ESCAPED) |
| 1035 | || (ilen > 0 && sc->sc_fcs != PPP_GOODFCS)) { |
| 1036 | s = spltty(); |
| 1037 | sc->sc_flags |= SC_PKTLOST; /* note the dropped packet */ |
| 1038 | if ((sc->sc_flags & (SC_FLUSH | SC_ESCAPED)) == 0){ |
| 1039 | if (sc->sc_flags & SC_DEBUG) |
| 1040 | printf("%s: bad fcs %x\n" , sc->sc_if.if_xname, |
| 1041 | sc->sc_fcs); |
| 1042 | sc->sc_if.if_ierrors++; |
| 1043 | sc->sc_stats.ppp_ierrors++; |
| 1044 | } else |
| 1045 | sc->sc_flags &= ~(SC_FLUSH | SC_ESCAPED); |
| 1046 | splx(s); |
| 1047 | return 0; |
| 1048 | } |
| 1049 | |
| 1050 | if (ilen < PPP_HDRLEN + PPP_FCSLEN) { |
| 1051 | if (ilen) { |
| 1052 | if (sc->sc_flags & SC_DEBUG) |
| 1053 | printf("%s: too short (%d)\n" , sc->sc_if.if_xname, ilen); |
| 1054 | s = spltty(); |
| 1055 | sc->sc_if.if_ierrors++; |
| 1056 | sc->sc_stats.ppp_ierrors++; |
| 1057 | sc->sc_flags |= SC_PKTLOST; |
| 1058 | splx(s); |
| 1059 | } |
| 1060 | return 0; |
| 1061 | } |
| 1062 | |
| 1063 | /* |
| 1064 | * Remove FCS trailer. Somewhat painful... |
| 1065 | */ |
| 1066 | ilen -= 2; |
| 1067 | if (--sc->sc_mc->m_len == 0) { |
| 1068 | for (m = sc->sc_m; m->m_next != sc->sc_mc; m = m->m_next) |
| 1069 | ; |
| 1070 | sc->sc_mc = m; |
| 1071 | } |
| 1072 | sc->sc_mc->m_len--; |
| 1073 | |
| 1074 | /* excise this mbuf chain */ |
| 1075 | m = sc->sc_m; |
| 1076 | sc->sc_m = sc->sc_mc->m_next; |
| 1077 | sc->sc_mc->m_next = NULL; |
| 1078 | |
| 1079 | ppppktin(sc, m, sc->sc_flags & SC_PKTLOST); |
| 1080 | if (sc->sc_flags & SC_PKTLOST) { |
| 1081 | s = spltty(); |
| 1082 | sc->sc_flags &= ~SC_PKTLOST; |
| 1083 | splx(s); |
| 1084 | } |
| 1085 | |
| 1086 | pppgetm(sc); |
| 1087 | return 0; |
| 1088 | } |
| 1089 | |
| 1090 | if (sc->sc_flags & SC_FLUSH) { |
| 1091 | if (sc->sc_flags & SC_LOG_FLUSH) |
| 1092 | ppplogchar(sc, c); |
| 1093 | return 0; |
| 1094 | } |
| 1095 | |
| 1096 | if (c < 0x20 && (sc->sc_rasyncmap & (1 << c))) |
| 1097 | return 0; |
| 1098 | |
| 1099 | s = spltty(); |
| 1100 | if (sc->sc_flags & SC_ESCAPED) { |
| 1101 | sc->sc_flags &= ~SC_ESCAPED; |
| 1102 | c ^= PPP_TRANS; |
| 1103 | } else if (c == PPP_ESCAPE) { |
| 1104 | sc->sc_flags |= SC_ESCAPED; |
| 1105 | splx(s); |
| 1106 | return 0; |
| 1107 | } |
| 1108 | splx(s); |
| 1109 | |
| 1110 | /* |
| 1111 | * Initialize buffer on first octet received. |
| 1112 | * First octet could be address or protocol (when compressing |
| 1113 | * address/control). |
| 1114 | * Second octet is control. |
| 1115 | * Third octet is first or second (when compressing protocol) |
| 1116 | * octet of protocol. |
| 1117 | * Fourth octet is second octet of protocol. |
| 1118 | */ |
| 1119 | if (sc->sc_ilen == 0) { |
| 1120 | /* reset the first input mbuf */ |
| 1121 | if (sc->sc_m == NULL) { |
| 1122 | pppgetm(sc); |
| 1123 | if (sc->sc_m == NULL) { |
| 1124 | if (sc->sc_flags & SC_DEBUG) |
| 1125 | printf("%s: no input mbufs!\n" , sc->sc_if.if_xname); |
| 1126 | goto flush; |
| 1127 | } |
| 1128 | } |
| 1129 | m = sc->sc_m; |
| 1130 | m->m_len = 0; |
| 1131 | m->m_data = M_DATASTART(sc->sc_m); |
| 1132 | sc->sc_mc = m; |
| 1133 | sc->sc_mp = mtod(m, char *); |
| 1134 | sc->sc_fcs = PPP_INITFCS; |
| 1135 | if (c != PPP_ALLSTATIONS) { |
| 1136 | if (sc->sc_flags & SC_REJ_COMP_AC) { |
| 1137 | if (sc->sc_flags & SC_DEBUG) |
| 1138 | printf("%s: garbage received: 0x%x (need 0xFF)\n" , |
| 1139 | sc->sc_if.if_xname, c); |
| 1140 | goto flush; |
| 1141 | } |
| 1142 | *sc->sc_mp++ = PPP_ALLSTATIONS; |
| 1143 | *sc->sc_mp++ = PPP_UI; |
| 1144 | sc->sc_ilen += 2; |
| 1145 | m->m_len += 2; |
| 1146 | } |
| 1147 | } |
| 1148 | if (sc->sc_ilen == 1 && c != PPP_UI) { |
| 1149 | if (sc->sc_flags & SC_DEBUG) |
| 1150 | printf("%s: missing UI (0x3), got 0x%x\n" , |
| 1151 | sc->sc_if.if_xname, c); |
| 1152 | goto flush; |
| 1153 | } |
| 1154 | if (sc->sc_ilen == 2 && (c & 1) == 1) { |
| 1155 | /* a compressed protocol */ |
| 1156 | *sc->sc_mp++ = 0; |
| 1157 | sc->sc_ilen++; |
| 1158 | sc->sc_mc->m_len++; |
| 1159 | } |
| 1160 | if (sc->sc_ilen == 3 && (c & 1) == 0) { |
| 1161 | if (sc->sc_flags & SC_DEBUG) |
| 1162 | printf("%s: bad protocol %x\n" , sc->sc_if.if_xname, |
| 1163 | (sc->sc_mp[-1] << 8) + c); |
| 1164 | goto flush; |
| 1165 | } |
| 1166 | |
| 1167 | /* packet beyond configured mru? */ |
| 1168 | if (++sc->sc_ilen > sc->sc_mru + PPP_HDRLEN + PPP_FCSLEN) { |
| 1169 | if (sc->sc_flags & SC_DEBUG) |
| 1170 | printf("%s: packet too big\n" , sc->sc_if.if_xname); |
| 1171 | goto flush; |
| 1172 | } |
| 1173 | |
| 1174 | /* is this mbuf full? */ |
| 1175 | m = sc->sc_mc; |
| 1176 | if (M_TRAILINGSPACE(m) <= 0) { |
| 1177 | if (m->m_next == NULL) { |
| 1178 | pppgetm(sc); |
| 1179 | if (m->m_next == NULL) { |
| 1180 | if (sc->sc_flags & SC_DEBUG) |
| 1181 | printf("%s: too few input mbufs!\n" , sc->sc_if.if_xname); |
| 1182 | goto flush; |
| 1183 | } |
| 1184 | } |
| 1185 | sc->sc_mc = m = m->m_next; |
| 1186 | m->m_len = 0; |
| 1187 | m->m_data = M_DATASTART(m); |
| 1188 | sc->sc_mp = mtod(m, char *); |
| 1189 | } |
| 1190 | |
| 1191 | ++m->m_len; |
| 1192 | *sc->sc_mp++ = c; |
| 1193 | sc->sc_fcs = PPP_FCS(sc->sc_fcs, c); |
| 1194 | return 0; |
| 1195 | |
| 1196 | flush: |
| 1197 | if (!(sc->sc_flags & SC_FLUSH)) { |
| 1198 | s = spltty(); |
| 1199 | sc->sc_if.if_ierrors++; |
| 1200 | sc->sc_stats.ppp_ierrors++; |
| 1201 | sc->sc_flags |= SC_FLUSH; |
| 1202 | splx(s); |
| 1203 | if (sc->sc_flags & SC_LOG_FLUSH) |
| 1204 | ppplogchar(sc, c); |
| 1205 | } |
| 1206 | return 0; |
| 1207 | } |
| 1208 | |
| 1209 | #define MAX_DUMP_BYTES 128 |
| 1210 | |
| 1211 | static void |
| 1212 | ppplogchar(struct ppp_softc *sc, int c) |
| 1213 | { |
| 1214 | if (c >= 0) { |
| 1215 | sc->sc_rawin.buf[sc->sc_rawin_start++] = c; |
| 1216 | if (sc->sc_rawin.count < sizeof(sc->sc_rawin.buf)) |
| 1217 | sc->sc_rawin.count++; |
| 1218 | } |
| 1219 | if (sc->sc_rawin_start >= sizeof(sc->sc_rawin.buf) |
| 1220 | || (c < 0 && sc->sc_rawin_start > 0)) { |
| 1221 | if (sc->sc_flags & (SC_LOG_FLUSH|SC_LOG_RAWIN)) { |
| 1222 | printf("%s input: " , sc->sc_if.if_xname); |
| 1223 | pppdumpb(sc->sc_rawin.buf, sc->sc_rawin_start); |
| 1224 | } |
| 1225 | if (c < 0) |
| 1226 | sc->sc_rawin.count = 0; |
| 1227 | sc->sc_rawin_start = 0; |
| 1228 | } |
| 1229 | } |
| 1230 | |
| 1231 | static void |
| 1232 | pppdumpb(u_char *b, int l) |
| 1233 | { |
| 1234 | char bf[3*MAX_DUMP_BYTES+4]; |
| 1235 | char *bp = bf; |
| 1236 | |
| 1237 | while (l--) { |
| 1238 | if (bp >= bf + sizeof(bf) - 3) { |
| 1239 | *bp++ = '>'; |
| 1240 | break; |
| 1241 | } |
| 1242 | *bp++ = hexdigits[*b >> 4]; /* convert byte to ascii hex */ |
| 1243 | *bp++ = hexdigits[*b++ & 0xf]; |
| 1244 | *bp++ = ' '; |
| 1245 | } |
| 1246 | |
| 1247 | *bp = 0; |
| 1248 | printf("%s\n" , bf); |
| 1249 | } |
| 1250 | |
| 1251 | static void |
| 1252 | pppdumpframe(struct ppp_softc *sc, struct mbuf *m, int xmit) |
| 1253 | { |
| 1254 | int i,lcount,copycount,count; |
| 1255 | char lbuf[16]; |
| 1256 | char *data; |
| 1257 | |
| 1258 | if (m == NULL) |
| 1259 | return; |
| 1260 | |
| 1261 | for(count=m->m_len,data=mtod(m,char*);m != NULL;) { |
| 1262 | /* build a line of output */ |
| 1263 | for(lcount=0;lcount < sizeof(lbuf);lcount += copycount) { |
| 1264 | if (!count) { |
| 1265 | m = m->m_next; |
| 1266 | if (m == NULL) |
| 1267 | break; |
| 1268 | count = m->m_len; |
| 1269 | data = mtod(m,char*); |
| 1270 | } |
| 1271 | copycount = (count > sizeof(lbuf)-lcount) ? |
| 1272 | sizeof(lbuf)-lcount : count; |
| 1273 | bcopy(data,&lbuf[lcount],copycount); |
| 1274 | data += copycount; |
| 1275 | count -= copycount; |
| 1276 | } |
| 1277 | |
| 1278 | /* output line (hex 1st, then ascii) */ |
| 1279 | printf("%s %s:" , sc->sc_if.if_xname, |
| 1280 | xmit ? "output" : "input " ); |
| 1281 | for(i=0;i<lcount;i++) |
| 1282 | printf("%02x " ,(u_char)lbuf[i]); |
| 1283 | for(;i<sizeof(lbuf);i++) |
| 1284 | printf(" " ); |
| 1285 | for(i=0;i<lcount;i++) |
| 1286 | printf("%c" ,(lbuf[i] >= 040 && |
| 1287 | lbuf[i] <= 0176) ? lbuf[i] : '.'); |
| 1288 | printf("\n" ); |
| 1289 | } |
| 1290 | } |
| 1291 | |