drivers/isdn/i4l/isdn_ppp.c

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