1 /* $Id: isdn_ppp.c,v 1.1.2.3 2004/02/10 01:07:13 keil Exp $
3 * Linux ISDN subsystem, functions for synchronous PPP (linklevel).
5 * Copyright 1995,96 by Michael Hipp (Michael.Hipp@student.uni-tuebingen.de)
7 * This software may be used and distributed according to the terms
8 * of the GNU General Public License, incorporated herein by reference.
12 #include <linux/isdn.h>
13 #include <linux/poll.h>
14 #include <linux/ppp-comp.h>
15 #include <linux/slab.h>
16 #ifdef CONFIG_IPPP_FILTER
17 #include <linux/filter.h>
20 #include "isdn_common.h"
25 #define PPP_IPX 0x002b
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,
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,
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,
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,
63 #ifdef CONFIG_ISDN_MPP
64 static ippp_bundle *isdn_ppp_bundle_arr = NULL;
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,
70 static void isdn_ppp_mp_cleanup(isdn_net_local *lp);
72 static int isdn_ppp_bundle(struct ippp_struct *, int unit);
73 #endif /* CONFIG_ISDN_MPP */
75 char *isdn_ppp_revision = "$Revision: 1.1.2.3 $";
77 static struct ippp_struct *ippp_table[ISDN_MAX_CHANNELS];
79 static struct isdn_ppp_compressor *ipc_head = NULL;
85 isdn_ppp_frame_log(char *info, char *data, int len, int maxlen, int unit, int slot)
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);
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
108 isdn_ppp_free(isdn_net_local *lp)
110 struct ippp_struct *is;
112 if (lp->ppp_slot < 0 || lp->ppp_slot >= ISDN_MAX_CHANNELS) {
113 printk(KERN_ERR "%s: ppp_slot(%d) out of range\n",
114 __func__, lp->ppp_slot);
118 #ifdef CONFIG_ISDN_MPP
119 spin_lock(&lp->netdev->pb->lock);
121 isdn_net_rm_from_bundle(lp);
122 #ifdef CONFIG_ISDN_MPP
123 if (lp->netdev->pb->ref_ct == 1) /* last link in queue? */
124 isdn_ppp_mp_cleanup(lp);
126 lp->netdev->pb->ref_ct--;
127 spin_unlock(&lp->netdev->pb->lock);
128 #endif /* CONFIG_ISDN_MPP */
129 if (lp->ppp_slot < 0 || lp->ppp_slot >= ISDN_MAX_CHANNELS) {
130 printk(KERN_ERR "%s: ppp_slot(%d) now invalid\n",
131 __func__, lp->ppp_slot);
134 is = ippp_table[lp->ppp_slot];
135 if ((is->state & IPPP_CONNECT))
136 isdn_ppp_closewait(lp->ppp_slot); /* force wakeup on ippp device */
137 else if (is->state & IPPP_ASSIGNED)
138 is->state = IPPP_OPEN; /* fallback to 'OPEN but not ASSIGNED' state */
141 printk(KERN_DEBUG "isdn_ppp_free %d %lx %lx\n", lp->ppp_slot, (long) lp, (long) is->lp);
143 is->lp = NULL; /* link is down .. set lp to NULL */
144 lp->ppp_slot = -1; /* is this OK ?? */
150 * bind isdn_net_local <=> ippp-device
152 * This function is allways called with holding dev->lock so
153 * no additional lock is needed
156 isdn_ppp_bind(isdn_net_local *lp)
160 struct ippp_struct *is;
163 if (lp->pppbind < 0) { /* device bounded to ippp device ? */
164 isdn_net_dev *net_dev = dev->netdev;
165 char exclusive[ISDN_MAX_CHANNELS]; /* exclusive flags */
166 memset(exclusive, 0, ISDN_MAX_CHANNELS);
167 while (net_dev) { /* step through net devices to find exclusive minors */
168 isdn_net_local *lp = net_dev->local;
169 if (lp->pppbind >= 0)
170 exclusive[lp->pppbind] = 1;
171 net_dev = net_dev->next;
174 * search a free device / slot
176 for (i = 0; i < ISDN_MAX_CHANNELS; i++) {
177 if (ippp_table[i]->state == IPPP_OPEN && !exclusive[ippp_table[i]->minor]) { /* OPEN, but not connected! */
182 for (i = 0; i < ISDN_MAX_CHANNELS; i++) {
183 if (ippp_table[i]->minor == lp->pppbind &&
184 (ippp_table[i]->state & IPPP_OPEN) == IPPP_OPEN)
189 if (i >= ISDN_MAX_CHANNELS) {
190 printk(KERN_WARNING "isdn_ppp_bind: Can't find a (free) connection to the ipppd daemon.\n");
194 /* get unit number from interface name .. ugly! */
195 unit = isdn_ppp_if_get_unit(lp->netdev->dev->name);
197 printk(KERN_ERR "isdn_ppp_bind: illegal interface name %s.\n",
198 lp->netdev->dev->name);
207 is->state = IPPP_OPEN | IPPP_ASSIGNED; /* assigned to a netdevice but not connected */
208 #ifdef CONFIG_ISDN_MPP
209 retval = isdn_ppp_mp_init(lp, NULL);
212 #endif /* CONFIG_ISDN_MPP */
214 retval = lp->ppp_slot;
221 * kick the ipppd on the device
222 * (wakes up daemon after B-channel connect)
226 isdn_ppp_wakeup_daemon(isdn_net_local *lp)
228 if (lp->ppp_slot < 0 || lp->ppp_slot >= ISDN_MAX_CHANNELS) {
229 printk(KERN_ERR "%s: ppp_slot(%d) out of range\n",
230 __func__, lp->ppp_slot);
233 ippp_table[lp->ppp_slot]->state = IPPP_OPEN | IPPP_CONNECT | IPPP_NOBLOCK;
234 wake_up_interruptible(&ippp_table[lp->ppp_slot]->wq);
238 * there was a hangup on the netdevice
239 * force wakeup of the ippp device
240 * go into 'device waits for release' state
243 isdn_ppp_closewait(int slot)
245 struct ippp_struct *is;
247 if (slot < 0 || slot >= ISDN_MAX_CHANNELS) {
248 printk(KERN_ERR "%s: slot(%d) out of range\n",
252 is = ippp_table[slot];
254 wake_up_interruptible(&is->wq);
255 is->state = IPPP_CLOSEWAIT;
260 * isdn_ppp_find_slot / isdn_ppp_free_slot
264 isdn_ppp_get_slot(void)
267 for (i = 0; i < ISDN_MAX_CHANNELS; i++) {
268 if (!ippp_table[i]->state)
279 isdn_ppp_open(int min, struct file *file)
282 struct ippp_struct *is;
284 if (min < 0 || min >= ISDN_MAX_CHANNELS)
287 slot = isdn_ppp_get_slot();
291 is = file->private_data = ippp_table[slot];
293 printk(KERN_DEBUG "ippp, open, slot: %d, minor: %d, state: %04x\n",
294 slot, min, is->state);
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;
303 is->reset = isdn_ppp_ccp_reset_alloc(is);
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 */
314 init_waitqueue_head(&is->wq);
315 is->first = is->rq + NUM_RCV_BUFFS - 1; /* receive queue */
318 #ifdef CONFIG_ISDN_PPP_VJ
320 * VJ header compression init
322 is->slcomp = slhc_init(16, 16); /* not necessary for 2. link in bundle */
324 #ifdef CONFIG_IPPP_FILTER
325 is->pass_filter = NULL;
326 is->active_filter = NULL;
328 is->state = IPPP_OPEN;
334 * release ippp device
337 isdn_ppp_release(int min, struct file *file)
340 struct ippp_struct *is;
342 if (min < 0 || min >= ISDN_MAX_CHANNELS)
344 is = file->private_data;
347 printk(KERN_ERR "%s: no file->private_data\n", __func__);
351 printk(KERN_DEBUG "ippp: release, minor: %d %lx\n", min, (long) is->lp);
353 if (is->lp) { /* a lp address says: this link is still up */
354 isdn_net_dev *p = is->lp->netdev;
357 printk(KERN_ERR "%s: no lp->netdev\n", __func__);
360 is->state &= ~IPPP_CONNECT; /* -> effect: no call of wakeup */
362 * isdn_net_hangup() calls isdn_ppp_free()
363 * isdn_ppp_free() sets is->lp to NULL and lp->ppp_slot to -1
364 * removing the IPPP_CONNECT flag omits calling of isdn_ppp_wakeup_daemon()
366 isdn_net_hangup(p->dev);
368 for (i = 0; i < NUM_RCV_BUFFS; i++) {
369 kfree(is->rq[i].buf);
370 is->rq[i].buf = NULL;
372 is->first = is->rq + NUM_RCV_BUFFS - 1; /* receive queue */
375 #ifdef CONFIG_ISDN_PPP_VJ
376 /* TODO: if this was the previous master: link the slcomp to the new master */
377 slhc_free(is->slcomp);
380 #ifdef CONFIG_IPPP_FILTER
381 if (is->pass_filter) {
382 sk_unattached_filter_destroy(is->pass_filter);
383 is->pass_filter = NULL;
386 if (is->active_filter) {
387 sk_unattached_filter_destroy(is->active_filter);
388 is->active_filter = NULL;
392 /* TODO: if this was the previous master: link the stuff to the new master */
394 is->compressor->free(is->comp_stat);
395 if (is->link_comp_stat)
396 is->link_compressor->free(is->link_comp_stat);
397 if (is->link_decomp_stat)
398 is->link_decompressor->free(is->link_decomp_stat);
400 is->decompressor->free(is->decomp_stat);
401 is->compressor = is->link_compressor = NULL;
402 is->decompressor = is->link_decompressor = NULL;
403 is->comp_stat = is->link_comp_stat = NULL;
404 is->decomp_stat = is->link_decomp_stat = NULL;
406 /* Clean up if necessary */
408 isdn_ppp_ccp_reset_free(is);
410 /* this slot is ready for new connections */
415 * get_arg .. ioctl helper
418 get_arg(void __user *b, void *val, int len)
421 len = sizeof(void *);
422 if (copy_from_user(val, b, len))
428 * set arg .. ioctl helper
431 set_arg(void __user *b, void *val, int len)
434 len = sizeof(void *);
435 if (copy_to_user(b, val, len))
440 #ifdef CONFIG_IPPP_FILTER
441 static int get_filter(void __user *arg, struct sock_filter **p)
443 struct sock_fprog uprog;
444 struct sock_filter *code = NULL;
447 if (copy_from_user(&uprog, arg, sizeof(uprog)))
455 /* uprog.len is unsigned short, so no overflow here */
456 len = uprog.len * sizeof(struct sock_filter);
457 code = memdup_user(uprog.filter, len);
459 return PTR_ERR(code);
461 err = sk_chk_filter(code, uprog.len);
470 #endif /* CONFIG_IPPP_FILTER */
476 isdn_ppp_ioctl(int min, struct file *file, unsigned int cmd, unsigned long arg)
480 struct ippp_struct *is;
482 struct isdn_ppp_comp_data data;
483 void __user *argp = (void __user *)arg;
485 is = file->private_data;
489 printk(KERN_DEBUG "isdn_ppp_ioctl: minor: %d cmd: %x state: %x\n", min, cmd, is->state);
491 if (!(is->state & IPPP_OPEN))
496 #ifdef CONFIG_ISDN_MPP
497 if (!(is->state & IPPP_CONNECT))
499 if ((r = get_arg(argp, &val, sizeof(val))))
501 printk(KERN_DEBUG "iPPP-bundle: minor: %d, slave unit: %d, master unit: %d\n",
502 (int) min, (int) is->unit, (int) val);
503 return isdn_ppp_bundle(is, val);
508 case PPPIOCGUNIT: /* get ppp/isdn unit number */
509 if ((r = set_arg(argp, &is->unit, sizeof(is->unit))))
515 if ((r = set_arg(argp, lp->netdev->dev->name,
516 strlen(lp->netdev->dev->name))))
519 case PPPIOCGMPFLAGS: /* get configuration flags */
520 if ((r = set_arg(argp, &is->mpppcfg, sizeof(is->mpppcfg))))
523 case PPPIOCSMPFLAGS: /* set configuration flags */
524 if ((r = get_arg(argp, &val, sizeof(val))))
528 case PPPIOCGFLAGS: /* get configuration flags */
529 if ((r = set_arg(argp, &is->pppcfg, sizeof(is->pppcfg))))
532 case PPPIOCSFLAGS: /* set configuration flags */
533 if ((r = get_arg(argp, &val, sizeof(val)))) {
536 if (val & SC_ENABLE_IP && !(is->pppcfg & SC_ENABLE_IP) && (is->state & IPPP_CONNECT)) {
538 /* OK .. we are ready to send buffers */
539 is->pppcfg = val; /* isdn_ppp_xmit test for SC_ENABLE_IP !!! */
540 netif_wake_queue(lp->netdev->dev);
546 case PPPIOCGIDLE: /* get idle time information */
548 struct ppp_idle pidle;
549 pidle.xmit_idle = pidle.recv_idle = lp->huptimer;
550 if ((r = set_arg(argp, &pidle, sizeof(struct ppp_idle))))
554 case PPPIOCSMRU: /* set receive unit size for PPP */
555 if ((r = get_arg(argp, &val, sizeof(val))))
563 case PPPIOCSMAXCID: /* set the maximum compression slot id */
564 if ((r = get_arg(argp, &val, sizeof(val))))
567 if (is->maxcid != val) {
568 #ifdef CONFIG_ISDN_PPP_VJ
569 struct slcompress *sltmp;
572 printk(KERN_DEBUG "ippp, ioctl: changed MAXCID to %ld\n", val);
574 #ifdef CONFIG_ISDN_PPP_VJ
575 sltmp = slhc_init(16, val);
577 printk(KERN_ERR "ippp, can't realloc slhc struct\n");
581 slhc_free(is->slcomp);
587 if ((r = set_arg(argp, &is->debug, sizeof(is->debug))))
591 if ((r = get_arg(argp, &val, sizeof(val))))
595 case PPPIOCGCOMPRESSORS:
597 unsigned long protos[8] = {0,};
598 struct isdn_ppp_compressor *ipc = ipc_head;
600 j = ipc->num / (sizeof(long) * 8);
601 i = ipc->num % (sizeof(long) * 8);
603 protos[j] |= (1UL << i);
606 if ((r = set_arg(argp, protos, 8 * sizeof(long))))
610 case PPPIOCSCOMPRESSOR:
611 if ((r = get_arg(argp, &data, sizeof(struct isdn_ppp_comp_data))))
613 return isdn_ppp_set_compressor(is, &data);
614 case PPPIOCGCALLINFO:
616 struct pppcallinfo pci;
617 memset((char *)&pci, 0, sizeof(struct pppcallinfo));
620 strncpy(pci.local_num, lp->msn, 63);
622 strncpy(pci.remote_num, lp->dial->num, 63);
624 pci.charge_units = lp->charge;
626 pci.calltype = CALLTYPE_OUTGOING;
628 pci.calltype = CALLTYPE_INCOMING;
629 if (lp->flags & ISDN_NET_CALLBACK)
630 pci.calltype |= CALLTYPE_CALLBACK;
632 return set_arg(argp, &pci, sizeof(struct pppcallinfo));
634 #ifdef CONFIG_IPPP_FILTER
637 struct sock_fprog fprog;
638 struct sock_filter *code;
639 int err, len = get_filter(argp, &code);
648 sk_unattached_filter_destroy(is->pass_filter);
649 err = sk_unattached_filter_create(&is->pass_filter, &fprog);
656 struct sock_fprog fprog;
657 struct sock_filter *code;
658 int err, len = get_filter(argp, &code);
666 if (is->active_filter)
667 sk_unattached_filter_destroy(is->active_filter);
668 err = sk_unattached_filter_create(&is->active_filter, &fprog);
673 #endif /* CONFIG_IPPP_FILTER */
681 isdn_ppp_poll(struct file *file, poll_table *wait)
684 struct ippp_buf_queue *bf, *bl;
686 struct ippp_struct *is;
688 is = file->private_data;
691 printk(KERN_DEBUG "isdn_ppp_poll: minor: %d\n",
692 iminor(file_inode(file)));
694 /* just registers wait_queue hook. This doesn't really wait. */
695 poll_wait(file, &is->wq, wait);
697 if (!(is->state & IPPP_OPEN)) {
698 if (is->state == IPPP_CLOSEWAIT)
700 printk(KERN_DEBUG "isdn_ppp: device not open\n");
703 /* we're always ready to send .. */
704 mask = POLLOUT | POLLWRNORM;
706 spin_lock_irqsave(&is->buflock, flags);
710 * if IPPP_NOBLOCK is set we return even if we have nothing to read
712 if (bf->next != bl || (is->state & IPPP_NOBLOCK)) {
713 is->state &= ~IPPP_NOBLOCK;
714 mask |= POLLIN | POLLRDNORM;
716 spin_unlock_irqrestore(&is->buflock, flags);
721 * fill up isdn_ppp_read() queue ..
725 isdn_ppp_fill_rq(unsigned char *buf, int len, int proto, int slot)
727 struct ippp_buf_queue *bf, *bl;
730 struct ippp_struct *is;
732 if (slot < 0 || slot >= ISDN_MAX_CHANNELS) {
733 printk(KERN_WARNING "ippp: illegal slot(%d).\n", slot);
736 is = ippp_table[slot];
738 if (!(is->state & IPPP_CONNECT)) {
739 printk(KERN_DEBUG "ippp: device not activated.\n");
742 nbuf = kmalloc(len + 4, GFP_ATOMIC);
744 printk(KERN_WARNING "ippp: Can't alloc buf\n");
747 nbuf[0] = PPP_ALLSTATIONS;
749 nbuf[2] = proto >> 8;
750 nbuf[3] = proto & 0xff;
751 memcpy(nbuf + 4, buf, len);
753 spin_lock_irqsave(&is->buflock, flags);
758 printk(KERN_WARNING "ippp: Queue is full; discarding first buffer\n");
763 bl->buf = (char *) nbuf;
767 spin_unlock_irqrestore(&is->buflock, flags);
768 wake_up_interruptible(&is->wq);
773 * read() .. non-blocking: ipppd calls it only after select()
774 * reports, that there is data
778 isdn_ppp_read(int min, struct file *file, char __user *buf, int count)
780 struct ippp_struct *is;
781 struct ippp_buf_queue *b;
785 is = file->private_data;
787 if (!(is->state & IPPP_OPEN))
790 if (!access_ok(VERIFY_WRITE, buf, count))
793 spin_lock_irqsave(&is->buflock, flags);
797 spin_unlock_irqrestore(&is->buflock, flags);
805 spin_unlock_irqrestore(&is->buflock, flags);
806 if (copy_to_user(buf, save_buf, count))
814 * ipppd wanna write a packet to the card .. non-blocking
818 isdn_ppp_write(int min, struct file *file, const char __user *buf, int count)
821 struct ippp_struct *is;
823 unsigned char protobuf[4];
825 is = file->private_data;
827 if (!(is->state & IPPP_CONNECT))
832 /* -> push it directly to the lowlevel interface */
835 printk(KERN_DEBUG "isdn_ppp_write: lp == NULL\n");
838 * Don't reset huptimer for
839 * LCP packets. (Echo requests).
841 if (copy_from_user(protobuf, buf, 4))
843 proto = PPP_PROTOCOL(protobuf);
844 if (proto != PPP_LCP)
847 if (lp->isdn_device < 0 || lp->isdn_channel < 0)
850 if ((dev->drv[lp->isdn_device]->flags & DRV_FLAG_RUNNING) &&
851 lp->dialstate == 0 &&
852 (lp->flags & ISDN_NET_CONNECTED)) {
856 * we need to reserve enough space in front of
857 * sk_buff. old call to dev_alloc_skb only reserved
858 * 16 bytes, now we are looking what the driver want
860 hl = dev->drv[lp->isdn_device]->interface->hl_hdrlen;
861 skb = alloc_skb(hl + count, GFP_ATOMIC);
863 printk(KERN_WARNING "isdn_ppp_write: out of memory!\n");
866 skb_reserve(skb, hl);
867 if (copy_from_user(skb_put(skb, count), buf, count))
872 if (is->debug & 0x40) {
873 printk(KERN_DEBUG "ppp xmit: len %d\n", (int) skb->len);
874 isdn_ppp_frame_log("xmit", skb->data, skb->len, 32, is->unit, lp->ppp_slot);
877 isdn_ppp_send_ccp(lp->netdev, lp, skb); /* keeps CCP/compression states in sync */
879 isdn_net_write_super(lp, skb);
886 * init memory, structures etc.
895 #ifdef CONFIG_ISDN_MPP
896 if (isdn_ppp_mp_bundle_array_init() < 0)
898 #endif /* CONFIG_ISDN_MPP */
900 for (i = 0; i < ISDN_MAX_CHANNELS; i++) {
901 if (!(ippp_table[i] = kzalloc(sizeof(struct ippp_struct), GFP_KERNEL))) {
902 printk(KERN_WARNING "isdn_ppp_init: Could not alloc ippp_table\n");
903 for (j = 0; j < i; j++)
904 kfree(ippp_table[j]);
907 spin_lock_init(&ippp_table[i]->buflock);
908 ippp_table[i]->state = 0;
909 ippp_table[i]->first = ippp_table[i]->rq + NUM_RCV_BUFFS - 1;
910 ippp_table[i]->last = ippp_table[i]->rq;
912 for (j = 0; j < NUM_RCV_BUFFS; j++) {
913 ippp_table[i]->rq[j].buf = NULL;
914 ippp_table[i]->rq[j].last = ippp_table[i]->rq +
915 (NUM_RCV_BUFFS + j - 1) % NUM_RCV_BUFFS;
916 ippp_table[i]->rq[j].next = ippp_table[i]->rq + (j + 1) % NUM_RCV_BUFFS;
923 isdn_ppp_cleanup(void)
927 for (i = 0; i < ISDN_MAX_CHANNELS; i++)
928 kfree(ippp_table[i]);
930 #ifdef CONFIG_ISDN_MPP
931 kfree(isdn_ppp_bundle_arr);
932 #endif /* CONFIG_ISDN_MPP */
937 * check for address/control field and skip if allowed
938 * retval != 0 -> discard packet silently
940 static int isdn_ppp_skip_ac(struct ippp_struct *is, struct sk_buff *skb)
945 if (skb->data[0] == 0xff) {
949 if (skb->data[1] != 0x03)
952 // skip address/control (AC) field
955 if (is->pppcfg & SC_REJ_COMP_AC)
956 // if AC compression was not negotiated, but used, discard packet
963 * get the PPP protocol header and pull skb
964 * retval < 0 -> discard packet silently
966 static int isdn_ppp_strip_proto(struct sk_buff *skb)
973 if (skb->data[0] & 0x1) {
974 // protocol field is compressed
975 proto = skb->data[0];
980 proto = ((int) skb->data[0] << 8) + skb->data[1];
988 * handler for incoming packets on a syncPPP interface
990 void isdn_ppp_receive(isdn_net_dev *net_dev, isdn_net_local *lp, struct sk_buff *skb)
992 struct ippp_struct *is;
996 BUG_ON(net_dev->local->master); // we're called with the master device always
999 if (slot < 0 || slot >= ISDN_MAX_CHANNELS) {
1000 printk(KERN_ERR "isdn_ppp_receive: lp->ppp_slot(%d)\n",
1005 is = ippp_table[slot];
1007 if (is->debug & 0x4) {
1008 printk(KERN_DEBUG "ippp_receive: is:%08lx lp:%08lx slot:%d unit:%d len:%d\n",
1009 (long)is, (long)lp, lp->ppp_slot, is->unit, (int)skb->len);
1010 isdn_ppp_frame_log("receive", skb->data, skb->len, 32, is->unit, lp->ppp_slot);
1013 if (isdn_ppp_skip_ac(is, skb) < 0) {
1017 proto = isdn_ppp_strip_proto(skb);
1023 #ifdef CONFIG_ISDN_MPP
1024 if (is->compflags & SC_LINK_DECOMP_ON) {
1025 skb = isdn_ppp_decompress(skb, is, NULL, &proto);
1026 if (!skb) // decompression error
1030 if (!(is->mpppcfg & SC_REJ_MP_PROT)) { // we agreed to receive MPPP
1031 if (proto == PPP_MP) {
1032 isdn_ppp_mp_receive(net_dev, lp, skb);
1037 isdn_ppp_push_higher(net_dev, lp, skb, proto);
1041 * we receive a reassembled frame, MPPP has been taken care of before.
1042 * address/control and protocol have been stripped from the skb
1043 * note: net_dev has to be master net_dev
1046 isdn_ppp_push_higher(isdn_net_dev *net_dev, isdn_net_local *lp, struct sk_buff *skb, int proto)
1048 struct net_device *dev = net_dev->dev;
1049 struct ippp_struct *is, *mis;
1050 isdn_net_local *mlp = NULL;
1053 slot = lp->ppp_slot;
1054 if (slot < 0 || slot >= ISDN_MAX_CHANNELS) {
1055 printk(KERN_ERR "isdn_ppp_push_higher: lp->ppp_slot(%d)\n",
1059 is = ippp_table[slot];
1061 if (lp->master) { // FIXME?
1062 mlp = ISDN_MASTER_PRIV(lp);
1063 slot = mlp->ppp_slot;
1064 if (slot < 0 || slot >= ISDN_MAX_CHANNELS) {
1065 printk(KERN_ERR "isdn_ppp_push_higher: master->ppp_slot(%d)\n",
1070 mis = ippp_table[slot];
1072 if (is->debug & 0x10) {
1073 printk(KERN_DEBUG "push, skb %d %04x\n", (int) skb->len, proto);
1074 isdn_ppp_frame_log("rpush", skb->data, skb->len, 32, is->unit, lp->ppp_slot);
1076 if (mis->compflags & SC_DECOMP_ON) {
1077 skb = isdn_ppp_decompress(skb, is, mis, &proto);
1078 if (!skb) // decompression error
1082 case PPP_IPX: /* untested */
1083 if (is->debug & 0x20)
1084 printk(KERN_DEBUG "isdn_ppp: IPX\n");
1085 skb->protocol = htons(ETH_P_IPX);
1088 if (is->debug & 0x20)
1089 printk(KERN_DEBUG "isdn_ppp: IP\n");
1090 skb->protocol = htons(ETH_P_IP);
1094 printk(KERN_INFO "isdn_ppp: unexpected compressed frame dropped\n");
1096 #ifdef CONFIG_ISDN_PPP_VJ
1097 case PPP_VJC_UNCOMP:
1098 if (is->debug & 0x20)
1099 printk(KERN_DEBUG "isdn_ppp: VJC_UNCOMP\n");
1100 if (net_dev->local->ppp_slot < 0) {
1101 printk(KERN_ERR "%s: net_dev->local->ppp_slot(%d) out of range\n",
1102 __func__, net_dev->local->ppp_slot);
1105 if (slhc_remember(ippp_table[net_dev->local->ppp_slot]->slcomp, skb->data, skb->len) <= 0) {
1106 printk(KERN_WARNING "isdn_ppp: received illegal VJC_UNCOMP frame!\n");
1109 skb->protocol = htons(ETH_P_IP);
1112 if (is->debug & 0x20)
1113 printk(KERN_DEBUG "isdn_ppp: VJC_COMP\n");
1115 struct sk_buff *skb_old = skb;
1117 skb = dev_alloc_skb(skb_old->len + 128);
1120 printk(KERN_WARNING "%s: Memory squeeze, dropping packet.\n", dev->name);
1124 skb_put(skb, skb_old->len + 128);
1125 skb_copy_from_linear_data(skb_old, skb->data,
1127 if (net_dev->local->ppp_slot < 0) {
1128 printk(KERN_ERR "%s: net_dev->local->ppp_slot(%d) out of range\n",
1129 __func__, net_dev->local->ppp_slot);
1132 pkt_len = slhc_uncompress(ippp_table[net_dev->local->ppp_slot]->slcomp,
1133 skb->data, skb_old->len);
1138 skb_trim(skb, pkt_len);
1139 skb->protocol = htons(ETH_P_IP);
1145 isdn_ppp_receive_ccp(net_dev, lp, skb, proto);
1146 /* Dont pop up ResetReq/Ack stuff to the daemon any
1147 longer - the job is done already */
1148 if (skb->data[0] == CCP_RESETREQ ||
1149 skb->data[0] == CCP_RESETACK)
1153 isdn_ppp_fill_rq(skb->data, skb->len, proto, lp->ppp_slot); /* push data to pppd device */
1158 #ifdef CONFIG_IPPP_FILTER
1159 /* check if the packet passes the pass and active filters
1160 * the filter instructions are constructed assuming
1161 * a four-byte PPP header on each packet (which is still present) */
1165 u_int16_t *p = (u_int16_t *) skb->data;
1167 *p = 0; /* indicate inbound */
1171 && SK_RUN_FILTER(is->pass_filter, skb) == 0) {
1172 if (is->debug & 0x2)
1173 printk(KERN_DEBUG "IPPP: inbound frame filtered.\n");
1177 if (!(is->active_filter
1178 && SK_RUN_FILTER(is->active_filter, skb) == 0)) {
1179 if (is->debug & 0x2)
1180 printk(KERN_DEBUG "IPPP: link-active filter: resetting huptimer.\n");
1186 #else /* CONFIG_IPPP_FILTER */
1190 #endif /* CONFIG_IPPP_FILTER */
1192 skb_reset_mac_header(skb);
1194 /* net_dev->local->stats.rx_packets++; done in isdn_net.c */
1198 net_dev->local->stats.rx_dropped++;
1203 * isdn_ppp_skb_push ..
1204 * checks whether we have enough space at the beginning of the skb
1205 * and allocs a new SKB if necessary
1207 static unsigned char *isdn_ppp_skb_push(struct sk_buff **skb_p, int len)
1209 struct sk_buff *skb = *skb_p;
1211 if (skb_headroom(skb) < len) {
1212 struct sk_buff *nskb = skb_realloc_headroom(skb, len);
1215 printk(KERN_ERR "isdn_ppp_skb_push: can't realloc headroom!\n");
1219 printk(KERN_DEBUG "isdn_ppp_skb_push:under %d %d\n", skb_headroom(skb), len);
1222 return skb_push(nskb, len);
1224 return skb_push(skb, len);
1228 * send ppp frame .. we expect a PIDCOMPressable proto --
1229 * (here: currently always PPP_IP,PPP_VJC_COMP,PPP_VJC_UNCOMP)
1231 * VJ compression may change skb pointer!!! .. requeue with old
1232 * skb isn't allowed!!
1236 isdn_ppp_xmit(struct sk_buff *skb, struct net_device *netdev)
1238 isdn_net_local *lp, *mlp;
1240 unsigned int proto = PPP_IP; /* 0x21 */
1241 struct ippp_struct *ipt, *ipts;
1242 int slot, retval = NETDEV_TX_OK;
1244 mlp = netdev_priv(netdev);
1245 nd = mlp->netdev; /* get master lp */
1247 slot = mlp->ppp_slot;
1248 if (slot < 0 || slot >= ISDN_MAX_CHANNELS) {
1249 printk(KERN_ERR "isdn_ppp_xmit: lp->ppp_slot(%d)\n",
1254 ipts = ippp_table[slot];
1256 if (!(ipts->pppcfg & SC_ENABLE_IP)) { /* PPP connected ? */
1257 if (ipts->debug & 0x1)
1258 printk(KERN_INFO "%s: IP frame delayed.\n", netdev->name);
1259 retval = NETDEV_TX_BUSY;
1263 switch (ntohs(skb->protocol)) {
1268 proto = PPP_IPX; /* untested */
1271 printk(KERN_ERR "isdn_ppp: skipped unsupported protocol: %#x.\n",
1277 lp = isdn_net_get_locked_lp(nd);
1279 printk(KERN_WARNING "%s: all channels busy - requeuing!\n", netdev->name);
1280 retval = NETDEV_TX_BUSY;
1283 /* we have our lp locked from now on */
1285 slot = lp->ppp_slot;
1286 if (slot < 0 || slot >= ISDN_MAX_CHANNELS) {
1287 printk(KERN_ERR "isdn_ppp_xmit: lp->ppp_slot(%d)\n",
1292 ipt = ippp_table[slot];
1295 * after this line .. requeueing in the device queue is no longer allowed!!!
1298 /* Pull off the fake header we stuck on earlier to keep
1299 * the fragmentation code happy.
1301 skb_pull(skb, IPPP_MAX_HEADER);
1303 #ifdef CONFIG_IPPP_FILTER
1304 /* check if we should pass this packet
1305 * the filter instructions are constructed assuming
1306 * a four-byte PPP header on each packet */
1307 *skb_push(skb, 4) = 1; /* indicate outbound */
1310 __be16 *p = (__be16 *)skb->data;
1316 if (ipt->pass_filter
1317 && SK_RUN_FILTER(ipt->pass_filter, skb) == 0) {
1318 if (ipt->debug & 0x4)
1319 printk(KERN_DEBUG "IPPP: outbound frame filtered.\n");
1323 if (!(ipt->active_filter
1324 && SK_RUN_FILTER(ipt->active_filter, skb) == 0)) {
1325 if (ipt->debug & 0x4)
1326 printk(KERN_DEBUG "IPPP: link-active filter: resetting huptimer.\n");
1330 #else /* CONFIG_IPPP_FILTER */
1332 #endif /* CONFIG_IPPP_FILTER */
1334 if (ipt->debug & 0x4)
1335 printk(KERN_DEBUG "xmit skb, len %d\n", (int) skb->len);
1336 if (ipts->debug & 0x40)
1337 isdn_ppp_frame_log("xmit0", skb->data, skb->len, 32, ipts->unit, lp->ppp_slot);
1339 #ifdef CONFIG_ISDN_PPP_VJ
1340 if (proto == PPP_IP && ipts->pppcfg & SC_COMP_TCP) { /* ipts here? probably yes, but check this again */
1341 struct sk_buff *new_skb;
1344 * we need to reserve enough space in front of
1345 * sk_buff. old call to dev_alloc_skb only reserved
1346 * 16 bytes, now we are looking what the driver want.
1348 hl = dev->drv[lp->isdn_device]->interface->hl_hdrlen + IPPP_MAX_HEADER;
1350 * Note: hl might still be insufficient because the method
1351 * above does not account for a possibible MPPP slave channel
1352 * which had larger HL header space requirements than the
1355 new_skb = alloc_skb(hl + skb->len, GFP_ATOMIC);
1360 skb_reserve(new_skb, hl);
1361 new_skb->dev = skb->dev;
1362 skb_put(new_skb, skb->len);
1365 pktlen = slhc_compress(ipts->slcomp, skb->data, skb->len, new_skb->data,
1366 &buf, !(ipts->pppcfg & SC_NO_TCP_CCID));
1368 if (buf != skb->data) {
1369 if (new_skb->data != buf)
1370 printk(KERN_ERR "isdn_ppp: FATAL error after slhc_compress!!\n");
1374 dev_kfree_skb(new_skb);
1377 skb_trim(skb, pktlen);
1378 if (skb->data[0] & SL_TYPE_COMPRESSED_TCP) { /* cslip? style -> PPP */
1379 proto = PPP_VJC_COMP;
1380 skb->data[0] ^= SL_TYPE_COMPRESSED_TCP;
1382 if (skb->data[0] >= SL_TYPE_UNCOMPRESSED_TCP)
1383 proto = PPP_VJC_UNCOMP;
1384 skb->data[0] = (skb->data[0] & 0x0f) | 0x40;
1391 * normal (single link) or bundle compression
1393 if (ipts->compflags & SC_COMP_ON) {
1394 /* We send compressed only if both down- und upstream
1395 compression is negotiated, that means, CCP is up */
1396 if (ipts->compflags & SC_DECOMP_ON) {
1397 skb = isdn_ppp_compress(skb, &proto, ipt, ipts, 0);
1399 printk(KERN_DEBUG "isdn_ppp: CCP not yet up - sending as-is\n");
1403 if (ipt->debug & 0x24)
1404 printk(KERN_DEBUG "xmit2 skb, len %d, proto %04x\n", (int) skb->len, proto);
1406 #ifdef CONFIG_ISDN_MPP
1407 if (ipt->mpppcfg & SC_MP_PROT) {
1408 /* we get mp_seqno from static isdn_net_local */
1409 long mp_seqno = ipts->mp_seqno;
1411 if (ipt->mpppcfg & SC_OUT_SHORT_SEQ) {
1412 unsigned char *data = isdn_ppp_skb_push(&skb, 3);
1416 data[0] = MP_BEGIN_FRAG | MP_END_FRAG | ((mp_seqno >> 8) & 0xf); /* (B)egin & (E)ndbit .. */
1417 data[1] = mp_seqno & 0xff;
1418 data[2] = proto; /* PID compression */
1420 unsigned char *data = isdn_ppp_skb_push(&skb, 5);
1423 data[0] = MP_BEGIN_FRAG | MP_END_FRAG; /* (B)egin & (E)ndbit .. */
1424 data[1] = (mp_seqno >> 16) & 0xff; /* sequence number: 24bit */
1425 data[2] = (mp_seqno >> 8) & 0xff;
1426 data[3] = (mp_seqno >> 0) & 0xff;
1427 data[4] = proto; /* PID compression */
1429 proto = PPP_MP; /* MP Protocol, 0x003d */
1434 * 'link in bundle' compression ...
1436 if (ipt->compflags & SC_LINK_COMP_ON)
1437 skb = isdn_ppp_compress(skb, &proto, ipt, ipts, 1);
1439 if ((ipt->pppcfg & SC_COMP_PROT) && (proto <= 0xff)) {
1440 unsigned char *data = isdn_ppp_skb_push(&skb, 1);
1443 data[0] = proto & 0xff;
1446 unsigned char *data = isdn_ppp_skb_push(&skb, 2);
1449 data[0] = (proto >> 8) & 0xff;
1450 data[1] = proto & 0xff;
1452 if (!(ipt->pppcfg & SC_COMP_AC)) {
1453 unsigned char *data = isdn_ppp_skb_push(&skb, 2);
1456 data[0] = 0xff; /* All Stations */
1457 data[1] = 0x03; /* Unnumbered information */
1460 /* tx-stats are now updated via BSENT-callback */
1462 if (ipts->debug & 0x40) {
1463 printk(KERN_DEBUG "skb xmit: len: %d\n", (int) skb->len);
1464 isdn_ppp_frame_log("xmit", skb->data, skb->len, 32, ipt->unit, lp->ppp_slot);
1467 isdn_net_writebuf_skb(lp, skb);
1470 spin_unlock_bh(&lp->xmit_lock);
1475 #ifdef CONFIG_IPPP_FILTER
1477 * check if this packet may trigger auto-dial.
1480 int isdn_ppp_autodial_filter(struct sk_buff *skb, isdn_net_local *lp)
1482 struct ippp_struct *is = ippp_table[lp->ppp_slot];
1486 switch (ntohs(skb->protocol)) {
1494 printk(KERN_ERR "isdn_ppp_autodial_filter: unsupported protocol 0x%x.\n",
1499 /* the filter instructions are constructed assuming
1500 * a four-byte PPP header on each packet. we have to
1501 * temporarily remove part of the fake header stuck on
1504 *skb_pull(skb, IPPP_MAX_HEADER - 4) = 1; /* indicate outbound */
1507 __be16 *p = (__be16 *)skb->data;
1513 drop |= is->pass_filter
1514 && SK_RUN_FILTER(is->pass_filter, skb) == 0;
1515 drop |= is->active_filter
1516 && SK_RUN_FILTER(is->active_filter, skb) == 0;
1518 skb_push(skb, IPPP_MAX_HEADER - 4);
1522 #ifdef CONFIG_ISDN_MPP
1524 /* this is _not_ rfc1990 header, but something we convert both short and long
1525 * headers to for convinience's sake:
1526 * byte 0 is flags as in rfc1990
1527 * bytes 1...4 is 24-bit seqence number converted to host byte order
1529 #define MP_HEADER_LEN 5
1531 #define MP_LONGSEQ_MASK 0x00ffffff
1532 #define MP_SHORTSEQ_MASK 0x00000fff
1533 #define MP_LONGSEQ_MAX MP_LONGSEQ_MASK
1534 #define MP_SHORTSEQ_MAX MP_SHORTSEQ_MASK
1535 #define MP_LONGSEQ_MAXBIT ((MP_LONGSEQ_MASK + 1) >> 1)
1536 #define MP_SHORTSEQ_MAXBIT ((MP_SHORTSEQ_MASK + 1) >> 1)
1538 /* sequence-wrap safe comparisons (for long sequence)*/
1539 #define MP_LT(a, b) ((a - b) & MP_LONGSEQ_MAXBIT)
1540 #define MP_LE(a, b) !((b - a) & MP_LONGSEQ_MAXBIT)
1541 #define MP_GT(a, b) ((b - a) & MP_LONGSEQ_MAXBIT)
1542 #define MP_GE(a, b) !((a - b) & MP_LONGSEQ_MAXBIT)
1544 #define MP_SEQ(f) ((*(u32 *)(f->data + 1)))
1545 #define MP_FLAGS(f) (f->data[0])
1547 static int isdn_ppp_mp_bundle_array_init(void)
1550 int sz = ISDN_MAX_CHANNELS * sizeof(ippp_bundle);
1551 if ((isdn_ppp_bundle_arr = kzalloc(sz, GFP_KERNEL)) == NULL)
1553 for (i = 0; i < ISDN_MAX_CHANNELS; i++)
1554 spin_lock_init(&isdn_ppp_bundle_arr[i].lock);
1558 static ippp_bundle *isdn_ppp_mp_bundle_alloc(void)
1561 for (i = 0; i < ISDN_MAX_CHANNELS; i++)
1562 if (isdn_ppp_bundle_arr[i].ref_ct <= 0)
1563 return (isdn_ppp_bundle_arr + i);
1567 static int isdn_ppp_mp_init(isdn_net_local *lp, ippp_bundle *add_to)
1569 struct ippp_struct *is;
1571 if (lp->ppp_slot < 0) {
1572 printk(KERN_ERR "%s: lp->ppp_slot(%d) out of range\n",
1573 __func__, lp->ppp_slot);
1577 is = ippp_table[lp->ppp_slot];
1580 lp->netdev->pb->ref_ct--;
1581 lp->netdev->pb = add_to;
1582 } else { /* first link in a bundle */
1584 if ((lp->netdev->pb = isdn_ppp_mp_bundle_alloc()) == NULL)
1586 lp->next = lp->last = lp; /* nobody else in a queue */
1587 lp->netdev->pb->frags = NULL;
1588 lp->netdev->pb->frames = 0;
1589 lp->netdev->pb->seq = UINT_MAX;
1591 lp->netdev->pb->ref_ct++;
1593 is->last_link_seqno = 0;
1597 static u32 isdn_ppp_mp_get_seq(int short_seq,
1598 struct sk_buff *skb, u32 last_seq);
1599 static struct sk_buff *isdn_ppp_mp_discard(ippp_bundle *mp,
1600 struct sk_buff *from, struct sk_buff *to);
1601 static void isdn_ppp_mp_reassembly(isdn_net_dev *net_dev, isdn_net_local *lp,
1602 struct sk_buff *from, struct sk_buff *to);
1603 static void isdn_ppp_mp_free_skb(ippp_bundle *mp, struct sk_buff *skb);
1604 static void isdn_ppp_mp_print_recv_pkt(int slot, struct sk_buff *skb);
1606 static void isdn_ppp_mp_receive(isdn_net_dev *net_dev, isdn_net_local *lp,
1607 struct sk_buff *skb)
1609 struct ippp_struct *is;
1610 isdn_net_local *lpq;
1612 isdn_mppp_stats *stats;
1613 struct sk_buff *newfrag, *frag, *start, *nextf;
1614 u32 newseq, minseq, thisseq;
1615 unsigned long flags;
1618 spin_lock_irqsave(&net_dev->pb->lock, flags);
1621 slot = lp->ppp_slot;
1622 if (slot < 0 || slot >= ISDN_MAX_CHANNELS) {
1623 printk(KERN_ERR "%s: lp->ppp_slot(%d)\n",
1624 __func__, lp->ppp_slot);
1625 stats->frame_drops++;
1627 spin_unlock_irqrestore(&mp->lock, flags);
1630 is = ippp_table[slot];
1631 if (++mp->frames > stats->max_queue_len)
1632 stats->max_queue_len = mp->frames;
1634 if (is->debug & 0x8)
1635 isdn_ppp_mp_print_recv_pkt(lp->ppp_slot, skb);
1637 newseq = isdn_ppp_mp_get_seq(is->mpppcfg & SC_IN_SHORT_SEQ,
1638 skb, is->last_link_seqno);
1641 /* if this packet seq # is less than last already processed one,
1642 * toss it right away, but check for sequence start case first
1644 if (mp->seq > MP_LONGSEQ_MAX && (newseq & MP_LONGSEQ_MAXBIT)) {
1645 mp->seq = newseq; /* the first packet: required for
1646 * rfc1990 non-compliant clients --
1647 * prevents constant packet toss */
1648 } else if (MP_LT(newseq, mp->seq)) {
1649 stats->frame_drops++;
1650 isdn_ppp_mp_free_skb(mp, skb);
1651 spin_unlock_irqrestore(&mp->lock, flags);
1655 /* find the minimum received sequence number over all links */
1656 is->last_link_seqno = minseq = newseq;
1657 for (lpq = net_dev->queue;;) {
1658 slot = lpq->ppp_slot;
1659 if (slot < 0 || slot >= ISDN_MAX_CHANNELS) {
1660 printk(KERN_ERR "%s: lpq->ppp_slot(%d)\n",
1661 __func__, lpq->ppp_slot);
1663 u32 lls = ippp_table[slot]->last_link_seqno;
1664 if (MP_LT(lls, minseq))
1667 if ((lpq = lpq->next) == net_dev->queue)
1670 if (MP_LT(minseq, mp->seq))
1671 minseq = mp->seq; /* can't go beyond already processed
1675 /* if this new fragment is before the first one, then enqueue it now. */
1676 if ((frag = mp->frags) == NULL || MP_LT(newseq, MP_SEQ(frag))) {
1677 newfrag->next = frag;
1678 mp->frags = frag = newfrag;
1682 start = MP_FLAGS(frag) & MP_BEGIN_FRAG &&
1683 MP_SEQ(frag) == mp->seq ? frag : NULL;
1686 * main fragment traversing loop
1688 * try to accomplish several tasks:
1689 * - insert new fragment into the proper sequence slot (once that's done
1690 * newfrag will be set to NULL)
1691 * - reassemble any complete fragment sequence (non-null 'start'
1692 * indicates there is a contiguous sequence present)
1693 * - discard any incomplete sequences that are below minseq -- due
1694 * to the fact that sender always increment sequence number, if there
1695 * is an incomplete sequence below minseq, no new fragments would
1696 * come to complete such sequence and it should be discarded
1698 * loop completes when we accomplished the following tasks:
1699 * - new fragment is inserted in the proper sequence ('newfrag' is
1701 * - we hit a gap in the sequence, so no reassembly/processing is
1702 * possible ('start' would be set to NULL)
1704 * algorithm for this code is derived from code in the book
1705 * 'PPP Design And Debugging' by James Carlson (Addison-Wesley)
1707 while (start != NULL || newfrag != NULL) {
1709 thisseq = MP_SEQ(frag);
1712 /* drop any duplicate fragments */
1713 if (newfrag != NULL && thisseq == newseq) {
1714 isdn_ppp_mp_free_skb(mp, newfrag);
1718 /* insert new fragment before next element if possible. */
1719 if (newfrag != NULL && (nextf == NULL ||
1720 MP_LT(newseq, MP_SEQ(nextf)))) {
1721 newfrag->next = nextf;
1722 frag->next = nextf = newfrag;
1726 if (start != NULL) {
1727 /* check for misplaced start */
1728 if (start != frag && (MP_FLAGS(frag) & MP_BEGIN_FRAG)) {
1729 printk(KERN_WARNING"isdn_mppp(seq %d): new "
1730 "BEGIN flag with no prior END", thisseq);
1732 stats->frame_drops++;
1733 start = isdn_ppp_mp_discard(mp, start, frag);
1736 } else if (MP_LE(thisseq, minseq)) {
1737 if (MP_FLAGS(frag) & MP_BEGIN_FRAG)
1740 if (MP_FLAGS(frag) & MP_END_FRAG)
1741 stats->frame_drops++;
1742 if (mp->frags == frag)
1744 isdn_ppp_mp_free_skb(mp, frag);
1750 /* if start is non-null and we have end fragment, then
1751 * we have full reassembly sequence -- reassemble
1752 * and process packet now
1754 if (start != NULL && (MP_FLAGS(frag) & MP_END_FRAG)) {
1755 minseq = mp->seq = (thisseq + 1) & MP_LONGSEQ_MASK;
1756 /* Reassemble the packet then dispatch it */
1757 isdn_ppp_mp_reassembly(net_dev, lp, start, nextf);
1765 /* check if need to update start pointer: if we just
1766 * reassembled the packet and sequence is contiguous
1767 * then next fragment should be the start of new reassembly
1768 * if sequence is contiguous, but we haven't reassembled yet,
1770 * if sequence is not contiguous, either clear everything
1771 * below low watermark and set start to the next frag or
1774 if (nextf != NULL &&
1775 ((thisseq + 1) & MP_LONGSEQ_MASK) == MP_SEQ(nextf)) {
1776 /* if we just reassembled and the next one is here,
1777 * then start another reassembly. */
1780 if (MP_FLAGS(nextf) & MP_BEGIN_FRAG)
1784 printk(KERN_WARNING"isdn_mppp(seq %d):"
1785 " END flag with no following "
1792 if (nextf != NULL && frag != NULL &&
1793 MP_LT(thisseq, minseq)) {
1794 /* we've got a break in the sequence
1795 * and we not at the end yet
1796 * and we did not just reassembled
1797 *(if we did, there wouldn't be anything before)
1798 * and we below the low watermark
1799 * discard all the frames below low watermark
1801 stats->frame_drops++;
1802 mp->frags = isdn_ppp_mp_discard(mp, start, nextf);
1804 /* break in the sequence, no reassembly */
1809 } /* while -- main loop */
1811 if (mp->frags == NULL)
1814 /* rather straighforward way to deal with (not very) possible
1816 if (mp->frames > MP_MAX_QUEUE_LEN) {
1818 while (mp->frames > MP_MAX_QUEUE_LEN) {
1819 frag = mp->frags->next;
1820 isdn_ppp_mp_free_skb(mp, mp->frags);
1824 spin_unlock_irqrestore(&mp->lock, flags);
1827 static void isdn_ppp_mp_cleanup(isdn_net_local *lp)
1829 struct sk_buff *frag = lp->netdev->pb->frags;
1830 struct sk_buff *nextfrag;
1832 nextfrag = frag->next;
1833 isdn_ppp_mp_free_skb(lp->netdev->pb, frag);
1836 lp->netdev->pb->frags = NULL;
1839 static u32 isdn_ppp_mp_get_seq(int short_seq,
1840 struct sk_buff *skb, u32 last_seq)
1843 int flags = skb->data[0] & (MP_BEGIN_FRAG | MP_END_FRAG);
1847 seq = ntohl(*(__be32 *)skb->data) & MP_LONGSEQ_MASK;
1852 /* convert 12-bit short seq number to 24-bit long one
1854 seq = ntohs(*(__be16 *)skb->data) & MP_SHORTSEQ_MASK;
1856 /* check for seqence wrap */
1857 if (!(seq & MP_SHORTSEQ_MAXBIT) &&
1858 (last_seq & MP_SHORTSEQ_MAXBIT) &&
1859 (unsigned long)last_seq <= MP_LONGSEQ_MAX)
1860 seq |= (last_seq + MP_SHORTSEQ_MAX + 1) &
1861 (~MP_SHORTSEQ_MASK & MP_LONGSEQ_MASK);
1863 seq |= last_seq & (~MP_SHORTSEQ_MASK & MP_LONGSEQ_MASK);
1865 skb_push(skb, 3); /* put converted seqence back in skb */
1867 *(u32 *)(skb->data + 1) = seq; /* put seqence back in _host_ byte
1869 skb->data[0] = flags; /* restore flags */
1873 struct sk_buff *isdn_ppp_mp_discard(ippp_bundle *mp,
1874 struct sk_buff *from, struct sk_buff *to)
1877 while (from != to) {
1878 struct sk_buff *next = from->next;
1879 isdn_ppp_mp_free_skb(mp, from);
1885 void isdn_ppp_mp_reassembly(isdn_net_dev *net_dev, isdn_net_local *lp,
1886 struct sk_buff *from, struct sk_buff *to)
1888 ippp_bundle *mp = net_dev->pb;
1890 struct sk_buff *skb;
1891 unsigned int tot_len;
1893 if (lp->ppp_slot < 0 || lp->ppp_slot >= ISDN_MAX_CHANNELS) {
1894 printk(KERN_ERR "%s: lp->ppp_slot(%d) out of range\n",
1895 __func__, lp->ppp_slot);
1898 if (MP_FLAGS(from) == (MP_BEGIN_FRAG | MP_END_FRAG)) {
1899 if (ippp_table[lp->ppp_slot]->debug & 0x40)
1900 printk(KERN_DEBUG "isdn_mppp: reassembly: frame %d, "
1901 "len %d\n", MP_SEQ(from), from->len);
1903 skb_pull(skb, MP_HEADER_LEN);
1906 struct sk_buff *frag;
1909 for (tot_len = n = 0, frag = from; frag != to; frag = frag->next, n++)
1910 tot_len += frag->len - MP_HEADER_LEN;
1912 if (ippp_table[lp->ppp_slot]->debug & 0x40)
1913 printk(KERN_DEBUG"isdn_mppp: reassembling frames %d "
1914 "to %d, len %d\n", MP_SEQ(from),
1915 (MP_SEQ(from) + n - 1) & MP_LONGSEQ_MASK, tot_len);
1916 if ((skb = dev_alloc_skb(tot_len)) == NULL) {
1917 printk(KERN_ERR "isdn_mppp: cannot allocate sk buff "
1918 "of size %d\n", tot_len);
1919 isdn_ppp_mp_discard(mp, from, to);
1923 while (from != to) {
1924 unsigned int len = from->len - MP_HEADER_LEN;
1926 skb_copy_from_linear_data_offset(from, MP_HEADER_LEN,
1930 isdn_ppp_mp_free_skb(mp, from);
1934 proto = isdn_ppp_strip_proto(skb);
1935 isdn_ppp_push_higher(net_dev, lp, skb, proto);
1938 static void isdn_ppp_mp_free_skb(ippp_bundle *mp, struct sk_buff *skb)
1944 static void isdn_ppp_mp_print_recv_pkt(int slot, struct sk_buff *skb)
1946 printk(KERN_DEBUG "mp_recv: %d/%d -> %02x %02x %02x %02x %02x %02x\n",
1947 slot, (int) skb->len,
1948 (int) skb->data[0], (int) skb->data[1], (int) skb->data[2],
1949 (int) skb->data[3], (int) skb->data[4], (int) skb->data[5]);
1953 isdn_ppp_bundle(struct ippp_struct *is, int unit)
1955 char ifn[IFNAMSIZ + 1];
1957 isdn_net_local *lp, *nlp;
1959 unsigned long flags;
1961 sprintf(ifn, "ippp%d", unit);
1962 p = isdn_net_findif(ifn);
1964 printk(KERN_ERR "ippp_bundle: cannot find %s\n", ifn);
1968 spin_lock_irqsave(&p->pb->lock, flags);
1972 if (nlp->ppp_slot < 0 || nlp->ppp_slot >= ISDN_MAX_CHANNELS ||
1973 lp->ppp_slot < 0 || lp->ppp_slot >= ISDN_MAX_CHANNELS) {
1974 printk(KERN_ERR "ippp_bundle: binding to invalid slot %d\n",
1975 nlp->ppp_slot < 0 || nlp->ppp_slot >= ISDN_MAX_CHANNELS ?
1976 nlp->ppp_slot : lp->ppp_slot);
1981 isdn_net_add_to_bundle(p, nlp);
1983 ippp_table[nlp->ppp_slot]->unit = ippp_table[lp->ppp_slot]->unit;
1985 /* maybe also SC_CCP stuff */
1986 ippp_table[nlp->ppp_slot]->pppcfg |= ippp_table[lp->ppp_slot]->pppcfg &
1987 (SC_ENABLE_IP | SC_NO_TCP_CCID | SC_REJ_COMP_TCP);
1988 ippp_table[nlp->ppp_slot]->mpppcfg |= ippp_table[lp->ppp_slot]->mpppcfg &
1989 (SC_MP_PROT | SC_REJ_MP_PROT | SC_OUT_SHORT_SEQ | SC_IN_SHORT_SEQ);
1990 rc = isdn_ppp_mp_init(nlp, p->pb);
1992 spin_unlock_irqrestore(&p->pb->lock, flags);
1996 #endif /* CONFIG_ISDN_MPP */
1999 * network device ioctl handlers
2003 isdn_ppp_dev_ioctl_stats(int slot, struct ifreq *ifr, struct net_device *dev)
2005 struct ppp_stats __user *res = ifr->ifr_data;
2007 isdn_net_local *lp = netdev_priv(dev);
2009 if (!access_ok(VERIFY_WRITE, res, sizeof(struct ppp_stats)))
2012 /* build a temporary stat struct and copy it to user space */
2014 memset(&t, 0, sizeof(struct ppp_stats));
2015 if (dev->flags & IFF_UP) {
2016 t.p.ppp_ipackets = lp->stats.rx_packets;
2017 t.p.ppp_ibytes = lp->stats.rx_bytes;
2018 t.p.ppp_ierrors = lp->stats.rx_errors;
2019 t.p.ppp_opackets = lp->stats.tx_packets;
2020 t.p.ppp_obytes = lp->stats.tx_bytes;
2021 t.p.ppp_oerrors = lp->stats.tx_errors;
2022 #ifdef CONFIG_ISDN_PPP_VJ
2023 if (slot >= 0 && ippp_table[slot]->slcomp) {
2024 struct slcompress *slcomp = ippp_table[slot]->slcomp;
2025 t.vj.vjs_packets = slcomp->sls_o_compressed + slcomp->sls_o_uncompressed;
2026 t.vj.vjs_compressed = slcomp->sls_o_compressed;
2027 t.vj.vjs_searches = slcomp->sls_o_searches;
2028 t.vj.vjs_misses = slcomp->sls_o_misses;
2029 t.vj.vjs_errorin = slcomp->sls_i_error;
2030 t.vj.vjs_tossed = slcomp->sls_i_tossed;
2031 t.vj.vjs_uncompressedin = slcomp->sls_i_uncompressed;
2032 t.vj.vjs_compressedin = slcomp->sls_i_compressed;
2036 if (copy_to_user(res, &t, sizeof(struct ppp_stats)))
2042 isdn_ppp_dev_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
2046 isdn_net_local *lp = netdev_priv(dev);
2049 if (lp->p_encap != ISDN_NET_ENCAP_SYNCPPP)
2053 #define PPP_VERSION "2.3.7"
2055 len = strlen(PPP_VERSION) + 1;
2056 if (copy_to_user(ifr->ifr_data, PPP_VERSION, len))
2061 error = isdn_ppp_dev_ioctl_stats(lp->ppp_slot, ifr, dev);
2071 isdn_ppp_if_get_unit(char *name)
2080 if (strncmp("ippp", name, 4) || len > 8)
2083 for (i = 0, deci = 1; i < len; i++, deci *= 10) {
2084 char a = name[len - i - 1];
2085 if (a >= '0' && a <= '9')
2086 unit += (a - '0') * deci;
2090 if (!i || len - i != 4)
2098 isdn_ppp_dial_slave(char *name)
2100 #ifdef CONFIG_ISDN_MPP
2103 struct net_device *sdev;
2105 if (!(ndev = isdn_net_findif(name)))
2108 if (!(lp->flags & ISDN_NET_CONNECTED))
2113 isdn_net_local *mlp = netdev_priv(sdev);
2114 if (!(mlp->flags & ISDN_NET_CONNECTED))
2121 isdn_net_dial_req(netdev_priv(sdev));
2129 isdn_ppp_hangup_slave(char *name)
2131 #ifdef CONFIG_ISDN_MPP
2134 struct net_device *sdev;
2136 if (!(ndev = isdn_net_findif(name)))
2139 if (!(lp->flags & ISDN_NET_CONNECTED))
2144 isdn_net_local *mlp = netdev_priv(sdev);
2146 if (mlp->slave) { /* find last connected link in chain */
2147 isdn_net_local *nlp = ISDN_SLAVE_PRIV(mlp);
2149 if (!(nlp->flags & ISDN_NET_CONNECTED))
2151 } else if (mlp->flags & ISDN_NET_CONNECTED)
2159 isdn_net_hangup(sdev);
2167 * PPP compression stuff
2171 /* Push an empty CCP Data Frame up to the daemon to wake it up and let it
2172 generate a CCP Reset-Request or tear down CCP altogether */
2174 static void isdn_ppp_ccp_kickup(struct ippp_struct *is)
2176 isdn_ppp_fill_rq(NULL, 0, PPP_COMP, is->lp->ppp_slot);
2179 /* In-kernel handling of CCP Reset-Request and Reset-Ack is necessary,
2180 but absolutely nontrivial. The most abstruse problem we are facing is
2181 that the generation, reception and all the handling of timeouts and
2182 resends including proper request id management should be entirely left
2183 to the (de)compressor, but indeed is not covered by the current API to
2184 the (de)compressor. The API is a prototype version from PPP where only
2185 some (de)compressors have yet been implemented and all of them are
2186 rather simple in their reset handling. Especially, their is only one
2187 outstanding ResetAck at a time with all of them and ResetReq/-Acks do
2188 not have parameters. For this very special case it was sufficient to
2189 just return an error code from the decompressor and have a single
2190 reset() entry to communicate all the necessary information between
2191 the framework and the (de)compressor. Bad enough, LZS is different
2192 (and any other compressor may be different, too). It has multiple
2193 histories (eventually) and needs to Reset each of them independently
2194 and thus uses multiple outstanding Acks and history numbers as an
2195 additional parameter to Reqs/Acks.
2196 All that makes it harder to port the reset state engine into the
2197 kernel because it is not just the same simple one as in (i)pppd but
2198 it must be able to pass additional parameters and have multiple out-
2199 standing Acks. We are trying to achieve the impossible by handling
2200 reset transactions independent by their id. The id MUST change when
2201 the data portion changes, thus any (de)compressor who uses more than
2202 one resettable state must provide and recognize individual ids for
2203 each individual reset transaction. The framework itself does _only_
2204 differentiate them by id, because it has no other semantics like the
2205 (de)compressor might.
2206 This looks like a major redesign of the interface would be nice,
2207 but I don't have an idea how to do it better. */
2209 /* Send a CCP Reset-Request or Reset-Ack directly from the kernel. This is
2210 getting that lengthy because there is no simple "send-this-frame-out"
2211 function above but every wrapper does a bit different. Hope I guess
2212 correct in this hack... */
2214 static void isdn_ppp_ccp_xmit_reset(struct ippp_struct *is, int proto,
2215 unsigned char code, unsigned char id,
2216 unsigned char *data, int len)
2218 struct sk_buff *skb;
2222 isdn_net_local *lp = is->lp;
2224 /* Alloc large enough skb */
2225 hl = dev->drv[lp->isdn_device]->interface->hl_hdrlen;
2226 skb = alloc_skb(len + hl + 16, GFP_ATOMIC);
2229 "ippp: CCP cannot send reset - out of memory\n");
2232 skb_reserve(skb, hl);
2234 /* We may need to stuff an address and control field first */
2235 if (!(is->pppcfg & SC_COMP_AC)) {
2236 p = skb_put(skb, 2);
2241 /* Stuff proto, code, id and length */
2242 p = skb_put(skb, 6);
2243 *p++ = (proto >> 8);
2244 *p++ = (proto & 0xff);
2249 *p++ = (cnt & 0xff);
2251 /* Now stuff remaining bytes */
2253 p = skb_put(skb, len);
2254 memcpy(p, data, len);
2257 /* skb is now ready for xmit */
2258 printk(KERN_DEBUG "Sending CCP Frame:\n");
2259 isdn_ppp_frame_log("ccp-xmit", skb->data, skb->len, 32, is->unit, lp->ppp_slot);
2261 isdn_net_write_super(lp, skb);
2264 /* Allocate the reset state vector */
2265 static struct ippp_ccp_reset *isdn_ppp_ccp_reset_alloc(struct ippp_struct *is)
2267 struct ippp_ccp_reset *r;
2268 r = kzalloc(sizeof(struct ippp_ccp_reset), GFP_KERNEL);
2270 printk(KERN_ERR "ippp_ccp: failed to allocate reset data"
2271 " structure - no mem\n");
2274 printk(KERN_DEBUG "ippp_ccp: allocated reset data structure %p\n", r);
2279 /* Destroy the reset state vector. Kill all pending timers first. */
2280 static void isdn_ppp_ccp_reset_free(struct ippp_struct *is)
2284 printk(KERN_DEBUG "ippp_ccp: freeing reset data structure %p\n",
2286 for (id = 0; id < 256; id++) {
2287 if (is->reset->rs[id]) {
2288 isdn_ppp_ccp_reset_free_state(is, (unsigned char)id);
2295 /* Free a given state and clear everything up for later reallocation */
2296 static void isdn_ppp_ccp_reset_free_state(struct ippp_struct *is,
2299 struct ippp_ccp_reset_state *rs;
2301 if (is->reset->rs[id]) {
2302 printk(KERN_DEBUG "ippp_ccp: freeing state for id %d\n", id);
2303 rs = is->reset->rs[id];
2304 /* Make sure the kernel will not call back later */
2306 del_timer(&rs->timer);
2307 is->reset->rs[id] = NULL;
2310 printk(KERN_WARNING "ippp_ccp: id %d is not allocated\n", id);
2314 /* The timer callback function which is called when a ResetReq has timed out,
2315 aka has never been answered by a ResetAck */
2316 static void isdn_ppp_ccp_timer_callback(unsigned long closure)
2318 struct ippp_ccp_reset_state *rs =
2319 (struct ippp_ccp_reset_state *)closure;
2322 printk(KERN_ERR "ippp_ccp: timer cb with zero closure.\n");
2325 if (rs->ta && rs->state == CCPResetSentReq) {
2326 /* We are correct here */
2328 /* Hmm, there is no Ack really expected. We can clean
2329 up the state now, it will be reallocated if the
2330 decompressor insists on another reset */
2332 isdn_ppp_ccp_reset_free_state(rs->is, rs->id);
2335 printk(KERN_DEBUG "ippp_ccp: CCP Reset timed out for id %d\n",
2338 isdn_ppp_ccp_xmit_reset(rs->is, PPP_CCP, CCP_RESETREQ, rs->id,
2339 rs->data, rs->dlen);
2341 rs->timer.expires = jiffies + HZ * 5;
2342 add_timer(&rs->timer);
2344 printk(KERN_WARNING "ippp_ccp: timer cb in wrong state %d\n",
2349 /* Allocate a new reset transaction state */
2350 static struct ippp_ccp_reset_state *isdn_ppp_ccp_reset_alloc_state(struct ippp_struct *is,
2353 struct ippp_ccp_reset_state *rs;
2354 if (is->reset->rs[id]) {
2355 printk(KERN_WARNING "ippp_ccp: old state exists for id %d\n",
2359 rs = kzalloc(sizeof(struct ippp_ccp_reset_state), GFP_KERNEL);
2362 rs->state = CCPResetIdle;
2365 init_timer(&rs->timer);
2366 rs->timer.data = (unsigned long)rs;
2367 rs->timer.function = isdn_ppp_ccp_timer_callback;
2368 is->reset->rs[id] = rs;
2374 /* A decompressor wants a reset with a set of parameters - do what is
2375 necessary to fulfill it */
2376 static void isdn_ppp_ccp_reset_trans(struct ippp_struct *is,
2377 struct isdn_ppp_resetparams *rp)
2379 struct ippp_ccp_reset_state *rs;
2382 /* The decompressor defines parameters by itself */
2384 /* And he wants us to send a request */
2386 printk(KERN_ERR "ippp_ccp: decompressor must"
2387 " specify reset id\n");
2390 if (is->reset->rs[rp->id]) {
2391 /* There is already a transaction in existence
2392 for this id. May be still waiting for a
2393 Ack or may be wrong. */
2394 rs = is->reset->rs[rp->id];
2395 if (rs->state == CCPResetSentReq && rs->ta) {
2396 printk(KERN_DEBUG "ippp_ccp: reset"
2397 " trans still in progress"
2398 " for id %d\n", rp->id);
2400 printk(KERN_WARNING "ippp_ccp: reset"
2401 " trans in wrong state %d for"
2402 " id %d\n", rs->state, rp->id);
2405 /* Ok, this is a new transaction */
2406 printk(KERN_DEBUG "ippp_ccp: new trans for id"
2407 " %d to be started\n", rp->id);
2408 rs = isdn_ppp_ccp_reset_alloc_state(is, rp->id);
2410 printk(KERN_ERR "ippp_ccp: out of mem"
2411 " allocing ccp trans\n");
2414 rs->state = CCPResetSentReq;
2415 rs->expra = rp->expra;
2417 rs->dlen = rp->dlen;
2418 memcpy(rs->data, rp->data, rp->dlen);
2420 /* HACK TODO - add link comp here */
2421 isdn_ppp_ccp_xmit_reset(is, PPP_CCP,
2422 CCP_RESETREQ, rs->id,
2423 rs->data, rs->dlen);
2424 /* Start the timer */
2425 rs->timer.expires = jiffies + 5 * HZ;
2426 add_timer(&rs->timer);
2430 printk(KERN_DEBUG "ippp_ccp: no reset sent\n");
2433 /* The reset params are invalid. The decompressor does not
2434 care about them, so we just send the minimal requests
2435 and increase ids only when an Ack is received for a
2437 if (is->reset->rs[is->reset->lastid]) {
2438 /* There is already a transaction in existence
2439 for this id. May be still waiting for a
2440 Ack or may be wrong. */
2441 rs = is->reset->rs[is->reset->lastid];
2442 if (rs->state == CCPResetSentReq && rs->ta) {
2443 printk(KERN_DEBUG "ippp_ccp: reset"
2444 " trans still in progress"
2445 " for id %d\n", rp->id);
2447 printk(KERN_WARNING "ippp_ccp: reset"
2448 " trans in wrong state %d for"
2449 " id %d\n", rs->state, rp->id);
2452 printk(KERN_DEBUG "ippp_ccp: new trans for id"
2453 " %d to be started\n", is->reset->lastid);
2454 rs = isdn_ppp_ccp_reset_alloc_state(is,
2457 printk(KERN_ERR "ippp_ccp: out of mem"
2458 " allocing ccp trans\n");
2461 rs->state = CCPResetSentReq;
2462 /* We always expect an Ack if the decompressor doesn't
2466 /* HACK TODO - add link comp here */
2467 isdn_ppp_ccp_xmit_reset(is, PPP_CCP, CCP_RESETREQ,
2469 /* Start the timer */
2470 rs->timer.expires = jiffies + 5 * HZ;
2471 add_timer(&rs->timer);
2477 /* An Ack was received for this id. This means we stop the timer and clean
2478 up the state prior to calling the decompressors reset routine. */
2479 static void isdn_ppp_ccp_reset_ack_rcvd(struct ippp_struct *is,
2482 struct ippp_ccp_reset_state *rs = is->reset->rs[id];
2485 if (rs->ta && rs->state == CCPResetSentReq) {
2486 /* Great, we are correct */
2488 printk(KERN_DEBUG "ippp_ccp: ResetAck received"
2489 " for id %d but not expected\n", id);
2491 printk(KERN_INFO "ippp_ccp: ResetAck received out of"
2492 "sync for id %d\n", id);
2496 del_timer(&rs->timer);
2498 isdn_ppp_ccp_reset_free_state(is, id);
2500 printk(KERN_INFO "ippp_ccp: ResetAck received for unknown id"
2503 /* Make sure the simple reset stuff uses a new id next time */
2504 is->reset->lastid++;
2510 * if master = 0, we're trying to uncompress an per-link compressed packet,
2511 * as opposed to an compressed reconstructed-from-MPPP packet.
2512 * proto is updated to protocol field of uncompressed packet.
2514 * retval: decompressed packet,
2515 * same packet if uncompressed,
2516 * NULL if decompression error
2519 static struct sk_buff *isdn_ppp_decompress(struct sk_buff *skb, struct ippp_struct *is, struct ippp_struct *master,
2523 struct isdn_ppp_compressor *ipc = NULL;
2524 struct sk_buff *skb_out;
2526 struct ippp_struct *ri;
2527 struct isdn_ppp_resetparams rsparm;
2528 unsigned char rsdata[IPPP_RESET_MAXDATABYTES];
2531 // per-link decompression
2532 stat = is->link_decomp_stat;
2533 ipc = is->link_decompressor;
2536 stat = master->decomp_stat;
2537 ipc = master->decompressor;
2542 // no decompressor -> we can't decompress.
2543 printk(KERN_DEBUG "ippp: no decompressor defined!\n");
2546 BUG_ON(!stat); // if we have a compressor, stat has been set as well
2548 if ((master && *proto == PPP_COMP) || (!master && *proto == PPP_COMPFRAG)) {
2549 // compressed packets are compressed by their protocol type
2551 // Set up reset params for the decompressor
2552 memset(&rsparm, 0, sizeof(rsparm));
2553 rsparm.data = rsdata;
2554 rsparm.maxdlen = IPPP_RESET_MAXDATABYTES;
2556 skb_out = dev_alloc_skb(is->mru + PPP_HDRLEN);
2559 printk(KERN_ERR "ippp: decomp memory allocation failure\n");
2562 len = ipc->decompress(stat, skb, skb_out, &rsparm);
2567 printk(KERN_INFO "ippp: decomp wants reset %s params\n",
2568 rsparm.valid ? "with" : "without");
2570 isdn_ppp_ccp_reset_trans(ri, &rsparm);
2572 case DECOMP_FATALERROR:
2573 ri->pppcfg |= SC_DC_FERROR;
2574 /* Kick ipppd to recognize the error */
2575 isdn_ppp_ccp_kickup(ri);
2581 *proto = isdn_ppp_strip_proto(skb_out);
2588 // uncompressed packets are fed through the decompressor to
2589 // update the decompressor state
2590 ipc->incomp(stat, skb, *proto);
2597 * type=0: normal/bundle compression
2598 * =1: link compression
2599 * returns original skb if we haven't compressed the frame
2600 * and a new skb pointer if we've done it
2602 static struct sk_buff *isdn_ppp_compress(struct sk_buff *skb_in, int *proto,
2603 struct ippp_struct *is, struct ippp_struct *master, int type)
2607 struct isdn_ppp_compressor *compressor;
2609 struct sk_buff *skb_out;
2611 /* we do not compress control protocols */
2612 if (*proto < 0 || *proto > 0x3fff) {
2616 if (type) { /* type=1 => Link compression */
2621 compressor = is->compressor;
2622 stat = is->comp_stat;
2625 compressor = master->compressor;
2626 stat = master->comp_stat;
2628 new_proto = PPP_COMP;
2632 printk(KERN_ERR "isdn_ppp: No compressor set!\n");
2636 printk(KERN_ERR "isdn_ppp: Compressor not initialized?\n");
2640 /* Allow for at least 150 % expansion (for now) */
2641 skb_out = alloc_skb(skb_in->len + skb_in->len / 2 + 32 +
2642 skb_headroom(skb_in), GFP_ATOMIC);
2645 skb_reserve(skb_out, skb_headroom(skb_in));
2647 ret = (compressor->compress)(stat, skb_in, skb_out, *proto);
2649 dev_kfree_skb(skb_out);
2653 dev_kfree_skb(skb_in);
2659 * we received a CCP frame ..
2660 * not a clean solution, but we MUST handle a few cases in the kernel
2662 static void isdn_ppp_receive_ccp(isdn_net_dev *net_dev, isdn_net_local *lp,
2663 struct sk_buff *skb, int proto)
2665 struct ippp_struct *is;
2666 struct ippp_struct *mis;
2668 struct isdn_ppp_resetparams rsparm;
2669 unsigned char rsdata[IPPP_RESET_MAXDATABYTES];
2671 printk(KERN_DEBUG "Received CCP frame from peer slot(%d)\n",
2673 if (lp->ppp_slot < 0 || lp->ppp_slot >= ISDN_MAX_CHANNELS) {
2674 printk(KERN_ERR "%s: lp->ppp_slot(%d) out of range\n",
2675 __func__, lp->ppp_slot);
2678 is = ippp_table[lp->ppp_slot];
2679 isdn_ppp_frame_log("ccp-rcv", skb->data, skb->len, 32, is->unit, lp->ppp_slot);
2682 int slot = ISDN_MASTER_PRIV(lp)->ppp_slot;
2683 if (slot < 0 || slot >= ISDN_MAX_CHANNELS) {
2684 printk(KERN_ERR "%s: slot(%d) out of range\n",
2688 mis = ippp_table[slot];
2692 switch (skb->data[0]) {
2694 if (is->debug & 0x10)
2695 printk(KERN_DEBUG "Disable compression here!\n");
2696 if (proto == PPP_CCP)
2697 mis->compflags &= ~SC_COMP_ON;
2699 is->compflags &= ~SC_LINK_COMP_ON;
2703 if (is->debug & 0x10)
2704 printk(KERN_DEBUG "Disable (de)compression here!\n");
2705 if (proto == PPP_CCP)
2706 mis->compflags &= ~(SC_DECOMP_ON | SC_COMP_ON);
2708 is->compflags &= ~(SC_LINK_DECOMP_ON | SC_LINK_COMP_ON);
2711 /* if we RECEIVE an ackowledge we enable the decompressor */
2712 if (is->debug & 0x10)
2713 printk(KERN_DEBUG "Enable decompression here!\n");
2714 if (proto == PPP_CCP) {
2715 if (!mis->decompressor)
2717 mis->compflags |= SC_DECOMP_ON;
2719 if (!is->decompressor)
2721 is->compflags |= SC_LINK_DECOMP_ON;
2726 printk(KERN_DEBUG "Received ResetAck from peer\n");
2727 len = (skb->data[2] << 8) | skb->data[3];
2730 if (proto == PPP_CCP) {
2731 /* If a reset Ack was outstanding for this id, then
2732 clean up the state engine */
2733 isdn_ppp_ccp_reset_ack_rcvd(mis, skb->data[1]);
2734 if (mis->decompressor && mis->decomp_stat)
2736 reset(mis->decomp_stat,
2739 len ? &skb->data[4] : NULL,
2741 /* TODO: This is not easy to decide here */
2742 mis->compflags &= ~SC_DECOMP_DISCARD;
2745 isdn_ppp_ccp_reset_ack_rcvd(is, skb->data[1]);
2746 if (is->link_decompressor && is->link_decomp_stat)
2747 is->link_decompressor->
2748 reset(is->link_decomp_stat,
2751 len ? &skb->data[4] : NULL,
2753 /* TODO: neither here */
2754 is->compflags &= ~SC_LINK_DECOMP_DISCARD;
2759 printk(KERN_DEBUG "Received ResetReq from peer\n");
2760 /* Receiving a ResetReq means we must reset our compressor */
2761 /* Set up reset params for the reset entry */
2762 memset(&rsparm, 0, sizeof(rsparm));
2763 rsparm.data = rsdata;
2764 rsparm.maxdlen = IPPP_RESET_MAXDATABYTES;
2765 /* Isolate data length */
2766 len = (skb->data[2] << 8) | skb->data[3];
2768 if (proto == PPP_CCP) {
2769 if (mis->compressor && mis->comp_stat)
2771 reset(mis->comp_stat,
2774 len ? &skb->data[4] : NULL,
2778 if (is->link_compressor && is->link_comp_stat)
2779 is->link_compressor->
2780 reset(is->link_comp_stat,
2783 len ? &skb->data[4] : NULL,
2786 /* Ack the Req as specified by rsparm */
2788 /* Compressor reset handler decided how to answer */
2790 /* We should send a Frame */
2791 isdn_ppp_ccp_xmit_reset(is, proto, CCP_RESETACK,
2792 rsparm.idval ? rsparm.id
2799 printk(KERN_DEBUG "ResetAck suppressed\n");
2802 /* We answer with a straight reflected Ack */
2803 isdn_ppp_ccp_xmit_reset(is, proto, CCP_RESETACK,
2805 len ? &skb->data[4] : NULL,
2814 * Daemon sends a CCP frame ...
2817 /* TODO: Clean this up with new Reset semantics */
2819 /* I believe the CCP handling as-is is done wrong. Compressed frames
2820 * should only be sent/received after CCP reaches UP state, which means
2821 * both sides have sent CONF_ACK. Currently, we handle both directions
2822 * independently, which means we may accept compressed frames too early
2823 * (supposedly not a problem), but may also mean we send compressed frames
2824 * too early, which may turn out to be a problem.
2825 * This part of state machine should actually be handled by (i)pppd, but
2826 * that's too big of a change now. --kai
2829 /* Actually, we might turn this into an advantage: deal with the RFC in
2830 * the old tradition of beeing generous on what we accept, but beeing
2831 * strict on what we send. Thus we should just
2832 * - accept compressed frames as soon as decompression is negotiated
2833 * - send compressed frames only when decomp *and* comp are negotiated
2834 * - drop rx compressed frames if we cannot decomp (instead of pushing them
2836 * and I tried to modify this file according to that. --abp
2839 static void isdn_ppp_send_ccp(isdn_net_dev *net_dev, isdn_net_local *lp, struct sk_buff *skb)
2841 struct ippp_struct *mis, *is;
2842 int proto, slot = lp->ppp_slot;
2843 unsigned char *data;
2845 if (!skb || skb->len < 3)
2847 if (slot < 0 || slot >= ISDN_MAX_CHANNELS) {
2848 printk(KERN_ERR "%s: lp->ppp_slot(%d) out of range\n",
2852 is = ippp_table[slot];
2853 /* Daemon may send with or without address and control field comp */
2855 if (!(is->pppcfg & SC_COMP_AC) && data[0] == 0xff && data[1] == 0x03) {
2861 proto = ((int)data[0]<<8) + data[1];
2862 if (proto != PPP_CCP && proto != PPP_CCPFRAG)
2865 printk(KERN_DEBUG "Received CCP frame from daemon:\n");
2866 isdn_ppp_frame_log("ccp-xmit", skb->data, skb->len, 32, is->unit, lp->ppp_slot);
2869 slot = ISDN_MASTER_PRIV(lp)->ppp_slot;
2870 if (slot < 0 || slot >= ISDN_MAX_CHANNELS) {
2871 printk(KERN_ERR "%s: slot(%d) out of range\n",
2875 mis = ippp_table[slot];
2879 printk(KERN_DEBUG "isdn_ppp: Ouch! Master CCP sends on slave slot!\n");
2883 if (is->debug & 0x10)
2884 printk(KERN_DEBUG "Disable decompression here!\n");
2885 if (proto == PPP_CCP)
2886 is->compflags &= ~SC_DECOMP_ON;
2888 is->compflags &= ~SC_LINK_DECOMP_ON;
2892 if (is->debug & 0x10)
2893 printk(KERN_DEBUG "Disable (de)compression here!\n");
2894 if (proto == PPP_CCP)
2895 is->compflags &= ~(SC_DECOMP_ON | SC_COMP_ON);
2897 is->compflags &= ~(SC_LINK_DECOMP_ON | SC_LINK_COMP_ON);
2900 /* if we SEND an ackowledge we can/must enable the compressor */
2901 if (is->debug & 0x10)
2902 printk(KERN_DEBUG "Enable compression here!\n");
2903 if (proto == PPP_CCP) {
2904 if (!is->compressor)
2906 is->compflags |= SC_COMP_ON;
2908 if (!is->compressor)
2910 is->compflags |= SC_LINK_COMP_ON;
2914 /* If we send a ACK we should reset our compressor */
2915 if (is->debug & 0x10)
2916 printk(KERN_DEBUG "Reset decompression state here!\n");
2917 printk(KERN_DEBUG "ResetAck from daemon passed by\n");
2918 if (proto == PPP_CCP) {
2919 /* link to master? */
2920 if (is->compressor && is->comp_stat)
2921 is->compressor->reset(is->comp_stat, 0, 0,
2923 is->compflags &= ~SC_COMP_DISCARD;
2926 if (is->link_compressor && is->link_comp_stat)
2927 is->link_compressor->reset(is->link_comp_stat,
2928 0, 0, NULL, 0, NULL);
2929 is->compflags &= ~SC_LINK_COMP_DISCARD;
2933 /* Just let it pass by */
2934 printk(KERN_DEBUG "ResetReq from daemon passed by\n");
2939 int isdn_ppp_register_compressor(struct isdn_ppp_compressor *ipc)
2941 ipc->next = ipc_head;
2944 ipc_head->prev = ipc;
2950 int isdn_ppp_unregister_compressor(struct isdn_ppp_compressor *ipc)
2953 ipc->prev->next = ipc->next;
2955 ipc_head = ipc->next;
2957 ipc->next->prev = ipc->prev;
2958 ipc->prev = ipc->next = NULL;
2962 static int isdn_ppp_set_compressor(struct ippp_struct *is, struct isdn_ppp_comp_data *data)
2964 struct isdn_ppp_compressor *ipc = ipc_head;
2967 int num = data->num;
2969 if (is->debug & 0x10)
2970 printk(KERN_DEBUG "[%d] Set %s type %d\n", is->unit,
2971 (data->flags & IPPP_COMP_FLAG_XMIT) ? "compressor" : "decompressor", num);
2973 /* If is has no valid reset state vector, we cannot allocate a
2974 decompressor. The decompressor would cause reset transactions
2975 sooner or later, and they need that vector. */
2977 if (!(data->flags & IPPP_COMP_FLAG_XMIT) && !is->reset) {
2978 printk(KERN_ERR "ippp_ccp: no reset data structure - can't"
2979 " allow decompression.\n");
2984 if (ipc->num == num) {
2985 stat = ipc->alloc(data);
2987 ret = ipc->init(stat, data, is->unit, 0);
2989 printk(KERN_ERR "Can't init (de)compression!\n");
2996 printk(KERN_ERR "Can't alloc (de)compression!\n");
3000 if (data->flags & IPPP_COMP_FLAG_XMIT) {
3001 if (data->flags & IPPP_COMP_FLAG_LINK) {
3002 if (is->link_comp_stat)
3003 is->link_compressor->free(is->link_comp_stat);
3004 is->link_comp_stat = stat;
3005 is->link_compressor = ipc;
3009 is->compressor->free(is->comp_stat);
3010 is->comp_stat = stat;
3011 is->compressor = ipc;
3015 if (data->flags & IPPP_COMP_FLAG_LINK) {
3016 if (is->link_decomp_stat)
3017 is->link_decompressor->free(is->link_decomp_stat);
3018 is->link_decomp_stat = stat;
3019 is->link_decompressor = ipc;
3022 if (is->decomp_stat)
3023 is->decompressor->free(is->decomp_stat);
3024 is->decomp_stat = stat;
3025 is->decompressor = ipc;