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