drivers/isdn/i4l/isdn_ppp.c

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