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