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

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