blob: 9c1e8adaf4fc825c54ff84e9c85d36a68ecb5da7 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/* $Id: isdn_ppp.c,v 1.1.2.3 2004/02/10 01:07:13 keil Exp $
2 *
3 * Linux ISDN subsystem, functions for synchronous PPP (linklevel).
4 *
5 * Copyright 1995,96 by Michael Hipp (Michael.Hipp@student.uni-tuebingen.de)
6 *
7 * This software may be used and distributed according to the terms
8 * of the GNU General Public License, incorporated herein by reference.
9 *
10 */
11
Linus Torvalds1da177e2005-04-16 15:20:36 -070012#include <linux/isdn.h>
13#include <linux/poll.h>
14#include <linux/ppp-comp.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090015#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070016#ifdef CONFIG_IPPP_FILTER
17#include <linux/filter.h>
18#endif
19
20#include "isdn_common.h"
21#include "isdn_ppp.h"
22#include "isdn_net.h"
23
24#ifndef PPP_IPX
25#define PPP_IPX 0x002b
26#endif
27
28/* Prototypes */
29static int isdn_ppp_fill_rq(unsigned char *buf, int len, int proto, int slot);
30static int isdn_ppp_closewait(int slot);
Joe Perches475be4d2012-02-19 19:52:38 -080031static void isdn_ppp_push_higher(isdn_net_dev *net_dev, isdn_net_local *lp,
Linus Torvalds1da177e2005-04-16 15:20:36 -070032 struct sk_buff *skb, int proto);
33static int isdn_ppp_if_get_unit(char *namebuf);
Joe Perches475be4d2012-02-19 19:52:38 -080034static int isdn_ppp_set_compressor(struct ippp_struct *is, struct isdn_ppp_comp_data *);
Linus Torvalds1da177e2005-04-16 15:20:36 -070035static struct sk_buff *isdn_ppp_decompress(struct sk_buff *,
Joe Perches475be4d2012-02-19 19:52:38 -080036 struct ippp_struct *, struct ippp_struct *, int *proto);
37static void isdn_ppp_receive_ccp(isdn_net_dev *net_dev, isdn_net_local *lp,
38 struct sk_buff *skb, int proto);
39static struct sk_buff *isdn_ppp_compress(struct sk_buff *skb_in, int *proto,
40 struct ippp_struct *is, struct ippp_struct *master, int type);
Linus Torvalds1da177e2005-04-16 15:20:36 -070041static void isdn_ppp_send_ccp(isdn_net_dev *net_dev, isdn_net_local *lp,
Joe Perches475be4d2012-02-19 19:52:38 -080042 struct sk_buff *skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -070043
44/* New CCP stuff */
45static void isdn_ppp_ccp_kickup(struct ippp_struct *is);
46static 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);
49static struct ippp_ccp_reset *isdn_ppp_ccp_reset_alloc(struct ippp_struct *is);
50static void isdn_ppp_ccp_reset_free(struct ippp_struct *is);
51static void isdn_ppp_ccp_reset_free_state(struct ippp_struct *is,
52 unsigned char id);
53static void isdn_ppp_ccp_timer_callback(unsigned long closure);
54static struct ippp_ccp_reset_state *isdn_ppp_ccp_reset_alloc_state(struct ippp_struct *is,
Joe Perches475be4d2012-02-19 19:52:38 -080055 unsigned char id);
Linus Torvalds1da177e2005-04-16 15:20:36 -070056static void isdn_ppp_ccp_reset_trans(struct ippp_struct *is,
57 struct isdn_ppp_resetparams *rp);
58static void isdn_ppp_ccp_reset_ack_rcvd(struct ippp_struct *is,
59 unsigned char id);
60
61
62
63#ifdef CONFIG_ISDN_MPP
Joe Perches475be4d2012-02-19 19:52:38 -080064static ippp_bundle *isdn_ppp_bundle_arr = NULL;
65
Linus Torvalds1da177e2005-04-16 15:20:36 -070066static int isdn_ppp_mp_bundle_array_init(void);
Joe Perches475be4d2012-02-19 19:52:38 -080067static int isdn_ppp_mp_init(isdn_net_local *lp, ippp_bundle *add_to);
68static void isdn_ppp_mp_receive(isdn_net_dev *net_dev, isdn_net_local *lp,
69 struct sk_buff *skb);
70static void isdn_ppp_mp_cleanup(isdn_net_local *lp);
Linus Torvalds1da177e2005-04-16 15:20:36 -070071
72static int isdn_ppp_bundle(struct ippp_struct *, int unit);
73#endif /* CONFIG_ISDN_MPP */
Joe Perches475be4d2012-02-19 19:52:38 -080074
Linus Torvalds1da177e2005-04-16 15:20:36 -070075char *isdn_ppp_revision = "$Revision: 1.1.2.3 $";
76
77static struct ippp_struct *ippp_table[ISDN_MAX_CHANNELS];
78
79static struct isdn_ppp_compressor *ipc_head = NULL;
80
81/*
82 * frame log (debug)
83 */
84static void
Joe Perches475be4d2012-02-19 19:52:38 -080085isdn_ppp_frame_log(char *info, char *data, int len, int maxlen, int unit, int slot)
Linus Torvalds1da177e2005-04-16 15:20:36 -070086{
87 int cnt,
Joe Perches475be4d2012-02-19 19:52:38 -080088 j,
89 i;
Linus Torvalds1da177e2005-04-16 15:20:36 -070090 char buf[80];
91
92 if (len < maxlen)
93 maxlen = len;
94
95 for (i = 0, cnt = 0; cnt < maxlen; i++) {
96 for (j = 0; j < 16 && cnt < maxlen; j++, cnt++)
Joe Perches475be4d2012-02-19 19:52:38 -080097 sprintf(buf + j * 3, "%02x ", (unsigned char)data[cnt]);
98 printk(KERN_DEBUG "[%d/%d].%s[%d]: %s\n", unit, slot, info, i, buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -070099 }
100}
101
102/*
103 * unbind isdn_net_local <=> ippp-device
104 * note: it can happen, that we hangup/free the master before the slaves
105 * in this case we bind another lp to the master device
106 */
107int
Joe Perches475be4d2012-02-19 19:52:38 -0800108isdn_ppp_free(isdn_net_local *lp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109{
110 struct ippp_struct *is;
111
Eric Sesterhenn052bb882006-04-11 17:29:17 -0700112 if (lp->ppp_slot < 0 || lp->ppp_slot >= ISDN_MAX_CHANNELS) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113 printk(KERN_ERR "%s: ppp_slot(%d) out of range\n",
Joe Perches475be4d2012-02-19 19:52:38 -0800114 __func__, lp->ppp_slot);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115 return 0;
116 }
117
118#ifdef CONFIG_ISDN_MPP
119 spin_lock(&lp->netdev->pb->lock);
120#endif
121 isdn_net_rm_from_bundle(lp);
122#ifdef CONFIG_ISDN_MPP
123 if (lp->netdev->pb->ref_ct == 1) /* last link in queue? */
124 isdn_ppp_mp_cleanup(lp);
125
126 lp->netdev->pb->ref_ct--;
127 spin_unlock(&lp->netdev->pb->lock);
128#endif /* CONFIG_ISDN_MPP */
Eric Sesterhenn052bb882006-04-11 17:29:17 -0700129 if (lp->ppp_slot < 0 || lp->ppp_slot >= ISDN_MAX_CHANNELS) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130 printk(KERN_ERR "%s: ppp_slot(%d) now invalid\n",
Joe Perches475be4d2012-02-19 19:52:38 -0800131 __func__, lp->ppp_slot);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132 return 0;
133 }
134 is = ippp_table[lp->ppp_slot];
135 if ((is->state & IPPP_CONNECT))
136 isdn_ppp_closewait(lp->ppp_slot); /* force wakeup on ippp device */
137 else if (is->state & IPPP_ASSIGNED)
138 is->state = IPPP_OPEN; /* fallback to 'OPEN but not ASSIGNED' state */
139
140 if (is->debug & 0x1)
141 printk(KERN_DEBUG "isdn_ppp_free %d %lx %lx\n", lp->ppp_slot, (long) lp, (long) is->lp);
142
143 is->lp = NULL; /* link is down .. set lp to NULL */
144 lp->ppp_slot = -1; /* is this OK ?? */
145
146 return 0;
147}
148
149/*
150 * bind isdn_net_local <=> ippp-device
151 *
152 * This function is allways called with holding dev->lock so
153 * no additional lock is needed
154 */
155int
Joe Perches475be4d2012-02-19 19:52:38 -0800156isdn_ppp_bind(isdn_net_local *lp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157{
158 int i;
159 int unit = 0;
160 struct ippp_struct *is;
161 int retval;
162
163 if (lp->pppbind < 0) { /* device bounded to ippp device ? */
164 isdn_net_dev *net_dev = dev->netdev;
165 char exclusive[ISDN_MAX_CHANNELS]; /* exclusive flags */
166 memset(exclusive, 0, ISDN_MAX_CHANNELS);
167 while (net_dev) { /* step through net devices to find exclusive minors */
168 isdn_net_local *lp = net_dev->local;
169 if (lp->pppbind >= 0)
170 exclusive[lp->pppbind] = 1;
171 net_dev = net_dev->next;
172 }
173 /*
174 * search a free device / slot
175 */
176 for (i = 0; i < ISDN_MAX_CHANNELS; i++) {
177 if (ippp_table[i]->state == IPPP_OPEN && !exclusive[ippp_table[i]->minor]) { /* OPEN, but not connected! */
178 break;
179 }
180 }
181 } else {
182 for (i = 0; i < ISDN_MAX_CHANNELS; i++) {
183 if (ippp_table[i]->minor == lp->pppbind &&
184 (ippp_table[i]->state & IPPP_OPEN) == IPPP_OPEN)
185 break;
186 }
187 }
188
189 if (i >= ISDN_MAX_CHANNELS) {
190 printk(KERN_WARNING "isdn_ppp_bind: Can't find a (free) connection to the ipppd daemon.\n");
191 retval = -1;
192 goto out;
193 }
Karsten Keilfaca94f2007-10-15 02:11:44 -0700194 /* get unit number from interface name .. ugly! */
195 unit = isdn_ppp_if_get_unit(lp->netdev->dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196 if (unit < 0) {
Karsten Keilfaca94f2007-10-15 02:11:44 -0700197 printk(KERN_ERR "isdn_ppp_bind: illegal interface name %s.\n",
Joe Perches475be4d2012-02-19 19:52:38 -0800198 lp->netdev->dev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199 retval = -1;
200 goto out;
201 }
Joe Perches475be4d2012-02-19 19:52:38 -0800202
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203 lp->ppp_slot = i;
204 is = ippp_table[i];
205 is->lp = lp;
206 is->unit = unit;
207 is->state = IPPP_OPEN | IPPP_ASSIGNED; /* assigned to a netdevice but not connected */
208#ifdef CONFIG_ISDN_MPP
209 retval = isdn_ppp_mp_init(lp, NULL);
210 if (retval < 0)
211 goto out;
212#endif /* CONFIG_ISDN_MPP */
213
214 retval = lp->ppp_slot;
215
Joe Perches475be4d2012-02-19 19:52:38 -0800216out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217 return retval;
218}
219
220/*
221 * kick the ipppd on the device
222 * (wakes up daemon after B-channel connect)
223 */
224
225void
Joe Perches475be4d2012-02-19 19:52:38 -0800226isdn_ppp_wakeup_daemon(isdn_net_local *lp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227{
228 if (lp->ppp_slot < 0 || lp->ppp_slot >= ISDN_MAX_CHANNELS) {
229 printk(KERN_ERR "%s: ppp_slot(%d) out of range\n",
Joe Perches475be4d2012-02-19 19:52:38 -0800230 __func__, lp->ppp_slot);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231 return;
232 }
233 ippp_table[lp->ppp_slot]->state = IPPP_OPEN | IPPP_CONNECT | IPPP_NOBLOCK;
234 wake_up_interruptible(&ippp_table[lp->ppp_slot]->wq);
235}
236
237/*
238 * there was a hangup on the netdevice
239 * force wakeup of the ippp device
240 * go into 'device waits for release' state
241 */
242static int
243isdn_ppp_closewait(int slot)
244{
245 struct ippp_struct *is;
246
247 if (slot < 0 || slot >= ISDN_MAX_CHANNELS) {
248 printk(KERN_ERR "%s: slot(%d) out of range\n",
Joe Perches475be4d2012-02-19 19:52:38 -0800249 __func__, slot);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250 return 0;
251 }
252 is = ippp_table[slot];
253 if (is->state)
254 wake_up_interruptible(&is->wq);
255 is->state = IPPP_CLOSEWAIT;
256 return 1;
257}
258
259/*
260 * isdn_ppp_find_slot / isdn_ppp_free_slot
261 */
262
263static int
264isdn_ppp_get_slot(void)
265{
266 int i;
267 for (i = 0; i < ISDN_MAX_CHANNELS; i++) {
268 if (!ippp_table[i]->state)
269 return i;
270 }
271 return -1;
272}
273
274/*
275 * isdn_ppp_open
276 */
277
278int
279isdn_ppp_open(int min, struct file *file)
280{
281 int slot;
282 struct ippp_struct *is;
283
Eric Sesterhenn052bb882006-04-11 17:29:17 -0700284 if (min < 0 || min >= ISDN_MAX_CHANNELS)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285 return -ENODEV;
286
287 slot = isdn_ppp_get_slot();
288 if (slot < 0) {
289 return -EBUSY;
290 }
291 is = file->private_data = ippp_table[slot];
Joe Perches475be4d2012-02-19 19:52:38 -0800292
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293 printk(KERN_DEBUG "ippp, open, slot: %d, minor: %d, state: %04x\n",
294 slot, min, is->state);
295
296 /* compression stuff */
297 is->link_compressor = is->compressor = NULL;
298 is->link_decompressor = is->decompressor = NULL;
299 is->link_comp_stat = is->comp_stat = NULL;
300 is->link_decomp_stat = is->decomp_stat = NULL;
301 is->compflags = 0;
302
303 is->reset = isdn_ppp_ccp_reset_alloc(is);
Ben Hutchings0baa57d2015-11-01 16:21:24 +0000304 if (!is->reset)
305 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306
307 is->lp = NULL;
308 is->mp_seqno = 0; /* MP sequence number */
309 is->pppcfg = 0; /* ppp configuration */
310 is->mpppcfg = 0; /* mppp configuration */
311 is->last_link_seqno = -1; /* MP: maybe set to Bundle-MIN, when joining a bundle ?? */
312 is->unit = -1; /* set, when we have our interface */
313 is->mru = 1524; /* MRU, default 1524 */
314 is->maxcid = 16; /* VJ: maxcid */
315 is->tk = current;
316 init_waitqueue_head(&is->wq);
317 is->first = is->rq + NUM_RCV_BUFFS - 1; /* receive queue */
318 is->last = is->rq;
319 is->minor = min;
320#ifdef CONFIG_ISDN_PPP_VJ
321 /*
322 * VJ header compression init
323 */
324 is->slcomp = slhc_init(16, 16); /* not necessary for 2. link in bundle */
Ben Hutchings4ab42d72015-11-01 16:22:53 +0000325 if (IS_ERR(is->slcomp)) {
Ben Hutchings0baa57d2015-11-01 16:21:24 +0000326 isdn_ppp_ccp_reset_free(is);
Ben Hutchings4ab42d72015-11-01 16:22:53 +0000327 return PTR_ERR(is->slcomp);
Ben Hutchings0baa57d2015-11-01 16:21:24 +0000328 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329#endif
330#ifdef CONFIG_IPPP_FILTER
331 is->pass_filter = NULL;
332 is->active_filter = NULL;
333#endif
334 is->state = IPPP_OPEN;
335
336 return 0;
337}
338
339/*
340 * release ippp device
341 */
342void
343isdn_ppp_release(int min, struct file *file)
344{
345 int i;
346 struct ippp_struct *is;
347
348 if (min < 0 || min >= ISDN_MAX_CHANNELS)
349 return;
350 is = file->private_data;
351
352 if (!is) {
Harvey Harrison156f1ed2008-04-28 02:14:40 -0700353 printk(KERN_ERR "%s: no file->private_data\n", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354 return;
355 }
356 if (is->debug & 0x1)
357 printk(KERN_DEBUG "ippp: release, minor: %d %lx\n", min, (long) is->lp);
358
359 if (is->lp) { /* a lp address says: this link is still up */
360 isdn_net_dev *p = is->lp->netdev;
361
362 if (!p) {
Harvey Harrison156f1ed2008-04-28 02:14:40 -0700363 printk(KERN_ERR "%s: no lp->netdev\n", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364 return;
365 }
366 is->state &= ~IPPP_CONNECT; /* -> effect: no call of wakeup */
367 /*
368 * isdn_net_hangup() calls isdn_ppp_free()
369 * isdn_ppp_free() sets is->lp to NULL and lp->ppp_slot to -1
370 * removing the IPPP_CONNECT flag omits calling of isdn_ppp_wakeup_daemon()
371 */
Karsten Keild62a38d2007-10-08 20:37:11 -0700372 isdn_net_hangup(p->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373 }
374 for (i = 0; i < NUM_RCV_BUFFS; i++) {
Jesper Juhl3c7208f2005-11-07 01:01:29 -0800375 kfree(is->rq[i].buf);
376 is->rq[i].buf = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377 }
378 is->first = is->rq + NUM_RCV_BUFFS - 1; /* receive queue */
379 is->last = is->rq;
380
381#ifdef CONFIG_ISDN_PPP_VJ
382/* TODO: if this was the previous master: link the slcomp to the new master */
383 slhc_free(is->slcomp);
384 is->slcomp = NULL;
385#endif
386#ifdef CONFIG_IPPP_FILTER
Daniel Borkmann77e01142014-03-28 18:58:24 +0100387 if (is->pass_filter) {
Alexei Starovoitov7ae457c2014-07-30 20:34:16 -0700388 bpf_prog_destroy(is->pass_filter);
Daniel Borkmann77e01142014-03-28 18:58:24 +0100389 is->pass_filter = NULL;
390 }
391
392 if (is->active_filter) {
Alexei Starovoitov7ae457c2014-07-30 20:34:16 -0700393 bpf_prog_destroy(is->active_filter);
Daniel Borkmann77e01142014-03-28 18:58:24 +0100394 is->active_filter = NULL;
395 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396#endif
397
398/* TODO: if this was the previous master: link the stuff to the new master */
Joe Perches475be4d2012-02-19 19:52:38 -0800399 if (is->comp_stat)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400 is->compressor->free(is->comp_stat);
Joe Perches475be4d2012-02-19 19:52:38 -0800401 if (is->link_comp_stat)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 is->link_compressor->free(is->link_comp_stat);
Joe Perches475be4d2012-02-19 19:52:38 -0800403 if (is->link_decomp_stat)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404 is->link_decompressor->free(is->link_decomp_stat);
Joe Perches475be4d2012-02-19 19:52:38 -0800405 if (is->decomp_stat)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406 is->decompressor->free(is->decomp_stat);
Joe Perches475be4d2012-02-19 19:52:38 -0800407 is->compressor = is->link_compressor = NULL;
408 is->decompressor = is->link_decompressor = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409 is->comp_stat = is->link_comp_stat = NULL;
Joe Perches475be4d2012-02-19 19:52:38 -0800410 is->decomp_stat = is->link_decomp_stat = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411
412 /* Clean up if necessary */
Joe Perches475be4d2012-02-19 19:52:38 -0800413 if (is->reset)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414 isdn_ppp_ccp_reset_free(is);
415
416 /* this slot is ready for new connections */
417 is->state = 0;
418}
419
420/*
421 * get_arg .. ioctl helper
422 */
423static int
424get_arg(void __user *b, void *val, int len)
425{
426 if (len <= 0)
427 len = sizeof(void *);
428 if (copy_from_user(val, b, len))
429 return -EFAULT;
430 return 0;
431}
432
433/*
434 * set arg .. ioctl helper
435 */
436static int
Joe Perches475be4d2012-02-19 19:52:38 -0800437set_arg(void __user *b, void *val, int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438{
Joe Perches475be4d2012-02-19 19:52:38 -0800439 if (len <= 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440 len = sizeof(void *);
441 if (copy_to_user(b, val, len))
442 return -EFAULT;
443 return 0;
444}
445
Daniele Venzano26285ba2009-01-26 12:24:38 -0800446#ifdef CONFIG_IPPP_FILTER
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447static int get_filter(void __user *arg, struct sock_filter **p)
448{
449 struct sock_fprog uprog;
450 struct sock_filter *code = NULL;
Christoph Schulz3916a312014-07-14 08:01:10 +0200451 int len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452
453 if (copy_from_user(&uprog, arg, sizeof(uprog)))
454 return -EFAULT;
455
456 if (!uprog.len) {
457 *p = NULL;
458 return 0;
459 }
460
461 /* uprog.len is unsigned short, so no overflow here */
462 len = uprog.len * sizeof(struct sock_filter);
Julia Lawall024cb8a2010-05-21 22:26:42 +0000463 code = memdup_user(uprog.filter, len);
464 if (IS_ERR(code))
465 return PTR_ERR(code);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467 *p = code;
468 return uprog.len;
469}
Daniele Venzano26285ba2009-01-26 12:24:38 -0800470#endif /* CONFIG_IPPP_FILTER */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471
472/*
473 * ippp device ioctl
474 */
475int
476isdn_ppp_ioctl(int min, struct file *file, unsigned int cmd, unsigned long arg)
477{
478 unsigned long val;
Joe Perches475be4d2012-02-19 19:52:38 -0800479 int r, i, j;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480 struct ippp_struct *is;
481 isdn_net_local *lp;
482 struct isdn_ppp_comp_data data;
483 void __user *argp = (void __user *)arg;
484
Joe Perches54cbb1c2010-07-12 10:50:02 +0000485 is = file->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486 lp = is->lp;
487
488 if (is->debug & 0x1)
489 printk(KERN_DEBUG "isdn_ppp_ioctl: minor: %d cmd: %x state: %x\n", min, cmd, is->state);
490
491 if (!(is->state & IPPP_OPEN))
492 return -EINVAL;
493
494 switch (cmd) {
Joe Perches475be4d2012-02-19 19:52:38 -0800495 case PPPIOCBUNDLE:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496#ifdef CONFIG_ISDN_MPP
Joe Perches475be4d2012-02-19 19:52:38 -0800497 if (!(is->state & IPPP_CONNECT))
498 return -EINVAL;
499 if ((r = get_arg(argp, &val, sizeof(val))))
500 return r;
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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504#else
Joe Perches475be4d2012-02-19 19:52:38 -0800505 return -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506#endif
Joe Perches475be4d2012-02-19 19:52:38 -0800507 break;
508 case PPPIOCGUNIT: /* get ppp/isdn unit number */
509 if ((r = set_arg(argp, &is->unit, sizeof(is->unit))))
510 return r;
511 break;
512 case PPPIOCGIFNAME:
513 if (!lp)
514 return -EINVAL;
515 if ((r = set_arg(argp, lp->netdev->dev->name,
516 strlen(lp->netdev->dev->name))))
517 return r;
518 break;
519 case PPPIOCGMPFLAGS: /* get configuration flags */
520 if ((r = set_arg(argp, &is->mpppcfg, sizeof(is->mpppcfg))))
521 return r;
522 break;
523 case PPPIOCSMPFLAGS: /* set configuration flags */
524 if ((r = get_arg(argp, &val, sizeof(val))))
525 return r;
526 is->mpppcfg = val;
527 break;
528 case PPPIOCGFLAGS: /* get configuration flags */
529 if ((r = set_arg(argp, &is->pppcfg, sizeof(is->pppcfg))))
530 return r;
531 break;
532 case PPPIOCSFLAGS: /* set configuration flags */
533 if ((r = get_arg(argp, &val, sizeof(val)))) {
534 return r;
535 }
536 if (val & SC_ENABLE_IP && !(is->pppcfg & SC_ENABLE_IP) && (is->state & IPPP_CONNECT)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537 if (lp) {
Joe Perches475be4d2012-02-19 19:52:38 -0800538 /* 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);
541 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542 }
Joe Perches475be4d2012-02-19 19:52:38 -0800543 }
544 is->pppcfg = val;
545 break;
546 case PPPIOCGIDLE: /* get idle time information */
547 if (lp) {
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))))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551 return r;
Joe Perches475be4d2012-02-19 19:52:38 -0800552 }
553 break;
554 case PPPIOCSMRU: /* set receive unit size for PPP */
555 if ((r = get_arg(argp, &val, sizeof(val))))
556 return r;
557 is->mru = val;
558 break;
559 case PPPIOCSMPMRU:
560 break;
561 case PPPIOCSMPMTU:
562 break;
563 case PPPIOCSMAXCID: /* set the maximum compression slot id */
564 if ((r = get_arg(argp, &val, sizeof(val))))
565 return r;
566 val++;
567 if (is->maxcid != val) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568#ifdef CONFIG_ISDN_PPP_VJ
Joe Perches475be4d2012-02-19 19:52:38 -0800569 struct slcompress *sltmp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570#endif
Joe Perches475be4d2012-02-19 19:52:38 -0800571 if (is->debug & 0x1)
572 printk(KERN_DEBUG "ippp, ioctl: changed MAXCID to %ld\n", val);
573 is->maxcid = val;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574#ifdef CONFIG_ISDN_PPP_VJ
Joe Perches475be4d2012-02-19 19:52:38 -0800575 sltmp = slhc_init(16, val);
Ben Hutchings4ab42d72015-11-01 16:22:53 +0000576 if (IS_ERR(sltmp))
577 return PTR_ERR(sltmp);
Joe Perches475be4d2012-02-19 19:52:38 -0800578 if (is->slcomp)
579 slhc_free(is->slcomp);
580 is->slcomp = sltmp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581#endif
Joe Perches475be4d2012-02-19 19:52:38 -0800582 }
583 break;
584 case PPPIOCGDEBUG:
585 if ((r = set_arg(argp, &is->debug, sizeof(is->debug))))
586 return r;
587 break;
588 case PPPIOCSDEBUG:
589 if ((r = get_arg(argp, &val, sizeof(val))))
590 return r;
591 is->debug = val;
592 break;
593 case PPPIOCGCOMPRESSORS:
594 {
595 unsigned long protos[8] = {0,};
596 struct isdn_ppp_compressor *ipc = ipc_head;
597 while (ipc) {
598 j = ipc->num / (sizeof(long) * 8);
599 i = ipc->num % (sizeof(long) * 8);
600 if (j < 8)
Dan Carpenter435f08a2012-10-09 23:42:18 +0000601 protos[j] |= (1UL << i);
Joe Perches475be4d2012-02-19 19:52:38 -0800602 ipc = ipc->next;
603 }
604 if ((r = set_arg(argp, protos, 8 * sizeof(long))))
605 return r;
606 }
607 break;
608 case PPPIOCSCOMPRESSOR:
609 if ((r = get_arg(argp, &data, sizeof(struct isdn_ppp_comp_data))))
610 return r;
611 return isdn_ppp_set_compressor(is, &data);
612 case PPPIOCGCALLINFO:
613 {
614 struct pppcallinfo pci;
615 memset((char *)&pci, 0, sizeof(struct pppcallinfo));
616 if (lp)
617 {
618 strncpy(pci.local_num, lp->msn, 63);
619 if (lp->dial) {
620 strncpy(pci.remote_num, lp->dial->num, 63);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621 }
Joe Perches475be4d2012-02-19 19:52:38 -0800622 pci.charge_units = lp->charge;
623 if (lp->outgoing)
624 pci.calltype = CALLTYPE_OUTGOING;
625 else
626 pci.calltype = CALLTYPE_INCOMING;
627 if (lp->flags & ISDN_NET_CALLBACK)
628 pci.calltype |= CALLTYPE_CALLBACK;
629 }
630 return set_arg(argp, &pci, sizeof(struct pppcallinfo));
631 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632#ifdef CONFIG_IPPP_FILTER
Joe Perches475be4d2012-02-19 19:52:38 -0800633 case PPPIOCSPASS:
634 {
Daniel Borkmannb1fcd352014-05-23 18:43:58 +0200635 struct sock_fprog_kern fprog;
Joe Perches475be4d2012-02-19 19:52:38 -0800636 struct sock_filter *code;
Daniel Borkmann77e01142014-03-28 18:58:24 +0100637 int err, len = get_filter(argp, &code);
638
Joe Perches475be4d2012-02-19 19:52:38 -0800639 if (len < 0)
640 return len;
Daniel Borkmann77e01142014-03-28 18:58:24 +0100641
642 fprog.len = len;
643 fprog.filter = code;
644
Christoph Schulzcc25eaa2014-07-16 22:10:29 +0200645 if (is->pass_filter) {
Alexei Starovoitov7ae457c2014-07-30 20:34:16 -0700646 bpf_prog_destroy(is->pass_filter);
Christoph Schulzcc25eaa2014-07-16 22:10:29 +0200647 is->pass_filter = NULL;
648 }
649 if (fprog.filter != NULL)
Alexei Starovoitov7ae457c2014-07-30 20:34:16 -0700650 err = bpf_prog_create(&is->pass_filter, &fprog);
Christoph Schulzcc25eaa2014-07-16 22:10:29 +0200651 else
652 err = 0;
Daniel Borkmann77e01142014-03-28 18:58:24 +0100653 kfree(code);
654
655 return err;
Joe Perches475be4d2012-02-19 19:52:38 -0800656 }
657 case PPPIOCSACTIVE:
658 {
Daniel Borkmannb1fcd352014-05-23 18:43:58 +0200659 struct sock_fprog_kern fprog;
Joe Perches475be4d2012-02-19 19:52:38 -0800660 struct sock_filter *code;
Daniel Borkmann77e01142014-03-28 18:58:24 +0100661 int err, len = get_filter(argp, &code);
662
Joe Perches475be4d2012-02-19 19:52:38 -0800663 if (len < 0)
664 return len;
Daniel Borkmann77e01142014-03-28 18:58:24 +0100665
666 fprog.len = len;
667 fprog.filter = code;
668
Christoph Schulzcc25eaa2014-07-16 22:10:29 +0200669 if (is->active_filter) {
Alexei Starovoitov7ae457c2014-07-30 20:34:16 -0700670 bpf_prog_destroy(is->active_filter);
Christoph Schulzcc25eaa2014-07-16 22:10:29 +0200671 is->active_filter = NULL;
672 }
673 if (fprog.filter != NULL)
Alexei Starovoitov7ae457c2014-07-30 20:34:16 -0700674 err = bpf_prog_create(&is->active_filter, &fprog);
Christoph Schulzcc25eaa2014-07-16 22:10:29 +0200675 else
676 err = 0;
Daniel Borkmann77e01142014-03-28 18:58:24 +0100677 kfree(code);
678
679 return err;
Joe Perches475be4d2012-02-19 19:52:38 -0800680 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681#endif /* CONFIG_IPPP_FILTER */
Joe Perches475be4d2012-02-19 19:52:38 -0800682 default:
683 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684 }
685 return 0;
686}
687
688unsigned int
Joe Perches475be4d2012-02-19 19:52:38 -0800689isdn_ppp_poll(struct file *file, poll_table *wait)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690{
691 u_int mask;
692 struct ippp_buf_queue *bf, *bl;
693 u_long flags;
694 struct ippp_struct *is;
695
696 is = file->private_data;
697
698 if (is->debug & 0x2)
699 printk(KERN_DEBUG "isdn_ppp_poll: minor: %d\n",
Al Viro496ad9a2013-01-23 17:07:38 -0500700 iminor(file_inode(file)));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701
702 /* just registers wait_queue hook. This doesn't really wait. */
703 poll_wait(file, &is->wq, wait);
704
705 if (!(is->state & IPPP_OPEN)) {
Joe Perches475be4d2012-02-19 19:52:38 -0800706 if (is->state == IPPP_CLOSEWAIT)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707 return POLLHUP;
708 printk(KERN_DEBUG "isdn_ppp: device not open\n");
709 return POLLERR;
710 }
711 /* we're always ready to send .. */
712 mask = POLLOUT | POLLWRNORM;
713
714 spin_lock_irqsave(&is->buflock, flags);
715 bl = is->last;
716 bf = is->first;
717 /*
718 * if IPPP_NOBLOCK is set we return even if we have nothing to read
719 */
720 if (bf->next != bl || (is->state & IPPP_NOBLOCK)) {
721 is->state &= ~IPPP_NOBLOCK;
722 mask |= POLLIN | POLLRDNORM;
723 }
724 spin_unlock_irqrestore(&is->buflock, flags);
725 return mask;
726}
727
728/*
729 * fill up isdn_ppp_read() queue ..
730 */
731
732static int
733isdn_ppp_fill_rq(unsigned char *buf, int len, int proto, int slot)
734{
735 struct ippp_buf_queue *bf, *bl;
736 u_long flags;
737 u_char *nbuf;
738 struct ippp_struct *is;
739
740 if (slot < 0 || slot >= ISDN_MAX_CHANNELS) {
741 printk(KERN_WARNING "ippp: illegal slot(%d).\n", slot);
742 return 0;
743 }
744 is = ippp_table[slot];
745
746 if (!(is->state & IPPP_CONNECT)) {
747 printk(KERN_DEBUG "ippp: device not activated.\n");
748 return 0;
749 }
Robert P. J. Day5cbded52006-12-13 00:35:56 -0800750 nbuf = kmalloc(len + 4, GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751 if (!nbuf) {
752 printk(KERN_WARNING "ippp: Can't alloc buf\n");
753 return 0;
754 }
755 nbuf[0] = PPP_ALLSTATIONS;
756 nbuf[1] = PPP_UI;
757 nbuf[2] = proto >> 8;
758 nbuf[3] = proto & 0xff;
759 memcpy(nbuf + 4, buf, len);
760
761 spin_lock_irqsave(&is->buflock, flags);
762 bf = is->first;
763 bl = is->last;
764
765 if (bf == bl) {
766 printk(KERN_WARNING "ippp: Queue is full; discarding first buffer\n");
767 bf = bf->next;
768 kfree(bf->buf);
769 is->first = bf;
770 }
771 bl->buf = (char *) nbuf;
772 bl->len = len + 4;
773
774 is->last = bl->next;
775 spin_unlock_irqrestore(&is->buflock, flags);
776 wake_up_interruptible(&is->wq);
777 return len;
778}
779
780/*
781 * read() .. non-blocking: ipppd calls it only after select()
782 * reports, that there is data
783 */
784
785int
786isdn_ppp_read(int min, struct file *file, char __user *buf, int count)
787{
788 struct ippp_struct *is;
789 struct ippp_buf_queue *b;
790 u_long flags;
791 u_char *save_buf;
792
793 is = file->private_data;
794
795 if (!(is->state & IPPP_OPEN))
796 return 0;
797
798 if (!access_ok(VERIFY_WRITE, buf, count))
799 return -EFAULT;
800
801 spin_lock_irqsave(&is->buflock, flags);
802 b = is->first->next;
803 save_buf = b->buf;
804 if (!save_buf) {
805 spin_unlock_irqrestore(&is->buflock, flags);
806 return -EAGAIN;
807 }
808 if (b->len < count)
809 count = b->len;
810 b->buf = NULL;
811 is->first = b;
812
813 spin_unlock_irqrestore(&is->buflock, flags);
Jesper Juhlc41a24c2006-03-25 03:07:02 -0800814 if (copy_to_user(buf, save_buf, count))
815 count = -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700816 kfree(save_buf);
817
818 return count;
819}
820
821/*
822 * ipppd wanna write a packet to the card .. non-blocking
823 */
824
825int
826isdn_ppp_write(int min, struct file *file, const char __user *buf, int count)
827{
828 isdn_net_local *lp;
829 struct ippp_struct *is;
830 int proto;
831 unsigned char protobuf[4];
832
833 is = file->private_data;
834
835 if (!(is->state & IPPP_CONNECT))
836 return 0;
837
838 lp = is->lp;
839
840 /* -> push it directly to the lowlevel interface */
841
842 if (!lp)
843 printk(KERN_DEBUG "isdn_ppp_write: lp == NULL\n");
844 else {
845 /*
846 * Don't reset huptimer for
847 * LCP packets. (Echo requests).
848 */
849 if (copy_from_user(protobuf, buf, 4))
850 return -EFAULT;
851 proto = PPP_PROTOCOL(protobuf);
852 if (proto != PPP_LCP)
853 lp->huptimer = 0;
854
855 if (lp->isdn_device < 0 || lp->isdn_channel < 0)
856 return 0;
857
858 if ((dev->drv[lp->isdn_device]->flags & DRV_FLAG_RUNNING) &&
Joe Perches475be4d2012-02-19 19:52:38 -0800859 lp->dialstate == 0 &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700860 (lp->flags & ISDN_NET_CONNECTED)) {
861 unsigned short hl;
862 struct sk_buff *skb;
863 /*
André Goddard Rosaaf901ca2009-11-14 13:09:05 -0200864 * we need to reserve enough space in front of
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865 * sk_buff. old call to dev_alloc_skb only reserved
866 * 16 bytes, now we are looking what the driver want
867 */
868 hl = dev->drv[lp->isdn_device]->interface->hl_hdrlen;
Joe Perches475be4d2012-02-19 19:52:38 -0800869 skb = alloc_skb(hl + count, GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870 if (!skb) {
871 printk(KERN_WARNING "isdn_ppp_write: out of memory!\n");
872 return count;
873 }
874 skb_reserve(skb, hl);
875 if (copy_from_user(skb_put(skb, count), buf, count))
876 {
877 kfree_skb(skb);
878 return -EFAULT;
879 }
880 if (is->debug & 0x40) {
881 printk(KERN_DEBUG "ppp xmit: len %d\n", (int) skb->len);
Joe Perches475be4d2012-02-19 19:52:38 -0800882 isdn_ppp_frame_log("xmit", skb->data, skb->len, 32, is->unit, lp->ppp_slot);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700883 }
884
Joe Perches475be4d2012-02-19 19:52:38 -0800885 isdn_ppp_send_ccp(lp->netdev, lp, skb); /* keeps CCP/compression states in sync */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700886
887 isdn_net_write_super(lp, skb);
888 }
889 }
890 return count;
891}
892
893/*
894 * init memory, structures etc.
895 */
896
897int
898isdn_ppp_init(void)
899{
900 int i,
Joe Perches475be4d2012-02-19 19:52:38 -0800901 j;
902
Linus Torvalds1da177e2005-04-16 15:20:36 -0700903#ifdef CONFIG_ISDN_MPP
Joe Perches475be4d2012-02-19 19:52:38 -0800904 if (isdn_ppp_mp_bundle_array_init() < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700905 return -ENOMEM;
906#endif /* CONFIG_ISDN_MPP */
907
908 for (i = 0; i < ISDN_MAX_CHANNELS; i++) {
Burman Yan41f96932006-12-08 02:39:35 -0800909 if (!(ippp_table[i] = kzalloc(sizeof(struct ippp_struct), GFP_KERNEL))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700910 printk(KERN_WARNING "isdn_ppp_init: Could not alloc ippp_table\n");
911 for (j = 0; j < i; j++)
912 kfree(ippp_table[j]);
913 return -1;
914 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700915 spin_lock_init(&ippp_table[i]->buflock);
916 ippp_table[i]->state = 0;
917 ippp_table[i]->first = ippp_table[i]->rq + NUM_RCV_BUFFS - 1;
918 ippp_table[i]->last = ippp_table[i]->rq;
919
920 for (j = 0; j < NUM_RCV_BUFFS; j++) {
921 ippp_table[i]->rq[j].buf = NULL;
922 ippp_table[i]->rq[j].last = ippp_table[i]->rq +
Joe Perches475be4d2012-02-19 19:52:38 -0800923 (NUM_RCV_BUFFS + j - 1) % NUM_RCV_BUFFS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700924 ippp_table[i]->rq[j].next = ippp_table[i]->rq + (j + 1) % NUM_RCV_BUFFS;
925 }
926 }
927 return 0;
928}
929
930void
931isdn_ppp_cleanup(void)
932{
933 int i;
934
935 for (i = 0; i < ISDN_MAX_CHANNELS; i++)
936 kfree(ippp_table[i]);
937
938#ifdef CONFIG_ISDN_MPP
Jesper Juhl3c7208f2005-11-07 01:01:29 -0800939 kfree(isdn_ppp_bundle_arr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700940#endif /* CONFIG_ISDN_MPP */
941
942}
943
944/*
945 * check for address/control field and skip if allowed
946 * retval != 0 -> discard packet silently
947 */
Joe Perches475be4d2012-02-19 19:52:38 -0800948static int isdn_ppp_skip_ac(struct ippp_struct *is, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700949{
950 if (skb->len < 1)
951 return -1;
952
953 if (skb->data[0] == 0xff) {
954 if (skb->len < 2)
955 return -1;
956
957 if (skb->data[1] != 0x03)
958 return -1;
959
960 // skip address/control (AC) field
961 skb_pull(skb, 2);
Joe Perches475be4d2012-02-19 19:52:38 -0800962 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963 if (is->pppcfg & SC_REJ_COMP_AC)
964 // if AC compression was not negotiated, but used, discard packet
965 return -1;
966 }
967 return 0;
968}
969
970/*
971 * get the PPP protocol header and pull skb
972 * retval < 0 -> discard packet silently
973 */
Joe Perches475be4d2012-02-19 19:52:38 -0800974static int isdn_ppp_strip_proto(struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700975{
976 int proto;
Joe Perches475be4d2012-02-19 19:52:38 -0800977
Linus Torvalds1da177e2005-04-16 15:20:36 -0700978 if (skb->len < 1)
979 return -1;
980
981 if (skb->data[0] & 0x1) {
982 // protocol field is compressed
983 proto = skb->data[0];
984 skb_pull(skb, 1);
985 } else {
986 if (skb->len < 2)
987 return -1;
988 proto = ((int) skb->data[0] << 8) + skb->data[1];
989 skb_pull(skb, 2);
990 }
991 return proto;
992}
993
994
995/*
996 * handler for incoming packets on a syncPPP interface
997 */
Joe Perches475be4d2012-02-19 19:52:38 -0800998void isdn_ppp_receive(isdn_net_dev *net_dev, isdn_net_local *lp, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700999{
1000 struct ippp_struct *is;
1001 int slot;
1002 int proto;
1003
Eric Sesterhenn6dd44a72006-03-26 18:19:26 +02001004 BUG_ON(net_dev->local->master); // we're called with the master device always
Linus Torvalds1da177e2005-04-16 15:20:36 -07001005
1006 slot = lp->ppp_slot;
1007 if (slot < 0 || slot >= ISDN_MAX_CHANNELS) {
1008 printk(KERN_ERR "isdn_ppp_receive: lp->ppp_slot(%d)\n",
Joe Perches475be4d2012-02-19 19:52:38 -08001009 lp->ppp_slot);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001010 kfree_skb(skb);
1011 return;
1012 }
1013 is = ippp_table[slot];
1014
1015 if (is->debug & 0x4) {
1016 printk(KERN_DEBUG "ippp_receive: is:%08lx lp:%08lx slot:%d unit:%d len:%d\n",
Joe Perches475be4d2012-02-19 19:52:38 -08001017 (long)is, (long)lp, lp->ppp_slot, is->unit, (int)skb->len);
1018 isdn_ppp_frame_log("receive", skb->data, skb->len, 32, is->unit, lp->ppp_slot);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001019 }
1020
Joe Perches475be4d2012-02-19 19:52:38 -08001021 if (isdn_ppp_skip_ac(is, skb) < 0) {
1022 kfree_skb(skb);
1023 return;
1024 }
1025 proto = isdn_ppp_strip_proto(skb);
1026 if (proto < 0) {
1027 kfree_skb(skb);
1028 return;
1029 }
1030
Linus Torvalds1da177e2005-04-16 15:20:36 -07001031#ifdef CONFIG_ISDN_MPP
Joe Perches475be4d2012-02-19 19:52:38 -08001032 if (is->compflags & SC_LINK_DECOMP_ON) {
1033 skb = isdn_ppp_decompress(skb, is, NULL, &proto);
1034 if (!skb) // decompression error
1035 return;
1036 }
1037
1038 if (!(is->mpppcfg & SC_REJ_MP_PROT)) { // we agreed to receive MPPP
1039 if (proto == PPP_MP) {
1040 isdn_ppp_mp_receive(net_dev, lp, skb);
1041 return;
1042 }
1043 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001044#endif
Joe Perches475be4d2012-02-19 19:52:38 -08001045 isdn_ppp_push_higher(net_dev, lp, skb, proto);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001046}
1047
1048/*
1049 * we receive a reassembled frame, MPPP has been taken care of before.
1050 * address/control and protocol have been stripped from the skb
1051 * note: net_dev has to be master net_dev
1052 */
1053static void
Joe Perches475be4d2012-02-19 19:52:38 -08001054isdn_ppp_push_higher(isdn_net_dev *net_dev, isdn_net_local *lp, struct sk_buff *skb, int proto)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001055{
Karsten Keild62a38d2007-10-08 20:37:11 -07001056 struct net_device *dev = net_dev->dev;
Joe Perches475be4d2012-02-19 19:52:38 -08001057 struct ippp_struct *is, *mis;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001058 isdn_net_local *mlp = NULL;
1059 int slot;
1060
1061 slot = lp->ppp_slot;
1062 if (slot < 0 || slot >= ISDN_MAX_CHANNELS) {
1063 printk(KERN_ERR "isdn_ppp_push_higher: lp->ppp_slot(%d)\n",
Joe Perches475be4d2012-02-19 19:52:38 -08001064 lp->ppp_slot);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001065 goto drop_packet;
1066 }
1067 is = ippp_table[slot];
Joe Perches475be4d2012-02-19 19:52:38 -08001068
1069 if (lp->master) { // FIXME?
Wang Chen838361f2008-12-03 15:49:46 -08001070 mlp = ISDN_MASTER_PRIV(lp);
Joe Perches475be4d2012-02-19 19:52:38 -08001071 slot = mlp->ppp_slot;
1072 if (slot < 0 || slot >= ISDN_MAX_CHANNELS) {
1073 printk(KERN_ERR "isdn_ppp_push_higher: master->ppp_slot(%d)\n",
1074 lp->ppp_slot);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001075 goto drop_packet;
Joe Perches475be4d2012-02-19 19:52:38 -08001076 }
1077 }
1078 mis = ippp_table[slot];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001079
1080 if (is->debug & 0x10) {
1081 printk(KERN_DEBUG "push, skb %d %04x\n", (int) skb->len, proto);
Joe Perches475be4d2012-02-19 19:52:38 -08001082 isdn_ppp_frame_log("rpush", skb->data, skb->len, 32, is->unit, lp->ppp_slot);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001083 }
1084 if (mis->compflags & SC_DECOMP_ON) {
1085 skb = isdn_ppp_decompress(skb, is, mis, &proto);
1086 if (!skb) // decompression error
Joe Perches475be4d2012-02-19 19:52:38 -08001087 return;
1088 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001089 switch (proto) {
Joe Perches475be4d2012-02-19 19:52:38 -08001090 case PPP_IPX: /* untested */
1091 if (is->debug & 0x20)
1092 printk(KERN_DEBUG "isdn_ppp: IPX\n");
1093 skb->protocol = htons(ETH_P_IPX);
1094 break;
1095 case PPP_IP:
1096 if (is->debug & 0x20)
1097 printk(KERN_DEBUG "isdn_ppp: IP\n");
1098 skb->protocol = htons(ETH_P_IP);
1099 break;
1100 case PPP_COMP:
1101 case PPP_COMPFRAG:
1102 printk(KERN_INFO "isdn_ppp: unexpected compressed frame dropped\n");
1103 goto drop_packet;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001104#ifdef CONFIG_ISDN_PPP_VJ
Joe Perches475be4d2012-02-19 19:52:38 -08001105 case PPP_VJC_UNCOMP:
1106 if (is->debug & 0x20)
1107 printk(KERN_DEBUG "isdn_ppp: VJC_UNCOMP\n");
1108 if (net_dev->local->ppp_slot < 0) {
1109 printk(KERN_ERR "%s: net_dev->local->ppp_slot(%d) out of range\n",
1110 __func__, net_dev->local->ppp_slot);
1111 goto drop_packet;
1112 }
1113 if (slhc_remember(ippp_table[net_dev->local->ppp_slot]->slcomp, skb->data, skb->len) <= 0) {
1114 printk(KERN_WARNING "isdn_ppp: received illegal VJC_UNCOMP frame!\n");
1115 goto drop_packet;
1116 }
1117 skb->protocol = htons(ETH_P_IP);
1118 break;
1119 case PPP_VJC_COMP:
1120 if (is->debug & 0x20)
1121 printk(KERN_DEBUG "isdn_ppp: VJC_COMP\n");
1122 {
1123 struct sk_buff *skb_old = skb;
1124 int pkt_len;
1125 skb = dev_alloc_skb(skb_old->len + 128);
1126
1127 if (!skb) {
1128 printk(KERN_WARNING "%s: Memory squeeze, dropping packet.\n", dev->name);
1129 skb = skb_old;
1130 goto drop_packet;
1131 }
1132 skb_put(skb, skb_old->len + 128);
1133 skb_copy_from_linear_data(skb_old, skb->data,
1134 skb_old->len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001135 if (net_dev->local->ppp_slot < 0) {
1136 printk(KERN_ERR "%s: net_dev->local->ppp_slot(%d) out of range\n",
Joe Perches475be4d2012-02-19 19:52:38 -08001137 __func__, net_dev->local->ppp_slot);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001138 goto drop_packet;
1139 }
Joe Perches475be4d2012-02-19 19:52:38 -08001140 pkt_len = slhc_uncompress(ippp_table[net_dev->local->ppp_slot]->slcomp,
1141 skb->data, skb_old->len);
1142 kfree_skb(skb_old);
1143 if (pkt_len < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001144 goto drop_packet;
Joe Perches475be4d2012-02-19 19:52:38 -08001145
1146 skb_trim(skb, pkt_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001147 skb->protocol = htons(ETH_P_IP);
Joe Perches475be4d2012-02-19 19:52:38 -08001148 }
1149 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001150#endif
Joe Perches475be4d2012-02-19 19:52:38 -08001151 case PPP_CCP:
1152 case PPP_CCPFRAG:
1153 isdn_ppp_receive_ccp(net_dev, lp, skb, proto);
1154 /* Dont pop up ResetReq/Ack stuff to the daemon any
1155 longer - the job is done already */
1156 if (skb->data[0] == CCP_RESETREQ ||
1157 skb->data[0] == CCP_RESETACK)
1158 break;
1159 /* fall through */
1160 default:
1161 isdn_ppp_fill_rq(skb->data, skb->len, proto, lp->ppp_slot); /* push data to pppd device */
1162 kfree_skb(skb);
1163 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001164 }
1165
1166#ifdef CONFIG_IPPP_FILTER
1167 /* check if the packet passes the pass and active filters
1168 * the filter instructions are constructed assuming
1169 * a four-byte PPP header on each packet (which is still present) */
1170 skb_push(skb, 4);
1171
1172 {
1173 u_int16_t *p = (u_int16_t *) skb->data;
1174
Karsten Keild8470b72005-04-21 08:30:30 -07001175 *p = 0; /* indicate inbound */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001176 }
1177
1178 if (is->pass_filter
Alexei Starovoitov7ae457c2014-07-30 20:34:16 -07001179 && BPF_PROG_RUN(is->pass_filter, skb) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001180 if (is->debug & 0x2)
1181 printk(KERN_DEBUG "IPPP: inbound frame filtered.\n");
1182 kfree_skb(skb);
1183 return;
1184 }
1185 if (!(is->active_filter
Alexei Starovoitov7ae457c2014-07-30 20:34:16 -07001186 && BPF_PROG_RUN(is->active_filter, skb) == 0)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001187 if (is->debug & 0x2)
Masanari Iidaee556fe2012-02-11 01:49:28 +00001188 printk(KERN_DEBUG "IPPP: link-active filter: resetting huptimer.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001189 lp->huptimer = 0;
1190 if (mlp)
1191 mlp->huptimer = 0;
1192 }
1193 skb_pull(skb, 4);
1194#else /* CONFIG_IPPP_FILTER */
1195 lp->huptimer = 0;
1196 if (mlp)
1197 mlp->huptimer = 0;
1198#endif /* CONFIG_IPPP_FILTER */
1199 skb->dev = dev;
Arnaldo Carvalho de Melo459a98e2007-03-19 15:30:44 -07001200 skb_reset_mac_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001201 netif_rx(skb);
1202 /* net_dev->local->stats.rx_packets++; done in isdn_net.c */
1203 return;
1204
Joe Perches475be4d2012-02-19 19:52:38 -08001205drop_packet:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001206 net_dev->local->stats.rx_dropped++;
1207 kfree_skb(skb);
1208}
1209
1210/*
1211 * isdn_ppp_skb_push ..
1212 * checks whether we have enough space at the beginning of the skb
1213 * and allocs a new SKB if necessary
1214 */
Joe Perches475be4d2012-02-19 19:52:38 -08001215static unsigned char *isdn_ppp_skb_push(struct sk_buff **skb_p, int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001216{
1217 struct sk_buff *skb = *skb_p;
1218
Joe Perches475be4d2012-02-19 19:52:38 -08001219 if (skb_headroom(skb) < len) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001220 struct sk_buff *nskb = skb_realloc_headroom(skb, len);
1221
1222 if (!nskb) {
1223 printk(KERN_ERR "isdn_ppp_skb_push: can't realloc headroom!\n");
1224 dev_kfree_skb(skb);
1225 return NULL;
1226 }
Joe Perches475be4d2012-02-19 19:52:38 -08001227 printk(KERN_DEBUG "isdn_ppp_skb_push:under %d %d\n", skb_headroom(skb), len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001228 dev_kfree_skb(skb);
1229 *skb_p = nskb;
1230 return skb_push(nskb, len);
1231 }
Joe Perches475be4d2012-02-19 19:52:38 -08001232 return skb_push(skb, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001233}
1234
1235/*
1236 * send ppp frame .. we expect a PIDCOMPressable proto --
1237 * (here: currently always PPP_IP,PPP_VJC_COMP,PPP_VJC_UNCOMP)
1238 *
1239 * VJ compression may change skb pointer!!! .. requeue with old
1240 * skb isn't allowed!!
1241 */
1242
1243int
1244isdn_ppp_xmit(struct sk_buff *skb, struct net_device *netdev)
1245{
Joe Perches475be4d2012-02-19 19:52:38 -08001246 isdn_net_local *lp, *mlp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001247 isdn_net_dev *nd;
1248 unsigned int proto = PPP_IP; /* 0x21 */
Joe Perches475be4d2012-02-19 19:52:38 -08001249 struct ippp_struct *ipt, *ipts;
Patrick McHardyec634fe2009-07-05 19:23:38 -07001250 int slot, retval = NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001251
Joe Perchesa17531f2010-11-15 11:12:24 +00001252 mlp = netdev_priv(netdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001253 nd = mlp->netdev; /* get master lp */
1254
1255 slot = mlp->ppp_slot;
1256 if (slot < 0 || slot >= ISDN_MAX_CHANNELS) {
1257 printk(KERN_ERR "isdn_ppp_xmit: lp->ppp_slot(%d)\n",
Joe Perches475be4d2012-02-19 19:52:38 -08001258 mlp->ppp_slot);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001259 kfree_skb(skb);
1260 goto out;
1261 }
1262 ipts = ippp_table[slot];
1263
1264 if (!(ipts->pppcfg & SC_ENABLE_IP)) { /* PPP connected ? */
1265 if (ipts->debug & 0x1)
1266 printk(KERN_INFO "%s: IP frame delayed.\n", netdev->name);
Patrick McHardyec634fe2009-07-05 19:23:38 -07001267 retval = NETDEV_TX_BUSY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001268 goto out;
1269 }
1270
1271 switch (ntohs(skb->protocol)) {
Joe Perches475be4d2012-02-19 19:52:38 -08001272 case ETH_P_IP:
1273 proto = PPP_IP;
1274 break;
1275 case ETH_P_IPX:
1276 proto = PPP_IPX; /* untested */
1277 break;
1278 default:
1279 printk(KERN_ERR "isdn_ppp: skipped unsupported protocol: %#x.\n",
1280 skb->protocol);
1281 dev_kfree_skb(skb);
1282 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001283 }
1284
1285 lp = isdn_net_get_locked_lp(nd);
1286 if (!lp) {
1287 printk(KERN_WARNING "%s: all channels busy - requeuing!\n", netdev->name);
Patrick McHardyec634fe2009-07-05 19:23:38 -07001288 retval = NETDEV_TX_BUSY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001289 goto out;
1290 }
1291 /* we have our lp locked from now on */
1292
1293 slot = lp->ppp_slot;
Eric Sesterhenn052bb882006-04-11 17:29:17 -07001294 if (slot < 0 || slot >= ISDN_MAX_CHANNELS) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001295 printk(KERN_ERR "isdn_ppp_xmit: lp->ppp_slot(%d)\n",
Joe Perches475be4d2012-02-19 19:52:38 -08001296 lp->ppp_slot);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001297 kfree_skb(skb);
1298 goto unlock;
1299 }
1300 ipt = ippp_table[slot];
1301
1302 /*
1303 * after this line .. requeueing in the device queue is no longer allowed!!!
1304 */
1305
1306 /* Pull off the fake header we stuck on earlier to keep
1307 * the fragmentation code happy.
1308 */
Joe Perches475be4d2012-02-19 19:52:38 -08001309 skb_pull(skb, IPPP_MAX_HEADER);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001310
1311#ifdef CONFIG_IPPP_FILTER
1312 /* check if we should pass this packet
1313 * the filter instructions are constructed assuming
1314 * a four-byte PPP header on each packet */
Karsten Keild8470b72005-04-21 08:30:30 -07001315 *skb_push(skb, 4) = 1; /* indicate outbound */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001316
1317 {
Harvey Harrisonc19d0362008-11-20 04:10:51 -08001318 __be16 *p = (__be16 *)skb->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001319
Karsten Keild8470b72005-04-21 08:30:30 -07001320 p++;
Harvey Harrisonc19d0362008-11-20 04:10:51 -08001321 *p = htons(proto);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001322 }
1323
1324 if (ipt->pass_filter
Alexei Starovoitov7ae457c2014-07-30 20:34:16 -07001325 && BPF_PROG_RUN(ipt->pass_filter, skb) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001326 if (ipt->debug & 0x4)
1327 printk(KERN_DEBUG "IPPP: outbound frame filtered.\n");
1328 kfree_skb(skb);
1329 goto unlock;
1330 }
1331 if (!(ipt->active_filter
Alexei Starovoitov7ae457c2014-07-30 20:34:16 -07001332 && BPF_PROG_RUN(ipt->active_filter, skb) == 0)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001333 if (ipt->debug & 0x4)
Masanari Iidaee556fe2012-02-11 01:49:28 +00001334 printk(KERN_DEBUG "IPPP: link-active filter: resetting huptimer.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001335 lp->huptimer = 0;
1336 }
1337 skb_pull(skb, 4);
1338#else /* CONFIG_IPPP_FILTER */
1339 lp->huptimer = 0;
1340#endif /* CONFIG_IPPP_FILTER */
1341
1342 if (ipt->debug & 0x4)
1343 printk(KERN_DEBUG "xmit skb, len %d\n", (int) skb->len);
Joe Perches475be4d2012-02-19 19:52:38 -08001344 if (ipts->debug & 0x40)
1345 isdn_ppp_frame_log("xmit0", skb->data, skb->len, 32, ipts->unit, lp->ppp_slot);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001346
1347#ifdef CONFIG_ISDN_PPP_VJ
1348 if (proto == PPP_IP && ipts->pppcfg & SC_COMP_TCP) { /* ipts here? probably yes, but check this again */
1349 struct sk_buff *new_skb;
Joe Perches475be4d2012-02-19 19:52:38 -08001350 unsigned short hl;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001351 /*
André Goddard Rosaaf901ca2009-11-14 13:09:05 -02001352 * we need to reserve enough space in front of
Linus Torvalds1da177e2005-04-16 15:20:36 -07001353 * sk_buff. old call to dev_alloc_skb only reserved
1354 * 16 bytes, now we are looking what the driver want.
1355 */
1356 hl = dev->drv[lp->isdn_device]->interface->hl_hdrlen + IPPP_MAX_HEADER;
Joe Perches475be4d2012-02-19 19:52:38 -08001357 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001358 * Note: hl might still be insufficient because the method
1359 * above does not account for a possibible MPPP slave channel
1360 * which had larger HL header space requirements than the
1361 * master.
1362 */
Joe Perches475be4d2012-02-19 19:52:38 -08001363 new_skb = alloc_skb(hl + skb->len, GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001364 if (new_skb) {
1365 u_char *buf;
1366 int pktlen;
1367
1368 skb_reserve(new_skb, hl);
1369 new_skb->dev = skb->dev;
1370 skb_put(new_skb, skb->len);
1371 buf = skb->data;
1372
1373 pktlen = slhc_compress(ipts->slcomp, skb->data, skb->len, new_skb->data,
Joe Perches475be4d2012-02-19 19:52:38 -08001374 &buf, !(ipts->pppcfg & SC_NO_TCP_CCID));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001375
Joe Perches475be4d2012-02-19 19:52:38 -08001376 if (buf != skb->data) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001377 if (new_skb->data != buf)
1378 printk(KERN_ERR "isdn_ppp: FATAL error after slhc_compress!!\n");
1379 dev_kfree_skb(skb);
1380 skb = new_skb;
1381 } else {
1382 dev_kfree_skb(new_skb);
1383 }
1384
1385 skb_trim(skb, pktlen);
1386 if (skb->data[0] & SL_TYPE_COMPRESSED_TCP) { /* cslip? style -> PPP */
1387 proto = PPP_VJC_COMP;
1388 skb->data[0] ^= SL_TYPE_COMPRESSED_TCP;
1389 } else {
1390 if (skb->data[0] >= SL_TYPE_UNCOMPRESSED_TCP)
1391 proto = PPP_VJC_UNCOMP;
1392 skb->data[0] = (skb->data[0] & 0x0f) | 0x40;
1393 }
1394 }
1395 }
1396#endif
1397
1398 /*
1399 * normal (single link) or bundle compression
1400 */
Joe Perches475be4d2012-02-19 19:52:38 -08001401 if (ipts->compflags & SC_COMP_ON) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001402 /* We send compressed only if both down- und upstream
1403 compression is negotiated, that means, CCP is up */
Joe Perches475be4d2012-02-19 19:52:38 -08001404 if (ipts->compflags & SC_DECOMP_ON) {
1405 skb = isdn_ppp_compress(skb, &proto, ipt, ipts, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001406 } else {
1407 printk(KERN_DEBUG "isdn_ppp: CCP not yet up - sending as-is\n");
1408 }
1409 }
1410
1411 if (ipt->debug & 0x24)
1412 printk(KERN_DEBUG "xmit2 skb, len %d, proto %04x\n", (int) skb->len, proto);
1413
1414#ifdef CONFIG_ISDN_MPP
1415 if (ipt->mpppcfg & SC_MP_PROT) {
1416 /* we get mp_seqno from static isdn_net_local */
1417 long mp_seqno = ipts->mp_seqno;
1418 ipts->mp_seqno++;
1419 if (ipt->mpppcfg & SC_OUT_SHORT_SEQ) {
1420 unsigned char *data = isdn_ppp_skb_push(&skb, 3);
Joe Perches475be4d2012-02-19 19:52:38 -08001421 if (!data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001422 goto unlock;
1423 mp_seqno &= 0xfff;
1424 data[0] = MP_BEGIN_FRAG | MP_END_FRAG | ((mp_seqno >> 8) & 0xf); /* (B)egin & (E)ndbit .. */
1425 data[1] = mp_seqno & 0xff;
1426 data[2] = proto; /* PID compression */
1427 } else {
1428 unsigned char *data = isdn_ppp_skb_push(&skb, 5);
Joe Perches475be4d2012-02-19 19:52:38 -08001429 if (!data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001430 goto unlock;
1431 data[0] = MP_BEGIN_FRAG | MP_END_FRAG; /* (B)egin & (E)ndbit .. */
1432 data[1] = (mp_seqno >> 16) & 0xff; /* sequence number: 24bit */
1433 data[2] = (mp_seqno >> 8) & 0xff;
1434 data[3] = (mp_seqno >> 0) & 0xff;
1435 data[4] = proto; /* PID compression */
1436 }
1437 proto = PPP_MP; /* MP Protocol, 0x003d */
1438 }
1439#endif
1440
1441 /*
1442 * 'link in bundle' compression ...
1443 */
Joe Perches475be4d2012-02-19 19:52:38 -08001444 if (ipt->compflags & SC_LINK_COMP_ON)
1445 skb = isdn_ppp_compress(skb, &proto, ipt, ipts, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001446
Joe Perches475be4d2012-02-19 19:52:38 -08001447 if ((ipt->pppcfg & SC_COMP_PROT) && (proto <= 0xff)) {
1448 unsigned char *data = isdn_ppp_skb_push(&skb, 1);
1449 if (!data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001450 goto unlock;
1451 data[0] = proto & 0xff;
1452 }
1453 else {
Joe Perches475be4d2012-02-19 19:52:38 -08001454 unsigned char *data = isdn_ppp_skb_push(&skb, 2);
1455 if (!data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001456 goto unlock;
1457 data[0] = (proto >> 8) & 0xff;
1458 data[1] = proto & 0xff;
1459 }
Joe Perches475be4d2012-02-19 19:52:38 -08001460 if (!(ipt->pppcfg & SC_COMP_AC)) {
1461 unsigned char *data = isdn_ppp_skb_push(&skb, 2);
1462 if (!data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001463 goto unlock;
1464 data[0] = 0xff; /* All Stations */
1465 data[1] = 0x03; /* Unnumbered information */
1466 }
1467
1468 /* tx-stats are now updated via BSENT-callback */
1469
1470 if (ipts->debug & 0x40) {
1471 printk(KERN_DEBUG "skb xmit: len: %d\n", (int) skb->len);
Joe Perches475be4d2012-02-19 19:52:38 -08001472 isdn_ppp_frame_log("xmit", skb->data, skb->len, 32, ipt->unit, lp->ppp_slot);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001473 }
Joe Perches475be4d2012-02-19 19:52:38 -08001474
Linus Torvalds1da177e2005-04-16 15:20:36 -07001475 isdn_net_writebuf_skb(lp, skb);
1476
Joe Perches475be4d2012-02-19 19:52:38 -08001477unlock:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001478 spin_unlock_bh(&lp->xmit_lock);
Joe Perches475be4d2012-02-19 19:52:38 -08001479out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001480 return retval;
1481}
1482
1483#ifdef CONFIG_IPPP_FILTER
1484/*
1485 * check if this packet may trigger auto-dial.
1486 */
1487
1488int isdn_ppp_autodial_filter(struct sk_buff *skb, isdn_net_local *lp)
1489{
1490 struct ippp_struct *is = ippp_table[lp->ppp_slot];
1491 u_int16_t proto;
1492 int drop = 0;
1493
1494 switch (ntohs(skb->protocol)) {
1495 case ETH_P_IP:
1496 proto = PPP_IP;
1497 break;
1498 case ETH_P_IPX:
1499 proto = PPP_IPX;
1500 break;
1501 default:
1502 printk(KERN_ERR "isdn_ppp_autodial_filter: unsupported protocol 0x%x.\n",
1503 skb->protocol);
1504 return 1;
1505 }
1506
1507 /* the filter instructions are constructed assuming
1508 * a four-byte PPP header on each packet. we have to
1509 * temporarily remove part of the fake header stuck on
1510 * earlier.
1511 */
Karsten Keild8470b72005-04-21 08:30:30 -07001512 *skb_pull(skb, IPPP_MAX_HEADER - 4) = 1; /* indicate outbound */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001513
1514 {
Harvey Harrisonc19d0362008-11-20 04:10:51 -08001515 __be16 *p = (__be16 *)skb->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001516
Karsten Keild8470b72005-04-21 08:30:30 -07001517 p++;
Harvey Harrisonc19d0362008-11-20 04:10:51 -08001518 *p = htons(proto);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001519 }
Joe Perches475be4d2012-02-19 19:52:38 -08001520
Linus Torvalds1da177e2005-04-16 15:20:36 -07001521 drop |= is->pass_filter
Alexei Starovoitov7ae457c2014-07-30 20:34:16 -07001522 && BPF_PROG_RUN(is->pass_filter, skb) == 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001523 drop |= is->active_filter
Alexei Starovoitov7ae457c2014-07-30 20:34:16 -07001524 && BPF_PROG_RUN(is->active_filter, skb) == 0;
Joe Perches475be4d2012-02-19 19:52:38 -08001525
Linus Torvalds1da177e2005-04-16 15:20:36 -07001526 skb_push(skb, IPPP_MAX_HEADER - 4);
1527 return drop;
1528}
1529#endif
1530#ifdef CONFIG_ISDN_MPP
1531
1532/* this is _not_ rfc1990 header, but something we convert both short and long
1533 * headers to for convinience's sake:
Joe Perches475be4d2012-02-19 19:52:38 -08001534 * byte 0 is flags as in rfc1990
1535 * bytes 1...4 is 24-bit seqence number converted to host byte order
Linus Torvalds1da177e2005-04-16 15:20:36 -07001536 */
1537#define MP_HEADER_LEN 5
1538
1539#define MP_LONGSEQ_MASK 0x00ffffff
1540#define MP_SHORTSEQ_MASK 0x00000fff
1541#define MP_LONGSEQ_MAX MP_LONGSEQ_MASK
1542#define MP_SHORTSEQ_MAX MP_SHORTSEQ_MASK
Joe Perches475be4d2012-02-19 19:52:38 -08001543#define MP_LONGSEQ_MAXBIT ((MP_LONGSEQ_MASK + 1) >> 1)
1544#define MP_SHORTSEQ_MAXBIT ((MP_SHORTSEQ_MASK + 1) >> 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001545
Lucas De Marchi25985ed2011-03-30 22:57:33 -03001546/* sequence-wrap safe comparisons (for long sequence)*/
Joe Perches475be4d2012-02-19 19:52:38 -08001547#define MP_LT(a, b) ((a - b) & MP_LONGSEQ_MAXBIT)
1548#define MP_LE(a, b) !((b - a) & MP_LONGSEQ_MAXBIT)
1549#define MP_GT(a, b) ((b - a) & MP_LONGSEQ_MAXBIT)
1550#define MP_GE(a, b) !((a - b) & MP_LONGSEQ_MAXBIT)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001551
Joe Perches475be4d2012-02-19 19:52:38 -08001552#define MP_SEQ(f) ((*(u32 *)(f->data + 1)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001553#define MP_FLAGS(f) (f->data[0])
1554
1555static int isdn_ppp_mp_bundle_array_init(void)
1556{
1557 int i;
Joe Perches475be4d2012-02-19 19:52:38 -08001558 int sz = ISDN_MAX_CHANNELS * sizeof(ippp_bundle);
1559 if ((isdn_ppp_bundle_arr = kzalloc(sz, GFP_KERNEL)) == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001560 return -ENOMEM;
Joe Perches475be4d2012-02-19 19:52:38 -08001561 for (i = 0; i < ISDN_MAX_CHANNELS; i++)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001562 spin_lock_init(&isdn_ppp_bundle_arr[i].lock);
1563 return 0;
1564}
1565
Joe Perches475be4d2012-02-19 19:52:38 -08001566static ippp_bundle *isdn_ppp_mp_bundle_alloc(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001567{
1568 int i;
Joe Perches475be4d2012-02-19 19:52:38 -08001569 for (i = 0; i < ISDN_MAX_CHANNELS; i++)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001570 if (isdn_ppp_bundle_arr[i].ref_ct <= 0)
1571 return (isdn_ppp_bundle_arr + i);
1572 return NULL;
1573}
1574
Joe Perches475be4d2012-02-19 19:52:38 -08001575static int isdn_ppp_mp_init(isdn_net_local *lp, ippp_bundle *add_to)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001576{
Joe Perches475be4d2012-02-19 19:52:38 -08001577 struct ippp_struct *is;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001578
1579 if (lp->ppp_slot < 0) {
1580 printk(KERN_ERR "%s: lp->ppp_slot(%d) out of range\n",
Joe Perches475be4d2012-02-19 19:52:38 -08001581 __func__, lp->ppp_slot);
1582 return (-EINVAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001583 }
1584
1585 is = ippp_table[lp->ppp_slot];
1586 if (add_to) {
Joe Perches475be4d2012-02-19 19:52:38 -08001587 if (lp->netdev->pb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001588 lp->netdev->pb->ref_ct--;
1589 lp->netdev->pb = add_to;
1590 } else { /* first link in a bundle */
1591 is->mp_seqno = 0;
1592 if ((lp->netdev->pb = isdn_ppp_mp_bundle_alloc()) == NULL)
1593 return -ENOMEM;
1594 lp->next = lp->last = lp; /* nobody else in a queue */
David S. Millere29d4362009-11-15 22:23:47 -08001595 lp->netdev->pb->frags = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001596 lp->netdev->pb->frames = 0;
1597 lp->netdev->pb->seq = UINT_MAX;
1598 }
1599 lp->netdev->pb->ref_ct++;
Joe Perches475be4d2012-02-19 19:52:38 -08001600
Linus Torvalds1da177e2005-04-16 15:20:36 -07001601 is->last_link_seqno = 0;
1602 return 0;
1603}
1604
Joe Perches475be4d2012-02-19 19:52:38 -08001605static u32 isdn_ppp_mp_get_seq(int short_seq,
1606 struct sk_buff *skb, u32 last_seq);
1607static struct sk_buff *isdn_ppp_mp_discard(ippp_bundle *mp,
1608 struct sk_buff *from, struct sk_buff *to);
1609static void isdn_ppp_mp_reassembly(isdn_net_dev *net_dev, isdn_net_local *lp,
1610 struct sk_buff *from, struct sk_buff *to);
1611static void isdn_ppp_mp_free_skb(ippp_bundle *mp, struct sk_buff *skb);
1612static void isdn_ppp_mp_print_recv_pkt(int slot, struct sk_buff *skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001613
Joe Perches475be4d2012-02-19 19:52:38 -08001614static void isdn_ppp_mp_receive(isdn_net_dev *net_dev, isdn_net_local *lp,
1615 struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001616{
David S. Miller38783e62008-09-22 01:15:02 -07001617 struct ippp_struct *is;
Joe Perches475be4d2012-02-19 19:52:38 -08001618 isdn_net_local *lpq;
1619 ippp_bundle *mp;
1620 isdn_mppp_stats *stats;
1621 struct sk_buff *newfrag, *frag, *start, *nextf;
David S. Millere29d4362009-11-15 22:23:47 -08001622 u32 newseq, minseq, thisseq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001623 unsigned long flags;
1624 int slot;
1625
1626 spin_lock_irqsave(&net_dev->pb->lock, flags);
Joe Perches475be4d2012-02-19 19:52:38 -08001627 mp = net_dev->pb;
1628 stats = &mp->stats;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001629 slot = lp->ppp_slot;
Eric Sesterhenn052bb882006-04-11 17:29:17 -07001630 if (slot < 0 || slot >= ISDN_MAX_CHANNELS) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001631 printk(KERN_ERR "%s: lp->ppp_slot(%d)\n",
Joe Perches475be4d2012-02-19 19:52:38 -08001632 __func__, lp->ppp_slot);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001633 stats->frame_drops++;
1634 dev_kfree_skb(skb);
1635 spin_unlock_irqrestore(&mp->lock, flags);
1636 return;
1637 }
1638 is = ippp_table[slot];
Joe Perches475be4d2012-02-19 19:52:38 -08001639 if (++mp->frames > stats->max_queue_len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001640 stats->max_queue_len = mp->frames;
Joe Perches475be4d2012-02-19 19:52:38 -08001641
Linus Torvalds1da177e2005-04-16 15:20:36 -07001642 if (is->debug & 0x8)
1643 isdn_ppp_mp_print_recv_pkt(lp->ppp_slot, skb);
1644
Joe Perches475be4d2012-02-19 19:52:38 -08001645 newseq = isdn_ppp_mp_get_seq(is->mpppcfg & SC_IN_SHORT_SEQ,
1646 skb, is->last_link_seqno);
David S. Millere29d4362009-11-15 22:23:47 -08001647
Linus Torvalds1da177e2005-04-16 15:20:36 -07001648
1649 /* if this packet seq # is less than last already processed one,
Joe Perches475be4d2012-02-19 19:52:38 -08001650 * toss it right away, but check for sequence start case first
Linus Torvalds1da177e2005-04-16 15:20:36 -07001651 */
Joe Perches475be4d2012-02-19 19:52:38 -08001652 if (mp->seq > MP_LONGSEQ_MAX && (newseq & MP_LONGSEQ_MAXBIT)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001653 mp->seq = newseq; /* the first packet: required for
1654 * rfc1990 non-compliant clients --
1655 * prevents constant packet toss */
Joe Perches475be4d2012-02-19 19:52:38 -08001656 } else if (MP_LT(newseq, mp->seq)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001657 stats->frame_drops++;
1658 isdn_ppp_mp_free_skb(mp, skb);
1659 spin_unlock_irqrestore(&mp->lock, flags);
1660 return;
1661 }
Joe Perches475be4d2012-02-19 19:52:38 -08001662
Linus Torvalds1da177e2005-04-16 15:20:36 -07001663 /* find the minimum received sequence number over all links */
1664 is->last_link_seqno = minseq = newseq;
1665 for (lpq = net_dev->queue;;) {
1666 slot = lpq->ppp_slot;
Eric Sesterhenn052bb882006-04-11 17:29:17 -07001667 if (slot < 0 || slot >= ISDN_MAX_CHANNELS) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001668 printk(KERN_ERR "%s: lpq->ppp_slot(%d)\n",
Joe Perches475be4d2012-02-19 19:52:38 -08001669 __func__, lpq->ppp_slot);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001670 } else {
1671 u32 lls = ippp_table[slot]->last_link_seqno;
1672 if (MP_LT(lls, minseq))
1673 minseq = lls;
1674 }
1675 if ((lpq = lpq->next) == net_dev->queue)
1676 break;
1677 }
1678 if (MP_LT(minseq, mp->seq))
1679 minseq = mp->seq; /* can't go beyond already processed
1680 * packets */
1681 newfrag = skb;
1682
Joe Perches475be4d2012-02-19 19:52:38 -08001683 /* if this new fragment is before the first one, then enqueue it now. */
1684 if ((frag = mp->frags) == NULL || MP_LT(newseq, MP_SEQ(frag))) {
David S. Millere29d4362009-11-15 22:23:47 -08001685 newfrag->next = frag;
Joe Perches475be4d2012-02-19 19:52:38 -08001686 mp->frags = frag = newfrag;
1687 newfrag = NULL;
1688 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001689
Joe Perches475be4d2012-02-19 19:52:38 -08001690 start = MP_FLAGS(frag) & MP_BEGIN_FRAG &&
1691 MP_SEQ(frag) == mp->seq ? frag : NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001692
Joe Perches475be4d2012-02-19 19:52:38 -08001693 /*
David S. Millere29d4362009-11-15 22:23:47 -08001694 * main fragment traversing loop
Linus Torvalds1da177e2005-04-16 15:20:36 -07001695 *
1696 * try to accomplish several tasks:
David S. Millere29d4362009-11-15 22:23:47 -08001697 * - insert new fragment into the proper sequence slot (once that's done
1698 * newfrag will be set to NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001699 * - reassemble any complete fragment sequence (non-null 'start'
André Goddard Rosaaf901ca2009-11-14 13:09:05 -02001700 * indicates there is a contiguous sequence present)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001701 * - discard any incomplete sequences that are below minseq -- due
1702 * to the fact that sender always increment sequence number, if there
1703 * is an incomplete sequence below minseq, no new fragments would
1704 * come to complete such sequence and it should be discarded
1705 *
1706 * loop completes when we accomplished the following tasks:
Joe Perches475be4d2012-02-19 19:52:38 -08001707 * - new fragment is inserted in the proper sequence ('newfrag' is
David S. Millere29d4362009-11-15 22:23:47 -08001708 * set to NULL)
Joe Perches475be4d2012-02-19 19:52:38 -08001709 * - we hit a gap in the sequence, so no reassembly/processing is
Linus Torvalds1da177e2005-04-16 15:20:36 -07001710 * possible ('start' would be set to NULL)
1711 *
Robert P. J. Dayd08df602007-02-17 19:07:33 +01001712 * algorithm for this code is derived from code in the book
Linus Torvalds1da177e2005-04-16 15:20:36 -07001713 * 'PPP Design And Debugging' by James Carlson (Addison-Wesley)
1714 */
Joe Perches475be4d2012-02-19 19:52:38 -08001715 while (start != NULL || newfrag != NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001716
Joe Perches475be4d2012-02-19 19:52:38 -08001717 thisseq = MP_SEQ(frag);
1718 nextf = frag->next;
David S. Millere29d4362009-11-15 22:23:47 -08001719
Joe Perches475be4d2012-02-19 19:52:38 -08001720 /* drop any duplicate fragments */
1721 if (newfrag != NULL && thisseq == newseq) {
1722 isdn_ppp_mp_free_skb(mp, newfrag);
1723 newfrag = NULL;
1724 }
David S. Millere29d4362009-11-15 22:23:47 -08001725
Joe Perches475be4d2012-02-19 19:52:38 -08001726 /* insert new fragment before next element if possible. */
1727 if (newfrag != NULL && (nextf == NULL ||
1728 MP_LT(newseq, MP_SEQ(nextf)))) {
1729 newfrag->next = nextf;
1730 frag->next = nextf = newfrag;
1731 newfrag = NULL;
1732 }
David S. Millere29d4362009-11-15 22:23:47 -08001733
Joe Perches475be4d2012-02-19 19:52:38 -08001734 if (start != NULL) {
1735 /* check for misplaced start */
1736 if (start != frag && (MP_FLAGS(frag) & MP_BEGIN_FRAG)) {
David S. Millere29d4362009-11-15 22:23:47 -08001737 printk(KERN_WARNING"isdn_mppp(seq %d): new "
Joe Perches475be4d2012-02-19 19:52:38 -08001738 "BEGIN flag with no prior END", thisseq);
David S. Millere29d4362009-11-15 22:23:47 -08001739 stats->seqerrs++;
1740 stats->frame_drops++;
Joe Perches475be4d2012-02-19 19:52:38 -08001741 start = isdn_ppp_mp_discard(mp, start, frag);
David S. Millere29d4362009-11-15 22:23:47 -08001742 nextf = frag->next;
Joe Perches475be4d2012-02-19 19:52:38 -08001743 }
1744 } else if (MP_LE(thisseq, minseq)) {
1745 if (MP_FLAGS(frag) & MP_BEGIN_FRAG)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001746 start = frag;
Joe Perches475be4d2012-02-19 19:52:38 -08001747 else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001748 if (MP_FLAGS(frag) & MP_END_FRAG)
Joe Perches475be4d2012-02-19 19:52:38 -08001749 stats->frame_drops++;
1750 if (mp->frags == frag)
1751 mp->frags = nextf;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001752 isdn_ppp_mp_free_skb(mp, frag);
David S. Millere29d4362009-11-15 22:23:47 -08001753 frag = nextf;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001754 continue;
Joe Perches475be4d2012-02-19 19:52:38 -08001755 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001756 }
Joe Perches475be4d2012-02-19 19:52:38 -08001757
David S. Millere29d4362009-11-15 22:23:47 -08001758 /* if start is non-null and we have end fragment, then
Joe Perches475be4d2012-02-19 19:52:38 -08001759 * we have full reassembly sequence -- reassemble
David S. Millere29d4362009-11-15 22:23:47 -08001760 * and process packet now
David S. Miller38783e62008-09-22 01:15:02 -07001761 */
Joe Perches475be4d2012-02-19 19:52:38 -08001762 if (start != NULL && (MP_FLAGS(frag) & MP_END_FRAG)) {
1763 minseq = mp->seq = (thisseq + 1) & MP_LONGSEQ_MASK;
1764 /* Reassemble the packet then dispatch it */
David S. Millere29d4362009-11-15 22:23:47 -08001765 isdn_ppp_mp_reassembly(net_dev, lp, start, nextf);
David S. Miller38783e62008-09-22 01:15:02 -07001766
Joe Perches475be4d2012-02-19 19:52:38 -08001767 start = NULL;
1768 frag = NULL;
1769
1770 mp->frags = nextf;
1771 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001772
1773 /* check if need to update start pointer: if we just
1774 * reassembled the packet and sequence is contiguous
1775 * then next fragment should be the start of new reassembly
1776 * if sequence is contiguous, but we haven't reassembled yet,
1777 * keep going.
Lucas De Marchi25985ed2011-03-30 22:57:33 -03001778 * if sequence is not contiguous, either clear everything
Linus Torvalds1da177e2005-04-16 15:20:36 -07001779 * below low watermark and set start to the next frag or
1780 * clear start ptr.
Joe Perches475be4d2012-02-19 19:52:38 -08001781 */
1782 if (nextf != NULL &&
1783 ((thisseq + 1) & MP_LONGSEQ_MASK) == MP_SEQ(nextf)) {
1784 /* if we just reassembled and the next one is here,
David S. Millere29d4362009-11-15 22:23:47 -08001785 * then start another reassembly. */
1786
Joe Perches475be4d2012-02-19 19:52:38 -08001787 if (frag == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001788 if (MP_FLAGS(nextf) & MP_BEGIN_FRAG)
Joe Perches475be4d2012-02-19 19:52:38 -08001789 start = nextf;
David S. Millere29d4362009-11-15 22:23:47 -08001790 else
1791 {
Joe Perches475be4d2012-02-19 19:52:38 -08001792 printk(KERN_WARNING"isdn_mppp(seq %d):"
1793 " END flag with no following "
1794 "BEGIN", thisseq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001795 stats->seqerrs++;
1796 }
1797 }
David S. Millere29d4362009-11-15 22:23:47 -08001798
Joe Perches475be4d2012-02-19 19:52:38 -08001799 } else {
1800 if (nextf != NULL && frag != NULL &&
1801 MP_LT(thisseq, minseq)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001802 /* we've got a break in the sequence
1803 * and we not at the end yet
1804 * and we did not just reassembled
1805 *(if we did, there wouldn't be anything before)
Joe Perches475be4d2012-02-19 19:52:38 -08001806 * and we below the low watermark
1807 * discard all the frames below low watermark
Linus Torvalds1da177e2005-04-16 15:20:36 -07001808 * and start over */
1809 stats->frame_drops++;
Joe Perches475be4d2012-02-19 19:52:38 -08001810 mp->frags = isdn_ppp_mp_discard(mp, start, nextf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001811 }
1812 /* break in the sequence, no reassembly */
Joe Perches475be4d2012-02-19 19:52:38 -08001813 start = NULL;
1814 }
1815
1816 frag = nextf;
1817 } /* while -- main loop */
1818
1819 if (mp->frags == NULL)
1820 mp->frags = frag;
1821
1822 /* rather straighforward way to deal with (not very) possible
David S. Millere29d4362009-11-15 22:23:47 -08001823 * queue overflow */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001824 if (mp->frames > MP_MAX_QUEUE_LEN) {
1825 stats->overflows++;
David S. Millere29d4362009-11-15 22:23:47 -08001826 while (mp->frames > MP_MAX_QUEUE_LEN) {
1827 frag = mp->frags->next;
1828 isdn_ppp_mp_free_skb(mp, mp->frags);
1829 mp->frags = frag;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001830 }
1831 }
1832 spin_unlock_irqrestore(&mp->lock, flags);
1833}
1834
Joe Perches475be4d2012-02-19 19:52:38 -08001835static void isdn_ppp_mp_cleanup(isdn_net_local *lp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001836{
Joe Perches475be4d2012-02-19 19:52:38 -08001837 struct sk_buff *frag = lp->netdev->pb->frags;
1838 struct sk_buff *nextfrag;
1839 while (frag) {
David S. Millere29d4362009-11-15 22:23:47 -08001840 nextfrag = frag->next;
1841 isdn_ppp_mp_free_skb(lp->netdev->pb, frag);
1842 frag = nextfrag;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001843 }
David S. Millere29d4362009-11-15 22:23:47 -08001844 lp->netdev->pb->frags = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001845}
1846
Joe Perches475be4d2012-02-19 19:52:38 -08001847static u32 isdn_ppp_mp_get_seq(int short_seq,
1848 struct sk_buff *skb, u32 last_seq)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001849{
1850 u32 seq;
1851 int flags = skb->data[0] & (MP_BEGIN_FRAG | MP_END_FRAG);
Joe Perches475be4d2012-02-19 19:52:38 -08001852
1853 if (!short_seq)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001854 {
Harvey Harrisonc19d0362008-11-20 04:10:51 -08001855 seq = ntohl(*(__be32 *)skb->data) & MP_LONGSEQ_MASK;
Joe Perches475be4d2012-02-19 19:52:38 -08001856 skb_push(skb, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001857 }
1858 else
1859 {
Joe Perches475be4d2012-02-19 19:52:38 -08001860 /* convert 12-bit short seq number to 24-bit long one
1861 */
Harvey Harrisonc19d0362008-11-20 04:10:51 -08001862 seq = ntohs(*(__be16 *)skb->data) & MP_SHORTSEQ_MASK;
Joe Perches475be4d2012-02-19 19:52:38 -08001863
Linus Torvalds1da177e2005-04-16 15:20:36 -07001864 /* check for seqence wrap */
Joe Perches475be4d2012-02-19 19:52:38 -08001865 if (!(seq & MP_SHORTSEQ_MAXBIT) &&
1866 (last_seq & MP_SHORTSEQ_MAXBIT) &&
1867 (unsigned long)last_seq <= MP_LONGSEQ_MAX)
1868 seq |= (last_seq + MP_SHORTSEQ_MAX + 1) &
1869 (~MP_SHORTSEQ_MASK & MP_LONGSEQ_MASK);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001870 else
1871 seq |= last_seq & (~MP_SHORTSEQ_MASK & MP_LONGSEQ_MASK);
Joe Perches475be4d2012-02-19 19:52:38 -08001872
Linus Torvalds1da177e2005-04-16 15:20:36 -07001873 skb_push(skb, 3); /* put converted seqence back in skb */
1874 }
Joe Perches475be4d2012-02-19 19:52:38 -08001875 *(u32 *)(skb->data + 1) = seq; /* put seqence back in _host_ byte
Linus Torvalds1da177e2005-04-16 15:20:36 -07001876 * order */
1877 skb->data[0] = flags; /* restore flags */
1878 return seq;
1879}
1880
Joe Perches475be4d2012-02-19 19:52:38 -08001881struct sk_buff *isdn_ppp_mp_discard(ippp_bundle *mp,
1882 struct sk_buff *from, struct sk_buff *to)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001883{
Joe Perches475be4d2012-02-19 19:52:38 -08001884 if (from)
David S. Millere29d4362009-11-15 22:23:47 -08001885 while (from != to) {
Joe Perches475be4d2012-02-19 19:52:38 -08001886 struct sk_buff *next = from->next;
David S. Millere29d4362009-11-15 22:23:47 -08001887 isdn_ppp_mp_free_skb(mp, from);
Joe Perches475be4d2012-02-19 19:52:38 -08001888 from = next;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001889 }
David S. Millere29d4362009-11-15 22:23:47 -08001890 return from;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001891}
1892
Joe Perches475be4d2012-02-19 19:52:38 -08001893void isdn_ppp_mp_reassembly(isdn_net_dev *net_dev, isdn_net_local *lp,
1894 struct sk_buff *from, struct sk_buff *to)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001895{
Joe Perches475be4d2012-02-19 19:52:38 -08001896 ippp_bundle *mp = net_dev->pb;
David S. Miller38783e62008-09-22 01:15:02 -07001897 int proto;
Joe Perches475be4d2012-02-19 19:52:38 -08001898 struct sk_buff *skb;
David S. Millere29d4362009-11-15 22:23:47 -08001899 unsigned int tot_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001900
1901 if (lp->ppp_slot < 0 || lp->ppp_slot >= ISDN_MAX_CHANNELS) {
1902 printk(KERN_ERR "%s: lp->ppp_slot(%d) out of range\n",
Joe Perches475be4d2012-02-19 19:52:38 -08001903 __func__, lp->ppp_slot);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001904 return;
1905 }
Joe Perches475be4d2012-02-19 19:52:38 -08001906 if (MP_FLAGS(from) == (MP_BEGIN_FRAG | MP_END_FRAG)) {
1907 if (ippp_table[lp->ppp_slot]->debug & 0x40)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001908 printk(KERN_DEBUG "isdn_mppp: reassembly: frame %d, "
Joe Perches475be4d2012-02-19 19:52:38 -08001909 "len %d\n", MP_SEQ(from), from->len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001910 skb = from;
1911 skb_pull(skb, MP_HEADER_LEN);
Joe Perches475be4d2012-02-19 19:52:38 -08001912 mp->frames--;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001913 } else {
Joe Perches475be4d2012-02-19 19:52:38 -08001914 struct sk_buff *frag;
David S. Millere29d4362009-11-15 22:23:47 -08001915 int n;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001916
Joe Perches475be4d2012-02-19 19:52:38 -08001917 for (tot_len = n = 0, frag = from; frag != to; frag = frag->next, n++)
David S. Millere29d4362009-11-15 22:23:47 -08001918 tot_len += frag->len - MP_HEADER_LEN;
1919
Joe Perches475be4d2012-02-19 19:52:38 -08001920 if (ippp_table[lp->ppp_slot]->debug & 0x40)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001921 printk(KERN_DEBUG"isdn_mppp: reassembling frames %d "
Joe Perches475be4d2012-02-19 19:52:38 -08001922 "to %d, len %d\n", MP_SEQ(from),
1923 (MP_SEQ(from) + n - 1) & MP_LONGSEQ_MASK, tot_len);
1924 if ((skb = dev_alloc_skb(tot_len)) == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001925 printk(KERN_ERR "isdn_mppp: cannot allocate sk buff "
Joe Perches475be4d2012-02-19 19:52:38 -08001926 "of size %d\n", tot_len);
David S. Millere29d4362009-11-15 22:23:47 -08001927 isdn_ppp_mp_discard(mp, from, to);
1928 return;
1929 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001930
Joe Perches475be4d2012-02-19 19:52:38 -08001931 while (from != to) {
David S. Millere29d4362009-11-15 22:23:47 -08001932 unsigned int len = from->len - MP_HEADER_LEN;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001933
David S. Millere29d4362009-11-15 22:23:47 -08001934 skb_copy_from_linear_data_offset(from, MP_HEADER_LEN,
Joe Perches475be4d2012-02-19 19:52:38 -08001935 skb_put(skb, len),
David S. Millere29d4362009-11-15 22:23:47 -08001936 len);
1937 frag = from->next;
1938 isdn_ppp_mp_free_skb(mp, from);
Joe Perches475be4d2012-02-19 19:52:38 -08001939 from = frag;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001940 }
1941 }
Joe Perches475be4d2012-02-19 19:52:38 -08001942 proto = isdn_ppp_strip_proto(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001943 isdn_ppp_push_higher(net_dev, lp, skb, proto);
1944}
1945
Joe Perches475be4d2012-02-19 19:52:38 -08001946static void isdn_ppp_mp_free_skb(ippp_bundle *mp, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001947{
1948 dev_kfree_skb(skb);
1949 mp->frames--;
1950}
1951
Joe Perches475be4d2012-02-19 19:52:38 -08001952static void isdn_ppp_mp_print_recv_pkt(int slot, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001953{
Joe Perches475be4d2012-02-19 19:52:38 -08001954 printk(KERN_DEBUG "mp_recv: %d/%d -> %02x %02x %02x %02x %02x %02x\n",
1955 slot, (int) skb->len,
1956 (int) skb->data[0], (int) skb->data[1], (int) skb->data[2],
1957 (int) skb->data[3], (int) skb->data[4], (int) skb->data[5]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001958}
1959
1960static int
1961isdn_ppp_bundle(struct ippp_struct *is, int unit)
1962{
1963 char ifn[IFNAMSIZ + 1];
1964 isdn_net_dev *p;
1965 isdn_net_local *lp, *nlp;
1966 int rc;
1967 unsigned long flags;
1968
1969 sprintf(ifn, "ippp%d", unit);
1970 p = isdn_net_findif(ifn);
1971 if (!p) {
1972 printk(KERN_ERR "ippp_bundle: cannot find %s\n", ifn);
1973 return -EINVAL;
1974 }
1975
Joe Perches475be4d2012-02-19 19:52:38 -08001976 spin_lock_irqsave(&p->pb->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001977
1978 nlp = is->lp;
1979 lp = p->queue;
Joe Perches475be4d2012-02-19 19:52:38 -08001980 if (nlp->ppp_slot < 0 || nlp->ppp_slot >= ISDN_MAX_CHANNELS ||
1981 lp->ppp_slot < 0 || lp->ppp_slot >= ISDN_MAX_CHANNELS) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001982 printk(KERN_ERR "ippp_bundle: binding to invalid slot %d\n",
Joe Perches475be4d2012-02-19 19:52:38 -08001983 nlp->ppp_slot < 0 || nlp->ppp_slot >= ISDN_MAX_CHANNELS ?
1984 nlp->ppp_slot : lp->ppp_slot);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001985 rc = -EINVAL;
1986 goto out;
Joe Perches475be4d2012-02-19 19:52:38 -08001987 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001988
1989 isdn_net_add_to_bundle(p, nlp);
1990
1991 ippp_table[nlp->ppp_slot]->unit = ippp_table[lp->ppp_slot]->unit;
1992
1993 /* maybe also SC_CCP stuff */
1994 ippp_table[nlp->ppp_slot]->pppcfg |= ippp_table[lp->ppp_slot]->pppcfg &
1995 (SC_ENABLE_IP | SC_NO_TCP_CCID | SC_REJ_COMP_TCP);
1996 ippp_table[nlp->ppp_slot]->mpppcfg |= ippp_table[lp->ppp_slot]->mpppcfg &
1997 (SC_MP_PROT | SC_REJ_MP_PROT | SC_OUT_SHORT_SEQ | SC_IN_SHORT_SEQ);
1998 rc = isdn_ppp_mp_init(nlp, p->pb);
1999out:
2000 spin_unlock_irqrestore(&p->pb->lock, flags);
2001 return rc;
2002}
Joe Perches475be4d2012-02-19 19:52:38 -08002003
Linus Torvalds1da177e2005-04-16 15:20:36 -07002004#endif /* CONFIG_ISDN_MPP */
Joe Perches475be4d2012-02-19 19:52:38 -08002005
Linus Torvalds1da177e2005-04-16 15:20:36 -07002006/*
2007 * network device ioctl handlers
2008 */
2009
2010static int
2011isdn_ppp_dev_ioctl_stats(int slot, struct ifreq *ifr, struct net_device *dev)
2012{
2013 struct ppp_stats __user *res = ifr->ifr_data;
2014 struct ppp_stats t;
Joe Perchesa17531f2010-11-15 11:12:24 +00002015 isdn_net_local *lp = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002016
2017 if (!access_ok(VERIFY_WRITE, res, sizeof(struct ppp_stats)))
2018 return -EFAULT;
2019
2020 /* build a temporary stat struct and copy it to user space */
2021
2022 memset(&t, 0, sizeof(struct ppp_stats));
2023 if (dev->flags & IFF_UP) {
2024 t.p.ppp_ipackets = lp->stats.rx_packets;
2025 t.p.ppp_ibytes = lp->stats.rx_bytes;
2026 t.p.ppp_ierrors = lp->stats.rx_errors;
2027 t.p.ppp_opackets = lp->stats.tx_packets;
2028 t.p.ppp_obytes = lp->stats.tx_bytes;
2029 t.p.ppp_oerrors = lp->stats.tx_errors;
2030#ifdef CONFIG_ISDN_PPP_VJ
2031 if (slot >= 0 && ippp_table[slot]->slcomp) {
2032 struct slcompress *slcomp = ippp_table[slot]->slcomp;
2033 t.vj.vjs_packets = slcomp->sls_o_compressed + slcomp->sls_o_uncompressed;
2034 t.vj.vjs_compressed = slcomp->sls_o_compressed;
2035 t.vj.vjs_searches = slcomp->sls_o_searches;
2036 t.vj.vjs_misses = slcomp->sls_o_misses;
2037 t.vj.vjs_errorin = slcomp->sls_i_error;
2038 t.vj.vjs_tossed = slcomp->sls_i_tossed;
2039 t.vj.vjs_uncompressedin = slcomp->sls_i_uncompressed;
2040 t.vj.vjs_compressedin = slcomp->sls_i_compressed;
2041 }
2042#endif
2043 }
2044 if (copy_to_user(res, &t, sizeof(struct ppp_stats)))
2045 return -EFAULT;
2046 return 0;
2047}
2048
2049int
2050isdn_ppp_dev_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
2051{
Joe Perches475be4d2012-02-19 19:52:38 -08002052 int error = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002053 int len;
Joe Perchesa17531f2010-11-15 11:12:24 +00002054 isdn_net_local *lp = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002055
2056
2057 if (lp->p_encap != ISDN_NET_ENCAP_SYNCPPP)
2058 return -EINVAL;
2059
2060 switch (cmd) {
2061#define PPP_VERSION "2.3.7"
Joe Perches475be4d2012-02-19 19:52:38 -08002062 case SIOCGPPPVER:
2063 len = strlen(PPP_VERSION) + 1;
2064 if (copy_to_user(ifr->ifr_data, PPP_VERSION, len))
2065 error = -EFAULT;
2066 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002067
Joe Perches475be4d2012-02-19 19:52:38 -08002068 case SIOCGPPPSTATS:
2069 error = isdn_ppp_dev_ioctl_stats(lp->ppp_slot, ifr, dev);
2070 break;
2071 default:
2072 error = -EINVAL;
2073 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002074 }
2075 return error;
2076}
2077
2078static int
2079isdn_ppp_if_get_unit(char *name)
2080{
2081 int len,
Joe Perches475be4d2012-02-19 19:52:38 -08002082 i,
2083 unit = 0,
2084 deci;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002085
2086 len = strlen(name);
2087
2088 if (strncmp("ippp", name, 4) || len > 8)
2089 return -1;
2090
2091 for (i = 0, deci = 1; i < len; i++, deci *= 10) {
2092 char a = name[len - i - 1];
2093 if (a >= '0' && a <= '9')
2094 unit += (a - '0') * deci;
2095 else
2096 break;
2097 }
2098 if (!i || len - i != 4)
2099 unit = -1;
2100
2101 return unit;
2102}
2103
2104
2105int
2106isdn_ppp_dial_slave(char *name)
2107{
2108#ifdef CONFIG_ISDN_MPP
2109 isdn_net_dev *ndev;
2110 isdn_net_local *lp;
2111 struct net_device *sdev;
2112
2113 if (!(ndev = isdn_net_findif(name)))
2114 return 1;
2115 lp = ndev->local;
2116 if (!(lp->flags & ISDN_NET_CONNECTED))
2117 return 5;
2118
2119 sdev = lp->slave;
2120 while (sdev) {
Joe Perchesa17531f2010-11-15 11:12:24 +00002121 isdn_net_local *mlp = netdev_priv(sdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002122 if (!(mlp->flags & ISDN_NET_CONNECTED))
2123 break;
2124 sdev = mlp->slave;
2125 }
2126 if (!sdev)
2127 return 2;
2128
Joe Perchesa17531f2010-11-15 11:12:24 +00002129 isdn_net_dial_req(netdev_priv(sdev));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002130 return 0;
2131#else
2132 return -1;
2133#endif
2134}
2135
2136int
2137isdn_ppp_hangup_slave(char *name)
2138{
2139#ifdef CONFIG_ISDN_MPP
2140 isdn_net_dev *ndev;
2141 isdn_net_local *lp;
2142 struct net_device *sdev;
2143
2144 if (!(ndev = isdn_net_findif(name)))
2145 return 1;
2146 lp = ndev->local;
2147 if (!(lp->flags & ISDN_NET_CONNECTED))
2148 return 5;
2149
2150 sdev = lp->slave;
2151 while (sdev) {
Joe Perchesa17531f2010-11-15 11:12:24 +00002152 isdn_net_local *mlp = netdev_priv(sdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002153
2154 if (mlp->slave) { /* find last connected link in chain */
Wang Chen838361f2008-12-03 15:49:46 -08002155 isdn_net_local *nlp = ISDN_SLAVE_PRIV(mlp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002156
2157 if (!(nlp->flags & ISDN_NET_CONNECTED))
2158 break;
2159 } else if (mlp->flags & ISDN_NET_CONNECTED)
2160 break;
Joe Perches475be4d2012-02-19 19:52:38 -08002161
Linus Torvalds1da177e2005-04-16 15:20:36 -07002162 sdev = mlp->slave;
2163 }
2164 if (!sdev)
2165 return 2;
2166
2167 isdn_net_hangup(sdev);
2168 return 0;
2169#else
2170 return -1;
2171#endif
2172}
2173
2174/*
2175 * PPP compression stuff
2176 */
2177
2178
2179/* Push an empty CCP Data Frame up to the daemon to wake it up and let it
2180 generate a CCP Reset-Request or tear down CCP altogether */
2181
2182static void isdn_ppp_ccp_kickup(struct ippp_struct *is)
2183{
2184 isdn_ppp_fill_rq(NULL, 0, PPP_COMP, is->lp->ppp_slot);
2185}
2186
2187/* In-kernel handling of CCP Reset-Request and Reset-Ack is necessary,
2188 but absolutely nontrivial. The most abstruse problem we are facing is
2189 that the generation, reception and all the handling of timeouts and
2190 resends including proper request id management should be entirely left
2191 to the (de)compressor, but indeed is not covered by the current API to
2192 the (de)compressor. The API is a prototype version from PPP where only
2193 some (de)compressors have yet been implemented and all of them are
2194 rather simple in their reset handling. Especially, their is only one
2195 outstanding ResetAck at a time with all of them and ResetReq/-Acks do
2196 not have parameters. For this very special case it was sufficient to
2197 just return an error code from the decompressor and have a single
2198 reset() entry to communicate all the necessary information between
2199 the framework and the (de)compressor. Bad enough, LZS is different
2200 (and any other compressor may be different, too). It has multiple
2201 histories (eventually) and needs to Reset each of them independently
2202 and thus uses multiple outstanding Acks and history numbers as an
2203 additional parameter to Reqs/Acks.
2204 All that makes it harder to port the reset state engine into the
2205 kernel because it is not just the same simple one as in (i)pppd but
2206 it must be able to pass additional parameters and have multiple out-
2207 standing Acks. We are trying to achieve the impossible by handling
2208 reset transactions independent by their id. The id MUST change when
2209 the data portion changes, thus any (de)compressor who uses more than
2210 one resettable state must provide and recognize individual ids for
2211 each individual reset transaction. The framework itself does _only_
2212 differentiate them by id, because it has no other semantics like the
2213 (de)compressor might.
2214 This looks like a major redesign of the interface would be nice,
2215 but I don't have an idea how to do it better. */
2216
2217/* Send a CCP Reset-Request or Reset-Ack directly from the kernel. This is
2218 getting that lengthy because there is no simple "send-this-frame-out"
2219 function above but every wrapper does a bit different. Hope I guess
2220 correct in this hack... */
2221
2222static void isdn_ppp_ccp_xmit_reset(struct ippp_struct *is, int proto,
2223 unsigned char code, unsigned char id,
2224 unsigned char *data, int len)
2225{
2226 struct sk_buff *skb;
2227 unsigned char *p;
2228 int hl;
2229 int cnt = 0;
2230 isdn_net_local *lp = is->lp;
2231
2232 /* Alloc large enough skb */
2233 hl = dev->drv[lp->isdn_device]->interface->hl_hdrlen;
Joe Perches475be4d2012-02-19 19:52:38 -08002234 skb = alloc_skb(len + hl + 16, GFP_ATOMIC);
2235 if (!skb) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002236 printk(KERN_WARNING
2237 "ippp: CCP cannot send reset - out of memory\n");
2238 return;
2239 }
2240 skb_reserve(skb, hl);
2241
2242 /* We may need to stuff an address and control field first */
Joe Perches475be4d2012-02-19 19:52:38 -08002243 if (!(is->pppcfg & SC_COMP_AC)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002244 p = skb_put(skb, 2);
2245 *p++ = 0xff;
2246 *p++ = 0x03;
2247 }
2248
2249 /* Stuff proto, code, id and length */
2250 p = skb_put(skb, 6);
2251 *p++ = (proto >> 8);
2252 *p++ = (proto & 0xff);
2253 *p++ = code;
2254 *p++ = id;
2255 cnt = 4 + len;
2256 *p++ = (cnt >> 8);
2257 *p++ = (cnt & 0xff);
2258
2259 /* Now stuff remaining bytes */
Joe Perches475be4d2012-02-19 19:52:38 -08002260 if (len) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002261 p = skb_put(skb, len);
2262 memcpy(p, data, len);
2263 }
2264
2265 /* skb is now ready for xmit */
2266 printk(KERN_DEBUG "Sending CCP Frame:\n");
Joe Perches475be4d2012-02-19 19:52:38 -08002267 isdn_ppp_frame_log("ccp-xmit", skb->data, skb->len, 32, is->unit, lp->ppp_slot);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002268
2269 isdn_net_write_super(lp, skb);
2270}
2271
2272/* Allocate the reset state vector */
2273static struct ippp_ccp_reset *isdn_ppp_ccp_reset_alloc(struct ippp_struct *is)
2274{
2275 struct ippp_ccp_reset *r;
Burman Yan41f96932006-12-08 02:39:35 -08002276 r = kzalloc(sizeof(struct ippp_ccp_reset), GFP_KERNEL);
Joe Perches475be4d2012-02-19 19:52:38 -08002277 if (!r) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002278 printk(KERN_ERR "ippp_ccp: failed to allocate reset data"
2279 " structure - no mem\n");
2280 return NULL;
2281 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002282 printk(KERN_DEBUG "ippp_ccp: allocated reset data structure %p\n", r);
2283 is->reset = r;
2284 return r;
2285}
2286
2287/* Destroy the reset state vector. Kill all pending timers first. */
2288static void isdn_ppp_ccp_reset_free(struct ippp_struct *is)
2289{
2290 unsigned int id;
2291
2292 printk(KERN_DEBUG "ippp_ccp: freeing reset data structure %p\n",
2293 is->reset);
Joe Perches475be4d2012-02-19 19:52:38 -08002294 for (id = 0; id < 256; id++) {
2295 if (is->reset->rs[id]) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002296 isdn_ppp_ccp_reset_free_state(is, (unsigned char)id);
2297 }
2298 }
2299 kfree(is->reset);
2300 is->reset = NULL;
2301}
2302
2303/* Free a given state and clear everything up for later reallocation */
2304static void isdn_ppp_ccp_reset_free_state(struct ippp_struct *is,
2305 unsigned char id)
2306{
2307 struct ippp_ccp_reset_state *rs;
2308
Joe Perches475be4d2012-02-19 19:52:38 -08002309 if (is->reset->rs[id]) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002310 printk(KERN_DEBUG "ippp_ccp: freeing state for id %d\n", id);
2311 rs = is->reset->rs[id];
2312 /* Make sure the kernel will not call back later */
Joe Perches475be4d2012-02-19 19:52:38 -08002313 if (rs->ta)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002314 del_timer(&rs->timer);
2315 is->reset->rs[id] = NULL;
2316 kfree(rs);
2317 } else {
2318 printk(KERN_WARNING "ippp_ccp: id %d is not allocated\n", id);
2319 }
2320}
2321
2322/* The timer callback function which is called when a ResetReq has timed out,
2323 aka has never been answered by a ResetAck */
2324static void isdn_ppp_ccp_timer_callback(unsigned long closure)
2325{
2326 struct ippp_ccp_reset_state *rs =
2327 (struct ippp_ccp_reset_state *)closure;
2328
Joe Perches475be4d2012-02-19 19:52:38 -08002329 if (!rs) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002330 printk(KERN_ERR "ippp_ccp: timer cb with zero closure.\n");
2331 return;
2332 }
Joe Perches475be4d2012-02-19 19:52:38 -08002333 if (rs->ta && rs->state == CCPResetSentReq) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002334 /* We are correct here */
Joe Perches475be4d2012-02-19 19:52:38 -08002335 if (!rs->expra) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002336 /* Hmm, there is no Ack really expected. We can clean
2337 up the state now, it will be reallocated if the
2338 decompressor insists on another reset */
2339 rs->ta = 0;
2340 isdn_ppp_ccp_reset_free_state(rs->is, rs->id);
2341 return;
2342 }
2343 printk(KERN_DEBUG "ippp_ccp: CCP Reset timed out for id %d\n",
2344 rs->id);
2345 /* Push it again */
2346 isdn_ppp_ccp_xmit_reset(rs->is, PPP_CCP, CCP_RESETREQ, rs->id,
2347 rs->data, rs->dlen);
2348 /* Restart timer */
Joe Perches475be4d2012-02-19 19:52:38 -08002349 rs->timer.expires = jiffies + HZ * 5;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002350 add_timer(&rs->timer);
2351 } else {
2352 printk(KERN_WARNING "ippp_ccp: timer cb in wrong state %d\n",
2353 rs->state);
2354 }
2355}
2356
2357/* Allocate a new reset transaction state */
2358static struct ippp_ccp_reset_state *isdn_ppp_ccp_reset_alloc_state(struct ippp_struct *is,
Joe Perches475be4d2012-02-19 19:52:38 -08002359 unsigned char id)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002360{
2361 struct ippp_ccp_reset_state *rs;
Joe Perches475be4d2012-02-19 19:52:38 -08002362 if (is->reset->rs[id]) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002363 printk(KERN_WARNING "ippp_ccp: old state exists for id %d\n",
2364 id);
2365 return NULL;
2366 } else {
Burman Yan41f96932006-12-08 02:39:35 -08002367 rs = kzalloc(sizeof(struct ippp_ccp_reset_state), GFP_KERNEL);
Joe Perches475be4d2012-02-19 19:52:38 -08002368 if (!rs)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002369 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002370 rs->state = CCPResetIdle;
2371 rs->is = is;
2372 rs->id = id;
Marcel Holtmanndab6df62006-12-21 23:06:24 +01002373 init_timer(&rs->timer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002374 rs->timer.data = (unsigned long)rs;
2375 rs->timer.function = isdn_ppp_ccp_timer_callback;
2376 is->reset->rs[id] = rs;
2377 }
2378 return rs;
2379}
2380
2381
2382/* A decompressor wants a reset with a set of parameters - do what is
2383 necessary to fulfill it */
2384static void isdn_ppp_ccp_reset_trans(struct ippp_struct *is,
2385 struct isdn_ppp_resetparams *rp)
2386{
2387 struct ippp_ccp_reset_state *rs;
2388
Joe Perches475be4d2012-02-19 19:52:38 -08002389 if (rp->valid) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002390 /* The decompressor defines parameters by itself */
Joe Perches475be4d2012-02-19 19:52:38 -08002391 if (rp->rsend) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002392 /* And he wants us to send a request */
Joe Perches475be4d2012-02-19 19:52:38 -08002393 if (!(rp->idval)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002394 printk(KERN_ERR "ippp_ccp: decompressor must"
2395 " specify reset id\n");
2396 return;
2397 }
Joe Perches475be4d2012-02-19 19:52:38 -08002398 if (is->reset->rs[rp->id]) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002399 /* There is already a transaction in existence
2400 for this id. May be still waiting for a
2401 Ack or may be wrong. */
2402 rs = is->reset->rs[rp->id];
Joe Perches475be4d2012-02-19 19:52:38 -08002403 if (rs->state == CCPResetSentReq && rs->ta) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002404 printk(KERN_DEBUG "ippp_ccp: reset"
2405 " trans still in progress"
2406 " for id %d\n", rp->id);
2407 } else {
2408 printk(KERN_WARNING "ippp_ccp: reset"
2409 " trans in wrong state %d for"
2410 " id %d\n", rs->state, rp->id);
2411 }
2412 } else {
2413 /* Ok, this is a new transaction */
2414 printk(KERN_DEBUG "ippp_ccp: new trans for id"
2415 " %d to be started\n", rp->id);
2416 rs = isdn_ppp_ccp_reset_alloc_state(is, rp->id);
Joe Perches475be4d2012-02-19 19:52:38 -08002417 if (!rs) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002418 printk(KERN_ERR "ippp_ccp: out of mem"
2419 " allocing ccp trans\n");
2420 return;
2421 }
2422 rs->state = CCPResetSentReq;
2423 rs->expra = rp->expra;
Joe Perches475be4d2012-02-19 19:52:38 -08002424 if (rp->dtval) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002425 rs->dlen = rp->dlen;
2426 memcpy(rs->data, rp->data, rp->dlen);
2427 }
2428 /* HACK TODO - add link comp here */
2429 isdn_ppp_ccp_xmit_reset(is, PPP_CCP,
2430 CCP_RESETREQ, rs->id,
2431 rs->data, rs->dlen);
2432 /* Start the timer */
Joe Perches475be4d2012-02-19 19:52:38 -08002433 rs->timer.expires = jiffies + 5 * HZ;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002434 add_timer(&rs->timer);
2435 rs->ta = 1;
2436 }
2437 } else {
2438 printk(KERN_DEBUG "ippp_ccp: no reset sent\n");
2439 }
2440 } else {
2441 /* The reset params are invalid. The decompressor does not
2442 care about them, so we just send the minimal requests
2443 and increase ids only when an Ack is received for a
2444 given id */
Joe Perches475be4d2012-02-19 19:52:38 -08002445 if (is->reset->rs[is->reset->lastid]) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002446 /* There is already a transaction in existence
2447 for this id. May be still waiting for a
2448 Ack or may be wrong. */
2449 rs = is->reset->rs[is->reset->lastid];
Joe Perches475be4d2012-02-19 19:52:38 -08002450 if (rs->state == CCPResetSentReq && rs->ta) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002451 printk(KERN_DEBUG "ippp_ccp: reset"
2452 " trans still in progress"
2453 " for id %d\n", rp->id);
2454 } else {
2455 printk(KERN_WARNING "ippp_ccp: reset"
2456 " trans in wrong state %d for"
2457 " id %d\n", rs->state, rp->id);
2458 }
2459 } else {
2460 printk(KERN_DEBUG "ippp_ccp: new trans for id"
2461 " %d to be started\n", is->reset->lastid);
2462 rs = isdn_ppp_ccp_reset_alloc_state(is,
2463 is->reset->lastid);
Joe Perches475be4d2012-02-19 19:52:38 -08002464 if (!rs) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002465 printk(KERN_ERR "ippp_ccp: out of mem"
2466 " allocing ccp trans\n");
2467 return;
2468 }
2469 rs->state = CCPResetSentReq;
2470 /* We always expect an Ack if the decompressor doesn't
2471 know better */
2472 rs->expra = 1;
2473 rs->dlen = 0;
2474 /* HACK TODO - add link comp here */
2475 isdn_ppp_ccp_xmit_reset(is, PPP_CCP, CCP_RESETREQ,
2476 rs->id, NULL, 0);
2477 /* Start the timer */
Joe Perches475be4d2012-02-19 19:52:38 -08002478 rs->timer.expires = jiffies + 5 * HZ;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002479 add_timer(&rs->timer);
2480 rs->ta = 1;
2481 }
2482 }
2483}
2484
2485/* An Ack was received for this id. This means we stop the timer and clean
2486 up the state prior to calling the decompressors reset routine. */
2487static void isdn_ppp_ccp_reset_ack_rcvd(struct ippp_struct *is,
2488 unsigned char id)
2489{
2490 struct ippp_ccp_reset_state *rs = is->reset->rs[id];
2491
Joe Perches475be4d2012-02-19 19:52:38 -08002492 if (rs) {
2493 if (rs->ta && rs->state == CCPResetSentReq) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002494 /* Great, we are correct */
Joe Perches475be4d2012-02-19 19:52:38 -08002495 if (!rs->expra)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002496 printk(KERN_DEBUG "ippp_ccp: ResetAck received"
2497 " for id %d but not expected\n", id);
2498 } else {
2499 printk(KERN_INFO "ippp_ccp: ResetAck received out of"
2500 "sync for id %d\n", id);
2501 }
Joe Perches475be4d2012-02-19 19:52:38 -08002502 if (rs->ta) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002503 rs->ta = 0;
2504 del_timer(&rs->timer);
2505 }
2506 isdn_ppp_ccp_reset_free_state(is, id);
2507 } else {
2508 printk(KERN_INFO "ippp_ccp: ResetAck received for unknown id"
2509 " %d\n", id);
2510 }
2511 /* Make sure the simple reset stuff uses a new id next time */
2512 is->reset->lastid++;
2513}
2514
Joe Perches475be4d2012-02-19 19:52:38 -08002515/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002516 * decompress packet
2517 *
2518 * if master = 0, we're trying to uncompress an per-link compressed packet,
2519 * as opposed to an compressed reconstructed-from-MPPP packet.
2520 * proto is updated to protocol field of uncompressed packet.
2521 *
2522 * retval: decompressed packet,
2523 * same packet if uncompressed,
2524 * NULL if decompression error
2525 */
2526
Joe Perches475be4d2012-02-19 19:52:38 -08002527static struct sk_buff *isdn_ppp_decompress(struct sk_buff *skb, struct ippp_struct *is, struct ippp_struct *master,
2528 int *proto)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002529{
2530 void *stat = NULL;
2531 struct isdn_ppp_compressor *ipc = NULL;
2532 struct sk_buff *skb_out;
2533 int len;
2534 struct ippp_struct *ri;
2535 struct isdn_ppp_resetparams rsparm;
2536 unsigned char rsdata[IPPP_RESET_MAXDATABYTES];
2537
Joe Perches475be4d2012-02-19 19:52:38 -08002538 if (!master) {
2539 // per-link decompression
Linus Torvalds1da177e2005-04-16 15:20:36 -07002540 stat = is->link_decomp_stat;
2541 ipc = is->link_decompressor;
2542 ri = is;
2543 } else {
2544 stat = master->decomp_stat;
2545 ipc = master->decompressor;
2546 ri = master;
2547 }
2548
2549 if (!ipc) {
2550 // no decompressor -> we can't decompress.
2551 printk(KERN_DEBUG "ippp: no decompressor defined!\n");
2552 return skb;
2553 }
Eric Sesterhenn6dd44a72006-03-26 18:19:26 +02002554 BUG_ON(!stat); // if we have a compressor, stat has been set as well
Linus Torvalds1da177e2005-04-16 15:20:36 -07002555
Joe Perches475be4d2012-02-19 19:52:38 -08002556 if ((master && *proto == PPP_COMP) || (!master && *proto == PPP_COMPFRAG)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002557 // compressed packets are compressed by their protocol type
2558
2559 // Set up reset params for the decompressor
Joe Perches475be4d2012-02-19 19:52:38 -08002560 memset(&rsparm, 0, sizeof(rsparm));
2561 rsparm.data = rsdata;
2562 rsparm.maxdlen = IPPP_RESET_MAXDATABYTES;
2563
2564 skb_out = dev_alloc_skb(is->mru + PPP_HDRLEN);
2565 if (!skb_out) {
2566 kfree_skb(skb);
2567 printk(KERN_ERR "ippp: decomp memory allocation failure\n");
Jesper Juhlf6e2cdc2006-12-08 02:39:34 -08002568 return NULL;
Joe Perches475be4d2012-02-19 19:52:38 -08002569 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002570 len = ipc->decompress(stat, skb, skb_out, &rsparm);
2571 kfree_skb(skb);
2572 if (len <= 0) {
Joe Perches475be4d2012-02-19 19:52:38 -08002573 switch (len) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002574 case DECOMP_ERROR:
2575 printk(KERN_INFO "ippp: decomp wants reset %s params\n",
2576 rsparm.valid ? "with" : "without");
Joe Perches475be4d2012-02-19 19:52:38 -08002577
Linus Torvalds1da177e2005-04-16 15:20:36 -07002578 isdn_ppp_ccp_reset_trans(ri, &rsparm);
2579 break;
2580 case DECOMP_FATALERROR:
2581 ri->pppcfg |= SC_DC_FERROR;
2582 /* Kick ipppd to recognize the error */
2583 isdn_ppp_ccp_kickup(ri);
2584 break;
2585 }
2586 kfree_skb(skb_out);
2587 return NULL;
2588 }
2589 *proto = isdn_ppp_strip_proto(skb_out);
2590 if (*proto < 0) {
2591 kfree_skb(skb_out);
2592 return NULL;
2593 }
2594 return skb_out;
Joe Perches475be4d2012-02-19 19:52:38 -08002595 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002596 // uncompressed packets are fed through the decompressor to
2597 // update the decompressor state
2598 ipc->incomp(stat, skb, *proto);
2599 return skb;
2600 }
2601}
2602
2603/*
Joe Perches475be4d2012-02-19 19:52:38 -08002604 * compress a frame
Linus Torvalds1da177e2005-04-16 15:20:36 -07002605 * type=0: normal/bundle compression
2606 * =1: link compression
2607 * returns original skb if we haven't compressed the frame
2608 * and a new skb pointer if we've done it
2609 */
Joe Perches475be4d2012-02-19 19:52:38 -08002610static struct sk_buff *isdn_ppp_compress(struct sk_buff *skb_in, int *proto,
2611 struct ippp_struct *is, struct ippp_struct *master, int type)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002612{
Joe Perches475be4d2012-02-19 19:52:38 -08002613 int ret;
2614 int new_proto;
2615 struct isdn_ppp_compressor *compressor;
2616 void *stat;
2617 struct sk_buff *skb_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002618
2619 /* we do not compress control protocols */
Joe Perches475be4d2012-02-19 19:52:38 -08002620 if (*proto < 0 || *proto > 0x3fff) {
2621 return skb_in;
2622 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002623
Joe Perches475be4d2012-02-19 19:52:38 -08002624 if (type) { /* type=1 => Link compression */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002625 return skb_in;
2626 }
2627 else {
Joe Perches475be4d2012-02-19 19:52:38 -08002628 if (!master) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002629 compressor = is->compressor;
2630 stat = is->comp_stat;
2631 }
2632 else {
2633 compressor = master->compressor;
2634 stat = master->comp_stat;
2635 }
2636 new_proto = PPP_COMP;
2637 }
2638
Joe Perches475be4d2012-02-19 19:52:38 -08002639 if (!compressor) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002640 printk(KERN_ERR "isdn_ppp: No compressor set!\n");
2641 return skb_in;
2642 }
Joe Perches475be4d2012-02-19 19:52:38 -08002643 if (!stat) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002644 printk(KERN_ERR "isdn_ppp: Compressor not initialized?\n");
2645 return skb_in;
2646 }
2647
2648 /* Allow for at least 150 % expansion (for now) */
Joe Perches475be4d2012-02-19 19:52:38 -08002649 skb_out = alloc_skb(skb_in->len + skb_in->len / 2 + 32 +
2650 skb_headroom(skb_in), GFP_ATOMIC);
2651 if (!skb_out)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002652 return skb_in;
2653 skb_reserve(skb_out, skb_headroom(skb_in));
2654
Joe Perches475be4d2012-02-19 19:52:38 -08002655 ret = (compressor->compress)(stat, skb_in, skb_out, *proto);
2656 if (!ret) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002657 dev_kfree_skb(skb_out);
2658 return skb_in;
2659 }
Joe Perches475be4d2012-02-19 19:52:38 -08002660
Linus Torvalds1da177e2005-04-16 15:20:36 -07002661 dev_kfree_skb(skb_in);
2662 *proto = new_proto;
2663 return skb_out;
2664}
2665
2666/*
Joe Perches475be4d2012-02-19 19:52:38 -08002667 * we received a CCP frame ..
Linus Torvalds1da177e2005-04-16 15:20:36 -07002668 * not a clean solution, but we MUST handle a few cases in the kernel
2669 */
2670static void isdn_ppp_receive_ccp(isdn_net_dev *net_dev, isdn_net_local *lp,
Joe Perches475be4d2012-02-19 19:52:38 -08002671 struct sk_buff *skb, int proto)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002672{
2673 struct ippp_struct *is;
2674 struct ippp_struct *mis;
2675 int len;
2676 struct isdn_ppp_resetparams rsparm;
Joe Perches475be4d2012-02-19 19:52:38 -08002677 unsigned char rsdata[IPPP_RESET_MAXDATABYTES];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002678
2679 printk(KERN_DEBUG "Received CCP frame from peer slot(%d)\n",
Joe Perches475be4d2012-02-19 19:52:38 -08002680 lp->ppp_slot);
Eric Sesterhenn052bb882006-04-11 17:29:17 -07002681 if (lp->ppp_slot < 0 || lp->ppp_slot >= ISDN_MAX_CHANNELS) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002682 printk(KERN_ERR "%s: lp->ppp_slot(%d) out of range\n",
Joe Perches475be4d2012-02-19 19:52:38 -08002683 __func__, lp->ppp_slot);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002684 return;
2685 }
2686 is = ippp_table[lp->ppp_slot];
Joe Perches475be4d2012-02-19 19:52:38 -08002687 isdn_ppp_frame_log("ccp-rcv", skb->data, skb->len, 32, is->unit, lp->ppp_slot);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002688
Joe Perches475be4d2012-02-19 19:52:38 -08002689 if (lp->master) {
Wang Chen838361f2008-12-03 15:49:46 -08002690 int slot = ISDN_MASTER_PRIV(lp)->ppp_slot;
Eric Sesterhenn052bb882006-04-11 17:29:17 -07002691 if (slot < 0 || slot >= ISDN_MAX_CHANNELS) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002692 printk(KERN_ERR "%s: slot(%d) out of range\n",
Joe Perches475be4d2012-02-19 19:52:38 -08002693 __func__, slot);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002694 return;
Joe Perches475be4d2012-02-19 19:52:38 -08002695 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002696 mis = ippp_table[slot];
2697 } else
2698 mis = is;
2699
Joe Perches475be4d2012-02-19 19:52:38 -08002700 switch (skb->data[0]) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002701 case CCP_CONFREQ:
Joe Perches475be4d2012-02-19 19:52:38 -08002702 if (is->debug & 0x10)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002703 printk(KERN_DEBUG "Disable compression here!\n");
Joe Perches475be4d2012-02-19 19:52:38 -08002704 if (proto == PPP_CCP)
2705 mis->compflags &= ~SC_COMP_ON;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002706 else
Joe Perches475be4d2012-02-19 19:52:38 -08002707 is->compflags &= ~SC_LINK_COMP_ON;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002708 break;
2709 case CCP_TERMREQ:
2710 case CCP_TERMACK:
Joe Perches475be4d2012-02-19 19:52:38 -08002711 if (is->debug & 0x10)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002712 printk(KERN_DEBUG "Disable (de)compression here!\n");
Joe Perches475be4d2012-02-19 19:52:38 -08002713 if (proto == PPP_CCP)
2714 mis->compflags &= ~(SC_DECOMP_ON | SC_COMP_ON);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002715 else
Joe Perches475be4d2012-02-19 19:52:38 -08002716 is->compflags &= ~(SC_LINK_DECOMP_ON | SC_LINK_COMP_ON);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002717 break;
2718 case CCP_CONFACK:
2719 /* if we RECEIVE an ackowledge we enable the decompressor */
Joe Perches475be4d2012-02-19 19:52:38 -08002720 if (is->debug & 0x10)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002721 printk(KERN_DEBUG "Enable decompression here!\n");
Joe Perches475be4d2012-02-19 19:52:38 -08002722 if (proto == PPP_CCP) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002723 if (!mis->decompressor)
2724 break;
2725 mis->compflags |= SC_DECOMP_ON;
2726 } else {
2727 if (!is->decompressor)
2728 break;
2729 is->compflags |= SC_LINK_DECOMP_ON;
2730 }
2731 break;
2732
2733 case CCP_RESETACK:
2734 printk(KERN_DEBUG "Received ResetAck from peer\n");
2735 len = (skb->data[2] << 8) | skb->data[3];
2736 len -= 4;
2737
Joe Perches475be4d2012-02-19 19:52:38 -08002738 if (proto == PPP_CCP) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002739 /* If a reset Ack was outstanding for this id, then
2740 clean up the state engine */
2741 isdn_ppp_ccp_reset_ack_rcvd(mis, skb->data[1]);
Joe Perches475be4d2012-02-19 19:52:38 -08002742 if (mis->decompressor && mis->decomp_stat)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002743 mis->decompressor->
2744 reset(mis->decomp_stat,
2745 skb->data[0],
2746 skb->data[1],
2747 len ? &skb->data[4] : NULL,
2748 len, NULL);
2749 /* TODO: This is not easy to decide here */
2750 mis->compflags &= ~SC_DECOMP_DISCARD;
2751 }
2752 else {
2753 isdn_ppp_ccp_reset_ack_rcvd(is, skb->data[1]);
Joe Perches475be4d2012-02-19 19:52:38 -08002754 if (is->link_decompressor && is->link_decomp_stat)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002755 is->link_decompressor->
2756 reset(is->link_decomp_stat,
2757 skb->data[0],
2758 skb->data[1],
2759 len ? &skb->data[4] : NULL,
2760 len, NULL);
2761 /* TODO: neither here */
2762 is->compflags &= ~SC_LINK_DECOMP_DISCARD;
2763 }
2764 break;
2765
2766 case CCP_RESETREQ:
2767 printk(KERN_DEBUG "Received ResetReq from peer\n");
2768 /* Receiving a ResetReq means we must reset our compressor */
2769 /* Set up reset params for the reset entry */
2770 memset(&rsparm, 0, sizeof(rsparm));
2771 rsparm.data = rsdata;
Joe Perches475be4d2012-02-19 19:52:38 -08002772 rsparm.maxdlen = IPPP_RESET_MAXDATABYTES;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002773 /* Isolate data length */
2774 len = (skb->data[2] << 8) | skb->data[3];
2775 len -= 4;
Joe Perches475be4d2012-02-19 19:52:38 -08002776 if (proto == PPP_CCP) {
2777 if (mis->compressor && mis->comp_stat)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002778 mis->compressor->
2779 reset(mis->comp_stat,
2780 skb->data[0],
2781 skb->data[1],
2782 len ? &skb->data[4] : NULL,
2783 len, &rsparm);
2784 }
2785 else {
Joe Perches475be4d2012-02-19 19:52:38 -08002786 if (is->link_compressor && is->link_comp_stat)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002787 is->link_compressor->
2788 reset(is->link_comp_stat,
2789 skb->data[0],
2790 skb->data[1],
2791 len ? &skb->data[4] : NULL,
2792 len, &rsparm);
2793 }
2794 /* Ack the Req as specified by rsparm */
Joe Perches475be4d2012-02-19 19:52:38 -08002795 if (rsparm.valid) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002796 /* Compressor reset handler decided how to answer */
Joe Perches475be4d2012-02-19 19:52:38 -08002797 if (rsparm.rsend) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002798 /* We should send a Frame */
2799 isdn_ppp_ccp_xmit_reset(is, proto, CCP_RESETACK,
2800 rsparm.idval ? rsparm.id
2801 : skb->data[1],
2802 rsparm.dtval ?
2803 rsparm.data : NULL,
2804 rsparm.dtval ?
2805 rsparm.dlen : 0);
2806 } else {
2807 printk(KERN_DEBUG "ResetAck suppressed\n");
2808 }
2809 } else {
2810 /* We answer with a straight reflected Ack */
2811 isdn_ppp_ccp_xmit_reset(is, proto, CCP_RESETACK,
2812 skb->data[1],
2813 len ? &skb->data[4] : NULL,
2814 len);
2815 }
2816 break;
2817 }
2818}
2819
2820
2821/*
2822 * Daemon sends a CCP frame ...
2823 */
2824
2825/* TODO: Clean this up with new Reset semantics */
2826
2827/* I believe the CCP handling as-is is done wrong. Compressed frames
2828 * should only be sent/received after CCP reaches UP state, which means
2829 * both sides have sent CONF_ACK. Currently, we handle both directions
2830 * independently, which means we may accept compressed frames too early
2831 * (supposedly not a problem), but may also mean we send compressed frames
2832 * too early, which may turn out to be a problem.
2833 * This part of state machine should actually be handled by (i)pppd, but
2834 * that's too big of a change now. --kai
2835 */
2836
2837/* Actually, we might turn this into an advantage: deal with the RFC in
2838 * the old tradition of beeing generous on what we accept, but beeing
2839 * strict on what we send. Thus we should just
2840 * - accept compressed frames as soon as decompression is negotiated
2841 * - send compressed frames only when decomp *and* comp are negotiated
2842 * - drop rx compressed frames if we cannot decomp (instead of pushing them
2843 * up to ipppd)
2844 * and I tried to modify this file according to that. --abp
2845 */
2846
2847static void isdn_ppp_send_ccp(isdn_net_dev *net_dev, isdn_net_local *lp, struct sk_buff *skb)
2848{
Joe Perches475be4d2012-02-19 19:52:38 -08002849 struct ippp_struct *mis, *is;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002850 int proto, slot = lp->ppp_slot;
2851 unsigned char *data;
2852
Joe Perches475be4d2012-02-19 19:52:38 -08002853 if (!skb || skb->len < 3)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002854 return;
2855 if (slot < 0 || slot >= ISDN_MAX_CHANNELS) {
2856 printk(KERN_ERR "%s: lp->ppp_slot(%d) out of range\n",
Joe Perches475be4d2012-02-19 19:52:38 -08002857 __func__, slot);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002858 return;
Joe Perches475be4d2012-02-19 19:52:38 -08002859 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002860 is = ippp_table[slot];
2861 /* Daemon may send with or without address and control field comp */
2862 data = skb->data;
Joe Perches475be4d2012-02-19 19:52:38 -08002863 if (!(is->pppcfg & SC_COMP_AC) && data[0] == 0xff && data[1] == 0x03) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002864 data += 2;
Joe Perches475be4d2012-02-19 19:52:38 -08002865 if (skb->len < 5)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002866 return;
2867 }
2868
Joe Perches475be4d2012-02-19 19:52:38 -08002869 proto = ((int)data[0]<<8) + data[1];
2870 if (proto != PPP_CCP && proto != PPP_CCPFRAG)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002871 return;
2872
2873 printk(KERN_DEBUG "Received CCP frame from daemon:\n");
Joe Perches475be4d2012-02-19 19:52:38 -08002874 isdn_ppp_frame_log("ccp-xmit", skb->data, skb->len, 32, is->unit, lp->ppp_slot);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002875
2876 if (lp->master) {
Wang Chen838361f2008-12-03 15:49:46 -08002877 slot = ISDN_MASTER_PRIV(lp)->ppp_slot;
Eric Sesterhenn052bb882006-04-11 17:29:17 -07002878 if (slot < 0 || slot >= ISDN_MAX_CHANNELS) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002879 printk(KERN_ERR "%s: slot(%d) out of range\n",
Joe Perches475be4d2012-02-19 19:52:38 -08002880 __func__, slot);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002881 return;
Joe Perches475be4d2012-02-19 19:52:38 -08002882 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002883 mis = ippp_table[slot];
2884 } else
2885 mis = is;
2886 if (mis != is)
2887 printk(KERN_DEBUG "isdn_ppp: Ouch! Master CCP sends on slave slot!\n");
Joe Perches475be4d2012-02-19 19:52:38 -08002888
2889 switch (data[2]) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002890 case CCP_CONFREQ:
Joe Perches475be4d2012-02-19 19:52:38 -08002891 if (is->debug & 0x10)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002892 printk(KERN_DEBUG "Disable decompression here!\n");
Joe Perches475be4d2012-02-19 19:52:38 -08002893 if (proto == PPP_CCP)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002894 is->compflags &= ~SC_DECOMP_ON;
2895 else
2896 is->compflags &= ~SC_LINK_DECOMP_ON;
2897 break;
2898 case CCP_TERMREQ:
2899 case CCP_TERMACK:
Joe Perches475be4d2012-02-19 19:52:38 -08002900 if (is->debug & 0x10)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002901 printk(KERN_DEBUG "Disable (de)compression here!\n");
Joe Perches475be4d2012-02-19 19:52:38 -08002902 if (proto == PPP_CCP)
2903 is->compflags &= ~(SC_DECOMP_ON | SC_COMP_ON);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002904 else
Joe Perches475be4d2012-02-19 19:52:38 -08002905 is->compflags &= ~(SC_LINK_DECOMP_ON | SC_LINK_COMP_ON);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002906 break;
2907 case CCP_CONFACK:
2908 /* if we SEND an ackowledge we can/must enable the compressor */
Joe Perches475be4d2012-02-19 19:52:38 -08002909 if (is->debug & 0x10)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002910 printk(KERN_DEBUG "Enable compression here!\n");
Joe Perches475be4d2012-02-19 19:52:38 -08002911 if (proto == PPP_CCP) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002912 if (!is->compressor)
2913 break;
2914 is->compflags |= SC_COMP_ON;
2915 } else {
2916 if (!is->compressor)
2917 break;
2918 is->compflags |= SC_LINK_COMP_ON;
2919 }
2920 break;
2921 case CCP_RESETACK:
2922 /* If we send a ACK we should reset our compressor */
Joe Perches475be4d2012-02-19 19:52:38 -08002923 if (is->debug & 0x10)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002924 printk(KERN_DEBUG "Reset decompression state here!\n");
2925 printk(KERN_DEBUG "ResetAck from daemon passed by\n");
Joe Perches475be4d2012-02-19 19:52:38 -08002926 if (proto == PPP_CCP) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002927 /* link to master? */
Joe Perches475be4d2012-02-19 19:52:38 -08002928 if (is->compressor && is->comp_stat)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002929 is->compressor->reset(is->comp_stat, 0, 0,
2930 NULL, 0, NULL);
Joe Perches475be4d2012-02-19 19:52:38 -08002931 is->compflags &= ~SC_COMP_DISCARD;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002932 }
2933 else {
Joe Perches475be4d2012-02-19 19:52:38 -08002934 if (is->link_compressor && is->link_comp_stat)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002935 is->link_compressor->reset(is->link_comp_stat,
2936 0, 0, NULL, 0, NULL);
Joe Perches475be4d2012-02-19 19:52:38 -08002937 is->compflags &= ~SC_LINK_COMP_DISCARD;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002938 }
2939 break;
2940 case CCP_RESETREQ:
2941 /* Just let it pass by */
2942 printk(KERN_DEBUG "ResetReq from daemon passed by\n");
2943 break;
2944 }
2945}
2946
2947int isdn_ppp_register_compressor(struct isdn_ppp_compressor *ipc)
2948{
2949 ipc->next = ipc_head;
2950 ipc->prev = NULL;
Joe Perches475be4d2012-02-19 19:52:38 -08002951 if (ipc_head) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002952 ipc_head->prev = ipc;
2953 }
2954 ipc_head = ipc;
2955 return 0;
2956}
2957
2958int isdn_ppp_unregister_compressor(struct isdn_ppp_compressor *ipc)
2959{
Joe Perches475be4d2012-02-19 19:52:38 -08002960 if (ipc->prev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002961 ipc->prev->next = ipc->next;
2962 else
2963 ipc_head = ipc->next;
Joe Perches475be4d2012-02-19 19:52:38 -08002964 if (ipc->next)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002965 ipc->next->prev = ipc->prev;
2966 ipc->prev = ipc->next = NULL;
2967 return 0;
2968}
2969
2970static int isdn_ppp_set_compressor(struct ippp_struct *is, struct isdn_ppp_comp_data *data)
2971{
2972 struct isdn_ppp_compressor *ipc = ipc_head;
2973 int ret;
2974 void *stat;
2975 int num = data->num;
2976
Joe Perches475be4d2012-02-19 19:52:38 -08002977 if (is->debug & 0x10)
2978 printk(KERN_DEBUG "[%d] Set %s type %d\n", is->unit,
2979 (data->flags & IPPP_COMP_FLAG_XMIT) ? "compressor" : "decompressor", num);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002980
2981 /* If is has no valid reset state vector, we cannot allocate a
2982 decompressor. The decompressor would cause reset transactions
2983 sooner or later, and they need that vector. */
2984
Joe Perches475be4d2012-02-19 19:52:38 -08002985 if (!(data->flags & IPPP_COMP_FLAG_XMIT) && !is->reset) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002986 printk(KERN_ERR "ippp_ccp: no reset data structure - can't"
2987 " allow decompression.\n");
2988 return -ENOMEM;
2989 }
2990
Joe Perches475be4d2012-02-19 19:52:38 -08002991 while (ipc) {
2992 if (ipc->num == num) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002993 stat = ipc->alloc(data);
Joe Perches475be4d2012-02-19 19:52:38 -08002994 if (stat) {
2995 ret = ipc->init(stat, data, is->unit, 0);
2996 if (!ret) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002997 printk(KERN_ERR "Can't init (de)compression!\n");
2998 ipc->free(stat);
2999 stat = NULL;
3000 break;
3001 }
3002 }
3003 else {
3004 printk(KERN_ERR "Can't alloc (de)compression!\n");
3005 break;
3006 }
3007
Joe Perches475be4d2012-02-19 19:52:38 -08003008 if (data->flags & IPPP_COMP_FLAG_XMIT) {
3009 if (data->flags & IPPP_COMP_FLAG_LINK) {
3010 if (is->link_comp_stat)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003011 is->link_compressor->free(is->link_comp_stat);
3012 is->link_comp_stat = stat;
Joe Perches475be4d2012-02-19 19:52:38 -08003013 is->link_compressor = ipc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003014 }
3015 else {
Joe Perches475be4d2012-02-19 19:52:38 -08003016 if (is->comp_stat)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003017 is->compressor->free(is->comp_stat);
3018 is->comp_stat = stat;
Joe Perches475be4d2012-02-19 19:52:38 -08003019 is->compressor = ipc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003020 }
3021 }
Joe Perches475be4d2012-02-19 19:52:38 -08003022 else {
3023 if (data->flags & IPPP_COMP_FLAG_LINK) {
3024 if (is->link_decomp_stat)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003025 is->link_decompressor->free(is->link_decomp_stat);
3026 is->link_decomp_stat = stat;
Joe Perches475be4d2012-02-19 19:52:38 -08003027 is->link_decompressor = ipc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003028 }
3029 else {
Joe Perches475be4d2012-02-19 19:52:38 -08003030 if (is->decomp_stat)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003031 is->decompressor->free(is->decomp_stat);
3032 is->decomp_stat = stat;
Joe Perches475be4d2012-02-19 19:52:38 -08003033 is->decompressor = ipc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003034 }
3035 }
3036 return 0;
3037 }
3038 ipc = ipc->next;
3039 }
3040 return -EINVAL;
3041}