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