drivers/isdn/i4l/isdn_ppp.c

   1 /* $Id: isdn_ppp.c,v 1.1.2.3 2004/02/10 01:07:13 keil Exp $
   2  *
   3  * Linux ISDN subsystem, functions for synchronous PPP (linklevel).
   4  *
   5  * Copyright 1995,96 by Michael Hipp (Michael.Hipp@student.uni-tuebingen.de)
   6  *
   7  * This software may be used and distributed according to the terms
   8  * of the GNU General Public License, incorporated herein by reference.
   9  *
  10  */
  11
  12 #include <linux/isdn.h>
  13 #include <linux/poll.h>
  14 #include <linux/ppp-comp.h>
  15 #include <linux/slab.h>
  16 #ifdef CONFIG_IPPP_FILTER
  17 #include <linux/filter.h>
  18 #endif
  19
  20 #include "isdn_common.h"
  21 #include "isdn_ppp.h"
  22 #include "isdn_net.h"
  23
  24 #ifndef PPP_IPX
  25 #define PPP_IPX 0x002b
  26 #endif
  27
  28 /* Prototypes */
  29 static int isdn_ppp_fill_rq(unsigned char *buf, int len, int proto, int slot);
  30 static int isdn_ppp_closewait(int slot);
  31 static void isdn_ppp_push_higher(isdn_net_dev *net_dev, isdn_net_local *lp,
  32                                  struct sk_buff *skb, int proto);
  33 static int isdn_ppp_if_get_unit(char *namebuf);
  34 static int isdn_ppp_set_compressor(struct ippp_struct *is, struct isdn_ppp_comp_data *);
  35 static struct sk_buff *isdn_ppp_decompress(struct sk_buff *,
  36                                            struct ippp_struct *, struct ippp_struct *, int *proto);
  37 static void isdn_ppp_receive_ccp(isdn_net_dev *net_dev, isdn_net_local *lp,
  38                                  struct sk_buff *skb, int proto);
  39 static struct sk_buff *isdn_ppp_compress(struct sk_buff *skb_in, int *proto,
  40                                          struct ippp_struct *is, struct ippp_struct *master, int type);
  41 static void isdn_ppp_send_ccp(isdn_net_dev *net_dev, isdn_net_local *lp,
  42                               struct sk_buff *skb);
  43
  44 /* New CCP stuff */
  45 static void isdn_ppp_ccp_kickup(struct ippp_struct *is);
  46 static void isdn_ppp_ccp_xmit_reset(struct ippp_struct *is, int proto,
  47                                     unsigned char code, unsigned char id,
  48                                     unsigned char *data, int len);
  49 static struct ippp_ccp_reset *isdn_ppp_ccp_reset_alloc(struct ippp_struct *is);
  50 static void isdn_ppp_ccp_reset_free(struct ippp_struct *is);
  51 static void isdn_ppp_ccp_reset_free_state(struct ippp_struct *is,
  52                                           unsigned char id);
  53 static void isdn_ppp_ccp_timer_callback(unsigned long closure);
  54 static struct ippp_ccp_reset_state *isdn_ppp_ccp_reset_alloc_state(struct ippp_struct *is,
  55                                                                    unsigned char id);
  56 static void isdn_ppp_ccp_reset_trans(struct ippp_struct *is,
  57                                      struct isdn_ppp_resetparams *rp);
  58 static void isdn_ppp_ccp_reset_ack_rcvd(struct ippp_struct *is,
  59                                         unsigned char id);
  60
  61
  62
  63 #ifdef CONFIG_ISDN_MPP
  64 static ippp_bundle *isdn_ppp_bundle_arr = NULL;
  65
  66 static int isdn_ppp_mp_bundle_array_init(void);
  67 static int isdn_ppp_mp_init(isdn_net_local *lp, ippp_bundle *add_to);
  68 static void isdn_ppp_mp_receive(isdn_net_dev *net_dev, isdn_net_local *lp,
  69                                 struct sk_buff *skb);
  70 static void isdn_ppp_mp_cleanup(isdn_net_local *lp);
  71
  72 static int isdn_ppp_bundle(struct ippp_struct *, int unit);
  73 #endif  /* CONFIG_ISDN_MPP */
  74
  75 char *isdn_ppp_revision = "$Revision: 1.1.2.3 $";
  76
  77 static struct ippp_struct *ippp_table[ISDN_MAX_CHANNELS];
  78
  79 static struct isdn_ppp_compressor *ipc_head = NULL;
  80
  81 /*
  82  * frame log (debug)
  83  */
  84 static void
  85 isdn_ppp_frame_log(char *info, char *data, int len, int maxlen, int unit, int slot)
  86 {
  87         int cnt,
  88                 j,
  89                 i;
  90         char buf[80];
  91
  92         if (len < maxlen)
  93                 maxlen = len;
  94
  95         for (i = 0, cnt = 0; cnt < maxlen; i++) {
  96                 for (j = 0; j < 16 && cnt < maxlen; j++, cnt++)
  97                         sprintf(buf + j * 3, "%02x ", (unsigned char)data[cnt]);
  98                 printk(KERN_DEBUG "[%d/%d].%s[%d]: %s\n", unit, slot, info, i, buf);
  99         }
 100 }
 101
 102 /*
 103  * unbind isdn_net_local <=> ippp-device
 104  * note: it can happen, that we hangup/free the master before the slaves
 105  *       in this case we bind another lp to the master device
 106  */
 107 int
 108 isdn_ppp_free(isdn_net_local *lp)
 109 {
 110         struct ippp_struct *is;
 111
 112         if (lp->ppp_slot < 0 || lp->ppp_slot >= ISDN_MAX_CHANNELS) {
 113                 printk(KERN_ERR "%s: ppp_slot(%d) out of range\n",
 114                        __func__, lp->ppp_slot);
 115                 return 0;
 116         }
 117
 118 #ifdef CONFIG_ISDN_MPP
 119         spin_lock(&lp->netdev->pb->lock);
 120 #endif
 121         isdn_net_rm_from_bundle(lp);
 122 #ifdef CONFIG_ISDN_MPP
 123         if (lp->netdev->pb->ref_ct == 1)        /* last link in queue? */
 124                 isdn_ppp_mp_cleanup(lp);
 125
 126         lp->netdev->pb->ref_ct--;
 127         spin_unlock(&lp->netdev->pb->lock);
 128 #endif /* CONFIG_ISDN_MPP */
 129         if (lp->ppp_slot < 0 || lp->ppp_slot >= ISDN_MAX_CHANNELS) {
 130                 printk(KERN_ERR "%s: ppp_slot(%d) now invalid\n",
 131                        __func__, lp->ppp_slot);
 132                 return 0;
 133         }
 134         is = ippp_table[lp->ppp_slot];
 135         if ((is->state & IPPP_CONNECT))
 136                 isdn_ppp_closewait(lp->ppp_slot);       /* force wakeup on ippp device */
 137         else if (is->state & IPPP_ASSIGNED)
 138                 is->state = IPPP_OPEN;  /* fallback to 'OPEN but not ASSIGNED' state */
 139
 140         if (is->debug & 0x1)
 141                 printk(KERN_DEBUG "isdn_ppp_free %d %lx %lx\n", lp->ppp_slot, (long) lp, (long) is->lp);
 142
 143         is->lp = NULL;          /* link is down .. set lp to NULL */
 144         lp->ppp_slot = -1;      /* is this OK ?? */
 145
 146         return 0;
 147 }
 148
 149 /*
 150  * bind isdn_net_local <=> ippp-device
 151  *
 152  * This function is allways called with holding dev->lock so
 153  * no additional lock is needed
 154  */
 155 int
 156 isdn_ppp_bind(isdn_net_local *lp)
 157 {
 158         int i;
 159         int unit = 0;
 160         struct ippp_struct *is;
 161         int retval;
 162
 163         if (lp->pppbind < 0) {  /* device bounded to ippp device ? */
 164                 isdn_net_dev *net_dev = dev->netdev;
 165                 char exclusive[ISDN_MAX_CHANNELS];      /* exclusive flags */
 166                 memset(exclusive, 0, ISDN_MAX_CHANNELS);
 167                 while (net_dev) {       /* step through net devices to find exclusive minors */
 168                         isdn_net_local *lp = net_dev->local;
 169                         if (lp->pppbind >= 0)
 170                                 exclusive[lp->pppbind] = 1;
 171                         net_dev = net_dev->next;
 172                 }
 173                 /*
 174                  * search a free device / slot
 175                  */
 176                 for (i = 0; i < ISDN_MAX_CHANNELS; i++) {
 177                         if (ippp_table[i]->state == IPPP_OPEN && !exclusive[ippp_table[i]->minor]) {    /* OPEN, but not connected! */
 178                                 break;
 179                         }
 180                 }
 181         } else {
 182                 for (i = 0; i < ISDN_MAX_CHANNELS; i++) {
 183                         if (ippp_table[i]->minor == lp->pppbind &&
 184                             (ippp_table[i]->state & IPPP_OPEN) == IPPP_OPEN)
 185                                 break;
 186                 }
 187         }
 188
 189         if (i >= ISDN_MAX_CHANNELS) {
 190                 printk(KERN_WARNING "isdn_ppp_bind: Can't find a (free) connection to the ipppd daemon.\n");
 191                 retval = -1;
 192                 goto out;
 193         }
 194         /* get unit number from interface name .. ugly! */
 195         unit = isdn_ppp_if_get_unit(lp->netdev->dev->name);
 196         if (unit < 0) {
 197                 printk(KERN_ERR "isdn_ppp_bind: illegal interface name %s.\n",
 198                        lp->netdev->dev->name);
 199                 retval = -1;
 200                 goto out;
 201         }
 202
 203         lp->ppp_slot = i;
 204         is = ippp_table[i];
 205         is->lp = lp;
 206         is->unit = unit;
 207         is->state = IPPP_OPEN | IPPP_ASSIGNED;  /* assigned to a netdevice but not connected */
 208 #ifdef CONFIG_ISDN_MPP
 209         retval = isdn_ppp_mp_init(lp, NULL);
 210         if (retval < 0)
 211                 goto out;
 212 #endif /* CONFIG_ISDN_MPP */
 213
 214         retval = lp->ppp_slot;
 215
 216 out:
 217         return retval;
 218 }
 219
 220 /*
 221  * kick the ipppd on the device
 222  * (wakes up daemon after B-channel connect)
 223  */
 224
 225 void
 226 isdn_ppp_wakeup_daemon(isdn_net_local *lp)
 227 {
 228         if (lp->ppp_slot < 0 || lp->ppp_slot >= ISDN_MAX_CHANNELS) {
 229                 printk(KERN_ERR "%s: ppp_slot(%d) out of range\n",
 230                        __func__, lp->ppp_slot);
 231                 return;
 232         }
 233         ippp_table[lp->ppp_slot]->state = IPPP_OPEN | IPPP_CONNECT | IPPP_NOBLOCK;
 234         wake_up_interruptible(&ippp_table[lp->ppp_slot]->wq);
 235 }
 236
 237 /*
 238  * there was a hangup on the netdevice
 239  * force wakeup of the ippp device
 240  * go into 'device waits for release' state
 241  */
 242 static int
 243 isdn_ppp_closewait(int slot)
 244 {
 245         struct ippp_struct *is;
 246
 247         if (slot < 0 || slot >= ISDN_MAX_CHANNELS) {
 248                 printk(KERN_ERR "%s: slot(%d) out of range\n",
 249                        __func__, slot);
 250                 return 0;
 251         }
 252         is = ippp_table[slot];
 253         if (is->state)
 254                 wake_up_interruptible(&is->wq);
 255         is->state = IPPP_CLOSEWAIT;
 256         return 1;
 257 }
 258
 259 /*
 260  * isdn_ppp_find_slot / isdn_ppp_free_slot
 261  */
 262
 263 static int
 264 isdn_ppp_get_slot(void)
 265 {
 266         int i;
 267         for (i = 0; i < ISDN_MAX_CHANNELS; i++) {
 268                 if (!ippp_table[i]->state)
 269                         return i;
 270         }
 271         return -1;
 272 }
 273
 274 /*
 275  * isdn_ppp_open
 276  */
 277
 278 int
 279 isdn_ppp_open(int min, struct file *file)
 280 {
 281         int slot;
 282         struct ippp_struct *is;
 283
 284         if (min < 0 || min >= ISDN_MAX_CHANNELS)
 285                 return -ENODEV;
 286
 287         slot = isdn_ppp_get_slot();
 288         if (slot < 0) {
 289                 return -EBUSY;
 290         }
 291         is = file->private_data = ippp_table[slot];
 292
 293         printk(KERN_DEBUG "ippp, open, slot: %d, minor: %d, state: %04x\n",
 294                slot, min, is->state);
 295
 296         /* compression stuff */
 297         is->link_compressor   = is->compressor = NULL;
 298         is->link_decompressor = is->decompressor = NULL;
 299         is->link_comp_stat    = is->comp_stat = NULL;
 300         is->link_decomp_stat  = is->decomp_stat = NULL;
 301         is->compflags = 0;
 302
 303         is->reset = isdn_ppp_ccp_reset_alloc(is);
 304
 305         is->lp = NULL;
 306         is->mp_seqno = 0;       /* MP sequence number */
 307         is->pppcfg = 0;         /* ppp configuration */
 308         is->mpppcfg = 0;        /* mppp configuration */
 309         is->last_link_seqno = -1;       /* MP: maybe set to Bundle-MIN, when joining a bundle ?? */
 310         is->unit = -1;          /* set, when we have our interface */
 311         is->mru = 1524;         /* MRU, default 1524 */
 312         is->maxcid = 16;        /* VJ: maxcid */
 313         is->tk = current;
 314         init_waitqueue_head(&is->wq);
 315         is->first = is->rq + NUM_RCV_BUFFS - 1; /* receive queue */
 316         is->last = is->rq;
 317         is->minor = min;
 318 #ifdef CONFIG_ISDN_PPP_VJ
 319         /*
 320          * VJ header compression init
 321          */
 322         is->slcomp = slhc_init(16, 16); /* not necessary for 2. link in bundle */
 323 #endif
 324 #ifdef CONFIG_IPPP_FILTER
 325         is->pass_filter = NULL;
 326         is->active_filter = NULL;
 327 #endif
 328         is->state = IPPP_OPEN;
 329
 330         return 0;
 331 }
 332
 333 /*
 334  * release ippp device
 335  */
 336 void
 337 isdn_ppp_release(int min, struct file *file)
 338 {
 339         int i;
 340         struct ippp_struct *is;
 341
 342         if (min < 0 || min >= ISDN_MAX_CHANNELS)
 343                 return;
 344         is = file->private_data;
 345
 346         if (!is) {
 347                 printk(KERN_ERR "%s: no file->private_data\n", __func__);
 348                 return;
 349         }
 350         if (is->debug & 0x1)
 351                 printk(KERN_DEBUG "ippp: release, minor: %d %lx\n", min, (long) is->lp);
 352
 353         if (is->lp) {           /* a lp address says: this link is still up */
 354                 isdn_net_dev *p = is->lp->netdev;
 355
 356                 if (!p) {
 357                         printk(KERN_ERR "%s: no lp->netdev\n", __func__);
 358                         return;
 359                 }
 360                 is->state &= ~IPPP_CONNECT;     /* -> effect: no call of wakeup */
 361                 /*
 362                  * isdn_net_hangup() calls isdn_ppp_free()
 363                  * isdn_ppp_free() sets is->lp to NULL and lp->ppp_slot to -1
 364                  * removing the IPPP_CONNECT flag omits calling of isdn_ppp_wakeup_daemon()
 365                  */
 366                 isdn_net_hangup(p->dev);
 367         }
 368         for (i = 0; i < NUM_RCV_BUFFS; i++) {
 369                 kfree(is->rq[i].buf);
 370                 is->rq[i].buf = NULL;
 371         }
 372         is->first = is->rq + NUM_RCV_BUFFS - 1; /* receive queue */
 373         is->last = is->rq;
 374
 375 #ifdef CONFIG_ISDN_PPP_VJ
 376 /* TODO: if this was the previous master: link the slcomp to the new master */
 377         slhc_free(is->slcomp);
 378         is->slcomp = NULL;
 379 #endif
 380 #ifdef CONFIG_IPPP_FILTER
 381         if (is->pass_filter) {
 382                 sk_unattached_filter_destroy(is->pass_filter);
 383                 is->pass_filter = NULL;
 384         }
 385
 386         if (is->active_filter) {
 387                 sk_unattached_filter_destroy(is->active_filter);
 388                 is->active_filter = NULL;
 389         }
 390 #endif
 391
 392 /* TODO: if this was the previous master: link the stuff to the new master */
 393         if (is->comp_stat)
 394                 is->compressor->free(is->comp_stat);
 395         if (is->link_comp_stat)
 396                 is->link_compressor->free(is->link_comp_stat);
 397         if (is->link_decomp_stat)
 398                 is->link_decompressor->free(is->link_decomp_stat);
 399         if (is->decomp_stat)
 400                 is->decompressor->free(is->decomp_stat);
 401         is->compressor   = is->link_compressor   = NULL;
 402         is->decompressor = is->link_decompressor = NULL;
 403         is->comp_stat    = is->link_comp_stat    = NULL;
 404         is->decomp_stat  = is->link_decomp_stat  = NULL;
 405
 406         /* Clean up if necessary */
 407         if (is->reset)
 408                 isdn_ppp_ccp_reset_free(is);
 409
 410         /* this slot is ready for new connections */
 411         is->state = 0;
 412 }
 413
 414 /*
 415  * get_arg .. ioctl helper
 416  */
 417 static int
 418 get_arg(void __user *b, void *val, int len)
 419 {
 420         if (len <= 0)
 421                 len = sizeof(void *);
 422         if (copy_from_user(val, b, len))
 423                 return -EFAULT;
 424         return 0;
 425 }
 426
 427 /*
 428  * set arg .. ioctl helper
 429  */
 430 static int
 431 set_arg(void __user *b, void *val, int len)
 432 {
 433         if (len <= 0)
 434                 len = sizeof(void *);
 435         if (copy_to_user(b, val, len))
 436                 return -EFAULT;
 437         return 0;
 438 }
 439
 440 #ifdef CONFIG_IPPP_FILTER
 441 static int get_filter(void __user *arg, struct sock_filter **p)
 442 {
 443         struct sock_fprog uprog;
 444         struct sock_filter *code = NULL;
 445         int len;
 446
 447         if (copy_from_user(&uprog, arg, sizeof(uprog)))
 448                 return -EFAULT;
 449
 450         if (!uprog.len) {
 451                 *p = NULL;
 452                 return 0;
 453         }
 454
 455         /* uprog.len is unsigned short, so no overflow here */
 456         len = uprog.len * sizeof(struct sock_filter);
 457         code = memdup_user(uprog.filter, len);
 458         if (IS_ERR(code))
 459                 return PTR_ERR(code);
 460
 461         *p = code;
 462         return uprog.len;
 463 }
 464 #endif /* CONFIG_IPPP_FILTER */
 465
 466 /*
 467  * ippp device ioctl
 468  */
 469 int
 470 isdn_ppp_ioctl(int min, struct file *file, unsigned int cmd, unsigned long arg)
 471 {
 472         unsigned long val;
 473         int r, i, j;
 474         struct ippp_struct *is;
 475         isdn_net_local *lp;
 476         struct isdn_ppp_comp_data data;
 477         void __user *argp = (void __user *)arg;
 478
 479         is = file->private_data;
 480         lp = is->lp;
 481
 482         if (is->debug & 0x1)
 483                 printk(KERN_DEBUG "isdn_ppp_ioctl: minor: %d cmd: %x state: %x\n", min, cmd, is->state);
 484
 485         if (!(is->state & IPPP_OPEN))
 486                 return -EINVAL;
 487
 488         switch (cmd) {
 489         case PPPIOCBUNDLE:
 490 #ifdef CONFIG_ISDN_MPP
 491                 if (!(is->state & IPPP_CONNECT))
 492                         return -EINVAL;
 493                 if ((r = get_arg(argp, &val, sizeof(val))))
 494                         return r;
 495                 printk(KERN_DEBUG "iPPP-bundle: minor: %d, slave unit: %d, master unit: %d\n",
 496                        (int) min, (int) is->unit, (int) val);
 497                 return isdn_ppp_bundle(is, val);
 498 #else
 499                 return -1;
 500 #endif
 501                 break;
 502         case PPPIOCGUNIT:       /* get ppp/isdn unit number */
 503                 if ((r = set_arg(argp, &is->unit, sizeof(is->unit))))
 504                         return r;
 505                 break;
 506         case PPPIOCGIFNAME:
 507                 if (!lp)
 508                         return -EINVAL;
 509                 if ((r = set_arg(argp, lp->netdev->dev->name,
 510                                  strlen(lp->netdev->dev->name))))
 511                         return r;
 512                 break;
 513         case PPPIOCGMPFLAGS:    /* get configuration flags */
 514                 if ((r = set_arg(argp, &is->mpppcfg, sizeof(is->mpppcfg))))
 515                         return r;
 516                 break;
 517         case PPPIOCSMPFLAGS:    /* set configuration flags */
 518                 if ((r = get_arg(argp, &val, sizeof(val))))
 519                         return r;
 520                 is->mpppcfg = val;
 521                 break;
 522         case PPPIOCGFLAGS:      /* get configuration flags */
 523                 if ((r = set_arg(argp, &is->pppcfg, sizeof(is->pppcfg))))
 524                         return r;
 525                 break;
 526         case PPPIOCSFLAGS:      /* set configuration flags */
 527                 if ((r = get_arg(argp, &val, sizeof(val)))) {
 528                         return r;
 529                 }
 530                 if (val & SC_ENABLE_IP && !(is->pppcfg & SC_ENABLE_IP) && (is->state & IPPP_CONNECT)) {
 531                         if (lp) {
 532                                 /* OK .. we are ready to send buffers */
 533                                 is->pppcfg = val; /* isdn_ppp_xmit test for SC_ENABLE_IP !!! */
 534                                 netif_wake_queue(lp->netdev->dev);
 535                                 break;
 536                         }
 537                 }
 538                 is->pppcfg = val;
 539                 break;
 540         case PPPIOCGIDLE:       /* get idle time information */
 541                 if (lp) {
 542                         struct ppp_idle pidle;
 543                         pidle.xmit_idle = pidle.recv_idle = lp->huptimer;
 544                         if ((r = set_arg(argp, &pidle, sizeof(struct ppp_idle))))
 545                                 return r;
 546                 }
 547                 break;
 548         case PPPIOCSMRU:        /* set receive unit size for PPP */
 549                 if ((r = get_arg(argp, &val, sizeof(val))))
 550                         return r;
 551                 is->mru = val;
 552                 break;
 553         case PPPIOCSMPMRU:
 554                 break;
 555         case PPPIOCSMPMTU:
 556                 break;
 557         case PPPIOCSMAXCID:     /* set the maximum compression slot id */
 558                 if ((r = get_arg(argp, &val, sizeof(val))))
 559                         return r;
 560                 val++;
 561                 if (is->maxcid != val) {
 562 #ifdef CONFIG_ISDN_PPP_VJ
 563                         struct slcompress *sltmp;
 564 #endif
 565                         if (is->debug & 0x1)
 566                                 printk(KERN_DEBUG "ippp, ioctl: changed MAXCID to %ld\n", val);
 567                         is->maxcid = val;
 568 #ifdef CONFIG_ISDN_PPP_VJ
 569                         sltmp = slhc_init(16, val);
 570                         if (!sltmp) {
 571                                 printk(KERN_ERR "ippp, can't realloc slhc struct\n");
 572                                 return -ENOMEM;
 573                         }
 574                         if (is->slcomp)
 575                                 slhc_free(is->slcomp);
 576                         is->slcomp = sltmp;
 577 #endif
 578                 }
 579                 break;
 580         case PPPIOCGDEBUG:
 581                 if ((r = set_arg(argp, &is->debug, sizeof(is->debug))))
 582                         return r;
 583                 break;
 584         case PPPIOCSDEBUG:
 585                 if ((r = get_arg(argp, &val, sizeof(val))))
 586                         return r;
 587                 is->debug = val;
 588                 break;
 589         case PPPIOCGCOMPRESSORS:
 590         {
 591                 unsigned long protos[8] = {0,};
 592                 struct isdn_ppp_compressor *ipc = ipc_head;
 593                 while (ipc) {
 594                         j = ipc->num / (sizeof(long) * 8);
 595                         i = ipc->num % (sizeof(long) * 8);
 596                         if (j < 8)
 597                                 protos[j] |= (1UL << i);
 598                         ipc = ipc->next;
 599                 }
 600                 if ((r = set_arg(argp, protos, 8 * sizeof(long))))
 601                         return r;
 602         }
 603         break;
 604         case PPPIOCSCOMPRESSOR:
 605                 if ((r = get_arg(argp, &data, sizeof(struct isdn_ppp_comp_data))))
 606                         return r;
 607                 return isdn_ppp_set_compressor(is, &data);
 608         case PPPIOCGCALLINFO:
 609         {
 610                 struct pppcallinfo pci;
 611                 memset((char *)&pci, 0, sizeof(struct pppcallinfo));
 612                 if (lp)
 613                 {
 614                         strncpy(pci.local_num, lp->msn, 63);
 615                         if (lp->dial) {
 616                                 strncpy(pci.remote_num, lp->dial->num, 63);
 617                         }
 618                         pci.charge_units = lp->charge;
 619                         if (lp->outgoing)
 620                                 pci.calltype = CALLTYPE_OUTGOING;
 621                         else
 622                                 pci.calltype = CALLTYPE_INCOMING;
 623                         if (lp->flags & ISDN_NET_CALLBACK)
 624                                 pci.calltype |= CALLTYPE_CALLBACK;
 625                 }
 626                 return set_arg(argp, &pci, sizeof(struct pppcallinfo));
 627         }
 628 #ifdef CONFIG_IPPP_FILTER
 629         case PPPIOCSPASS:
 630         {
 631                 struct sock_fprog_kern fprog;
 632                 struct sock_filter *code;
 633                 int err, len = get_filter(argp, &code);
 634
 635                 if (len < 0)
 636                         return len;
 637
 638                 fprog.len = len;
 639                 fprog.filter = code;
 640
 641                 if (is->pass_filter)
 642                         sk_unattached_filter_destroy(is->pass_filter);
 643                 err = sk_unattached_filter_create(&is->pass_filter, &fprog);
 644                 kfree(code);
 645
 646                 return err;
 647         }
 648         case PPPIOCSACTIVE:
 649         {
 650                 struct sock_fprog_kern fprog;
 651                 struct sock_filter *code;
 652                 int err, len = get_filter(argp, &code);
 653
 654                 if (len < 0)
 655                         return len;
 656
 657                 fprog.len = len;
 658                 fprog.filter = code;
 659
 660                 if (is->active_filter)
 661                         sk_unattached_filter_destroy(is->active_filter);
 662                 err = sk_unattached_filter_create(&is->active_filter, &fprog);
 663                 kfree(code);
 664
 665                 return err;
 666         }
 667 #endif /* CONFIG_IPPP_FILTER */
 668         default:
 669                 break;
 670         }
 671         return 0;
 672 }
 673
 674 unsigned int
 675 isdn_ppp_poll(struct file *file, poll_table *wait)
 676 {
 677         u_int mask;
 678         struct ippp_buf_queue *bf, *bl;
 679         u_long flags;
 680         struct ippp_struct *is;
 681
 682         is = file->private_data;
 683
 684         if (is->debug & 0x2)
 685                 printk(KERN_DEBUG "isdn_ppp_poll: minor: %d\n",
 686                        iminor(file_inode(file)));
 687
 688         /* just registers wait_queue hook. This doesn't really wait. */
 689         poll_wait(file, &is->wq, wait);
 690
 691         if (!(is->state & IPPP_OPEN)) {
 692                 if (is->state == IPPP_CLOSEWAIT)
 693                         return POLLHUP;
 694                 printk(KERN_DEBUG "isdn_ppp: device not open\n");
 695                 return POLLERR;
 696         }
 697         /* we're always ready to send .. */
 698         mask = POLLOUT | POLLWRNORM;
 699
 700         spin_lock_irqsave(&is->buflock, flags);
 701         bl = is->last;
 702         bf = is->first;
 703         /*
 704          * if IPPP_NOBLOCK is set we return even if we have nothing to read
 705          */
 706         if (bf->next != bl || (is->state & IPPP_NOBLOCK)) {
 707                 is->state &= ~IPPP_NOBLOCK;
 708                 mask |= POLLIN | POLLRDNORM;
 709         }
 710         spin_unlock_irqrestore(&is->buflock, flags);
 711         return mask;
 712 }
 713
 714 /*
 715  *  fill up isdn_ppp_read() queue ..
 716  */
 717
 718 static int
 719 isdn_ppp_fill_rq(unsigned char *buf, int len, int proto, int slot)
 720 {
 721         struct ippp_buf_queue *bf, *bl;
 722         u_long flags;
 723         u_char *nbuf;
 724         struct ippp_struct *is;
 725
 726         if (slot < 0 || slot >= ISDN_MAX_CHANNELS) {
 727                 printk(KERN_WARNING "ippp: illegal slot(%d).\n", slot);
 728                 return 0;
 729         }
 730         is = ippp_table[slot];
 731
 732         if (!(is->state & IPPP_CONNECT)) {
 733                 printk(KERN_DEBUG "ippp: device not activated.\n");
 734                 return 0;
 735         }
 736         nbuf = kmalloc(len + 4, GFP_ATOMIC);
 737         if (!nbuf) {
 738                 printk(KERN_WARNING "ippp: Can't alloc buf\n");
 739                 return 0;
 740         }
 741         nbuf[0] = PPP_ALLSTATIONS;
 742         nbuf[1] = PPP_UI;
 743         nbuf[2] = proto >> 8;
 744         nbuf[3] = proto & 0xff;
 745         memcpy(nbuf + 4, buf, len);
 746
 747         spin_lock_irqsave(&is->buflock, flags);
 748         bf = is->first;
 749         bl = is->last;
 750
 751         if (bf == bl) {
 752                 printk(KERN_WARNING "ippp: Queue is full; discarding first buffer\n");
 753                 bf = bf->next;
 754                 kfree(bf->buf);
 755                 is->first = bf;
 756         }
 757         bl->buf = (char *) nbuf;
 758         bl->len = len + 4;
 759
 760         is->last = bl->next;
 761         spin_unlock_irqrestore(&is->buflock, flags);
 762         wake_up_interruptible(&is->wq);
 763         return len;
 764 }
 765
 766 /*
 767  * read() .. non-blocking: ipppd calls it only after select()
 768  *           reports, that there is data
 769  */
 770
 771 int
 772 isdn_ppp_read(int min, struct file *file, char __user *buf, int count)
 773 {
 774         struct ippp_struct *is;
 775         struct ippp_buf_queue *b;
 776         u_long flags;
 777         u_char *save_buf;
 778
 779         is = file->private_data;
 780
 781         if (!(is->state & IPPP_OPEN))
 782                 return 0;
 783
 784         if (!access_ok(VERIFY_WRITE, buf, count))
 785                 return -EFAULT;
 786
 787         spin_lock_irqsave(&is->buflock, flags);
 788         b = is->first->next;
 789         save_buf = b->buf;
 790         if (!save_buf) {
 791                 spin_unlock_irqrestore(&is->buflock, flags);
 792                 return -EAGAIN;
 793         }
 794         if (b->len < count)
 795                 count = b->len;
 796         b->buf = NULL;
 797         is->first = b;
 798
 799         spin_unlock_irqrestore(&is->buflock, flags);
 800         if (copy_to_user(buf, save_buf, count))
 801                 count = -EFAULT;
 802         kfree(save_buf);
 803
 804         return count;
 805 }
 806
 807 /*
 808  * ipppd wanna write a packet to the card .. non-blocking
 809  */
 810
 811 int
 812 isdn_ppp_write(int min, struct file *file, const char __user *buf, int count)
 813 {
 814         isdn_net_local *lp;
 815         struct ippp_struct *is;
 816         int proto;
 817         unsigned char protobuf[4];
 818
 819         is = file->private_data;
 820
 821         if (!(is->state & IPPP_CONNECT))
 822                 return 0;
 823
 824         lp = is->lp;
 825
 826         /* -> push it directly to the lowlevel interface */
 827
 828         if (!lp)
 829                 printk(KERN_DEBUG "isdn_ppp_write: lp == NULL\n");
 830         else {
 831                 /*
 832                  * Don't reset huptimer for
 833                  * LCP packets. (Echo requests).
 834                  */
 835                 if (copy_from_user(protobuf, buf, 4))
 836                         return -EFAULT;
 837                 proto = PPP_PROTOCOL(protobuf);
 838                 if (proto != PPP_LCP)
 839                         lp->huptimer = 0;
 840
 841                 if (lp->isdn_device < 0 || lp->isdn_channel < 0)
 842                         return 0;
 843
 844                 if ((dev->drv[lp->isdn_device]->flags & DRV_FLAG_RUNNING) &&
 845                     lp->dialstate == 0 &&
 846                     (lp->flags & ISDN_NET_CONNECTED)) {
 847                         unsigned short hl;
 848                         struct sk_buff *skb;
 849                         /*
 850                          * we need to reserve enough space in front of
 851                          * sk_buff. old call to dev_alloc_skb only reserved
 852                          * 16 bytes, now we are looking what the driver want
 853                          */
 854                         hl = dev->drv[lp->isdn_device]->interface->hl_hdrlen;
 855                         skb = alloc_skb(hl + count, GFP_ATOMIC);
 856                         if (!skb) {
 857                                 printk(KERN_WARNING "isdn_ppp_write: out of memory!\n");
 858                                 return count;
 859                         }
 860                         skb_reserve(skb, hl);
 861                         if (copy_from_user(skb_put(skb, count), buf, count))
 862                         {
 863                                 kfree_skb(skb);
 864                                 return -EFAULT;
 865                         }
 866                         if (is->debug & 0x40) {
 867                                 printk(KERN_DEBUG "ppp xmit: len %d\n", (int) skb->len);
 868                                 isdn_ppp_frame_log("xmit", skb->data, skb->len, 32, is->unit, lp->ppp_slot);
 869                         }
 870
 871                         isdn_ppp_send_ccp(lp->netdev, lp, skb); /* keeps CCP/compression states in sync */
 872
 873                         isdn_net_write_super(lp, skb);
 874                 }
 875         }
 876         return count;
 877 }
 878
 879 /*
 880  * init memory, structures etc.
 881  */
 882
 883 int
 884 isdn_ppp_init(void)
 885 {
 886         int i,
 887                 j;
 888
 889 #ifdef CONFIG_ISDN_MPP
 890         if (isdn_ppp_mp_bundle_array_init() < 0)
 891                 return -ENOMEM;
 892 #endif /* CONFIG_ISDN_MPP */
 893
 894         for (i = 0; i < ISDN_MAX_CHANNELS; i++) {
 895                 if (!(ippp_table[i] = kzalloc(sizeof(struct ippp_struct), GFP_KERNEL))) {
 896                         printk(KERN_WARNING "isdn_ppp_init: Could not alloc ippp_table\n");
 897                         for (j = 0; j < i; j++)
 898                                 kfree(ippp_table[j]);
 899                         return -1;
 900                 }
 901                 spin_lock_init(&ippp_table[i]->buflock);
 902                 ippp_table[i]->state = 0;
 903                 ippp_table[i]->first = ippp_table[i]->rq + NUM_RCV_BUFFS - 1;
 904                 ippp_table[i]->last = ippp_table[i]->rq;
 905
 906                 for (j = 0; j < NUM_RCV_BUFFS; j++) {
 907                         ippp_table[i]->rq[j].buf = NULL;
 908                         ippp_table[i]->rq[j].last = ippp_table[i]->rq +
 909                                 (NUM_RCV_BUFFS + j - 1) % NUM_RCV_BUFFS;
 910                         ippp_table[i]->rq[j].next = ippp_table[i]->rq + (j + 1) % NUM_RCV_BUFFS;
 911                 }
 912         }
 913         return 0;
 914 }
 915
 916 void
 917 isdn_ppp_cleanup(void)
 918 {
 919         int i;
 920
 921         for (i = 0; i < ISDN_MAX_CHANNELS; i++)
 922                 kfree(ippp_table[i]);
 923
 924 #ifdef CONFIG_ISDN_MPP
 925         kfree(isdn_ppp_bundle_arr);
 926 #endif /* CONFIG_ISDN_MPP */
 927
 928 }
 929
 930 /*
 931  * check for address/control field and skip if allowed
 932  * retval != 0 -> discard packet silently
 933  */
 934 static int isdn_ppp_skip_ac(struct ippp_struct *is, struct sk_buff *skb)
 935 {
 936         if (skb->len < 1)
 937                 return -1;
 938
 939         if (skb->data[0] == 0xff) {
 940                 if (skb->len < 2)
 941                         return -1;
 942
 943                 if (skb->data[1] != 0x03)
 944                         return -1;
 945
 946                 // skip address/control (AC) field
 947                 skb_pull(skb, 2);
 948         } else {
 949                 if (is->pppcfg & SC_REJ_COMP_AC)
 950                         // if AC compression was not negotiated, but used, discard packet
 951                         return -1;
 952         }
 953         return 0;
 954 }
 955
 956 /*
 957  * get the PPP protocol header and pull skb
 958  * retval < 0 -> discard packet silently
 959  */
 960 static int isdn_ppp_strip_proto(struct sk_buff *skb)
 961 {
 962         int proto;
 963
 964         if (skb->len < 1)
 965                 return -1;
 966
 967         if (skb->data[0] & 0x1) {
 968                 // protocol field is compressed
 969                 proto = skb->data[0];
 970                 skb_pull(skb, 1);
 971         } else {
 972                 if (skb->len < 2)
 973                         return -1;
 974                 proto = ((int) skb->data[0] << 8) + skb->data[1];
 975                 skb_pull(skb, 2);
 976         }
 977         return proto;
 978 }
 979
 980
 981 /*
 982  * handler for incoming packets on a syncPPP interface
 983  */
 984 void isdn_ppp_receive(isdn_net_dev *net_dev, isdn_net_local *lp, struct sk_buff *skb)
 985 {
 986         struct ippp_struct *is;
 987         int slot;
 988         int proto;
 989
 990         BUG_ON(net_dev->local->master); // we're called with the master device always
 991
 992         slot = lp->ppp_slot;
 993         if (slot < 0 || slot >= ISDN_MAX_CHANNELS) {
 994                 printk(KERN_ERR "isdn_ppp_receive: lp->ppp_slot(%d)\n",
 995                        lp->ppp_slot);
 996                 kfree_skb(skb);
 997                 return;
 998         }
 999         is = ippp_table[slot];
1000
1001         if (is->debug & 0x4) {
1002                 printk(KERN_DEBUG "ippp_receive: is:%08lx lp:%08lx slot:%d unit:%d len:%d\n",
1003                        (long)is, (long)lp, lp->ppp_slot, is->unit, (int)skb->len);
1004                 isdn_ppp_frame_log("receive", skb->data, skb->len, 32, is->unit, lp->ppp_slot);
1005         }
1006
1007         if (isdn_ppp_skip_ac(is, skb) < 0) {
1008                 kfree_skb(skb);
1009                 return;
1010         }
1011         proto = isdn_ppp_strip_proto(skb);
1012         if (proto < 0) {
1013                 kfree_skb(skb);
1014                 return;
1015         }
1016
1017 #ifdef CONFIG_ISDN_MPP
1018         if (is->compflags & SC_LINK_DECOMP_ON) {
1019                 skb = isdn_ppp_decompress(skb, is, NULL, &proto);
1020                 if (!skb) // decompression error
1021                         return;
1022         }
1023
1024         if (!(is->mpppcfg & SC_REJ_MP_PROT)) { // we agreed to receive MPPP
1025                 if (proto == PPP_MP) {
1026                         isdn_ppp_mp_receive(net_dev, lp, skb);
1027                         return;
1028                 }
1029         }
1030 #endif
1031         isdn_ppp_push_higher(net_dev, lp, skb, proto);
1032 }
1033
1034 /*
1035  * we receive a reassembled frame, MPPP has been taken care of before.
1036  * address/control and protocol have been stripped from the skb
1037  * note: net_dev has to be master net_dev
1038  */
1039 static void
1040 isdn_ppp_push_higher(isdn_net_dev *net_dev, isdn_net_local *lp, struct sk_buff *skb, int proto)
1041 {
1042         struct net_device *dev = net_dev->dev;
1043         struct ippp_struct *is, *mis;
1044         isdn_net_local *mlp = NULL;
1045         int slot;
1046
1047         slot = lp->ppp_slot;
1048         if (slot < 0 || slot >= ISDN_MAX_CHANNELS) {
1049                 printk(KERN_ERR "isdn_ppp_push_higher: lp->ppp_slot(%d)\n",
1050                        lp->ppp_slot);
1051                 goto drop_packet;
1052         }
1053         is = ippp_table[slot];
1054
1055         if (lp->master) { // FIXME?
1056                 mlp = ISDN_MASTER_PRIV(lp);
1057                 slot = mlp->ppp_slot;
1058                 if (slot < 0 || slot >= ISDN_MAX_CHANNELS) {
1059                         printk(KERN_ERR "isdn_ppp_push_higher: master->ppp_slot(%d)\n",
1060                                lp->ppp_slot);
1061                         goto drop_packet;
1062                 }
1063         }
1064         mis = ippp_table[slot];
1065
1066         if (is->debug & 0x10) {
1067                 printk(KERN_DEBUG "push, skb %d %04x\n", (int) skb->len, proto);
1068                 isdn_ppp_frame_log("rpush", skb->data, skb->len, 32, is->unit, lp->ppp_slot);
1069         }
1070         if (mis->compflags & SC_DECOMP_ON) {
1071                 skb = isdn_ppp_decompress(skb, is, mis, &proto);
1072                 if (!skb) // decompression error
1073                         return;
1074         }
1075         switch (proto) {
1076         case PPP_IPX:  /* untested */
1077                 if (is->debug & 0x20)
1078                         printk(KERN_DEBUG "isdn_ppp: IPX\n");
1079                 skb->protocol = htons(ETH_P_IPX);
1080                 break;
1081         case PPP_IP:
1082                 if (is->debug & 0x20)
1083                         printk(KERN_DEBUG "isdn_ppp: IP\n");
1084                 skb->protocol = htons(ETH_P_IP);
1085                 break;
1086         case PPP_COMP:
1087         case PPP_COMPFRAG:
1088                 printk(KERN_INFO "isdn_ppp: unexpected compressed frame dropped\n");
1089                 goto drop_packet;
1090 #ifdef CONFIG_ISDN_PPP_VJ
1091         case PPP_VJC_UNCOMP:
1092                 if (is->debug & 0x20)
1093                         printk(KERN_DEBUG "isdn_ppp: VJC_UNCOMP\n");
1094                 if (net_dev->local->ppp_slot < 0) {
1095                         printk(KERN_ERR "%s: net_dev->local->ppp_slot(%d) out of range\n",
1096                                __func__, net_dev->local->ppp_slot);
1097                         goto drop_packet;
1098                 }
1099                 if (slhc_remember(ippp_table[net_dev->local->ppp_slot]->slcomp, skb->data, skb->len) <= 0) {
1100                         printk(KERN_WARNING "isdn_ppp: received illegal VJC_UNCOMP frame!\n");
1101                         goto drop_packet;
1102                 }
1103                 skb->protocol = htons(ETH_P_IP);
1104                 break;
1105         case PPP_VJC_COMP:
1106                 if (is->debug & 0x20)
1107                         printk(KERN_DEBUG "isdn_ppp: VJC_COMP\n");
1108                 {
1109                         struct sk_buff *skb_old = skb;
1110                         int pkt_len;
1111                         skb = dev_alloc_skb(skb_old->len + 128);
1112
1113                         if (!skb) {
1114                                 printk(KERN_WARNING "%s: Memory squeeze, dropping packet.\n", dev->name);
1115                                 skb = skb_old;
1116                                 goto drop_packet;
1117                         }
1118                         skb_put(skb, skb_old->len + 128);
1119                         skb_copy_from_linear_data(skb_old, skb->data,
1120                                                   skb_old->len);
1121                         if (net_dev->local->ppp_slot < 0) {
1122                                 printk(KERN_ERR "%s: net_dev->local->ppp_slot(%d) out of range\n",
1123                                        __func__, net_dev->local->ppp_slot);
1124                                 goto drop_packet;
1125                         }
1126                         pkt_len = slhc_uncompress(ippp_table[net_dev->local->ppp_slot]->slcomp,
1127                                                   skb->data, skb_old->len);
1128                         kfree_skb(skb_old);
1129                         if (pkt_len < 0)
1130                                 goto drop_packet;
1131
1132                         skb_trim(skb, pkt_len);
1133                         skb->protocol = htons(ETH_P_IP);
1134                 }
1135                 break;
1136 #endif
1137         case PPP_CCP:
1138         case PPP_CCPFRAG:
1139                 isdn_ppp_receive_ccp(net_dev, lp, skb, proto);
1140                 /* Dont pop up ResetReq/Ack stuff to the daemon any
1141                    longer - the job is done already */
1142                 if (skb->data[0] == CCP_RESETREQ ||
1143                     skb->data[0] == CCP_RESETACK)
1144                         break;
1145                 /* fall through */
1146         default:
1147                 isdn_ppp_fill_rq(skb->data, skb->len, proto, lp->ppp_slot);     /* push data to pppd device */
1148                 kfree_skb(skb);
1149                 return;
1150         }
1151
1152 #ifdef CONFIG_IPPP_FILTER
1153         /* check if the packet passes the pass and active filters
1154          * the filter instructions are constructed assuming
1155          * a four-byte PPP header on each packet (which is still present) */
1156         skb_push(skb, 4);
1157
1158         {
1159                 u_int16_t *p = (u_int16_t *) skb->data;
1160
1161                 *p = 0; /* indicate inbound */
1162         }
1163
1164         if (is->pass_filter
1165             && SK_RUN_FILTER(is->pass_filter, skb) == 0) {
1166                 if (is->debug & 0x2)
1167                         printk(KERN_DEBUG "IPPP: inbound frame filtered.\n");
1168                 kfree_skb(skb);
1169                 return;
1170         }
1171         if (!(is->active_filter
1172               && SK_RUN_FILTER(is->active_filter, skb) == 0)) {
1173                 if (is->debug & 0x2)
1174                         printk(KERN_DEBUG "IPPP: link-active filter: resetting huptimer.\n");
1175                 lp->huptimer = 0;
1176                 if (mlp)
1177                         mlp->huptimer = 0;
1178         }
1179         skb_pull(skb, 4);
1180 #else /* CONFIG_IPPP_FILTER */
1181         lp->huptimer = 0;
1182         if (mlp)
1183                 mlp->huptimer = 0;
1184 #endif /* CONFIG_IPPP_FILTER */
1185         skb->dev = dev;
1186         skb_reset_mac_header(skb);
1187         netif_rx(skb);
1188         /* net_dev->local->stats.rx_packets++; done in isdn_net.c */
1189         return;
1190
1191 drop_packet:
1192         net_dev->local->stats.rx_dropped++;
1193         kfree_skb(skb);
1194 }
1195
1196 /*
1197  * isdn_ppp_skb_push ..
1198  * checks whether we have enough space at the beginning of the skb
1199  * and allocs a new SKB if necessary
1200  */
1201 static unsigned char *isdn_ppp_skb_push(struct sk_buff **skb_p, int len)
1202 {
1203         struct sk_buff *skb = *skb_p;
1204
1205         if (skb_headroom(skb) < len) {
1206                 struct sk_buff *nskb = skb_realloc_headroom(skb, len);
1207
1208                 if (!nskb) {
1209                         printk(KERN_ERR "isdn_ppp_skb_push: can't realloc headroom!\n");
1210                         dev_kfree_skb(skb);
1211                         return NULL;
1212                 }
1213                 printk(KERN_DEBUG "isdn_ppp_skb_push:under %d %d\n", skb_headroom(skb), len);
1214                 dev_kfree_skb(skb);
1215                 *skb_p = nskb;
1216                 return skb_push(nskb, len);
1217         }
1218         return skb_push(skb, len);
1219 }
1220
1221 /*
1222  * send ppp frame .. we expect a PIDCOMPressable proto --
1223  *  (here: currently always PPP_IP,PPP_VJC_COMP,PPP_VJC_UNCOMP)
1224  *
1225  * VJ compression may change skb pointer!!! .. requeue with old
1226  * skb isn't allowed!!
1227  */
1228
1229 int
1230 isdn_ppp_xmit(struct sk_buff *skb, struct net_device *netdev)
1231 {
1232         isdn_net_local *lp, *mlp;
1233         isdn_net_dev *nd;
1234         unsigned int proto = PPP_IP;     /* 0x21 */
1235         struct ippp_struct *ipt, *ipts;
1236         int slot, retval = NETDEV_TX_OK;
1237
1238         mlp = netdev_priv(netdev);
1239         nd = mlp->netdev;       /* get master lp */
1240
1241         slot = mlp->ppp_slot;
1242         if (slot < 0 || slot >= ISDN_MAX_CHANNELS) {
1243                 printk(KERN_ERR "isdn_ppp_xmit: lp->ppp_slot(%d)\n",
1244                        mlp->ppp_slot);
1245                 kfree_skb(skb);
1246                 goto out;
1247         }
1248         ipts = ippp_table[slot];
1249
1250         if (!(ipts->pppcfg & SC_ENABLE_IP)) {   /* PPP connected ? */
1251                 if (ipts->debug & 0x1)
1252                         printk(KERN_INFO "%s: IP frame delayed.\n", netdev->name);
1253                 retval = NETDEV_TX_BUSY;
1254                 goto out;
1255         }
1256
1257         switch (ntohs(skb->protocol)) {
1258         case ETH_P_IP:
1259                 proto = PPP_IP;
1260                 break;
1261         case ETH_P_IPX:
1262                 proto = PPP_IPX;        /* untested */
1263                 break;
1264         default:
1265                 printk(KERN_ERR "isdn_ppp: skipped unsupported protocol: %#x.\n",
1266                        skb->protocol);
1267                 dev_kfree_skb(skb);
1268                 goto out;
1269         }
1270
1271         lp = isdn_net_get_locked_lp(nd);
1272         if (!lp) {
1273                 printk(KERN_WARNING "%s: all channels busy - requeuing!\n", netdev->name);
1274                 retval = NETDEV_TX_BUSY;
1275                 goto out;
1276         }
1277         /* we have our lp locked from now on */
1278
1279         slot = lp->ppp_slot;
1280         if (slot < 0 || slot >= ISDN_MAX_CHANNELS) {
1281                 printk(KERN_ERR "isdn_ppp_xmit: lp->ppp_slot(%d)\n",
1282                        lp->ppp_slot);
1283                 kfree_skb(skb);
1284                 goto unlock;
1285         }
1286         ipt = ippp_table[slot];
1287
1288         /*
1289          * after this line .. requeueing in the device queue is no longer allowed!!!
1290          */
1291
1292         /* Pull off the fake header we stuck on earlier to keep
1293          * the fragmentation code happy.
1294          */
1295         skb_pull(skb, IPPP_MAX_HEADER);
1296
1297 #ifdef CONFIG_IPPP_FILTER
1298         /* check if we should pass this packet
1299          * the filter instructions are constructed assuming
1300          * a four-byte PPP header on each packet */
1301         *skb_push(skb, 4) = 1; /* indicate outbound */
1302
1303         {
1304                 __be16 *p = (__be16 *)skb->data;
1305
1306                 p++;
1307                 *p = htons(proto);
1308         }
1309
1310         if (ipt->pass_filter
1311             && SK_RUN_FILTER(ipt->pass_filter, skb) == 0) {
1312                 if (ipt->debug & 0x4)
1313                         printk(KERN_DEBUG "IPPP: outbound frame filtered.\n");
1314                 kfree_skb(skb);
1315                 goto unlock;
1316         }
1317         if (!(ipt->active_filter
1318               && SK_RUN_FILTER(ipt->active_filter, skb) == 0)) {
1319                 if (ipt->debug & 0x4)
1320                         printk(KERN_DEBUG "IPPP: link-active filter: resetting huptimer.\n");
1321                 lp->huptimer = 0;
1322         }
1323         skb_pull(skb, 4);
1324 #else /* CONFIG_IPPP_FILTER */
1325         lp->huptimer = 0;
1326 #endif /* CONFIG_IPPP_FILTER */
1327
1328         if (ipt->debug & 0x4)
1329                 printk(KERN_DEBUG "xmit skb, len %d\n", (int) skb->len);
1330         if (ipts->debug & 0x40)
1331                 isdn_ppp_frame_log("xmit0", skb->data, skb->len, 32, ipts->unit, lp->ppp_slot);
1332
1333 #ifdef CONFIG_ISDN_PPP_VJ
1334         if (proto == PPP_IP && ipts->pppcfg & SC_COMP_TCP) {    /* ipts here? probably yes, but check this again */
1335                 struct sk_buff *new_skb;
1336                 unsigned short hl;
1337                 /*
1338                  * we need to reserve enough space in front of
1339                  * sk_buff. old call to dev_alloc_skb only reserved
1340                  * 16 bytes, now we are looking what the driver want.
1341                  */
1342                 hl = dev->drv[lp->isdn_device]->interface->hl_hdrlen + IPPP_MAX_HEADER;
1343                 /*
1344                  * Note: hl might still be insufficient because the method
1345                  * above does not account for a possibible MPPP slave channel
1346                  * which had larger HL header space requirements than the
1347                  * master.
1348                  */
1349                 new_skb = alloc_skb(hl + skb->len, GFP_ATOMIC);
1350                 if (new_skb) {
1351                         u_char *buf;
1352                         int pktlen;
1353
1354                         skb_reserve(new_skb, hl);
1355                         new_skb->dev = skb->dev;
1356                         skb_put(new_skb, skb->len);
1357                         buf = skb->data;
1358
1359                         pktlen = slhc_compress(ipts->slcomp, skb->data, skb->len, new_skb->data,
1360                                                &buf, !(ipts->pppcfg & SC_NO_TCP_CCID));
1361
1362                         if (buf != skb->data) {
1363                                 if (new_skb->data != buf)
1364                                         printk(KERN_ERR "isdn_ppp: FATAL error after slhc_compress!!\n");
1365                                 dev_kfree_skb(skb);
1366                                 skb = new_skb;
1367                         } else {
1368                                 dev_kfree_skb(new_skb);
1369                         }
1370
1371                         skb_trim(skb, pktlen);
1372                         if (skb->data[0] & SL_TYPE_COMPRESSED_TCP) {    /* cslip? style -> PPP */
1373                                 proto = PPP_VJC_COMP;
1374                                 skb->data[0] ^= SL_TYPE_COMPRESSED_TCP;
1375                         } else {
1376                                 if (skb->data[0] >= SL_TYPE_UNCOMPRESSED_TCP)
1377                                         proto = PPP_VJC_UNCOMP;
1378                                 skb->data[0] = (skb->data[0] & 0x0f) | 0x40;
1379                         }
1380                 }
1381         }
1382 #endif
1383
1384         /*
1385          * normal (single link) or bundle compression
1386          */
1387         if (ipts->compflags & SC_COMP_ON) {
1388                 /* We send compressed only if both down- und upstream
1389                    compression is negotiated, that means, CCP is up */
1390                 if (ipts->compflags & SC_DECOMP_ON) {
1391                         skb = isdn_ppp_compress(skb, &proto, ipt, ipts, 0);
1392                 } else {
1393                         printk(KERN_DEBUG "isdn_ppp: CCP not yet up - sending as-is\n");
1394                 }
1395         }
1396
1397         if (ipt->debug & 0x24)
1398                 printk(KERN_DEBUG "xmit2 skb, len %d, proto %04x\n", (int) skb->len, proto);
1399
1400 #ifdef CONFIG_ISDN_MPP
1401         if (ipt->mpppcfg & SC_MP_PROT) {
1402                 /* we get mp_seqno from static isdn_net_local */
1403                 long mp_seqno = ipts->mp_seqno;
1404                 ipts->mp_seqno++;
1405                 if (ipt->mpppcfg & SC_OUT_SHORT_SEQ) {
1406                         unsigned char *data = isdn_ppp_skb_push(&skb, 3);
1407                         if (!data)
1408                                 goto unlock;
1409                         mp_seqno &= 0xfff;
1410                         data[0] = MP_BEGIN_FRAG | MP_END_FRAG | ((mp_seqno >> 8) & 0xf);        /* (B)egin & (E)ndbit .. */
1411                         data[1] = mp_seqno & 0xff;
1412                         data[2] = proto;        /* PID compression */
1413                 } else {
1414                         unsigned char *data = isdn_ppp_skb_push(&skb, 5);
1415                         if (!data)
1416                                 goto unlock;
1417                         data[0] = MP_BEGIN_FRAG | MP_END_FRAG;  /* (B)egin & (E)ndbit .. */
1418                         data[1] = (mp_seqno >> 16) & 0xff;      /* sequence number: 24bit */
1419                         data[2] = (mp_seqno >> 8) & 0xff;
1420                         data[3] = (mp_seqno >> 0) & 0xff;
1421                         data[4] = proto;        /* PID compression */
1422                 }
1423                 proto = PPP_MP; /* MP Protocol, 0x003d */
1424         }
1425 #endif
1426
1427         /*
1428          * 'link in bundle' compression  ...
1429          */
1430         if (ipt->compflags & SC_LINK_COMP_ON)
1431                 skb = isdn_ppp_compress(skb, &proto, ipt, ipts, 1);
1432
1433         if ((ipt->pppcfg & SC_COMP_PROT) && (proto <= 0xff)) {
1434                 unsigned char *data = isdn_ppp_skb_push(&skb, 1);
1435                 if (!data)
1436                         goto unlock;
1437                 data[0] = proto & 0xff;
1438         }
1439         else {
1440                 unsigned char *data = isdn_ppp_skb_push(&skb, 2);
1441                 if (!data)
1442                         goto unlock;
1443                 data[0] = (proto >> 8) & 0xff;
1444                 data[1] = proto & 0xff;
1445         }
1446         if (!(ipt->pppcfg & SC_COMP_AC)) {
1447                 unsigned char *data = isdn_ppp_skb_push(&skb, 2);
1448                 if (!data)
1449                         goto unlock;
1450                 data[0] = 0xff;    /* All Stations */
1451                 data[1] = 0x03;    /* Unnumbered information */
1452         }
1453
1454         /* tx-stats are now updated via BSENT-callback */
1455
1456         if (ipts->debug & 0x40) {
1457                 printk(KERN_DEBUG "skb xmit: len: %d\n", (int) skb->len);
1458                 isdn_ppp_frame_log("xmit", skb->data, skb->len, 32, ipt->unit, lp->ppp_slot);
1459         }
1460
1461         isdn_net_writebuf_skb(lp, skb);
1462
1463 unlock:
1464         spin_unlock_bh(&lp->xmit_lock);
1465 out:
1466         return retval;
1467 }
1468
1469 #ifdef CONFIG_IPPP_FILTER
1470 /*
1471  * check if this packet may trigger auto-dial.
1472  */
1473
1474 int isdn_ppp_autodial_filter(struct sk_buff *skb, isdn_net_local *lp)
1475 {
1476         struct ippp_struct *is = ippp_table[lp->ppp_slot];
1477         u_int16_t proto;
1478         int drop = 0;
1479
1480         switch (ntohs(skb->protocol)) {
1481         case ETH_P_IP:
1482                 proto = PPP_IP;
1483                 break;
1484         case ETH_P_IPX:
1485                 proto = PPP_IPX;
1486                 break;
1487         default:
1488                 printk(KERN_ERR "isdn_ppp_autodial_filter: unsupported protocol 0x%x.\n",
1489                        skb->protocol);
1490                 return 1;
1491         }
1492
1493         /* the filter instructions are constructed assuming
1494          * a four-byte PPP header on each packet. we have to
1495          * temporarily remove part of the fake header stuck on
1496          * earlier.
1497          */
1498         *skb_pull(skb, IPPP_MAX_HEADER - 4) = 1; /* indicate outbound */
1499
1500         {
1501                 __be16 *p = (__be16 *)skb->data;
1502
1503                 p++;
1504                 *p = htons(proto);
1505         }
1506
1507         drop |= is->pass_filter
1508                 && SK_RUN_FILTER(is->pass_filter, skb) == 0;
1509         drop |= is->active_filter
1510                 && SK_RUN_FILTER(is->active_filter, skb) == 0;
1511
1512         skb_push(skb, IPPP_MAX_HEADER - 4);
1513         return drop;
1514 }
1515 #endif
1516 #ifdef CONFIG_ISDN_MPP
1517
1518 /* this is _not_ rfc1990 header, but something we convert both short and long
1519  * headers to for convinience's sake:
1520  *      byte 0 is flags as in rfc1990
1521  *      bytes 1...4 is 24-bit seqence number converted to host byte order
1522  */
1523 #define MP_HEADER_LEN   5
1524
1525 #define MP_LONGSEQ_MASK         0x00ffffff
1526 #define MP_SHORTSEQ_MASK        0x00000fff
1527 #define MP_LONGSEQ_MAX          MP_LONGSEQ_MASK
1528 #define MP_SHORTSEQ_MAX         MP_SHORTSEQ_MASK
1529 #define MP_LONGSEQ_MAXBIT       ((MP_LONGSEQ_MASK + 1) >> 1)
1530 #define MP_SHORTSEQ_MAXBIT      ((MP_SHORTSEQ_MASK + 1) >> 1)
1531
1532 /* sequence-wrap safe comparisons (for long sequence)*/
1533 #define MP_LT(a, b)     ((a - b) & MP_LONGSEQ_MAXBIT)
1534 #define MP_LE(a, b)     !((b - a) & MP_LONGSEQ_MAXBIT)
1535 #define MP_GT(a, b)     ((b - a) & MP_LONGSEQ_MAXBIT)
1536 #define MP_GE(a, b)     !((a - b) & MP_LONGSEQ_MAXBIT)
1537
1538 #define MP_SEQ(f)       ((*(u32 *)(f->data + 1)))
1539 #define MP_FLAGS(f)     (f->data[0])
1540
1541 static int isdn_ppp_mp_bundle_array_init(void)
1542 {
1543         int i;
1544         int sz = ISDN_MAX_CHANNELS * sizeof(ippp_bundle);
1545         if ((isdn_ppp_bundle_arr = kzalloc(sz, GFP_KERNEL)) == NULL)
1546                 return -ENOMEM;
1547         for (i = 0; i < ISDN_MAX_CHANNELS; i++)
1548                 spin_lock_init(&isdn_ppp_bundle_arr[i].lock);
1549         return 0;
1550 }
1551
1552 static ippp_bundle *isdn_ppp_mp_bundle_alloc(void)
1553 {
1554         int i;
1555         for (i = 0; i < ISDN_MAX_CHANNELS; i++)
1556                 if (isdn_ppp_bundle_arr[i].ref_ct <= 0)
1557                         return (isdn_ppp_bundle_arr + i);
1558         return NULL;
1559 }
1560
1561 static int isdn_ppp_mp_init(isdn_net_local *lp, ippp_bundle *add_to)
1562 {
1563         struct ippp_struct *is;
1564
1565         if (lp->ppp_slot < 0) {
1566                 printk(KERN_ERR "%s: lp->ppp_slot(%d) out of range\n",
1567                        __func__, lp->ppp_slot);
1568                 return (-EINVAL);
1569         }
1570
1571         is = ippp_table[lp->ppp_slot];
1572         if (add_to) {
1573                 if (lp->netdev->pb)
1574                         lp->netdev->pb->ref_ct--;
1575                 lp->netdev->pb = add_to;
1576         } else {                /* first link in a bundle */
1577                 is->mp_seqno = 0;
1578                 if ((lp->netdev->pb = isdn_ppp_mp_bundle_alloc()) == NULL)
1579                         return -ENOMEM;
1580                 lp->next = lp->last = lp;       /* nobody else in a queue */
1581                 lp->netdev->pb->frags = NULL;
1582                 lp->netdev->pb->frames = 0;
1583                 lp->netdev->pb->seq = UINT_MAX;
1584         }
1585         lp->netdev->pb->ref_ct++;
1586
1587         is->last_link_seqno = 0;
1588         return 0;
1589 }
1590
1591 static u32 isdn_ppp_mp_get_seq(int short_seq,
1592                                struct sk_buff *skb, u32 last_seq);
1593 static struct sk_buff *isdn_ppp_mp_discard(ippp_bundle *mp,
1594                                            struct sk_buff *from, struct sk_buff *to);
1595 static void isdn_ppp_mp_reassembly(isdn_net_dev *net_dev, isdn_net_local *lp,
1596                                    struct sk_buff *from, struct sk_buff *to);
1597 static void isdn_ppp_mp_free_skb(ippp_bundle *mp, struct sk_buff *skb);
1598 static void isdn_ppp_mp_print_recv_pkt(int slot, struct sk_buff *skb);
1599
1600 static void isdn_ppp_mp_receive(isdn_net_dev *net_dev, isdn_net_local *lp,
1601                                 struct sk_buff *skb)
1602 {
1603         struct ippp_struct *is;
1604         isdn_net_local *lpq;
1605         ippp_bundle *mp;
1606         isdn_mppp_stats *stats;
1607         struct sk_buff *newfrag, *frag, *start, *nextf;
1608         u32 newseq, minseq, thisseq;
1609         unsigned long flags;
1610         int slot;
1611
1612         spin_lock_irqsave(&net_dev->pb->lock, flags);
1613         mp = net_dev->pb;
1614         stats = &mp->stats;
1615         slot = lp->ppp_slot;
1616         if (slot < 0 || slot >= ISDN_MAX_CHANNELS) {
1617                 printk(KERN_ERR "%s: lp->ppp_slot(%d)\n",
1618                        __func__, lp->ppp_slot);
1619                 stats->frame_drops++;
1620                 dev_kfree_skb(skb);
1621                 spin_unlock_irqrestore(&mp->lock, flags);
1622                 return;
1623         }
1624         is = ippp_table[slot];
1625         if (++mp->frames > stats->max_queue_len)
1626                 stats->max_queue_len = mp->frames;
1627
1628         if (is->debug & 0x8)
1629                 isdn_ppp_mp_print_recv_pkt(lp->ppp_slot, skb);
1630
1631         newseq = isdn_ppp_mp_get_seq(is->mpppcfg & SC_IN_SHORT_SEQ,
1632                                      skb, is->last_link_seqno);
1633
1634
1635         /* if this packet seq # is less than last already processed one,
1636          * toss it right away, but check for sequence start case first
1637          */
1638         if (mp->seq > MP_LONGSEQ_MAX && (newseq & MP_LONGSEQ_MAXBIT)) {
1639                 mp->seq = newseq;       /* the first packet: required for
1640                                          * rfc1990 non-compliant clients --
1641                                          * prevents constant packet toss */
1642         } else if (MP_LT(newseq, mp->seq)) {
1643                 stats->frame_drops++;
1644                 isdn_ppp_mp_free_skb(mp, skb);
1645                 spin_unlock_irqrestore(&mp->lock, flags);
1646                 return;
1647         }
1648
1649         /* find the minimum received sequence number over all links */
1650         is->last_link_seqno = minseq = newseq;
1651         for (lpq = net_dev->queue;;) {
1652                 slot = lpq->ppp_slot;
1653                 if (slot < 0 || slot >= ISDN_MAX_CHANNELS) {
1654                         printk(KERN_ERR "%s: lpq->ppp_slot(%d)\n",
1655                                __func__, lpq->ppp_slot);
1656                 } else {
1657                         u32 lls = ippp_table[slot]->last_link_seqno;
1658                         if (MP_LT(lls, minseq))
1659                                 minseq = lls;
1660                 }
1661                 if ((lpq = lpq->next) == net_dev->queue)
1662                         break;
1663         }
1664         if (MP_LT(minseq, mp->seq))
1665                 minseq = mp->seq;       /* can't go beyond already processed
1666                                          * packets */
1667         newfrag = skb;
1668
1669         /* if this new fragment is before the first one, then enqueue it now. */
1670         if ((frag = mp->frags) == NULL || MP_LT(newseq, MP_SEQ(frag))) {
1671                 newfrag->next = frag;
1672                 mp->frags = frag = newfrag;
1673                 newfrag = NULL;
1674         }
1675
1676         start = MP_FLAGS(frag) & MP_BEGIN_FRAG &&
1677                 MP_SEQ(frag) == mp->seq ? frag : NULL;
1678
1679         /*
1680          * main fragment traversing loop
1681          *
1682          * try to accomplish several tasks:
1683          * - insert new fragment into the proper sequence slot (once that's done
1684          *   newfrag will be set to NULL)
1685          * - reassemble any complete fragment sequence (non-null 'start'
1686          *   indicates there is a contiguous sequence present)
1687          * - discard any incomplete sequences that are below minseq -- due
1688          *   to the fact that sender always increment sequence number, if there
1689          *   is an incomplete sequence below minseq, no new fragments would
1690          *   come to complete such sequence and it should be discarded
1691          *
1692          * loop completes when we accomplished the following tasks:
1693          * - new fragment is inserted in the proper sequence ('newfrag' is
1694          *   set to NULL)
1695          * - we hit a gap in the sequence, so no reassembly/processing is
1696          *   possible ('start' would be set to NULL)
1697          *
1698          * algorithm for this code is derived from code in the book
1699          * 'PPP Design And Debugging' by James Carlson (Addison-Wesley)
1700          */
1701         while (start != NULL || newfrag != NULL) {
1702
1703                 thisseq = MP_SEQ(frag);
1704                 nextf = frag->next;
1705
1706                 /* drop any duplicate fragments */
1707                 if (newfrag != NULL && thisseq == newseq) {
1708                         isdn_ppp_mp_free_skb(mp, newfrag);
1709                         newfrag = NULL;
1710                 }
1711
1712                 /* insert new fragment before next element if possible. */
1713                 if (newfrag != NULL && (nextf == NULL ||
1714                                         MP_LT(newseq, MP_SEQ(nextf)))) {
1715                         newfrag->next = nextf;
1716                         frag->next = nextf = newfrag;
1717                         newfrag = NULL;
1718                 }
1719
1720                 if (start != NULL) {
1721                         /* check for misplaced start */
1722                         if (start != frag && (MP_FLAGS(frag) & MP_BEGIN_FRAG)) {
1723                                 printk(KERN_WARNING"isdn_mppp(seq %d): new "
1724                                        "BEGIN flag with no prior END", thisseq);
1725                                 stats->seqerrs++;
1726                                 stats->frame_drops++;
1727                                 start = isdn_ppp_mp_discard(mp, start, frag);
1728                                 nextf = frag->next;
1729                         }
1730                 } else if (MP_LE(thisseq, minseq)) {
1731                         if (MP_FLAGS(frag) & MP_BEGIN_FRAG)
1732                                 start = frag;
1733                         else {
1734                                 if (MP_FLAGS(frag) & MP_END_FRAG)
1735                                         stats->frame_drops++;
1736                                 if (mp->frags == frag)
1737                                         mp->frags = nextf;
1738                                 isdn_ppp_mp_free_skb(mp, frag);
1739                                 frag = nextf;
1740                                 continue;
1741                         }
1742                 }
1743
1744                 /* if start is non-null and we have end fragment, then
1745                  * we have full reassembly sequence -- reassemble
1746                  * and process packet now
1747                  */
1748                 if (start != NULL && (MP_FLAGS(frag) & MP_END_FRAG)) {
1749                         minseq = mp->seq = (thisseq + 1) & MP_LONGSEQ_MASK;
1750                         /* Reassemble the packet then dispatch it */
1751                         isdn_ppp_mp_reassembly(net_dev, lp, start, nextf);
1752
1753                         start = NULL;
1754                         frag = NULL;
1755
1756                         mp->frags = nextf;
1757                 }
1758
1759                 /* check if need to update start pointer: if we just
1760                  * reassembled the packet and sequence is contiguous
1761                  * then next fragment should be the start of new reassembly
1762                  * if sequence is contiguous, but we haven't reassembled yet,
1763                  * keep going.
1764                  * if sequence is not contiguous, either clear everything
1765                  * below low watermark and set start to the next frag or
1766                  * clear start ptr.
1767                  */
1768                 if (nextf != NULL &&
1769                     ((thisseq + 1) & MP_LONGSEQ_MASK) == MP_SEQ(nextf)) {
1770                         /* if we just reassembled and the next one is here,
1771                          * then start another reassembly. */
1772
1773                         if (frag == NULL) {
1774                                 if (MP_FLAGS(nextf) & MP_BEGIN_FRAG)
1775                                         start = nextf;
1776                                 else
1777                                 {
1778                                         printk(KERN_WARNING"isdn_mppp(seq %d):"
1779                                                " END flag with no following "
1780                                                "BEGIN", thisseq);
1781                                         stats->seqerrs++;
1782                                 }
1783                         }
1784
1785                 } else {
1786                         if (nextf != NULL && frag != NULL &&
1787                             MP_LT(thisseq, minseq)) {
1788                                 /* we've got a break in the sequence
1789                                  * and we not at the end yet
1790                                  * and we did not just reassembled
1791                                  *(if we did, there wouldn't be anything before)
1792                                  * and we below the low watermark
1793                                  * discard all the frames below low watermark
1794                                  * and start over */
1795                                 stats->frame_drops++;
1796                                 mp->frags = isdn_ppp_mp_discard(mp, start, nextf);
1797                         }
1798                         /* break in the sequence, no reassembly */
1799                         start = NULL;
1800                 }
1801
1802                 frag = nextf;
1803         }       /* while -- main loop */
1804
1805         if (mp->frags == NULL)
1806                 mp->frags = frag;
1807
1808         /* rather straighforward way to deal with (not very) possible
1809          * queue overflow */
1810         if (mp->frames > MP_MAX_QUEUE_LEN) {
1811                 stats->overflows++;
1812                 while (mp->frames > MP_MAX_QUEUE_LEN) {
1813                         frag = mp->frags->next;
1814                         isdn_ppp_mp_free_skb(mp, mp->frags);
1815                         mp->frags = frag;
1816                 }
1817         }
1818         spin_unlock_irqrestore(&mp->lock, flags);
1819 }
1820
1821 static void isdn_ppp_mp_cleanup(isdn_net_local *lp)
1822 {
1823         struct sk_buff *frag = lp->netdev->pb->frags;
1824         struct sk_buff *nextfrag;
1825         while (frag) {
1826                 nextfrag = frag->next;
1827                 isdn_ppp_mp_free_skb(lp->netdev->pb, frag);
1828                 frag = nextfrag;
1829         }
1830         lp->netdev->pb->frags = NULL;
1831 }
1832
1833 static u32 isdn_ppp_mp_get_seq(int short_seq,
1834                                struct sk_buff *skb, u32 last_seq)
1835 {
1836         u32 seq;
1837         int flags = skb->data[0] & (MP_BEGIN_FRAG | MP_END_FRAG);
1838
1839         if (!short_seq)
1840         {
1841                 seq = ntohl(*(__be32 *)skb->data) & MP_LONGSEQ_MASK;
1842                 skb_push(skb, 1);
1843         }
1844         else
1845         {
1846                 /* convert 12-bit short seq number to 24-bit long one
1847                  */
1848                 seq = ntohs(*(__be16 *)skb->data) & MP_SHORTSEQ_MASK;
1849
1850                 /* check for seqence wrap */
1851                 if (!(seq &  MP_SHORTSEQ_MAXBIT) &&
1852                     (last_seq &  MP_SHORTSEQ_MAXBIT) &&
1853                     (unsigned long)last_seq <= MP_LONGSEQ_MAX)
1854                         seq |= (last_seq + MP_SHORTSEQ_MAX + 1) &
1855                                 (~MP_SHORTSEQ_MASK & MP_LONGSEQ_MASK);
1856                 else
1857                         seq |= last_seq & (~MP_SHORTSEQ_MASK & MP_LONGSEQ_MASK);
1858
1859                 skb_push(skb, 3);       /* put converted seqence back in skb */
1860         }
1861         *(u32 *)(skb->data + 1) = seq;  /* put seqence back in _host_ byte
1862                                          * order */
1863         skb->data[0] = flags;           /* restore flags */
1864         return seq;
1865 }
1866
1867 struct sk_buff *isdn_ppp_mp_discard(ippp_bundle *mp,
1868                                     struct sk_buff *from, struct sk_buff *to)
1869 {
1870         if (from)
1871                 while (from != to) {
1872                         struct sk_buff *next = from->next;
1873                         isdn_ppp_mp_free_skb(mp, from);
1874                         from = next;
1875                 }
1876         return from;
1877 }
1878
1879 void isdn_ppp_mp_reassembly(isdn_net_dev *net_dev, isdn_net_local *lp,
1880                             struct sk_buff *from, struct sk_buff *to)
1881 {
1882         ippp_bundle *mp = net_dev->pb;
1883         int proto;
1884         struct sk_buff *skb;
1885         unsigned int tot_len;
1886
1887         if (lp->ppp_slot < 0 || lp->ppp_slot >= ISDN_MAX_CHANNELS) {
1888                 printk(KERN_ERR "%s: lp->ppp_slot(%d) out of range\n",
1889                        __func__, lp->ppp_slot);
1890                 return;
1891         }
1892         if (MP_FLAGS(from) == (MP_BEGIN_FRAG | MP_END_FRAG)) {
1893                 if (ippp_table[lp->ppp_slot]->debug & 0x40)
1894                         printk(KERN_DEBUG "isdn_mppp: reassembly: frame %d, "
1895                                "len %d\n", MP_SEQ(from), from->len);
1896                 skb = from;
1897                 skb_pull(skb, MP_HEADER_LEN);
1898                 mp->frames--;
1899         } else {
1900                 struct sk_buff *frag;
1901                 int n;
1902
1903                 for (tot_len = n = 0, frag = from; frag != to; frag = frag->next, n++)
1904                         tot_len += frag->len - MP_HEADER_LEN;
1905
1906                 if (ippp_table[lp->ppp_slot]->debug & 0x40)
1907                         printk(KERN_DEBUG"isdn_mppp: reassembling frames %d "
1908                                "to %d, len %d\n", MP_SEQ(from),
1909                                (MP_SEQ(from) + n - 1) & MP_LONGSEQ_MASK, tot_len);
1910                 if ((skb = dev_alloc_skb(tot_len)) == NULL) {
1911                         printk(KERN_ERR "isdn_mppp: cannot allocate sk buff "
1912                                "of size %d\n", tot_len);
1913                         isdn_ppp_mp_discard(mp, from, to);
1914                         return;
1915                 }
1916
1917                 while (from != to) {
1918                         unsigned int len = from->len - MP_HEADER_LEN;
1919
1920                         skb_copy_from_linear_data_offset(from, MP_HEADER_LEN,
1921                                                          skb_put(skb, len),
1922                                                          len);
1923                         frag = from->next;
1924                         isdn_ppp_mp_free_skb(mp, from);
1925                         from = frag;
1926                 }
1927         }
1928         proto = isdn_ppp_strip_proto(skb);
1929         isdn_ppp_push_higher(net_dev, lp, skb, proto);
1930 }
1931
1932 static void isdn_ppp_mp_free_skb(ippp_bundle *mp, struct sk_buff *skb)
1933 {
1934         dev_kfree_skb(skb);
1935         mp->frames--;
1936 }
1937
1938 static void isdn_ppp_mp_print_recv_pkt(int slot, struct sk_buff *skb)
1939 {
1940         printk(KERN_DEBUG "mp_recv: %d/%d -> %02x %02x %02x %02x %02x %02x\n",
1941                slot, (int) skb->len,
1942                (int) skb->data[0], (int) skb->data[1], (int) skb->data[2],
1943                (int) skb->data[3], (int) skb->data[4], (int) skb->data[5]);
1944 }
1945
1946 static int
1947 isdn_ppp_bundle(struct ippp_struct *is, int unit)
1948 {
1949         char ifn[IFNAMSIZ + 1];
1950         isdn_net_dev *p;
1951         isdn_net_local *lp, *nlp;
1952         int rc;
1953         unsigned long flags;
1954
1955         sprintf(ifn, "ippp%d", unit);
1956         p = isdn_net_findif(ifn);
1957         if (!p) {
1958                 printk(KERN_ERR "ippp_bundle: cannot find %s\n", ifn);
1959                 return -EINVAL;
1960         }
1961
1962         spin_lock_irqsave(&p->pb->lock, flags);
1963
1964         nlp = is->lp;
1965         lp = p->queue;
1966         if (nlp->ppp_slot < 0 || nlp->ppp_slot >= ISDN_MAX_CHANNELS ||
1967             lp->ppp_slot < 0 || lp->ppp_slot >= ISDN_MAX_CHANNELS) {
1968                 printk(KERN_ERR "ippp_bundle: binding to invalid slot %d\n",
1969                        nlp->ppp_slot < 0 || nlp->ppp_slot >= ISDN_MAX_CHANNELS ?
1970                        nlp->ppp_slot : lp->ppp_slot);
1971                 rc = -EINVAL;
1972                 goto out;
1973         }
1974
1975         isdn_net_add_to_bundle(p, nlp);
1976
1977         ippp_table[nlp->ppp_slot]->unit = ippp_table[lp->ppp_slot]->unit;
1978
1979         /* maybe also SC_CCP stuff */
1980         ippp_table[nlp->ppp_slot]->pppcfg |= ippp_table[lp->ppp_slot]->pppcfg &
1981                 (SC_ENABLE_IP | SC_NO_TCP_CCID | SC_REJ_COMP_TCP);
1982         ippp_table[nlp->ppp_slot]->mpppcfg |= ippp_table[lp->ppp_slot]->mpppcfg &
1983                 (SC_MP_PROT | SC_REJ_MP_PROT | SC_OUT_SHORT_SEQ | SC_IN_SHORT_SEQ);
1984         rc = isdn_ppp_mp_init(nlp, p->pb);
1985 out:
1986         spin_unlock_irqrestore(&p->pb->lock, flags);
1987         return rc;
1988 }
1989
1990 #endif /* CONFIG_ISDN_MPP */
1991
1992 /*
1993  * network device ioctl handlers
1994  */
1995
1996 static int
1997 isdn_ppp_dev_ioctl_stats(int slot, struct ifreq *ifr, struct net_device *dev)
1998 {
1999         struct ppp_stats __user *res = ifr->ifr_data;
2000         struct ppp_stats t;
2001         isdn_net_local *lp = netdev_priv(dev);
2002
2003         if (!access_ok(VERIFY_WRITE, res, sizeof(struct ppp_stats)))
2004                 return -EFAULT;
2005
2006         /* build a temporary stat struct and copy it to user space */
2007
2008         memset(&t, 0, sizeof(struct ppp_stats));
2009         if (dev->flags & IFF_UP) {
2010                 t.p.ppp_ipackets = lp->stats.rx_packets;
2011                 t.p.ppp_ibytes = lp->stats.rx_bytes;
2012                 t.p.ppp_ierrors = lp->stats.rx_errors;
2013                 t.p.ppp_opackets = lp->stats.tx_packets;
2014                 t.p.ppp_obytes = lp->stats.tx_bytes;
2015                 t.p.ppp_oerrors = lp->stats.tx_errors;
2016 #ifdef CONFIG_ISDN_PPP_VJ
2017                 if (slot >= 0 && ippp_table[slot]->slcomp) {
2018                         struct slcompress *slcomp = ippp_table[slot]->slcomp;
2019                         t.vj.vjs_packets = slcomp->sls_o_compressed + slcomp->sls_o_uncompressed;
2020                         t.vj.vjs_compressed = slcomp->sls_o_compressed;
2021                         t.vj.vjs_searches = slcomp->sls_o_searches;
2022                         t.vj.vjs_misses = slcomp->sls_o_misses;
2023                         t.vj.vjs_errorin = slcomp->sls_i_error;
2024                         t.vj.vjs_tossed = slcomp->sls_i_tossed;
2025                         t.vj.vjs_uncompressedin = slcomp->sls_i_uncompressed;
2026                         t.vj.vjs_compressedin = slcomp->sls_i_compressed;
2027                 }
2028 #endif
2029         }
2030         if (copy_to_user(res, &t, sizeof(struct ppp_stats)))
2031                 return -EFAULT;
2032         return 0;
2033 }
2034
2035 int
2036 isdn_ppp_dev_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
2037 {
2038         int error = 0;
2039         int len;
2040         isdn_net_local *lp = netdev_priv(dev);
2041
2042
2043         if (lp->p_encap != ISDN_NET_ENCAP_SYNCPPP)
2044                 return -EINVAL;
2045
2046         switch (cmd) {
2047 #define PPP_VERSION "2.3.7"
2048         case SIOCGPPPVER:
2049                 len = strlen(PPP_VERSION) + 1;
2050                 if (copy_to_user(ifr->ifr_data, PPP_VERSION, len))
2051                         error = -EFAULT;
2052                 break;
2053
2054         case SIOCGPPPSTATS:
2055                 error = isdn_ppp_dev_ioctl_stats(lp->ppp_slot, ifr, dev);
2056                 break;
2057         default:
2058                 error = -EINVAL;
2059                 break;
2060         }
2061         return error;
2062 }
2063
2064 static int
2065 isdn_ppp_if_get_unit(char *name)
2066 {
2067         int len,
2068                 i,
2069                 unit = 0,
2070                 deci;
2071
2072         len = strlen(name);
2073
2074         if (strncmp("ippp", name, 4) || len > 8)
2075                 return -1;
2076
2077         for (i = 0, deci = 1; i < len; i++, deci *= 10) {
2078                 char a = name[len - i - 1];
2079                 if (a >= '0' && a <= '9')
2080                         unit += (a - '0') * deci;
2081                 else
2082                         break;
2083         }
2084         if (!i || len - i != 4)
2085                 unit = -1;
2086
2087         return unit;
2088 }
2089
2090
2091 int
2092 isdn_ppp_dial_slave(char *name)
2093 {
2094 #ifdef CONFIG_ISDN_MPP
2095         isdn_net_dev *ndev;
2096         isdn_net_local *lp;
2097         struct net_device *sdev;
2098
2099         if (!(ndev = isdn_net_findif(name)))
2100                 return 1;
2101         lp = ndev->local;
2102         if (!(lp->flags & ISDN_NET_CONNECTED))
2103                 return 5;
2104
2105         sdev = lp->slave;
2106         while (sdev) {
2107                 isdn_net_local *mlp = netdev_priv(sdev);
2108                 if (!(mlp->flags & ISDN_NET_CONNECTED))
2109                         break;
2110                 sdev = mlp->slave;
2111         }
2112         if (!sdev)
2113                 return 2;
2114
2115         isdn_net_dial_req(netdev_priv(sdev));
2116         return 0;
2117 #else
2118         return -1;
2119 #endif
2120 }
2121
2122 int
2123 isdn_ppp_hangup_slave(char *name)
2124 {
2125 #ifdef CONFIG_ISDN_MPP
2126         isdn_net_dev *ndev;
2127         isdn_net_local *lp;
2128         struct net_device *sdev;
2129
2130         if (!(ndev = isdn_net_findif(name)))
2131                 return 1;
2132         lp = ndev->local;
2133         if (!(lp->flags & ISDN_NET_CONNECTED))
2134                 return 5;
2135
2136         sdev = lp->slave;
2137         while (sdev) {
2138                 isdn_net_local *mlp = netdev_priv(sdev);
2139
2140                 if (mlp->slave) { /* find last connected link in chain */
2141                         isdn_net_local *nlp = ISDN_SLAVE_PRIV(mlp);
2142
2143                         if (!(nlp->flags & ISDN_NET_CONNECTED))
2144                                 break;
2145                 } else if (mlp->flags & ISDN_NET_CONNECTED)
2146                         break;
2147
2148                 sdev = mlp->slave;
2149         }
2150         if (!sdev)
2151                 return 2;
2152
2153         isdn_net_hangup(sdev);
2154         return 0;
2155 #else
2156         return -1;
2157 #endif
2158 }
2159
2160 /*
2161  * PPP compression stuff
2162  */
2163
2164
2165 /* Push an empty CCP Data Frame up to the daemon to wake it up and let it
2166    generate a CCP Reset-Request or tear down CCP altogether */
2167
2168 static void isdn_ppp_ccp_kickup(struct ippp_struct *is)
2169 {
2170         isdn_ppp_fill_rq(NULL, 0, PPP_COMP, is->lp->ppp_slot);
2171 }
2172
2173 /* In-kernel handling of CCP Reset-Request and Reset-Ack is necessary,
2174    but absolutely nontrivial. The most abstruse problem we are facing is
2175    that the generation, reception and all the handling of timeouts and
2176    resends including proper request id management should be entirely left
2177    to the (de)compressor, but indeed is not covered by the current API to
2178    the (de)compressor. The API is a prototype version from PPP where only
2179    some (de)compressors have yet been implemented and all of them are
2180    rather simple in their reset handling. Especially, their is only one
2181    outstanding ResetAck at a time with all of them and ResetReq/-Acks do
2182    not have parameters. For this very special case it was sufficient to
2183    just return an error code from the decompressor and have a single
2184    reset() entry to communicate all the necessary information between
2185    the framework and the (de)compressor. Bad enough, LZS is different
2186    (and any other compressor may be different, too). It has multiple
2187    histories (eventually) and needs to Reset each of them independently
2188    and thus uses multiple outstanding Acks and history numbers as an
2189    additional parameter to Reqs/Acks.
2190    All that makes it harder to port the reset state engine into the
2191    kernel because it is not just the same simple one as in (i)pppd but
2192    it must be able to pass additional parameters and have multiple out-
2193    standing Acks. We are trying to achieve the impossible by handling
2194    reset transactions independent by their id. The id MUST change when
2195    the data portion changes, thus any (de)compressor who uses more than
2196    one resettable state must provide and recognize individual ids for
2197    each individual reset transaction. The framework itself does _only_
2198    differentiate them by id, because it has no other semantics like the
2199    (de)compressor might.
2200    This looks like a major redesign of the interface would be nice,
2201    but I don't have an idea how to do it better. */
2202
2203 /* Send a CCP Reset-Request or Reset-Ack directly from the kernel. This is
2204    getting that lengthy because there is no simple "send-this-frame-out"
2205    function above but every wrapper does a bit different. Hope I guess
2206    correct in this hack... */
2207
2208 static void isdn_ppp_ccp_xmit_reset(struct ippp_struct *is, int proto,
2209                                     unsigned char code, unsigned char id,
2210                                     unsigned char *data, int len)
2211 {
2212         struct sk_buff *skb;
2213         unsigned char *p;
2214         int hl;
2215         int cnt = 0;
2216         isdn_net_local *lp = is->lp;
2217
2218         /* Alloc large enough skb */
2219         hl = dev->drv[lp->isdn_device]->interface->hl_hdrlen;
2220         skb = alloc_skb(len + hl + 16, GFP_ATOMIC);
2221         if (!skb) {
2222                 printk(KERN_WARNING
2223                        "ippp: CCP cannot send reset - out of memory\n");
2224                 return;
2225         }
2226         skb_reserve(skb, hl);
2227
2228         /* We may need to stuff an address and control field first */
2229         if (!(is->pppcfg & SC_COMP_AC)) {
2230                 p = skb_put(skb, 2);
2231                 *p++ = 0xff;
2232                 *p++ = 0x03;
2233         }
2234
2235         /* Stuff proto, code, id and length */
2236         p = skb_put(skb, 6);
2237         *p++ = (proto >> 8);
2238         *p++ = (proto & 0xff);
2239         *p++ = code;
2240         *p++ = id;
2241         cnt = 4 + len;
2242         *p++ = (cnt >> 8);
2243         *p++ = (cnt & 0xff);
2244
2245         /* Now stuff remaining bytes */
2246         if (len) {
2247                 p = skb_put(skb, len);
2248                 memcpy(p, data, len);
2249         }
2250
2251         /* skb is now ready for xmit */
2252         printk(KERN_DEBUG "Sending CCP Frame:\n");
2253         isdn_ppp_frame_log("ccp-xmit", skb->data, skb->len, 32, is->unit, lp->ppp_slot);
2254
2255         isdn_net_write_super(lp, skb);
2256 }
2257
2258 /* Allocate the reset state vector */
2259 static struct ippp_ccp_reset *isdn_ppp_ccp_reset_alloc(struct ippp_struct *is)
2260 {
2261         struct ippp_ccp_reset *r;
2262         r = kzalloc(sizeof(struct ippp_ccp_reset), GFP_KERNEL);
2263         if (!r) {
2264                 printk(KERN_ERR "ippp_ccp: failed to allocate reset data"
2265                        " structure - no mem\n");
2266                 return NULL;
2267         }
2268         printk(KERN_DEBUG "ippp_ccp: allocated reset data structure %p\n", r);
2269         is->reset = r;
2270         return r;
2271 }
2272
2273 /* Destroy the reset state vector. Kill all pending timers first. */
2274 static void isdn_ppp_ccp_reset_free(struct ippp_struct *is)
2275 {
2276         unsigned int id;
2277
2278         printk(KERN_DEBUG "ippp_ccp: freeing reset data structure %p\n",
2279                is->reset);
2280         for (id = 0; id < 256; id++) {
2281                 if (is->reset->rs[id]) {
2282                         isdn_ppp_ccp_reset_free_state(is, (unsigned char)id);
2283                 }
2284         }
2285         kfree(is->reset);
2286         is->reset = NULL;
2287 }
2288
2289 /* Free a given state and clear everything up for later reallocation */
2290 static void isdn_ppp_ccp_reset_free_state(struct ippp_struct *is,
2291                                           unsigned char id)
2292 {
2293         struct ippp_ccp_reset_state *rs;
2294
2295         if (is->reset->rs[id]) {
2296                 printk(KERN_DEBUG "ippp_ccp: freeing state for id %d\n", id);
2297                 rs = is->reset->rs[id];
2298                 /* Make sure the kernel will not call back later */
2299                 if (rs->ta)
2300                         del_timer(&rs->timer);
2301                 is->reset->rs[id] = NULL;
2302                 kfree(rs);
2303         } else {
2304                 printk(KERN_WARNING "ippp_ccp: id %d is not allocated\n", id);
2305         }
2306 }
2307
2308 /* The timer callback function which is called when a ResetReq has timed out,
2309    aka has never been answered by a ResetAck */
2310 static void isdn_ppp_ccp_timer_callback(unsigned long closure)
2311 {
2312         struct ippp_ccp_reset_state *rs =
2313                 (struct ippp_ccp_reset_state *)closure;
2314
2315         if (!rs) {
2316                 printk(KERN_ERR "ippp_ccp: timer cb with zero closure.\n");
2317                 return;
2318         }
2319         if (rs->ta && rs->state == CCPResetSentReq) {
2320                 /* We are correct here */
2321                 if (!rs->expra) {
2322                         /* Hmm, there is no Ack really expected. We can clean
2323                            up the state now, it will be reallocated if the
2324                            decompressor insists on another reset */
2325                         rs->ta = 0;
2326                         isdn_ppp_ccp_reset_free_state(rs->is, rs->id);
2327                         return;
2328                 }
2329                 printk(KERN_DEBUG "ippp_ccp: CCP Reset timed out for id %d\n",
2330                        rs->id);
2331                 /* Push it again */
2332                 isdn_ppp_ccp_xmit_reset(rs->is, PPP_CCP, CCP_RESETREQ, rs->id,
2333                                         rs->data, rs->dlen);
2334                 /* Restart timer */
2335                 rs->timer.expires = jiffies + HZ * 5;
2336                 add_timer(&rs->timer);
2337         } else {
2338                 printk(KERN_WARNING "ippp_ccp: timer cb in wrong state %d\n",
2339                        rs->state);
2340         }
2341 }
2342
2343 /* Allocate a new reset transaction state */
2344 static struct ippp_ccp_reset_state *isdn_ppp_ccp_reset_alloc_state(struct ippp_struct *is,
2345                                                                    unsigned char id)
2346 {
2347         struct ippp_ccp_reset_state *rs;
2348         if (is->reset->rs[id]) {
2349                 printk(KERN_WARNING "ippp_ccp: old state exists for id %d\n",
2350                        id);
2351                 return NULL;
2352         } else {
2353                 rs = kzalloc(sizeof(struct ippp_ccp_reset_state), GFP_KERNEL);
2354                 if (!rs)
2355                         return NULL;
2356                 rs->state = CCPResetIdle;
2357                 rs->is = is;
2358                 rs->id = id;
2359                 init_timer(&rs->timer);
2360                 rs->timer.data = (unsigned long)rs;
2361                 rs->timer.function = isdn_ppp_ccp_timer_callback;
2362                 is->reset->rs[id] = rs;
2363         }
2364         return rs;
2365 }
2366
2367
2368 /* A decompressor wants a reset with a set of parameters - do what is
2369    necessary to fulfill it */
2370 static void isdn_ppp_ccp_reset_trans(struct ippp_struct *is,
2371                                      struct isdn_ppp_resetparams *rp)
2372 {
2373         struct ippp_ccp_reset_state *rs;
2374
2375         if (rp->valid) {
2376                 /* The decompressor defines parameters by itself */
2377                 if (rp->rsend) {
2378                         /* And he wants us to send a request */
2379                         if (!(rp->idval)) {
2380                                 printk(KERN_ERR "ippp_ccp: decompressor must"
2381                                        " specify reset id\n");
2382                                 return;
2383                         }
2384                         if (is->reset->rs[rp->id]) {
2385                                 /* There is already a transaction in existence
2386                                    for this id. May be still waiting for a
2387                                    Ack or may be wrong. */
2388                                 rs = is->reset->rs[rp->id];
2389                                 if (rs->state == CCPResetSentReq && rs->ta) {
2390                                         printk(KERN_DEBUG "ippp_ccp: reset"
2391                                                " trans still in progress"
2392                                                " for id %d\n", rp->id);
2393                                 } else {
2394                                         printk(KERN_WARNING "ippp_ccp: reset"
2395                                                " trans in wrong state %d for"
2396                                                " id %d\n", rs->state, rp->id);
2397                                 }
2398                         } else {
2399                                 /* Ok, this is a new transaction */
2400                                 printk(KERN_DEBUG "ippp_ccp: new trans for id"
2401                                        " %d to be started\n", rp->id);
2402                                 rs = isdn_ppp_ccp_reset_alloc_state(is, rp->id);
2403                                 if (!rs) {
2404                                         printk(KERN_ERR "ippp_ccp: out of mem"
2405                                                " allocing ccp trans\n");
2406                                         return;
2407                                 }
2408                                 rs->state = CCPResetSentReq;
2409                                 rs->expra = rp->expra;
2410                                 if (rp->dtval) {
2411                                         rs->dlen = rp->dlen;
2412                                         memcpy(rs->data, rp->data, rp->dlen);
2413                                 }
2414                                 /* HACK TODO - add link comp here */
2415                                 isdn_ppp_ccp_xmit_reset(is, PPP_CCP,
2416                                                         CCP_RESETREQ, rs->id,
2417                                                         rs->data, rs->dlen);
2418                                 /* Start the timer */
2419                                 rs->timer.expires = jiffies + 5 * HZ;
2420                                 add_timer(&rs->timer);
2421                                 rs->ta = 1;
2422                         }
2423                 } else {
2424                         printk(KERN_DEBUG "ippp_ccp: no reset sent\n");
2425                 }
2426         } else {
2427                 /* The reset params are invalid. The decompressor does not
2428                    care about them, so we just send the minimal requests
2429                    and increase ids only when an Ack is received for a
2430                    given id */
2431                 if (is->reset->rs[is->reset->lastid]) {
2432                         /* There is already a transaction in existence
2433                            for this id. May be still waiting for a
2434                            Ack or may be wrong. */
2435                         rs = is->reset->rs[is->reset->lastid];
2436                         if (rs->state == CCPResetSentReq && rs->ta) {
2437                                 printk(KERN_DEBUG "ippp_ccp: reset"
2438                                        " trans still in progress"
2439                                        " for id %d\n", rp->id);
2440                         } else {
2441                                 printk(KERN_WARNING "ippp_ccp: reset"
2442                                        " trans in wrong state %d for"
2443                                        " id %d\n", rs->state, rp->id);
2444                         }
2445                 } else {
2446                         printk(KERN_DEBUG "ippp_ccp: new trans for id"
2447                                " %d to be started\n", is->reset->lastid);
2448                         rs = isdn_ppp_ccp_reset_alloc_state(is,
2449                                                             is->reset->lastid);
2450                         if (!rs) {
2451                                 printk(KERN_ERR "ippp_ccp: out of mem"
2452                                        " allocing ccp trans\n");
2453                                 return;
2454                         }
2455                         rs->state = CCPResetSentReq;
2456                         /* We always expect an Ack if the decompressor doesn't
2457                            know better */
2458                         rs->expra = 1;
2459                         rs->dlen = 0;
2460                         /* HACK TODO - add link comp here */
2461                         isdn_ppp_ccp_xmit_reset(is, PPP_CCP, CCP_RESETREQ,
2462                                                 rs->id, NULL, 0);
2463                         /* Start the timer */
2464                         rs->timer.expires = jiffies + 5 * HZ;
2465                         add_timer(&rs->timer);
2466                         rs->ta = 1;
2467                 }
2468         }
2469 }
2470
2471 /* An Ack was received for this id. This means we stop the timer and clean
2472    up the state prior to calling the decompressors reset routine. */
2473 static void isdn_ppp_ccp_reset_ack_rcvd(struct ippp_struct *is,
2474                                         unsigned char id)
2475 {
2476         struct ippp_ccp_reset_state *rs = is->reset->rs[id];
2477
2478         if (rs) {
2479                 if (rs->ta && rs->state == CCPResetSentReq) {
2480                         /* Great, we are correct */
2481                         if (!rs->expra)
2482                                 printk(KERN_DEBUG "ippp_ccp: ResetAck received"
2483                                        " for id %d but not expected\n", id);
2484                 } else {
2485                         printk(KERN_INFO "ippp_ccp: ResetAck received out of"
2486                                "sync for id %d\n", id);
2487                 }
2488                 if (rs->ta) {
2489                         rs->ta = 0;
2490                         del_timer(&rs->timer);
2491                 }
2492                 isdn_ppp_ccp_reset_free_state(is, id);
2493         } else {
2494                 printk(KERN_INFO "ippp_ccp: ResetAck received for unknown id"
2495                        " %d\n", id);
2496         }
2497         /* Make sure the simple reset stuff uses a new id next time */
2498         is->reset->lastid++;
2499 }
2500
2501 /*
2502  * decompress packet
2503  *
2504  * if master = 0, we're trying to uncompress an per-link compressed packet,
2505  * as opposed to an compressed reconstructed-from-MPPP packet.
2506  * proto is updated to protocol field of uncompressed packet.
2507  *
2508  * retval: decompressed packet,
2509  *         same packet if uncompressed,
2510  *         NULL if decompression error
2511  */
2512
2513 static struct sk_buff *isdn_ppp_decompress(struct sk_buff *skb, struct ippp_struct *is, struct ippp_struct *master,
2514                                            int *proto)
2515 {
2516         void *stat = NULL;
2517         struct isdn_ppp_compressor *ipc = NULL;
2518         struct sk_buff *skb_out;
2519         int len;
2520         struct ippp_struct *ri;
2521         struct isdn_ppp_resetparams rsparm;
2522         unsigned char rsdata[IPPP_RESET_MAXDATABYTES];
2523
2524         if (!master) {
2525                 // per-link decompression
2526                 stat = is->link_decomp_stat;
2527                 ipc = is->link_decompressor;
2528                 ri = is;
2529         } else {
2530                 stat = master->decomp_stat;
2531                 ipc = master->decompressor;
2532                 ri = master;
2533         }
2534
2535         if (!ipc) {
2536                 // no decompressor -> we can't decompress.
2537                 printk(KERN_DEBUG "ippp: no decompressor defined!\n");
2538                 return skb;
2539         }
2540         BUG_ON(!stat); // if we have a compressor, stat has been set as well
2541
2542         if ((master && *proto == PPP_COMP) || (!master && *proto == PPP_COMPFRAG)) {
2543                 // compressed packets are compressed by their protocol type
2544
2545                 // Set up reset params for the decompressor
2546                 memset(&rsparm, 0, sizeof(rsparm));
2547                 rsparm.data = rsdata;
2548                 rsparm.maxdlen = IPPP_RESET_MAXDATABYTES;
2549
2550                 skb_out = dev_alloc_skb(is->mru + PPP_HDRLEN);
2551                 if (!skb_out) {
2552                         kfree_skb(skb);
2553                         printk(KERN_ERR "ippp: decomp memory allocation failure\n");
2554                         return NULL;
2555                 }
2556                 len = ipc->decompress(stat, skb, skb_out, &rsparm);
2557                 kfree_skb(skb);
2558                 if (len <= 0) {
2559                         switch (len) {
2560                         case DECOMP_ERROR:
2561                                 printk(KERN_INFO "ippp: decomp wants reset %s params\n",
2562                                        rsparm.valid ? "with" : "without");
2563
2564                                 isdn_ppp_ccp_reset_trans(ri, &rsparm);
2565                                 break;
2566                         case DECOMP_FATALERROR:
2567                                 ri->pppcfg |= SC_DC_FERROR;
2568                                 /* Kick ipppd to recognize the error */
2569                                 isdn_ppp_ccp_kickup(ri);
2570                                 break;
2571                         }
2572                         kfree_skb(skb_out);
2573                         return NULL;
2574                 }
2575                 *proto = isdn_ppp_strip_proto(skb_out);
2576                 if (*proto < 0) {
2577                         kfree_skb(skb_out);
2578                         return NULL;
2579                 }
2580                 return skb_out;
2581         } else {
2582                 // uncompressed packets are fed through the decompressor to
2583                 // update the decompressor state
2584                 ipc->incomp(stat, skb, *proto);
2585                 return skb;
2586         }
2587 }
2588
2589 /*
2590  * compress a frame
2591  *   type=0: normal/bundle compression
2592  *       =1: link compression
2593  * returns original skb if we haven't compressed the frame
2594  * and a new skb pointer if we've done it
2595  */
2596 static struct sk_buff *isdn_ppp_compress(struct sk_buff *skb_in, int *proto,
2597                                          struct ippp_struct *is, struct ippp_struct *master, int type)
2598 {
2599         int ret;
2600         int new_proto;
2601         struct isdn_ppp_compressor *compressor;
2602         void *stat;
2603         struct sk_buff *skb_out;
2604
2605         /* we do not compress control protocols */
2606         if (*proto < 0 || *proto > 0x3fff) {
2607                 return skb_in;
2608         }
2609
2610         if (type) { /* type=1 => Link compression */
2611                 return skb_in;
2612         }
2613         else {
2614                 if (!master) {
2615                         compressor = is->compressor;
2616                         stat = is->comp_stat;
2617                 }
2618                 else {
2619                         compressor = master->compressor;
2620                         stat = master->comp_stat;
2621                 }
2622                 new_proto = PPP_COMP;
2623         }
2624
2625         if (!compressor) {
2626                 printk(KERN_ERR "isdn_ppp: No compressor set!\n");
2627                 return skb_in;
2628         }
2629         if (!stat) {
2630                 printk(KERN_ERR "isdn_ppp: Compressor not initialized?\n");
2631                 return skb_in;
2632         }
2633
2634         /* Allow for at least 150 % expansion (for now) */
2635         skb_out = alloc_skb(skb_in->len + skb_in->len / 2 + 32 +
2636                             skb_headroom(skb_in), GFP_ATOMIC);
2637         if (!skb_out)
2638                 return skb_in;
2639         skb_reserve(skb_out, skb_headroom(skb_in));
2640
2641         ret = (compressor->compress)(stat, skb_in, skb_out, *proto);
2642         if (!ret) {
2643                 dev_kfree_skb(skb_out);
2644                 return skb_in;
2645         }
2646
2647         dev_kfree_skb(skb_in);
2648         *proto = new_proto;
2649         return skb_out;
2650 }
2651
2652 /*
2653  * we received a CCP frame ..
2654  * not a clean solution, but we MUST handle a few cases in the kernel
2655  */
2656 static void isdn_ppp_receive_ccp(isdn_net_dev *net_dev, isdn_net_local *lp,
2657                                  struct sk_buff *skb, int proto)
2658 {
2659         struct ippp_struct *is;
2660         struct ippp_struct *mis;
2661         int len;
2662         struct isdn_ppp_resetparams rsparm;
2663         unsigned char rsdata[IPPP_RESET_MAXDATABYTES];
2664
2665         printk(KERN_DEBUG "Received CCP frame from peer slot(%d)\n",
2666                lp->ppp_slot);
2667         if (lp->ppp_slot < 0 || lp->ppp_slot >= ISDN_MAX_CHANNELS) {
2668                 printk(KERN_ERR "%s: lp->ppp_slot(%d) out of range\n",
2669                        __func__, lp->ppp_slot);
2670                 return;
2671         }
2672         is = ippp_table[lp->ppp_slot];
2673         isdn_ppp_frame_log("ccp-rcv", skb->data, skb->len, 32, is->unit, lp->ppp_slot);
2674
2675         if (lp->master) {
2676                 int slot = ISDN_MASTER_PRIV(lp)->ppp_slot;
2677                 if (slot < 0 || slot >= ISDN_MAX_CHANNELS) {
2678                         printk(KERN_ERR "%s: slot(%d) out of range\n",
2679                                __func__, slot);
2680                         return;
2681                 }
2682                 mis = ippp_table[slot];
2683         } else
2684                 mis = is;
2685
2686         switch (skb->data[0]) {
2687         case CCP_CONFREQ:
2688                 if (is->debug & 0x10)
2689                         printk(KERN_DEBUG "Disable compression here!\n");
2690                 if (proto == PPP_CCP)
2691                         mis->compflags &= ~SC_COMP_ON;
2692                 else
2693                         is->compflags &= ~SC_LINK_COMP_ON;
2694                 break;
2695         case CCP_TERMREQ:
2696         case CCP_TERMACK:
2697                 if (is->debug & 0x10)
2698                         printk(KERN_DEBUG "Disable (de)compression here!\n");
2699                 if (proto == PPP_CCP)
2700                         mis->compflags &= ~(SC_DECOMP_ON | SC_COMP_ON);
2701                 else
2702                         is->compflags &= ~(SC_LINK_DECOMP_ON | SC_LINK_COMP_ON);
2703                 break;
2704         case CCP_CONFACK:
2705                 /* if we RECEIVE an ackowledge we enable the decompressor */
2706                 if (is->debug & 0x10)
2707                         printk(KERN_DEBUG "Enable decompression here!\n");
2708                 if (proto == PPP_CCP) {
2709                         if (!mis->decompressor)
2710                                 break;
2711                         mis->compflags |= SC_DECOMP_ON;
2712                 } else {
2713                         if (!is->decompressor)
2714                                 break;
2715                         is->compflags |= SC_LINK_DECOMP_ON;
2716                 }
2717                 break;
2718
2719         case CCP_RESETACK:
2720                 printk(KERN_DEBUG "Received ResetAck from peer\n");
2721                 len = (skb->data[2] << 8) | skb->data[3];
2722                 len -= 4;
2723
2724                 if (proto == PPP_CCP) {
2725                         /* If a reset Ack was outstanding for this id, then
2726                            clean up the state engine */
2727                         isdn_ppp_ccp_reset_ack_rcvd(mis, skb->data[1]);
2728                         if (mis->decompressor && mis->decomp_stat)
2729                                 mis->decompressor->
2730                                         reset(mis->decomp_stat,
2731                                               skb->data[0],
2732                                               skb->data[1],
2733                                               len ? &skb->data[4] : NULL,
2734                                               len, NULL);
2735                         /* TODO: This is not easy to decide here */
2736                         mis->compflags &= ~SC_DECOMP_DISCARD;
2737                 }
2738                 else {
2739                         isdn_ppp_ccp_reset_ack_rcvd(is, skb->data[1]);
2740                         if (is->link_decompressor && is->link_decomp_stat)
2741                                 is->link_decompressor->
2742                                         reset(is->link_decomp_stat,
2743                                               skb->data[0],
2744                                               skb->data[1],
2745                                               len ? &skb->data[4] : NULL,
2746                                               len, NULL);
2747                         /* TODO: neither here */
2748                         is->compflags &= ~SC_LINK_DECOMP_DISCARD;
2749                 }
2750                 break;
2751
2752         case CCP_RESETREQ:
2753                 printk(KERN_DEBUG "Received ResetReq from peer\n");
2754                 /* Receiving a ResetReq means we must reset our compressor */
2755                 /* Set up reset params for the reset entry */
2756                 memset(&rsparm, 0, sizeof(rsparm));
2757                 rsparm.data = rsdata;
2758                 rsparm.maxdlen = IPPP_RESET_MAXDATABYTES;
2759                 /* Isolate data length */
2760                 len = (skb->data[2] << 8) | skb->data[3];
2761                 len -= 4;
2762                 if (proto == PPP_CCP) {
2763                         if (mis->compressor && mis->comp_stat)
2764                                 mis->compressor->
2765                                         reset(mis->comp_stat,
2766                                               skb->data[0],
2767                                               skb->data[1],
2768                                               len ? &skb->data[4] : NULL,
2769                                               len, &rsparm);
2770                 }
2771                 else {
2772                         if (is->link_compressor && is->link_comp_stat)
2773                                 is->link_compressor->
2774                                         reset(is->link_comp_stat,
2775                                               skb->data[0],
2776                                               skb->data[1],
2777                                               len ? &skb->data[4] : NULL,
2778                                               len, &rsparm);
2779                 }
2780                 /* Ack the Req as specified by rsparm */
2781                 if (rsparm.valid) {
2782                         /* Compressor reset handler decided how to answer */
2783                         if (rsparm.rsend) {
2784                                 /* We should send a Frame */
2785                                 isdn_ppp_ccp_xmit_reset(is, proto, CCP_RESETACK,
2786                                                         rsparm.idval ? rsparm.id
2787                                                         : skb->data[1],
2788                                                         rsparm.dtval ?
2789                                                         rsparm.data : NULL,
2790                                                         rsparm.dtval ?
2791                                                         rsparm.dlen : 0);
2792                         } else {
2793                                 printk(KERN_DEBUG "ResetAck suppressed\n");
2794                         }
2795                 } else {
2796                         /* We answer with a straight reflected Ack */
2797                         isdn_ppp_ccp_xmit_reset(is, proto, CCP_RESETACK,
2798                                                 skb->data[1],
2799                                                 len ? &skb->data[4] : NULL,
2800                                                 len);
2801                 }
2802                 break;
2803         }
2804 }
2805
2806
2807 /*
2808  * Daemon sends a CCP frame ...
2809  */
2810
2811 /* TODO: Clean this up with new Reset semantics */
2812
2813 /* I believe the CCP handling as-is is done wrong. Compressed frames
2814  * should only be sent/received after CCP reaches UP state, which means
2815  * both sides have sent CONF_ACK. Currently, we handle both directions
2816  * independently, which means we may accept compressed frames too early
2817  * (supposedly not a problem), but may also mean we send compressed frames
2818  * too early, which may turn out to be a problem.
2819  * This part of state machine should actually be handled by (i)pppd, but
2820  * that's too big of a change now. --kai
2821  */
2822
2823 /* Actually, we might turn this into an advantage: deal with the RFC in
2824  * the old tradition of beeing generous on what we accept, but beeing
2825  * strict on what we send. Thus we should just
2826  * - accept compressed frames as soon as decompression is negotiated
2827  * - send compressed frames only when decomp *and* comp are negotiated
2828  * - drop rx compressed frames if we cannot decomp (instead of pushing them
2829  *   up to ipppd)
2830  * and I tried to modify this file according to that. --abp
2831  */
2832
2833 static void isdn_ppp_send_ccp(isdn_net_dev *net_dev, isdn_net_local *lp, struct sk_buff *skb)
2834 {
2835         struct ippp_struct *mis, *is;
2836         int proto, slot = lp->ppp_slot;
2837         unsigned char *data;
2838
2839         if (!skb || skb->len < 3)
2840                 return;
2841         if (slot < 0 || slot >= ISDN_MAX_CHANNELS) {
2842                 printk(KERN_ERR "%s: lp->ppp_slot(%d) out of range\n",
2843                        __func__, slot);
2844                 return;
2845         }
2846         is = ippp_table[slot];
2847         /* Daemon may send with or without address and control field comp */
2848         data = skb->data;
2849         if (!(is->pppcfg & SC_COMP_AC) && data[0] == 0xff && data[1] == 0x03) {
2850                 data += 2;
2851                 if (skb->len < 5)
2852                         return;
2853         }
2854
2855         proto = ((int)data[0]<<8) + data[1];
2856         if (proto != PPP_CCP && proto != PPP_CCPFRAG)
2857                 return;
2858
2859         printk(KERN_DEBUG "Received CCP frame from daemon:\n");
2860         isdn_ppp_frame_log("ccp-xmit", skb->data, skb->len, 32, is->unit, lp->ppp_slot);
2861
2862         if (lp->master) {
2863                 slot = ISDN_MASTER_PRIV(lp)->ppp_slot;
2864                 if (slot < 0 || slot >= ISDN_MAX_CHANNELS) {
2865                         printk(KERN_ERR "%s: slot(%d) out of range\n",
2866                                __func__, slot);
2867                         return;
2868                 }
2869                 mis = ippp_table[slot];
2870         } else
2871                 mis = is;
2872         if (mis != is)
2873                 printk(KERN_DEBUG "isdn_ppp: Ouch! Master CCP sends on slave slot!\n");
2874
2875         switch (data[2]) {
2876         case CCP_CONFREQ:
2877                 if (is->debug & 0x10)
2878                         printk(KERN_DEBUG "Disable decompression here!\n");
2879                 if (proto == PPP_CCP)
2880                         is->compflags &= ~SC_DECOMP_ON;
2881                 else
2882                         is->compflags &= ~SC_LINK_DECOMP_ON;
2883                 break;
2884         case CCP_TERMREQ:
2885         case CCP_TERMACK:
2886                 if (is->debug & 0x10)
2887                         printk(KERN_DEBUG "Disable (de)compression here!\n");
2888                 if (proto == PPP_CCP)
2889                         is->compflags &= ~(SC_DECOMP_ON | SC_COMP_ON);
2890                 else
2891                         is->compflags &= ~(SC_LINK_DECOMP_ON | SC_LINK_COMP_ON);
2892                 break;
2893         case CCP_CONFACK:
2894                 /* if we SEND an ackowledge we can/must enable the compressor */
2895                 if (is->debug & 0x10)
2896                         printk(KERN_DEBUG "Enable compression here!\n");
2897                 if (proto == PPP_CCP) {
2898                         if (!is->compressor)
2899                                 break;
2900                         is->compflags |= SC_COMP_ON;
2901                 } else {
2902                         if (!is->compressor)
2903                                 break;
2904                         is->compflags |= SC_LINK_COMP_ON;
2905                 }
2906                 break;
2907         case CCP_RESETACK:
2908                 /* If we send a ACK we should reset our compressor */
2909                 if (is->debug & 0x10)
2910                         printk(KERN_DEBUG "Reset decompression state here!\n");
2911                 printk(KERN_DEBUG "ResetAck from daemon passed by\n");
2912                 if (proto == PPP_CCP) {
2913                         /* link to master? */
2914                         if (is->compressor && is->comp_stat)
2915                                 is->compressor->reset(is->comp_stat, 0, 0,
2916                                                       NULL, 0, NULL);
2917                         is->compflags &= ~SC_COMP_DISCARD;
2918                 }
2919                 else {
2920                         if (is->link_compressor && is->link_comp_stat)
2921                                 is->link_compressor->reset(is->link_comp_stat,
2922                                                            0, 0, NULL, 0, NULL);
2923                         is->compflags &= ~SC_LINK_COMP_DISCARD;
2924                 }
2925                 break;
2926         case CCP_RESETREQ:
2927                 /* Just let it pass by */
2928                 printk(KERN_DEBUG "ResetReq from daemon passed by\n");
2929                 break;
2930         }
2931 }
2932
2933 int isdn_ppp_register_compressor(struct isdn_ppp_compressor *ipc)
2934 {
2935         ipc->next = ipc_head;
2936         ipc->prev = NULL;
2937         if (ipc_head) {
2938                 ipc_head->prev = ipc;
2939         }
2940         ipc_head = ipc;
2941         return 0;
2942 }
2943
2944 int isdn_ppp_unregister_compressor(struct isdn_ppp_compressor *ipc)
2945 {
2946         if (ipc->prev)
2947                 ipc->prev->next = ipc->next;
2948         else
2949                 ipc_head = ipc->next;
2950         if (ipc->next)
2951                 ipc->next->prev = ipc->prev;
2952         ipc->prev = ipc->next = NULL;
2953         return 0;
2954 }
2955
2956 static int isdn_ppp_set_compressor(struct ippp_struct *is, struct isdn_ppp_comp_data *data)
2957 {
2958         struct isdn_ppp_compressor *ipc = ipc_head;
2959         int ret;
2960         void *stat;
2961         int num = data->num;
2962
2963         if (is->debug & 0x10)
2964                 printk(KERN_DEBUG "[%d] Set %s type %d\n", is->unit,
2965                        (data->flags & IPPP_COMP_FLAG_XMIT) ? "compressor" : "decompressor", num);
2966
2967         /* If is has no valid reset state vector, we cannot allocate a
2968            decompressor. The decompressor would cause reset transactions
2969            sooner or later, and they need that vector. */
2970
2971         if (!(data->flags & IPPP_COMP_FLAG_XMIT) && !is->reset) {
2972                 printk(KERN_ERR "ippp_ccp: no reset data structure - can't"
2973                        " allow decompression.\n");
2974                 return -ENOMEM;
2975         }
2976
2977         while (ipc) {
2978                 if (ipc->num == num) {
2979                         stat = ipc->alloc(data);
2980                         if (stat) {
2981                                 ret = ipc->init(stat, data, is->unit, 0);
2982                                 if (!ret) {
2983                                         printk(KERN_ERR "Can't init (de)compression!\n");
2984                                         ipc->free(stat);
2985                                         stat = NULL;
2986                                         break;
2987                                 }
2988                         }
2989                         else {
2990                                 printk(KERN_ERR "Can't alloc (de)compression!\n");
2991                                 break;
2992                         }
2993
2994                         if (data->flags & IPPP_COMP_FLAG_XMIT) {
2995                                 if (data->flags & IPPP_COMP_FLAG_LINK) {
2996                                         if (is->link_comp_stat)
2997                                                 is->link_compressor->free(is->link_comp_stat);
2998                                         is->link_comp_stat = stat;
2999                                         is->link_compressor = ipc;
3000                                 }
3001                                 else {
3002                                         if (is->comp_stat)
3003                                                 is->compressor->free(is->comp_stat);
3004                                         is->comp_stat = stat;
3005                                         is->compressor = ipc;
3006                                 }
3007                         }
3008                         else {
3009                                 if (data->flags & IPPP_COMP_FLAG_LINK) {
3010                                         if (is->link_decomp_stat)
3011                                                 is->link_decompressor->free(is->link_decomp_stat);
3012                                         is->link_decomp_stat = stat;
3013                                         is->link_decompressor = ipc;
3014                                 }
3015                                 else {
3016                                         if (is->decomp_stat)
3017                                                 is->decompressor->free(is->decomp_stat);
3018                                         is->decomp_stat = stat;
3019                                         is->decompressor = ipc;
3020                                 }
3021                         }
3022                         return 0;
3023                 }
3024                 ipc = ipc->next;
3025         }
3026         return -EINVAL;
3027 }