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