drivers/isdn/i4l/isdn_ppp.c

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