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