linux/ppp.c

   1 /*  PPP for Linux
   2  *
   3  *  Michael Callahan <callahan@maths.ox.ac.uk>
   4  *  Al Longyear <longyear@netcom.com>
   5  *  Extensively rewritten by Paul Mackerras <paulus@cs.anu.edu.au>
   6  *
   7  *  ==FILEVERSION 981004==
   8  *
   9  *  NOTE TO MAINTAINERS:
  10  *     If you modify this file at all, please set the number above to the
  11  *     date of the modification as YYMMDD (year month day).
  12  *     ppp.c is shipped with a PPP distribution as well as with the kernel;
  13  *     if everyone increases the FILEVERSION number above, then scripts
  14  *     can do the right thing when deciding whether to install a new ppp.c
  15  *     file.  Don't change the format of that line otherwise, so the
  16  *     installation script can recognize it.
  17  */
  18
  19 /*
  20    Sources:
  21
  22    slip.c
  23
  24    RFC1331: The Point-to-Point Protocol (PPP) for the Transmission of
  25    Multi-protocol Datagrams over Point-to-Point Links
  26
  27    RFC1332: IPCP
  28
  29    ppp-2.0
  30
  31    Flags for this module (any combination is acceptable for testing.):
  32
  33    OPTIMIZE_FLAG_TIME - Number of jiffies to force sending of leading flag
  34                         character. This is normally set to ((HZ * 3) / 2).
  35                         This is 1.5 seconds. If zero then the leading
  36                         flag is always sent.
  37
  38    CHECK_CHARACTERS   - Enable the checking on all received characters for
  39                         8 data bits, no parity. This adds a small amount of
  40                         processing for each received character.
  41 */
  42
  43 #define OPTIMIZE_FLAG_TIME      ((HZ * 3)/2)
  44 #define CHECK_CHARACTERS        1
  45
  46 #define PPP_MAX_RCV_QLEN        32      /* max # frames we queue up for pppd */
  47
  48 /* $Id: ppp.c,v 1.20 1999/01/19 23:57:44 paulus Exp $ */
  49
  50 #include <linux/version.h>
  51 #include <linux/config.h>
  52 #include <linux/module.h>
  53 #include <linux/kernel.h>
  54 #include <linux/sched.h>
  55 #include <linux/types.h>
  56 #include <linux/fcntl.h>
  57 #include <linux/interrupt.h>
  58 #include <linux/ptrace.h>
  59
  60 /* a macro to generate linux version number codes */
  61 #define VERSION(major,minor,patch) (((((major)<<8)+(minor))<<8)+(patch))
  62
  63 #if LINUX_VERSION_CODE < VERSION(2,1,14)
  64 #include <linux/ioport.h>
  65 #endif
  66
  67 #if LINUX_VERSION_CODE >= VERSION(2,1,23)
  68 #include <linux/poll.h>
  69 #endif
  70
  71 #include <linux/in.h>
  72 #include <linux/malloc.h>
  73 #include <linux/tty.h>
  74 #include <linux/errno.h>
  75 #include <linux/sched.h>        /* to get the struct task_struct */
  76 #include <linux/string.h>       /* used in new tty drivers */
  77 #include <linux/signal.h>       /* used in new tty drivers */
  78 #include <asm/system.h>
  79 #include <asm/bitops.h>
  80 #include <linux/if.h>
  81 #include <linux/if_ether.h>
  82 #include <linux/netdevice.h>
  83 #include <linux/skbuff.h>
  84 #include <linux/inet.h>
  85 #include <linux/ioctl.h>
  86 #include <linux/ip.h>
  87 #include <linux/tcp.h>
  88 #include <linux/if_arp.h>
  89 #include <net/slhc_vj.h>
  90
  91 #define fcstab  ppp_crc16_table         /* Name of the table in the kernel */
  92 #include <linux/ppp_defs.h>
  93
  94 #include <linux/socket.h>
  95 #include <linux/if_ppp.h>
  96 #include <linux/if_pppvar.h>
  97 #include <linux/ppp-comp.h>
  98
  99 #ifdef CONFIG_KMOD
 100 #include <linux/kmod.h>
 101 #endif
 102 #ifdef CONFIG_KERNELD
 103 #include <linux/kerneld.h>
 104 #endif
 105
 106 #define PPP_VERSION     "2.3.5"
 107
 108 #if LINUX_VERSION_CODE >= VERSION(2,1,4)
 109
 110 #if LINUX_VERSION_CODE >= VERSION(2,1,5)
 111 #include <asm/uaccess.h>
 112 #else
 113 #include <asm/segment.h>
 114 #endif
 115
 116 #define GET_USER        get_user
 117 #define PUT_USER        put_user
 118 #define COPY_FROM_USER  copy_from_user
 119 #define COPY_TO_USER    copy_to_user
 120
 121 #else  /* 2.0.x and 2.1.x before 2.1.4 */
 122
 123 #define GET_USER(val, src)      \
 124         (verify_area(VERIFY_READ, src, sizeof(*src))? -EFAULT: \
 125          ((val) = get_user(src), 0))
 126 #define PUT_USER(val, dst)      \
 127         (verify_area(VERIFY_WRITE, dst, sizeof(*dst))? -EFAULT: \
 128          (put_user(val, dst), 0))
 129 #define COPY_FROM_USER(dst, src, size)  \
 130         (verify_area(VERIFY_READ, src, size)? -EFAULT: \
 131          (memcpy_fromfs(dst, src, size), 0))
 132 #define COPY_TO_USER(dst, src, size)    \
 133         (verify_area(VERIFY_WRITE, dst, size)? -EFAULT: \
 134          (memcpy_tofs(dst, src, size), 0))
 135
 136 #endif /* < 2.1.4 */
 137
 138 #if LINUX_VERSION_CODE < VERSION(2,1,37)
 139 #define test_and_set_bit(nr, addr)      set_bit(nr, addr)
 140 #endif
 141
 142 #if LINUX_VERSION_CODE < VERSION(2,1,25)
 143 #define net_device_stats        enet_statistics
 144 #endif
 145
 146 #if LINUX_VERSION_CODE < VERSION(2,1,57)
 147 #define signal_pending(tsk)     ((tsk)->pending & ~(tsk)->blocked)
 148 #endif
 149
 150 #if LINUX_VERSION_CODE < VERSION(2,1,60)
 151 typedef int             rw_ret_t;
 152 typedef unsigned int    rw_count_t;
 153 #else
 154 typedef ssize_t         rw_ret_t;
 155 typedef size_t          rw_count_t;
 156 #endif
 157
 158 /*
 159  * Local functions
 160  */
 161
 162 #ifdef CONFIG_MODULES
 163 static int ppp_register_compressor (struct compressor *cp);
 164 static void ppp_unregister_compressor (struct compressor *cp);
 165 #endif
 166
 167 static void ppp_async_init(struct ppp *ppp);
 168 static void ppp_async_release(struct ppp *ppp);
 169 static int ppp_tty_push(struct ppp *ppp);
 170 static int ppp_async_encode(struct ppp *ppp);
 171 static int ppp_async_send(struct ppp *, struct sk_buff *);
 172
 173 static int ppp_ioctl(struct ppp *, unsigned int, unsigned long);
 174 static int ppp_set_compression (struct ppp *ppp, struct ppp_option_data *odp);
 175 static void ppp_proto_ccp(struct ppp *ppp, __u8 *dp, int len, int rcvd);
 176 static void ppp_ccp_closed(struct ppp *ppp);
 177 static int ppp_receive_frame(struct ppp *, struct sk_buff *);
 178 static void ppp_receive_error(struct ppp *ppp);
 179 static void ppp_output_wakeup(struct ppp *ppp);
 180 static void ppp_send_ctrl(struct ppp *ppp, struct sk_buff *skb);
 181 static void ppp_send_frame(struct ppp *ppp, struct sk_buff *skb);
 182 static void ppp_send_frames(struct ppp *ppp);
 183 static struct sk_buff *ppp_vj_compress(struct ppp *ppp, struct sk_buff *skb);
 184
 185 static struct ppp *ppp_find (int pid_value);
 186 static struct ppp *ppp_alloc (void);
 187 static void ppp_generic_init(struct ppp *ppp);
 188 static void ppp_release(struct ppp *ppp);
 189 static void ppp_print_buffer (const char *, const __u8 *, int);
 190 static struct compressor *find_compressor (int type);
 191
 192 #ifndef OPTIMIZE_FLAG_TIME
 193 #define OPTIMIZE_FLAG_TIME      0
 194 #endif
 195
 196 /*
 197  * Parameters which may be changed via insmod.
 198  */
 199
 200 static int  flag_time = OPTIMIZE_FLAG_TIME;
 201 #if LINUX_VERSION_CODE >= VERSION(2,1,19)
 202 MODULE_PARM(flag_time, "i");
 203 #endif
 204
 205 #define CHECK_PPP_MAGIC(ppp)    do { \
 206         if (ppp->magic != PPP_MAGIC) { \
 207                 printk(ppp_magic_warn, ppp, __FILE__, __LINE__); \
 208         } \
 209 } while (0)
 210 #define CHECK_PPP(a)    do { \
 211         CHECK_PPP_MAGIC(ppp); \
 212         if (!ppp->inuse) { \
 213                 printk(ppp_warning, __LINE__); \
 214                 return a; \
 215         } \
 216 } while (0)
 217 #define CHECK_PPP_VOID() do { \
 218         CHECK_PPP_MAGIC(ppp); \
 219         if (!ppp->inuse) { \
 220                 printk(ppp_warning, __LINE__); \
 221                 return; \
 222         } \
 223 } while (0)
 224
 225 #define tty2ppp(tty)    ((struct ppp *) ((tty)->disc_data))
 226 #define dev2ppp(dev)    ((struct ppp *) ((dev)->priv))
 227 #define ppp2tty(ppp)    ((ppp)->tty)
 228 #define ppp2dev(ppp)    (&(ppp)->dev)
 229
 230 static struct ppp *ppp_list = NULL;
 231 static struct ppp *ppp_last = NULL;
 232
 233 /* Define these strings only once for all macro invocations */
 234 static char ppp_warning[] = KERN_WARNING "PPP: ALERT! not INUSE! %d\n";
 235 static char ppp_magic_warn[] = KERN_WARNING "bad magic for ppp %p at %s:%d\n";
 236
 237 static char szVersion[]         = PPP_VERSION;
 238
 239 #if LINUX_VERSION_CODE < VERSION(2,1,18)
 240 static struct symbol_table ppp_syms = {
 241 #include <linux/symtab_begin.h>
 242         X(ppp_register_compressor),
 243         X(ppp_unregister_compressor),
 244         X(ppp_crc16_table),
 245 #include <linux/symtab_end.h>
 246 };
 247 #else
 248 EXPORT_SYMBOL(ppp_register_compressor);
 249 EXPORT_SYMBOL(ppp_unregister_compressor);
 250 #endif
 251
 252 /*************************************************************
 253  * LINE DISCIPLINE SUPPORT
 254  *    The following code implements the PPP line discipline
 255  *    and supports using PPP on an async serial line.
 256  *************************************************************/
 257
 258 #define in_xmap(ppp,c)  (ppp->xmit_async_map[(c) >> 5] & (1 << ((c) & 0x1f)))
 259 #define in_rmap(ppp,c)  ((((unsigned int) (__u8) (c)) < 0x20) && \
 260                         ppp->recv_async_map & (1 << (c)))
 261
 262 /*
 263  * TTY callbacks
 264  */
 265
 266 static rw_ret_t ppp_tty_read(struct tty_struct *, struct file *, __u8 *,
 267                              rw_count_t);
 268 static rw_ret_t ppp_tty_write(struct tty_struct *, struct file *, const __u8 *,
 269                               rw_count_t);
 270 static int ppp_tty_ioctl(struct tty_struct *, struct file *, unsigned int,
 271                          unsigned long);
 272 #if LINUX_VERSION_CODE < VERSION(2,1,23)
 273 static int ppp_tty_select(struct tty_struct *tty, struct inode *inode,
 274                         struct file *filp, int sel_type, select_table * wait);
 275 #else
 276 static unsigned int ppp_tty_poll(struct tty_struct *tty, struct file *filp,
 277                                  poll_table * wait);
 278 #endif
 279 static int ppp_tty_open (struct tty_struct *);
 280 static void ppp_tty_close (struct tty_struct *);
 281 static int ppp_tty_room (struct tty_struct *tty);
 282 static void ppp_tty_receive (struct tty_struct *tty, const __u8 * cp,
 283                              char *fp, int count);
 284 static void ppp_tty_wakeup (struct tty_struct *tty);
 285
 286 __u16 ppp_crc16_table[256] =
 287 {
 288         0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
 289         0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
 290         0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
 291         0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
 292         0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
 293         0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
 294         0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
 295         0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
 296         0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
 297         0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
 298         0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
 299         0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
 300         0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
 301         0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
 302         0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
 303         0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
 304         0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
 305         0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
 306         0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
 307         0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
 308         0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
 309         0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
 310         0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
 311         0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
 312         0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
 313         0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
 314         0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
 315         0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
 316         0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
 317         0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
 318         0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
 319         0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
 320 };
 321 EXPORT_SYMBOL(ppp_crc16_table);
 322
 323 #ifdef CHECK_CHARACTERS
 324 static __u32 paritytab[8] =
 325 {
 326         0x96696996, 0x69969669, 0x69969669, 0x96696996,
 327         0x69969669, 0x96696996, 0x96696996, 0x69969669
 328 };
 329 #endif
 330
 331 /*
 332  * This procedure is called at initialization time to register
 333  * the PPP line discipline.
 334  */
 335 static int
 336 ppp_first_time(void)
 337 {
 338         static struct tty_ldisc ppp_ldisc;
 339         int    status;
 340
 341         printk(KERN_INFO
 342                "PPP: version %s (demand dialling)"
 343                "\n", szVersion);
 344
 345 #ifndef MODULE /* slhc module logic has its own copyright announcement */
 346         printk(KERN_INFO
 347                "TCP compression code copyright 1989 Regents of the "
 348                "University of California\n");
 349 #endif
 350
 351         /*
 352          * Register the tty discipline
 353          */
 354         (void) memset (&ppp_ldisc, 0, sizeof (ppp_ldisc));
 355         ppp_ldisc.magic         = TTY_LDISC_MAGIC;
 356         ppp_ldisc.name          = "ppp";
 357         ppp_ldisc.open          = ppp_tty_open;
 358         ppp_ldisc.close         = ppp_tty_close;
 359         ppp_ldisc.read          = ppp_tty_read;
 360         ppp_ldisc.write         = ppp_tty_write;
 361         ppp_ldisc.ioctl         = ppp_tty_ioctl;
 362 #if LINUX_VERSION_CODE < VERSION(2,1,23)
 363         ppp_ldisc.select        = ppp_tty_select;
 364 #else
 365         ppp_ldisc.poll          = ppp_tty_poll;
 366 #endif
 367         ppp_ldisc.receive_room  = ppp_tty_room;
 368         ppp_ldisc.receive_buf   = ppp_tty_receive;
 369         ppp_ldisc.write_wakeup  = ppp_tty_wakeup;
 370
 371         status = tty_register_ldisc (N_PPP, &ppp_ldisc);
 372         if (status == 0)
 373                 printk(KERN_INFO "PPP line discipline registered.\n");
 374         else
 375                 printk(KERN_ERR "error registering line discipline: %d\n",
 376                        status);
 377         return status;
 378 }
 379
 380
 381 #ifndef MODULE
 382 /*
 383  * Called at boot time if the PPP driver is compiled into the kernel.
 384  */
 385 int
 386 ppp_init(struct device *dev)
 387 {
 388         static int first_time = 1;
 389         int    answer = 0;
 390
 391         if (first_time) {
 392                 first_time = 0;
 393                 answer     = ppp_first_time();
 394 #if LINUX_VERSION_CODE < VERSION(2,1,18)
 395                 if (answer == 0)
 396                         (void) register_symtab(&ppp_syms);
 397 #endif
 398         }
 399         if (answer == 0)
 400                 answer = -ENODEV;
 401         return answer;
 402 }
 403 #endif
 404
 405 /*
 406  * Initialize the async-specific parts of the ppp structure.
 407  */
 408 static void
 409 ppp_async_init(struct ppp *ppp)
 410 {
 411         ppp->escape = 0;
 412         ppp->toss   = 0xE0;
 413         ppp->tty_pushing = 0;
 414
 415         memset (ppp->xmit_async_map, 0, sizeof (ppp->xmit_async_map));
 416         ppp->xmit_async_map[0] = 0xffffffff;
 417         ppp->xmit_async_map[3] = 0x60000000;
 418         ppp->recv_async_map    = 0xffffffff;
 419
 420         ppp->tpkt = NULL;
 421         ppp->tfcs = PPP_INITFCS;
 422         ppp->optr = ppp->obuf;
 423         ppp->olim = ppp->obuf;
 424
 425         ppp->rpkt = NULL;
 426         ppp->rfcs = PPP_INITFCS;
 427
 428         ppp->tty  = NULL;
 429         ppp->backup_tty = NULL;
 430
 431         ppp->bytes_sent = 0;
 432         ppp->bytes_rcvd = 0;
 433 }
 434
 435 /*
 436  * Clean up the async-specific parts of the ppp structure.
 437  */
 438 static void
 439 ppp_async_release(struct ppp *ppp)
 440 {
 441         struct sk_buff *skb;
 442
 443         if ((skb = ppp->rpkt) != NULL)
 444                 kfree_skb(skb);
 445         ppp->rpkt = NULL;
 446         if ((skb = ppp->tpkt) != NULL)
 447                 kfree_skb(skb);
 448         ppp->tpkt = NULL;
 449 }
 450
 451 /*
 452  * TTY callback.
 453  *
 454  * Called when the tty discipline is switched to PPP.
 455  */
 456
 457 static int
 458 ppp_tty_open (struct tty_struct *tty)
 459 {
 460         struct ppp *ppp;
 461
 462         /*
 463          * Allocate a ppp structure to use.
 464          */
 465         tty->disc_data = NULL;
 466         ppp = ppp_find(current->pid);
 467         if (ppp != NULL) {
 468                 /*
 469                  * If we are taking over a ppp unit which is currently
 470                  * connected to a loopback pty, there's not much to do.
 471                  */
 472                 CHECK_PPP(-EINVAL);
 473
 474         } else {
 475                 ppp = ppp_alloc();
 476                 if (ppp == NULL) {
 477                         printk(KERN_ERR "ppp_alloc failed\n");
 478                         return -ENFILE;
 479                 }
 480
 481                 /*
 482                  * Initialize the control block
 483                  */
 484                 ppp_generic_init(ppp);
 485                 ppp_async_init(ppp);
 486
 487                 MOD_INC_USE_COUNT;
 488         }
 489
 490         tty->disc_data = ppp;
 491         ppp->tty       = tty;
 492
 493         /*
 494          * Flush any pending characters in the driver
 495          */
 496         if (tty->driver.flush_buffer)
 497                 tty->driver.flush_buffer (tty);
 498
 499         return ppp->line;
 500 }
 501
 502 /*
 503  * TTY callback.
 504  *
 505  * Called when the line discipline is changed to something
 506  * else, the tty is closed, or the tty detects a hangup.
 507  */
 508
 509 static void
 510 ppp_tty_close (struct tty_struct *tty)
 511 {
 512         struct ppp *ppp = tty2ppp(tty);
 513
 514         if (ppp == NULL)
 515                 return;
 516         tty->disc_data = NULL;
 517         if (ppp->magic != PPP_MAGIC) {
 518                 printk(KERN_WARNING "ppp_tty_close: bogus\n");
 519                 return;
 520         }
 521         if (!ppp->inuse) {
 522                 printk(KERN_WARNING "ppp_tty_close: not inuse\n");
 523                 ppp->tty = ppp->backup_tty = 0;
 524                 return;
 525         }
 526         if (tty == ppp->backup_tty)
 527                 ppp->backup_tty = 0;
 528         if (tty != ppp->tty)
 529                 return;
 530         if (ppp->backup_tty) {
 531                 ppp->tty = ppp->backup_tty;
 532                 if (ppp_tty_push(ppp))
 533                         ppp_output_wakeup(ppp);
 534         } else {
 535                 ppp->tty = 0;
 536                 ppp->sc_xfer = 0;
 537                 if (ppp->flags & SC_DEBUG)
 538                         printk(KERN_INFO "ppp: channel %s closing.\n",
 539                                ppp2dev(ppp)->name);
 540
 541                 ppp_async_release(ppp);
 542                 ppp_release(ppp);
 543                 MOD_DEC_USE_COUNT;
 544         }
 545 }
 546
 547 /*
 548  * Read a PPP frame from the rcv_q list,
 549  * waiting if necessary
 550  */
 551 static rw_ret_t
 552 ppp_tty_read(struct tty_struct *tty, struct file *file, __u8 * buf,
 553              rw_count_t nr)
 554 {
 555         struct ppp *ppp = tty2ppp (tty);
 556         struct sk_buff *skb;
 557         rw_ret_t len, err;
 558
 559         /*
 560          * Validate the pointers
 561          */
 562         if (!ppp)
 563                 return -EIO;
 564         CHECK_PPP(-ENXIO);
 565
 566         /*
 567          * Before we attempt to write the frame to the user, ensure that the
 568          * user has access to the pages for the total buffer length.
 569          */
 570         err = verify_area(VERIFY_WRITE, buf, nr);
 571         if (err != 0)
 572                 return (err);
 573
 574         /*
 575          * Wait for a frame to arrive if necessary.
 576          * We increment the module use count so that the module
 577          * can't go away while we're sleeping.
 578          */
 579         MOD_INC_USE_COUNT;
 580         skb = NULL;
 581         for (;;) {
 582                 ppp = tty2ppp(tty);
 583                 err = 0;
 584                 if (!ppp || ppp->magic != PPP_MAGIC || !ppp->inuse
 585                     || tty != ppp->tty)
 586                         break;
 587
 588                 skb = skb_dequeue(&ppp->rcv_q);
 589                 if (skb != 0)
 590                         break;
 591
 592                 /*
 593                  * If no frame is available, return -EAGAIN or wait.
 594                  */
 595                 err = -EAGAIN;
 596                 if (file->f_flags & O_NONBLOCK)
 597                         break;
 598
 599                 current->timeout = 0;
 600                 interruptible_sleep_on(&ppp->read_wait);
 601                 err = -EINTR;
 602                 if (signal_pending(current))
 603                         break;
 604         }
 605         MOD_DEC_USE_COUNT;
 606         if (skb == 0)
 607                 return err;
 608
 609         /*
 610          * Ensure that the frame will fit within the caller's buffer.
 611          * If not, just discard the frame.
 612          */
 613         len = skb->len;
 614         if (len > nr) {
 615                 if (ppp->flags & SC_DEBUG)
 616                         printk(KERN_DEBUG
 617                                "ppp: read of %lu bytes too small for %ld "
 618                                "frame\n", (unsigned long) nr, (long) len);
 619                 ppp->stats.ppp_ierrors++;
 620                 err = -EOVERFLOW;
 621                 goto out;
 622         }
 623
 624         /*
 625          * Copy the received data from the buffer to the caller's area.
 626          */
 627         err = len;
 628         if (COPY_TO_USER(buf, skb->data, len))
 629                 err = -EFAULT;
 630
 631 out:
 632         kfree_skb(skb);
 633         return err;
 634 }
 635
 636 /*
 637  * Writing to a tty in ppp line discipline sends a PPP frame.
 638  * Used by pppd to send control packets (LCP, etc.).
 639  */
 640 static rw_ret_t
 641 ppp_tty_write(struct tty_struct *tty, struct file *file, const __u8 * data,
 642               rw_count_t count)
 643 {
 644         struct ppp *ppp = tty2ppp (tty);
 645         __u8 *new_data;
 646         struct sk_buff *skb;
 647
 648         /*
 649          * Verify the pointers.
 650          */
 651         if (!ppp)
 652                 return -EIO;
 653
 654         if (ppp->magic != PPP_MAGIC)
 655                 return -EIO;
 656
 657         CHECK_PPP(-ENXIO);
 658
 659         /*
 660          * Ensure that the caller does not wish to send too much.
 661          */
 662         if (count > PPP_MTU + PPP_HDRLEN) {
 663                 if (ppp->flags & SC_DEBUG)
 664                         printk(KERN_WARNING
 665                                "ppp_tty_write: truncating user packet "
 666                                "from %lu to mtu %d\n", (unsigned long) count,
 667                                PPP_MTU + PPP_HDRLEN);
 668                 count = PPP_MTU + PPP_HDRLEN;
 669         }
 670
 671         /*
 672          * Allocate a buffer for the data and fetch it from the user space.
 673          */
 674         skb = alloc_skb(count, GFP_KERNEL);
 675         if (skb == NULL) {
 676                 printk(KERN_ERR "ppp_tty_write: no memory\n");
 677                 return 0;
 678         }
 679         new_data = skb_put(skb, count);
 680
 681         /*
 682          * Retrieve the user's buffer
 683          */
 684         if (COPY_FROM_USER(new_data, data, count)) {
 685                 kfree_skb(skb);
 686                 return -EFAULT;
 687         }
 688
 689         /*
 690          * Send the frame
 691          */
 692         ppp_send_ctrl(ppp, skb);
 693
 694         return (rw_ret_t) count;
 695 }
 696
 697 /*
 698  * Process the IOCTL call for the tty device.
 699  * Only the ioctls that relate to using ppp on async serial lines
 700  * are processed here; the rest are handled by ppp_ioctl.
 701  */
 702 static int
 703 ppp_tty_ioctl (struct tty_struct *tty, struct file * file,
 704                unsigned int param2, unsigned long param3)
 705 {
 706         struct ppp *ppp = tty2ppp (tty);
 707         register int temp_i = 0;
 708         int error = -EFAULT;
 709
 710         /*
 711          * Verify the status of the PPP device.
 712          */
 713         if (!ppp || ppp->magic != PPP_MAGIC || !ppp->inuse)
 714                 return -ENXIO;
 715
 716         /*
 717          * The user must have an euid of root to do these requests.
 718          */
 719         if (!capable(CAP_NET_ADMIN))
 720                 return -EPERM;
 721
 722         switch (param2) {
 723         case PPPIOCGASYNCMAP:
 724                 /*
 725                  * Retrieve the transmit async map
 726                  */
 727                 if (PUT_USER(ppp->xmit_async_map[0], (int *) param3))
 728                         break;
 729                 error = 0;
 730                 break;
 731
 732         case PPPIOCSASYNCMAP:
 733                 /*
 734                  * Set the transmit async map
 735                  */
 736                 if (GET_USER(temp_i, (int *) param3))
 737                         break;
 738                 ppp->xmit_async_map[0] = temp_i;
 739                 if (ppp->flags & SC_DEBUG)
 740                         printk(KERN_INFO
 741                                "ppp_tty_ioctl: set xmit asyncmap %x\n",
 742                                ppp->xmit_async_map[0]);
 743                 error = 0;
 744                 break;
 745
 746         case PPPIOCSRASYNCMAP:
 747                 /*
 748                  * Set the receive async map
 749                  */
 750                 if (GET_USER(temp_i, (int *) param3))
 751                         break;
 752                 ppp->recv_async_map = temp_i;
 753                 if (ppp->flags & SC_DEBUG)
 754                         printk(KERN_INFO
 755                                "ppp_tty_ioctl: set rcv asyncmap %x\n",
 756                                ppp->recv_async_map);
 757                 error = 0;
 758                 break;
 759
 760         case PPPIOCGXASYNCMAP:
 761                 /*
 762                  * Get the map of characters to be escaped on transmission.
 763                  */
 764                 if (COPY_TO_USER((void *) param3, ppp->xmit_async_map,
 765                                  sizeof (ppp->xmit_async_map)))
 766                         break;
 767                 error = 0;
 768                 break;
 769
 770         case PPPIOCSXASYNCMAP:
 771                 /*
 772                  * Set the map of characters to be escaped on transmission.
 773                  */
 774                 {
 775                         __u32 temp_tbl[8];
 776
 777                         if (COPY_FROM_USER(temp_tbl, (void *) param3,
 778                                            sizeof (temp_tbl)))
 779                                 break;
 780
 781                         temp_tbl[1]  =  0x00000000;
 782                         temp_tbl[2] &= ~0x40000000;
 783                         temp_tbl[3] |=  0x60000000;
 784
 785                         memcpy(ppp->xmit_async_map, temp_tbl,
 786                                sizeof (ppp->xmit_async_map));
 787
 788                         if (ppp->flags & SC_DEBUG)
 789                                 printk(KERN_INFO
 790                                        "ppp_tty_ioctl: set xasyncmap\n");
 791                         error = 0;
 792                 }
 793                 break;
 794
 795         case PPPIOCXFERUNIT:
 796                 /*
 797                  * Set up this PPP unit to be used next time this
 798                  * process sets a tty to PPP line discipline.
 799                  */
 800                 ppp->backup_tty = tty;
 801                 ppp->sc_xfer = current->pid;
 802                 error = 0;
 803                 break;
 804
 805         case TCGETS:
 806         case TCGETA:
 807                 /*
 808                  * Allow users to read, but not set, the serial port parameters
 809                  */
 810                 error = n_tty_ioctl (tty, file, param2, param3);
 811                 break;
 812
 813         case FIONREAD:
 814                 /*
 815                  * Returns how many bytes are available for a read().
 816                  */
 817                 {
 818                         unsigned long flags;
 819                         struct sk_buff *skb;
 820                         int count = 0;
 821
 822                         save_flags(flags);
 823                         cli();
 824                         skb = skb_peek(&ppp->rcv_q);
 825                         if (skb != 0)
 826                                 count = skb->len;
 827                         restore_flags(flags);
 828                         if (PUT_USER(count, (int *) param3))
 829                                 break;
 830                         error = 0;
 831                 }
 832                 break;
 833
 834         default:
 835                 /*
 836                  *  All other ioctl() events will come here.
 837                  */
 838                 error = ppp_ioctl(ppp, param2, param3);
 839                 break;
 840         }
 841         return error;
 842 }
 843
 844 /*
 845  * TTY callback.
 846  *
 847  * Process the select() or poll() statement for the PPP device.
 848  */
 849
 850 #if LINUX_VERSION_CODE < VERSION(2,1,23)
 851 static int
 852 ppp_tty_select(struct tty_struct *tty, struct inode *inode,
 853                struct file *filp, int sel_type, select_table * wait)
 854 {
 855         struct ppp *ppp = tty2ppp(tty);
 856         int result = 1;
 857
 858         /*
 859          * Verify the status of the PPP device.
 860          */
 861         if (!ppp || tty != ppp->tty)
 862                 return -EBADF;
 863
 864         CHECK_PPP(-EBADF);
 865
 866         switch (sel_type) {
 867         case SEL_IN:
 868                 /* The fd is readable if the receive queue isn't empty. */
 869                 if (skb_peek(&ppp->rcv_q) != NULL)
 870                         break;
 871                 /* fall through */
 872         case SEL_EX:
 873                 /* Check for exceptions or read errors. */
 874                 /* Is this a pty link and the remote disconnected? */
 875                 if (tty->flags & (1 << TTY_OTHER_CLOSED))
 876                         break;
 877
 878                 /* Is this a local link and the modem disconnected? */
 879                 if (tty_hung_up_p (filp))
 880                         break;
 881
 882                 select_wait(&ppp->read_wait, wait);
 883                 result = 0;
 884                 break;
 885
 886         case SEL_OUT:
 887                 /* The fd is always writable. */
 888                 break;
 889         }
 890         return result;
 891 }
 892
 893 #else   /* 2.1.23 or later */
 894
 895 static unsigned int
 896 ppp_tty_poll(struct tty_struct *tty, struct file *filp, poll_table * wait)
 897 {
 898         struct ppp *ppp = tty2ppp(tty);
 899         unsigned int mask = 0;
 900
 901         if (ppp && ppp->magic == PPP_MAGIC && tty == ppp->tty) {
 902                 CHECK_PPP(0);
 903
 904                 poll_wait(filp, &ppp->read_wait, wait);
 905
 906                 if (skb_peek(&ppp->rcv_q) != NULL)
 907                         mask |= POLLIN | POLLRDNORM;
 908                 if (tty->flags & (1 << TTY_OTHER_CLOSED)
 909                     || tty_hung_up_p(filp))
 910                         mask |= POLLHUP;
 911                 mask |= POLLOUT | POLLWRNORM;
 912         }
 913         return mask;
 914 }
 915 #endif  /* >= 2.1.23 */
 916
 917 /*
 918  * This function is called by the tty driver when the transmit buffer has
 919  * additional space. It is used by the ppp code to continue to transmit
 920  * the current buffer should the buffer have been partially sent.
 921  */
 922 static void
 923 ppp_tty_wakeup (struct tty_struct *tty)
 924 {
 925         struct ppp *ppp = tty2ppp (tty);
 926
 927         tty->flags &= ~(1 << TTY_DO_WRITE_WAKEUP);
 928         if (!ppp)
 929                 return;
 930         CHECK_PPP_VOID();
 931         if (tty != ppp->tty)
 932                 return;
 933
 934         if (ppp_tty_push(ppp))
 935                 ppp_output_wakeup(ppp);
 936 }
 937
 938 /*
 939  * Send a packet to the peer over an async tty line.
 940  * Returns -1 iff the packet could not be accepted at present,
 941  * 0 if the packet was accepted but we can't accept another yet, or
 942  * 1 if we can accept another packet immediately.
 943  * If this procedure returns 0, ppp_output_wakeup will be called
 944  * exactly once.
 945  */
 946 static int
 947 ppp_async_send(struct ppp *ppp, struct sk_buff *skb)
 948 {
 949         CHECK_PPP(0);
 950
 951         ppp_tty_push(ppp);
 952
 953         if (ppp->tpkt != NULL)
 954                 return -1;
 955         ppp->tpkt = skb;
 956         ppp->tpkt_pos = 0;
 957
 958         return ppp_tty_push(ppp);
 959 }
 960
 961 /*
 962  * Push as much data as possible out to the tty.
 963  * Returns 1 if we finished encoding the current frame, 0 otherwise.
 964  */
 965 static int
 966 ppp_tty_push(struct ppp *ppp)
 967 {
 968         int avail, sent, done = 0;
 969         struct tty_struct *tty = ppp2tty(ppp);
 970
 971         CHECK_PPP(0);
 972         if (ppp->tty_pushing)
 973                 return 0;
 974         if (tty == NULL || tty->disc_data != (void *) ppp)
 975                 goto flush;
 976         while (ppp->optr < ppp->olim || ppp->tpkt != 0) {
 977                 ppp->tty_pushing = 1;
 978                 avail = ppp->olim - ppp->optr;
 979                 if (avail > 0) {
 980                         tty->flags |= (1 << TTY_DO_WRITE_WAKEUP);
 981                         sent = tty->driver.write(tty, 0, ppp->optr, avail);
 982                         if (sent < 0)
 983                                 goto flush;     /* error, e.g. loss of CD */
 984                         ppp->stats.ppp_obytes += sent;
 985                         ppp->optr += sent;
 986                         if (sent < avail) {
 987                                 ppp->tty_pushing = 0;
 988                                 return done;
 989                         }
 990                 }
 991                 if (ppp->tpkt != 0)
 992                         done = ppp_async_encode(ppp);
 993                 ppp->tty_pushing = 0;
 994         }
 995         return done;
 996
 997 flush:
 998         ppp->tty_pushing = 1;
 999         ppp->stats.ppp_oerrors++;
1000         if (ppp->tpkt != 0) {
1001                 kfree_skb(ppp->tpkt);
1002                 ppp->tpkt = 0;
1003                 done = 1;
1004         }
1005         ppp->optr = ppp->olim;
1006         ppp->tty_pushing = 0;
1007         return done;
1008 }
1009
1010 /*
1011  * Procedure to encode the data for async serial transmission.
1012  * Does octet stuffing (escaping) and address/control
1013  * and protocol compression.
1014  * Assumes ppp->opkt != 0 on entry.
1015  * Returns 1 if we finished the current frame, 0 otherwise.
1016  */
1017 static int
1018 ppp_async_encode(struct ppp *ppp)
1019 {
1020         int fcs, i, count, c;
1021         unsigned char *buf, *buflim;
1022         unsigned char *data;
1023         int islcp;
1024
1025         CHECK_PPP(0);
1026
1027         buf = ppp->obuf;
1028         ppp->olim = buf;
1029         ppp->optr = buf;
1030         i = ppp->tpkt_pos;
1031         data = ppp->tpkt->data;
1032         count = ppp->tpkt->len;
1033         fcs = ppp->tfcs;
1034
1035         /*
1036          * LCP packets with code values between 1 (configure-reqest)
1037          * and 7 (code-reject) must be sent as though no options
1038          * had been negotiated.
1039          */
1040         islcp = PPP_PROTOCOL(data) == PPP_LCP
1041                 && 1 <= data[PPP_HDRLEN] && data[PPP_HDRLEN] <= 7;
1042
1043         if (i == 0) {
1044                 /*
1045                  * Start of a new packet - insert the leading FLAG
1046                  * character if necessary.
1047                  */
1048                 if (islcp || flag_time == 0
1049                     || jiffies - ppp->last_xmit >= flag_time)
1050                         *buf++ = PPP_FLAG;
1051                 /* only reset idle time for data packets */
1052                 if (PPP_PROTOCOL(data) < 0x8000)
1053                         ppp->last_xmit = jiffies;
1054                 fcs = PPP_INITFCS;
1055                 ++ppp->stats.ppp_opackets;
1056                 ppp->stats.ppp_ooctects += count;
1057
1058                 /*
1059                  * Do address/control compression
1060                  */
1061                 if ((ppp->flags & SC_COMP_AC) != 0 && !islcp
1062                     && PPP_ADDRESS(data) == PPP_ALLSTATIONS
1063                     && PPP_CONTROL(data) == PPP_UI)
1064                         i += 2;
1065         }
1066
1067         /*
1068          * Once we put in the last byte, we need to put in the FCS
1069          * and closing flag, so make sure there is at least 7 bytes
1070          * of free space in the output buffer.
1071          */
1072         buflim = buf + OBUFSIZE - 6;
1073         while (i < count && buf < buflim) {
1074                 c = data[i++];
1075                 if (i == 3 && c == 0 && (ppp->flags & SC_COMP_PROT))
1076                         continue;       /* compress protocol field */
1077                 fcs = PPP_FCS(fcs, c);
1078                 if (in_xmap(ppp, c) || (islcp && c < 0x20)) {
1079                         *buf++ = PPP_ESCAPE;
1080                         c ^= 0x20;
1081                 }
1082                 *buf++ = c;
1083         }
1084
1085         if (i == count) {
1086                 /*
1087                  * We have finished the packet.  Add the FCS and flag.
1088                  */
1089                 fcs = ~fcs;
1090                 c = fcs & 0xff;
1091                 if (in_xmap(ppp, c) || (islcp && c < 0x20)) {
1092                         *buf++ = PPP_ESCAPE;
1093                         c ^= 0x20;
1094                 }
1095                 *buf++ = c;
1096                 c = (fcs >> 8) & 0xff;
1097                 if (in_xmap(ppp, c) || (islcp && c < 0x20)) {
1098                         *buf++ = PPP_ESCAPE;
1099                         c ^= 0x20;
1100                 }
1101                 *buf++ = c;
1102                 *buf++ = PPP_FLAG;
1103                 ppp->olim = buf;
1104
1105                 kfree_skb(ppp->tpkt);
1106                 ppp->tpkt = 0;
1107                 return 1;
1108         }
1109
1110         /*
1111          * Remember where we are up to in this packet.
1112          */
1113         ppp->olim = buf;
1114         ppp->tpkt_pos = i;
1115         ppp->tfcs = fcs;
1116         return 0;
1117 }
1118
1119 /*
1120  * Callback function from tty driver. Return the amount of space left
1121  * in the receiver's buffer to decide if remote transmitter is to be
1122  * throttled.
1123  */
1124 static int
1125 ppp_tty_room (struct tty_struct *tty)
1126 {
1127         return 65536;       /* We can handle an infinite amount of data. :-) */
1128 }
1129
1130 /*
1131  * Callback function when data is available at the tty driver.
1132  */
1133 static void
1134 ppp_tty_receive (struct tty_struct *tty, const __u8 * data,
1135                  char *flags, int count)
1136 {
1137         register struct ppp *ppp = tty2ppp (tty);
1138         struct sk_buff *skb;
1139         int chr, flg;
1140         unsigned char *p;
1141
1142         if (ppp != 0)
1143                 CHECK_PPP_VOID();
1144         /*
1145          * This can happen if stuff comes in on the backup tty.
1146          */
1147         if (ppp == 0 || tty != ppp->tty)
1148                 return;
1149         /*
1150          * Verify the table pointer and ensure that the line is
1151          * still in PPP discipline.
1152          */
1153         if (ppp->magic != PPP_MAGIC) {
1154                 if (ppp->flags & SC_DEBUG)
1155                         printk(KERN_DEBUG
1156                                "PPP: tty_receive called but couldn't find "
1157                                "PPP struct.\n");
1158                 return;
1159         }
1160         /*
1161          * Print the buffer if desired
1162          */
1163         if (ppp->flags & SC_LOG_RAWIN)
1164                 ppp_print_buffer ("receive buffer", data, count);
1165
1166         ppp->stats.ppp_ibytes += count;
1167         skb = ppp->rpkt;
1168         while (count-- > 0) {
1169                 /*
1170                  * Collect the character and error condition for the character.
1171                  * Set the toss flag for the first character error.
1172                  */
1173                 chr = *data++;
1174                 if (flags) {
1175                         flg = *flags++;
1176                         if (flg) {
1177                                 if (ppp->toss == 0)
1178                                         ppp->toss = flg;
1179                                 switch (flg) {
1180                                 case TTY_OVERRUN:
1181                                         ++ppp->estats.rx_fifo_errors;
1182                                         break;
1183                                 case TTY_FRAME:
1184                                 case TTY_BREAK:
1185                                         ++ppp->estats.rx_frame_errors;
1186                                         break;
1187                                 }
1188                                 continue;
1189                         }
1190                 }
1191
1192                 /*
1193                  * Set the flags for d7 being 0/1 and parity being
1194                  * even/odd so that the normal processing would have
1195                  * all flags set at the end of the session.  A
1196                  * missing flag bit indicates an error condition.
1197                  */
1198
1199 #ifdef CHECK_CHARACTERS
1200                 if (chr & 0x80)
1201                         ppp->flags |= SC_RCV_B7_1;
1202                 else
1203                         ppp->flags |= SC_RCV_B7_0;
1204
1205                 if (paritytab[chr >> 5] & (1 << (chr & 0x1F)))
1206                         ppp->flags |= SC_RCV_ODDP;
1207                 else
1208                         ppp->flags |= SC_RCV_EVNP;
1209 #endif
1210
1211                 if (chr == PPP_FLAG) {
1212                         /*
1213                          * FLAG. This is the end of the block. If the block
1214                          * ends with ESC FLAG, then the block is to be ignored.
1215                          */
1216                         if (ppp->escape)
1217                                 ppp->toss |= 0x80;
1218                         /*
1219                          * Process the frame if it was received correctly.
1220                          * If there was an error, let the VJ decompressor know.
1221                          * There are 4 cases here:
1222                          * skb != NULL, toss != 0: error in frame
1223                          * skb != NULL, toss == 0: frame ok
1224                          * skb == NULL, toss != 0: very first frame,
1225                          *      error on 1st char, or alloc_skb failed
1226                          * skb == NULL, toss == 0: empty frame (~~)
1227                          */
1228                         if (ppp->toss || !ppp_receive_frame(ppp, skb)) {
1229                                 if (ppp->toss && (ppp->flags & SC_DEBUG))
1230                                         printk(KERN_DEBUG
1231                                                "ppp: tossing frame (%x)\n",
1232                                                ppp->toss);
1233                                 if (skb != NULL)
1234                                         kfree_skb(skb);
1235                                 if (!(ppp->toss == 0xE0 || ppp->toss == 0x80))
1236                                         ++ppp->stats.ppp_ierrors;
1237                                 ppp_receive_error(ppp);
1238                         }
1239                         /*
1240                          * Reset for the next frame.
1241                          */
1242                         skb = NULL;
1243                         ppp->rfcs = PPP_INITFCS;
1244                         ppp->escape = 0;
1245                         ppp->toss = 0;
1246                         continue;
1247                 }
1248
1249                 /* If we're tossing, look no further. */
1250                 if (ppp->toss != 0)
1251                         continue;
1252
1253                 /* If this is a control char to be ignored, do so */
1254                 if (in_rmap(ppp, chr))
1255                         continue;
1256
1257                 /*
1258                  * Modify the next character if preceded by escape.
1259                  * The escape character (0x7d) could be an escaped
1260                  * 0x5d, if it follows an escape :-)
1261                  */
1262                 if (ppp->escape) {
1263                         chr ^= PPP_TRANS;
1264                         ppp->escape = 0;
1265                 } else if (chr == PPP_ESCAPE) {
1266                         ppp->escape = PPP_TRANS;
1267                         continue;
1268                 }
1269
1270                 /*
1271                  * Allocate an skbuff on the first character received.
1272                  * The 128 is room for VJ header expansion and FCS.
1273                  */
1274                 if (skb == NULL) {
1275                         skb = dev_alloc_skb(ppp->mru + 128 + PPP_HDRLEN);
1276                         if (skb == NULL) {
1277                                 if (ppp->flags & SC_DEBUG)
1278                                         printk(KERN_DEBUG "couldn't "
1279                                                "alloc skb for recv\n");
1280                                 ppp->toss = 1;
1281                                 continue;
1282                         }
1283                 }
1284
1285                 /*
1286                  * Decompress A/C and protocol compression here.
1287                  */
1288                 if (skb->len == 0 && chr != PPP_ALLSTATIONS) {
1289                         p = skb_put(skb, 2);
1290                         p[0] = PPP_ALLSTATIONS;
1291                         p[1] = PPP_UI;
1292                 }
1293                 if (skb->len == 2 && (chr & 1) != 0) {
1294                         p = skb_put(skb, 1);
1295                         p[0] = 0;
1296                 }
1297
1298                 /*
1299                  * Check if we've overflowed the MRU
1300                  */
1301                 if (skb->len >= ppp->mru + PPP_HDRLEN + 2
1302                     || skb_tailroom(skb) <= 0) {
1303                         ++ppp->estats.rx_length_errors;
1304                         ppp->toss = 0xC0;
1305                         if (ppp->flags & SC_DEBUG)
1306                                 printk(KERN_DEBUG "rcv frame too long: "
1307                                        "len=%d mru=%d hroom=%d troom=%d\n",
1308                                        skb->len, ppp->mru, skb_headroom(skb),
1309                                        skb_tailroom(skb));
1310                         continue;
1311                 }
1312
1313                 /*
1314                  * Store the character and update the FCS.
1315                  */
1316                 p = skb_put(skb, 1);
1317                 *p = chr;
1318                 ppp->rfcs = PPP_FCS(ppp->rfcs, chr);
1319         }
1320         ppp->rpkt = skb;
1321 }
1322
1323 /*************************************************************
1324  * PPP NETWORK INTERFACE SUPPORT
1325  *      The following code implements the PPP network
1326  *      interface device and handles those parts of
1327  *      the PPP processing which are independent of the
1328  *      type of hardware link being used, including
1329  *      VJ and packet compression.
1330  *************************************************************/
1331
1332 /*
1333  * Network device driver callback routines
1334  */
1335
1336 static int ppp_init_dev(struct device *dev);
1337 static int ppp_dev_open(struct device *);
1338 static int ppp_dev_ioctl(struct device *dev, struct ifreq *ifr, int cmd);
1339 static int ppp_dev_close(struct device *);
1340 static int ppp_dev_xmit(struct sk_buff *, struct device *);
1341 static struct net_device_stats *ppp_dev_stats (struct device *);
1342
1343 #if LINUX_VERSION_CODE < VERSION(2,1,15)
1344 static int ppp_dev_header(struct sk_buff *, struct device *, __u16,
1345                           void *, void *, unsigned int);
1346 static int ppp_dev_rebuild(void *eth, struct device *dev,
1347                            unsigned long raddr, struct sk_buff *skb);
1348 #endif
1349
1350 /*
1351  * Information for the protocol decoder
1352  */
1353
1354 typedef int (*pfn_proto)  (struct ppp *, struct sk_buff *);
1355
1356 typedef struct ppp_proto_struct {
1357         int             proto;
1358         pfn_proto       func;
1359 } ppp_proto_type;
1360
1361 static int rcv_proto_ip         (struct ppp *, struct sk_buff *);
1362 static int rcv_proto_ipx        (struct ppp *, struct sk_buff *);
1363 static int rcv_proto_at         (struct ppp *, struct sk_buff *);
1364 static int rcv_proto_vjc_comp   (struct ppp *, struct sk_buff *);
1365 static int rcv_proto_vjc_uncomp (struct ppp *, struct sk_buff *);
1366 static int rcv_proto_ccp        (struct ppp *, struct sk_buff *);
1367 static int rcv_proto_unknown    (struct ppp *, struct sk_buff *);
1368
1369 static
1370 ppp_proto_type proto_list[] = {
1371         { PPP_IP,         rcv_proto_ip         },
1372         { PPP_IPX,        rcv_proto_ipx        },
1373         { PPP_AT,         rcv_proto_at         },
1374         { PPP_VJC_COMP,   rcv_proto_vjc_comp   },
1375         { PPP_VJC_UNCOMP, rcv_proto_vjc_uncomp },
1376         { PPP_CCP,        rcv_proto_ccp        },
1377         { 0,              rcv_proto_unknown    }  /* !!! MUST BE LAST !!! */
1378 };
1379
1380 /*
1381  * Called when the PPP network interface device is actually created.
1382  */
1383 static int
1384 ppp_init_dev (struct device *dev)
1385 {
1386         dev->hard_header_len  = PPP_HDRLEN;
1387 #if LINUX_VERSION_CODE < VERSION(2,1,15)
1388         dev->hard_header      = ppp_dev_header;
1389         dev->rebuild_header   = ppp_dev_rebuild;
1390 #endif
1391
1392         /* device INFO */
1393         dev->mtu              = PPP_MTU;
1394         dev->hard_start_xmit  = ppp_dev_xmit;
1395         dev->open             = ppp_dev_open;
1396         dev->stop             = ppp_dev_close;
1397         dev->get_stats        = ppp_dev_stats;
1398         dev->do_ioctl         = ppp_dev_ioctl;
1399         dev->addr_len         = 0;
1400         dev->tx_queue_len     = 10;
1401         dev->type             = ARPHRD_PPP;
1402
1403 #if LINUX_VERSION_CODE < VERSION(2,1,20)
1404         {
1405                 int    indx;
1406
1407                 for (indx = 0; indx < DEV_NUMBUFFS; indx++)
1408                         skb_queue_head_init (&dev->buffs[indx]);
1409         }
1410 #else
1411         dev_init_buffers(dev);
1412 #endif
1413
1414         dev->flags = IFF_POINTOPOINT | IFF_NOARP | IFF_MULTICAST;
1415
1416         return 0;
1417 }
1418
1419 /*
1420  * Callback from the network layer when the device goes up.
1421  */
1422
1423 static int
1424 ppp_dev_open (struct device *dev)
1425 {
1426         struct ppp *ppp = dev2ppp(dev);
1427
1428         if (!ppp->inuse || ppp2tty(ppp) == NULL) {
1429                 printk(KERN_ERR "ppp: %s not active\n", dev->name);
1430                 return -ENXIO;
1431         }
1432
1433         MOD_INC_USE_COUNT;
1434
1435         return 0;
1436 }
1437
1438 /*
1439  * Callback from the network layer when the ppp device goes down.
1440  */
1441
1442 static int
1443 ppp_dev_close (struct device *dev)
1444 {
1445         struct ppp *ppp = dev2ppp (dev);
1446
1447         CHECK_PPP_MAGIC(ppp);
1448
1449         MOD_DEC_USE_COUNT;
1450
1451         return 0;
1452 }
1453
1454 static inline void
1455 get_vj_stats(struct vjstat *vj, struct slcompress *slc)
1456 {
1457         vj->vjs_packets    = slc->sls_o_compressed + slc->sls_o_uncompressed;
1458         vj->vjs_compressed = slc->sls_o_compressed;
1459         vj->vjs_searches   = slc->sls_o_searches;
1460         vj->vjs_misses     = slc->sls_o_misses;
1461         vj->vjs_errorin    = slc->sls_i_error;
1462         vj->vjs_tossed     = slc->sls_i_tossed;
1463         vj->vjs_uncompressedin = slc->sls_i_uncompressed;
1464         vj->vjs_compressedin   = slc->sls_i_compressed;
1465 }
1466
1467 /*
1468  * Callback from the network layer to process the sockioctl functions.
1469  */
1470 static int
1471 ppp_dev_ioctl (struct device *dev, struct ifreq *ifr, int cmd)
1472 {
1473         struct ppp *ppp = dev2ppp(dev);
1474         int nb;
1475         union {
1476                 struct ppp_stats stats;
1477                 struct ppp_comp_stats cstats;
1478                 char vers[32];
1479         } u;
1480
1481         CHECK_PPP_MAGIC(ppp);
1482
1483         memset(&u, 0, sizeof(u));
1484         switch (cmd) {
1485         case SIOCGPPPSTATS:
1486                 u.stats.p = ppp->stats;
1487                 if (ppp->slcomp != NULL)
1488                         get_vj_stats(&u.stats.vj, ppp->slcomp);
1489                 nb = sizeof(u.stats);
1490                 break;
1491
1492         case SIOCGPPPCSTATS:
1493                 if (ppp->sc_xc_state != NULL)
1494                         (*ppp->sc_xcomp->comp_stat)
1495                                 (ppp->sc_xc_state, &u.cstats.c);
1496                 if (ppp->sc_rc_state != NULL)
1497                         (*ppp->sc_rcomp->decomp_stat)
1498                                 (ppp->sc_rc_state, &u.cstats.d);
1499                 nb = sizeof(u.cstats);
1500                 break;
1501
1502         case SIOCGPPPVER:
1503                 strcpy(u.vers, szVersion);
1504                 nb = strlen(u.vers) + 1;
1505                 break;
1506
1507         default:
1508                 return -EINVAL;
1509         }
1510
1511         if (COPY_TO_USER((void *) ifr->ifr_ifru.ifru_data, &u, nb))
1512                 return -EFAULT;
1513         return 0;
1514 }
1515
1516 /*
1517  * Process the generic PPP ioctls, i.e. those which are not specific
1518  * to any particular type of hardware link.
1519  */
1520 static int
1521 ppp_ioctl(struct ppp *ppp, unsigned int param2, unsigned long param3)
1522 {
1523         register int temp_i = 0, oldflags;
1524         int error = -EFAULT;
1525         unsigned long flags;
1526         struct ppp_idle cur_ddinfo;
1527         struct npioctl npi;
1528
1529         CHECK_PPP(-ENXIO);
1530
1531         /*
1532          * The user must have an euid of root to do these requests.
1533          */
1534         if (!capable(CAP_NET_ADMIN))
1535                 return -EPERM;
1536
1537         switch (param2) {
1538         case PPPIOCSMRU:
1539                 /*
1540                  * Set the MRU value
1541                  */
1542                 if (GET_USER(temp_i, (int *) param3))
1543                         break;
1544                 if (temp_i < PPP_MRU)
1545                         temp_i = PPP_MRU;
1546                 ppp->mru = temp_i;
1547                 if (ppp->flags & SC_DEBUG)
1548                         printk(KERN_INFO
1549                                "ppp_ioctl: set mru to %x\n", temp_i);
1550                 error = 0;
1551                 break;
1552
1553         case PPPIOCGFLAGS:
1554                 /*
1555                  * Fetch the current flags
1556                  */
1557                 temp_i = ppp->flags & SC_MASK;
1558 #ifndef CHECK_CHARACTERS /* Don't generate errors if we don't check chars. */
1559                 temp_i |= SC_RCV_B7_1 | SC_RCV_B7_0 |
1560                           SC_RCV_ODDP | SC_RCV_EVNP;
1561 #endif
1562                 if (PUT_USER(temp_i, (int *) param3))
1563                         break;
1564                 error = 0;
1565                 break;
1566
1567         case PPPIOCSFLAGS:
1568                 /*
1569                  * Set the flags for the various options
1570                  */
1571                 if (GET_USER(temp_i, (int *) param3))
1572                         break;
1573
1574                 if (ppp->flags & ~temp_i & SC_CCP_OPEN)
1575                         ppp_ccp_closed(ppp);
1576
1577                 save_flags(flags);
1578                 cli();
1579                 oldflags = ppp->flags;
1580                 temp_i = (temp_i & SC_MASK) | (oldflags & ~SC_MASK);
1581                 ppp->flags = temp_i;
1582                 restore_flags(flags);
1583
1584                 if ((oldflags | temp_i) & SC_DEBUG)
1585                         printk(KERN_INFO
1586                                "ppp_ioctl: set flags to %x\n", temp_i);
1587                 error = 0;
1588                 break;
1589
1590         case PPPIOCSCOMPRESS:
1591                 /*
1592                  * Set the compression mode
1593                  */
1594                 error = ppp_set_compression
1595                         (ppp, (struct ppp_option_data *) param3);
1596                 break;
1597
1598         case PPPIOCGUNIT:
1599                 /*
1600                  * Obtain the unit number for this device.
1601                  */
1602                 if (PUT_USER(ppp->line, (int *) param3))
1603                         break;
1604                 if (ppp->flags & SC_DEBUG)
1605                         printk(KERN_INFO
1606                                "ppp_ioctl: get unit: %d\n", ppp->line);
1607                 error = 0;
1608                 break;
1609
1610         case PPPIOCSDEBUG:
1611                 /*
1612                  * Set the debug level
1613                  */
1614                 if (GET_USER(temp_i, (int *) param3))
1615                         break;
1616                 temp_i = (temp_i & 0x1F) << 16;
1617
1618                 if ((ppp->flags | temp_i) & SC_DEBUG)
1619                         printk(KERN_INFO
1620                                "ppp_ioctl: set dbg flags to %x\n", temp_i);
1621
1622                 save_flags(flags);
1623                 cli();
1624                 ppp->flags = (ppp->flags & ~0x1F0000) | temp_i;
1625                 restore_flags(flags);
1626                 error = 0;
1627                 break;
1628
1629         case PPPIOCGDEBUG:
1630                 /*
1631                  * Get the debug level
1632                  */
1633                 temp_i = (ppp->flags >> 16) & 0x1F;
1634                 if (PUT_USER(temp_i, (int *) param3))
1635                         break;
1636                 error = 0;
1637                 break;
1638
1639         case PPPIOCGIDLE:
1640                 /*
1641                  * Get the times since the last send/receive frame operation
1642                  */
1643                 /* change absolute times to relative times. */
1644                 cur_ddinfo.xmit_idle = (jiffies - ppp->last_xmit) / HZ;
1645                 cur_ddinfo.recv_idle = (jiffies - ppp->last_recv) / HZ;
1646                 if (COPY_TO_USER((void *) param3, &cur_ddinfo,
1647                                  sizeof (cur_ddinfo)))
1648                         break;
1649                 error = 0;
1650                 break;
1651
1652         case PPPIOCSMAXCID:
1653                 /*
1654                  * Set the maximum VJ header compression slot number.
1655                  */
1656                 if (GET_USER(temp_i, (int *) param3))
1657                         break;
1658                 error = -EINVAL;
1659                 if (temp_i < 2 || temp_i > 255)
1660                         break;
1661                 ++temp_i;
1662                 if (ppp->flags & SC_DEBUG)
1663                         printk(KERN_INFO "ppp_ioctl: set maxcid to %d\n",
1664                                temp_i);
1665                 if (ppp->slcomp != NULL)
1666                         slhc_free(ppp->slcomp);
1667                 ppp->slcomp = slhc_init(16, temp_i);
1668
1669                 error = -ENOMEM;
1670                 if (ppp->slcomp == NULL) {
1671                         printk(KERN_ERR "ppp: no memory for VJ compression\n");
1672                         break;
1673                 }
1674                 error = 0;
1675                 break;
1676
1677         case PPPIOCGNPMODE:
1678         case PPPIOCSNPMODE:
1679                 if (COPY_FROM_USER(&npi, (void *) param3, sizeof(npi)))
1680                         break;
1681
1682                 switch (npi.protocol) {
1683                 case PPP_IP:
1684                         npi.protocol = NP_IP;
1685                         break;
1686                 case PPP_IPX:
1687                         npi.protocol = NP_IPX;
1688                         break;
1689                 case PPP_AT:
1690                         npi.protocol = NP_AT;
1691                         break;
1692                 default:
1693                         if (ppp->flags & SC_DEBUG)
1694                                 printk(KERN_DEBUG "pppioc[gs]npmode: "
1695                                        "invalid proto %d\n", npi.protocol);
1696                         error = -EINVAL;
1697                         goto out;
1698                 }
1699
1700                 if (param2 == PPPIOCGNPMODE) {
1701                         npi.mode = ppp->sc_npmode[npi.protocol];
1702                         if (COPY_TO_USER((void *) param3, &npi, sizeof(npi)))
1703                                 break;
1704                 } else {
1705                         ppp->sc_npmode[npi.protocol] = npi.mode;
1706                         if (ppp->flags & SC_DEBUG)
1707                                 printk(KERN_DEBUG "ppp: set np %d to %d\n",
1708                                        npi.protocol, npi.mode);
1709                         mark_bh(NET_BH);
1710                 }
1711                 error = 0;
1712                 break;
1713
1714         default:
1715                 /*
1716                  *  All other ioctl() events will come here.
1717                  */
1718                 if (ppp->flags & SC_DEBUG)
1719                         printk(KERN_ERR
1720                                "ppp_ioctl: invalid ioctl: %x, addr %lx\n",
1721                                param2, param3);
1722
1723                 error = -ENOIOCTLCMD;
1724                 break;
1725         }
1726 out:
1727         return error;
1728 }
1729
1730 /*
1731  * Process the set-compression ioctl.
1732  */
1733 static int
1734 ppp_set_compression (struct ppp *ppp, struct ppp_option_data *odp)
1735 {
1736         struct compressor *cp;
1737         int error, nb;
1738         unsigned long flags;
1739         __u8 *ptr;
1740         __u8 ccp_option[CCP_MAX_OPTION_LENGTH];
1741         struct ppp_option_data data;
1742
1743         /*
1744          * Fetch the compression parameters
1745          */
1746         error = -EFAULT;
1747         if (COPY_FROM_USER(&data, odp, sizeof (data)))
1748                 goto out;
1749
1750         nb  = data.length;
1751         ptr = data.ptr;
1752         if ((unsigned) nb >= CCP_MAX_OPTION_LENGTH)
1753                 nb = CCP_MAX_OPTION_LENGTH;
1754
1755         if (COPY_FROM_USER(ccp_option, ptr, nb))
1756                 goto out;
1757
1758         error = -EINVAL;
1759         if (ccp_option[1] < 2)  /* preliminary check on the length byte */
1760                 goto out;
1761
1762         save_flags(flags);
1763         cli();
1764         ppp->flags &= ~(data.transmit? SC_COMP_RUN: SC_DECOMP_RUN);
1765         restore_flags(flags);
1766
1767         cp = find_compressor (ccp_option[0]);
1768 #if defined(CONFIG_KMOD) || defined(CONFIG_KERNELD)
1769         if (cp == NULL) {
1770                 char modname[32];
1771                 sprintf(modname, "ppp-compress-%d", ccp_option[0]);
1772                 request_module(modname);
1773                 cp = find_compressor(ccp_option[0]);
1774         }
1775 #endif /* CONFIG_KMOD */
1776
1777         if (cp == NULL) {
1778                 if (ppp->flags & SC_DEBUG)
1779                         printk(KERN_DEBUG
1780                                "%s: no compressor for [%x %x %x], %x\n",
1781                                ppp->name, ccp_option[0], ccp_option[1],
1782                                ccp_option[2], nb);
1783                 goto out;               /* compressor not loaded */
1784         }
1785
1786         /*
1787          * Found a handler for the protocol - try to allocate
1788          * a compressor or decompressor.
1789          */
1790         error = 0;
1791         if (data.transmit) {
1792                 if (ppp->sc_xc_state != NULL)
1793                         (*ppp->sc_xcomp->comp_free)(ppp->sc_xc_state);
1794                 ppp->sc_xc_state = NULL;
1795
1796                 ppp->sc_xcomp    = cp;
1797                 ppp->sc_xc_state = cp->comp_alloc(ccp_option, nb);
1798                 if (ppp->sc_xc_state == NULL) {
1799                         if (ppp->flags & SC_DEBUG)
1800                                 printk(KERN_DEBUG "%s: comp_alloc failed\n",
1801                                        ppp->name);
1802                         error = -ENOBUFS;
1803                 }
1804         } else {
1805                 if (ppp->sc_rc_state != NULL)
1806                         (*ppp->sc_rcomp->decomp_free)(ppp->sc_rc_state);
1807                 ppp->sc_rc_state = NULL;
1808
1809                 ppp->sc_rcomp    = cp;
1810                 ppp->sc_rc_state = cp->decomp_alloc(ccp_option, nb);
1811                 if (ppp->sc_rc_state == NULL) {
1812                         if (ppp->flags & SC_DEBUG)
1813                                 printk(KERN_DEBUG "%s: decomp_alloc failed\n",
1814                                        ppp->name);
1815                         error = -ENOBUFS;
1816                 }
1817         }
1818 out:
1819         return error;
1820 }
1821
1822 /*
1823  * Handle a CCP packet.
1824  *
1825  * The CCP packet is passed along to the pppd process just like any
1826  * other PPP frame. The difference is that some processing needs to be
1827  * immediate or the compressors will become confused on the peer.
1828  */
1829
1830 static void ppp_proto_ccp(struct ppp *ppp, __u8 *dp, int len, int rcvd)
1831 {
1832         int slen    = CCP_LENGTH(dp);
1833         __u8 *opt = dp   + CCP_HDRLEN;
1834         int opt_len = slen - CCP_HDRLEN;
1835         unsigned long flags;
1836
1837         if (slen > len)
1838                 return;
1839
1840         if (ppp->flags & SC_DEBUG)
1841                 printk(KERN_DEBUG "ppp_proto_ccp rcvd=%d code=%x flags=%x\n",
1842                        rcvd, CCP_CODE(dp), ppp->flags);
1843         save_flags(flags);
1844         switch (CCP_CODE(dp)) {
1845         case CCP_CONFREQ:
1846         case CCP_TERMREQ:
1847         case CCP_TERMACK:
1848                 /*
1849                  * CCP must be going down - disable compression
1850                  */
1851                 if (ppp->flags & SC_CCP_UP) {
1852                         cli();
1853                         ppp->flags &= ~(SC_CCP_UP   |
1854                                         SC_COMP_RUN |
1855                                         SC_DECOMP_RUN);
1856                 }
1857                 break;
1858
1859         case CCP_CONFACK:
1860                 if ((ppp->flags & SC_CCP_OPEN) == 0)
1861                         break;
1862                 if (ppp->flags & SC_CCP_UP)
1863                         break;
1864                 if (slen < (CCP_HDRLEN + CCP_OPT_MINLEN))
1865                         break;
1866                 if (slen < (CCP_OPT_LENGTH (opt) + CCP_HDRLEN))
1867                         break;
1868                 if (!rcvd) {
1869                         /*
1870                          * we're agreeing to send compressed packets.
1871                          */
1872                         if (ppp->sc_xc_state == NULL)
1873                                 break;
1874
1875                         if ((*ppp->sc_xcomp->comp_init)
1876                             (ppp->sc_xc_state,
1877                              opt, opt_len,
1878                              ppp->line, 0, ppp->flags & SC_DEBUG)) {
1879                                 if (ppp->flags & SC_DEBUG)
1880                                         printk(KERN_DEBUG "%s: comp running\n",
1881                                                ppp->name);
1882                                 cli();
1883                                 ppp->flags |= SC_COMP_RUN;
1884                         }
1885                         break;
1886                 }
1887
1888                 /*
1889                  * peer is agreeing to send compressed packets.
1890                  */
1891                 if (ppp->sc_rc_state == NULL)
1892                         break;
1893
1894                 if ((*ppp->sc_rcomp->decomp_init)
1895                     (ppp->sc_rc_state,
1896                      opt, opt_len,
1897                      ppp->line, 0, ppp->mru, ppp->flags & SC_DEBUG)) {
1898                         if (ppp->flags & SC_DEBUG)
1899                                 printk(KERN_DEBUG "%s: decomp running\n",
1900                                        ppp->name);
1901                         cli();
1902                         ppp->flags |= SC_DECOMP_RUN;
1903                         ppp->flags &= ~(SC_DC_ERROR | SC_DC_FERROR);
1904                 }
1905                 break;
1906
1907         case CCP_RESETACK:
1908                 /*
1909                  * CCP Reset-ack resets compressors and decompressors
1910                  * as it passes through.
1911                  */
1912                 if ((ppp->flags & SC_CCP_UP) == 0)
1913                         break;
1914
1915                 if (!rcvd) {
1916                         if (ppp->sc_xc_state && (ppp->flags & SC_COMP_RUN)) {
1917                                 (*ppp->sc_xcomp->comp_reset)(ppp->sc_xc_state);
1918                                 if (ppp->flags & SC_DEBUG)
1919                                         printk(KERN_DEBUG "%s: comp reset\n",
1920                                                ppp->name);
1921                         }
1922                 } else {
1923                         if (ppp->sc_rc_state && (ppp->flags & SC_DECOMP_RUN)) {
1924                               (*ppp->sc_rcomp->decomp_reset)(ppp->sc_rc_state);
1925                               if (ppp->flags & SC_DEBUG)
1926                                         printk(KERN_DEBUG "%s: decomp reset\n",
1927                                                ppp->name);
1928                               cli();
1929                               ppp->flags &= ~SC_DC_ERROR;
1930                         }
1931                 }
1932                 break;
1933         }
1934         restore_flags(flags);
1935 }
1936
1937 /*
1938  * CCP is down; free (de)compressor state if necessary.
1939  */
1940
1941 static void
1942 ppp_ccp_closed(struct ppp *ppp)
1943 {
1944         unsigned long flags;
1945
1946         save_flags(flags);
1947         cli();
1948         ppp->flags &= ~(SC_CCP_OPEN | SC_CCP_UP | SC_COMP_RUN | SC_DECOMP_RUN);
1949         restore_flags(flags);
1950         if (ppp->flags & SC_DEBUG)
1951                 printk(KERN_DEBUG "%s: ccp closed\n", ppp->name);
1952         if (ppp->sc_xc_state) {
1953                 (*ppp->sc_xcomp->comp_free) (ppp->sc_xc_state);
1954                 ppp->sc_xc_state = NULL;
1955         }
1956
1957         if (ppp->sc_rc_state) {
1958                 (*ppp->sc_rcomp->decomp_free) (ppp->sc_rc_state);
1959                 ppp->sc_rc_state = NULL;
1960         }
1961 }
1962
1963 /*************************************************************
1964  * RECEIVE-SIDE ROUTINES
1965  *************************************************************/
1966
1967 /*
1968  * On entry, a received frame is in skb.
1969  * Check it and dispose as appropriate.
1970  */
1971 static int
1972 ppp_receive_frame(struct ppp *ppp, struct sk_buff *skb)
1973 {
1974         __u8    *data;
1975         int     count;
1976         int     proto;
1977         int     new_count;
1978         struct sk_buff *new_skb;
1979         ppp_proto_type  *proto_ptr;
1980
1981         /*
1982          * An empty frame is ignored. This occurs if the FLAG sequence
1983          * precedes and follows each frame.
1984          */
1985         if (skb == NULL)
1986                 return 1;
1987         if (skb->len == 0) {
1988                 kfree_skb(skb);
1989                 return 1;
1990         }
1991         data = skb->data;
1992         count = skb->len;
1993
1994         /*
1995          * Generate an error if the frame is too small.
1996          */
1997         if (count < PPP_HDRLEN + 2) {
1998                 if (ppp->flags & SC_DEBUG)
1999                         printk(KERN_DEBUG
2000                                "ppp: got runt ppp frame, %d chars\n", count);
2001                 ++ppp->estats.rx_length_errors;
2002                 return 0;
2003         }
2004
2005         /*
2006          * Verify the FCS of the frame and discard the FCS characters
2007          * from the end of the buffer.
2008          */
2009         if (ppp->rfcs != PPP_GOODFCS) {
2010                 if (ppp->flags & SC_DEBUG) {
2011                         printk(KERN_DEBUG
2012                                "ppp: frame with bad fcs, length = %d\n",
2013                                count);
2014                         ppp_print_buffer("bad frame", data, count);
2015                 }
2016                 ++ppp->estats.rx_crc_errors;
2017                 return 0;
2018         }
2019         count -= 2;             /* ignore the fcs characters */
2020         skb_trim(skb, count);
2021
2022         /*
2023          * Process the active decompressor.
2024          */
2025         if (ppp->sc_rc_state != NULL &&
2026             (ppp->flags & SC_DECOMP_RUN) &&
2027             ((ppp->flags & (SC_DC_FERROR | SC_DC_ERROR)) == 0)) {
2028                 if (PPP_PROTOCOL(data) == PPP_COMP) {
2029                         /*
2030                          * If the frame is compressed then decompress it.
2031                          */
2032                         new_skb = dev_alloc_skb(ppp->mru + 128 + PPP_HDRLEN);
2033                         if (new_skb == NULL) {
2034                                 printk(KERN_ERR "ppp_recv_frame: no memory\n");
2035                                 new_count = DECOMP_ERROR;
2036                         } else {
2037                                 new_count = (*ppp->sc_rcomp->decompress)
2038                                         (ppp->sc_rc_state, data, count,
2039                                          new_skb->data, ppp->mru + PPP_HDRLEN);
2040                         }
2041                         if (new_count > 0) {
2042                                 /* Frame was decompressed OK */
2043                                 kfree_skb(skb);
2044                                 skb = new_skb;
2045                                 count = new_count;
2046                                 data = skb_put(skb, count);
2047
2048                         } else {
2049                                 /*
2050                                  * On a decompression error, we pass the
2051                                  * compressed frame up to pppd as an
2052                                  * error indication.
2053                                  */
2054                                 if (ppp->flags & SC_DEBUG)
2055                                         printk(KERN_INFO "%s: decomp err %d\n",
2056                                                ppp->name, new_count);
2057                                 if (new_skb != 0)
2058                                         kfree_skb(new_skb);
2059                                 if (ppp->slcomp != 0)
2060                                         slhc_toss(ppp->slcomp);
2061                                 ++ppp->stats.ppp_ierrors;
2062                                 if (new_count == DECOMP_FATALERROR) {
2063                                         ppp->flags |= SC_DC_FERROR;
2064                                 } else {
2065                                         ppp->flags |= SC_DC_ERROR;
2066                                 }
2067                         }
2068
2069
2070                 } else {
2071                         /*
2072                          * The frame is not compressed. Pass it to the
2073                          * decompression code so it can update its
2074                          * dictionary if necessary.
2075                          */
2076                         (*ppp->sc_rcomp->incomp)(ppp->sc_rc_state,
2077                                                  data, count);
2078                 }
2079         }
2080         else if (PPP_PROTOCOL(data) == PPP_COMP && (ppp->flags & SC_DEBUG))
2081                 printk(KERN_INFO "%s: not decomp, rc_state=%p flags=%x\n",
2082                        ppp->name, ppp->sc_rc_state, ppp->flags);
2083
2084         /*
2085          * Count the frame and print it
2086          */
2087         ++ppp->stats.ppp_ipackets;
2088         ppp->stats.ppp_ioctects += count;
2089         if (ppp->flags & SC_LOG_INPKT)
2090                 ppp_print_buffer ("receive frame", data, count);
2091
2092         /*
2093          * Find the procedure to handle this protocol.
2094          * The last one is marked as protocol 0 which is the 'catch-all'
2095          * to feed it to the pppd daemon.
2096          */
2097         proto = PPP_PROTOCOL(data);
2098         proto_ptr = proto_list;
2099         while (proto_ptr->proto != 0 && proto_ptr->proto != proto)
2100                 ++proto_ptr;
2101
2102         /*
2103          * Update the appropriate statistic counter.
2104          */
2105         if (!(*proto_ptr->func)(ppp, skb)) {
2106                 kfree_skb(skb);
2107                 ++ppp->stats.ppp_discards;
2108         }
2109
2110         return 1;
2111 }
2112
2113 /*
2114  * An input error has been detected, so we need to inform
2115  * the VJ decompressor.
2116  */
2117 static void
2118 ppp_receive_error(struct ppp *ppp)
2119 {
2120         CHECK_PPP_VOID();
2121
2122         if (ppp->slcomp != 0)
2123                 slhc_toss(ppp->slcomp);
2124 }
2125
2126 /*
2127  * Put the input frame into the networking system for the indicated protocol
2128  */
2129 static int
2130 ppp_rcv_rx(struct ppp *ppp, __u16 proto, struct sk_buff *skb)
2131 {
2132
2133         /*
2134          * Fill in a few fields of the skb and give it to netif_rx().
2135          */
2136         skb->dev      = ppp2dev(ppp);   /* We are the device */
2137         skb->protocol = htons(proto);
2138         skb_pull(skb, PPP_HDRLEN);      /* pull off ppp header */
2139         skb->mac.raw   = skb->data;
2140         ppp->last_recv = jiffies;
2141 #if LINUX_VERSION_CODE < VERSION(2,1,15)
2142         skb->free = 1;
2143 #endif
2144         netif_rx (skb);
2145         return 1;
2146 }
2147
2148 /*
2149  * Process the receipt of an IP frame
2150  */
2151 static int
2152 rcv_proto_ip(struct ppp *ppp, struct sk_buff *skb)
2153 {
2154         CHECK_PPP(0);
2155         if ((ppp2dev(ppp)->flags & IFF_UP) && (skb->len > 0)
2156             && ppp->sc_npmode[NP_IP] == NPMODE_PASS)
2157                 return ppp_rcv_rx(ppp, ETH_P_IP, skb);
2158         return 0;
2159 }
2160
2161 /*
2162  * Process the receipt of an IPX frame
2163  */
2164 static int
2165 rcv_proto_ipx(struct ppp *ppp, struct sk_buff *skb)
2166 {
2167         CHECK_PPP(0);
2168         if (((ppp2dev(ppp)->flags & IFF_UP) != 0) && (skb->len > 0)
2169             && ppp->sc_npmode[NP_IPX] == NPMODE_PASS)
2170                 return ppp_rcv_rx(ppp, ETH_P_IPX, skb);
2171         return 0;
2172 }
2173
2174 /*
2175  * Process the receipt of an Appletalk frame
2176  */
2177 static int
2178 rcv_proto_at(struct ppp *ppp, struct sk_buff *skb)
2179 {
2180         CHECK_PPP(0);
2181         if ((ppp2dev(ppp)->flags & IFF_UP) && (skb->len > 0)
2182             && ppp->sc_npmode[NP_AT] == NPMODE_PASS)
2183                 return ppp_rcv_rx(ppp, ETH_P_PPPTALK, skb);
2184         return 0;
2185 }
2186
2187 /*
2188  * Process the receipt of an VJ Compressed frame
2189  */
2190 static int
2191 rcv_proto_vjc_comp(struct ppp *ppp, struct sk_buff *skb)
2192 {
2193         int new_count;
2194
2195         CHECK_PPP(0);
2196         if ((ppp->flags & SC_REJ_COMP_TCP) || ppp->slcomp == NULL)
2197                 return 0;
2198         new_count = slhc_uncompress(ppp->slcomp, skb->data + PPP_HDRLEN,
2199                                     skb->len - PPP_HDRLEN);
2200         if (new_count < 0) {
2201                 if (ppp->flags & SC_DEBUG)
2202                         printk(KERN_NOTICE
2203                                "ppp: error in VJ decompression\n");
2204                 return 0;
2205         }
2206         skb_put(skb, new_count + PPP_HDRLEN - skb->len);
2207         return rcv_proto_ip(ppp, skb);
2208 }
2209
2210 /*
2211  * Process the receipt of an VJ Un-compressed frame
2212  */
2213 static int
2214 rcv_proto_vjc_uncomp(struct ppp *ppp, struct sk_buff *skb)
2215 {
2216         CHECK_PPP(0);
2217         if ((ppp->flags & SC_REJ_COMP_TCP) || ppp->slcomp == NULL)
2218                 return 0;
2219         if (slhc_remember(ppp->slcomp, skb->data + PPP_HDRLEN,
2220                           skb->len - PPP_HDRLEN) <= 0) {
2221                 if (ppp->flags & SC_DEBUG)
2222                         printk(KERN_NOTICE "ppp: error in VJ memorizing\n");
2223                 return 0;
2224         }
2225         return rcv_proto_ip(ppp, skb);
2226 }
2227
2228 static int
2229 rcv_proto_ccp(struct ppp *ppp, struct sk_buff *skb)
2230 {
2231         CHECK_PPP(0);
2232         ppp_proto_ccp (ppp, skb->data + PPP_HDRLEN, skb->len - PPP_HDRLEN, 1);
2233         return rcv_proto_unknown(ppp, skb);
2234 }
2235
2236 /*
2237  * Receive all unclassified protocols.
2238  */
2239 static int
2240 rcv_proto_unknown(struct ppp *ppp, struct sk_buff *skb)
2241 {
2242         CHECK_PPP(0);
2243
2244         /*
2245          * Limit queue length by dropping old frames.
2246          */
2247         skb_queue_tail(&ppp->rcv_q, skb);
2248         while (ppp->rcv_q.qlen > PPP_MAX_RCV_QLEN) {
2249                 struct sk_buff *skb = skb_dequeue(&ppp->rcv_q);
2250                 if (skb)
2251                         kfree_skb(skb);
2252         }
2253
2254         wake_up_interruptible (&ppp->read_wait);
2255         if (ppp->tty->fasync != NULL)
2256                 kill_fasync (ppp->tty->fasync, SIGIO);
2257
2258         return 1;
2259 }
2260
2261 /*************************************************************
2262  * TRANSMIT-SIDE ROUTINES
2263  *************************************************************/
2264
2265 /* local function to store a value into the LQR frame */
2266 extern inline __u8 * store_long (register __u8 *p, register int value) {
2267         *p++ = (__u8) (value >> 24);
2268         *p++ = (__u8) (value >> 16);
2269         *p++ = (__u8) (value >>  8);
2270         *p++ = (__u8) value;
2271         return p;
2272 }
2273
2274 /*
2275  * Compress and send an frame to the peer.
2276  * Should be called with xmit_busy == 1, having been set by the caller.
2277  * That is, we use xmit_busy as a lock to prevent reentry of this
2278  * procedure.
2279  */
2280 static void
2281 ppp_send_frame(struct ppp *ppp, struct sk_buff *skb)
2282 {
2283         int     proto;
2284         __u8    *data;
2285         int     count;
2286         __u8    *p;
2287         int     ret;
2288
2289         CHECK_PPP_VOID();
2290         data = skb->data;
2291         count = skb->len;
2292
2293         /* dump the buffer */
2294         if (ppp->flags & SC_LOG_OUTPKT)
2295                 ppp_print_buffer ("write frame", data, count);
2296
2297         /*
2298          * Handle various types of protocol-specific compression
2299          * and other processing, including:
2300          * - VJ TCP header compression
2301          * - updating LQR packets
2302          * - updating CCP state on CCP packets
2303          */
2304         proto = PPP_PROTOCOL(data);
2305         switch (proto) {
2306         case PPP_IP:
2307                 if ((ppp->flags & SC_COMP_TCP) && ppp->slcomp != NULL)
2308                         skb = ppp_vj_compress(ppp, skb);
2309                 break;
2310
2311         case PPP_LQR:
2312                 /*
2313                  * Update the LQR frame with the current MIB information.
2314                  * This way the information is accurate and up-to-date.
2315                  */
2316                 if (count < 48)
2317                         break;
2318                 p = data + 40;  /* Point to last two items. */
2319                 p = store_long(p, ppp->stats.ppp_opackets + 1);
2320                 p = store_long(p, ppp->stats.ppp_ooctects + count);
2321                 ++ppp->stats.ppp_olqrs;
2322                 break;
2323
2324         case PPP_CCP:
2325                 /*
2326                  * Outbound compression control frames
2327                  */
2328                 ppp_proto_ccp(ppp, data + PPP_HDRLEN, count - PPP_HDRLEN, 0);
2329                 break;
2330         }
2331         data = skb->data;
2332         count = skb->len;
2333
2334         /*
2335          * Compress the whole frame if possible.
2336          */
2337         if (((ppp->flags & SC_COMP_RUN) != 0)   &&
2338             (ppp->sc_xc_state != (void *) 0)    &&
2339             (proto != PPP_LCP)                  &&
2340             (proto != PPP_CCP)) {
2341                 struct sk_buff *new_skb;
2342                 int new_count;
2343
2344                 /* Allocate an skb for the compressed frame. */
2345                 new_skb = alloc_skb(ppp->mtu + PPP_HDRLEN, GFP_ATOMIC);
2346                 if (new_skb == NULL) {
2347                         printk(KERN_ERR "ppp_send_frame: no memory\n");
2348                         kfree_skb(skb);
2349                         ppp->xmit_busy = 0;
2350                         return;
2351                 }
2352
2353                 /* Compress the frame. */
2354                 new_count = (*ppp->sc_xcomp->compress)
2355                         (ppp->sc_xc_state, data, new_skb->data,
2356                          count, ppp->mtu + PPP_HDRLEN);
2357
2358                 /* Did it compress? */
2359                 if (new_count > 0 && (ppp->flags & SC_CCP_UP)) {
2360                         skb_put(new_skb, new_count);
2361                         kfree_skb(skb);
2362                         skb = new_skb;
2363                 } else {
2364                         /*
2365                          * The frame could not be compressed, or it could not
2366                          * be sent in compressed form because CCP is down.
2367                          */
2368                         kfree_skb(new_skb);
2369                 }
2370         }
2371
2372         /*
2373          * Send the frame
2374          */
2375         ret = ppp_async_send(ppp, skb);
2376         if (ret > 0) {
2377                 /* we can release the lock */
2378                 ppp->xmit_busy = 0;
2379         } else if (ret < 0) {
2380                 /* can't happen, since the caller got the xmit_busy lock */
2381                 printk(KERN_ERR "ppp: ppp_async_send didn't accept pkt\n");
2382         }
2383 }
2384
2385 /*
2386  * Apply VJ TCP header compression to a packet.
2387  */
2388 static struct sk_buff *
2389 ppp_vj_compress(struct ppp *ppp, struct sk_buff *skb)
2390 {
2391         __u8 *orig_data, *data;
2392         struct sk_buff *new_skb;
2393         int len, proto;
2394
2395         new_skb = alloc_skb(skb->len, GFP_ATOMIC);
2396         if (new_skb == NULL) {
2397                 printk(KERN_ERR "ppp: no memory for vj compression\n");
2398                 return skb;
2399         }
2400
2401         orig_data = data = skb->data + PPP_HDRLEN;
2402         len = slhc_compress(ppp->slcomp, data, skb->len - PPP_HDRLEN,
2403                             new_skb->data + PPP_HDRLEN, &data,
2404                             (ppp->flags & SC_NO_TCP_CCID) == 0);
2405
2406         if (data == orig_data) {
2407                 /* Couldn't compress the data */
2408                 kfree_skb(new_skb);
2409                 return skb;
2410         }
2411
2412         /* The data has been changed */
2413         if (data[0] & SL_TYPE_COMPRESSED_TCP) {
2414                 proto = PPP_VJC_COMP;
2415                 data[0] ^= SL_TYPE_COMPRESSED_TCP;
2416         } else {
2417                 if (data[0] >= SL_TYPE_UNCOMPRESSED_TCP)
2418                         proto = PPP_VJC_UNCOMP;
2419                 else
2420                         proto = PPP_IP;
2421                 data[0] = orig_data[0];
2422         }
2423
2424         data = skb_put(new_skb, len + PPP_HDRLEN);
2425         data[0] = PPP_ALLSTATIONS;
2426         data[1] = PPP_UI;
2427         data[2] = 0;
2428         data[3] = proto;
2429
2430         kfree_skb(skb);
2431         return new_skb;
2432 }
2433
2434 static inline void
2435 ppp_send_frames(struct ppp *ppp)
2436 {
2437         struct sk_buff *skb;
2438
2439         while (!test_and_set_bit(0, &ppp->xmit_busy)) {
2440                 skb = skb_dequeue(&ppp->xmt_q);
2441                 if (skb == NULL) {
2442                         ppp->xmit_busy = 0;
2443                         break;
2444                 }
2445                 ppp_send_frame(ppp, skb);
2446         }
2447         if (!ppp->xmit_busy && ppp->dev.tbusy) {
2448                 ppp->dev.tbusy = 0;
2449                 mark_bh(NET_BH);
2450         }
2451 }
2452
2453 /*
2454  * Called from the hardware (tty) layer when it can accept
2455  * another packet.
2456  */
2457 static void
2458 ppp_output_wakeup(struct ppp *ppp)
2459 {
2460         CHECK_PPP_VOID();
2461
2462         if (!ppp->xmit_busy) {
2463                 printk(KERN_ERR "ppp_output_wakeup called but xmit_busy==0\n");
2464                 return;
2465         }
2466         ppp->xmit_busy = 0;
2467         ppp_send_frames(ppp);
2468 }
2469
2470 /*
2471  * Send a control frame (from pppd).
2472  */
2473 static void
2474 ppp_send_ctrl(struct ppp *ppp, struct sk_buff *skb)
2475 {
2476         CHECK_PPP_VOID();
2477
2478         /*
2479          * Put the packet on the queue, then send as many as we can.
2480          */
2481         skb_queue_tail(&ppp->xmt_q, skb);
2482         ppp_send_frames(ppp);
2483 }
2484
2485
2486 /*************************************************************
2487  * NETWORK OUTPUT
2488  *    This routine accepts requests from the network layer
2489  *    and attempts to deliver the packets.
2490  *************************************************************/
2491 /*
2492  * Send a frame to the peer.
2493  * Returns 1 iff the frame was not accepted.
2494  */
2495 static int
2496 ppp_dev_xmit(struct sk_buff *skb, struct device *dev)
2497 {
2498         struct ppp *ppp = dev2ppp(dev);
2499         struct tty_struct *tty = ppp2tty(ppp);
2500         enum NPmode npmode;
2501         int proto;
2502         unsigned char *hdr;
2503
2504         /* just a little sanity check. */
2505         if (skb == NULL)
2506                 return 0;
2507         if (skb->data == NULL) {
2508                 kfree_skb(skb);
2509                 return 0;
2510         }
2511
2512         /*
2513          * Avoid timing problem should tty hangup while data is
2514          * queued to be sent.
2515          */
2516         if (!ppp->inuse) {
2517                 dev_kfree_skb(skb);
2518                 return 0;
2519         }
2520
2521         /*
2522          * Validate the tty interface
2523          */
2524         if (tty == NULL) {
2525                 if (ppp->flags & SC_DEBUG)
2526                         printk(KERN_ERR
2527                                "ppp_dev_xmit: %s not connected to a TTY!\n",
2528                                dev->name);
2529                 dev_kfree_skb(skb);
2530                 return 0;
2531         }
2532
2533         /*
2534          * Work out the appropriate network-protocol mode for this packet.
2535          */
2536         npmode = NPMODE_PASS;   /* default */
2537         switch (ntohs(skb->protocol)) {
2538         case ETH_P_IP:
2539                 proto = PPP_IP;
2540                 npmode = ppp->sc_npmode[NP_IP];
2541                 break;
2542         case ETH_P_IPX:
2543                 proto = PPP_IPX;
2544                 npmode = ppp->sc_npmode[NP_IPX];
2545                 break;
2546         case ETH_P_PPPTALK:
2547         case ETH_P_ATALK:
2548                 proto = PPP_AT;
2549                 npmode = ppp->sc_npmode[NP_AT];
2550                 break;
2551         default:
2552                 if (ppp->flags & SC_DEBUG)
2553                         printk(KERN_INFO "%s: packet for unknown proto %x\n",
2554                                ppp->name, ntohs(skb->protocol));
2555                 dev_kfree_skb(skb);
2556                 return 0;
2557         }
2558
2559         /*
2560          * Drop, accept or reject the packet depending on the mode.
2561          */
2562         switch (npmode) {
2563         case NPMODE_PASS:
2564                 break;
2565
2566         case NPMODE_QUEUE:
2567                 /*
2568                  * We may not send the packet now, so drop it.
2569                  * XXX It would be nice to be able to return it to the
2570                  * network system to be queued and retransmitted later.
2571                  */
2572                 if (ppp->flags & SC_DEBUG)
2573                         printk(KERN_DEBUG "%s: returning frame\n", ppp->name);
2574                 dev_kfree_skb(skb);
2575                 return 0;
2576
2577         case NPMODE_ERROR:
2578         case NPMODE_DROP:
2579                 if (ppp->flags & SC_DEBUG)
2580                         printk(KERN_DEBUG
2581                                "ppp_dev_xmit: dropping (npmode = %d) on %s\n",
2582                                npmode, ppp->name);
2583                 dev_kfree_skb(skb);
2584                 return 0;
2585         }
2586
2587         /*
2588          * The dev->tbusy field acts as a lock to allow only
2589          * one packet to be processed at a time.  If we can't
2590          * get the lock, try again later.
2591          * We deliberately queue as little as possible inside
2592          * the ppp driver in order to minimize the latency
2593          * for high-priority packets.
2594          */
2595         if (test_and_set_bit(0, &ppp->xmit_busy)) {
2596                 dev->tbusy = 1; /* can't take it now */
2597                 return 1;
2598         }
2599         dev->tbusy = 0;
2600
2601         /*
2602          * Put the 4-byte PPP header on the packet.
2603          * If there isn't room for it, we have to copy the packet.
2604          */
2605         if (skb_headroom(skb) < PPP_HDRLEN) {
2606                 struct sk_buff *new_skb;
2607
2608                 new_skb = alloc_skb(skb->len + PPP_HDRLEN, GFP_ATOMIC);
2609                 if (new_skb == NULL) {
2610                         printk(KERN_ERR "%s: skb hdr alloc failed\n",
2611                                ppp->name);
2612                         dev_kfree_skb(skb);
2613                         ppp->xmit_busy = 0;
2614                         ppp_send_frames(ppp);
2615                         return 0;
2616                 }
2617                 skb_reserve(new_skb, PPP_HDRLEN);
2618                 memcpy(skb_put(new_skb, skb->len), skb->data, skb->len);
2619                 dev_kfree_skb(skb);
2620                 skb = new_skb;
2621         }
2622
2623         hdr = skb_push(skb, PPP_HDRLEN);
2624         hdr[0] = PPP_ALLSTATIONS;
2625         hdr[1] = PPP_UI;
2626         hdr[2] = proto >> 8;
2627         hdr[3] = proto;
2628
2629         ppp_send_frame(ppp, skb);
2630         if (!ppp->xmit_busy)
2631                 ppp_send_frames(ppp);
2632         return 0;
2633 }
2634
2635 #if LINUX_VERSION_CODE < VERSION(2,1,15)
2636 /*
2637  * Null hard_header and header_rebuild routines.
2638  */
2639 static int ppp_dev_header(struct sk_buff *skb, struct device *dev,
2640                           unsigned short type, void *daddr,
2641                           void *saddr, unsigned int len)
2642 {
2643         return 0;
2644 }
2645
2646 static int ppp_dev_rebuild(void *eth, struct device *dev,
2647                            unsigned long raddr, struct sk_buff *skb)
2648 {
2649         return 0;
2650 }
2651 #endif /* < 2.1.15 */
2652
2653 /*
2654  * Generate the statistic information for the /proc/net/dev listing.
2655  */
2656 static struct net_device_stats *
2657 ppp_dev_stats (struct device *dev)
2658 {
2659         struct ppp *ppp = dev2ppp (dev);
2660
2661         ppp->estats.rx_packets = ppp->stats.ppp_ipackets;
2662         ppp->estats.rx_errors  = ppp->stats.ppp_ierrors;
2663         ppp->estats.tx_packets = ppp->stats.ppp_opackets;
2664         ppp->estats.tx_errors  = ppp->stats.ppp_oerrors;
2665 #if LINUX_VERSION_CODE >= VERSION(2,1,25)
2666         ppp->estats.rx_bytes   = ppp->stats.ppp_ibytes;
2667         ppp->estats.tx_bytes   = ppp->stats.ppp_obytes;
2668 #endif
2669
2670         return &ppp->estats;
2671 }
2672
2673 /*************************************************************
2674  * UTILITIES
2675  *    Miscellany called by various functions above.
2676  *************************************************************/
2677
2678 /* Locate the previous instance of the PPP channel */
2679 static struct ppp *
2680 ppp_find(int pid_value)
2681 {
2682         struct ppp      *ppp;
2683
2684         /* try to find the device which this pid is already using */
2685         for (ppp = ppp_list; ppp != 0; ppp = ppp->next) {
2686                 if (ppp->inuse && ppp->sc_xfer == pid_value) {
2687                         ppp->sc_xfer = 0;
2688                         break;
2689                 }
2690         }
2691         return ppp;
2692 }
2693
2694 /* allocate or create a PPP channel */
2695 static struct ppp *
2696 ppp_alloc(void)
2697 {
2698         int             if_num;
2699         int             status;
2700         struct device   *dev;
2701         struct ppp      *ppp;
2702
2703         /* try to find an free device */
2704         for (ppp = ppp_list; ppp != 0; ppp = ppp->next) {
2705                 if (!test_and_set_bit(0, &ppp->inuse)) {
2706                         dev = ppp2dev(ppp);
2707                         if (dev->flags & IFF_UP) {
2708                                 clear_bit(0, &ppp->inuse);
2709                                 continue;
2710                         }
2711                         /* Reregister device */
2712                         unregister_netdev(dev);
2713                         if (register_netdev(dev) == 0)
2714                                 return ppp;
2715                         printk(KERN_DEBUG "could not reregister ppp device\n");
2716                         /* leave inuse set in this case */
2717                 }
2718         }
2719
2720         /*
2721          * There are no available units, so make a new one.
2722          */
2723         ppp = (struct ppp *) kmalloc(sizeof(struct ppp), GFP_KERNEL);
2724         if (ppp == 0) {
2725                 printk(KERN_ERR "ppp: struct ppp allocation failed\n");
2726                 return 0;
2727         }
2728         memset(ppp, 0, sizeof(*ppp));
2729
2730         /* initialize channel control data */
2731         ppp->magic = PPP_MAGIC;
2732         ppp->next = NULL;
2733         ppp->inuse = 1;
2734         ppp->read_wait = NULL;
2735
2736         /*
2737          * Make up a suitable name for this device
2738          */
2739         dev = ppp2dev(ppp);
2740         dev->name = ppp->name;
2741         if_num = dev_alloc_name(dev, "ppp%d");
2742         if (if_num < 0) {
2743                 printk(KERN_ERR "ppp: dev_alloc_name failed (%d)\n", if_num);
2744                 kfree(ppp);
2745                 return 0;
2746         }
2747         ppp->line = if_num;
2748         ppp->slcomp = NULL;
2749
2750         dev->next = NULL;
2751         dev->init = ppp_init_dev;
2752         dev->name = ppp->name;
2753         dev->priv = (void *) ppp;
2754
2755         /* register device so that we can be ifconfig'd */
2756         /* ppp_init_dev() will be called as a side-effect */
2757         status = register_netdev (dev);
2758         if (status == 0) {
2759                 printk(KERN_INFO "registered device %s\n", dev->name);
2760         } else {
2761                 printk(KERN_ERR
2762                        "ppp_alloc - register_netdev(%s) = %d failure.\n",
2763                        dev->name, status);
2764                 kfree(ppp);
2765                 ppp = NULL;
2766         }
2767
2768         /* link this unit into our list */
2769         if (ppp_list == 0)
2770                 ppp_list = ppp;
2771         else
2772                 ppp_last->next = ppp;
2773         ppp_last = ppp;
2774
2775         return ppp;
2776 }
2777
2778 /*
2779  * Initialize the generic parts of the ppp structure.
2780  */
2781 static void
2782 ppp_generic_init(struct ppp *ppp)
2783 {
2784         int indx;
2785
2786         ppp->flags  = 0;
2787         ppp->mtu    = PPP_MTU;
2788         ppp->mru    = PPP_MRU;
2789
2790         skb_queue_head_init(&ppp->xmt_q);
2791         skb_queue_head_init(&ppp->rcv_q);
2792
2793         ppp->last_xmit  = jiffies;
2794         ppp->last_recv  = jiffies;
2795         ppp->xmit_busy  = 0;
2796
2797         /* clear statistics */
2798         memset(&ppp->stats, 0, sizeof (struct pppstat));
2799         memset(&ppp->estats, 0, sizeof(struct net_device_stats));
2800
2801         /* PPP compression data */
2802         ppp->sc_xc_state = NULL;
2803         ppp->sc_rc_state = NULL;
2804
2805         for (indx = 0; indx < NUM_NP; ++indx)
2806                 ppp->sc_npmode[indx] = NPMODE_PASS;
2807 }
2808
2809 /*
2810  * Called to clean up the generic parts of the ppp structure.
2811  */
2812 static void
2813 ppp_release(struct ppp *ppp)
2814 {
2815         struct sk_buff *skb;
2816
2817         CHECK_PPP_MAGIC(ppp);
2818
2819         if (ppp->flags & SC_DEBUG)
2820                 printk(KERN_DEBUG "%s released\n", ppp->name);
2821
2822         ppp_ccp_closed(ppp);
2823
2824         /* Ensure that the pppd process is not hanging on select()/poll() */
2825         wake_up_interruptible(&ppp->read_wait);
2826
2827         if (ppp->slcomp) {
2828                 slhc_free(ppp->slcomp);
2829                 ppp->slcomp = NULL;
2830         }
2831
2832         while ((skb = skb_dequeue(&ppp->rcv_q)) != NULL)
2833                 kfree_skb(skb);
2834         while ((skb = skb_dequeue(&ppp->xmt_q)) != NULL)
2835                 kfree_skb(skb);
2836
2837         ppp->inuse = 0;
2838         if (ppp->dev.tbusy) {
2839                 ppp->dev.tbusy = 0;
2840                 mark_bh(NET_BH);
2841         }
2842 }
2843
2844 /*
2845  * Utility procedures to print a buffer in hex/ascii
2846  */
2847 static void
2848 ppp_print_hex (register __u8 * out, const __u8 * in, int count)
2849 {
2850         register __u8 next_ch;
2851         static char hex[] = "0123456789ABCDEF";
2852
2853         while (count-- > 0) {
2854                 next_ch = *in++;
2855                 *out++ = hex[(next_ch >> 4) & 0x0F];
2856                 *out++ = hex[next_ch & 0x0F];
2857                 ++out;
2858         }
2859 }
2860
2861 static void
2862 ppp_print_char (register __u8 * out, const __u8 * in, int count)
2863 {
2864         register __u8 next_ch;
2865
2866         while (count-- > 0) {
2867                 next_ch = *in++;
2868
2869                 if (next_ch < 0x20 || next_ch > 0x7e)
2870                         *out++ = '.';
2871                 else {
2872                         *out++ = next_ch;
2873                         if (next_ch == '%')   /* printk/syslogd has a bug !! */
2874                                 *out++ = '%';
2875                 }
2876         }
2877         *out = '\0';
2878 }
2879
2880 static void
2881 ppp_print_buffer (const char *name, const __u8 *buf, int count)
2882 {
2883         __u8 line[44];
2884
2885         if (name != NULL)
2886                 printk(KERN_DEBUG "ppp: %s, count = %d\n", name, count);
2887
2888         while (count > 8) {
2889                 memset (line, 32, 44);
2890                 ppp_print_hex (line, buf, 8);
2891                 ppp_print_char (&line[8 * 3], buf, 8);
2892                 printk(KERN_DEBUG "%s\n", line);
2893                 count -= 8;
2894                 buf += 8;
2895         }
2896
2897         if (count > 0) {
2898                 memset (line, 32, 44);
2899                 ppp_print_hex (line, buf, count);
2900                 ppp_print_char (&line[8 * 3], buf, count);
2901                 printk(KERN_DEBUG "%s\n", line);
2902         }
2903 }
2904
2905 /*************************************************************
2906  * Compressor module interface
2907  *************************************************************/
2908
2909 struct compressor_link {
2910         struct compressor_link  *next;
2911         struct compressor       *comp;
2912 };
2913
2914 static struct compressor_link *ppp_compressors = (struct compressor_link *) 0;
2915
2916 static struct compressor *find_compressor (int type)
2917 {
2918         struct compressor_link *lnk;
2919         unsigned long flags;
2920
2921         save_flags(flags);
2922         cli();
2923
2924         lnk = ppp_compressors;
2925         while (lnk != (struct compressor_link *) 0) {
2926                 if ((int) (__u8) lnk->comp->compress_proto == type) {
2927                         restore_flags(flags);
2928                         return lnk->comp;
2929                 }
2930                 lnk = lnk->next;
2931         }
2932
2933         restore_flags(flags);
2934         return (struct compressor *) 0;
2935 }
2936
2937 #ifdef CONFIG_MODULES
2938 static int ppp_register_compressor (struct compressor *cp)
2939 {
2940         struct compressor_link *new;
2941         unsigned long flags;
2942
2943         new = (struct compressor_link *)
2944                 kmalloc (sizeof (struct compressor_link), GFP_KERNEL);
2945
2946         if (new == (struct compressor_link *) 0)
2947                 return 1;
2948
2949         save_flags(flags);
2950         cli();
2951
2952         if (find_compressor (cp->compress_proto)) {
2953                 restore_flags(flags);
2954                 kfree (new);
2955                 return 0;
2956         }
2957
2958         new->next       = ppp_compressors;
2959         new->comp       = cp;
2960         ppp_compressors = new;
2961
2962         restore_flags(flags);
2963         return 0;
2964 }
2965
2966 static void ppp_unregister_compressor (struct compressor *cp)
2967 {
2968         struct compressor_link *prev = (struct compressor_link *) 0;
2969         struct compressor_link *lnk;
2970         unsigned long flags;
2971
2972         save_flags(flags);
2973         cli();
2974
2975         lnk  = ppp_compressors;
2976         while (lnk != (struct compressor_link *) 0) {
2977                 if (lnk->comp == cp) {
2978                         if (prev)
2979                                 prev->next = lnk->next;
2980                         else
2981                                 ppp_compressors = lnk->next;
2982                         kfree (lnk);
2983                         break;
2984                 }
2985                 prev = lnk;
2986                 lnk  = lnk->next;
2987         }
2988         restore_flags(flags);
2989 }
2990 #endif
2991
2992 /*************************************************************
2993  * Module support routines
2994  *************************************************************/
2995
2996 #ifdef MODULE
2997 int
2998 init_module(void)
2999 {
3000         int status;
3001
3002         /* register our line disciplines */
3003         status = ppp_first_time();
3004         if (status != 0)
3005                 printk(KERN_INFO "PPP: ppp_init() failure %d\n", status);
3006 #if LINUX_VERSION_CODE < VERSION(2,1,18)
3007         else
3008                 (void) register_symtab (&ppp_syms);
3009 #endif
3010
3011         return status;
3012 }
3013
3014 void
3015 cleanup_module(void)
3016 {
3017         int status;
3018         struct ppp *ppp, *next_ppp;
3019         int busy = 0;
3020
3021         /*
3022          * Ensure that the devices are not in operation.
3023          */
3024         for (ppp = ppp_list; ppp != 0; ppp = ppp->next) {
3025                 CHECK_PPP_MAGIC(ppp);
3026                 if (ppp->inuse || (ppp->dev.flags & IFF_UP))
3027                         ++busy;
3028         }
3029         if (busy)
3030                 printk(KERN_CRIT "PPP: removing despite %d units in use!\n",
3031                        busy);
3032
3033         /*
3034          * Release the tty registration of the line discipline so that
3035          * ttys can no longer be put into PPP line discipline.
3036          */
3037         status = tty_register_ldisc (N_PPP, NULL);
3038         if (status != 0)
3039                 printk(KERN_ERR
3040                        "PPP: Unable to unregister ppp line discipline "
3041                        "(err = %d)\n", status);
3042         else
3043                 printk(KERN_INFO
3044                        "PPP: ppp line discipline successfully unregistered\n");
3045
3046         /*
3047          * De-register the devices so that there is no problem with them
3048          */
3049         for (ppp = ppp_list; ppp != 0; ppp = next_ppp) {
3050                 next_ppp = ppp->next;
3051                 unregister_netdev(&ppp->dev);
3052                 kfree (ppp);
3053         }
3054 }
3055 #endif