drivers/isdn/i4l/isdn_ppp.c

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