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