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