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