SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/isdn/i4l/isdn_ppp.c

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