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);
464 #endif /* CONFIG_IPPP_FILTER */
470 isdn_ppp_ioctl(int min, struct file *file, unsigned int cmd, unsigned long arg)
474 struct ippp_struct *is;
476 struct isdn_ppp_comp_data data;
477 void __user *argp = (void __user *)arg;
479 is = file->private_data;
483 printk(KERN_DEBUG "isdn_ppp_ioctl: minor: %d cmd: %x state: %x\n", min, cmd, is->state);
485 if (!(is->state & IPPP_OPEN))
490 #ifdef CONFIG_ISDN_MPP
491 if (!(is->state & IPPP_CONNECT))
493 if ((r = get_arg(argp, &val, sizeof(val))))
495 printk(KERN_DEBUG "iPPP-bundle: minor: %d, slave unit: %d, master unit: %d\n",
496 (int) min, (int) is->unit, (int) val);
497 return isdn_ppp_bundle(is, val);
502 case PPPIOCGUNIT: /* get ppp/isdn unit number */
503 if ((r = set_arg(argp, &is->unit, sizeof(is->unit))))
509 if ((r = set_arg(argp, lp->netdev->dev->name,
510 strlen(lp->netdev->dev->name))))
513 case PPPIOCGMPFLAGS: /* get configuration flags */
514 if ((r = set_arg(argp, &is->mpppcfg, sizeof(is->mpppcfg))))
517 case PPPIOCSMPFLAGS: /* set configuration flags */
518 if ((r = get_arg(argp, &val, sizeof(val))))
522 case PPPIOCGFLAGS: /* get configuration flags */
523 if ((r = set_arg(argp, &is->pppcfg, sizeof(is->pppcfg))))
526 case PPPIOCSFLAGS: /* set configuration flags */
527 if ((r = get_arg(argp, &val, sizeof(val)))) {
530 if (val & SC_ENABLE_IP && !(is->pppcfg & SC_ENABLE_IP) && (is->state & IPPP_CONNECT)) {
532 /* OK .. we are ready to send buffers */
533 is->pppcfg = val; /* isdn_ppp_xmit test for SC_ENABLE_IP !!! */
534 netif_wake_queue(lp->netdev->dev);
540 case PPPIOCGIDLE: /* get idle time information */
542 struct ppp_idle pidle;
543 pidle.xmit_idle = pidle.recv_idle = lp->huptimer;
544 if ((r = set_arg(argp, &pidle, sizeof(struct ppp_idle))))
548 case PPPIOCSMRU: /* set receive unit size for PPP */
549 if ((r = get_arg(argp, &val, sizeof(val))))
557 case PPPIOCSMAXCID: /* set the maximum compression slot id */
558 if ((r = get_arg(argp, &val, sizeof(val))))
561 if (is->maxcid != val) {
562 #ifdef CONFIG_ISDN_PPP_VJ
563 struct slcompress *sltmp;
566 printk(KERN_DEBUG "ippp, ioctl: changed MAXCID to %ld\n", val);
568 #ifdef CONFIG_ISDN_PPP_VJ
569 sltmp = slhc_init(16, val);
571 printk(KERN_ERR "ippp, can't realloc slhc struct\n");
575 slhc_free(is->slcomp);
581 if ((r = set_arg(argp, &is->debug, sizeof(is->debug))))
585 if ((r = get_arg(argp, &val, sizeof(val))))
589 case PPPIOCGCOMPRESSORS:
591 unsigned long protos[8] = {0,};
592 struct isdn_ppp_compressor *ipc = ipc_head;
594 j = ipc->num / (sizeof(long) * 8);
595 i = ipc->num % (sizeof(long) * 8);
597 protos[j] |= (1UL << i);
600 if ((r = set_arg(argp, protos, 8 * sizeof(long))))
604 case PPPIOCSCOMPRESSOR:
605 if ((r = get_arg(argp, &data, sizeof(struct isdn_ppp_comp_data))))
607 return isdn_ppp_set_compressor(is, &data);
608 case PPPIOCGCALLINFO:
610 struct pppcallinfo pci;
611 memset((char *)&pci, 0, sizeof(struct pppcallinfo));
614 strncpy(pci.local_num, lp->msn, 63);
616 strncpy(pci.remote_num, lp->dial->num, 63);
618 pci.charge_units = lp->charge;
620 pci.calltype = CALLTYPE_OUTGOING;
622 pci.calltype = CALLTYPE_INCOMING;
623 if (lp->flags & ISDN_NET_CALLBACK)
624 pci.calltype |= CALLTYPE_CALLBACK;
626 return set_arg(argp, &pci, sizeof(struct pppcallinfo));
628 #ifdef CONFIG_IPPP_FILTER
631 struct sock_fprog_kern fprog;
632 struct sock_filter *code;
633 int err, len = get_filter(argp, &code);
642 sk_unattached_filter_destroy(is->pass_filter);
643 err = sk_unattached_filter_create(&is->pass_filter, &fprog);
650 struct sock_fprog_kern fprog;
651 struct sock_filter *code;
652 int err, len = get_filter(argp, &code);
660 if (is->active_filter)
661 sk_unattached_filter_destroy(is->active_filter);
662 err = sk_unattached_filter_create(&is->active_filter, &fprog);
667 #endif /* CONFIG_IPPP_FILTER */
675 isdn_ppp_poll(struct file *file, poll_table *wait)
678 struct ippp_buf_queue *bf, *bl;
680 struct ippp_struct *is;
682 is = file->private_data;
685 printk(KERN_DEBUG "isdn_ppp_poll: minor: %d\n",
686 iminor(file_inode(file)));
688 /* just registers wait_queue hook. This doesn't really wait. */
689 poll_wait(file, &is->wq, wait);
691 if (!(is->state & IPPP_OPEN)) {
692 if (is->state == IPPP_CLOSEWAIT)
694 printk(KERN_DEBUG "isdn_ppp: device not open\n");
697 /* we're always ready to send .. */
698 mask = POLLOUT | POLLWRNORM;
700 spin_lock_irqsave(&is->buflock, flags);
704 * if IPPP_NOBLOCK is set we return even if we have nothing to read
706 if (bf->next != bl || (is->state & IPPP_NOBLOCK)) {
707 is->state &= ~IPPP_NOBLOCK;
708 mask |= POLLIN | POLLRDNORM;
710 spin_unlock_irqrestore(&is->buflock, flags);
715 * fill up isdn_ppp_read() queue ..
719 isdn_ppp_fill_rq(unsigned char *buf, int len, int proto, int slot)
721 struct ippp_buf_queue *bf, *bl;
724 struct ippp_struct *is;
726 if (slot < 0 || slot >= ISDN_MAX_CHANNELS) {
727 printk(KERN_WARNING "ippp: illegal slot(%d).\n", slot);
730 is = ippp_table[slot];
732 if (!(is->state & IPPP_CONNECT)) {
733 printk(KERN_DEBUG "ippp: device not activated.\n");
736 nbuf = kmalloc(len + 4, GFP_ATOMIC);
738 printk(KERN_WARNING "ippp: Can't alloc buf\n");
741 nbuf[0] = PPP_ALLSTATIONS;
743 nbuf[2] = proto >> 8;
744 nbuf[3] = proto & 0xff;
745 memcpy(nbuf + 4, buf, len);
747 spin_lock_irqsave(&is->buflock, flags);
752 printk(KERN_WARNING "ippp: Queue is full; discarding first buffer\n");
757 bl->buf = (char *) nbuf;
761 spin_unlock_irqrestore(&is->buflock, flags);
762 wake_up_interruptible(&is->wq);
767 * read() .. non-blocking: ipppd calls it only after select()
768 * reports, that there is data
772 isdn_ppp_read(int min, struct file *file, char __user *buf, int count)
774 struct ippp_struct *is;
775 struct ippp_buf_queue *b;
779 is = file->private_data;
781 if (!(is->state & IPPP_OPEN))
784 if (!access_ok(VERIFY_WRITE, buf, count))
787 spin_lock_irqsave(&is->buflock, flags);
791 spin_unlock_irqrestore(&is->buflock, flags);
799 spin_unlock_irqrestore(&is->buflock, flags);
800 if (copy_to_user(buf, save_buf, count))
808 * ipppd wanna write a packet to the card .. non-blocking
812 isdn_ppp_write(int min, struct file *file, const char __user *buf, int count)
815 struct ippp_struct *is;
817 unsigned char protobuf[4];
819 is = file->private_data;
821 if (!(is->state & IPPP_CONNECT))
826 /* -> push it directly to the lowlevel interface */
829 printk(KERN_DEBUG "isdn_ppp_write: lp == NULL\n");
832 * Don't reset huptimer for
833 * LCP packets. (Echo requests).
835 if (copy_from_user(protobuf, buf, 4))
837 proto = PPP_PROTOCOL(protobuf);
838 if (proto != PPP_LCP)
841 if (lp->isdn_device < 0 || lp->isdn_channel < 0)
844 if ((dev->drv[lp->isdn_device]->flags & DRV_FLAG_RUNNING) &&
845 lp->dialstate == 0 &&
846 (lp->flags & ISDN_NET_CONNECTED)) {
850 * we need to reserve enough space in front of
851 * sk_buff. old call to dev_alloc_skb only reserved
852 * 16 bytes, now we are looking what the driver want
854 hl = dev->drv[lp->isdn_device]->interface->hl_hdrlen;
855 skb = alloc_skb(hl + count, GFP_ATOMIC);
857 printk(KERN_WARNING "isdn_ppp_write: out of memory!\n");
860 skb_reserve(skb, hl);
861 if (copy_from_user(skb_put(skb, count), buf, count))
866 if (is->debug & 0x40) {
867 printk(KERN_DEBUG "ppp xmit: len %d\n", (int) skb->len);
868 isdn_ppp_frame_log("xmit", skb->data, skb->len, 32, is->unit, lp->ppp_slot);
871 isdn_ppp_send_ccp(lp->netdev, lp, skb); /* keeps CCP/compression states in sync */
873 isdn_net_write_super(lp, skb);
880 * init memory, structures etc.
889 #ifdef CONFIG_ISDN_MPP
890 if (isdn_ppp_mp_bundle_array_init() < 0)
892 #endif /* CONFIG_ISDN_MPP */
894 for (i = 0; i < ISDN_MAX_CHANNELS; i++) {
895 if (!(ippp_table[i] = kzalloc(sizeof(struct ippp_struct), GFP_KERNEL))) {
896 printk(KERN_WARNING "isdn_ppp_init: Could not alloc ippp_table\n");
897 for (j = 0; j < i; j++)
898 kfree(ippp_table[j]);
901 spin_lock_init(&ippp_table[i]->buflock);
902 ippp_table[i]->state = 0;
903 ippp_table[i]->first = ippp_table[i]->rq + NUM_RCV_BUFFS - 1;
904 ippp_table[i]->last = ippp_table[i]->rq;
906 for (j = 0; j < NUM_RCV_BUFFS; j++) {
907 ippp_table[i]->rq[j].buf = NULL;
908 ippp_table[i]->rq[j].last = ippp_table[i]->rq +
909 (NUM_RCV_BUFFS + j - 1) % NUM_RCV_BUFFS;
910 ippp_table[i]->rq[j].next = ippp_table[i]->rq + (j + 1) % NUM_RCV_BUFFS;
917 isdn_ppp_cleanup(void)
921 for (i = 0; i < ISDN_MAX_CHANNELS; i++)
922 kfree(ippp_table[i]);
924 #ifdef CONFIG_ISDN_MPP
925 kfree(isdn_ppp_bundle_arr);
926 #endif /* CONFIG_ISDN_MPP */
931 * check for address/control field and skip if allowed
932 * retval != 0 -> discard packet silently
934 static int isdn_ppp_skip_ac(struct ippp_struct *is, struct sk_buff *skb)
939 if (skb->data[0] == 0xff) {
943 if (skb->data[1] != 0x03)
946 // skip address/control (AC) field
949 if (is->pppcfg & SC_REJ_COMP_AC)
950 // if AC compression was not negotiated, but used, discard packet
957 * get the PPP protocol header and pull skb
958 * retval < 0 -> discard packet silently
960 static int isdn_ppp_strip_proto(struct sk_buff *skb)
967 if (skb->data[0] & 0x1) {
968 // protocol field is compressed
969 proto = skb->data[0];
974 proto = ((int) skb->data[0] << 8) + skb->data[1];
982 * handler for incoming packets on a syncPPP interface
984 void isdn_ppp_receive(isdn_net_dev *net_dev, isdn_net_local *lp, struct sk_buff *skb)
986 struct ippp_struct *is;
990 BUG_ON(net_dev->local->master); // we're called with the master device always
993 if (slot < 0 || slot >= ISDN_MAX_CHANNELS) {
994 printk(KERN_ERR "isdn_ppp_receive: lp->ppp_slot(%d)\n",
999 is = ippp_table[slot];
1001 if (is->debug & 0x4) {
1002 printk(KERN_DEBUG "ippp_receive: is:%08lx lp:%08lx slot:%d unit:%d len:%d\n",
1003 (long)is, (long)lp, lp->ppp_slot, is->unit, (int)skb->len);
1004 isdn_ppp_frame_log("receive", skb->data, skb->len, 32, is->unit, lp->ppp_slot);
1007 if (isdn_ppp_skip_ac(is, skb) < 0) {
1011 proto = isdn_ppp_strip_proto(skb);
1017 #ifdef CONFIG_ISDN_MPP
1018 if (is->compflags & SC_LINK_DECOMP_ON) {
1019 skb = isdn_ppp_decompress(skb, is, NULL, &proto);
1020 if (!skb) // decompression error
1024 if (!(is->mpppcfg & SC_REJ_MP_PROT)) { // we agreed to receive MPPP
1025 if (proto == PPP_MP) {
1026 isdn_ppp_mp_receive(net_dev, lp, skb);
1031 isdn_ppp_push_higher(net_dev, lp, skb, proto);
1035 * we receive a reassembled frame, MPPP has been taken care of before.
1036 * address/control and protocol have been stripped from the skb
1037 * note: net_dev has to be master net_dev
1040 isdn_ppp_push_higher(isdn_net_dev *net_dev, isdn_net_local *lp, struct sk_buff *skb, int proto)
1042 struct net_device *dev = net_dev->dev;
1043 struct ippp_struct *is, *mis;
1044 isdn_net_local *mlp = NULL;
1047 slot = lp->ppp_slot;
1048 if (slot < 0 || slot >= ISDN_MAX_CHANNELS) {
1049 printk(KERN_ERR "isdn_ppp_push_higher: lp->ppp_slot(%d)\n",
1053 is = ippp_table[slot];
1055 if (lp->master) { // FIXME?
1056 mlp = ISDN_MASTER_PRIV(lp);
1057 slot = mlp->ppp_slot;
1058 if (slot < 0 || slot >= ISDN_MAX_CHANNELS) {
1059 printk(KERN_ERR "isdn_ppp_push_higher: master->ppp_slot(%d)\n",
1064 mis = ippp_table[slot];
1066 if (is->debug & 0x10) {
1067 printk(KERN_DEBUG "push, skb %d %04x\n", (int) skb->len, proto);
1068 isdn_ppp_frame_log("rpush", skb->data, skb->len, 32, is->unit, lp->ppp_slot);
1070 if (mis->compflags & SC_DECOMP_ON) {
1071 skb = isdn_ppp_decompress(skb, is, mis, &proto);
1072 if (!skb) // decompression error
1076 case PPP_IPX: /* untested */
1077 if (is->debug & 0x20)
1078 printk(KERN_DEBUG "isdn_ppp: IPX\n");
1079 skb->protocol = htons(ETH_P_IPX);
1082 if (is->debug & 0x20)
1083 printk(KERN_DEBUG "isdn_ppp: IP\n");
1084 skb->protocol = htons(ETH_P_IP);
1088 printk(KERN_INFO "isdn_ppp: unexpected compressed frame dropped\n");
1090 #ifdef CONFIG_ISDN_PPP_VJ
1091 case PPP_VJC_UNCOMP:
1092 if (is->debug & 0x20)
1093 printk(KERN_DEBUG "isdn_ppp: VJC_UNCOMP\n");
1094 if (net_dev->local->ppp_slot < 0) {
1095 printk(KERN_ERR "%s: net_dev->local->ppp_slot(%d) out of range\n",
1096 __func__, net_dev->local->ppp_slot);
1099 if (slhc_remember(ippp_table[net_dev->local->ppp_slot]->slcomp, skb->data, skb->len) <= 0) {
1100 printk(KERN_WARNING "isdn_ppp: received illegal VJC_UNCOMP frame!\n");
1103 skb->protocol = htons(ETH_P_IP);
1106 if (is->debug & 0x20)
1107 printk(KERN_DEBUG "isdn_ppp: VJC_COMP\n");
1109 struct sk_buff *skb_old = skb;
1111 skb = dev_alloc_skb(skb_old->len + 128);
1114 printk(KERN_WARNING "%s: Memory squeeze, dropping packet.\n", dev->name);
1118 skb_put(skb, skb_old->len + 128);
1119 skb_copy_from_linear_data(skb_old, skb->data,
1121 if (net_dev->local->ppp_slot < 0) {
1122 printk(KERN_ERR "%s: net_dev->local->ppp_slot(%d) out of range\n",
1123 __func__, net_dev->local->ppp_slot);
1126 pkt_len = slhc_uncompress(ippp_table[net_dev->local->ppp_slot]->slcomp,
1127 skb->data, skb_old->len);
1132 skb_trim(skb, pkt_len);
1133 skb->protocol = htons(ETH_P_IP);
1139 isdn_ppp_receive_ccp(net_dev, lp, skb, proto);
1140 /* Dont pop up ResetReq/Ack stuff to the daemon any
1141 longer - the job is done already */
1142 if (skb->data[0] == CCP_RESETREQ ||
1143 skb->data[0] == CCP_RESETACK)
1147 isdn_ppp_fill_rq(skb->data, skb->len, proto, lp->ppp_slot); /* push data to pppd device */
1152 #ifdef CONFIG_IPPP_FILTER
1153 /* check if the packet passes the pass and active filters
1154 * the filter instructions are constructed assuming
1155 * a four-byte PPP header on each packet (which is still present) */
1159 u_int16_t *p = (u_int16_t *) skb->data;
1161 *p = 0; /* indicate inbound */
1165 && SK_RUN_FILTER(is->pass_filter, skb) == 0) {
1166 if (is->debug & 0x2)
1167 printk(KERN_DEBUG "IPPP: inbound frame filtered.\n");
1171 if (!(is->active_filter
1172 && SK_RUN_FILTER(is->active_filter, skb) == 0)) {
1173 if (is->debug & 0x2)
1174 printk(KERN_DEBUG "IPPP: link-active filter: resetting huptimer.\n");
1180 #else /* CONFIG_IPPP_FILTER */
1184 #endif /* CONFIG_IPPP_FILTER */
1186 skb_reset_mac_header(skb);
1188 /* net_dev->local->stats.rx_packets++; done in isdn_net.c */
1192 net_dev->local->stats.rx_dropped++;
1197 * isdn_ppp_skb_push ..
1198 * checks whether we have enough space at the beginning of the skb
1199 * and allocs a new SKB if necessary
1201 static unsigned char *isdn_ppp_skb_push(struct sk_buff **skb_p, int len)
1203 struct sk_buff *skb = *skb_p;
1205 if (skb_headroom(skb) < len) {
1206 struct sk_buff *nskb = skb_realloc_headroom(skb, len);
1209 printk(KERN_ERR "isdn_ppp_skb_push: can't realloc headroom!\n");
1213 printk(KERN_DEBUG "isdn_ppp_skb_push:under %d %d\n", skb_headroom(skb), len);
1216 return skb_push(nskb, len);
1218 return skb_push(skb, len);
1222 * send ppp frame .. we expect a PIDCOMPressable proto --
1223 * (here: currently always PPP_IP,PPP_VJC_COMP,PPP_VJC_UNCOMP)
1225 * VJ compression may change skb pointer!!! .. requeue with old
1226 * skb isn't allowed!!
1230 isdn_ppp_xmit(struct sk_buff *skb, struct net_device *netdev)
1232 isdn_net_local *lp, *mlp;
1234 unsigned int proto = PPP_IP; /* 0x21 */
1235 struct ippp_struct *ipt, *ipts;
1236 int slot, retval = NETDEV_TX_OK;
1238 mlp = netdev_priv(netdev);
1239 nd = mlp->netdev; /* get master lp */
1241 slot = mlp->ppp_slot;
1242 if (slot < 0 || slot >= ISDN_MAX_CHANNELS) {
1243 printk(KERN_ERR "isdn_ppp_xmit: lp->ppp_slot(%d)\n",
1248 ipts = ippp_table[slot];
1250 if (!(ipts->pppcfg & SC_ENABLE_IP)) { /* PPP connected ? */
1251 if (ipts->debug & 0x1)
1252 printk(KERN_INFO "%s: IP frame delayed.\n", netdev->name);
1253 retval = NETDEV_TX_BUSY;
1257 switch (ntohs(skb->protocol)) {
1262 proto = PPP_IPX; /* untested */
1265 printk(KERN_ERR "isdn_ppp: skipped unsupported protocol: %#x.\n",
1271 lp = isdn_net_get_locked_lp(nd);
1273 printk(KERN_WARNING "%s: all channels busy - requeuing!\n", netdev->name);
1274 retval = NETDEV_TX_BUSY;
1277 /* we have our lp locked from now on */
1279 slot = lp->ppp_slot;
1280 if (slot < 0 || slot >= ISDN_MAX_CHANNELS) {
1281 printk(KERN_ERR "isdn_ppp_xmit: lp->ppp_slot(%d)\n",
1286 ipt = ippp_table[slot];
1289 * after this line .. requeueing in the device queue is no longer allowed!!!
1292 /* Pull off the fake header we stuck on earlier to keep
1293 * the fragmentation code happy.
1295 skb_pull(skb, IPPP_MAX_HEADER);
1297 #ifdef CONFIG_IPPP_FILTER
1298 /* check if we should pass this packet
1299 * the filter instructions are constructed assuming
1300 * a four-byte PPP header on each packet */
1301 *skb_push(skb, 4) = 1; /* indicate outbound */
1304 __be16 *p = (__be16 *)skb->data;
1310 if (ipt->pass_filter
1311 && SK_RUN_FILTER(ipt->pass_filter, skb) == 0) {
1312 if (ipt->debug & 0x4)
1313 printk(KERN_DEBUG "IPPP: outbound frame filtered.\n");
1317 if (!(ipt->active_filter
1318 && SK_RUN_FILTER(ipt->active_filter, skb) == 0)) {
1319 if (ipt->debug & 0x4)
1320 printk(KERN_DEBUG "IPPP: link-active filter: resetting huptimer.\n");
1324 #else /* CONFIG_IPPP_FILTER */
1326 #endif /* CONFIG_IPPP_FILTER */
1328 if (ipt->debug & 0x4)
1329 printk(KERN_DEBUG "xmit skb, len %d\n", (int) skb->len);
1330 if (ipts->debug & 0x40)
1331 isdn_ppp_frame_log("xmit0", skb->data, skb->len, 32, ipts->unit, lp->ppp_slot);
1333 #ifdef CONFIG_ISDN_PPP_VJ
1334 if (proto == PPP_IP && ipts->pppcfg & SC_COMP_TCP) { /* ipts here? probably yes, but check this again */
1335 struct sk_buff *new_skb;
1338 * we need to reserve enough space in front of
1339 * sk_buff. old call to dev_alloc_skb only reserved
1340 * 16 bytes, now we are looking what the driver want.
1342 hl = dev->drv[lp->isdn_device]->interface->hl_hdrlen + IPPP_MAX_HEADER;
1344 * Note: hl might still be insufficient because the method
1345 * above does not account for a possibible MPPP slave channel
1346 * which had larger HL header space requirements than the
1349 new_skb = alloc_skb(hl + skb->len, GFP_ATOMIC);
1354 skb_reserve(new_skb, hl);
1355 new_skb->dev = skb->dev;
1356 skb_put(new_skb, skb->len);
1359 pktlen = slhc_compress(ipts->slcomp, skb->data, skb->len, new_skb->data,
1360 &buf, !(ipts->pppcfg & SC_NO_TCP_CCID));
1362 if (buf != skb->data) {
1363 if (new_skb->data != buf)
1364 printk(KERN_ERR "isdn_ppp: FATAL error after slhc_compress!!\n");
1368 dev_kfree_skb(new_skb);
1371 skb_trim(skb, pktlen);
1372 if (skb->data[0] & SL_TYPE_COMPRESSED_TCP) { /* cslip? style -> PPP */
1373 proto = PPP_VJC_COMP;
1374 skb->data[0] ^= SL_TYPE_COMPRESSED_TCP;
1376 if (skb->data[0] >= SL_TYPE_UNCOMPRESSED_TCP)
1377 proto = PPP_VJC_UNCOMP;
1378 skb->data[0] = (skb->data[0] & 0x0f) | 0x40;
1385 * normal (single link) or bundle compression
1387 if (ipts->compflags & SC_COMP_ON) {
1388 /* We send compressed only if both down- und upstream
1389 compression is negotiated, that means, CCP is up */
1390 if (ipts->compflags & SC_DECOMP_ON) {
1391 skb = isdn_ppp_compress(skb, &proto, ipt, ipts, 0);
1393 printk(KERN_DEBUG "isdn_ppp: CCP not yet up - sending as-is\n");
1397 if (ipt->debug & 0x24)
1398 printk(KERN_DEBUG "xmit2 skb, len %d, proto %04x\n", (int) skb->len, proto);
1400 #ifdef CONFIG_ISDN_MPP
1401 if (ipt->mpppcfg & SC_MP_PROT) {
1402 /* we get mp_seqno from static isdn_net_local */
1403 long mp_seqno = ipts->mp_seqno;
1405 if (ipt->mpppcfg & SC_OUT_SHORT_SEQ) {
1406 unsigned char *data = isdn_ppp_skb_push(&skb, 3);
1410 data[0] = MP_BEGIN_FRAG | MP_END_FRAG | ((mp_seqno >> 8) & 0xf); /* (B)egin & (E)ndbit .. */
1411 data[1] = mp_seqno & 0xff;
1412 data[2] = proto; /* PID compression */
1414 unsigned char *data = isdn_ppp_skb_push(&skb, 5);
1417 data[0] = MP_BEGIN_FRAG | MP_END_FRAG; /* (B)egin & (E)ndbit .. */
1418 data[1] = (mp_seqno >> 16) & 0xff; /* sequence number: 24bit */
1419 data[2] = (mp_seqno >> 8) & 0xff;
1420 data[3] = (mp_seqno >> 0) & 0xff;
1421 data[4] = proto; /* PID compression */
1423 proto = PPP_MP; /* MP Protocol, 0x003d */
1428 * 'link in bundle' compression ...
1430 if (ipt->compflags & SC_LINK_COMP_ON)
1431 skb = isdn_ppp_compress(skb, &proto, ipt, ipts, 1);
1433 if ((ipt->pppcfg & SC_COMP_PROT) && (proto <= 0xff)) {
1434 unsigned char *data = isdn_ppp_skb_push(&skb, 1);
1437 data[0] = proto & 0xff;
1440 unsigned char *data = isdn_ppp_skb_push(&skb, 2);
1443 data[0] = (proto >> 8) & 0xff;
1444 data[1] = proto & 0xff;
1446 if (!(ipt->pppcfg & SC_COMP_AC)) {
1447 unsigned char *data = isdn_ppp_skb_push(&skb, 2);
1450 data[0] = 0xff; /* All Stations */
1451 data[1] = 0x03; /* Unnumbered information */
1454 /* tx-stats are now updated via BSENT-callback */
1456 if (ipts->debug & 0x40) {
1457 printk(KERN_DEBUG "skb xmit: len: %d\n", (int) skb->len);
1458 isdn_ppp_frame_log("xmit", skb->data, skb->len, 32, ipt->unit, lp->ppp_slot);
1461 isdn_net_writebuf_skb(lp, skb);
1464 spin_unlock_bh(&lp->xmit_lock);
1469 #ifdef CONFIG_IPPP_FILTER
1471 * check if this packet may trigger auto-dial.
1474 int isdn_ppp_autodial_filter(struct sk_buff *skb, isdn_net_local *lp)
1476 struct ippp_struct *is = ippp_table[lp->ppp_slot];
1480 switch (ntohs(skb->protocol)) {
1488 printk(KERN_ERR "isdn_ppp_autodial_filter: unsupported protocol 0x%x.\n",
1493 /* the filter instructions are constructed assuming
1494 * a four-byte PPP header on each packet. we have to
1495 * temporarily remove part of the fake header stuck on
1498 *skb_pull(skb, IPPP_MAX_HEADER - 4) = 1; /* indicate outbound */
1501 __be16 *p = (__be16 *)skb->data;
1507 drop |= is->pass_filter
1508 && SK_RUN_FILTER(is->pass_filter, skb) == 0;
1509 drop |= is->active_filter
1510 && SK_RUN_FILTER(is->active_filter, skb) == 0;
1512 skb_push(skb, IPPP_MAX_HEADER - 4);
1516 #ifdef CONFIG_ISDN_MPP
1518 /* this is _not_ rfc1990 header, but something we convert both short and long
1519 * headers to for convinience's sake:
1520 * byte 0 is flags as in rfc1990
1521 * bytes 1...4 is 24-bit seqence number converted to host byte order
1523 #define MP_HEADER_LEN 5
1525 #define MP_LONGSEQ_MASK 0x00ffffff
1526 #define MP_SHORTSEQ_MASK 0x00000fff
1527 #define MP_LONGSEQ_MAX MP_LONGSEQ_MASK
1528 #define MP_SHORTSEQ_MAX MP_SHORTSEQ_MASK
1529 #define MP_LONGSEQ_MAXBIT ((MP_LONGSEQ_MASK + 1) >> 1)
1530 #define MP_SHORTSEQ_MAXBIT ((MP_SHORTSEQ_MASK + 1) >> 1)
1532 /* sequence-wrap safe comparisons (for long sequence)*/
1533 #define MP_LT(a, b) ((a - b) & MP_LONGSEQ_MAXBIT)
1534 #define MP_LE(a, b) !((b - a) & MP_LONGSEQ_MAXBIT)
1535 #define MP_GT(a, b) ((b - a) & MP_LONGSEQ_MAXBIT)
1536 #define MP_GE(a, b) !((a - b) & MP_LONGSEQ_MAXBIT)
1538 #define MP_SEQ(f) ((*(u32 *)(f->data + 1)))
1539 #define MP_FLAGS(f) (f->data[0])
1541 static int isdn_ppp_mp_bundle_array_init(void)
1544 int sz = ISDN_MAX_CHANNELS * sizeof(ippp_bundle);
1545 if ((isdn_ppp_bundle_arr = kzalloc(sz, GFP_KERNEL)) == NULL)
1547 for (i = 0; i < ISDN_MAX_CHANNELS; i++)
1548 spin_lock_init(&isdn_ppp_bundle_arr[i].lock);
1552 static ippp_bundle *isdn_ppp_mp_bundle_alloc(void)
1555 for (i = 0; i < ISDN_MAX_CHANNELS; i++)
1556 if (isdn_ppp_bundle_arr[i].ref_ct <= 0)
1557 return (isdn_ppp_bundle_arr + i);
1561 static int isdn_ppp_mp_init(isdn_net_local *lp, ippp_bundle *add_to)
1563 struct ippp_struct *is;
1565 if (lp->ppp_slot < 0) {
1566 printk(KERN_ERR "%s: lp->ppp_slot(%d) out of range\n",
1567 __func__, lp->ppp_slot);
1571 is = ippp_table[lp->ppp_slot];
1574 lp->netdev->pb->ref_ct--;
1575 lp->netdev->pb = add_to;
1576 } else { /* first link in a bundle */
1578 if ((lp->netdev->pb = isdn_ppp_mp_bundle_alloc()) == NULL)
1580 lp->next = lp->last = lp; /* nobody else in a queue */
1581 lp->netdev->pb->frags = NULL;
1582 lp->netdev->pb->frames = 0;
1583 lp->netdev->pb->seq = UINT_MAX;
1585 lp->netdev->pb->ref_ct++;
1587 is->last_link_seqno = 0;
1591 static u32 isdn_ppp_mp_get_seq(int short_seq,
1592 struct sk_buff *skb, u32 last_seq);
1593 static struct sk_buff *isdn_ppp_mp_discard(ippp_bundle *mp,
1594 struct sk_buff *from, struct sk_buff *to);
1595 static void isdn_ppp_mp_reassembly(isdn_net_dev *net_dev, isdn_net_local *lp,
1596 struct sk_buff *from, struct sk_buff *to);
1597 static void isdn_ppp_mp_free_skb(ippp_bundle *mp, struct sk_buff *skb);
1598 static void isdn_ppp_mp_print_recv_pkt(int slot, struct sk_buff *skb);
1600 static void isdn_ppp_mp_receive(isdn_net_dev *net_dev, isdn_net_local *lp,
1601 struct sk_buff *skb)
1603 struct ippp_struct *is;
1604 isdn_net_local *lpq;
1606 isdn_mppp_stats *stats;
1607 struct sk_buff *newfrag, *frag, *start, *nextf;
1608 u32 newseq, minseq, thisseq;
1609 unsigned long flags;
1612 spin_lock_irqsave(&net_dev->pb->lock, flags);
1615 slot = lp->ppp_slot;
1616 if (slot < 0 || slot >= ISDN_MAX_CHANNELS) {
1617 printk(KERN_ERR "%s: lp->ppp_slot(%d)\n",
1618 __func__, lp->ppp_slot);
1619 stats->frame_drops++;
1621 spin_unlock_irqrestore(&mp->lock, flags);
1624 is = ippp_table[slot];
1625 if (++mp->frames > stats->max_queue_len)
1626 stats->max_queue_len = mp->frames;
1628 if (is->debug & 0x8)
1629 isdn_ppp_mp_print_recv_pkt(lp->ppp_slot, skb);
1631 newseq = isdn_ppp_mp_get_seq(is->mpppcfg & SC_IN_SHORT_SEQ,
1632 skb, is->last_link_seqno);
1635 /* if this packet seq # is less than last already processed one,
1636 * toss it right away, but check for sequence start case first
1638 if (mp->seq > MP_LONGSEQ_MAX && (newseq & MP_LONGSEQ_MAXBIT)) {
1639 mp->seq = newseq; /* the first packet: required for
1640 * rfc1990 non-compliant clients --
1641 * prevents constant packet toss */
1642 } else if (MP_LT(newseq, mp->seq)) {
1643 stats->frame_drops++;
1644 isdn_ppp_mp_free_skb(mp, skb);
1645 spin_unlock_irqrestore(&mp->lock, flags);
1649 /* find the minimum received sequence number over all links */
1650 is->last_link_seqno = minseq = newseq;
1651 for (lpq = net_dev->queue;;) {
1652 slot = lpq->ppp_slot;
1653 if (slot < 0 || slot >= ISDN_MAX_CHANNELS) {
1654 printk(KERN_ERR "%s: lpq->ppp_slot(%d)\n",
1655 __func__, lpq->ppp_slot);
1657 u32 lls = ippp_table[slot]->last_link_seqno;
1658 if (MP_LT(lls, minseq))
1661 if ((lpq = lpq->next) == net_dev->queue)
1664 if (MP_LT(minseq, mp->seq))
1665 minseq = mp->seq; /* can't go beyond already processed
1669 /* if this new fragment is before the first one, then enqueue it now. */
1670 if ((frag = mp->frags) == NULL || MP_LT(newseq, MP_SEQ(frag))) {
1671 newfrag->next = frag;
1672 mp->frags = frag = newfrag;
1676 start = MP_FLAGS(frag) & MP_BEGIN_FRAG &&
1677 MP_SEQ(frag) == mp->seq ? frag : NULL;
1680 * main fragment traversing loop
1682 * try to accomplish several tasks:
1683 * - insert new fragment into the proper sequence slot (once that's done
1684 * newfrag will be set to NULL)
1685 * - reassemble any complete fragment sequence (non-null 'start'
1686 * indicates there is a contiguous sequence present)
1687 * - discard any incomplete sequences that are below minseq -- due
1688 * to the fact that sender always increment sequence number, if there
1689 * is an incomplete sequence below minseq, no new fragments would
1690 * come to complete such sequence and it should be discarded
1692 * loop completes when we accomplished the following tasks:
1693 * - new fragment is inserted in the proper sequence ('newfrag' is
1695 * - we hit a gap in the sequence, so no reassembly/processing is
1696 * possible ('start' would be set to NULL)
1698 * algorithm for this code is derived from code in the book
1699 * 'PPP Design And Debugging' by James Carlson (Addison-Wesley)
1701 while (start != NULL || newfrag != NULL) {
1703 thisseq = MP_SEQ(frag);
1706 /* drop any duplicate fragments */
1707 if (newfrag != NULL && thisseq == newseq) {
1708 isdn_ppp_mp_free_skb(mp, newfrag);
1712 /* insert new fragment before next element if possible. */
1713 if (newfrag != NULL && (nextf == NULL ||
1714 MP_LT(newseq, MP_SEQ(nextf)))) {
1715 newfrag->next = nextf;
1716 frag->next = nextf = newfrag;
1720 if (start != NULL) {
1721 /* check for misplaced start */
1722 if (start != frag && (MP_FLAGS(frag) & MP_BEGIN_FRAG)) {
1723 printk(KERN_WARNING"isdn_mppp(seq %d): new "
1724 "BEGIN flag with no prior END", thisseq);
1726 stats->frame_drops++;
1727 start = isdn_ppp_mp_discard(mp, start, frag);
1730 } else if (MP_LE(thisseq, minseq)) {
1731 if (MP_FLAGS(frag) & MP_BEGIN_FRAG)
1734 if (MP_FLAGS(frag) & MP_END_FRAG)
1735 stats->frame_drops++;
1736 if (mp->frags == frag)
1738 isdn_ppp_mp_free_skb(mp, frag);
1744 /* if start is non-null and we have end fragment, then
1745 * we have full reassembly sequence -- reassemble
1746 * and process packet now
1748 if (start != NULL && (MP_FLAGS(frag) & MP_END_FRAG)) {
1749 minseq = mp->seq = (thisseq + 1) & MP_LONGSEQ_MASK;
1750 /* Reassemble the packet then dispatch it */
1751 isdn_ppp_mp_reassembly(net_dev, lp, start, nextf);
1759 /* check if need to update start pointer: if we just
1760 * reassembled the packet and sequence is contiguous
1761 * then next fragment should be the start of new reassembly
1762 * if sequence is contiguous, but we haven't reassembled yet,
1764 * if sequence is not contiguous, either clear everything
1765 * below low watermark and set start to the next frag or
1768 if (nextf != NULL &&
1769 ((thisseq + 1) & MP_LONGSEQ_MASK) == MP_SEQ(nextf)) {
1770 /* if we just reassembled and the next one is here,
1771 * then start another reassembly. */
1774 if (MP_FLAGS(nextf) & MP_BEGIN_FRAG)
1778 printk(KERN_WARNING"isdn_mppp(seq %d):"
1779 " END flag with no following "
1786 if (nextf != NULL && frag != NULL &&
1787 MP_LT(thisseq, minseq)) {
1788 /* we've got a break in the sequence
1789 * and we not at the end yet
1790 * and we did not just reassembled
1791 *(if we did, there wouldn't be anything before)
1792 * and we below the low watermark
1793 * discard all the frames below low watermark
1795 stats->frame_drops++;
1796 mp->frags = isdn_ppp_mp_discard(mp, start, nextf);
1798 /* break in the sequence, no reassembly */
1803 } /* while -- main loop */
1805 if (mp->frags == NULL)
1808 /* rather straighforward way to deal with (not very) possible
1810 if (mp->frames > MP_MAX_QUEUE_LEN) {
1812 while (mp->frames > MP_MAX_QUEUE_LEN) {
1813 frag = mp->frags->next;
1814 isdn_ppp_mp_free_skb(mp, mp->frags);
1818 spin_unlock_irqrestore(&mp->lock, flags);
1821 static void isdn_ppp_mp_cleanup(isdn_net_local *lp)
1823 struct sk_buff *frag = lp->netdev->pb->frags;
1824 struct sk_buff *nextfrag;
1826 nextfrag = frag->next;
1827 isdn_ppp_mp_free_skb(lp->netdev->pb, frag);
1830 lp->netdev->pb->frags = NULL;
1833 static u32 isdn_ppp_mp_get_seq(int short_seq,
1834 struct sk_buff *skb, u32 last_seq)
1837 int flags = skb->data[0] & (MP_BEGIN_FRAG | MP_END_FRAG);
1841 seq = ntohl(*(__be32 *)skb->data) & MP_LONGSEQ_MASK;
1846 /* convert 12-bit short seq number to 24-bit long one
1848 seq = ntohs(*(__be16 *)skb->data) & MP_SHORTSEQ_MASK;
1850 /* check for seqence wrap */
1851 if (!(seq & MP_SHORTSEQ_MAXBIT) &&
1852 (last_seq & MP_SHORTSEQ_MAXBIT) &&
1853 (unsigned long)last_seq <= MP_LONGSEQ_MAX)
1854 seq |= (last_seq + MP_SHORTSEQ_MAX + 1) &
1855 (~MP_SHORTSEQ_MASK & MP_LONGSEQ_MASK);
1857 seq |= last_seq & (~MP_SHORTSEQ_MASK & MP_LONGSEQ_MASK);
1859 skb_push(skb, 3); /* put converted seqence back in skb */
1861 *(u32 *)(skb->data + 1) = seq; /* put seqence back in _host_ byte
1863 skb->data[0] = flags; /* restore flags */
1867 struct sk_buff *isdn_ppp_mp_discard(ippp_bundle *mp,
1868 struct sk_buff *from, struct sk_buff *to)
1871 while (from != to) {
1872 struct sk_buff *next = from->next;
1873 isdn_ppp_mp_free_skb(mp, from);
1879 void isdn_ppp_mp_reassembly(isdn_net_dev *net_dev, isdn_net_local *lp,
1880 struct sk_buff *from, struct sk_buff *to)
1882 ippp_bundle *mp = net_dev->pb;
1884 struct sk_buff *skb;
1885 unsigned int tot_len;
1887 if (lp->ppp_slot < 0 || lp->ppp_slot >= ISDN_MAX_CHANNELS) {
1888 printk(KERN_ERR "%s: lp->ppp_slot(%d) out of range\n",
1889 __func__, lp->ppp_slot);
1892 if (MP_FLAGS(from) == (MP_BEGIN_FRAG | MP_END_FRAG)) {
1893 if (ippp_table[lp->ppp_slot]->debug & 0x40)
1894 printk(KERN_DEBUG "isdn_mppp: reassembly: frame %d, "
1895 "len %d\n", MP_SEQ(from), from->len);
1897 skb_pull(skb, MP_HEADER_LEN);
1900 struct sk_buff *frag;
1903 for (tot_len = n = 0, frag = from; frag != to; frag = frag->next, n++)
1904 tot_len += frag->len - MP_HEADER_LEN;
1906 if (ippp_table[lp->ppp_slot]->debug & 0x40)
1907 printk(KERN_DEBUG"isdn_mppp: reassembling frames %d "
1908 "to %d, len %d\n", MP_SEQ(from),
1909 (MP_SEQ(from) + n - 1) & MP_LONGSEQ_MASK, tot_len);
1910 if ((skb = dev_alloc_skb(tot_len)) == NULL) {
1911 printk(KERN_ERR "isdn_mppp: cannot allocate sk buff "
1912 "of size %d\n", tot_len);
1913 isdn_ppp_mp_discard(mp, from, to);
1917 while (from != to) {
1918 unsigned int len = from->len - MP_HEADER_LEN;
1920 skb_copy_from_linear_data_offset(from, MP_HEADER_LEN,
1924 isdn_ppp_mp_free_skb(mp, from);
1928 proto = isdn_ppp_strip_proto(skb);
1929 isdn_ppp_push_higher(net_dev, lp, skb, proto);
1932 static void isdn_ppp_mp_free_skb(ippp_bundle *mp, struct sk_buff *skb)
1938 static void isdn_ppp_mp_print_recv_pkt(int slot, struct sk_buff *skb)
1940 printk(KERN_DEBUG "mp_recv: %d/%d -> %02x %02x %02x %02x %02x %02x\n",
1941 slot, (int) skb->len,
1942 (int) skb->data[0], (int) skb->data[1], (int) skb->data[2],
1943 (int) skb->data[3], (int) skb->data[4], (int) skb->data[5]);
1947 isdn_ppp_bundle(struct ippp_struct *is, int unit)
1949 char ifn[IFNAMSIZ + 1];
1951 isdn_net_local *lp, *nlp;
1953 unsigned long flags;
1955 sprintf(ifn, "ippp%d", unit);
1956 p = isdn_net_findif(ifn);
1958 printk(KERN_ERR "ippp_bundle: cannot find %s\n", ifn);
1962 spin_lock_irqsave(&p->pb->lock, flags);
1966 if (nlp->ppp_slot < 0 || nlp->ppp_slot >= ISDN_MAX_CHANNELS ||
1967 lp->ppp_slot < 0 || lp->ppp_slot >= ISDN_MAX_CHANNELS) {
1968 printk(KERN_ERR "ippp_bundle: binding to invalid slot %d\n",
1969 nlp->ppp_slot < 0 || nlp->ppp_slot >= ISDN_MAX_CHANNELS ?
1970 nlp->ppp_slot : lp->ppp_slot);
1975 isdn_net_add_to_bundle(p, nlp);
1977 ippp_table[nlp->ppp_slot]->unit = ippp_table[lp->ppp_slot]->unit;
1979 /* maybe also SC_CCP stuff */
1980 ippp_table[nlp->ppp_slot]->pppcfg |= ippp_table[lp->ppp_slot]->pppcfg &
1981 (SC_ENABLE_IP | SC_NO_TCP_CCID | SC_REJ_COMP_TCP);
1982 ippp_table[nlp->ppp_slot]->mpppcfg |= ippp_table[lp->ppp_slot]->mpppcfg &
1983 (SC_MP_PROT | SC_REJ_MP_PROT | SC_OUT_SHORT_SEQ | SC_IN_SHORT_SEQ);
1984 rc = isdn_ppp_mp_init(nlp, p->pb);
1986 spin_unlock_irqrestore(&p->pb->lock, flags);
1990 #endif /* CONFIG_ISDN_MPP */
1993 * network device ioctl handlers
1997 isdn_ppp_dev_ioctl_stats(int slot, struct ifreq *ifr, struct net_device *dev)
1999 struct ppp_stats __user *res = ifr->ifr_data;
2001 isdn_net_local *lp = netdev_priv(dev);
2003 if (!access_ok(VERIFY_WRITE, res, sizeof(struct ppp_stats)))
2006 /* build a temporary stat struct and copy it to user space */
2008 memset(&t, 0, sizeof(struct ppp_stats));
2009 if (dev->flags & IFF_UP) {
2010 t.p.ppp_ipackets = lp->stats.rx_packets;
2011 t.p.ppp_ibytes = lp->stats.rx_bytes;
2012 t.p.ppp_ierrors = lp->stats.rx_errors;
2013 t.p.ppp_opackets = lp->stats.tx_packets;
2014 t.p.ppp_obytes = lp->stats.tx_bytes;
2015 t.p.ppp_oerrors = lp->stats.tx_errors;
2016 #ifdef CONFIG_ISDN_PPP_VJ
2017 if (slot >= 0 && ippp_table[slot]->slcomp) {
2018 struct slcompress *slcomp = ippp_table[slot]->slcomp;
2019 t.vj.vjs_packets = slcomp->sls_o_compressed + slcomp->sls_o_uncompressed;
2020 t.vj.vjs_compressed = slcomp->sls_o_compressed;
2021 t.vj.vjs_searches = slcomp->sls_o_searches;
2022 t.vj.vjs_misses = slcomp->sls_o_misses;
2023 t.vj.vjs_errorin = slcomp->sls_i_error;
2024 t.vj.vjs_tossed = slcomp->sls_i_tossed;
2025 t.vj.vjs_uncompressedin = slcomp->sls_i_uncompressed;
2026 t.vj.vjs_compressedin = slcomp->sls_i_compressed;
2030 if (copy_to_user(res, &t, sizeof(struct ppp_stats)))
2036 isdn_ppp_dev_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
2040 isdn_net_local *lp = netdev_priv(dev);
2043 if (lp->p_encap != ISDN_NET_ENCAP_SYNCPPP)
2047 #define PPP_VERSION "2.3.7"
2049 len = strlen(PPP_VERSION) + 1;
2050 if (copy_to_user(ifr->ifr_data, PPP_VERSION, len))
2055 error = isdn_ppp_dev_ioctl_stats(lp->ppp_slot, ifr, dev);
2065 isdn_ppp_if_get_unit(char *name)
2074 if (strncmp("ippp", name, 4) || len > 8)
2077 for (i = 0, deci = 1; i < len; i++, deci *= 10) {
2078 char a = name[len - i - 1];
2079 if (a >= '0' && a <= '9')
2080 unit += (a - '0') * deci;
2084 if (!i || len - i != 4)
2092 isdn_ppp_dial_slave(char *name)
2094 #ifdef CONFIG_ISDN_MPP
2097 struct net_device *sdev;
2099 if (!(ndev = isdn_net_findif(name)))
2102 if (!(lp->flags & ISDN_NET_CONNECTED))
2107 isdn_net_local *mlp = netdev_priv(sdev);
2108 if (!(mlp->flags & ISDN_NET_CONNECTED))
2115 isdn_net_dial_req(netdev_priv(sdev));
2123 isdn_ppp_hangup_slave(char *name)
2125 #ifdef CONFIG_ISDN_MPP
2128 struct net_device *sdev;
2130 if (!(ndev = isdn_net_findif(name)))
2133 if (!(lp->flags & ISDN_NET_CONNECTED))
2138 isdn_net_local *mlp = netdev_priv(sdev);
2140 if (mlp->slave) { /* find last connected link in chain */
2141 isdn_net_local *nlp = ISDN_SLAVE_PRIV(mlp);
2143 if (!(nlp->flags & ISDN_NET_CONNECTED))
2145 } else if (mlp->flags & ISDN_NET_CONNECTED)
2153 isdn_net_hangup(sdev);
2161 * PPP compression stuff
2165 /* Push an empty CCP Data Frame up to the daemon to wake it up and let it
2166 generate a CCP Reset-Request or tear down CCP altogether */
2168 static void isdn_ppp_ccp_kickup(struct ippp_struct *is)
2170 isdn_ppp_fill_rq(NULL, 0, PPP_COMP, is->lp->ppp_slot);
2173 /* In-kernel handling of CCP Reset-Request and Reset-Ack is necessary,
2174 but absolutely nontrivial. The most abstruse problem we are facing is
2175 that the generation, reception and all the handling of timeouts and
2176 resends including proper request id management should be entirely left
2177 to the (de)compressor, but indeed is not covered by the current API to
2178 the (de)compressor. The API is a prototype version from PPP where only
2179 some (de)compressors have yet been implemented and all of them are
2180 rather simple in their reset handling. Especially, their is only one
2181 outstanding ResetAck at a time with all of them and ResetReq/-Acks do
2182 not have parameters. For this very special case it was sufficient to
2183 just return an error code from the decompressor and have a single
2184 reset() entry to communicate all the necessary information between
2185 the framework and the (de)compressor. Bad enough, LZS is different
2186 (and any other compressor may be different, too). It has multiple
2187 histories (eventually) and needs to Reset each of them independently
2188 and thus uses multiple outstanding Acks and history numbers as an
2189 additional parameter to Reqs/Acks.
2190 All that makes it harder to port the reset state engine into the
2191 kernel because it is not just the same simple one as in (i)pppd but
2192 it must be able to pass additional parameters and have multiple out-
2193 standing Acks. We are trying to achieve the impossible by handling
2194 reset transactions independent by their id. The id MUST change when
2195 the data portion changes, thus any (de)compressor who uses more than
2196 one resettable state must provide and recognize individual ids for
2197 each individual reset transaction. The framework itself does _only_
2198 differentiate them by id, because it has no other semantics like the
2199 (de)compressor might.
2200 This looks like a major redesign of the interface would be nice,
2201 but I don't have an idea how to do it better. */
2203 /* Send a CCP Reset-Request or Reset-Ack directly from the kernel. This is
2204 getting that lengthy because there is no simple "send-this-frame-out"
2205 function above but every wrapper does a bit different. Hope I guess
2206 correct in this hack... */
2208 static void isdn_ppp_ccp_xmit_reset(struct ippp_struct *is, int proto,
2209 unsigned char code, unsigned char id,
2210 unsigned char *data, int len)
2212 struct sk_buff *skb;
2216 isdn_net_local *lp = is->lp;
2218 /* Alloc large enough skb */
2219 hl = dev->drv[lp->isdn_device]->interface->hl_hdrlen;
2220 skb = alloc_skb(len + hl + 16, GFP_ATOMIC);
2223 "ippp: CCP cannot send reset - out of memory\n");
2226 skb_reserve(skb, hl);
2228 /* We may need to stuff an address and control field first */
2229 if (!(is->pppcfg & SC_COMP_AC)) {
2230 p = skb_put(skb, 2);
2235 /* Stuff proto, code, id and length */
2236 p = skb_put(skb, 6);
2237 *p++ = (proto >> 8);
2238 *p++ = (proto & 0xff);
2243 *p++ = (cnt & 0xff);
2245 /* Now stuff remaining bytes */
2247 p = skb_put(skb, len);
2248 memcpy(p, data, len);
2251 /* skb is now ready for xmit */
2252 printk(KERN_DEBUG "Sending CCP Frame:\n");
2253 isdn_ppp_frame_log("ccp-xmit", skb->data, skb->len, 32, is->unit, lp->ppp_slot);
2255 isdn_net_write_super(lp, skb);
2258 /* Allocate the reset state vector */
2259 static struct ippp_ccp_reset *isdn_ppp_ccp_reset_alloc(struct ippp_struct *is)
2261 struct ippp_ccp_reset *r;
2262 r = kzalloc(sizeof(struct ippp_ccp_reset), GFP_KERNEL);
2264 printk(KERN_ERR "ippp_ccp: failed to allocate reset data"
2265 " structure - no mem\n");
2268 printk(KERN_DEBUG "ippp_ccp: allocated reset data structure %p\n", r);
2273 /* Destroy the reset state vector. Kill all pending timers first. */
2274 static void isdn_ppp_ccp_reset_free(struct ippp_struct *is)
2278 printk(KERN_DEBUG "ippp_ccp: freeing reset data structure %p\n",
2280 for (id = 0; id < 256; id++) {
2281 if (is->reset->rs[id]) {
2282 isdn_ppp_ccp_reset_free_state(is, (unsigned char)id);
2289 /* Free a given state and clear everything up for later reallocation */
2290 static void isdn_ppp_ccp_reset_free_state(struct ippp_struct *is,
2293 struct ippp_ccp_reset_state *rs;
2295 if (is->reset->rs[id]) {
2296 printk(KERN_DEBUG "ippp_ccp: freeing state for id %d\n", id);
2297 rs = is->reset->rs[id];
2298 /* Make sure the kernel will not call back later */
2300 del_timer(&rs->timer);
2301 is->reset->rs[id] = NULL;
2304 printk(KERN_WARNING "ippp_ccp: id %d is not allocated\n", id);
2308 /* The timer callback function which is called when a ResetReq has timed out,
2309 aka has never been answered by a ResetAck */
2310 static void isdn_ppp_ccp_timer_callback(unsigned long closure)
2312 struct ippp_ccp_reset_state *rs =
2313 (struct ippp_ccp_reset_state *)closure;
2316 printk(KERN_ERR "ippp_ccp: timer cb with zero closure.\n");
2319 if (rs->ta && rs->state == CCPResetSentReq) {
2320 /* We are correct here */
2322 /* Hmm, there is no Ack really expected. We can clean
2323 up the state now, it will be reallocated if the
2324 decompressor insists on another reset */
2326 isdn_ppp_ccp_reset_free_state(rs->is, rs->id);
2329 printk(KERN_DEBUG "ippp_ccp: CCP Reset timed out for id %d\n",
2332 isdn_ppp_ccp_xmit_reset(rs->is, PPP_CCP, CCP_RESETREQ, rs->id,
2333 rs->data, rs->dlen);
2335 rs->timer.expires = jiffies + HZ * 5;
2336 add_timer(&rs->timer);
2338 printk(KERN_WARNING "ippp_ccp: timer cb in wrong state %d\n",
2343 /* Allocate a new reset transaction state */
2344 static struct ippp_ccp_reset_state *isdn_ppp_ccp_reset_alloc_state(struct ippp_struct *is,
2347 struct ippp_ccp_reset_state *rs;
2348 if (is->reset->rs[id]) {
2349 printk(KERN_WARNING "ippp_ccp: old state exists for id %d\n",
2353 rs = kzalloc(sizeof(struct ippp_ccp_reset_state), GFP_KERNEL);
2356 rs->state = CCPResetIdle;
2359 init_timer(&rs->timer);
2360 rs->timer.data = (unsigned long)rs;
2361 rs->timer.function = isdn_ppp_ccp_timer_callback;
2362 is->reset->rs[id] = rs;
2368 /* A decompressor wants a reset with a set of parameters - do what is
2369 necessary to fulfill it */
2370 static void isdn_ppp_ccp_reset_trans(struct ippp_struct *is,
2371 struct isdn_ppp_resetparams *rp)
2373 struct ippp_ccp_reset_state *rs;
2376 /* The decompressor defines parameters by itself */
2378 /* And he wants us to send a request */
2380 printk(KERN_ERR "ippp_ccp: decompressor must"
2381 " specify reset id\n");
2384 if (is->reset->rs[rp->id]) {
2385 /* There is already a transaction in existence
2386 for this id. May be still waiting for a
2387 Ack or may be wrong. */
2388 rs = is->reset->rs[rp->id];
2389 if (rs->state == CCPResetSentReq && rs->ta) {
2390 printk(KERN_DEBUG "ippp_ccp: reset"
2391 " trans still in progress"
2392 " for id %d\n", rp->id);
2394 printk(KERN_WARNING "ippp_ccp: reset"
2395 " trans in wrong state %d for"
2396 " id %d\n", rs->state, rp->id);
2399 /* Ok, this is a new transaction */
2400 printk(KERN_DEBUG "ippp_ccp: new trans for id"
2401 " %d to be started\n", rp->id);
2402 rs = isdn_ppp_ccp_reset_alloc_state(is, rp->id);
2404 printk(KERN_ERR "ippp_ccp: out of mem"
2405 " allocing ccp trans\n");
2408 rs->state = CCPResetSentReq;
2409 rs->expra = rp->expra;
2411 rs->dlen = rp->dlen;
2412 memcpy(rs->data, rp->data, rp->dlen);
2414 /* HACK TODO - add link comp here */
2415 isdn_ppp_ccp_xmit_reset(is, PPP_CCP,
2416 CCP_RESETREQ, rs->id,
2417 rs->data, rs->dlen);
2418 /* Start the timer */
2419 rs->timer.expires = jiffies + 5 * HZ;
2420 add_timer(&rs->timer);
2424 printk(KERN_DEBUG "ippp_ccp: no reset sent\n");
2427 /* The reset params are invalid. The decompressor does not
2428 care about them, so we just send the minimal requests
2429 and increase ids only when an Ack is received for a
2431 if (is->reset->rs[is->reset->lastid]) {
2432 /* There is already a transaction in existence
2433 for this id. May be still waiting for a
2434 Ack or may be wrong. */
2435 rs = is->reset->rs[is->reset->lastid];
2436 if (rs->state == CCPResetSentReq && rs->ta) {
2437 printk(KERN_DEBUG "ippp_ccp: reset"
2438 " trans still in progress"
2439 " for id %d\n", rp->id);
2441 printk(KERN_WARNING "ippp_ccp: reset"
2442 " trans in wrong state %d for"
2443 " id %d\n", rs->state, rp->id);
2446 printk(KERN_DEBUG "ippp_ccp: new trans for id"
2447 " %d to be started\n", is->reset->lastid);
2448 rs = isdn_ppp_ccp_reset_alloc_state(is,
2451 printk(KERN_ERR "ippp_ccp: out of mem"
2452 " allocing ccp trans\n");
2455 rs->state = CCPResetSentReq;
2456 /* We always expect an Ack if the decompressor doesn't
2460 /* HACK TODO - add link comp here */
2461 isdn_ppp_ccp_xmit_reset(is, PPP_CCP, CCP_RESETREQ,
2463 /* Start the timer */
2464 rs->timer.expires = jiffies + 5 * HZ;
2465 add_timer(&rs->timer);
2471 /* An Ack was received for this id. This means we stop the timer and clean
2472 up the state prior to calling the decompressors reset routine. */
2473 static void isdn_ppp_ccp_reset_ack_rcvd(struct ippp_struct *is,
2476 struct ippp_ccp_reset_state *rs = is->reset->rs[id];
2479 if (rs->ta && rs->state == CCPResetSentReq) {
2480 /* Great, we are correct */
2482 printk(KERN_DEBUG "ippp_ccp: ResetAck received"
2483 " for id %d but not expected\n", id);
2485 printk(KERN_INFO "ippp_ccp: ResetAck received out of"
2486 "sync for id %d\n", id);
2490 del_timer(&rs->timer);
2492 isdn_ppp_ccp_reset_free_state(is, id);
2494 printk(KERN_INFO "ippp_ccp: ResetAck received for unknown id"
2497 /* Make sure the simple reset stuff uses a new id next time */
2498 is->reset->lastid++;
2504 * if master = 0, we're trying to uncompress an per-link compressed packet,
2505 * as opposed to an compressed reconstructed-from-MPPP packet.
2506 * proto is updated to protocol field of uncompressed packet.
2508 * retval: decompressed packet,
2509 * same packet if uncompressed,
2510 * NULL if decompression error
2513 static struct sk_buff *isdn_ppp_decompress(struct sk_buff *skb, struct ippp_struct *is, struct ippp_struct *master,
2517 struct isdn_ppp_compressor *ipc = NULL;
2518 struct sk_buff *skb_out;
2520 struct ippp_struct *ri;
2521 struct isdn_ppp_resetparams rsparm;
2522 unsigned char rsdata[IPPP_RESET_MAXDATABYTES];
2525 // per-link decompression
2526 stat = is->link_decomp_stat;
2527 ipc = is->link_decompressor;
2530 stat = master->decomp_stat;
2531 ipc = master->decompressor;
2536 // no decompressor -> we can't decompress.
2537 printk(KERN_DEBUG "ippp: no decompressor defined!\n");
2540 BUG_ON(!stat); // if we have a compressor, stat has been set as well
2542 if ((master && *proto == PPP_COMP) || (!master && *proto == PPP_COMPFRAG)) {
2543 // compressed packets are compressed by their protocol type
2545 // Set up reset params for the decompressor
2546 memset(&rsparm, 0, sizeof(rsparm));
2547 rsparm.data = rsdata;
2548 rsparm.maxdlen = IPPP_RESET_MAXDATABYTES;
2550 skb_out = dev_alloc_skb(is->mru + PPP_HDRLEN);
2553 printk(KERN_ERR "ippp: decomp memory allocation failure\n");
2556 len = ipc->decompress(stat, skb, skb_out, &rsparm);
2561 printk(KERN_INFO "ippp: decomp wants reset %s params\n",
2562 rsparm.valid ? "with" : "without");
2564 isdn_ppp_ccp_reset_trans(ri, &rsparm);
2566 case DECOMP_FATALERROR:
2567 ri->pppcfg |= SC_DC_FERROR;
2568 /* Kick ipppd to recognize the error */
2569 isdn_ppp_ccp_kickup(ri);
2575 *proto = isdn_ppp_strip_proto(skb_out);
2582 // uncompressed packets are fed through the decompressor to
2583 // update the decompressor state
2584 ipc->incomp(stat, skb, *proto);
2591 * type=0: normal/bundle compression
2592 * =1: link compression
2593 * returns original skb if we haven't compressed the frame
2594 * and a new skb pointer if we've done it
2596 static struct sk_buff *isdn_ppp_compress(struct sk_buff *skb_in, int *proto,
2597 struct ippp_struct *is, struct ippp_struct *master, int type)
2601 struct isdn_ppp_compressor *compressor;
2603 struct sk_buff *skb_out;
2605 /* we do not compress control protocols */
2606 if (*proto < 0 || *proto > 0x3fff) {
2610 if (type) { /* type=1 => Link compression */
2615 compressor = is->compressor;
2616 stat = is->comp_stat;
2619 compressor = master->compressor;
2620 stat = master->comp_stat;
2622 new_proto = PPP_COMP;
2626 printk(KERN_ERR "isdn_ppp: No compressor set!\n");
2630 printk(KERN_ERR "isdn_ppp: Compressor not initialized?\n");
2634 /* Allow for at least 150 % expansion (for now) */
2635 skb_out = alloc_skb(skb_in->len + skb_in->len / 2 + 32 +
2636 skb_headroom(skb_in), GFP_ATOMIC);
2639 skb_reserve(skb_out, skb_headroom(skb_in));
2641 ret = (compressor->compress)(stat, skb_in, skb_out, *proto);
2643 dev_kfree_skb(skb_out);
2647 dev_kfree_skb(skb_in);
2653 * we received a CCP frame ..
2654 * not a clean solution, but we MUST handle a few cases in the kernel
2656 static void isdn_ppp_receive_ccp(isdn_net_dev *net_dev, isdn_net_local *lp,
2657 struct sk_buff *skb, int proto)
2659 struct ippp_struct *is;
2660 struct ippp_struct *mis;
2662 struct isdn_ppp_resetparams rsparm;
2663 unsigned char rsdata[IPPP_RESET_MAXDATABYTES];
2665 printk(KERN_DEBUG "Received CCP frame from peer slot(%d)\n",
2667 if (lp->ppp_slot < 0 || lp->ppp_slot >= ISDN_MAX_CHANNELS) {
2668 printk(KERN_ERR "%s: lp->ppp_slot(%d) out of range\n",
2669 __func__, lp->ppp_slot);
2672 is = ippp_table[lp->ppp_slot];
2673 isdn_ppp_frame_log("ccp-rcv", skb->data, skb->len, 32, is->unit, lp->ppp_slot);
2676 int slot = ISDN_MASTER_PRIV(lp)->ppp_slot;
2677 if (slot < 0 || slot >= ISDN_MAX_CHANNELS) {
2678 printk(KERN_ERR "%s: slot(%d) out of range\n",
2682 mis = ippp_table[slot];
2686 switch (skb->data[0]) {
2688 if (is->debug & 0x10)
2689 printk(KERN_DEBUG "Disable compression here!\n");
2690 if (proto == PPP_CCP)
2691 mis->compflags &= ~SC_COMP_ON;
2693 is->compflags &= ~SC_LINK_COMP_ON;
2697 if (is->debug & 0x10)
2698 printk(KERN_DEBUG "Disable (de)compression here!\n");
2699 if (proto == PPP_CCP)
2700 mis->compflags &= ~(SC_DECOMP_ON | SC_COMP_ON);
2702 is->compflags &= ~(SC_LINK_DECOMP_ON | SC_LINK_COMP_ON);
2705 /* if we RECEIVE an ackowledge we enable the decompressor */
2706 if (is->debug & 0x10)
2707 printk(KERN_DEBUG "Enable decompression here!\n");
2708 if (proto == PPP_CCP) {
2709 if (!mis->decompressor)
2711 mis->compflags |= SC_DECOMP_ON;
2713 if (!is->decompressor)
2715 is->compflags |= SC_LINK_DECOMP_ON;
2720 printk(KERN_DEBUG "Received ResetAck from peer\n");
2721 len = (skb->data[2] << 8) | skb->data[3];
2724 if (proto == PPP_CCP) {
2725 /* If a reset Ack was outstanding for this id, then
2726 clean up the state engine */
2727 isdn_ppp_ccp_reset_ack_rcvd(mis, skb->data[1]);
2728 if (mis->decompressor && mis->decomp_stat)
2730 reset(mis->decomp_stat,
2733 len ? &skb->data[4] : NULL,
2735 /* TODO: This is not easy to decide here */
2736 mis->compflags &= ~SC_DECOMP_DISCARD;
2739 isdn_ppp_ccp_reset_ack_rcvd(is, skb->data[1]);
2740 if (is->link_decompressor && is->link_decomp_stat)
2741 is->link_decompressor->
2742 reset(is->link_decomp_stat,
2745 len ? &skb->data[4] : NULL,
2747 /* TODO: neither here */
2748 is->compflags &= ~SC_LINK_DECOMP_DISCARD;
2753 printk(KERN_DEBUG "Received ResetReq from peer\n");
2754 /* Receiving a ResetReq means we must reset our compressor */
2755 /* Set up reset params for the reset entry */
2756 memset(&rsparm, 0, sizeof(rsparm));
2757 rsparm.data = rsdata;
2758 rsparm.maxdlen = IPPP_RESET_MAXDATABYTES;
2759 /* Isolate data length */
2760 len = (skb->data[2] << 8) | skb->data[3];
2762 if (proto == PPP_CCP) {
2763 if (mis->compressor && mis->comp_stat)
2765 reset(mis->comp_stat,
2768 len ? &skb->data[4] : NULL,
2772 if (is->link_compressor && is->link_comp_stat)
2773 is->link_compressor->
2774 reset(is->link_comp_stat,
2777 len ? &skb->data[4] : NULL,
2780 /* Ack the Req as specified by rsparm */
2782 /* Compressor reset handler decided how to answer */
2784 /* We should send a Frame */
2785 isdn_ppp_ccp_xmit_reset(is, proto, CCP_RESETACK,
2786 rsparm.idval ? rsparm.id
2793 printk(KERN_DEBUG "ResetAck suppressed\n");
2796 /* We answer with a straight reflected Ack */
2797 isdn_ppp_ccp_xmit_reset(is, proto, CCP_RESETACK,
2799 len ? &skb->data[4] : NULL,
2808 * Daemon sends a CCP frame ...
2811 /* TODO: Clean this up with new Reset semantics */
2813 /* I believe the CCP handling as-is is done wrong. Compressed frames
2814 * should only be sent/received after CCP reaches UP state, which means
2815 * both sides have sent CONF_ACK. Currently, we handle both directions
2816 * independently, which means we may accept compressed frames too early
2817 * (supposedly not a problem), but may also mean we send compressed frames
2818 * too early, which may turn out to be a problem.
2819 * This part of state machine should actually be handled by (i)pppd, but
2820 * that's too big of a change now. --kai
2823 /* Actually, we might turn this into an advantage: deal with the RFC in
2824 * the old tradition of beeing generous on what we accept, but beeing
2825 * strict on what we send. Thus we should just
2826 * - accept compressed frames as soon as decompression is negotiated
2827 * - send compressed frames only when decomp *and* comp are negotiated
2828 * - drop rx compressed frames if we cannot decomp (instead of pushing them
2830 * and I tried to modify this file according to that. --abp
2833 static void isdn_ppp_send_ccp(isdn_net_dev *net_dev, isdn_net_local *lp, struct sk_buff *skb)
2835 struct ippp_struct *mis, *is;
2836 int proto, slot = lp->ppp_slot;
2837 unsigned char *data;
2839 if (!skb || skb->len < 3)
2841 if (slot < 0 || slot >= ISDN_MAX_CHANNELS) {
2842 printk(KERN_ERR "%s: lp->ppp_slot(%d) out of range\n",
2846 is = ippp_table[slot];
2847 /* Daemon may send with or without address and control field comp */
2849 if (!(is->pppcfg & SC_COMP_AC) && data[0] == 0xff && data[1] == 0x03) {
2855 proto = ((int)data[0]<<8) + data[1];
2856 if (proto != PPP_CCP && proto != PPP_CCPFRAG)
2859 printk(KERN_DEBUG "Received CCP frame from daemon:\n");
2860 isdn_ppp_frame_log("ccp-xmit", skb->data, skb->len, 32, is->unit, lp->ppp_slot);
2863 slot = ISDN_MASTER_PRIV(lp)->ppp_slot;
2864 if (slot < 0 || slot >= ISDN_MAX_CHANNELS) {
2865 printk(KERN_ERR "%s: slot(%d) out of range\n",
2869 mis = ippp_table[slot];
2873 printk(KERN_DEBUG "isdn_ppp: Ouch! Master CCP sends on slave slot!\n");
2877 if (is->debug & 0x10)
2878 printk(KERN_DEBUG "Disable decompression here!\n");
2879 if (proto == PPP_CCP)
2880 is->compflags &= ~SC_DECOMP_ON;
2882 is->compflags &= ~SC_LINK_DECOMP_ON;
2886 if (is->debug & 0x10)
2887 printk(KERN_DEBUG "Disable (de)compression here!\n");
2888 if (proto == PPP_CCP)
2889 is->compflags &= ~(SC_DECOMP_ON | SC_COMP_ON);
2891 is->compflags &= ~(SC_LINK_DECOMP_ON | SC_LINK_COMP_ON);
2894 /* if we SEND an ackowledge we can/must enable the compressor */
2895 if (is->debug & 0x10)
2896 printk(KERN_DEBUG "Enable compression here!\n");
2897 if (proto == PPP_CCP) {
2898 if (!is->compressor)
2900 is->compflags |= SC_COMP_ON;
2902 if (!is->compressor)
2904 is->compflags |= SC_LINK_COMP_ON;
2908 /* If we send a ACK we should reset our compressor */
2909 if (is->debug & 0x10)
2910 printk(KERN_DEBUG "Reset decompression state here!\n");
2911 printk(KERN_DEBUG "ResetAck from daemon passed by\n");
2912 if (proto == PPP_CCP) {
2913 /* link to master? */
2914 if (is->compressor && is->comp_stat)
2915 is->compressor->reset(is->comp_stat, 0, 0,
2917 is->compflags &= ~SC_COMP_DISCARD;
2920 if (is->link_compressor && is->link_comp_stat)
2921 is->link_compressor->reset(is->link_comp_stat,
2922 0, 0, NULL, 0, NULL);
2923 is->compflags &= ~SC_LINK_COMP_DISCARD;
2927 /* Just let it pass by */
2928 printk(KERN_DEBUG "ResetReq from daemon passed by\n");
2933 int isdn_ppp_register_compressor(struct isdn_ppp_compressor *ipc)
2935 ipc->next = ipc_head;
2938 ipc_head->prev = ipc;
2944 int isdn_ppp_unregister_compressor(struct isdn_ppp_compressor *ipc)
2947 ipc->prev->next = ipc->next;
2949 ipc_head = ipc->next;
2951 ipc->next->prev = ipc->prev;
2952 ipc->prev = ipc->next = NULL;
2956 static int isdn_ppp_set_compressor(struct ippp_struct *is, struct isdn_ppp_comp_data *data)
2958 struct isdn_ppp_compressor *ipc = ipc_head;
2961 int num = data->num;
2963 if (is->debug & 0x10)
2964 printk(KERN_DEBUG "[%d] Set %s type %d\n", is->unit,
2965 (data->flags & IPPP_COMP_FLAG_XMIT) ? "compressor" : "decompressor", num);
2967 /* If is has no valid reset state vector, we cannot allocate a
2968 decompressor. The decompressor would cause reset transactions
2969 sooner or later, and they need that vector. */
2971 if (!(data->flags & IPPP_COMP_FLAG_XMIT) && !is->reset) {
2972 printk(KERN_ERR "ippp_ccp: no reset data structure - can't"
2973 " allow decompression.\n");
2978 if (ipc->num == num) {
2979 stat = ipc->alloc(data);
2981 ret = ipc->init(stat, data, is->unit, 0);
2983 printk(KERN_ERR "Can't init (de)compression!\n");
2990 printk(KERN_ERR "Can't alloc (de)compression!\n");
2994 if (data->flags & IPPP_COMP_FLAG_XMIT) {
2995 if (data->flags & IPPP_COMP_FLAG_LINK) {
2996 if (is->link_comp_stat)
2997 is->link_compressor->free(is->link_comp_stat);
2998 is->link_comp_stat = stat;
2999 is->link_compressor = ipc;
3003 is->compressor->free(is->comp_stat);
3004 is->comp_stat = stat;
3005 is->compressor = ipc;
3009 if (data->flags & IPPP_COMP_FLAG_LINK) {
3010 if (is->link_decomp_stat)
3011 is->link_decompressor->free(is->link_decomp_stat);
3012 is->link_decomp_stat = stat;
3013 is->link_decompressor = ipc;
3016 if (is->decomp_stat)
3017 is->decompressor->free(is->decomp_stat);
3018 is->decomp_stat = stat;
3019 is->decompressor = ipc;