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