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) == 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) == 0)) {
1158                 if (is->debug & 0x2)
1159                         printk(KERN_DEBUG "IPPP: link-active filter: reseting huptimer.\n");
1160                 lp->huptimer = 0;
1161                 if (mlp)
1162                         mlp->huptimer = 0;
1163         }
1164         skb_pull(skb, 4);
1165 #else /* CONFIG_IPPP_FILTER */
1166         lp->huptimer = 0;
1167         if (mlp)
1168                 mlp->huptimer = 0;
1169 #endif /* CONFIG_IPPP_FILTER */
1170         skb->dev = dev;
1171         skb_reset_mac_header(skb);
1172         netif_rx(skb);
1173         /* net_dev->local->stats.rx_packets++; done in isdn_net.c */
1174         return;
1175
1176  drop_packet:
1177         net_dev->local->stats.rx_dropped++;
1178         kfree_skb(skb);
1179 }
1180
1181 /*
1182  * isdn_ppp_skb_push ..
1183  * checks whether we have enough space at the beginning of the skb
1184  * and allocs a new SKB if necessary
1185  */
1186 static unsigned char *isdn_ppp_skb_push(struct sk_buff **skb_p,int len)
1187 {
1188         struct sk_buff *skb = *skb_p;
1189
1190         if(skb_headroom(skb) < len) {
1191                 struct sk_buff *nskb = skb_realloc_headroom(skb, len);
1192
1193                 if (!nskb) {
1194                         printk(KERN_ERR "isdn_ppp_skb_push: can't realloc headroom!\n");
1195                         dev_kfree_skb(skb);
1196                         return NULL;
1197                 }
1198                 printk(KERN_DEBUG "isdn_ppp_skb_push:under %d %d\n",skb_headroom(skb),len);
1199                 dev_kfree_skb(skb);
1200                 *skb_p = nskb;
1201                 return skb_push(nskb, len);
1202         }
1203         return skb_push(skb,len);
1204 }
1205
1206 /*
1207  * send ppp frame .. we expect a PIDCOMPressable proto --
1208  *  (here: currently always PPP_IP,PPP_VJC_COMP,PPP_VJC_UNCOMP)
1209  *
1210  * VJ compression may change skb pointer!!! .. requeue with old
1211  * skb isn't allowed!!
1212  */
1213
1214 int
1215 isdn_ppp_xmit(struct sk_buff *skb, struct net_device *netdev)
1216 {
1217         isdn_net_local *lp,*mlp;
1218         isdn_net_dev *nd;
1219         unsigned int proto = PPP_IP;     /* 0x21 */
1220         struct ippp_struct *ipt,*ipts;
1221         int slot, retval = NETDEV_TX_OK;
1222
1223         mlp = netdev_priv(netdev);
1224         nd = mlp->netdev;       /* get master lp */
1225
1226         slot = mlp->ppp_slot;
1227         if (slot < 0 || slot >= ISDN_MAX_CHANNELS) {
1228                 printk(KERN_ERR "isdn_ppp_xmit: lp->ppp_slot(%d)\n",
1229                         mlp->ppp_slot);
1230                 kfree_skb(skb);
1231                 goto out;
1232         }
1233         ipts = ippp_table[slot];
1234
1235         if (!(ipts->pppcfg & SC_ENABLE_IP)) {   /* PPP connected ? */
1236                 if (ipts->debug & 0x1)
1237                         printk(KERN_INFO "%s: IP frame delayed.\n", netdev->name);
1238                 retval = NETDEV_TX_BUSY;
1239                 goto out;
1240         }
1241
1242         switch (ntohs(skb->protocol)) {
1243                 case ETH_P_IP:
1244                         proto = PPP_IP;
1245                         break;
1246                 case ETH_P_IPX:
1247                         proto = PPP_IPX;        /* untested */
1248                         break;
1249                 default:
1250                         printk(KERN_ERR "isdn_ppp: skipped unsupported protocol: %#x.\n",
1251                                skb->protocol);
1252                         dev_kfree_skb(skb);
1253                         goto out;
1254         }
1255
1256         lp = isdn_net_get_locked_lp(nd);
1257         if (!lp) {
1258                 printk(KERN_WARNING "%s: all channels busy - requeuing!\n", netdev->name);
1259                 retval = NETDEV_TX_BUSY;
1260                 goto out;
1261         }
1262         /* we have our lp locked from now on */
1263
1264         slot = lp->ppp_slot;
1265         if (slot < 0 || slot >= ISDN_MAX_CHANNELS) {
1266                 printk(KERN_ERR "isdn_ppp_xmit: lp->ppp_slot(%d)\n",
1267                         lp->ppp_slot);
1268                 kfree_skb(skb);
1269                 goto unlock;
1270         }
1271         ipt = ippp_table[slot];
1272
1273         /*
1274          * after this line .. requeueing in the device queue is no longer allowed!!!
1275          */
1276
1277         /* Pull off the fake header we stuck on earlier to keep
1278          * the fragmentation code happy.
1279          */
1280         skb_pull(skb,IPPP_MAX_HEADER);
1281
1282 #ifdef CONFIG_IPPP_FILTER
1283         /* check if we should pass this packet
1284          * the filter instructions are constructed assuming
1285          * a four-byte PPP header on each packet */
1286         *skb_push(skb, 4) = 1; /* indicate outbound */
1287
1288         {
1289                 __be16 *p = (__be16 *)skb->data;
1290
1291                 p++;
1292                 *p = htons(proto);
1293         }
1294
1295         if (ipt->pass_filter
1296             && sk_run_filter(skb, ipt->pass_filter) == 0) {
1297                 if (ipt->debug & 0x4)
1298                         printk(KERN_DEBUG "IPPP: outbound frame filtered.\n");
1299                 kfree_skb(skb);
1300                 goto unlock;
1301         }
1302         if (!(ipt->active_filter
1303               && sk_run_filter(skb, ipt->active_filter) == 0)) {
1304                 if (ipt->debug & 0x4)
1305                         printk(KERN_DEBUG "IPPP: link-active filter: reseting huptimer.\n");
1306                 lp->huptimer = 0;
1307         }
1308         skb_pull(skb, 4);
1309 #else /* CONFIG_IPPP_FILTER */
1310         lp->huptimer = 0;
1311 #endif /* CONFIG_IPPP_FILTER */
1312
1313         if (ipt->debug & 0x4)
1314                 printk(KERN_DEBUG "xmit skb, len %d\n", (int) skb->len);
1315         if (ipts->debug & 0x40)
1316                 isdn_ppp_frame_log("xmit0", skb->data, skb->len, 32,ipts->unit,lp->ppp_slot);
1317
1318 #ifdef CONFIG_ISDN_PPP_VJ
1319         if (proto == PPP_IP && ipts->pppcfg & SC_COMP_TCP) {    /* ipts here? probably yes, but check this again */
1320                 struct sk_buff *new_skb;
1321                 unsigned short hl;
1322                 /*
1323                  * we need to reserve enough space in front of
1324                  * sk_buff. old call to dev_alloc_skb only reserved
1325                  * 16 bytes, now we are looking what the driver want.
1326                  */
1327                 hl = dev->drv[lp->isdn_device]->interface->hl_hdrlen + IPPP_MAX_HEADER;
1328                 /*
1329                  * Note: hl might still be insufficient because the method
1330                  * above does not account for a possibible MPPP slave channel
1331                  * which had larger HL header space requirements than the
1332                  * master.
1333                  */
1334                 new_skb = alloc_skb(hl+skb->len, GFP_ATOMIC);
1335                 if (new_skb) {
1336                         u_char *buf;
1337                         int pktlen;
1338
1339                         skb_reserve(new_skb, hl);
1340                         new_skb->dev = skb->dev;
1341                         skb_put(new_skb, skb->len);
1342                         buf = skb->data;
1343
1344                         pktlen = slhc_compress(ipts->slcomp, skb->data, skb->len, new_skb->data,
1345                                  &buf, !(ipts->pppcfg & SC_NO_TCP_CCID));
1346
1347                         if (buf != skb->data) {
1348                                 if (new_skb->data != buf)
1349                                         printk(KERN_ERR "isdn_ppp: FATAL error after slhc_compress!!\n");
1350                                 dev_kfree_skb(skb);
1351                                 skb = new_skb;
1352                         } else {
1353                                 dev_kfree_skb(new_skb);
1354                         }
1355
1356                         skb_trim(skb, pktlen);
1357                         if (skb->data[0] & SL_TYPE_COMPRESSED_TCP) {    /* cslip? style -> PPP */
1358                                 proto = PPP_VJC_COMP;
1359                                 skb->data[0] ^= SL_TYPE_COMPRESSED_TCP;
1360                         } else {
1361                                 if (skb->data[0] >= SL_TYPE_UNCOMPRESSED_TCP)
1362                                         proto = PPP_VJC_UNCOMP;
1363                                 skb->data[0] = (skb->data[0] & 0x0f) | 0x40;
1364                         }
1365                 }
1366         }
1367 #endif
1368
1369         /*
1370          * normal (single link) or bundle compression
1371          */
1372         if(ipts->compflags & SC_COMP_ON) {
1373                 /* We send compressed only if both down- und upstream
1374                    compression is negotiated, that means, CCP is up */
1375                 if(ipts->compflags & SC_DECOMP_ON) {
1376                         skb = isdn_ppp_compress(skb,&proto,ipt,ipts,0);
1377                 } else {
1378                         printk(KERN_DEBUG "isdn_ppp: CCP not yet up - sending as-is\n");
1379                 }
1380         }
1381
1382         if (ipt->debug & 0x24)
1383                 printk(KERN_DEBUG "xmit2 skb, len %d, proto %04x\n", (int) skb->len, proto);
1384
1385 #ifdef CONFIG_ISDN_MPP
1386         if (ipt->mpppcfg & SC_MP_PROT) {
1387                 /* we get mp_seqno from static isdn_net_local */
1388                 long mp_seqno = ipts->mp_seqno;
1389                 ipts->mp_seqno++;
1390                 if (ipt->mpppcfg & SC_OUT_SHORT_SEQ) {
1391                         unsigned char *data = isdn_ppp_skb_push(&skb, 3);
1392                         if(!data)
1393                                 goto unlock;
1394                         mp_seqno &= 0xfff;
1395                         data[0] = MP_BEGIN_FRAG | MP_END_FRAG | ((mp_seqno >> 8) & 0xf);        /* (B)egin & (E)ndbit .. */
1396                         data[1] = mp_seqno & 0xff;
1397                         data[2] = proto;        /* PID compression */
1398                 } else {
1399                         unsigned char *data = isdn_ppp_skb_push(&skb, 5);
1400                         if(!data)
1401                                 goto unlock;
1402                         data[0] = MP_BEGIN_FRAG | MP_END_FRAG;  /* (B)egin & (E)ndbit .. */
1403                         data[1] = (mp_seqno >> 16) & 0xff;      /* sequence number: 24bit */
1404                         data[2] = (mp_seqno >> 8) & 0xff;
1405                         data[3] = (mp_seqno >> 0) & 0xff;
1406                         data[4] = proto;        /* PID compression */
1407                 }
1408                 proto = PPP_MP; /* MP Protocol, 0x003d */
1409         }
1410 #endif
1411
1412         /*
1413          * 'link in bundle' compression  ...
1414          */
1415         if(ipt->compflags & SC_LINK_COMP_ON)
1416                 skb = isdn_ppp_compress(skb,&proto,ipt,ipts,1);
1417
1418         if( (ipt->pppcfg & SC_COMP_PROT) && (proto <= 0xff) ) {
1419                 unsigned char *data = isdn_ppp_skb_push(&skb,1);
1420                 if(!data)
1421                         goto unlock;
1422                 data[0] = proto & 0xff;
1423         }
1424         else {
1425                 unsigned char *data = isdn_ppp_skb_push(&skb,2);
1426                 if(!data)
1427                         goto unlock;
1428                 data[0] = (proto >> 8) & 0xff;
1429                 data[1] = proto & 0xff;
1430         }
1431         if(!(ipt->pppcfg & SC_COMP_AC)) {
1432                 unsigned char *data = isdn_ppp_skb_push(&skb,2);
1433                 if(!data)
1434                         goto unlock;
1435                 data[0] = 0xff;    /* All Stations */
1436                 data[1] = 0x03;    /* Unnumbered information */
1437         }
1438
1439         /* tx-stats are now updated via BSENT-callback */
1440
1441         if (ipts->debug & 0x40) {
1442                 printk(KERN_DEBUG "skb xmit: len: %d\n", (int) skb->len);
1443                 isdn_ppp_frame_log("xmit", skb->data, skb->len, 32,ipt->unit,lp->ppp_slot);
1444         }
1445
1446         isdn_net_writebuf_skb(lp, skb);
1447
1448  unlock:
1449         spin_unlock_bh(&lp->xmit_lock);
1450  out:
1451         return retval;
1452 }
1453
1454 #ifdef CONFIG_IPPP_FILTER
1455 /*
1456  * check if this packet may trigger auto-dial.
1457  */
1458
1459 int isdn_ppp_autodial_filter(struct sk_buff *skb, isdn_net_local *lp)
1460 {
1461         struct ippp_struct *is = ippp_table[lp->ppp_slot];
1462         u_int16_t proto;
1463         int drop = 0;
1464
1465         switch (ntohs(skb->protocol)) {
1466         case ETH_P_IP:
1467                 proto = PPP_IP;
1468                 break;
1469         case ETH_P_IPX:
1470                 proto = PPP_IPX;
1471                 break;
1472         default:
1473                 printk(KERN_ERR "isdn_ppp_autodial_filter: unsupported protocol 0x%x.\n",
1474                        skb->protocol);
1475                 return 1;
1476         }
1477
1478         /* the filter instructions are constructed assuming
1479          * a four-byte PPP header on each packet. we have to
1480          * temporarily remove part of the fake header stuck on
1481          * earlier.
1482          */
1483         *skb_pull(skb, IPPP_MAX_HEADER - 4) = 1; /* indicate outbound */
1484
1485         {
1486                 __be16 *p = (__be16 *)skb->data;
1487
1488                 p++;
1489                 *p = htons(proto);
1490         }
1491
1492         drop |= is->pass_filter
1493                 && sk_run_filter(skb, is->pass_filter) == 0;
1494         drop |= is->active_filter
1495                 && sk_run_filter(skb, is->active_filter) == 0;
1496
1497         skb_push(skb, IPPP_MAX_HEADER - 4);
1498         return drop;
1499 }
1500 #endif
1501 #ifdef CONFIG_ISDN_MPP
1502
1503 /* this is _not_ rfc1990 header, but something we convert both short and long
1504  * headers to for convinience's sake:
1505  *      byte 0 is flags as in rfc1990
1506  *      bytes 1...4 is 24-bit seqence number converted to host byte order
1507  */
1508 #define MP_HEADER_LEN   5
1509
1510 #define MP_LONGSEQ_MASK         0x00ffffff
1511 #define MP_SHORTSEQ_MASK        0x00000fff
1512 #define MP_LONGSEQ_MAX          MP_LONGSEQ_MASK
1513 #define MP_SHORTSEQ_MAX         MP_SHORTSEQ_MASK
1514 #define MP_LONGSEQ_MAXBIT       ((MP_LONGSEQ_MASK+1)>>1)
1515 #define MP_SHORTSEQ_MAXBIT      ((MP_SHORTSEQ_MASK+1)>>1)
1516
1517 /* sequence-wrap safe comparisons (for long sequence)*/
1518 #define MP_LT(a,b)      ((a-b)&MP_LONGSEQ_MAXBIT)
1519 #define MP_LE(a,b)      !((b-a)&MP_LONGSEQ_MAXBIT)
1520 #define MP_GT(a,b)      ((b-a)&MP_LONGSEQ_MAXBIT)
1521 #define MP_GE(a,b)      !((a-b)&MP_LONGSEQ_MAXBIT)
1522
1523 #define MP_SEQ(f)       ((*(u32*)(f->data+1)))
1524 #define MP_FLAGS(f)     (f->data[0])
1525
1526 static int isdn_ppp_mp_bundle_array_init(void)
1527 {
1528         int i;
1529         int sz = ISDN_MAX_CHANNELS*sizeof(ippp_bundle);
1530         if( (isdn_ppp_bundle_arr = kzalloc(sz, GFP_KERNEL)) == NULL )
1531                 return -ENOMEM;
1532         for( i = 0; i < ISDN_MAX_CHANNELS; i++ )
1533                 spin_lock_init(&isdn_ppp_bundle_arr[i].lock);
1534         return 0;
1535 }
1536
1537 static ippp_bundle * isdn_ppp_mp_bundle_alloc(void)
1538 {
1539         int i;
1540         for( i = 0; i < ISDN_MAX_CHANNELS; i++ )
1541                 if (isdn_ppp_bundle_arr[i].ref_ct <= 0)
1542                         return (isdn_ppp_bundle_arr + i);
1543         return NULL;
1544 }
1545
1546 static int isdn_ppp_mp_init( isdn_net_local * lp, ippp_bundle * add_to )
1547 {
1548         struct ippp_struct * is;
1549
1550         if (lp->ppp_slot < 0) {
1551                 printk(KERN_ERR "%s: lp->ppp_slot(%d) out of range\n",
1552                         __func__, lp->ppp_slot);
1553                 return(-EINVAL);
1554         }
1555
1556         is = ippp_table[lp->ppp_slot];
1557         if (add_to) {
1558                 if( lp->netdev->pb )
1559                         lp->netdev->pb->ref_ct--;
1560                 lp->netdev->pb = add_to;
1561         } else {                /* first link in a bundle */
1562                 is->mp_seqno = 0;
1563                 if ((lp->netdev->pb = isdn_ppp_mp_bundle_alloc()) == NULL)
1564                         return -ENOMEM;
1565                 lp->next = lp->last = lp;       /* nobody else in a queue */
1566                 lp->netdev->pb->frags = NULL;
1567                 lp->netdev->pb->frames = 0;
1568                 lp->netdev->pb->seq = UINT_MAX;
1569         }
1570         lp->netdev->pb->ref_ct++;
1571
1572         is->last_link_seqno = 0;
1573         return 0;
1574 }
1575
1576 static u32 isdn_ppp_mp_get_seq( int short_seq,
1577                                         struct sk_buff * skb, u32 last_seq );
1578 static struct sk_buff * isdn_ppp_mp_discard( ippp_bundle * mp,
1579                         struct sk_buff * from, struct sk_buff * to );
1580 static void isdn_ppp_mp_reassembly( isdn_net_dev * net_dev, isdn_net_local * lp,
1581                                 struct sk_buff * from, struct sk_buff * to );
1582 static void isdn_ppp_mp_free_skb( ippp_bundle * mp, struct sk_buff * skb );
1583 static void isdn_ppp_mp_print_recv_pkt( int slot, struct sk_buff * skb );
1584
1585 static void isdn_ppp_mp_receive(isdn_net_dev * net_dev, isdn_net_local * lp,
1586                                                         struct sk_buff *skb)
1587 {
1588         struct ippp_struct *is;
1589         isdn_net_local * lpq;
1590         ippp_bundle * mp;
1591         isdn_mppp_stats * stats;
1592         struct sk_buff * newfrag, * frag, * start, *nextf;
1593         u32 newseq, minseq, thisseq;
1594         unsigned long flags;
1595         int slot;
1596
1597         spin_lock_irqsave(&net_dev->pb->lock, flags);
1598         mp = net_dev->pb;
1599         stats = &mp->stats;
1600         slot = lp->ppp_slot;
1601         if (slot < 0 || slot >= ISDN_MAX_CHANNELS) {
1602                 printk(KERN_ERR "%s: lp->ppp_slot(%d)\n",
1603                         __func__, lp->ppp_slot);
1604                 stats->frame_drops++;
1605                 dev_kfree_skb(skb);
1606                 spin_unlock_irqrestore(&mp->lock, flags);
1607                 return;
1608         }
1609         is = ippp_table[slot];
1610         if( ++mp->frames > stats->max_queue_len )
1611                 stats->max_queue_len = mp->frames;
1612
1613         if (is->debug & 0x8)
1614                 isdn_ppp_mp_print_recv_pkt(lp->ppp_slot, skb);
1615
1616         newseq = isdn_ppp_mp_get_seq(is->mpppcfg & SC_IN_SHORT_SEQ,
1617                                                 skb, is->last_link_seqno);
1618
1619
1620         /* if this packet seq # is less than last already processed one,
1621          * toss it right away, but check for sequence start case first
1622          */
1623         if( mp->seq > MP_LONGSEQ_MAX && (newseq & MP_LONGSEQ_MAXBIT) ) {
1624                 mp->seq = newseq;       /* the first packet: required for
1625                                          * rfc1990 non-compliant clients --
1626                                          * prevents constant packet toss */
1627         } else if( MP_LT(newseq, mp->seq) ) {
1628                 stats->frame_drops++;
1629                 isdn_ppp_mp_free_skb(mp, skb);
1630                 spin_unlock_irqrestore(&mp->lock, flags);
1631                 return;
1632         }
1633
1634         /* find the minimum received sequence number over all links */
1635         is->last_link_seqno = minseq = newseq;
1636         for (lpq = net_dev->queue;;) {
1637                 slot = lpq->ppp_slot;
1638                 if (slot < 0 || slot >= ISDN_MAX_CHANNELS) {
1639                         printk(KERN_ERR "%s: lpq->ppp_slot(%d)\n",
1640                                 __func__, lpq->ppp_slot);
1641                 } else {
1642                         u32 lls = ippp_table[slot]->last_link_seqno;
1643                         if (MP_LT(lls, minseq))
1644                                 minseq = lls;
1645                 }
1646                 if ((lpq = lpq->next) == net_dev->queue)
1647                         break;
1648         }
1649         if (MP_LT(minseq, mp->seq))
1650                 minseq = mp->seq;       /* can't go beyond already processed
1651                                          * packets */
1652         newfrag = skb;
1653
1654         /* if this new fragment is before the first one, then enqueue it now. */
1655         if ((frag = mp->frags) == NULL || MP_LT(newseq, MP_SEQ(frag))) {
1656                 newfrag->next = frag;
1657                 mp->frags = frag = newfrag;
1658                 newfrag = NULL;
1659         }
1660
1661         start = MP_FLAGS(frag) & MP_BEGIN_FRAG &&
1662                                 MP_SEQ(frag) == mp->seq ? frag : NULL;
1663
1664         /*
1665          * main fragment traversing loop
1666          *
1667          * try to accomplish several tasks:
1668          * - insert new fragment into the proper sequence slot (once that's done
1669          *   newfrag will be set to NULL)
1670          * - reassemble any complete fragment sequence (non-null 'start'
1671          *   indicates there is a contiguous sequence present)
1672          * - discard any incomplete sequences that are below minseq -- due
1673          *   to the fact that sender always increment sequence number, if there
1674          *   is an incomplete sequence below minseq, no new fragments would
1675          *   come to complete such sequence and it should be discarded
1676          *
1677          * loop completes when we accomplished the following tasks:
1678          * - new fragment is inserted in the proper sequence ('newfrag' is
1679          *   set to NULL)
1680          * - we hit a gap in the sequence, so no reassembly/processing is
1681          *   possible ('start' would be set to NULL)
1682          *
1683          * algorithm for this code is derived from code in the book
1684          * 'PPP Design And Debugging' by James Carlson (Addison-Wesley)
1685          */
1686         while (start != NULL || newfrag != NULL) {
1687
1688                 thisseq = MP_SEQ(frag);
1689                 nextf = frag->next;
1690
1691                 /* drop any duplicate fragments */
1692                 if (newfrag != NULL && thisseq == newseq) {
1693                         isdn_ppp_mp_free_skb(mp, newfrag);
1694                         newfrag = NULL;
1695                 }
1696
1697                 /* insert new fragment before next element if possible. */
1698                 if (newfrag != NULL && (nextf == NULL ||
1699                                                 MP_LT(newseq, MP_SEQ(nextf)))) {
1700                         newfrag->next = nextf;
1701                         frag->next = nextf = newfrag;
1702                         newfrag = NULL;
1703                 }
1704
1705                 if (start != NULL) {
1706                         /* check for misplaced start */
1707                         if (start != frag && (MP_FLAGS(frag) & MP_BEGIN_FRAG)) {
1708                                 printk(KERN_WARNING"isdn_mppp(seq %d): new "
1709                                       "BEGIN flag with no prior END", thisseq);
1710                                 stats->seqerrs++;
1711                                 stats->frame_drops++;
1712                                 start = isdn_ppp_mp_discard(mp, start,frag);
1713                                 nextf = frag->next;
1714                         }
1715                 } else if (MP_LE(thisseq, minseq)) {
1716                         if (MP_FLAGS(frag) & MP_BEGIN_FRAG)
1717                                 start = frag;
1718                         else {
1719                                 if (MP_FLAGS(frag) & MP_END_FRAG)
1720                                         stats->frame_drops++;
1721                                 if( mp->frags == frag )
1722                                         mp->frags = nextf;
1723                                 isdn_ppp_mp_free_skb(mp, frag);
1724                                 frag = nextf;
1725                                 continue;
1726                         }
1727                 }
1728
1729                 /* if start is non-null and we have end fragment, then
1730                  * we have full reassembly sequence -- reassemble
1731                  * and process packet now
1732                  */
1733                 if (start != NULL && (MP_FLAGS(frag) & MP_END_FRAG)) {
1734                         minseq = mp->seq = (thisseq+1) & MP_LONGSEQ_MASK;
1735                         /* Reassemble the packet then dispatch it */
1736                         isdn_ppp_mp_reassembly(net_dev, lp, start, nextf);
1737
1738                         start = NULL;
1739                         frag = NULL;
1740
1741                         mp->frags = nextf;
1742                 }
1743
1744                 /* check if need to update start pointer: if we just
1745                  * reassembled the packet and sequence is contiguous
1746                  * then next fragment should be the start of new reassembly
1747                  * if sequence is contiguous, but we haven't reassembled yet,
1748                  * keep going.
1749                  * if sequence is not contiguous, either clear everything
1750                  * below low watermark and set start to the next frag or
1751                  * clear start ptr.
1752                  */
1753                 if (nextf != NULL &&
1754                     ((thisseq+1) & MP_LONGSEQ_MASK) == MP_SEQ(nextf)) {
1755                         /* if we just reassembled and the next one is here,
1756                          * then start another reassembly. */
1757
1758                         if (frag == NULL) {
1759                                 if (MP_FLAGS(nextf) & MP_BEGIN_FRAG)
1760                                         start = nextf;
1761                                 else
1762                                 {
1763                                         printk(KERN_WARNING"isdn_mppp(seq %d):"
1764                                                 " END flag with no following "
1765                                                 "BEGIN", thisseq);
1766                                         stats->seqerrs++;
1767                                 }
1768                         }
1769
1770                 } else {
1771                         if ( nextf != NULL && frag != NULL &&
1772                                                 MP_LT(thisseq, minseq)) {
1773                                 /* we've got a break in the sequence
1774                                  * and we not at the end yet
1775                                  * and we did not just reassembled
1776                                  *(if we did, there wouldn't be anything before)
1777                                  * and we below the low watermark
1778                                  * discard all the frames below low watermark
1779                                  * and start over */
1780                                 stats->frame_drops++;
1781                                 mp->frags = isdn_ppp_mp_discard(mp,start,nextf);
1782                         }
1783                         /* break in the sequence, no reassembly */
1784                         start = NULL;
1785                 }
1786
1787                 frag = nextf;
1788         }       /* while -- main loop */
1789
1790         if (mp->frags == NULL)
1791                 mp->frags = frag;
1792
1793         /* rather straighforward way to deal with (not very) possible
1794          * queue overflow */
1795         if (mp->frames > MP_MAX_QUEUE_LEN) {
1796                 stats->overflows++;
1797                 while (mp->frames > MP_MAX_QUEUE_LEN) {
1798                         frag = mp->frags->next;
1799                         isdn_ppp_mp_free_skb(mp, mp->frags);
1800                         mp->frags = frag;
1801                 }
1802         }
1803         spin_unlock_irqrestore(&mp->lock, flags);
1804 }
1805
1806 static void isdn_ppp_mp_cleanup( isdn_net_local * lp )
1807 {
1808         struct sk_buff * frag = lp->netdev->pb->frags;
1809         struct sk_buff * nextfrag;
1810         while( frag ) {
1811                 nextfrag = frag->next;
1812                 isdn_ppp_mp_free_skb(lp->netdev->pb, frag);
1813                 frag = nextfrag;
1814         }
1815         lp->netdev->pb->frags = NULL;
1816 }
1817
1818 static u32 isdn_ppp_mp_get_seq( int short_seq,
1819                                         struct sk_buff * skb, u32 last_seq )
1820 {
1821         u32 seq;
1822         int flags = skb->data[0] & (MP_BEGIN_FRAG | MP_END_FRAG);
1823
1824         if( !short_seq )
1825         {
1826                 seq = ntohl(*(__be32 *)skb->data) & MP_LONGSEQ_MASK;
1827                 skb_push(skb,1);
1828         }
1829         else
1830         {
1831                 /* convert 12-bit short seq number to 24-bit long one
1832                 */
1833                 seq = ntohs(*(__be16 *)skb->data) & MP_SHORTSEQ_MASK;
1834
1835                 /* check for seqence wrap */
1836                 if( !(seq &  MP_SHORTSEQ_MAXBIT) &&
1837                      (last_seq &  MP_SHORTSEQ_MAXBIT) &&
1838                      (unsigned long)last_seq <= MP_LONGSEQ_MAX )
1839                         seq |= (last_seq + MP_SHORTSEQ_MAX+1) &
1840                                         (~MP_SHORTSEQ_MASK & MP_LONGSEQ_MASK);
1841                 else
1842                         seq |= last_seq & (~MP_SHORTSEQ_MASK & MP_LONGSEQ_MASK);
1843
1844                 skb_push(skb, 3);       /* put converted seqence back in skb */
1845         }
1846         *(u32*)(skb->data+1) = seq;     /* put seqence back in _host_ byte
1847                                          * order */
1848         skb->data[0] = flags;           /* restore flags */
1849         return seq;
1850 }
1851
1852 struct sk_buff * isdn_ppp_mp_discard( ippp_bundle * mp,
1853                         struct sk_buff * from, struct sk_buff * to )
1854 {
1855         if( from )
1856                 while (from != to) {
1857                         struct sk_buff * next = from->next;
1858                         isdn_ppp_mp_free_skb(mp, from);
1859                         from = next;
1860                 }
1861         return from;
1862 }
1863
1864 void isdn_ppp_mp_reassembly( isdn_net_dev * net_dev, isdn_net_local * lp,
1865                                 struct sk_buff * from, struct sk_buff * to )
1866 {
1867         ippp_bundle * mp = net_dev->pb;
1868         int proto;
1869         struct sk_buff * skb;
1870         unsigned int tot_len;
1871
1872         if (lp->ppp_slot < 0 || lp->ppp_slot >= ISDN_MAX_CHANNELS) {
1873                 printk(KERN_ERR "%s: lp->ppp_slot(%d) out of range\n",
1874                         __func__, lp->ppp_slot);
1875                 return;
1876         }
1877         if( MP_FLAGS(from) == (MP_BEGIN_FRAG | MP_END_FRAG) ) {
1878                 if( ippp_table[lp->ppp_slot]->debug & 0x40 )
1879                         printk(KERN_DEBUG "isdn_mppp: reassembly: frame %d, "
1880                                         "len %d\n", MP_SEQ(from), from->len );
1881                 skb = from;
1882                 skb_pull(skb, MP_HEADER_LEN);
1883                 mp->frames--;
1884         } else {
1885                 struct sk_buff * frag;
1886                 int n;
1887
1888                 for(tot_len=n=0, frag=from; frag != to; frag=frag->next, n++)
1889                         tot_len += frag->len - MP_HEADER_LEN;
1890
1891                 if( ippp_table[lp->ppp_slot]->debug & 0x40 )
1892                         printk(KERN_DEBUG"isdn_mppp: reassembling frames %d "
1893                                 "to %d, len %d\n", MP_SEQ(from),
1894                                 (MP_SEQ(from)+n-1) & MP_LONGSEQ_MASK, tot_len );
1895                 if( (skb = dev_alloc_skb(tot_len)) == NULL ) {
1896                         printk(KERN_ERR "isdn_mppp: cannot allocate sk buff "
1897                                         "of size %d\n", tot_len);
1898                         isdn_ppp_mp_discard(mp, from, to);
1899                         return;
1900                 }
1901
1902                 while( from != to ) {
1903                         unsigned int len = from->len - MP_HEADER_LEN;
1904
1905                         skb_copy_from_linear_data_offset(from, MP_HEADER_LEN,
1906                                                          skb_put(skb,len),
1907                                                          len);
1908                         frag = from->next;
1909                         isdn_ppp_mp_free_skb(mp, from);
1910                         from = frag;
1911                 }
1912         }
1913         proto = isdn_ppp_strip_proto(skb);
1914         isdn_ppp_push_higher(net_dev, lp, skb, proto);
1915 }
1916
1917 static void isdn_ppp_mp_free_skb(ippp_bundle * mp, struct sk_buff * skb)
1918 {
1919         dev_kfree_skb(skb);
1920         mp->frames--;
1921 }
1922
1923 static void isdn_ppp_mp_print_recv_pkt( int slot, struct sk_buff * skb )
1924 {
1925         printk(KERN_DEBUG "mp_recv: %d/%d -> %02x %02x %02x %02x %02x %02x\n",
1926                 slot, (int) skb->len,
1927                 (int) skb->data[0], (int) skb->data[1], (int) skb->data[2],
1928                 (int) skb->data[3], (int) skb->data[4], (int) skb->data[5]);
1929 }
1930
1931 static int
1932 isdn_ppp_bundle(struct ippp_struct *is, int unit)
1933 {
1934         char ifn[IFNAMSIZ + 1];
1935         isdn_net_dev *p;
1936         isdn_net_local *lp, *nlp;
1937         int rc;
1938         unsigned long flags;
1939
1940         sprintf(ifn, "ippp%d", unit);
1941         p = isdn_net_findif(ifn);
1942         if (!p) {
1943                 printk(KERN_ERR "ippp_bundle: cannot find %s\n", ifn);
1944                 return -EINVAL;
1945         }
1946
1947         spin_lock_irqsave(&p->pb->lock, flags);
1948
1949         nlp = is->lp;
1950         lp = p->queue;
1951         if( nlp->ppp_slot < 0 || nlp->ppp_slot >= ISDN_MAX_CHANNELS ||
1952                 lp->ppp_slot < 0 || lp->ppp_slot >= ISDN_MAX_CHANNELS ) {
1953                 printk(KERN_ERR "ippp_bundle: binding to invalid slot %d\n",
1954                         nlp->ppp_slot < 0 || nlp->ppp_slot >= ISDN_MAX_CHANNELS ?
1955                         nlp->ppp_slot : lp->ppp_slot );
1956                 rc = -EINVAL;
1957                 goto out;
1958         }
1959
1960         isdn_net_add_to_bundle(p, nlp);
1961
1962         ippp_table[nlp->ppp_slot]->unit = ippp_table[lp->ppp_slot]->unit;
1963
1964         /* maybe also SC_CCP stuff */
1965         ippp_table[nlp->ppp_slot]->pppcfg |= ippp_table[lp->ppp_slot]->pppcfg &
1966                 (SC_ENABLE_IP | SC_NO_TCP_CCID | SC_REJ_COMP_TCP);
1967         ippp_table[nlp->ppp_slot]->mpppcfg |= ippp_table[lp->ppp_slot]->mpppcfg &
1968                 (SC_MP_PROT | SC_REJ_MP_PROT | SC_OUT_SHORT_SEQ | SC_IN_SHORT_SEQ);
1969         rc = isdn_ppp_mp_init(nlp, p->pb);
1970 out:
1971         spin_unlock_irqrestore(&p->pb->lock, flags);
1972         return rc;
1973 }
1974
1975 #endif /* CONFIG_ISDN_MPP */
1976
1977 /*
1978  * network device ioctl handlers
1979  */
1980
1981 static int
1982 isdn_ppp_dev_ioctl_stats(int slot, struct ifreq *ifr, struct net_device *dev)
1983 {
1984         struct ppp_stats __user *res = ifr->ifr_data;
1985         struct ppp_stats t;
1986         isdn_net_local *lp = netdev_priv(dev);
1987
1988         if (!access_ok(VERIFY_WRITE, res, sizeof(struct ppp_stats)))
1989                 return -EFAULT;
1990
1991         /* build a temporary stat struct and copy it to user space */
1992
1993         memset(&t, 0, sizeof(struct ppp_stats));
1994         if (dev->flags & IFF_UP) {
1995                 t.p.ppp_ipackets = lp->stats.rx_packets;
1996                 t.p.ppp_ibytes = lp->stats.rx_bytes;
1997                 t.p.ppp_ierrors = lp->stats.rx_errors;
1998                 t.p.ppp_opackets = lp->stats.tx_packets;
1999                 t.p.ppp_obytes = lp->stats.tx_bytes;
2000                 t.p.ppp_oerrors = lp->stats.tx_errors;
2001 #ifdef CONFIG_ISDN_PPP_VJ
2002                 if (slot >= 0 && ippp_table[slot]->slcomp) {
2003                         struct slcompress *slcomp = ippp_table[slot]->slcomp;
2004                         t.vj.vjs_packets = slcomp->sls_o_compressed + slcomp->sls_o_uncompressed;
2005                         t.vj.vjs_compressed = slcomp->sls_o_compressed;
2006                         t.vj.vjs_searches = slcomp->sls_o_searches;
2007                         t.vj.vjs_misses = slcomp->sls_o_misses;
2008                         t.vj.vjs_errorin = slcomp->sls_i_error;
2009                         t.vj.vjs_tossed = slcomp->sls_i_tossed;
2010                         t.vj.vjs_uncompressedin = slcomp->sls_i_uncompressed;
2011                         t.vj.vjs_compressedin = slcomp->sls_i_compressed;
2012                 }
2013 #endif
2014         }
2015         if (copy_to_user(res, &t, sizeof(struct ppp_stats)))
2016                 return -EFAULT;
2017         return 0;
2018 }
2019
2020 int
2021 isdn_ppp_dev_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
2022 {
2023         int error=0;
2024         int len;
2025         isdn_net_local *lp = netdev_priv(dev);
2026
2027
2028         if (lp->p_encap != ISDN_NET_ENCAP_SYNCPPP)
2029                 return -EINVAL;
2030
2031         switch (cmd) {
2032 #define PPP_VERSION "2.3.7"
2033                 case SIOCGPPPVER:
2034                         len = strlen(PPP_VERSION) + 1;
2035                         if (copy_to_user(ifr->ifr_data, PPP_VERSION, len))
2036                                 error = -EFAULT;
2037                         break;
2038
2039                 case SIOCGPPPSTATS:
2040                         error = isdn_ppp_dev_ioctl_stats(lp->ppp_slot, ifr, dev);
2041                         break;
2042                 default:
2043                         error = -EINVAL;
2044                         break;
2045         }
2046         return error;
2047 }
2048
2049 static int
2050 isdn_ppp_if_get_unit(char *name)
2051 {
2052         int len,
2053          i,
2054          unit = 0,
2055          deci;
2056
2057         len = strlen(name);
2058
2059         if (strncmp("ippp", name, 4) || len > 8)
2060                 return -1;
2061
2062         for (i = 0, deci = 1; i < len; i++, deci *= 10) {
2063                 char a = name[len - i - 1];
2064                 if (a >= '0' && a <= '9')
2065                         unit += (a - '0') * deci;
2066                 else
2067                         break;
2068         }
2069         if (!i || len - i != 4)
2070                 unit = -1;
2071
2072         return unit;
2073 }
2074
2075
2076 int
2077 isdn_ppp_dial_slave(char *name)
2078 {
2079 #ifdef CONFIG_ISDN_MPP
2080         isdn_net_dev *ndev;
2081         isdn_net_local *lp;
2082         struct net_device *sdev;
2083
2084         if (!(ndev = isdn_net_findif(name)))
2085                 return 1;
2086         lp = ndev->local;
2087         if (!(lp->flags & ISDN_NET_CONNECTED))
2088                 return 5;
2089
2090         sdev = lp->slave;
2091         while (sdev) {
2092                 isdn_net_local *mlp = netdev_priv(sdev);
2093                 if (!(mlp->flags & ISDN_NET_CONNECTED))
2094                         break;
2095                 sdev = mlp->slave;
2096         }
2097         if (!sdev)
2098                 return 2;
2099
2100         isdn_net_dial_req(netdev_priv(sdev));
2101         return 0;
2102 #else
2103         return -1;
2104 #endif
2105 }
2106
2107 int
2108 isdn_ppp_hangup_slave(char *name)
2109 {
2110 #ifdef CONFIG_ISDN_MPP
2111         isdn_net_dev *ndev;
2112         isdn_net_local *lp;
2113         struct net_device *sdev;
2114
2115         if (!(ndev = isdn_net_findif(name)))
2116                 return 1;
2117         lp = ndev->local;
2118         if (!(lp->flags & ISDN_NET_CONNECTED))
2119                 return 5;
2120
2121         sdev = lp->slave;
2122         while (sdev) {
2123                 isdn_net_local *mlp = netdev_priv(sdev);
2124
2125                 if (mlp->slave) { /* find last connected link in chain */
2126                         isdn_net_local *nlp = ISDN_SLAVE_PRIV(mlp);
2127
2128                         if (!(nlp->flags & ISDN_NET_CONNECTED))
2129                                 break;
2130                 } else if (mlp->flags & ISDN_NET_CONNECTED)
2131                         break;
2132
2133                 sdev = mlp->slave;
2134         }
2135         if (!sdev)
2136                 return 2;
2137
2138         isdn_net_hangup(sdev);
2139         return 0;
2140 #else
2141         return -1;
2142 #endif
2143 }
2144
2145 /*
2146  * PPP compression stuff
2147  */
2148
2149
2150 /* Push an empty CCP Data Frame up to the daemon to wake it up and let it
2151    generate a CCP Reset-Request or tear down CCP altogether */
2152
2153 static void isdn_ppp_ccp_kickup(struct ippp_struct *is)
2154 {
2155         isdn_ppp_fill_rq(NULL, 0, PPP_COMP, is->lp->ppp_slot);
2156 }
2157
2158 /* In-kernel handling of CCP Reset-Request and Reset-Ack is necessary,
2159    but absolutely nontrivial. The most abstruse problem we are facing is
2160    that the generation, reception and all the handling of timeouts and
2161    resends including proper request id management should be entirely left
2162    to the (de)compressor, but indeed is not covered by the current API to
2163    the (de)compressor. The API is a prototype version from PPP where only
2164    some (de)compressors have yet been implemented and all of them are
2165    rather simple in their reset handling. Especially, their is only one
2166    outstanding ResetAck at a time with all of them and ResetReq/-Acks do
2167    not have parameters. For this very special case it was sufficient to
2168    just return an error code from the decompressor and have a single
2169    reset() entry to communicate all the necessary information between
2170    the framework and the (de)compressor. Bad enough, LZS is different
2171    (and any other compressor may be different, too). It has multiple
2172    histories (eventually) and needs to Reset each of them independently
2173    and thus uses multiple outstanding Acks and history numbers as an
2174    additional parameter to Reqs/Acks.
2175    All that makes it harder to port the reset state engine into the
2176    kernel because it is not just the same simple one as in (i)pppd but
2177    it must be able to pass additional parameters and have multiple out-
2178    standing Acks. We are trying to achieve the impossible by handling
2179    reset transactions independent by their id. The id MUST change when
2180    the data portion changes, thus any (de)compressor who uses more than
2181    one resettable state must provide and recognize individual ids for
2182    each individual reset transaction. The framework itself does _only_
2183    differentiate them by id, because it has no other semantics like the
2184    (de)compressor might.
2185    This looks like a major redesign of the interface would be nice,
2186    but I don't have an idea how to do it better. */
2187
2188 /* Send a CCP Reset-Request or Reset-Ack directly from the kernel. This is
2189    getting that lengthy because there is no simple "send-this-frame-out"
2190    function above but every wrapper does a bit different. Hope I guess
2191    correct in this hack... */
2192
2193 static void isdn_ppp_ccp_xmit_reset(struct ippp_struct *is, int proto,
2194                                     unsigned char code, unsigned char id,
2195                                     unsigned char *data, int len)
2196 {
2197         struct sk_buff *skb;
2198         unsigned char *p;
2199         int hl;
2200         int cnt = 0;
2201         isdn_net_local *lp = is->lp;
2202
2203         /* Alloc large enough skb */
2204         hl = dev->drv[lp->isdn_device]->interface->hl_hdrlen;
2205         skb = alloc_skb(len + hl + 16,GFP_ATOMIC);
2206         if(!skb) {
2207                 printk(KERN_WARNING
2208                        "ippp: CCP cannot send reset - out of memory\n");
2209                 return;
2210         }
2211         skb_reserve(skb, hl);
2212
2213         /* We may need to stuff an address and control field first */
2214         if(!(is->pppcfg & SC_COMP_AC)) {
2215                 p = skb_put(skb, 2);
2216                 *p++ = 0xff;
2217                 *p++ = 0x03;
2218         }
2219
2220         /* Stuff proto, code, id and length */
2221         p = skb_put(skb, 6);
2222         *p++ = (proto >> 8);
2223         *p++ = (proto & 0xff);
2224         *p++ = code;
2225         *p++ = id;
2226         cnt = 4 + len;
2227         *p++ = (cnt >> 8);
2228         *p++ = (cnt & 0xff);
2229
2230         /* Now stuff remaining bytes */
2231         if(len) {
2232                 p = skb_put(skb, len);
2233                 memcpy(p, data, len);
2234         }
2235
2236         /* skb is now ready for xmit */
2237         printk(KERN_DEBUG "Sending CCP Frame:\n");
2238         isdn_ppp_frame_log("ccp-xmit", skb->data, skb->len, 32, is->unit,lp->ppp_slot);
2239
2240         isdn_net_write_super(lp, skb);
2241 }
2242
2243 /* Allocate the reset state vector */
2244 static struct ippp_ccp_reset *isdn_ppp_ccp_reset_alloc(struct ippp_struct *is)
2245 {
2246         struct ippp_ccp_reset *r;
2247         r = kzalloc(sizeof(struct ippp_ccp_reset), GFP_KERNEL);
2248         if(!r) {
2249                 printk(KERN_ERR "ippp_ccp: failed to allocate reset data"
2250                        " structure - no mem\n");
2251                 return NULL;
2252         }
2253         printk(KERN_DEBUG "ippp_ccp: allocated reset data structure %p\n", r);
2254         is->reset = r;
2255         return r;
2256 }
2257
2258 /* Destroy the reset state vector. Kill all pending timers first. */
2259 static void isdn_ppp_ccp_reset_free(struct ippp_struct *is)
2260 {
2261         unsigned int id;
2262
2263         printk(KERN_DEBUG "ippp_ccp: freeing reset data structure %p\n",
2264                is->reset);
2265         for(id = 0; id < 256; id++) {
2266                 if(is->reset->rs[id]) {
2267                         isdn_ppp_ccp_reset_free_state(is, (unsigned char)id);
2268                 }
2269         }
2270         kfree(is->reset);
2271         is->reset = NULL;
2272 }
2273
2274 /* Free a given state and clear everything up for later reallocation */
2275 static void isdn_ppp_ccp_reset_free_state(struct ippp_struct *is,
2276                                           unsigned char id)
2277 {
2278         struct ippp_ccp_reset_state *rs;
2279
2280         if(is->reset->rs[id]) {
2281                 printk(KERN_DEBUG "ippp_ccp: freeing state for id %d\n", id);
2282                 rs = is->reset->rs[id];
2283                 /* Make sure the kernel will not call back later */
2284                 if(rs->ta)
2285                         del_timer(&rs->timer);
2286                 is->reset->rs[id] = NULL;
2287                 kfree(rs);
2288         } else {
2289                 printk(KERN_WARNING "ippp_ccp: id %d is not allocated\n", id);
2290         }
2291 }
2292
2293 /* The timer callback function which is called when a ResetReq has timed out,
2294    aka has never been answered by a ResetAck */
2295 static void isdn_ppp_ccp_timer_callback(unsigned long closure)
2296 {
2297         struct ippp_ccp_reset_state *rs =
2298                 (struct ippp_ccp_reset_state *)closure;
2299
2300         if(!rs) {
2301                 printk(KERN_ERR "ippp_ccp: timer cb with zero closure.\n");
2302                 return;
2303         }
2304         if(rs->ta && rs->state == CCPResetSentReq) {
2305                 /* We are correct here */
2306                 if(!rs->expra) {
2307                         /* Hmm, there is no Ack really expected. We can clean
2308                            up the state now, it will be reallocated if the
2309                            decompressor insists on another reset */
2310                         rs->ta = 0;
2311                         isdn_ppp_ccp_reset_free_state(rs->is, rs->id);
2312                         return;
2313                 }
2314                 printk(KERN_DEBUG "ippp_ccp: CCP Reset timed out for id %d\n",
2315                        rs->id);
2316                 /* Push it again */
2317                 isdn_ppp_ccp_xmit_reset(rs->is, PPP_CCP, CCP_RESETREQ, rs->id,
2318                                         rs->data, rs->dlen);
2319                 /* Restart timer */
2320                 rs->timer.expires = jiffies + HZ*5;
2321                 add_timer(&rs->timer);
2322         } else {
2323                 printk(KERN_WARNING "ippp_ccp: timer cb in wrong state %d\n",
2324                        rs->state);
2325         }
2326 }
2327
2328 /* Allocate a new reset transaction state */
2329 static struct ippp_ccp_reset_state *isdn_ppp_ccp_reset_alloc_state(struct ippp_struct *is,
2330                                                       unsigned char id)
2331 {
2332         struct ippp_ccp_reset_state *rs;
2333         if(is->reset->rs[id]) {
2334                 printk(KERN_WARNING "ippp_ccp: old state exists for id %d\n",
2335                        id);
2336                 return NULL;
2337         } else {
2338                 rs = kzalloc(sizeof(struct ippp_ccp_reset_state), GFP_KERNEL);
2339                 if(!rs)
2340                         return NULL;
2341                 rs->state = CCPResetIdle;
2342                 rs->is = is;
2343                 rs->id = id;
2344                 init_timer(&rs->timer);
2345                 rs->timer.data = (unsigned long)rs;
2346                 rs->timer.function = isdn_ppp_ccp_timer_callback;
2347                 is->reset->rs[id] = rs;
2348         }
2349         return rs;
2350 }
2351
2352
2353 /* A decompressor wants a reset with a set of parameters - do what is
2354    necessary to fulfill it */
2355 static void isdn_ppp_ccp_reset_trans(struct ippp_struct *is,
2356                                      struct isdn_ppp_resetparams *rp)
2357 {
2358         struct ippp_ccp_reset_state *rs;
2359
2360         if(rp->valid) {
2361                 /* The decompressor defines parameters by itself */
2362                 if(rp->rsend) {
2363                         /* And he wants us to send a request */
2364                         if(!(rp->idval)) {
2365                                 printk(KERN_ERR "ippp_ccp: decompressor must"
2366                                        " specify reset id\n");
2367                                 return;
2368                         }
2369                         if(is->reset->rs[rp->id]) {
2370                                 /* There is already a transaction in existence
2371                                    for this id. May be still waiting for a
2372                                    Ack or may be wrong. */
2373                                 rs = is->reset->rs[rp->id];
2374                                 if(rs->state == CCPResetSentReq && rs->ta) {
2375                                         printk(KERN_DEBUG "ippp_ccp: reset"
2376                                                " trans still in progress"
2377                                                " for id %d\n", rp->id);
2378                                 } else {
2379                                         printk(KERN_WARNING "ippp_ccp: reset"
2380                                                " trans in wrong state %d for"
2381                                                " id %d\n", rs->state, rp->id);
2382                                 }
2383                         } else {
2384                                 /* Ok, this is a new transaction */
2385                                 printk(KERN_DEBUG "ippp_ccp: new trans for id"
2386                                        " %d to be started\n", rp->id);
2387                                 rs = isdn_ppp_ccp_reset_alloc_state(is, rp->id);
2388                                 if(!rs) {
2389                                         printk(KERN_ERR "ippp_ccp: out of mem"
2390                                                " allocing ccp trans\n");
2391                                         return;
2392                                 }
2393                                 rs->state = CCPResetSentReq;
2394                                 rs->expra = rp->expra;
2395                                 if(rp->dtval) {
2396                                         rs->dlen = rp->dlen;
2397                                         memcpy(rs->data, rp->data, rp->dlen);
2398                                 }
2399                                 /* HACK TODO - add link comp here */
2400                                 isdn_ppp_ccp_xmit_reset(is, PPP_CCP,
2401                                                         CCP_RESETREQ, rs->id,
2402                                                         rs->data, rs->dlen);
2403                                 /* Start the timer */
2404                                 rs->timer.expires = jiffies + 5*HZ;
2405                                 add_timer(&rs->timer);
2406                                 rs->ta = 1;
2407                         }
2408                 } else {
2409                         printk(KERN_DEBUG "ippp_ccp: no reset sent\n");
2410                 }
2411         } else {
2412                 /* The reset params are invalid. The decompressor does not
2413                    care about them, so we just send the minimal requests
2414                    and increase ids only when an Ack is received for a
2415                    given id */
2416                 if(is->reset->rs[is->reset->lastid]) {
2417                         /* There is already a transaction in existence
2418                            for this id. May be still waiting for a
2419                            Ack or may be wrong. */
2420                         rs = is->reset->rs[is->reset->lastid];
2421                         if(rs->state == CCPResetSentReq && rs->ta) {
2422                                 printk(KERN_DEBUG "ippp_ccp: reset"
2423                                        " trans still in progress"
2424                                        " for id %d\n", rp->id);
2425                         } else {
2426                                 printk(KERN_WARNING "ippp_ccp: reset"
2427                                        " trans in wrong state %d for"
2428                                        " id %d\n", rs->state, rp->id);
2429                         }
2430                 } else {
2431                         printk(KERN_DEBUG "ippp_ccp: new trans for id"
2432                                " %d to be started\n", is->reset->lastid);
2433                         rs = isdn_ppp_ccp_reset_alloc_state(is,
2434                                                             is->reset->lastid);
2435                         if(!rs) {
2436                                 printk(KERN_ERR "ippp_ccp: out of mem"
2437                                        " allocing ccp trans\n");
2438                                 return;
2439                         }
2440                         rs->state = CCPResetSentReq;
2441                         /* We always expect an Ack if the decompressor doesn't
2442                            know better */
2443                         rs->expra = 1;
2444                         rs->dlen = 0;
2445                         /* HACK TODO - add link comp here */
2446                         isdn_ppp_ccp_xmit_reset(is, PPP_CCP, CCP_RESETREQ,
2447                                                 rs->id, NULL, 0);
2448                         /* Start the timer */
2449                         rs->timer.expires = jiffies + 5*HZ;
2450                         add_timer(&rs->timer);
2451                         rs->ta = 1;
2452                 }
2453         }
2454 }
2455
2456 /* An Ack was received for this id. This means we stop the timer and clean
2457    up the state prior to calling the decompressors reset routine. */
2458 static void isdn_ppp_ccp_reset_ack_rcvd(struct ippp_struct *is,
2459                                         unsigned char id)
2460 {
2461         struct ippp_ccp_reset_state *rs = is->reset->rs[id];
2462
2463         if(rs) {
2464                 if(rs->ta && rs->state == CCPResetSentReq) {
2465                         /* Great, we are correct */
2466                         if(!rs->expra)
2467                                 printk(KERN_DEBUG "ippp_ccp: ResetAck received"
2468                                        " for id %d but not expected\n", id);
2469                 } else {
2470                         printk(KERN_INFO "ippp_ccp: ResetAck received out of"
2471                                "sync for id %d\n", id);
2472                 }
2473                 if(rs->ta) {
2474                         rs->ta = 0;
2475                         del_timer(&rs->timer);
2476                 }
2477                 isdn_ppp_ccp_reset_free_state(is, id);
2478         } else {
2479                 printk(KERN_INFO "ippp_ccp: ResetAck received for unknown id"
2480                        " %d\n", id);
2481         }
2482         /* Make sure the simple reset stuff uses a new id next time */
2483         is->reset->lastid++;
2484 }
2485
2486 /*
2487  * decompress packet
2488  *
2489  * if master = 0, we're trying to uncompress an per-link compressed packet,
2490  * as opposed to an compressed reconstructed-from-MPPP packet.
2491  * proto is updated to protocol field of uncompressed packet.
2492  *
2493  * retval: decompressed packet,
2494  *         same packet if uncompressed,
2495  *         NULL if decompression error
2496  */
2497
2498 static struct sk_buff *isdn_ppp_decompress(struct sk_buff *skb,struct ippp_struct *is,struct ippp_struct *master,
2499         int *proto)
2500 {
2501         void *stat = NULL;
2502         struct isdn_ppp_compressor *ipc = NULL;
2503         struct sk_buff *skb_out;
2504         int len;
2505         struct ippp_struct *ri;
2506         struct isdn_ppp_resetparams rsparm;
2507         unsigned char rsdata[IPPP_RESET_MAXDATABYTES];
2508
2509         if(!master) {
2510                 // per-link decompression
2511                 stat = is->link_decomp_stat;
2512                 ipc = is->link_decompressor;
2513                 ri = is;
2514         } else {
2515                 stat = master->decomp_stat;
2516                 ipc = master->decompressor;
2517                 ri = master;
2518         }
2519
2520         if (!ipc) {
2521                 // no decompressor -> we can't decompress.
2522                 printk(KERN_DEBUG "ippp: no decompressor defined!\n");
2523                 return skb;
2524         }
2525         BUG_ON(!stat); // if we have a compressor, stat has been set as well
2526
2527         if((master && *proto == PPP_COMP) || (!master && *proto == PPP_COMPFRAG) ) {
2528                 // compressed packets are compressed by their protocol type
2529
2530                 // Set up reset params for the decompressor
2531                 memset(&rsparm, 0, sizeof(rsparm));
2532                 rsparm.data = rsdata;
2533                 rsparm.maxdlen = IPPP_RESET_MAXDATABYTES;
2534
2535                 skb_out = dev_alloc_skb(is->mru + PPP_HDRLEN);
2536                 if (!skb_out) {
2537                         kfree_skb(skb);
2538                         printk(KERN_ERR "ippp: decomp memory allocation failure\n");
2539                         return NULL;
2540                 }
2541                 len = ipc->decompress(stat, skb, skb_out, &rsparm);
2542                 kfree_skb(skb);
2543                 if (len <= 0) {
2544                         switch(len) {
2545                         case DECOMP_ERROR:
2546                                 printk(KERN_INFO "ippp: decomp wants reset %s params\n",
2547                                        rsparm.valid ? "with" : "without");
2548
2549                                 isdn_ppp_ccp_reset_trans(ri, &rsparm);
2550                                 break;
2551                         case DECOMP_FATALERROR:
2552                                 ri->pppcfg |= SC_DC_FERROR;
2553                                 /* Kick ipppd to recognize the error */
2554                                 isdn_ppp_ccp_kickup(ri);
2555                                 break;
2556                         }
2557                         kfree_skb(skb_out);
2558                         return NULL;
2559                 }
2560                 *proto = isdn_ppp_strip_proto(skb_out);
2561                 if (*proto < 0) {
2562                         kfree_skb(skb_out);
2563                         return NULL;
2564                 }
2565                 return skb_out;
2566         } else {
2567                 // uncompressed packets are fed through the decompressor to
2568                 // update the decompressor state
2569                 ipc->incomp(stat, skb, *proto);
2570                 return skb;
2571         }
2572 }
2573
2574 /*
2575  * compress a frame
2576  *   type=0: normal/bundle compression
2577  *       =1: link compression
2578  * returns original skb if we haven't compressed the frame
2579  * and a new skb pointer if we've done it
2580  */
2581 static struct sk_buff *isdn_ppp_compress(struct sk_buff *skb_in,int *proto,
2582         struct ippp_struct *is,struct ippp_struct *master,int type)
2583 {
2584     int ret;
2585     int new_proto;
2586     struct isdn_ppp_compressor *compressor;
2587     void *stat;
2588     struct sk_buff *skb_out;
2589
2590         /* we do not compress control protocols */
2591     if(*proto < 0 || *proto > 0x3fff) {
2592             return skb_in;
2593     }
2594
2595         if(type) { /* type=1 => Link compression */
2596                 return skb_in;
2597         }
2598         else {
2599                 if(!master) {
2600                         compressor = is->compressor;
2601                         stat = is->comp_stat;
2602                 }
2603                 else {
2604                         compressor = master->compressor;
2605                         stat = master->comp_stat;
2606                 }
2607                 new_proto = PPP_COMP;
2608         }
2609
2610         if(!compressor) {
2611                 printk(KERN_ERR "isdn_ppp: No compressor set!\n");
2612                 return skb_in;
2613         }
2614         if(!stat) {
2615                 printk(KERN_ERR "isdn_ppp: Compressor not initialized?\n");
2616                 return skb_in;
2617         }
2618
2619         /* Allow for at least 150 % expansion (for now) */
2620         skb_out = alloc_skb(skb_in->len + skb_in->len/2 + 32 +
2621                 skb_headroom(skb_in), GFP_ATOMIC);
2622         if(!skb_out)
2623                 return skb_in;
2624         skb_reserve(skb_out, skb_headroom(skb_in));
2625
2626         ret = (compressor->compress)(stat,skb_in,skb_out,*proto);
2627         if(!ret) {
2628                 dev_kfree_skb(skb_out);
2629                 return skb_in;
2630         }
2631
2632         dev_kfree_skb(skb_in);
2633         *proto = new_proto;
2634         return skb_out;
2635 }
2636
2637 /*
2638  * we received a CCP frame ..
2639  * not a clean solution, but we MUST handle a few cases in the kernel
2640  */
2641 static void isdn_ppp_receive_ccp(isdn_net_dev *net_dev, isdn_net_local *lp,
2642          struct sk_buff *skb,int proto)
2643 {
2644         struct ippp_struct *is;
2645         struct ippp_struct *mis;
2646         int len;
2647         struct isdn_ppp_resetparams rsparm;
2648         unsigned char rsdata[IPPP_RESET_MAXDATABYTES];
2649
2650         printk(KERN_DEBUG "Received CCP frame from peer slot(%d)\n",
2651                 lp->ppp_slot);
2652         if (lp->ppp_slot < 0 || lp->ppp_slot >= ISDN_MAX_CHANNELS) {
2653                 printk(KERN_ERR "%s: lp->ppp_slot(%d) out of range\n",
2654                         __func__, lp->ppp_slot);
2655                 return;
2656         }
2657         is = ippp_table[lp->ppp_slot];
2658         isdn_ppp_frame_log("ccp-rcv", skb->data, skb->len, 32, is->unit,lp->ppp_slot);
2659
2660         if(lp->master) {
2661                 int slot = ISDN_MASTER_PRIV(lp)->ppp_slot;
2662                 if (slot < 0 || slot >= ISDN_MAX_CHANNELS) {
2663                         printk(KERN_ERR "%s: slot(%d) out of range\n",
2664                                 __func__, slot);
2665                         return;
2666                 }
2667                 mis = ippp_table[slot];
2668         } else
2669                 mis = is;
2670
2671         switch(skb->data[0]) {
2672         case CCP_CONFREQ:
2673                 if(is->debug & 0x10)
2674                         printk(KERN_DEBUG "Disable compression here!\n");
2675                 if(proto == PPP_CCP)
2676                         mis->compflags &= ~SC_COMP_ON;
2677                 else
2678                         is->compflags &= ~SC_LINK_COMP_ON;
2679                 break;
2680         case CCP_TERMREQ:
2681         case CCP_TERMACK:
2682                 if(is->debug & 0x10)
2683                         printk(KERN_DEBUG "Disable (de)compression here!\n");
2684                 if(proto == PPP_CCP)
2685                         mis->compflags &= ~(SC_DECOMP_ON|SC_COMP_ON);
2686                 else
2687                         is->compflags &= ~(SC_LINK_DECOMP_ON|SC_LINK_COMP_ON);
2688                 break;
2689         case CCP_CONFACK:
2690                 /* if we RECEIVE an ackowledge we enable the decompressor */
2691                 if(is->debug & 0x10)
2692                         printk(KERN_DEBUG "Enable decompression here!\n");
2693                 if(proto == PPP_CCP) {
2694                         if (!mis->decompressor)
2695                                 break;
2696                         mis->compflags |= SC_DECOMP_ON;
2697                 } else {
2698                         if (!is->decompressor)
2699                                 break;
2700                         is->compflags |= SC_LINK_DECOMP_ON;
2701                 }
2702                 break;
2703
2704         case CCP_RESETACK:
2705                 printk(KERN_DEBUG "Received ResetAck from peer\n");
2706                 len = (skb->data[2] << 8) | skb->data[3];
2707                 len -= 4;
2708
2709                 if(proto == PPP_CCP) {
2710                         /* If a reset Ack was outstanding for this id, then
2711                            clean up the state engine */
2712                         isdn_ppp_ccp_reset_ack_rcvd(mis, skb->data[1]);
2713                         if(mis->decompressor && mis->decomp_stat)
2714                                 mis->decompressor->
2715                                         reset(mis->decomp_stat,
2716                                               skb->data[0],
2717                                               skb->data[1],
2718                                               len ? &skb->data[4] : NULL,
2719                                               len, NULL);
2720                         /* TODO: This is not easy to decide here */
2721                         mis->compflags &= ~SC_DECOMP_DISCARD;
2722                 }
2723                 else {
2724                         isdn_ppp_ccp_reset_ack_rcvd(is, skb->data[1]);
2725                         if(is->link_decompressor && is->link_decomp_stat)
2726                                 is->link_decompressor->
2727                                         reset(is->link_decomp_stat,
2728                                               skb->data[0],
2729                                               skb->data[1],
2730                                               len ? &skb->data[4] : NULL,
2731                                               len, NULL);
2732                         /* TODO: neither here */
2733                         is->compflags &= ~SC_LINK_DECOMP_DISCARD;
2734                 }
2735                 break;
2736
2737         case CCP_RESETREQ:
2738                 printk(KERN_DEBUG "Received ResetReq from peer\n");
2739                 /* Receiving a ResetReq means we must reset our compressor */
2740                 /* Set up reset params for the reset entry */
2741                 memset(&rsparm, 0, sizeof(rsparm));
2742                 rsparm.data = rsdata;
2743                 rsparm.maxdlen = IPPP_RESET_MAXDATABYTES;
2744                 /* Isolate data length */
2745                 len = (skb->data[2] << 8) | skb->data[3];
2746                 len -= 4;
2747                 if(proto == PPP_CCP) {
2748                         if(mis->compressor && mis->comp_stat)
2749                                 mis->compressor->
2750                                         reset(mis->comp_stat,
2751                                               skb->data[0],
2752                                               skb->data[1],
2753                                               len ? &skb->data[4] : NULL,
2754                                               len, &rsparm);
2755                 }
2756                 else {
2757                         if(is->link_compressor && is->link_comp_stat)
2758                                 is->link_compressor->
2759                                         reset(is->link_comp_stat,
2760                                               skb->data[0],
2761                                               skb->data[1],
2762                                               len ? &skb->data[4] : NULL,
2763                                               len, &rsparm);
2764                 }
2765                 /* Ack the Req as specified by rsparm */
2766                 if(rsparm.valid) {
2767                         /* Compressor reset handler decided how to answer */
2768                         if(rsparm.rsend) {
2769                                 /* We should send a Frame */
2770                                 isdn_ppp_ccp_xmit_reset(is, proto, CCP_RESETACK,
2771                                                         rsparm.idval ? rsparm.id
2772                                                         : skb->data[1],
2773                                                         rsparm.dtval ?
2774                                                         rsparm.data : NULL,
2775                                                         rsparm.dtval ?
2776                                                         rsparm.dlen : 0);
2777                         } else {
2778                                 printk(KERN_DEBUG "ResetAck suppressed\n");
2779                         }
2780                 } else {
2781                         /* We answer with a straight reflected Ack */
2782                         isdn_ppp_ccp_xmit_reset(is, proto, CCP_RESETACK,
2783                                                 skb->data[1],
2784                                                 len ? &skb->data[4] : NULL,
2785                                                 len);
2786                 }
2787                 break;
2788         }
2789 }
2790
2791
2792 /*
2793  * Daemon sends a CCP frame ...
2794  */
2795
2796 /* TODO: Clean this up with new Reset semantics */
2797
2798 /* I believe the CCP handling as-is is done wrong. Compressed frames
2799  * should only be sent/received after CCP reaches UP state, which means
2800  * both sides have sent CONF_ACK. Currently, we handle both directions
2801  * independently, which means we may accept compressed frames too early
2802  * (supposedly not a problem), but may also mean we send compressed frames
2803  * too early, which may turn out to be a problem.
2804  * This part of state machine should actually be handled by (i)pppd, but
2805  * that's too big of a change now. --kai
2806  */
2807
2808 /* Actually, we might turn this into an advantage: deal with the RFC in
2809  * the old tradition of beeing generous on what we accept, but beeing
2810  * strict on what we send. Thus we should just
2811  * - accept compressed frames as soon as decompression is negotiated
2812  * - send compressed frames only when decomp *and* comp are negotiated
2813  * - drop rx compressed frames if we cannot decomp (instead of pushing them
2814  *   up to ipppd)
2815  * and I tried to modify this file according to that. --abp
2816  */
2817
2818 static void isdn_ppp_send_ccp(isdn_net_dev *net_dev, isdn_net_local *lp, struct sk_buff *skb)
2819 {
2820         struct ippp_struct *mis,*is;
2821         int proto, slot = lp->ppp_slot;
2822         unsigned char *data;
2823
2824         if(!skb || skb->len < 3)
2825                 return;
2826         if (slot < 0 || slot >= ISDN_MAX_CHANNELS) {
2827                 printk(KERN_ERR "%s: lp->ppp_slot(%d) out of range\n",
2828                         __func__, slot);
2829                 return;
2830         }
2831         is = ippp_table[slot];
2832         /* Daemon may send with or without address and control field comp */
2833         data = skb->data;
2834         if(!(is->pppcfg & SC_COMP_AC) && data[0] == 0xff && data[1] == 0x03) {
2835                 data += 2;
2836                 if(skb->len < 5)
2837                         return;
2838         }
2839
2840         proto = ((int)data[0]<<8)+data[1];
2841         if(proto != PPP_CCP && proto != PPP_CCPFRAG)
2842                 return;
2843
2844         printk(KERN_DEBUG "Received CCP frame from daemon:\n");
2845         isdn_ppp_frame_log("ccp-xmit", skb->data, skb->len, 32, is->unit,lp->ppp_slot);
2846
2847         if (lp->master) {
2848                 slot = ISDN_MASTER_PRIV(lp)->ppp_slot;
2849                 if (slot < 0 || slot >= ISDN_MAX_CHANNELS) {
2850                         printk(KERN_ERR "%s: slot(%d) out of range\n",
2851                                 __func__, slot);
2852                         return;
2853                 }
2854                 mis = ippp_table[slot];
2855         } else
2856                 mis = is;
2857         if (mis != is)
2858                 printk(KERN_DEBUG "isdn_ppp: Ouch! Master CCP sends on slave slot!\n");
2859
2860         switch(data[2]) {
2861         case CCP_CONFREQ:
2862                 if(is->debug & 0x10)
2863                         printk(KERN_DEBUG "Disable decompression here!\n");
2864                 if(proto == PPP_CCP)
2865                         is->compflags &= ~SC_DECOMP_ON;
2866                 else
2867                         is->compflags &= ~SC_LINK_DECOMP_ON;
2868                 break;
2869         case CCP_TERMREQ:
2870         case CCP_TERMACK:
2871                 if(is->debug & 0x10)
2872                         printk(KERN_DEBUG "Disable (de)compression here!\n");
2873                 if(proto == PPP_CCP)
2874                         is->compflags &= ~(SC_DECOMP_ON|SC_COMP_ON);
2875                 else
2876                         is->compflags &= ~(SC_LINK_DECOMP_ON|SC_LINK_COMP_ON);
2877                 break;
2878         case CCP_CONFACK:
2879                 /* if we SEND an ackowledge we can/must enable the compressor */
2880                 if(is->debug & 0x10)
2881                         printk(KERN_DEBUG "Enable compression here!\n");
2882                 if(proto == PPP_CCP) {
2883                         if (!is->compressor)
2884                                 break;
2885                         is->compflags |= SC_COMP_ON;
2886                 } else {
2887                         if (!is->compressor)
2888                                 break;
2889                         is->compflags |= SC_LINK_COMP_ON;
2890                 }
2891                 break;
2892         case CCP_RESETACK:
2893                 /* If we send a ACK we should reset our compressor */
2894                 if(is->debug & 0x10)
2895                         printk(KERN_DEBUG "Reset decompression state here!\n");
2896                 printk(KERN_DEBUG "ResetAck from daemon passed by\n");
2897                 if(proto == PPP_CCP) {
2898                         /* link to master? */
2899                         if(is->compressor && is->comp_stat)
2900                                 is->compressor->reset(is->comp_stat, 0, 0,
2901                                                       NULL, 0, NULL);
2902                         is->compflags &= ~SC_COMP_DISCARD;
2903                 }
2904                 else {
2905                         if(is->link_compressor && is->link_comp_stat)
2906                                 is->link_compressor->reset(is->link_comp_stat,
2907                                                            0, 0, NULL, 0, NULL);
2908                         is->compflags &= ~SC_LINK_COMP_DISCARD;
2909                 }
2910                 break;
2911         case CCP_RESETREQ:
2912                 /* Just let it pass by */
2913                 printk(KERN_DEBUG "ResetReq from daemon passed by\n");
2914                 break;
2915         }
2916 }
2917
2918 int isdn_ppp_register_compressor(struct isdn_ppp_compressor *ipc)
2919 {
2920         ipc->next = ipc_head;
2921         ipc->prev = NULL;
2922         if(ipc_head) {
2923                 ipc_head->prev = ipc;
2924         }
2925         ipc_head = ipc;
2926         return 0;
2927 }
2928
2929 int isdn_ppp_unregister_compressor(struct isdn_ppp_compressor *ipc)
2930 {
2931         if(ipc->prev)
2932                 ipc->prev->next = ipc->next;
2933         else
2934                 ipc_head = ipc->next;
2935         if(ipc->next)
2936                 ipc->next->prev = ipc->prev;
2937         ipc->prev = ipc->next = NULL;
2938         return 0;
2939 }
2940
2941 static int isdn_ppp_set_compressor(struct ippp_struct *is, struct isdn_ppp_comp_data *data)
2942 {
2943         struct isdn_ppp_compressor *ipc = ipc_head;
2944         int ret;
2945         void *stat;
2946         int num = data->num;
2947
2948         if(is->debug & 0x10)
2949                 printk(KERN_DEBUG "[%d] Set %s type %d\n",is->unit,
2950                         (data->flags&IPPP_COMP_FLAG_XMIT)?"compressor":"decompressor",num);
2951
2952         /* If is has no valid reset state vector, we cannot allocate a
2953            decompressor. The decompressor would cause reset transactions
2954            sooner or later, and they need that vector. */
2955
2956         if(!(data->flags & IPPP_COMP_FLAG_XMIT) && !is->reset) {
2957                 printk(KERN_ERR "ippp_ccp: no reset data structure - can't"
2958                        " allow decompression.\n");
2959                 return -ENOMEM;
2960         }
2961
2962         while(ipc) {
2963                 if(ipc->num == num) {
2964                         stat = ipc->alloc(data);
2965                         if(stat) {
2966                                 ret = ipc->init(stat,data,is->unit,0);
2967                                 if(!ret) {
2968                                         printk(KERN_ERR "Can't init (de)compression!\n");
2969                                         ipc->free(stat);
2970                                         stat = NULL;
2971                                         break;
2972                                 }
2973                         }
2974                         else {
2975                                 printk(KERN_ERR "Can't alloc (de)compression!\n");
2976                                 break;
2977                         }
2978
2979                         if(data->flags & IPPP_COMP_FLAG_XMIT) {
2980                                 if(data->flags & IPPP_COMP_FLAG_LINK) {
2981                                         if(is->link_comp_stat)
2982                                                 is->link_compressor->free(is->link_comp_stat);
2983                                         is->link_comp_stat = stat;
2984                                         is->link_compressor = ipc;
2985                                 }
2986                                 else {
2987                                         if(is->comp_stat)
2988                                                 is->compressor->free(is->comp_stat);
2989                                         is->comp_stat = stat;
2990                                         is->compressor = ipc;
2991                                 }
2992                         }
2993                         else {
2994                                 if(data->flags & IPPP_COMP_FLAG_LINK) {
2995                                         if(is->link_decomp_stat)
2996                                                 is->link_decompressor->free(is->link_decomp_stat);
2997                                         is->link_decomp_stat = stat;
2998                                         is->link_decompressor = ipc;
2999                                 }
3000                                 else {
3001                                         if(is->decomp_stat)
3002                                                 is->decompressor->free(is->decomp_stat);
3003                                         is->decomp_stat = stat;
3004                                         is->decompressor = ipc;
3005                                 }
3006                         }
3007                         return 0;
3008                 }
3009                 ipc = ipc->next;
3010         }
3011         return -EINVAL;
3012 }