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