drivers/net/ppp_async.c

   1 /*
   2  * PPP async serial channel driver for Linux.
   3  *
   4  * Copyright 1999 Paul Mackerras.
   5  *
   6  *  This program is free software; you can redistribute it and/or
   7  *  modify it under the terms of the GNU General Public License
   8  *  as published by the Free Software Foundation; either version
   9  *  2 of the License, or (at your option) any later version.
  10  *
  11  * This driver provides the encapsulation and framing for sending
  12  * and receiving PPP frames over async serial lines.  It relies on
  13  * the generic PPP layer to give it frames to send and to process
  14  * received frames.  It implements the PPP line discipline.
  15  *
  16  * Part of the code in this driver was inspired by the old async-only
  17  * PPP driver, written by Michael Callahan and Al Longyear, and
  18  * subsequently hacked by Paul Mackerras.
  19  *
  20  * ==FILEVERSION 20020125==
  21  */
  22
  23 #include <linux/module.h>
  24 #include <linux/kernel.h>
  25 #include <linux/skbuff.h>
  26 #include <linux/tty.h>
  27 #include <linux/netdevice.h>
  28 #include <linux/poll.h>
  29 #include <linux/ppp_defs.h>
  30 #include <linux/if_ppp.h>
  31 #include <linux/ppp_channel.h>
  32 #include <linux/spinlock.h>
  33 #include <linux/init.h>
  34 #include <asm/uaccess.h>
  35
  36 #define PPP_VERSION     "2.4.2"
  37
  38 #define OBUFSIZE        256
  39
  40 /* Structure for storing local state. */
  41 struct asyncppp {
  42         struct tty_struct *tty;
  43         unsigned int    flags;
  44         unsigned int    state;
  45         unsigned int    rbits;
  46         int             mru;
  47         spinlock_t      xmit_lock;
  48         spinlock_t      recv_lock;
  49         unsigned long   xmit_flags;
  50         u32             xaccm[8];
  51         u32             raccm;
  52         unsigned int    bytes_sent;
  53         unsigned int    bytes_rcvd;
  54
  55         struct sk_buff  *tpkt;
  56         int             tpkt_pos;
  57         u16             tfcs;
  58         unsigned char   *optr;
  59         unsigned char   *olim;
  60         unsigned long   last_xmit;
  61
  62         struct sk_buff  *rpkt;
  63         int             lcp_fcs;
  64
  65         atomic_t        refcnt;
  66         struct semaphore dead_sem;
  67         struct ppp_channel chan;        /* interface to generic ppp layer */
  68         unsigned char   obuf[OBUFSIZE];
  69 };
  70
  71 /* Bit numbers in xmit_flags */
  72 #define XMIT_WAKEUP     0
  73 #define XMIT_FULL       1
  74 #define XMIT_BUSY       2
  75
  76 /* State bits */
  77 #define SC_TOSS         0x20000000
  78 #define SC_ESCAPE       0x40000000
  79
  80 /* Bits in rbits */
  81 #define SC_RCV_BITS     (SC_RCV_B7_1|SC_RCV_B7_0|SC_RCV_ODDP|SC_RCV_EVNP)
  82
  83 static int flag_time = HZ;
  84 MODULE_PARM(flag_time, "i");
  85 MODULE_PARM_DESC(flag_time, "ppp_async: interval between flagged packets (in clock ticks)");
  86 MODULE_LICENSE("GPL");
  87
  88
  89 /*
  90  * Prototypes.
  91  */
  92 static int ppp_async_encode(struct asyncppp *ap);
  93 static int ppp_async_send(struct ppp_channel *chan, struct sk_buff *skb);
  94 static int ppp_async_push(struct asyncppp *ap);
  95 static void ppp_async_flush_output(struct asyncppp *ap);
  96 static void ppp_async_input(struct asyncppp *ap, const unsigned char *buf,
  97                             char *flags, int count);
  98 static int ppp_async_ioctl(struct ppp_channel *chan, unsigned int cmd,
  99                            unsigned long arg);
 100 static void async_lcp_peek(struct asyncppp *ap, unsigned char *data,
 101                            int len, int inbound);
 102
 103 static struct ppp_channel_ops async_ops = {
 104         ppp_async_send,
 105         ppp_async_ioctl
 106 };
 107
 108 /*
 109  * Routines implementing the PPP line discipline.
 110  */
 111
 112 /*
 113  * We have a potential race on dereferencing tty->disc_data,
 114  * because the tty layer provides no locking at all - thus one
 115  * cpu could be running ppp_asynctty_receive while another
 116  * calls ppp_asynctty_close, which zeroes tty->disc_data and
 117  * frees the memory that ppp_asynctty_receive is using.  The best
 118  * way to fix this is to use a rwlock in the tty struct, but for now
 119  * we use a single global rwlock for all ttys in ppp line discipline.
 120  *
 121  * FIXME: this is no longer true. The _close path for the ldisc is
 122  * now guaranteed to be sane.
 123  */
 124 static rwlock_t disc_data_lock = RW_LOCK_UNLOCKED;
 125
 126 static struct asyncppp *ap_get(struct tty_struct *tty)
 127 {
 128         struct asyncppp *ap;
 129
 130         read_lock(&disc_data_lock);
 131         ap = tty->disc_data;
 132         if (ap != NULL)
 133                 atomic_inc(&ap->refcnt);
 134         read_unlock(&disc_data_lock);
 135         return ap;
 136 }
 137
 138 static void ap_put(struct asyncppp *ap)
 139 {
 140         if (atomic_dec_and_test(&ap->refcnt))
 141                 up(&ap->dead_sem);
 142 }
 143
 144 /*
 145  * Called when a tty is put into PPP line discipline. Called in process
 146  * context.
 147  */
 148 static int
 149 ppp_asynctty_open(struct tty_struct *tty)
 150 {
 151         struct asyncppp *ap;
 152         int err;
 153
 154         MOD_INC_USE_COUNT;
 155         err = -ENOMEM;
 156         ap = kmalloc(sizeof(*ap), GFP_KERNEL);
 157         if (ap == 0)
 158                 goto out;
 159
 160         /* initialize the asyncppp structure */
 161         memset(ap, 0, sizeof(*ap));
 162         ap->tty = tty;
 163         ap->mru = PPP_MRU;
 164         spin_lock_init(&ap->xmit_lock);
 165         spin_lock_init(&ap->recv_lock);
 166         ap->xaccm[0] = ~0U;
 167         ap->xaccm[3] = 0x60000000U;
 168         ap->raccm = ~0U;
 169         ap->optr = ap->obuf;
 170         ap->olim = ap->obuf;
 171         ap->lcp_fcs = -1;
 172
 173         atomic_set(&ap->refcnt, 1);
 174         init_MUTEX_LOCKED(&ap->dead_sem);
 175
 176         ap->chan.private = ap;
 177         ap->chan.ops = &async_ops;
 178         ap->chan.mtu = PPP_MRU;
 179         err = ppp_register_channel(&ap->chan);
 180         if (err)
 181                 goto out_free;
 182
 183         tty->disc_data = ap;
 184
 185         return 0;
 186
 187  out_free:
 188         kfree(ap);
 189  out:
 190         MOD_DEC_USE_COUNT;
 191         return err;
 192 }
 193
 194 /*
 195  * Called when the tty is put into another line discipline
 196  * or it hangs up.  We have to wait for any cpu currently
 197  * executing in any of the other ppp_asynctty_* routines to
 198  * finish before we can call ppp_unregister_channel and free
 199  * the asyncppp struct.  This routine must be called from
 200  * process context, not interrupt or softirq context.
 201  */
 202 static void
 203 ppp_asynctty_close(struct tty_struct *tty)
 204 {
 205         struct asyncppp *ap;
 206
 207         write_lock(&disc_data_lock);
 208         ap = tty->disc_data;
 209         tty->disc_data = 0;
 210         write_unlock(&disc_data_lock);
 211         if (ap == 0)
 212                 return;
 213
 214         /*
 215          * We have now ensured that nobody can start using ap from now
 216          * on, but we have to wait for all existing users to finish.
 217          * Note that ppp_unregister_channel ensures that no calls to
 218          * our channel ops (i.e. ppp_async_send/ioctl) are in progress
 219          * by the time it returns.
 220          */
 221         if (!atomic_dec_and_test(&ap->refcnt))
 222                 down(&ap->dead_sem);
 223
 224         ppp_unregister_channel(&ap->chan);
 225         if (ap->rpkt != 0)
 226                 kfree_skb(ap->rpkt);
 227         if (ap->tpkt != 0)
 228                 kfree_skb(ap->tpkt);
 229         kfree(ap);
 230         MOD_DEC_USE_COUNT;
 231 }
 232
 233 /*
 234  * Called on tty hangup in process context.
 235  *
 236  * Wait for I/O to driver to complete and unregister PPP channel.
 237  * This is already done by the close routine, so just call that.
 238  */
 239 static int ppp_asynctty_hangup(struct tty_struct *tty)
 240 {
 241         ppp_asynctty_close(tty);
 242         return 0;
 243 }
 244
 245 /*
 246  * Read does nothing - no data is ever available this way.
 247  * Pppd reads and writes packets via /dev/ppp instead.
 248  */
 249 static ssize_t
 250 ppp_asynctty_read(struct tty_struct *tty, struct file *file,
 251                   unsigned char *buf, size_t count)
 252 {
 253         return -EAGAIN;
 254 }
 255
 256 /*
 257  * Write on the tty does nothing, the packets all come in
 258  * from the ppp generic stuff.
 259  */
 260 static ssize_t
 261 ppp_asynctty_write(struct tty_struct *tty, struct file *file,
 262                    const unsigned char *buf, size_t count)
 263 {
 264         return -EAGAIN;
 265 }
 266
 267 /*
 268  * Called in process context only. May be re-entered by multiple
 269  * ioctl calling threads.
 270  */
 271
 272 static int
 273 ppp_asynctty_ioctl(struct tty_struct *tty, struct file *file,
 274                    unsigned int cmd, unsigned long arg)
 275 {
 276         struct asyncppp *ap = ap_get(tty);
 277         int err, val;
 278
 279         if (ap == 0)
 280                 return -ENXIO;
 281         err = -EFAULT;
 282         switch (cmd) {
 283         case PPPIOCGCHAN:
 284                 err = -ENXIO;
 285                 if (ap == 0)
 286                         break;
 287                 err = -EFAULT;
 288                 if (put_user(ppp_channel_index(&ap->chan), (int *) arg))
 289                         break;
 290                 err = 0;
 291                 break;
 292
 293         case PPPIOCGUNIT:
 294                 err = -ENXIO;
 295                 if (ap == 0)
 296                         break;
 297                 err = -EFAULT;
 298                 if (put_user(ppp_unit_number(&ap->chan), (int *) arg))
 299                         break;
 300                 err = 0;
 301                 break;
 302
 303         case TCGETS:
 304         case TCGETA:
 305                 err = n_tty_ioctl(tty, file, cmd, arg);
 306                 break;
 307
 308         case TCFLSH:
 309                 /* flush our buffers and the serial port's buffer */
 310                 if (arg == TCIOFLUSH || arg == TCOFLUSH)
 311                         ppp_async_flush_output(ap);
 312                 err = n_tty_ioctl(tty, file, cmd, arg);
 313                 break;
 314
 315         case FIONREAD:
 316                 val = 0;
 317                 if (put_user(val, (int *) arg))
 318                         break;
 319                 err = 0;
 320                 break;
 321
 322         default:
 323                 err = -ENOIOCTLCMD;
 324         }
 325
 326         ap_put(ap);
 327         return err;
 328 }
 329
 330 /* No kernel lock - fine */
 331 static unsigned int
 332 ppp_asynctty_poll(struct tty_struct *tty, struct file *file, poll_table *wait)
 333 {
 334         return 0;
 335 }
 336
 337 static int
 338 ppp_asynctty_room(struct tty_struct *tty)
 339 {
 340         return 65535;
 341 }
 342
 343 static void
 344 ppp_asynctty_receive(struct tty_struct *tty, const unsigned char *buf,
 345                   char *flags, int count)
 346 {
 347         struct asyncppp *ap = ap_get(tty);
 348
 349         if (ap == 0)
 350                 return;
 351         spin_lock_bh(&ap->recv_lock);
 352         ppp_async_input(ap, buf, flags, count);
 353         spin_unlock_bh(&ap->recv_lock);
 354         ap_put(ap);
 355         if (test_and_clear_bit(TTY_THROTTLED, &tty->flags)
 356             && tty->driver.unthrottle)
 357                 tty->driver.unthrottle(tty);
 358 }
 359
 360 static void
 361 ppp_asynctty_wakeup(struct tty_struct *tty)
 362 {
 363         struct asyncppp *ap = ap_get(tty);
 364
 365         clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
 366         if (ap == 0)
 367                 return;
 368         if (ppp_async_push(ap))
 369                 ppp_output_wakeup(&ap->chan);
 370         ap_put(ap);
 371 }
 372
 373
 374 static struct tty_ldisc ppp_ldisc = {
 375         magic:  TTY_LDISC_MAGIC,
 376         name:   "ppp",
 377         open:   ppp_asynctty_open,
 378         close:  ppp_asynctty_close,
 379         read:   ppp_asynctty_read,
 380         write:  ppp_asynctty_write,
 381         ioctl:  ppp_asynctty_ioctl,
 382         poll:   ppp_asynctty_poll,
 383         hangup: ppp_asynctty_hangup,
 384         receive_room: ppp_asynctty_room,
 385         receive_buf: ppp_asynctty_receive,
 386         write_wakeup: ppp_asynctty_wakeup,
 387 };
 388
 389 static int __init
 390 ppp_async_init(void)
 391 {
 392         int err;
 393
 394         err = tty_register_ldisc(N_PPP, &ppp_ldisc);
 395         if (err != 0)
 396                 printk(KERN_ERR "PPP_async: error %d registering line disc.\n",
 397                        err);
 398         return err;
 399 }
 400
 401 /*
 402  * The following routines provide the PPP channel interface.
 403  */
 404 static int
 405 ppp_async_ioctl(struct ppp_channel *chan, unsigned int cmd, unsigned long arg)
 406 {
 407         struct asyncppp *ap = chan->private;
 408         int err, val;
 409         u32 accm[8];
 410
 411         err = -EFAULT;
 412         switch (cmd) {
 413         case PPPIOCGFLAGS:
 414                 val = ap->flags | ap->rbits;
 415                 if (put_user(val, (int *) arg))
 416                         break;
 417                 err = 0;
 418                 break;
 419         case PPPIOCSFLAGS:
 420                 if (get_user(val, (int *) arg))
 421                         break;
 422                 ap->flags = val & ~SC_RCV_BITS;
 423                 spin_lock_bh(&ap->recv_lock);
 424                 ap->rbits = val & SC_RCV_BITS;
 425                 spin_unlock_bh(&ap->recv_lock);
 426                 err = 0;
 427                 break;
 428
 429         case PPPIOCGASYNCMAP:
 430                 if (put_user(ap->xaccm[0], (u32 *) arg))
 431                         break;
 432                 err = 0;
 433                 break;
 434         case PPPIOCSASYNCMAP:
 435                 if (get_user(ap->xaccm[0], (u32 *) arg))
 436                         break;
 437                 err = 0;
 438                 break;
 439
 440         case PPPIOCGRASYNCMAP:
 441                 if (put_user(ap->raccm, (u32 *) arg))
 442                         break;
 443                 err = 0;
 444                 break;
 445         case PPPIOCSRASYNCMAP:
 446                 if (get_user(ap->raccm, (u32 *) arg))
 447                         break;
 448                 err = 0;
 449                 break;
 450
 451         case PPPIOCGXASYNCMAP:
 452                 if (copy_to_user((void *) arg, ap->xaccm, sizeof(ap->xaccm)))
 453                         break;
 454                 err = 0;
 455                 break;
 456         case PPPIOCSXASYNCMAP:
 457                 if (copy_from_user(accm, (void *) arg, sizeof(accm)))
 458                         break;
 459                 accm[2] &= ~0x40000000U;        /* can't escape 0x5e */
 460                 accm[3] |= 0x60000000U;         /* must escape 0x7d, 0x7e */
 461                 memcpy(ap->xaccm, accm, sizeof(ap->xaccm));
 462                 err = 0;
 463                 break;
 464
 465         case PPPIOCGMRU:
 466                 if (put_user(ap->mru, (int *) arg))
 467                         break;
 468                 err = 0;
 469                 break;
 470         case PPPIOCSMRU:
 471                 if (get_user(val, (int *) arg))
 472                         break;
 473                 if (val < PPP_MRU)
 474                         val = PPP_MRU;
 475                 ap->mru = val;
 476                 err = 0;
 477                 break;
 478
 479         default:
 480                 err = -ENOTTY;
 481         }
 482
 483         return err;
 484 }
 485
 486 /*
 487  * Procedures for encapsulation and framing.
 488  */
 489
 490 u16 ppp_crc16_table[256] = {
 491         0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
 492         0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
 493         0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
 494         0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
 495         0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
 496         0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
 497         0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
 498         0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
 499         0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
 500         0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
 501         0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
 502         0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
 503         0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
 504         0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
 505         0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
 506         0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
 507         0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
 508         0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
 509         0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
 510         0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
 511         0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
 512         0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
 513         0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
 514         0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
 515         0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
 516         0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
 517         0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
 518         0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
 519         0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
 520         0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
 521         0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
 522         0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
 523 };
 524 EXPORT_SYMBOL(ppp_crc16_table);
 525 #define fcstab  ppp_crc16_table         /* for PPP_FCS macro */
 526
 527 /*
 528  * Procedure to encode the data for async serial transmission.
 529  * Does octet stuffing (escaping), puts the address/control bytes
 530  * on if A/C compression is disabled, and does protocol compression.
 531  * Assumes ap->tpkt != 0 on entry.
 532  * Returns 1 if we finished the current frame, 0 otherwise.
 533  */
 534
 535 #define PUT_BYTE(ap, buf, c, islcp)     do {            \
 536         if ((islcp && c < 0x20) || (ap->xaccm[c >> 5] & (1 << (c & 0x1f)))) {\
 537                 *buf++ = PPP_ESCAPE;                    \
 538                 *buf++ = c ^ 0x20;                      \
 539         } else                                          \
 540                 *buf++ = c;                             \
 541 } while (0)
 542
 543 static int
 544 ppp_async_encode(struct asyncppp *ap)
 545 {
 546         int fcs, i, count, c, proto;
 547         unsigned char *buf, *buflim;
 548         unsigned char *data;
 549         int islcp;
 550
 551         buf = ap->obuf;
 552         ap->olim = buf;
 553         ap->optr = buf;
 554         i = ap->tpkt_pos;
 555         data = ap->tpkt->data;
 556         count = ap->tpkt->len;
 557         fcs = ap->tfcs;
 558         proto = (data[0] << 8) + data[1];
 559
 560         /*
 561          * LCP packets with code values between 1 (configure-reqest)
 562          * and 7 (code-reject) must be sent as though no options
 563          * had been negotiated.
 564          */
 565         islcp = proto == PPP_LCP && 1 <= data[2] && data[2] <= 7;
 566
 567         if (i == 0) {
 568                 if (islcp)
 569                         async_lcp_peek(ap, data, count, 0);
 570
 571                 /*
 572                  * Start of a new packet - insert the leading FLAG
 573                  * character if necessary.
 574                  */
 575                 if (islcp || flag_time == 0
 576                     || jiffies - ap->last_xmit >= flag_time)
 577                         *buf++ = PPP_FLAG;
 578                 ap->last_xmit = jiffies;
 579                 fcs = PPP_INITFCS;
 580
 581                 /*
 582                  * Put in the address/control bytes if necessary
 583                  */
 584                 if ((ap->flags & SC_COMP_AC) == 0 || islcp) {
 585                         PUT_BYTE(ap, buf, 0xff, islcp);
 586                         fcs = PPP_FCS(fcs, 0xff);
 587                         PUT_BYTE(ap, buf, 0x03, islcp);
 588                         fcs = PPP_FCS(fcs, 0x03);
 589                 }
 590         }
 591
 592         /*
 593          * Once we put in the last byte, we need to put in the FCS
 594          * and closing flag, so make sure there is at least 7 bytes
 595          * of free space in the output buffer.
 596          */
 597         buflim = ap->obuf + OBUFSIZE - 6;
 598         while (i < count && buf < buflim) {
 599                 c = data[i++];
 600                 if (i == 1 && c == 0 && (ap->flags & SC_COMP_PROT))
 601                         continue;       /* compress protocol field */
 602                 fcs = PPP_FCS(fcs, c);
 603                 PUT_BYTE(ap, buf, c, islcp);
 604         }
 605
 606         if (i < count) {
 607                 /*
 608                  * Remember where we are up to in this packet.
 609                  */
 610                 ap->olim = buf;
 611                 ap->tpkt_pos = i;
 612                 ap->tfcs = fcs;
 613                 return 0;
 614         }
 615
 616         /*
 617          * We have finished the packet.  Add the FCS and flag.
 618          */
 619         fcs = ~fcs;
 620         c = fcs & 0xff;
 621         PUT_BYTE(ap, buf, c, islcp);
 622         c = (fcs >> 8) & 0xff;
 623         PUT_BYTE(ap, buf, c, islcp);
 624         *buf++ = PPP_FLAG;
 625         ap->olim = buf;
 626
 627         kfree_skb(ap->tpkt);
 628         ap->tpkt = 0;
 629         return 1;
 630 }
 631
 632 /*
 633  * Transmit-side routines.
 634  */
 635
 636 /*
 637  * Send a packet to the peer over an async tty line.
 638  * Returns 1 iff the packet was accepted.
 639  * If the packet was not accepted, we will call ppp_output_wakeup
 640  * at some later time.
 641  */
 642 static int
 643 ppp_async_send(struct ppp_channel *chan, struct sk_buff *skb)
 644 {
 645         struct asyncppp *ap = chan->private;
 646
 647         ppp_async_push(ap);
 648
 649         if (test_and_set_bit(XMIT_FULL, &ap->xmit_flags))
 650                 return 0;       /* already full */
 651         ap->tpkt = skb;
 652         ap->tpkt_pos = 0;
 653
 654         ppp_async_push(ap);
 655         return 1;
 656 }
 657
 658 /*
 659  * Push as much data as possible out to the tty.
 660  */
 661 static int
 662 ppp_async_push(struct asyncppp *ap)
 663 {
 664         int avail, sent, done = 0;
 665         struct tty_struct *tty = ap->tty;
 666         int tty_stuffed = 0;
 667
 668         set_bit(XMIT_WAKEUP, &ap->xmit_flags);
 669         /*
 670          * We can get called recursively here if the tty write
 671          * function calls our wakeup function.  This can happen
 672          * for example on a pty with both the master and slave
 673          * set to PPP line discipline.
 674          * We use the XMIT_BUSY bit to detect this and get out,
 675          * leaving the XMIT_WAKEUP bit set to tell the other
 676          * instance that it may now be able to write more now.
 677          */
 678         if (test_and_set_bit(XMIT_BUSY, &ap->xmit_flags))
 679                 return 0;
 680         spin_lock_bh(&ap->xmit_lock);
 681         for (;;) {
 682                 if (test_and_clear_bit(XMIT_WAKEUP, &ap->xmit_flags))
 683                         tty_stuffed = 0;
 684                 if (!tty_stuffed && ap->optr < ap->olim) {
 685                         avail = ap->olim - ap->optr;
 686                         set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
 687                         sent = tty->driver.write(tty, 0, ap->optr, avail);
 688                         if (sent < 0)
 689                                 goto flush;     /* error, e.g. loss of CD */
 690                         ap->optr += sent;
 691                         if (sent < avail)
 692                                 tty_stuffed = 1;
 693                         continue;
 694                 }
 695                 if (ap->optr >= ap->olim && ap->tpkt != 0) {
 696                         if (ppp_async_encode(ap)) {
 697                                 /* finished processing ap->tpkt */
 698                                 clear_bit(XMIT_FULL, &ap->xmit_flags);
 699                                 done = 1;
 700                         }
 701                         continue;
 702                 }
 703                 /*
 704                  * We haven't made any progress this time around.
 705                  * Clear XMIT_BUSY to let other callers in, but
 706                  * after doing so we have to check if anyone set
 707                  * XMIT_WAKEUP since we last checked it.  If they
 708                  * did, we should try again to set XMIT_BUSY and go
 709                  * around again in case XMIT_BUSY was still set when
 710                  * the other caller tried.
 711                  */
 712                 clear_bit(XMIT_BUSY, &ap->xmit_flags);
 713                 /* any more work to do? if not, exit the loop */
 714                 if (!(test_bit(XMIT_WAKEUP, &ap->xmit_flags)
 715                       || (!tty_stuffed && ap->tpkt != 0)))
 716                         break;
 717                 /* more work to do, see if we can do it now */
 718                 if (test_and_set_bit(XMIT_BUSY, &ap->xmit_flags))
 719                         break;
 720         }
 721         spin_unlock_bh(&ap->xmit_lock);
 722         return done;
 723
 724 flush:
 725         clear_bit(XMIT_BUSY, &ap->xmit_flags);
 726         if (ap->tpkt != 0) {
 727                 kfree_skb(ap->tpkt);
 728                 ap->tpkt = 0;
 729                 clear_bit(XMIT_FULL, &ap->xmit_flags);
 730                 done = 1;
 731         }
 732         ap->optr = ap->olim;
 733         spin_unlock_bh(&ap->xmit_lock);
 734         return done;
 735 }
 736
 737 /*
 738  * Flush output from our internal buffers.
 739  * Called for the TCFLSH ioctl. Can be entered in parallel
 740  * but this is covered by the xmit_lock.
 741  */
 742 static void
 743 ppp_async_flush_output(struct asyncppp *ap)
 744 {
 745         int done = 0;
 746
 747         spin_lock_bh(&ap->xmit_lock);
 748         ap->optr = ap->olim;
 749         if (ap->tpkt != NULL) {
 750                 kfree_skb(ap->tpkt);
 751                 ap->tpkt = 0;
 752                 clear_bit(XMIT_FULL, &ap->xmit_flags);
 753                 done = 1;
 754         }
 755         spin_unlock_bh(&ap->xmit_lock);
 756         if (done)
 757                 ppp_output_wakeup(&ap->chan);
 758 }
 759
 760 /*
 761  * Receive-side routines.
 762  */
 763
 764 /* see how many ordinary chars there are at the start of buf */
 765 static inline int
 766 scan_ordinary(struct asyncppp *ap, const unsigned char *buf, int count)
 767 {
 768         int i, c;
 769
 770         for (i = 0; i < count; ++i) {
 771                 c = buf[i];
 772                 if (c == PPP_ESCAPE || c == PPP_FLAG
 773                     || (c < 0x20 && (ap->raccm & (1 << c)) != 0))
 774                         break;
 775         }
 776         return i;
 777 }
 778
 779 /* called when a flag is seen - do end-of-packet processing */
 780 static inline void
 781 process_input_packet(struct asyncppp *ap)
 782 {
 783         struct sk_buff *skb;
 784         unsigned char *p;
 785         unsigned int len, fcs, proto;
 786         int code = 0;
 787
 788         skb = ap->rpkt;
 789         ap->rpkt = 0;
 790         if ((ap->state & (SC_TOSS | SC_ESCAPE)) || skb == 0) {
 791                 ap->state &= ~(SC_TOSS | SC_ESCAPE);
 792                 if (skb != 0)
 793                         kfree_skb(skb);
 794                 return;
 795         }
 796
 797         /* check the FCS */
 798         p = skb->data;
 799         len = skb->len;
 800         if (len < 3)
 801                 goto err;       /* too short */
 802         fcs = PPP_INITFCS;
 803         for (; len > 0; --len)
 804                 fcs = PPP_FCS(fcs, *p++);
 805         if (fcs != PPP_GOODFCS)
 806                 goto err;       /* bad FCS */
 807         skb_trim(skb, skb->len - 2);
 808
 809         /* check for address/control and protocol compression */
 810         p = skb->data;
 811         if (p[0] == PPP_ALLSTATIONS && p[1] == PPP_UI) {
 812                 /* chop off address/control */
 813                 if (skb->len < 3)
 814                         goto err;
 815                 p = skb_pull(skb, 2);
 816         }
 817         proto = p[0];
 818         if (proto & 1) {
 819                 /* protocol is compressed */
 820                 skb_push(skb, 1)[0] = 0;
 821         } else {
 822                 if (skb->len < 2)
 823                         goto err;
 824                 proto = (proto << 8) + p[1];
 825                 if (proto == PPP_LCP)
 826                         async_lcp_peek(ap, p, skb->len, 1);
 827         }
 828
 829         /* all OK, give it to the generic layer */
 830         ppp_input(&ap->chan, skb);
 831         return;
 832
 833  err:
 834         kfree_skb(skb);
 835         ppp_input_error(&ap->chan, code);
 836 }
 837
 838 static inline void
 839 input_error(struct asyncppp *ap, int code)
 840 {
 841         ap->state |= SC_TOSS;
 842         ppp_input_error(&ap->chan, code);
 843 }
 844
 845 /* Called when the tty driver has data for us. Runs parallel with the
 846    other ldisc functions but will not be re-entered */
 847
 848 static void
 849 ppp_async_input(struct asyncppp *ap, const unsigned char *buf,
 850                 char *flags, int count)
 851 {
 852         struct sk_buff *skb;
 853         int c, i, j, n, s, f;
 854         unsigned char *sp;
 855
 856         /* update bits used for 8-bit cleanness detection */
 857         if (~ap->rbits & SC_RCV_BITS) {
 858                 s = 0;
 859                 for (i = 0; i < count; ++i) {
 860                         c = buf[i];
 861                         if (flags != 0 && flags[i] != 0)
 862                                 continue;
 863                         s |= (c & 0x80)? SC_RCV_B7_1: SC_RCV_B7_0;
 864                         c = ((c >> 4) ^ c) & 0xf;
 865                         s |= (0x6996 & (1 << c))? SC_RCV_ODDP: SC_RCV_EVNP;
 866                 }
 867                 ap->rbits |= s;
 868         }
 869
 870         while (count > 0) {
 871                 /* scan through and see how many chars we can do in bulk */
 872                 if ((ap->state & SC_ESCAPE) && buf[0] == PPP_ESCAPE)
 873                         n = 1;
 874                 else
 875                         n = scan_ordinary(ap, buf, count);
 876
 877                 f = 0;
 878                 if (flags != 0 && (ap->state & SC_TOSS) == 0) {
 879                         /* check the flags to see if any char had an error */
 880                         for (j = 0; j < n; ++j)
 881                                 if ((f = flags[j]) != 0)
 882                                         break;
 883                 }
 884                 if (f != 0) {
 885                         /* start tossing */
 886                         input_error(ap, f);
 887
 888                 } else if (n > 0 && (ap->state & SC_TOSS) == 0) {
 889                         /* stuff the chars in the skb */
 890                         skb = ap->rpkt;
 891                         if (skb == 0) {
 892                                 skb = dev_alloc_skb(ap->mru + PPP_HDRLEN + 2);
 893                                 if (skb == 0)
 894                                         goto nomem;
 895                                 /* Try to get the payload 4-byte aligned */
 896                                 if (buf[0] != PPP_ALLSTATIONS)
 897                                         skb_reserve(skb, 2 + (buf[0] & 1));
 898                                 ap->rpkt = skb;
 899                         }
 900                         if (n > skb_tailroom(skb)) {
 901                                 /* packet overflowed MRU */
 902                                 input_error(ap, 1);
 903                         } else {
 904                                 sp = skb_put(skb, n);
 905                                 memcpy(sp, buf, n);
 906                                 if (ap->state & SC_ESCAPE) {
 907                                         sp[0] ^= 0x20;
 908                                         ap->state &= ~SC_ESCAPE;
 909                                 }
 910                         }
 911                 }
 912
 913                 if (n >= count)
 914                         break;
 915
 916                 c = buf[n];
 917                 if (c == PPP_FLAG) {
 918                         process_input_packet(ap);
 919                 } else if (c == PPP_ESCAPE) {
 920                         ap->state |= SC_ESCAPE;
 921                 }
 922                 /* otherwise it's a char in the recv ACCM */
 923                 ++n;
 924
 925                 buf += n;
 926                 if (flags != 0)
 927                         flags += n;
 928                 count -= n;
 929         }
 930         return;
 931
 932  nomem:
 933         printk(KERN_ERR "PPPasync: no memory (input pkt)\n");
 934         input_error(ap, 0);
 935 }
 936
 937 /*
 938  * We look at LCP frames going past so that we can notice
 939  * and react to the LCP configure-ack from the peer.
 940  * In the situation where the peer has been sent a configure-ack
 941  * already, LCP is up once it has sent its configure-ack
 942  * so the immediately following packet can be sent with the
 943  * configured LCP options.  This allows us to process the following
 944  * packet correctly without pppd needing to respond quickly.
 945  *
 946  * We only respond to the received configure-ack if we have just
 947  * sent a configure-request, and the configure-ack contains the
 948  * same data (this is checked using a 16-bit crc of the data).
 949  */
 950 #define CONFREQ         1       /* LCP code field values */
 951 #define CONFACK         2
 952 #define LCP_MRU         1       /* LCP option numbers */
 953 #define LCP_ASYNCMAP    2
 954
 955 static void async_lcp_peek(struct asyncppp *ap, unsigned char *data,
 956                            int len, int inbound)
 957 {
 958         int dlen, fcs, i, code;
 959         u32 val;
 960
 961         data += 2;              /* skip protocol bytes */
 962         len -= 2;
 963         if (len < 4)            /* 4 = code, ID, length */
 964                 return;
 965         code = data[0];
 966         if (code != CONFACK && code != CONFREQ)
 967                 return;
 968         dlen = (data[2] << 8) + data[3];
 969         if (len < dlen)
 970                 return;         /* packet got truncated or length is bogus */
 971
 972         if (code == (inbound? CONFACK: CONFREQ)) {
 973                 /*
 974                  * sent confreq or received confack:
 975                  * calculate the crc of the data from the ID field on.
 976                  */
 977                 fcs = PPP_INITFCS;
 978                 for (i = 1; i < dlen; ++i)
 979                         fcs = PPP_FCS(fcs, data[i]);
 980
 981                 if (!inbound) {
 982                         /* outbound confreq - remember the crc for later */
 983                         ap->lcp_fcs = fcs;
 984                         return;
 985                 }
 986
 987                 /* received confack, check the crc */
 988                 fcs ^= ap->lcp_fcs;
 989                 ap->lcp_fcs = -1;
 990                 if (fcs != 0)
 991                         return;
 992         } else if (inbound)
 993                 return; /* not interested in received confreq */
 994
 995         /* process the options in the confack */
 996         data += 4;
 997         dlen -= 4;
 998         /* data[0] is code, data[1] is length */
 999         while (dlen >= 2 && dlen >= data[1] && data[1] >= 2) {
1000                 switch (data[0]) {
1001                 case LCP_MRU:
1002                         val = (data[2] << 8) + data[3];
1003                         if (inbound)
1004                                 ap->mru = val;
1005                         else
1006                                 ap->chan.mtu = val;
1007                         break;
1008                 case LCP_ASYNCMAP:
1009                         val = (data[2] << 24) + (data[3] << 16)
1010                                 + (data[4] << 8) + data[5];
1011                         if (inbound)
1012                                 ap->raccm = val;
1013                         else
1014                                 ap->xaccm[0] = val;
1015                         break;
1016                 }
1017                 dlen -= data[1];
1018                 data += data[1];
1019         }
1020 }
1021
1022 static void __exit ppp_async_cleanup(void)
1023 {
1024         if (tty_register_ldisc(N_PPP, NULL) != 0)
1025                 printk(KERN_ERR "failed to unregister PPP line discipline\n");
1026 }
1027
1028 module_init(ppp_async_init);
1029 module_exit(ppp_async_cleanup);