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