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