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