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