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