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