开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
ppp_generic.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：63k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

ppp_generic.c：源码内容
  1. /*
  2.  * Generic PPP layer for Linux.
  3.  *
  4.  * Copyright 1999-2002 Paul Mackerras.
  5.  *
  6.  *  This program is free software; you can redistribute it and/or
  7.  *  modify it under the terms of the GNU General Public License
  8.  *  as published by the Free Software Foundation; either version
  9.  *  2 of the License, or (at your option) any later version.
  10.  *
  11.  * The generic PPP layer handles the PPP network interfaces, the
  12.  * /dev/ppp device, packet and VJ compression, and multilink.
  13.  * It talks to PPP `channels' via the interface defined in
  14.  * include/linux/ppp_channel.h.  Channels provide the basic means for
  15.  * sending and receiving PPP frames on some kind of communications
  16.  * channel.
  17.  *
  18.  * Part of the code in this driver was inspired by the old async-only
  19.  * PPP driver, written by Michael Callahan and Al Longyear, and
  20.  * subsequently hacked by Paul Mackerras.
  21.  *
  22.  * ==FILEVERSION 20020217==
  23.  */
  25. #include <linux/config.h>
  26. #include <linux/module.h>
  27. #include <linux/kernel.h>
  28. #include <linux/kmod.h>
  29. #include <linux/init.h>
  30. #include <linux/list.h>
  31. #include <linux/devfs_fs_kernel.h>
  32. #include <linux/netdevice.h>
  33. #include <linux/poll.h>
  34. #include <linux/ppp_defs.h>
  35. #include <linux/filter.h>
  36. #include <linux/if_ppp.h>
  37. #include <linux/ppp_channel.h>
  38. #include <linux/ppp-comp.h>
  39. #include <linux/skbuff.h>
  40. #include <linux/rtnetlink.h>
  41. #include <linux/if_arp.h>
  42. #include <linux/ip.h>
  43. #include <linux/tcp.h>
  44. #include <linux/spinlock.h>
  45. #include <linux/smp_lock.h>
  46. #include <linux/rwsem.h>
  47. #include <linux/stddef.h>
  48. #include <net/slhc_vj.h>
  49. #include <asm/atomic.h>
  51. #define PPP_VERSION "2.4.2"
  53. /*
  54.  * Network protocols we support.
  55.  */
  56. #define NP_IP 0 /* Internet Protocol V4 */
  57. #define NP_IPV6 1 /* Internet Protocol V6 */
  58. #define NP_IPX 2 /* IPX protocol */
  59. #define NP_AT 3 /* Appletalk protocol */
  60. #define NUM_NP 4 /* Number of NPs. */
  62. #define MPHDRLEN 6 /* multilink protocol header length */
  63. #define MPHDRLEN_SSN 4 /* ditto with short sequence numbers */
  64. #define MIN_FRAG_SIZE 64
  66. /*
  67.  * An instance of /dev/ppp can be associated with either a ppp
  68.  * interface unit or a ppp channel.  In both cases, file->private_data
  69.  * points to one of these.
  70.  */
  71. struct ppp_file {
  72. enum {
  73. INTERFACE=1, CHANNEL
  74. } kind;
  75. struct sk_buff_head xq; /* pppd transmit queue */
  76. struct sk_buff_head rq; /* receive queue for pppd */
  77. wait_queue_head_t rwait; /* for poll on reading /dev/ppp */
  78. atomic_t refcnt; /* # refs (incl /dev/ppp attached) */
  79. int hdrlen; /* space to leave for headers */
  80. int index; /* interface unit / channel number */
  81. int dead; /* unit/channel has been shut down */
  82. };
  84. #define PF_TO_X(pf, X) ((X *)((char *)(pf) - offsetof(X, file)))
  86. #define PF_TO_PPP(pf) PF_TO_X(pf, struct ppp)
  87. #define PF_TO_CHANNEL(pf) PF_TO_X(pf, struct channel)
  89. #define ROUNDUP(n, x) (((n) + (x) - 1) / (x))
  91. /*
  92.  * Data structure describing one ppp unit.
  93.  * A ppp unit corresponds to a ppp network interface device
  94.  * and represents a multilink bundle.
  95.  * It can have 0 or more ppp channels connected to it.
  96.  */
  97. struct ppp {
  98. struct ppp_file file; /* stuff for read/write/poll 0 */
  99. struct file *owner; /* file that owns this unit 48 */
  100. struct list_head channels; /* list of attached channels 4c */
  101. int n_channels; /* how many channels are attached 54 */
  102. spinlock_t rlock; /* lock for receive side 58 */
  103. spinlock_t wlock; /* lock for transmit side 5c */
  104. int mru; /* max receive unit 60 */
  105. unsigned int flags; /* control bits 64 */
  106. unsigned int xstate; /* transmit state bits 68 */
  107. unsigned int rstate; /* receive state bits 6c */
  108. int debug; /* debug flags 70 */
  109. struct slcompress *vj; /* state for VJ header compression */
  110. enum NPmode npmode[NUM_NP]; /* what to do with each net proto 78 */
  111. struct sk_buff *xmit_pending; /* a packet ready to go out 88 */
  112. struct compressor *xcomp; /* transmit packet compressor 8c */
  113. void *xc_state; /* its internal state 90 */
  114. struct compressor *rcomp; /* receive decompressor 94 */
  115. void *rc_state; /* its internal state 98 */
  116. unsigned long last_xmit; /* jiffies when last pkt sent 9c */
  117. unsigned long last_recv; /* jiffies when last pkt rcvd a0 */
  118. struct net_device *dev; /* network interface device a4 */
  119. #ifdef CONFIG_PPP_MULTILINK
  120. int nxchan; /* next channel to send something on */
  121. u32 nxseq; /* next sequence number to send */
  122. int mrru; /* MP: max reconst. receive unit */
  123. u32 nextseq; /* MP: seq no of next packet */
  124. u32 minseq; /* MP: min of most recent seqnos */
  125. struct sk_buff_head mrq; /* MP: receive reconstruction queue */
  126. #endif /* CONFIG_PPP_MULTILINK */
  127. struct net_device_stats stats; /* statistics */
  128. #ifdef CONFIG_PPP_FILTER
  129. struct sock_fprog pass_filter; /* filter for packets to pass */
  130. struct sock_fprog active_filter;/* filter for pkts to reset idle */
  131. #endif /* CONFIG_PPP_FILTER */
  132. };
  134. /*
  135.  * Bits in flags: SC_NO_TCP_CCID, SC_CCP_OPEN, SC_CCP_UP, SC_LOOP_TRAFFIC,
  136.  * SC_MULTILINK, SC_MP_SHORTSEQ, SC_MP_XSHORTSEQ, SC_COMP_TCP, SC_REJ_COMP_TCP.
  137.  * Bits in rstate: SC_DECOMP_RUN, SC_DC_ERROR, SC_DC_FERROR.
  138.  * Bits in xstate: SC_COMP_RUN
  139.  */
  140. #define SC_FLAG_BITS (SC_NO_TCP_CCID|SC_CCP_OPEN|SC_CCP_UP|SC_LOOP_TRAFFIC 
  141.  |SC_MULTILINK|SC_MP_SHORTSEQ|SC_MP_XSHORTSEQ 
  142.  |SC_COMP_TCP|SC_REJ_COMP_TCP)
  144. /*
  145.  * Private data structure for each channel.
  146.  * This includes the data structure used for multilink.
  147.  */
  148. struct channel {
  149. struct ppp_file file; /* stuff for read/write/poll */
  150. struct list_head list; /* link in all/new_channels list */
  151. struct ppp_channel *chan; /* public channel data structure */
  152. struct rw_semaphore chan_sem; /* protects `chan' during chan ioctl */
  153. spinlock_t downl; /* protects `chan', file.xq dequeue */
  154. struct ppp *ppp; /* ppp unit we're connected to */
  155. struct list_head clist; /* link in list of channels per unit */
  156. rwlock_t upl; /* protects `ppp' */
  157. #ifdef CONFIG_PPP_MULTILINK
  158. u8 avail; /* flag used in multilink stuff */
  159. u8 had_frag; /* >= 1 fragments have been sent */
  160. u32 lastseq; /* MP: last sequence # received */
  161. #endif /* CONFIG_PPP_MULTILINK */
  162. };
  164. /*
  165.  * SMP locking issues:
  166.  * Both the ppp.rlock and ppp.wlock locks protect the ppp.channels
  167.  * list and the ppp.n_channels field, you need to take both locks
  168.  * before you modify them.
  169.  * The lock ordering is: channel.upl -> ppp.wlock -> ppp.rlock ->
  170.  * channel.downl.
  171.  */
  173. /*
  174.  * A cardmap represents a mapping from unsigned integers to pointers,
  175.  * and provides a fast "find lowest unused number" operation.
  176.  * It uses a broad (32-way) tree with a bitmap at each level.
  177.  * It is designed to be space-efficient for small numbers of entries
  178.  * and time-efficient for large numbers of entries.
  179.  */
  180. #define CARDMAP_ORDER 5
  181. #define CARDMAP_WIDTH (1U << CARDMAP_ORDER)
  182. #define CARDMAP_MASK (CARDMAP_WIDTH - 1)
  184. struct cardmap {
  185. int shift;
  186. unsigned long inuse;
  187. struct cardmap *parent;
  188. void *ptr[CARDMAP_WIDTH];
  189. };
  190. static void *cardmap_get(struct cardmap *map, unsigned int nr);
  191. static void cardmap_set(struct cardmap **map, unsigned int nr, void *ptr);
  192. static unsigned int cardmap_find_first_free(struct cardmap *map);
  193. static void cardmap_destroy(struct cardmap **map);
  195. /*
  196.  * all_ppp_sem protects the all_ppp_units mapping.
  197.  * It also ensures that finding a ppp unit in the all_ppp_units map
  198.  * and updating its file.refcnt field is atomic.
  199.  */
  200. static DECLARE_MUTEX(all_ppp_sem);
  201. static struct cardmap *all_ppp_units;
  202. static atomic_t ppp_unit_count = ATOMIC_INIT(0);
  204. /*
  205.  * all_channels_lock protects all_channels and last_channel_index,
  206.  * and the atomicity of find a channel and updating its file.refcnt
  207.  * field.
  208.  */
  209. static spinlock_t all_channels_lock = SPIN_LOCK_UNLOCKED;
  210. static LIST_HEAD(all_channels);
  211. static LIST_HEAD(new_channels);
  212. static int last_channel_index;
  213. static atomic_t channel_count = ATOMIC_INIT(0);
  215. /* Get the PPP protocol number from a skb */
  216. #define PPP_PROTO(skb) (((skb)->data[0] << 8) + (skb)->data[1])
  218. /* We limit the length of ppp->file.rq to this (arbitrary) value */
  219. #define PPP_MAX_RQLEN 32
  221. /*
  222.  * Maximum number of multilink fragments queued up.
  223.  * This has to be large enough to cope with the maximum latency of
  224.  * the slowest channel relative to the others.  Strictly it should
  225.  * depend on the number of channels and their characteristics.
  226.  */
  227. #define PPP_MP_MAX_QLEN 128
  229. /* Multilink header bits. */
  230. #define B 0x80 /* this fragment begins a packet */
  231. #define E 0x40 /* this fragment ends a packet */
  233. /* Compare multilink sequence numbers (assumed to be 32 bits wide) */
  234. #define seq_before(a, b) ((s32)((a) - (b)) < 0)
  235. #define seq_after(a, b) ((s32)((a) - (b)) > 0)
  237. /* Prototypes. */
  238. static int ppp_unattached_ioctl(struct ppp_file *pf, struct file *file,
  239. unsigned int cmd, unsigned long arg);
  240. static void ppp_xmit_process(struct ppp *ppp);
  241. static void ppp_send_frame(struct ppp *ppp, struct sk_buff *skb);
  242. static void ppp_push(struct ppp *ppp);
  243. static void ppp_channel_push(struct channel *pch);
  244. static void ppp_receive_frame(struct ppp *ppp, struct sk_buff *skb,
  245.       struct channel *pch);
  246. static void ppp_receive_error(struct ppp *ppp);
  247. static void ppp_receive_nonmp_frame(struct ppp *ppp, struct sk_buff *skb);
  248. static struct sk_buff *ppp_decompress_frame(struct ppp *ppp,
  249.     struct sk_buff *skb);
  250. #ifdef CONFIG_PPP_MULTILINK
  251. static void ppp_receive_mp_frame(struct ppp *ppp, struct sk_buff *skb,
  252. struct channel *pch);
  253. static void ppp_mp_insert(struct ppp *ppp, struct sk_buff *skb);
  254. static struct sk_buff *ppp_mp_reconstruct(struct ppp *ppp);
  255. static int ppp_mp_explode(struct ppp *ppp, struct sk_buff *skb);
  256. #endif /* CONFIG_PPP_MULTILINK */
  257. static int ppp_set_compress(struct ppp *ppp, unsigned long arg);
  258. static void ppp_ccp_peek(struct ppp *ppp, struct sk_buff *skb, int inbound);
  259. static void ppp_ccp_closed(struct ppp *ppp);
  260. static struct compressor *find_compressor(int type);
  261. static void ppp_get_stats(struct ppp *ppp, struct ppp_stats *st);
  262. static struct ppp *ppp_create_interface(int unit, int *retp);
  263. static void init_ppp_file(struct ppp_file *pf, int kind);
  264. static void ppp_shutdown_interface(struct ppp *ppp);
  265. static void ppp_destroy_interface(struct ppp *ppp);
  266. static struct ppp *ppp_find_unit(int unit);
  267. static struct channel *ppp_find_channel(int unit);
  268. static int ppp_connect_channel(struct channel *pch, int unit);
  269. static int ppp_disconnect_channel(struct channel *pch);
  270. static void ppp_destroy_channel(struct channel *pch);
  272. /* Translates a PPP protocol number to a NP index (NP == network protocol) */
  273. static inline int proto_to_npindex(int proto)
  274. {
  275. switch (proto) {
  276. case PPP_IP:
  277. return NP_IP;
  278. case PPP_IPV6:
  279. return NP_IPV6;
  280. case PPP_IPX:
  281. return NP_IPX;
  282. case PPP_AT:
  283. return NP_AT;
  284. }
  285. return -EINVAL;
  286. }
  288. /* Translates an NP index into a PPP protocol number */
  289. static const int npindex_to_proto[NUM_NP] = {
  290. PPP_IP,
  291. PPP_IPV6,
  292. PPP_IPX,
  293. PPP_AT,
  294. };
  296. /* Translates an ethertype into an NP index */
  297. static inline int ethertype_to_npindex(int ethertype)
  298. {
  299. switch (ethertype) {
  300. case ETH_P_IP:
  301. return NP_IP;
  302. case ETH_P_IPV6:
  303. return NP_IPV6;
  304. case ETH_P_IPX:
  305. return NP_IPX;
  306. case ETH_P_PPPTALK:
  307. case ETH_P_ATALK:
  308. return NP_AT;
  309. }
  310. return -1;
  311. }
  313. /* Translates an NP index into an ethertype */
  314. static const int npindex_to_ethertype[NUM_NP] = {
  315. ETH_P_IP,
  316. ETH_P_IPV6,
  317. ETH_P_IPX,
  318. ETH_P_PPPTALK,
  319. };
  321. /*
  322.  * Locking shorthand.
  323.  */
  324. #define ppp_xmit_lock(ppp) spin_lock_bh(&(ppp)->wlock)
  325. #define ppp_xmit_unlock(ppp) spin_unlock_bh(&(ppp)->wlock)
  326. #define ppp_recv_lock(ppp) spin_lock_bh(&(ppp)->rlock)
  327. #define ppp_recv_unlock(ppp) spin_unlock_bh(&(ppp)->rlock)
  328. #define ppp_lock(ppp) do { ppp_xmit_lock(ppp); 
  329.      ppp_recv_lock(ppp); } while (0)
  330. #define ppp_unlock(ppp) do { ppp_recv_unlock(ppp); 
  331.      ppp_xmit_unlock(ppp); } while (0)
  333. /*
  334.  * /dev/ppp device routines.
  335.  * The /dev/ppp device is used by pppd to control the ppp unit.
  336.  * It supports the read, write, ioctl and poll functions.
  337.  * Open instances of /dev/ppp can be in one of three states:
  338.  * unattached, attached to a ppp unit, or attached to a ppp channel.
  339.  */
  340. static int ppp_open(struct inode *inode, struct file *file)
  341. {
  342. /*
  343.  * This could (should?) be enforced by the permissions on /dev/ppp.
  344.  */
  345. if (!capable(CAP_NET_ADMIN))
  346. return -EPERM;
  347. return 0;
  348. }
  350. static int ppp_release(struct inode *inode, struct file *file)
  351. {
  352. struct ppp_file *pf = file->private_data;
  353. struct ppp *ppp;
  355. if (pf != 0) {
  356. file->private_data = 0;
  357. if (pf->kind == INTERFACE) {
  358. ppp = PF_TO_PPP(pf);
  359. if (file == ppp->owner)
  360. ppp_shutdown_interface(ppp);
  361. }
  362. if (atomic_dec_and_test(&pf->refcnt)) {
  363. switch (pf->kind) {
  364. case INTERFACE:
  365. ppp_destroy_interface(PF_TO_PPP(pf));
  366. break;
  367. case CHANNEL:
  368. ppp_destroy_channel(PF_TO_CHANNEL(pf));
  369. break;
  370. }
  371. }
  372. }
  373. return 0;
  374. }
  376. static ssize_t ppp_read(struct file *file, char *buf,
  377. size_t count, loff_t *ppos)
  378. {
  379. struct ppp_file *pf = file->private_data;
  380. DECLARE_WAITQUEUE(wait, current);
  381. ssize_t ret = 0;
  382. struct sk_buff *skb = 0;
  384. if (pf == 0)
  385. return -ENXIO;
  386. add_wait_queue(&pf->rwait, &wait);
  387. for (;;) {
  388. set_current_state(TASK_INTERRUPTIBLE);
  389. skb = skb_dequeue(&pf->rq);
  390. if (skb)
  391. break;
  392. ret = 0;
  393. if (pf->dead)
  394. break;
  395. ret = -EAGAIN;
  396. if (file->f_flags & O_NONBLOCK)
  397. break;
  398. ret = -ERESTARTSYS;
  399. if (signal_pending(current))
  400. break;
  401. schedule();
  402. }
  403. set_current_state(TASK_RUNNING);
  404. remove_wait_queue(&pf->rwait, &wait);
  406. if (skb == 0)
  407. goto err1;
  409. ret = -EOVERFLOW;
  410. if (skb->len > count)
  411. goto err2;
  412. ret = -EFAULT;
  413. if (copy_to_user(buf, skb->data, skb->len))
  414. goto err2;
  415. ret = skb->len;
  417.  err2:
  418. kfree_skb(skb);
  419.  err1:
  420. return ret;
  421. }
  423. static ssize_t ppp_write(struct file *file, const char *buf,
  424.  size_t count, loff_t *ppos)
  425. {
  426. struct ppp_file *pf = file->private_data;
  427. struct sk_buff *skb;
  428. ssize_t ret;
  430. if (pf == 0)
  431. return -ENXIO;
  432. ret = -ENOMEM;
  433. skb = alloc_skb(count + pf->hdrlen, GFP_KERNEL);
  434. if (skb == 0)
  435. goto err1;
  436. skb_reserve(skb, pf->hdrlen);
  437. ret = -EFAULT;
  438. if (copy_from_user(skb_put(skb, count), buf, count)) {
  439. kfree_skb(skb);
  440. goto err1;
  441. }
  443. skb_queue_tail(&pf->xq, skb);
  445. switch (pf->kind) {
  446. case INTERFACE:
  447. ppp_xmit_process(PF_TO_PPP(pf));
  448. break;
  449. case CHANNEL:
  450. ppp_channel_push(PF_TO_CHANNEL(pf));
  451. break;
  452. }
  454. ret = count;
  456.  err1:
  457. return ret;
  458. }
  460. /* No kernel lock - fine */
  461. static unsigned int ppp_poll(struct file *file, poll_table *wait)
  462. {
  463. struct ppp_file *pf = file->private_data;
  464. unsigned int mask;
  466. if (pf == 0)
  467. return 0;
  468. poll_wait(file, &pf->rwait, wait);
  469. mask = POLLOUT | POLLWRNORM;
  470. if (skb_peek(&pf->rq) != 0)
  471. mask |= POLLIN | POLLRDNORM;
  472. if (pf->dead)
  473. mask |= POLLHUP;
  474. return mask;
  475. }
  477. static int ppp_ioctl(struct inode *inode, struct file *file,
  478.      unsigned int cmd, unsigned long arg)
  479. {
  480. struct ppp_file *pf = file->private_data;
  481. struct ppp *ppp;
  482. int err = -EFAULT, val, val2, i;
  483. struct ppp_idle idle;
  484. struct npioctl npi;
  485. int unit, cflags;
  486. struct slcompress *vj;
  488. if (pf == 0)
  489. return ppp_unattached_ioctl(pf, file, cmd, arg);
  491. if (cmd == PPPIOCDETACH) {
  492. /*
  493.  * We have to be careful here... if the file descriptor
  494.  * has been dup'd, we could have another process in the
  495.  * middle of a poll using the same file *, so we had
  496.  * better not free the interface data structures -
  497.  * instead we fail the ioctl.  Even in this case, we
  498.  * shut down the interface if we are the owner of it.
  499.  * Actually, we should get rid of PPPIOCDETACH, userland
  500.  * (i.e. pppd) could achieve the same effect by closing
  501.  * this fd and reopening /dev/ppp.
  502.  */
  503. err = -EINVAL;
  504. if (pf->kind == INTERFACE) {
  505. ppp = PF_TO_PPP(pf);
  506. if (file == ppp->owner)
  507. ppp_shutdown_interface(ppp);
  508. }
  509. if (atomic_read(&file->f_count) <= 2) {
  510. ppp_release(inode, file);
  511. err = 0;
  512. } else
  513. printk(KERN_DEBUG "PPPIOCDETACH file->f_count=%dn",
  514.        atomic_read(&file->f_count));
  515. return err;
  516. }
  518. if (pf->kind == CHANNEL) {
  519. struct channel *pch = PF_TO_CHANNEL(pf);
  520. struct ppp_channel *chan;
  522. switch (cmd) {
  523. case PPPIOCCONNECT:
  524. if (get_user(unit, (int *) arg))
  525. break;
  526. err = ppp_connect_channel(pch, unit);
  527. break;
  529. case PPPIOCDISCONN:
  530. err = ppp_disconnect_channel(pch);
  531. break;
  533. default:
  534. down_read(&pch->chan_sem);
  535. chan = pch->chan;
  536. err = -ENOTTY;
  537. if (chan && chan->ops->ioctl)
  538. err = chan->ops->ioctl(chan, cmd, arg);
  539. up_read(&pch->chan_sem);
  540. }
  541. return err;
  542. }
  544. if (pf->kind != INTERFACE) {
  545. /* can't happen */
  546. printk(KERN_ERR "PPP: not interface or channel??n");
  547. return -EINVAL;
  548. }
  550. ppp = PF_TO_PPP(pf);
  551. switch (cmd) {
  552. case PPPIOCSMRU:
  553. if (get_user(val, (int *) arg))
  554. break;
  555. ppp->mru = val;
  556. err = 0;
  557. break;
  559. case PPPIOCSFLAGS:
  560. if (get_user(val, (int *) arg))
  561. break;
  562. ppp_lock(ppp);
  563. cflags = ppp->flags & ~val;
  564. ppp->flags = val & SC_FLAG_BITS;
  565. ppp_unlock(ppp);
  566. if (cflags & SC_CCP_OPEN)
  567. ppp_ccp_closed(ppp);
  568. err = 0;
  569. break;
  571. case PPPIOCGFLAGS:
  572. val = ppp->flags | ppp->xstate | ppp->rstate;
  573. if (put_user(val, (int *) arg))
  574. break;
  575. err = 0;
  576. break;
  578. case PPPIOCSCOMPRESS:
  579. err = ppp_set_compress(ppp, arg);
  580. break;
  582. case PPPIOCGUNIT:
  583. if (put_user(ppp->file.index, (int *) arg))
  584. break;
  585. err = 0;
  586. break;
  588. case PPPIOCSDEBUG:
  589. if (get_user(val, (int *) arg))
  590. break;
  591. ppp->debug = val;
  592. err = 0;
  593. break;
  595. case PPPIOCGDEBUG:
  596. if (put_user(ppp->debug, (int *) arg))
  597. break;
  598. err = 0;
  599. break;
  601. case PPPIOCGIDLE:
  602. idle.xmit_idle = (jiffies - ppp->last_xmit) / HZ;
  603. idle.recv_idle = (jiffies - ppp->last_recv) / HZ;
  604. if (copy_to_user((void *) arg, &idle, sizeof(idle)))
  605. break;
  606. err = 0;
  607. break;
  609. case PPPIOCSMAXCID:
  610. if (get_user(val, (int *) arg))
  611. break;
  612. val2 = 15;
  613. if ((val >> 16) != 0) {
  614. val2 = val >> 16;
  615. val &= 0xffff;
  616. }
  617. vj = slhc_init(val2+1, val+1);
  618. if (vj == 0) {
  619. printk(KERN_ERR "PPP: no memory (VJ compressor)n");
  620. err = -ENOMEM;
  621. break;
  622. }
  623. ppp_lock(ppp);
  624. if (ppp->vj != 0)
  625. slhc_free(ppp->vj);
  626. ppp->vj = vj;
  627. ppp_unlock(ppp);
  628. err = 0;
  629. break;
  631. case PPPIOCGNPMODE:
  632. case PPPIOCSNPMODE:
  633. if (copy_from_user(&npi, (void *) arg, sizeof(npi)))
  634. break;
  635. err = proto_to_npindex(npi.protocol);
  636. if (err < 0)
  637. break;
  638. i = err;
  639. if (cmd == PPPIOCGNPMODE) {
  640. err = -EFAULT;
  641. npi.mode = ppp->npmode[i];
  642. if (copy_to_user((void *) arg, &npi, sizeof(npi)))
  643. break;
  644. } else {
  645. ppp->npmode[i] = npi.mode;
  646. /* we may be able to transmit more packets now (??) */
  647. netif_wake_queue(ppp->dev);
  648. }
  649. err = 0;
  650. break;
  652. #ifdef CONFIG_PPP_FILTER
  653. case PPPIOCSPASS:
  654. case PPPIOCSACTIVE:
  655. {
  656. struct sock_fprog uprog, *filtp;
  657. struct sock_filter *code = NULL;
  658. int len;
  660. if (copy_from_user(&uprog, (void *) arg, sizeof(uprog)))
  661. break;
  662. if (uprog.len > 0 && uprog.len < 65536) {
  663. err = -ENOMEM;
  664. len = uprog.len * sizeof(struct sock_filter);
  665. code = kmalloc(len, GFP_KERNEL);
  666. if (code == 0)
  667. break;
  668. err = -EFAULT;
  669. if (copy_from_user(code, uprog.filter, len))
  670. break;
  671. err = sk_chk_filter(code, uprog.len);
  672. if (err) {
  673. kfree(code);
  674. break;
  675. }
  676. }
  677. filtp = (cmd == PPPIOCSPASS)? &ppp->pass_filter: &ppp->active_filter;
  678. ppp_lock(ppp);
  679. if (filtp->filter)
  680. kfree(filtp->filter);
  681. filtp->filter = code;
  682. filtp->len = uprog.len;
  683. ppp_unlock(ppp);
  684. err = 0;
  685. break;
  686. }
  687. #endif /* CONFIG_PPP_FILTER */
  689. #ifdef CONFIG_PPP_MULTILINK
  690. case PPPIOCSMRRU:
  691. if (get_user(val, (int *) arg))
  692. break;
  693. ppp_recv_lock(ppp);
  694. ppp->mrru = val;
  695. ppp_recv_unlock(ppp);
  696. err = 0;
  697. break;
  698. #endif /* CONFIG_PPP_MULTILINK */
  700. default:
  701. err = -ENOTTY;
  702. }
  704. return err;
  705. }
  707. static int ppp_unattached_ioctl(struct ppp_file *pf, struct file *file,
  708. unsigned int cmd, unsigned long arg)
  709. {
  710. int unit, err = -EFAULT;
  711. struct ppp *ppp;
  712. struct channel *chan;
  714. switch (cmd) {
  715. case PPPIOCNEWUNIT:
  716. /* Create a new ppp unit */
  717. if (get_user(unit, (int *) arg))
  718. break;
  719. ppp = ppp_create_interface(unit, &err);
  720. if (ppp == 0)
  721. break;
  722. file->private_data = &ppp->file;
  723. ppp->owner = file;
  724. err = -EFAULT;
  725. if (put_user(ppp->file.index, (int *) arg))
  726. break;
  727. err = 0;
  728. break;
  730. case PPPIOCATTACH:
  731. /* Attach to an existing ppp unit */
  732. if (get_user(unit, (int *) arg))
  733. break;
  734. down(&all_ppp_sem);
  735. err = -ENXIO;
  736. ppp = ppp_find_unit(unit);
  737. if (ppp != 0) {
  738. atomic_inc(&ppp->file.refcnt);
  739. file->private_data = &ppp->file;
  740. err = 0;
  741. }
  742. up(&all_ppp_sem);
  743. break;
  745. case PPPIOCATTCHAN:
  746. if (get_user(unit, (int *) arg))
  747. break;
  748. spin_lock_bh(&all_channels_lock);
  749. err = -ENXIO;
  750. chan = ppp_find_channel(unit);
  751. if (chan != 0) {
  752. atomic_inc(&chan->file.refcnt);
  753. file->private_data = &chan->file;
  754. err = 0;
  755. }
  756. spin_unlock_bh(&all_channels_lock);
  757. break;
  759. default:
  760. err = -ENOTTY;
  761. }
  762. return err;
  763. }
  765. static struct file_operations ppp_device_fops = {
  766. owner: THIS_MODULE,
  767. read: ppp_read,
  768. write: ppp_write,
  769. poll: ppp_poll,
  770. ioctl: ppp_ioctl,
  771. open: ppp_open,
  772. release: ppp_release
  773. };
  775. #define PPP_MAJOR 108
  777. static devfs_handle_t devfs_handle;
  779. /* Called at boot time if ppp is compiled into the kernel,
  780.    or at module load time (from init_module) if compiled as a module. */
  781. int __init ppp_init(void)
  782. {
  783. int err;
  785. printk(KERN_INFO "PPP generic driver version " PPP_VERSION "n");
  786. err = devfs_register_chrdev(PPP_MAJOR, "ppp", &ppp_device_fops);
  787. if (err)
  788. printk(KERN_ERR "failed to register PPP device (%d)n", err);
  789. devfs_handle = devfs_register(NULL, "ppp", DEVFS_FL_DEFAULT,
  790.       PPP_MAJOR, 0,
  791.       S_IFCHR | S_IRUSR | S_IWUSR,
  792.       &ppp_device_fops, NULL);
  794. return 0;
  795. }
  797. /*
  798.  * Network interface unit routines.
  799.  */
  800. static int
  801. ppp_start_xmit(struct sk_buff *skb, struct net_device *dev)
  802. {
  803. struct ppp *ppp = (struct ppp *) dev->priv;
  804. int npi, proto;
  805. unsigned char *pp;
  807. npi = ethertype_to_npindex(ntohs(skb->protocol));
  808. if (npi < 0)
  809. goto err1;
  811. /* Drop, accept or reject the packet */
  812. switch (ppp->npmode[npi]) {
  813. case NPMODE_PASS:
  814. break;
  815. case NPMODE_QUEUE:
  816. /* it would be nice to have a way to tell the network
  817.    system to queue this one up for later. */
  818. goto err1;
  819. case NPMODE_DROP:
  820. case NPMODE_ERROR:
  821. goto err1;
  822. }
  824. /* Put the 2-byte PPP protocol number on the front,
  825.    making sure there is room for the address and control fields. */
  826. if (skb_headroom(skb) < PPP_HDRLEN) {
  827. struct sk_buff *ns;
  829. ns = alloc_skb(skb->len + dev->hard_header_len, GFP_ATOMIC);
  830. if (ns == 0)
  831. goto err1;
  832. skb_reserve(ns, dev->hard_header_len);
  833. memcpy(skb_put(ns, skb->len), skb->data, skb->len);
  834. kfree_skb(skb);
  835. skb = ns;
  836. }
  837. pp = skb_push(skb, 2);
  838. proto = npindex_to_proto[npi];
  839. pp[0] = proto >> 8;
  840. pp[1] = proto;
  842. netif_stop_queue(dev);
  843. skb_queue_tail(&ppp->file.xq, skb);
  844. ppp_xmit_process(ppp);
  845. return 0;
  847.  err1:
  848. kfree_skb(skb);
  849. ++ppp->stats.tx_dropped;
  850. return 0;
  851. }
  853. static struct net_device_stats *
  854. ppp_net_stats(struct net_device *dev)
  855. {
  856. struct ppp *ppp = (struct ppp *) dev->priv;
  858. return &ppp->stats;
  859. }
  861. static int
  862. ppp_net_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
  863. {
  864. struct ppp *ppp = dev->priv;
  865. int err = -EFAULT;
  866. void *addr = (void *) ifr->ifr_ifru.ifru_data;
  867. struct ppp_stats stats;
  868. struct ppp_comp_stats cstats;
  869. char *vers;
  871. switch (cmd) {
  872. case SIOCGPPPSTATS:
  873. ppp_get_stats(ppp, &stats);
  874. if (copy_to_user(addr, &stats, sizeof(stats)))
  875. break;
  876. err = 0;
  877. break;
  879. case SIOCGPPPCSTATS:
  880. memset(&cstats, 0, sizeof(cstats));
  881. if (ppp->xc_state != 0)
  882. ppp->xcomp->comp_stat(ppp->xc_state, &cstats.c);
  883. if (ppp->rc_state != 0)
  884. ppp->rcomp->decomp_stat(ppp->rc_state, &cstats.d);
  885. if (copy_to_user(addr, &cstats, sizeof(cstats)))
  886. break;
  887. err = 0;
  888. break;
  890. case SIOCGPPPVER:
  891. vers = PPP_VERSION;
  892. if (copy_to_user(addr, vers, strlen(vers) + 1))
  893. break;
  894. err = 0;
  895. break;
  897. default:
  898. err = -EINVAL;
  899. }
  901. return err;
  902. }
  904. static int
  905. ppp_net_init(struct net_device *dev)
  906. {
  907. dev->hard_header_len = PPP_HDRLEN;
  908. dev->mtu = PPP_MTU;
  909. dev->hard_start_xmit = ppp_start_xmit;
  910. dev->get_stats = ppp_net_stats;
  911. dev->do_ioctl = ppp_net_ioctl;
  912. dev->addr_len = 0;
  913. dev->tx_queue_len = 3;
  914. dev->type = ARPHRD_PPP;
  915. dev->flags = IFF_POINTOPOINT | IFF_NOARP | IFF_MULTICAST;
  916. return 0;
  917. }
  919. /*
  920.  * Transmit-side routines.
  921.  */
  923. /*
  924.  * Called to do any work queued up on the transmit side
  925.  * that can now be done.
  926.  */
  927. static void
  928. ppp_xmit_process(struct ppp *ppp)
  929. {
  930. struct sk_buff *skb;
  932. ppp_xmit_lock(ppp);
  933. if (ppp->dev != 0) {
  934. ppp_push(ppp);
  935. while (ppp->xmit_pending == 0
  936.        && (skb = skb_dequeue(&ppp->file.xq)) != 0)
  937. ppp_send_frame(ppp, skb);
  938. /* If there's no work left to do, tell the core net
  939.    code that we can accept some more. */
  940. if (ppp->xmit_pending == 0 && skb_peek(&ppp->file.xq) == 0)
  941. netif_wake_queue(ppp->dev);
  942. }
  943. ppp_xmit_unlock(ppp);
  944. }
  946. /*
  947.  * Compress and send a frame.
  948.  * The caller should have locked the xmit path,
  949.  * and xmit_pending should be 0.
  950.  */
  951. static void
  952. ppp_send_frame(struct ppp *ppp, struct sk_buff *skb)
  953. {
  954. int proto = PPP_PROTO(skb);
  955. struct sk_buff *new_skb;
  956. int len;
  957. unsigned char *cp;
  959. if (proto < 0x8000) {
  960. #ifdef CONFIG_PPP_FILTER
  961. /* check if we should pass this packet */
  962. /* the filter instructions are constructed assuming
  963.    a four-byte PPP header on each packet */
  964. *skb_push(skb, 2) = 1;
  965. if (ppp->pass_filter.filter
  966.     && sk_run_filter(skb, ppp->pass_filter.filter,
  967.      ppp->pass_filter.len) == 0) {
  968. if (ppp->debug & 1) {
  969. printk(KERN_DEBUG "PPP: outbound frame not passedn");
  970. kfree_skb(skb);
  971. return;
  972. }
  973. }
  974. /* if this packet passes the active filter, record the time */
  975. if (!(ppp->active_filter.filter
  976.       && sk_run_filter(skb, ppp->active_filter.filter,
  977.        ppp->active_filter.len) == 0))
  978. ppp->last_xmit = jiffies;
  979. skb_pull(skb, 2);
  980. #else
  981. /* for data packets, record the time */
  982. ppp->last_xmit = jiffies;
  983. #endif /* CONFIG_PPP_FILTER */
  984. }
  986. ++ppp->stats.tx_packets;
  987. ppp->stats.tx_bytes += skb->len - 2;
  989. switch (proto) {
  990. case PPP_IP:
  991. if (ppp->vj == 0 || (ppp->flags & SC_COMP_TCP) == 0)
  992. break;
  993. /* try to do VJ TCP header compression */
  994. new_skb = alloc_skb(skb->len + ppp->dev->hard_header_len - 2,
  995.     GFP_ATOMIC);
  996. if (new_skb == 0) {
  997. printk(KERN_ERR "PPP: no memory (VJ comp pkt)n");
  998. goto drop;
  999. }
  1000. skb_reserve(new_skb, ppp->dev->hard_header_len - 2);
  1001. cp = skb->data + 2;
  1002. len = slhc_compress(ppp->vj, cp, skb->len - 2,
  1003.     new_skb->data + 2, &cp,
  1004.     !(ppp->flags & SC_NO_TCP_CCID));
  1005. if (cp == skb->data + 2) {
  1006. /* didn't compress */
  1007. kfree_skb(new_skb);
  1008. } else {
  1009. if (cp[0] & SL_TYPE_COMPRESSED_TCP) {
  1010. proto = PPP_VJC_COMP;
  1011. cp[0] &= ~SL_TYPE_COMPRESSED_TCP;
  1012. } else {
  1013. proto = PPP_VJC_UNCOMP;
  1014. cp[0] = skb->data[2];
  1015. }
  1016. kfree_skb(skb);
  1017. skb = new_skb;
  1018. cp = skb_put(skb, len + 2);
  1019. cp[0] = 0;
  1020. cp[1] = proto;
  1021. }
  1022. break;
  1024. case PPP_CCP:
  1025. /* peek at outbound CCP frames */
  1026. ppp_ccp_peek(ppp, skb, 0);
  1027. break;
  1028. }
  1030. /* try to do packet compression */
  1031. if ((ppp->xstate & SC_COMP_RUN) && ppp->xc_state != 0
  1032.     && proto != PPP_LCP && proto != PPP_CCP) {
  1033. new_skb = alloc_skb(ppp->dev->mtu + ppp->dev->hard_header_len,
  1034.     GFP_ATOMIC);
  1035. if (new_skb == 0) {
  1036. printk(KERN_ERR "PPP: no memory (comp pkt)n");
  1037. goto drop;
  1038. }
  1039. if (ppp->dev->hard_header_len > PPP_HDRLEN)
  1040. skb_reserve(new_skb,
  1041.     ppp->dev->hard_header_len - PPP_HDRLEN);
  1043. /* compressor still expects A/C bytes in hdr */
  1044. len = ppp->xcomp->compress(ppp->xc_state, skb->data - 2,
  1045.    new_skb->data, skb->len + 2,
  1046.    ppp->dev->mtu + PPP_HDRLEN);
  1047. if (len > 0 && (ppp->flags & SC_CCP_UP)) {
  1048. kfree_skb(skb);
  1049. skb = new_skb;
  1050. skb_put(skb, len);
  1051. skb_pull(skb, 2); /* pull off A/C bytes */
  1052. } else {
  1053. /* didn't compress, or CCP not up yet */
  1054. kfree_skb(new_skb);
  1055. }
  1056. }
  1058. /*
  1059.  * If we are waiting for traffic (demand dialling),
  1060.  * queue it up for pppd to receive.
  1061.  */
  1062. if (ppp->flags & SC_LOOP_TRAFFIC) {
  1063. if (ppp->file.rq.qlen > PPP_MAX_RQLEN)
  1064. goto drop;
  1065. skb_queue_tail(&ppp->file.rq, skb);
  1066. wake_up_interruptible(&ppp->file.rwait);
  1067. return;
  1068. }
  1070. ppp->xmit_pending = skb;
  1071. ppp_push(ppp);
  1072. return;
  1074.  drop:
  1075. kfree_skb(skb);
  1076. ++ppp->stats.tx_errors;
  1077. }
  1079. /*
  1080.  * Try to send the frame in xmit_pending.
  1081.  * The caller should have the xmit path locked.
  1082.  */
  1083. static void
  1084. ppp_push(struct ppp *ppp)
  1085. {
  1086. struct list_head *list;
  1087. struct channel *pch;
  1088. struct sk_buff *skb = ppp->xmit_pending;
  1090. if (skb == 0)
  1091. return;
  1093. list = &ppp->channels;
  1094. if (list_empty(list)) {
  1095. /* nowhere to send the packet, just drop it */
  1096. ppp->xmit_pending = 0;
  1097. kfree_skb(skb);
  1098. return;
  1099. }
  1101. if ((ppp->flags & SC_MULTILINK) == 0) {
  1102. /* not doing multilink: send it down the first channel */
  1103. list = list->next;
  1104. pch = list_entry(list, struct channel, clist);
  1106. spin_lock_bh(&pch->downl);
  1107. if (pch->chan) {
  1108. if (pch->chan->ops->start_xmit(pch->chan, skb))
  1109. ppp->xmit_pending = 0;
  1110. } else {
  1111. /* channel got unregistered */
  1112. kfree_skb(skb);
  1113. ppp->xmit_pending = 0;
  1114. }
  1115. spin_unlock_bh(&pch->downl);
  1116. return;
  1117. }
  1119. #ifdef CONFIG_PPP_MULTILINK
  1120. /* Multilink: fragment the packet over as many links
  1121.    as can take the packet at the moment. */
  1122. if (!ppp_mp_explode(ppp, skb))
  1123. return;
  1124. #endif /* CONFIG_PPP_MULTILINK */
  1126. ppp->xmit_pending = 0;
  1127. kfree_skb(skb);
  1128. }
  1130. #ifdef CONFIG_PPP_MULTILINK
  1131. /*
  1132.  * Divide a packet to be transmitted into fragments and
  1133.  * send them out the individual links.
  1134.  */
  1135. static int ppp_mp_explode(struct ppp *ppp, struct sk_buff *skb)
  1136. {
  1137. int nch, len, fragsize;
  1138. int i, bits, hdrlen, mtu;
  1139. int flen, fnb;
  1140. unsigned char *p, *q;
  1141. struct list_head *list;
  1142. struct channel *pch;
  1143. struct sk_buff *frag;
  1144. struct ppp_channel *chan;
  1146. nch = 0;
  1147. hdrlen = (ppp->flags & SC_MP_XSHORTSEQ)? MPHDRLEN_SSN: MPHDRLEN;
  1148. list = &ppp->channels;
  1149. while ((list = list->next) != &ppp->channels) {
  1150. pch = list_entry(list, struct channel, clist);
  1151. nch += pch->avail = (skb_queue_len(&pch->file.xq) == 0);
  1152. /*
  1153.  * If a channel hasn't had a fragment yet, it has to get
  1154.  * one before we send any fragments on later channels.
  1155.  * If it can't take a fragment now, don't give any
  1156.  * to subsequent channels.
  1157.  */
  1158. if (!pch->had_frag && !pch->avail) {
  1159. while ((list = list->next) != &ppp->channels) {
  1160. pch = list_entry(list, struct channel, clist);
  1161. pch->avail = 0;
  1162. }
  1163. break;
  1164. }
  1165. }
  1166. if (nch == 0)
  1167. return 0; /* can't take now, leave it in xmit_pending */
  1169. /* Do protocol field compression (XXX this should be optional) */
  1170. p = skb->data;
  1171. len = skb->len;
  1172. if (*p == 0) {
  1173. ++p;
  1174. --len;
  1175. }
  1177. /* decide on fragment size */
  1178. fragsize = len;
  1179. if (nch > 1) {
  1180. int maxch = ROUNDUP(len, MIN_FRAG_SIZE);
  1181. if (nch > maxch)
  1182. nch = maxch;
  1183. fragsize = ROUNDUP(fragsize, nch);
  1184. }
  1186. /* skip to the channel after the one we last used
  1187.    and start at that one */
  1188. for (i = 0; i < ppp->nxchan; ++i) {
  1189. list = list->next;
  1190. if (list == &ppp->channels) {
  1191. i = 0;
  1192. break;
  1193. }
  1194. }
  1196. /* create a fragment for each channel */
  1197. bits = B;
  1198. do {
  1199. list = list->next;
  1200. if (list == &ppp->channels) {
  1201. i = 0;
  1202. continue;
  1203. }
  1204. pch = list_entry(list, struct channel, clist);
  1205. ++i;
  1206. if (!pch->avail)
  1207. continue;
  1209. /* check the channel's mtu and whether it is still attached. */
  1210. spin_lock_bh(&pch->downl);
  1211. if (pch->chan == 0 || (mtu = pch->chan->mtu) < hdrlen) {
  1212. /* can't use this channel */
  1213. spin_unlock_bh(&pch->downl);
  1214. pch->avail = 0;
  1215. if (--nch == 0)
  1216. break;
  1217. continue;
  1218. }
  1220. /*
  1221.  * We have to create multiple fragments for this channel
  1222.  * if fragsize is greater than the channel's mtu.
  1223.  */
  1224. if (fragsize > len)
  1225. fragsize = len;
  1226. for (flen = fragsize; flen > 0; flen -= fnb) {
  1227. fnb = flen;
  1228. if (fnb > mtu + 2 - hdrlen)
  1229. fnb = mtu + 2 - hdrlen;
  1230. if (fnb >= len)
  1231. bits |= E;
  1232. frag = alloc_skb(fnb + hdrlen, GFP_ATOMIC);
  1233. if (frag == 0)
  1234. goto noskb;
  1235. q = skb_put(frag, fnb + hdrlen);
  1236. /* make the MP header */
  1237. q[0] = PPP_MP >> 8;
  1238. q[1] = PPP_MP;
  1239. if (ppp->flags & SC_MP_XSHORTSEQ) {
  1240. q[2] = bits + ((ppp->nxseq >> 8) & 0xf);
  1241. q[3] = ppp->nxseq;
  1242. } else {
  1243. q[2] = bits;
  1244. q[3] = ppp->nxseq >> 16;
  1245. q[4] = ppp->nxseq >> 8;
  1246. q[5] = ppp->nxseq;
  1247. }
  1249. /* copy the data in */
  1250. memcpy(q + hdrlen, p, fnb);
  1252. /* try to send it down the channel */
  1253. chan = pch->chan;
  1254. if (!chan->ops->start_xmit(chan, frag))
  1255. skb_queue_tail(&pch->file.xq, frag);
  1256. pch->had_frag = 1;
  1257. p += fnb;
  1258. len -= fnb;
  1259. ++ppp->nxseq;
  1260. bits = 0;
  1261. }
  1262. spin_unlock_bh(&pch->downl);
  1263. } while (len > 0);
  1264. ppp->nxchan = i;
  1266. return 1;
  1268.  noskb:
  1269. spin_unlock_bh(&pch->downl);
  1270. if (ppp->debug & 1)
  1271. printk(KERN_ERR "PPP: no memory (fragment)n");
  1272. ++ppp->stats.tx_errors;
  1273. ++ppp->nxseq;
  1274. return 1; /* abandon the frame */
  1275. }
  1276. #endif /* CONFIG_PPP_MULTILINK */
  1278. /*
  1279.  * Try to send data out on a channel.
  1280.  */
  1281. static void
  1282. ppp_channel_push(struct channel *pch)
  1283. {
  1284. struct sk_buff *skb;
  1285. struct ppp *ppp;
  1287. spin_lock_bh(&pch->downl);
  1288. if (pch->chan != 0) {
  1289. while (skb_queue_len(&pch->file.xq) > 0) {
  1290. skb = skb_dequeue(&pch->file.xq);
  1291. if (!pch->chan->ops->start_xmit(pch->chan, skb)) {
  1292. /* put the packet back and try again later */
  1293. skb_queue_head(&pch->file.xq, skb);
  1294. break;
  1295. }
  1296. }
  1297. } else {
  1298. /* channel got deregistered */
  1299. skb_queue_purge(&pch->file.xq);
  1300. }
  1301. spin_unlock_bh(&pch->downl);
  1302. /* see if there is anything from the attached unit to be sent */
  1303. if (skb_queue_len(&pch->file.xq) == 0) {
  1304. read_lock_bh(&pch->upl);
  1305. ppp = pch->ppp;
  1306. if (ppp != 0)
  1307. ppp_xmit_process(ppp);
  1308. read_unlock_bh(&pch->upl);
  1309. }
  1310. }
  1312. /*
  1313.  * Receive-side routines.
  1314.  */
  1316. /* misuse a few fields of the skb for MP reconstruction */
  1317. #define sequence priority
  1318. #define BEbits cb[0]
  1320. static inline void
  1321. ppp_do_recv(struct ppp *ppp, struct sk_buff *skb, struct channel *pch)
  1322. {
  1323. ppp_recv_lock(ppp);
  1324. /* ppp->dev == 0 means interface is closing down */
  1325. if (ppp->dev != 0)
  1326. ppp_receive_frame(ppp, skb, pch);
  1327. else
  1328. kfree_skb(skb);
  1329. ppp_recv_unlock(ppp);
  1330. }
  1332. void
  1333. ppp_input(struct ppp_channel *chan, struct sk_buff *skb)
  1334. {
  1335. struct channel *pch = chan->ppp;
  1336. int proto;
  1338. if (pch == 0 || skb->len == 0) {
  1339. kfree_skb(skb);
  1340. return;
  1341. }
  1343. proto = PPP_PROTO(skb);
  1344. read_lock_bh(&pch->upl);
  1345. if (pch->ppp == 0 || proto >= 0xc000 || proto == PPP_CCPFRAG) {
  1346. /* put it on the channel queue */
  1347. skb_queue_tail(&pch->file.rq, skb);
  1348. /* drop old frames if queue too long */
  1349. while (pch->file.rq.qlen > PPP_MAX_RQLEN
  1350.        && (skb = skb_dequeue(&pch->file.rq)) != 0)
  1351. kfree_skb(skb);
  1352. wake_up_interruptible(&pch->file.rwait);
  1353. } else {
  1354. ppp_do_recv(pch->ppp, skb, pch);
  1355. }
  1356. read_unlock_bh(&pch->upl);
  1357. }
  1359. /* Put a 0-length skb in the receive queue as an error indication */
  1360. void
  1361. ppp_input_error(struct ppp_channel *chan, int code)
  1362. {
  1363. struct channel *pch = chan->ppp;
  1364. struct sk_buff *skb;
  1366. if (pch == 0)
  1367. return;
  1369. read_lock_bh(&pch->upl);
  1370. if (pch->ppp != 0) {
  1371. skb = alloc_skb(0, GFP_ATOMIC);
  1372. if (skb != 0) {
  1373. skb->len = 0; /* probably unnecessary */
  1374. skb->cb[0] = code;
  1375. ppp_do_recv(pch->ppp, skb, pch);
  1376. }
  1377. }
  1378. read_unlock_bh(&pch->upl);
  1379. }
  1381. /*
  1382.  * We come in here to process a received frame.
  1383.  * The receive side of the ppp unit is locked.
  1384.  */
  1385. static void
  1386. ppp_receive_frame(struct ppp *ppp, struct sk_buff *skb, struct channel *pch)
  1387. {
  1388. if (skb->len >= 2) {
  1389. #ifdef CONFIG_PPP_MULTILINK
  1390. /* XXX do channel-level decompression here */
  1391. if (PPP_PROTO(skb) == PPP_MP)
  1392. ppp_receive_mp_frame(ppp, skb, pch);
  1393. else
  1394. #endif /* CONFIG_PPP_MULTILINK */
  1395. ppp_receive_nonmp_frame(ppp, skb);
  1396. return;
  1397. }
  1399. if (skb->len > 0)
  1400. /* note: a 0-length skb is used as an error indication */
  1401. ++ppp->stats.rx_length_errors;
  1403. kfree_skb(skb);
  1404. ppp_receive_error(ppp);
  1405. }
  1407. static void
  1408. ppp_receive_error(struct ppp *ppp)
  1409. {
  1410. ++ppp->stats.rx_errors;
  1411. if (ppp->vj != 0)
  1412. slhc_toss(ppp->vj);
  1413. }
  1415. static void
  1416. ppp_receive_nonmp_frame(struct ppp *ppp, struct sk_buff *skb)
  1417. {
  1418. struct sk_buff *ns;
  1419. int proto, len, npi;
  1421. /*
  1422.  * Decompress the frame, if compressed.
  1423.  * Note that some decompressors need to see uncompressed frames
  1424.  * that come in as well as compressed frames.
  1425.  */
  1426. if (ppp->rc_state != 0 && (ppp->rstate & SC_DECOMP_RUN)
  1427.     && (ppp->rstate & (SC_DC_FERROR | SC_DC_ERROR)) == 0)
  1428. skb = ppp_decompress_frame(ppp, skb);
  1430. proto = PPP_PROTO(skb);
  1431. switch (proto) {
  1432. case PPP_VJC_COMP:
  1433. /* decompress VJ compressed packets */
  1434. if (ppp->vj == 0 || (ppp->flags & SC_REJ_COMP_TCP))
  1435. goto err;
  1436. if (skb_tailroom(skb) < 124) {
  1437. /* copy to a new sk_buff with more tailroom */
  1438. ns = dev_alloc_skb(skb->len + 128);
  1439. if (ns == 0) {
  1440. printk(KERN_ERR"PPP: no memory (VJ decomp)n");
  1441. goto err;
  1442. }
  1443. skb_reserve(ns, 2);
  1444. memcpy(skb_put(ns, skb->len), skb->data, skb->len);
  1445. kfree_skb(skb);
  1446. skb = ns;
  1447. }
  1448. len = slhc_uncompress(ppp->vj, skb->data + 2, skb->len - 2);
  1449. if (len <= 0) {
  1450. printk(KERN_DEBUG "PPP: VJ decompression errorn");
  1451. goto err;
  1452. }
  1453. len += 2;
  1454. if (len > skb->len)
  1455. skb_put(skb, len - skb->len);
  1456. else if (len < skb->len)
  1457. skb_trim(skb, len);
  1458. proto = PPP_IP;
  1459. break;
  1461. case PPP_VJC_UNCOMP:
  1462. if (ppp->vj == 0 || (ppp->flags & SC_REJ_COMP_TCP))
  1463. goto err;
  1464. if (slhc_remember(ppp->vj, skb->data + 2, skb->len - 2) <= 0) {
  1465. printk(KERN_ERR "PPP: VJ uncompressed errorn");
  1466. goto err;
  1467. }
  1468. proto = PPP_IP;
  1469. break;
  1471. case PPP_CCP:
  1472. ppp_ccp_peek(ppp, skb, 1);
  1473. break;
  1474. }
  1476. ++ppp->stats.rx_packets;
  1477. ppp->stats.rx_bytes += skb->len - 2;
  1479. npi = proto_to_npindex(proto);
  1480. if (npi < 0) {
  1481. /* control or unknown frame - pass it to pppd */
  1482. skb_queue_tail(&ppp->file.rq, skb);
  1483. /* limit queue length by dropping old frames */
  1484. while (ppp->file.rq.qlen > PPP_MAX_RQLEN
  1485.        && (skb = skb_dequeue(&ppp->file.rq)) != 0)
  1486. kfree_skb(skb);
  1487. /* wake up any process polling or blocking on read */
  1488. wake_up_interruptible(&ppp->file.rwait);
  1490. } else {
  1491. /* network protocol frame - give it to the kernel */
  1493. #ifdef CONFIG_PPP_FILTER
  1494. /* check if the packet passes the pass and active filters */
  1495. /* the filter instructions are constructed assuming
  1496.    a four-byte PPP header on each packet */
  1497. *skb_push(skb, 2) = 0;
  1498. if (ppp->pass_filter.filter
  1499.     && sk_run_filter(skb, ppp->pass_filter.filter,
  1500.      ppp->pass_filter.len) == 0) {
  1501. if (ppp->debug & 1)
  1502. printk(KERN_DEBUG "PPP: inbound frame not passedn");
  1503. kfree_skb(skb);
  1504. return;
  1505. }
  1506. if (!(ppp->active_filter.filter
  1507.       && sk_run_filter(skb, ppp->active_filter.filter,
  1508.        ppp->active_filter.len) == 0))
  1509. ppp->last_recv = jiffies;
  1510. skb_pull(skb, 2);
  1511. #else
  1512. ppp->last_recv = jiffies;
  1513. #endif /* CONFIG_PPP_FILTER */
  1515. if ((ppp->dev->flags & IFF_UP) == 0
  1516.     || ppp->npmode[npi] != NPMODE_PASS) {
  1517. kfree_skb(skb);
  1518. } else {
  1519. skb_pull(skb, 2); /* chop off protocol */
  1520. skb->dev = ppp->dev;
  1521. skb->protocol = htons(npindex_to_ethertype[npi]);
  1522. skb->mac.raw = skb->data;
  1523. netif_rx(skb);
  1524. ppp->dev->last_rx = jiffies;
  1525. }
  1526. }
  1527. return;
  1529.  err:
  1530. kfree_skb(skb);
  1531. ppp_receive_error(ppp);
  1532. }
  1534. static struct sk_buff *
  1535. ppp_decompress_frame(struct ppp *ppp, struct sk_buff *skb)
  1536. {
  1537. int proto = PPP_PROTO(skb);
  1538. struct sk_buff *ns;
  1539. int len;
  1541. if (proto == PPP_COMP) {
  1542. ns = dev_alloc_skb(ppp->mru + PPP_HDRLEN);
  1543. if (ns == 0) {
  1544. printk(KERN_ERR "ppp_decompress_frame: no memoryn");
  1545. goto err;
  1546. }
  1547. /* the decompressor still expects the A/C bytes in the hdr */
  1548. len = ppp->rcomp->decompress(ppp->rc_state, skb->data - 2,
  1549. skb->len + 2, ns->data, ppp->mru + PPP_HDRLEN);
  1550. if (len < 0) {
  1551. /* Pass the compressed frame to pppd as an
  1552.    error indication. */
  1553. if (len == DECOMP_FATALERROR)
  1554. ppp->rstate |= SC_DC_FERROR;
  1555. kfree_skb(ns);
  1556. goto err;
  1557. }
  1559. kfree_skb(skb);
  1560. skb = ns;
  1561. skb_put(skb, len);
  1562. skb_pull(skb, 2); /* pull off the A/C bytes */
  1564. } else {
  1565. /* Uncompressed frame - pass to decompressor so it
  1566.    can update its dictionary if necessary. */
  1567. if (ppp->rcomp->incomp)
  1568. ppp->rcomp->incomp(ppp->rc_state, skb->data - 2,
  1569.    skb->len + 2);
  1570. }
  1572. return skb;
  1574.  err:
  1575. ppp->rstate |= SC_DC_ERROR;
  1576. ppp_receive_error(ppp);
  1577. return skb;
  1578. }
  1580. #ifdef CONFIG_PPP_MULTILINK
  1581. /*
  1582.  * Receive a multilink frame.
  1583.  * We put it on the reconstruction queue and then pull off
  1584.  * as many completed frames as we can.
  1585.  */
  1586. static void
  1587. ppp_receive_mp_frame(struct ppp *ppp, struct sk_buff *skb, struct channel *pch)
  1588. {
  1589. u32 mask, seq;
  1590. struct list_head *l;
  1591. int mphdrlen = (ppp->flags & SC_MP_SHORTSEQ)? MPHDRLEN_SSN: MPHDRLEN;
  1593. if (skb->len < mphdrlen + 1 || ppp->mrru == 0)
  1594. goto err; /* no good, throw it away */
  1596. /* Decode sequence number and begin/end bits */
  1597. if (ppp->flags & SC_MP_SHORTSEQ) {
  1598. seq = ((skb->data[2] & 0x0f) << 8) | skb->data[3];
  1599. mask = 0xfff;
  1600. } else {
  1601. seq = (skb->data[3] << 16) | (skb->data[4] << 8)| skb->data[5];
  1602. mask = 0xffffff;
  1603. }
  1604. skb->BEbits = skb->data[2];
  1605. skb_pull(skb, mphdrlen); /* pull off PPP and MP headers */
  1607. /*
  1608.  * Do protocol ID decompression on the first fragment of each packet.
  1609.  */
  1610. if ((skb->BEbits & B) && (skb->data[0] & 1))
  1611. *skb_push(skb, 1) = 0;
  1613. /*
  1614.  * Expand sequence number to 32 bits, making it as close
  1615.  * as possible to ppp->minseq.
  1616.  */
  1617. seq |= ppp->minseq & ~mask;
  1618. if ((int)(ppp->minseq - seq) > (int)(mask >> 1))
  1619. seq += mask + 1;
  1620. else if ((int)(seq - ppp->minseq) > (int)(mask >> 1))
  1621. seq -= mask + 1; /* should never happen */
  1622. skb->sequence = seq;
  1623. pch->lastseq = seq;
  1625. /*
  1626.  * If this packet comes before the next one we were expecting,
  1627.  * drop it.
  1628.  */
  1629. if (seq_before(seq, ppp->nextseq)) {
  1630. kfree_skb(skb);
  1631. ++ppp->stats.rx_dropped;
  1632. ppp_receive_error(ppp);
  1633. return;
  1634. }
  1636. /*
  1637.  * Reevaluate minseq, the minimum over all channels of the
  1638.  * last sequence number received on each channel.  Because of
  1639.  * the increasing sequence number rule, we know that any fragment
  1640.  * before `minseq' which hasn't arrived is never going to arrive.
  1641.  * The list of channels can't change because we have the receive
  1642.  * side of the ppp unit locked.
  1643.  */
  1644. for (l = ppp->channels.next; l != &ppp->channels; l = l->next) {
  1645. struct channel *ch = list_entry(l, struct channel, clist);
  1646. if (seq_before(ch->lastseq, seq))
  1647. seq = ch->lastseq;
  1648. }
  1649. if (seq_before(ppp->minseq, seq))
  1650. ppp->minseq = seq;
  1652. /* Put the fragment on the reconstruction queue */
  1653. ppp_mp_insert(ppp, skb);
  1655. /* If the queue is getting long, don't wait any longer for packets
  1656.    before the start of the queue. */
  1657. if (skb_queue_len(&ppp->mrq) >= PPP_MP_MAX_QLEN
  1658.     && seq_before(ppp->minseq, ppp->mrq.next->sequence))
  1659. ppp->minseq = ppp->mrq.next->sequence;
  1661. /* Pull completed packets off the queue and receive them. */
  1662. while ((skb = ppp_mp_reconstruct(ppp)) != 0)
  1663. ppp_receive_nonmp_frame(ppp, skb);
  1665. return;
  1667.  err:
  1668. kfree_skb(skb);
  1669. ppp_receive_error(ppp);
  1670. }
  1672. /*
  1673.  * Insert a fragment on the MP reconstruction queue.
  1674.  * The queue is ordered by increasing sequence number.
  1675.  */
  1676. static void
  1677. ppp_mp_insert(struct ppp *ppp, struct sk_buff *skb)
  1678. {
  1679. struct sk_buff *p;
  1680. struct sk_buff_head *list = &ppp->mrq;
  1681. u32 seq = skb->sequence;
  1683. /* N.B. we don't need to lock the list lock because we have the
  1684.    ppp unit receive-side lock. */
  1685. for (p = list->next; p != (struct sk_buff *)list; p = p->next)
  1686. if (seq_before(seq, p->sequence))
  1687. break;
  1688. __skb_insert(skb, p->prev, p, list);
  1689. }
  1691. /*
  1692.  * Reconstruct a packet from the MP fragment queue.
  1693.  * We go through increasing sequence numbers until we find a
  1694.  * complete packet, or we get to the sequence number for a fragment
  1695.  * which hasn't arrived but might still do so.
  1696.  */
  1697. struct sk_buff *
  1698. ppp_mp_reconstruct(struct ppp *ppp)
  1699. {
  1700. u32 seq = ppp->nextseq;
  1701. u32 minseq = ppp->minseq;
  1702. struct sk_buff_head *list = &ppp->mrq;
  1703. struct sk_buff *p, *next;
  1704. struct sk_buff *head, *tail;
  1705. struct sk_buff *skb = NULL;
  1706. int lost = 0, len = 0;
  1708. if (ppp->mrru == 0) /* do nothing until mrru is set */
  1709. return NULL;
  1710. head = list->next;
  1711. tail = NULL;
  1712. for (p = head; p != (struct sk_buff *) list; p = next) {
  1713. next = p->next;
  1714. if (seq_before(p->sequence, seq)) {
  1715. /* this can't happen, anyway ignore the skb */
  1716. printk(KERN_ERR "ppp_mp_reconstruct bad seq %u < %un",
  1717.        p->sequence, seq);
  1718. head = next;
  1719. continue;
  1720. }
  1721. if (p->sequence != seq) {
  1722. /* Fragment `seq' is missing.  If it is after
  1723.    minseq, it might arrive later, so stop here. */
  1724. if (seq_after(seq, minseq))
  1725. break;
  1726. /* Fragment `seq' is lost, keep going. */
  1727. lost = 1;
  1728. seq = seq_before(minseq, p->sequence)?
  1729. minseq + 1: p->sequence;
  1730. next = p;
  1731. continue;
  1732. }
  1734. /*
  1735.  * At this point we know that all the fragments from
  1736.  * ppp->nextseq to seq are either present or lost.
  1737.  * Also, there are no complete packets in the queue
  1738.  * that have no missing fragments and end before this
  1739.  * fragment.
  1740.  */
  1742. /* B bit set indicates this fragment starts a packet */
  1743. if (p->BEbits & B) {
  1744. head = p;
  1745. lost = 0;
  1746. len = 0;
  1747. }
  1749. len += p->len;
  1751. /* Got a complete packet yet? */
  1752. if (lost == 0 && (p->BEbits & E) && (head->BEbits & B)) {
  1753. if (len > ppp->mrru + 2) {
  1754. ++ppp->stats.rx_length_errors;
  1755. printk(KERN_DEBUG "PPP: reconstructed packet"
  1756.        " is too long (%d)n", len);
  1757. } else if (p == head) {
  1758. /* fragment is complete packet - reuse skb */
  1759. tail = p;
  1760. skb = skb_get(p);
  1761. break;
  1762. } else if ((skb = dev_alloc_skb(len)) == NULL) {
  1763. ++ppp->stats.rx_missed_errors;
  1764. printk(KERN_DEBUG "PPP: no memory for "
  1765.        "reconstructed packet");
  1766. } else {
  1767. tail = p;
  1768. break;
  1769. }
  1770. ppp->nextseq = seq + 1;
  1771. }
  1773. /*
  1774.  * If this is the ending fragment of a packet,
  1775.  * and we haven't found a complete valid packet yet,
  1776.  * we can discard up to and including this fragment.
  1777.  */
  1778. if (p->BEbits & E)
  1779. head = next;
  1781. ++seq;
  1782. }
  1784. /* If we have a complete packet, copy it all into one skb. */
  1785. if (tail != NULL) {
  1786. /* If we have discarded any fragments,
  1787.    signal a receive error. */
  1788. if (head->sequence != ppp->nextseq) {
  1789. if (ppp->debug & 1)
  1790. printk(KERN_DEBUG "  missed pkts %u..%un",
  1791.        ppp->nextseq, head->sequence-1);
  1792. ++ppp->stats.rx_dropped;
  1793. ppp_receive_error(ppp);
  1794. }
  1796. if (head != tail)
  1797. /* copy to a single skb */
  1798. for (p = head; p != tail->next; p = p->next)
  1799. memcpy(skb_put(skb, p->len), p->data, p->len);
  1800. ppp->nextseq = tail->sequence + 1;
  1801. head = tail->next;
  1802. }
  1804. /* Discard all the skbuffs that we have copied the data out of
  1805.    or that we can't use. */
  1806. while ((p = list->next) != head) {
  1807. __skb_unlink(p, list);
  1808. kfree_skb(p);
  1809. }
  1811. return skb;
  1812. }
  1813. #endif /* CONFIG_PPP_MULTILINK */
  1815. /*
  1816.  * Channel interface.
  1817.  */
  1819. /*
  1820.  * Create a new, unattached ppp channel.
  1821.  */
  1822. int
  1823. ppp_register_channel(struct ppp_channel *chan)
  1824. {
  1825. struct channel *pch;
  1827. pch = kmalloc(sizeof(struct channel), GFP_KERNEL);
  1828. if (pch == 0)
  1829. return -ENOMEM;
  1830. memset(pch, 0, sizeof(struct channel));
  1831. pch->ppp = NULL;
  1832. pch->chan = chan;
  1833. chan->ppp = pch;
  1834. init_ppp_file(&pch->file, CHANNEL);
  1835. pch->file.hdrlen = chan->hdrlen;
  1836. #ifdef CONFIG_PPP_MULTILINK
  1837. pch->lastseq = -1;
  1838. #endif /* CONFIG_PPP_MULTILINK */
  1839. init_rwsem(&pch->chan_sem);
  1840. spin_lock_init(&pch->downl);
  1841. pch->upl = RW_LOCK_UNLOCKED;
  1842. spin_lock_bh(&all_channels_lock);
  1843. pch->file.index = ++last_channel_index;
  1844. list_add(&pch->list, &new_channels);
  1845. atomic_inc(&channel_count);
  1846. spin_unlock_bh(&all_channels_lock);
  1847. MOD_INC_USE_COUNT;
  1848. return 0;
  1849. }
  1851. /*
  1852.  * Return the index of a channel.
  1853.  */
  1854. int ppp_channel_index(struct ppp_channel *chan)
  1855. {
  1856. struct channel *pch = chan->ppp;
  1858. if (pch != 0)
  1859. return pch->file.index;
  1860. return -1;
  1861. }
  1863. /*
  1864.  * Return the PPP unit number to which a channel is connected.
  1865.  */
  1866. int ppp_unit_number(struct ppp_channel *chan)
  1867. {
  1868. struct channel *pch = chan->ppp;
  1869. int unit = -1;
  1871. if (pch != 0) {
  1872. read_lock_bh(&pch->upl);
  1873. if (pch->ppp != 0)
  1874. unit = pch->ppp->file.index;
  1875. read_unlock_bh(&pch->upl);
  1876. }
  1877. return unit;
  1878. }
  1880. /*
  1881.  * Disconnect a channel from the generic layer.
  1882.  * This must be called in process context.
  1883.  */
  1884. void
  1885. ppp_unregister_channel(struct ppp_channel *chan)
  1886. {
  1887. struct channel *pch = chan->ppp;
  1889. if (pch == 0)
  1890. return; /* should never happen */
  1891. chan->ppp = 0;
  1893. /*
  1894.  * This ensures that we have returned from any calls into the
  1895.  * the channel's start_xmit or ioctl routine before we proceed.
  1896.  */
  1897. down_write(&pch->chan_sem);
  1898. spin_lock_bh(&pch->downl);
  1899. pch->chan = 0;
  1900. spin_unlock_bh(&pch->downl);
  1901. up_write(&pch->chan_sem);
  1902. ppp_disconnect_channel(pch);
  1903. spin_lock_bh(&all_channels_lock);
  1904. list_del(&pch->list);
  1905. spin_unlock_bh(&all_channels_lock);
  1906. pch->file.dead = 1;
  1907. wake_up_interruptible(&pch->file.rwait);
  1908. if (atomic_dec_and_test(&pch->file.refcnt))
  1909. ppp_destroy_channel(pch);
  1910. MOD_DEC_USE_COUNT;
  1911. }
  1913. /*
  1914.  * Callback from a channel when it can accept more to transmit.
  1915.  * This should be called at BH/softirq level, not interrupt level.
  1916.  */
  1917. void
  1918. ppp_output_wakeup(struct ppp_channel *chan)
  1919. {
  1920. struct channel *pch = chan->ppp;
  1922. if (pch == 0)
  1923. return;
  1924. ppp_channel_push(pch);
  1925. }
  1927. /*
  1928.  * Compression control.
  1929.  */
  1931. /* Process the PPPIOCSCOMPRESS ioctl. */
  1932. static int
  1933. ppp_set_compress(struct ppp *ppp, unsigned long arg)
  1934. {
  1935. int err;
  1936. struct compressor *cp, *ocomp;
  1937. struct ppp_option_data data;
  1938. void *state, *ostate;
  1939. unsigned char ccp_option[CCP_MAX_OPTION_LENGTH];
  1940. #ifdef CONFIG_KMOD
  1941. char modname[32];
  1942. #endif
  1944. err = -EFAULT;
  1945. if (copy_from_user(&data, (void *) arg, sizeof(data))
  1946.     || (data.length <= CCP_MAX_OPTION_LENGTH
  1947. && copy_from_user(ccp_option, data.ptr, data.length)))
  1948. goto err1;
  1949. err = -EINVAL;
  1950. if (data.length > CCP_MAX_OPTION_LENGTH
  1951.     || ccp_option[1] < 2 || ccp_option[1] > data.length)
  1952. goto err1;
  1954. cp = find_compressor(ccp_option[0]);
  1955. #ifdef CONFIG_KMOD
  1956. if (cp == 0) {
  1957. sprintf(modname, "ppp-compress-%d", ccp_option[0]);
  1958. request_module(modname);
  1959. cp = find_compressor(ccp_option[0]);
  1960. }
  1961. #endif /* CONFIG_KMOD */
  1962. if (cp == 0)
  1963. goto err1;
  1964. /*
  1965.  * XXX race: the compressor module could get unloaded between
  1966.  * here and when we do the comp_alloc or decomp_alloc call below.
  1967.  */
  1969. err = -ENOBUFS;
  1970. if (data.transmit) {
  1971. state = cp->comp_alloc(ccp_option, data.length);
  1972. if (state != 0) {
  1973. ppp_xmit_lock(ppp);
  1974. ppp->xstate &= ~SC_COMP_RUN;
  1975. ocomp = ppp->xcomp;
  1976. ostate = ppp->xc_state;
  1977. ppp->xcomp = cp;
  1978. ppp->xc_state = state;
  1979. ppp_xmit_unlock(ppp);
  1980. if (ostate != 0)
  1981. ocomp->comp_free(ostate);
  1982. err = 0;
  1983. }
  1985. } else {
  1986. state = cp->decomp_alloc(ccp_option, data.length);
  1987. if (state != 0) {
  1988. ppp_recv_lock(ppp);
  1989. ppp->rstate &= ~SC_DECOMP_RUN;
  1990. ocomp = ppp->rcomp;
  1991. ostate = ppp->rc_state;
  1992. ppp->rcomp = cp;
  1993. ppp->rc_state = state;
  1994. ppp_recv_unlock(ppp);
  1995. if (ostate != 0)
  1996. ocomp->decomp_free(ostate);
  1997. err = 0;
  1998. }
  1999. }
  2001.  err1:
  2002. return err;
  2003. }
  2005. /*
  2006.  * Look at a CCP packet and update our state accordingly.
  2007.  * We assume the caller has the xmit or recv path locked.
  2008.  */
  2009. static void
  2010. ppp_ccp_peek(struct ppp *ppp, struct sk_buff *skb, int inbound)
  2011. {
  2012. unsigned char *dp = skb->data + 2;
  2013. int len;
  2015. if (skb->len < CCP_HDRLEN + 2
  2016.     || skb->len < (len = CCP_LENGTH(dp)) + 2)
  2017. return; /* too short */
  2019. switch (CCP_CODE(dp)) {
  2020. case CCP_CONFREQ:
  2022. /* A ConfReq starts negotiation of compression 
  2023.  * in one direction of transmission,
  2024.  * and hence brings it down...but which way?
  2025.  *
  2026.  * Remember:
  2027.  * A ConfReq indicates what the sender would like to receive
  2028.  */
  2029. if(inbound)
  2030. /* He is proposing what I should send */
  2031. ppp->xstate &= ~SC_COMP_RUN;
  2032. else
  2033. /* I am proposing to what he should send */
  2034. ppp->rstate &= ~SC_DECOMP_RUN;
  2036. break;
  2038. case CCP_TERMREQ:
  2039. case CCP_TERMACK:
  2040. /*
  2041.  * CCP is going down, both directions of transmission 
  2042.  */
  2043. ppp->rstate &= ~SC_DECOMP_RUN;
  2044. ppp->xstate &= ~SC_COMP_RUN;
  2045. break;
  2047. case CCP_CONFACK:
  2048. if ((ppp->flags & (SC_CCP_OPEN | SC_CCP_UP)) != SC_CCP_OPEN)
  2049. break;
  2050. dp += CCP_HDRLEN;
  2051. len -= CCP_HDRLEN;
  2052. if (len < CCP_OPT_MINLEN || len < CCP_OPT_LENGTH(dp))
  2053. break;
  2054. if (inbound) {
  2055. /* we will start receiving compressed packets */
  2056. if (ppp->rc_state == 0)
  2057. break;
  2058. if (ppp->rcomp->decomp_init(ppp->rc_state, dp, len,
  2059. ppp->file.index, 0, ppp->mru, ppp->debug)) {
  2060. ppp->rstate |= SC_DECOMP_RUN;
  2061. ppp->rstate &= ~(SC_DC_ERROR | SC_DC_FERROR);
  2062. }
  2063. } else {
  2064. /* we will soon start sending compressed packets */
  2065. if (ppp->xc_state == 0)
  2066. break;
  2067. if (ppp->xcomp->comp_init(ppp->xc_state, dp, len,
  2068. ppp->file.index, 0, ppp->debug))
  2069. ppp->xstate |= SC_COMP_RUN;
  2070. }
  2071. break;
  2073. case CCP_RESETACK:
  2074. /* reset the [de]compressor */
  2075. if ((ppp->flags & SC_CCP_UP) == 0)
  2076. break;
  2077. if (inbound) {
  2078. if (ppp->rc_state && (ppp->rstate & SC_DECOMP_RUN)) {
  2079. ppp->rcomp->decomp_reset(ppp->rc_state);
  2080. ppp->rstate &= ~SC_DC_ERROR;
  2081. }
  2082. } else {
  2083. if (ppp->xc_state && (ppp->xstate & SC_COMP_RUN))
  2084. ppp->xcomp->comp_reset(ppp->xc_state);
  2085. }
  2086. break;
  2087. }
  2088. }
  2090. /* Free up compression resources. */
  2091. static void
  2092. ppp_ccp_closed(struct ppp *ppp)
  2093. {
  2094. void *xstate, *rstate;
  2095. struct compressor *xcomp, *rcomp;
  2097. ppp_lock(ppp);
  2098. ppp->flags &= ~(SC_CCP_OPEN | SC_CCP_UP);
  2099. ppp->xstate = 0;
  2100. xcomp = ppp->xcomp;
  2101. xstate = ppp->xc_state;
  2102. ppp->xc_state = 0;
  2103. ppp->rstate = 0;
  2104. rcomp = ppp->rcomp;
  2105. rstate = ppp->rc_state;
  2106. ppp->rc_state = 0;
  2107. ppp_unlock(ppp);
  2109. if (xstate)
  2110. xcomp->comp_free(xstate);
  2111. if (rstate)
  2112. rcomp->decomp_free(rstate);
  2113. }
  2115. /* List of compressors. */
  2116. static LIST_HEAD(compressor_list);
  2117. static spinlock_t compressor_list_lock = SPIN_LOCK_UNLOCKED;
  2119. struct compressor_entry {
  2120. struct list_head list;
  2121. struct compressor *comp;
  2122. };
  2124. static struct compressor_entry *
  2125. find_comp_entry(int proto)
  2126. {
  2127. struct compressor_entry *ce;
  2128. struct list_head *list = &compressor_list;
  2130. while ((list = list->next) != &compressor_list) {
  2131. ce = list_entry(list, struct compressor_entry, list);
  2132. if (ce->comp->compress_proto == proto)
  2133. return ce;
  2134. }
  2135. return 0;
  2136. }
  2138. /* Register a compressor */
  2139. int
  2140. ppp_register_compressor(struct compressor *cp)
  2141. {
  2142. struct compressor_entry *ce;
  2143. int ret;
  2144. spin_lock(&compressor_list_lock);
  2145. ret = -EEXIST;
  2146. if (find_comp_entry(cp->compress_proto) != 0)
  2147. goto err1;
  2148. ret = -ENOMEM;
  2149. ce = kmalloc(sizeof(struct compressor_entry), GFP_ATOMIC);
  2150. if (ce == 0)
  2151. goto err1;
  2152. ret = 0;
  2153. ce->comp = cp;
  2154. list_add(&ce->list, &compressor_list);
  2155.  err1:
  2156. spin_unlock(&compressor_list_lock);
  2157. return ret;
  2158. }
  2160. /* Unregister a compressor */
  2161. void
  2162. ppp_unregister_compressor(struct compressor *cp)
  2163. {
  2164. struct compressor_entry *ce;
  2166. spin_lock(&compressor_list_lock);
  2167. ce = find_comp_entry(cp->compress_proto);
  2168. if (ce != 0 && ce->comp == cp) {
  2169. list_del(&ce->list);
  2170. kfree(ce);
  2171. }
  2172. spin_unlock(&compressor_list_lock);
  2173. }
  2175. /* Find a compressor. */
  2176. static struct compressor *
  2177. find_compressor(int type)
  2178. {
  2179. struct compressor_entry *ce;
  2180. struct compressor *cp = 0;
  2182. spin_lock(&compressor_list_lock);
  2183. ce = find_comp_entry(type);
  2184. if (ce != 0)
  2185. cp = ce->comp;
  2186. spin_unlock(&compressor_list_lock);
  2187. return cp;
  2188. }
  2190. /*
  2191.  * Miscelleneous stuff.
  2192.  */
  2194. static void
  2195. ppp_get_stats(struct ppp *ppp, struct ppp_stats *st)
  2196. {
  2197. struct slcompress *vj = ppp->vj;
  2199. memset(st, 0, sizeof(*st));
  2200. st->p.ppp_ipackets = ppp->stats.rx_packets;
  2201. st->p.ppp_ierrors = ppp->stats.rx_errors;
  2202. st->p.ppp_ibytes = ppp->stats.rx_bytes;
  2203. st->p.ppp_opackets = ppp->stats.tx_packets;
  2204. st->p.ppp_oerrors = ppp->stats.tx_errors;
  2205. st->p.ppp_obytes = ppp->stats.tx_bytes;
  2206. if (vj == 0)
  2207. return;
  2208. st->vj.vjs_packets = vj->sls_o_compressed + vj->sls_o_uncompressed;
  2209. st->vj.vjs_compressed = vj->sls_o_compressed;
  2210. st->vj.vjs_searches = vj->sls_o_searches;
  2211. st->vj.vjs_misses = vj->sls_o_misses;
  2212. st->vj.vjs_errorin = vj->sls_i_error;
  2213. st->vj.vjs_tossed = vj->sls_i_tossed;
  2214. st->vj.vjs_uncompressedin = vj->sls_i_uncompressed;
  2215. st->vj.vjs_compressedin = vj->sls_i_compressed;
  2216. }
  2218. /*
  2219.  * Stuff for handling the lists of ppp units and channels
  2220.  * and for initialization.
  2221.  */
  2223. /*
  2224.  * Create a new ppp interface unit.  Fails if it can't allocate memory
  2225.  * or if there is already a unit with the requested number.
  2226.  * unit == -1 means allocate a new number.
  2227.  */
  2228. static struct ppp *
  2229. ppp_create_interface(int unit, int *retp)
  2230. {
  2231. struct ppp *ppp;
  2232. struct net_device *dev = NULL;
  2233. int ret = -ENOMEM;
  2234. int i;
  2236. ppp = kmalloc(sizeof(struct ppp), GFP_KERNEL);
  2237. if (ppp == 0)
  2238. goto err;
  2239. dev = kmalloc(sizeof(struct net_device), GFP_KERNEL);
  2240. if (dev == 0)
  2241. goto err;
  2242. memset(ppp, 0, sizeof(struct ppp));
  2243. memset(dev, 0, sizeof(struct net_device));
  2245. ret = -EEXIST;
  2246. down(&all_ppp_sem);
  2247. if (unit < 0)
  2248. unit = cardmap_find_first_free(all_ppp_units);
  2249. else if (cardmap_get(all_ppp_units, unit) != NULL)
  2250. goto err_unlock; /* unit already exists */
  2252. /* Initialize the new ppp unit */
  2253. ppp->file.index = unit;
  2254. ppp->mru = PPP_MRU;
  2255. init_ppp_file(&ppp->file, INTERFACE);
  2256. ppp->file.hdrlen = PPP_HDRLEN - 2; /* don't count proto bytes */
  2257. for (i = 0; i < NUM_NP; ++i)
  2258. ppp->npmode[i] = NPMODE_PASS;
  2259. INIT_LIST_HEAD(&ppp->channels);
  2260. spin_lock_init(&ppp->rlock);
  2261. spin_lock_init(&ppp->wlock);
  2262. #ifdef CONFIG_PPP_MULTILINK
  2263. ppp->minseq = -1;
  2264. skb_queue_head_init(&ppp->mrq);
  2265. #endif /* CONFIG_PPP_MULTILINK */
  2267. ppp->dev = dev;
  2268. dev->init = ppp_net_init;
  2269. sprintf(dev->name, "ppp%d", unit);
  2270. dev->priv = ppp;
  2271. dev->features |= NETIF_F_DYNALLOC;
  2273. rtnl_lock();
  2274. ret = register_netdevice(dev);
  2275. rtnl_unlock();
  2276. if (ret != 0) {
  2277. printk(KERN_ERR "PPP: couldn't register device %s (%d)n",
  2278.        dev->name, ret);
  2279. goto err_unlock;
  2280. }
  2282. atomic_inc(&ppp_unit_count);
  2283. cardmap_set(&all_ppp_units, unit, ppp);
  2284. up(&all_ppp_sem);
  2285. *retp = 0;
  2286. return ppp;
  2288.  err_unlock:
  2289. up(&all_ppp_sem);
  2290.  err:
  2291. *retp = ret;
  2292. if (ppp)
  2293. kfree(ppp);
  2294. if (dev)
  2295. kfree(dev);
  2296. return NULL;
  2297. }
  2299. /*
  2300.  * Initialize a ppp_file structure.
  2301.  */
  2302. static void
  2303. init_ppp_file(struct ppp_file *pf, int kind)
  2304. {
  2305. pf->kind = kind;
  2306. skb_queue_head_init(&pf->xq);
  2307. skb_queue_head_init(&pf->rq);
  2308. atomic_set(&pf->refcnt, 1);
  2309. init_waitqueue_head(&pf->rwait);
  2310. }
  2312. /*
  2313.  * Take down a ppp interface unit - called when the owning file
  2314.  * (the one that created the unit) is closed or detached.
  2315.  */
  2316. static void ppp_shutdown_interface(struct ppp *ppp)
  2317. {
  2318. struct net_device *dev;
  2320. down(&all_ppp_sem);
  2321. ppp_lock(ppp);
  2322. dev = ppp->dev;
  2323. ppp->dev = 0;
  2324. ppp_unlock(ppp);
  2325. if (dev) {
  2326. rtnl_lock();
  2327. dev_close(dev);
  2328. unregister_netdevice(dev);
  2329. rtnl_unlock();
  2330. }
  2331. cardmap_set(&all_ppp_units, ppp->file.index, NULL);
  2332. ppp->file.dead = 1;
  2333. ppp->owner = NULL;
  2334. wake_up_interruptible(&ppp->file.rwait);
  2335. up(&all_ppp_sem);
  2336. }
  2338. /*
  2339.  * Free the memory used by a ppp unit.  This is only called once
  2340.  * there are no channels connected to the unit and no file structs
  2341.  * that reference the unit.
  2342.  */
  2343. static void ppp_destroy_interface(struct ppp *ppp)
  2344. {
  2345. atomic_dec(&ppp_unit_count);
  2347. if (!ppp->file.dead || ppp->n_channels) {
  2348. /* "can't happen" */
  2349. printk(KERN_ERR "ppp: destroying ppp struct %p but dead=%d "
  2350.        "n_channels=%d !n", ppp, ppp->file.dead,
  2351.        ppp->n_channels);
  2352. return;
  2353. }
  2355. ppp_ccp_closed(ppp);
  2356. if (ppp->vj) {
  2357. slhc_free(ppp->vj);
  2358. ppp->vj = 0;
  2359. }
  2360. skb_queue_purge(&ppp->file.xq);
  2361. skb_queue_purge(&ppp->file.rq);
  2362. #ifdef CONFIG_PPP_MULTILINK
  2363. skb_queue_purge(&ppp->mrq);
  2364. #endif /* CONFIG_PPP_MULTILINK */
  2365. #ifdef CONFIG_PPP_FILTER
  2366. if (ppp->pass_filter.filter) {
  2367. kfree(ppp->pass_filter.filter);
  2368. ppp->pass_filter.filter = NULL;
  2369. }
  2370. if (ppp->active_filter.filter) {
  2371. kfree(ppp->active_filter.filter);
  2372. ppp->active_filter.filter = 0;
  2373. }
  2374. #endif /* CONFIG_PPP_FILTER */
  2376. kfree(ppp);
  2377. }
  2379. /*
  2380.  * Locate an existing ppp unit.
  2381.  * The caller should have locked the all_ppp_sem.
  2382.  */
  2383. static struct ppp *
  2384. ppp_find_unit(int unit)
  2385. {
  2386. return cardmap_get(all_ppp_units, unit);
  2387. }
  2389. /*
  2390.  * Locate an existing ppp channel.
  2391.  * The caller should have locked the all_channels_lock.
  2392.  * First we look in the new_channels list, then in the
  2393.  * all_channels list.  If found in the new_channels list,
  2394.  * we move it to the all_channels list.  This is for speed
  2395.  * when we have a lot of channels in use.
  2396.  */
  2397. static struct channel *
  2398. ppp_find_channel(int unit)
  2399. {
  2400. struct channel *pch;
  2401. struct list_head *list;
  2403. list = &new_channels;
  2404. while ((list = list->next) != &new_channels) {
  2405. pch = list_entry(list, struct channel, list);
  2406. if (pch->file.index == unit) {
  2407. list_del(&pch->list);
  2408. list_add(&pch->list, &all_channels);
  2409. return pch;
  2410. }
  2411. }
  2412. list = &all_channels;
  2413. while ((list = list->next) != &all_channels) {
  2414. pch = list_entry(list, struct channel, list);
  2415. if (pch->file.index == unit)
  2416. return pch;
  2417. }
  2418. return 0;
  2419. }
  2421. /*
  2422.  * Connect a PPP channel to a PPP interface unit.
  2423.  */
  2424. static int
  2425. ppp_connect_channel(struct channel *pch, int unit)
  2426. {
  2427. struct ppp *ppp;
  2428. int ret = -ENXIO;
  2429. int hdrlen;
  2431. down(&all_ppp_sem);
  2432. ppp = ppp_find_unit(unit);
  2433. if (ppp == 0)
  2434. goto err1;
  2436. write_lock_bh(&pch->upl);
  2437. ret = -EINVAL;
  2438. if (pch->ppp != 0)
  2439. goto err2;
  2441. ppp_lock(ppp);
  2442. if (pch->file.hdrlen > ppp->file.hdrlen)
  2443. ppp->file.hdrlen = pch->file.hdrlen;
  2444. hdrlen = pch->file.hdrlen + 2; /* for protocol bytes */
  2445. if (ppp->dev && hdrlen > ppp->dev->hard_header_len)
  2446. ppp->dev->hard_header_len = hdrlen;
  2447. list_add_tail(&pch->clist, &ppp->channels);
  2448. ++ppp->n_channels;
  2449. pch->ppp = ppp;
  2450. atomic_inc(&ppp->file.refcnt);
  2451. ppp_unlock(ppp);
  2452. ret = 0;
  2454.  err2:
  2455. write_unlock_bh(&pch->upl);
  2456.  err1:
  2457. up(&all_ppp_sem);
  2458. return ret;
  2459. }
  2461. /*
  2462.  * Disconnect a channel from its ppp unit.
  2463.  */
  2464. static int
  2465. ppp_disconnect_channel(struct channel *pch)
  2466. {
  2467. struct ppp *ppp;
  2468. int err = -EINVAL;
  2470. write_lock_bh(&pch->upl);
  2471. ppp = pch->ppp;
  2472. pch->ppp = NULL;
  2473. write_unlock_bh(&pch->upl);
  2474. if (ppp != 0) {
  2475. /* remove it from the ppp unit's list */
  2476. ppp_lock(ppp);
  2477. list_del(&pch->clist);
  2478. --ppp->n_channels;
  2479. ppp_unlock(ppp);
  2480. if (atomic_dec_and_test(&ppp->file.refcnt))
  2481. ppp_destroy_interface(ppp);
  2482. err = 0;
  2483. }
  2484. return err;
  2485. }
  2487. /*
  2488.  * Free up the resources used by a ppp channel.
  2489.  */
  2490. static void ppp_destroy_channel(struct channel *pch)
  2491. {
  2492. atomic_dec(&channel_count);
  2494. if (!pch->file.dead) {
  2495. /* "can't happen" */
  2496. printk(KERN_ERR "ppp: destroying undead channel %p !n",
  2497.        pch);
  2498. return;
  2499. }
  2500. skb_queue_purge(&pch->file.xq);
  2501. skb_queue_purge(&pch->file.rq);
  2502. kfree(pch);
  2503. }
  2505. static void __exit ppp_cleanup(void)
  2506. {
  2507. /* should never happen */
  2508. if (atomic_read(&ppp_unit_count) || atomic_read(&channel_count))
  2509. printk(KERN_ERR "PPP: removing module but units remain!n");
  2510. cardmap_destroy(&all_ppp_units);
  2511. if (devfs_unregister_chrdev(PPP_MAJOR, "ppp") != 0)
  2512. printk(KERN_ERR "PPP: failed to unregister PPP devicen");
  2513. devfs_unregister(devfs_handle);
  2514. }
  2516. /*
  2517.  * Cardmap implementation.
  2518.  */
  2519. static void *cardmap_get(struct cardmap *map, unsigned int nr)
  2520. {
  2521. struct cardmap *p;
  2522. int i;
  2524. for (p = map; p != NULL; ) {
  2525. if ((i = nr >> p->shift) >= CARDMAP_WIDTH)
  2526. return NULL;
  2527. if (p->shift == 0)
  2528. return p->ptr[i];
  2529. nr &= ~(CARDMAP_MASK << p->shift);
  2530. p = p->ptr[i];
  2531. }
  2532. return NULL;
  2533. }
  2535. static void cardmap_set(struct cardmap **pmap, unsigned int nr, void *ptr)
  2536. {
  2537. struct cardmap *p;
  2538. int i;
  2540. p = *pmap;
  2541. if (p == NULL || (nr >> p->shift) >= CARDMAP_WIDTH) {
  2542. do {
  2543. /* need a new top level */
  2544. struct cardmap *np = kmalloc(sizeof(*np), GFP_KERNEL);
  2545. memset(np, 0, sizeof(*np));
  2546. np->ptr[0] = p;
  2547. if (p != NULL) {
  2548. np->shift = p->shift + CARDMAP_ORDER;
  2549. p->parent = np;
  2550. } else
  2551. np->shift = 0;
  2552. p = np;
  2553. } while ((nr >> p->shift) >= CARDMAP_WIDTH);
  2554. *pmap = p;
  2555. }
  2556. while (p->shift > 0) {
  2557. i = (nr >> p->shift) & CARDMAP_MASK;
  2558. if (p->ptr[i] == NULL) {
  2559. struct cardmap *np = kmalloc(sizeof(*np), GFP_KERNEL);
  2560. memset(np, 0, sizeof(*np));
  2561. np->shift = p->shift - CARDMAP_ORDER;
  2562. np->parent = p;
  2563. p->ptr[i] = np;
  2564. }
  2565. if (ptr == NULL)
  2566. clear_bit(i, &p->inuse);
  2567. p = p->ptr[i];
  2568. }
  2569. i = nr & CARDMAP_MASK;
  2570. p->ptr[i] = ptr;
  2571. if (ptr != NULL)
  2572. set_bit(i, &p->inuse);
  2573. else
  2574. clear_bit(i, &p->inuse);
  2575. }
  2577. static unsigned int cardmap_find_first_free(struct cardmap *map)
  2578. {
  2579. struct cardmap *p;
  2580. unsigned int nr = 0;
  2581. int i;
  2583. if ((p = map) == NULL)
  2584. return 0;
  2585. for (;;) {
  2586. i = find_first_zero_bit(&p->inuse, CARDMAP_WIDTH);
  2587. if (i >= CARDMAP_WIDTH) {
  2588. if (p->parent == NULL)
  2589. return CARDMAP_WIDTH << p->shift;
  2590. p = p->parent;
  2591. i = (nr >> p->shift) & CARDMAP_MASK;
  2592. set_bit(i, &p->inuse);
  2593. continue;
  2594. }
  2595. nr = (nr & (~CARDMAP_MASK << p->shift)) | (i << p->shift);
  2596. if (p->shift == 0 || p->ptr[i] == NULL)
  2597. return nr;
  2598. p = p->ptr[i];
  2599. }
  2600. }
  2602. static void cardmap_destroy(struct cardmap **pmap)
  2603. {
  2604. struct cardmap *p, *np;
  2605. int i;
  2607. for (p = *pmap; p != NULL; p = np) {
  2608. if (p->shift != 0) {
  2609. for (i = 0; i < CARDMAP_WIDTH; ++i)
  2610. if (p->ptr[i] != NULL)
  2611. break;
  2612. if (i < CARDMAP_WIDTH) {
  2613. np = p->ptr[i];
  2614. p->ptr[i] = NULL;
  2615. continue;
  2616. }
  2617. }
  2618. np = p->parent;
  2619. kfree(p);
  2620. }
  2621. *pmap = NULL;
  2622. }
  2624. /* Module/initialization stuff */
  2626. module_init(ppp_init);
  2627. module_exit(ppp_cleanup);
  2629. EXPORT_SYMBOL(ppp_register_channel);
  2630. EXPORT_SYMBOL(ppp_unregister_channel);
  2631. EXPORT_SYMBOL(ppp_channel_index);
  2632. EXPORT_SYMBOL(ppp_unit_number);
  2633. EXPORT_SYMBOL(ppp_input);
  2634. EXPORT_SYMBOL(ppp_input_error);
  2635. EXPORT_SYMBOL(ppp_output_wakeup);
  2636. EXPORT_SYMBOL(ppp_register_compressor);
  2637. EXPORT_SYMBOL(ppp_unregister_compressor);
  2638. EXPORT_SYMBOL(all_ppp_units); /* for debugging */
  2639. EXPORT_SYMBOL(all_channels); /* for debugging */
  2640. MODULE_LICENSE("GPL");