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