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