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