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