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