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