drivers/isdn/i4l/isdn_ppp.c

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