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