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