pppoatm.c 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368
  1. /* net/atm/pppoatm.c - RFC2364 PPP over ATM/AAL5 */
  2. /* Copyright 1999-2000 by Mitchell Blank Jr */
  3. /* Based on clip.c; 1995-1999 by Werner Almesberger, EPFL LRC/ICA */
  4. /* And on ppp_async.c; Copyright 1999 Paul Mackerras */
  5. /* And help from Jens Axboe */
  6. /*
  7. * This program is free software; you can redistribute it and/or
  8. * modify it under the terms of the GNU General Public License
  9. * as published by the Free Software Foundation; either version
  10. * 2 of the License, or (at your option) any later version.
  11. *
  12. * This driver provides the encapsulation and framing for sending
  13. * and receiving PPP frames in ATM AAL5 PDUs.
  14. */
  15. /*
  16. * One shortcoming of this driver is that it does not comply with
  17. * section 8 of RFC2364 - we are supposed to detect a change
  18. * in encapsulation and immediately abort the connection (in order
  19. * to avoid a black-hole being created if our peer loses state
  20. * and changes encapsulation unilaterally. However, since the
  21. * ppp_generic layer actually does the decapsulation, we need
  22. * a way of notifying it when we _think_ there might be a problem)
  23. * There's two cases:
  24. * 1. LLC-encapsulation was missing when it was enabled. In
  25. * this case, we should tell the upper layer "tear down
  26. * this session if this skb looks ok to you"
  27. * 2. LLC-encapsulation was present when it was disabled. Then
  28. * we need to tell the upper layer "this packet may be
  29. * ok, but if its in error tear down the session"
  30. * These hooks are not yet available in ppp_generic
  31. */
  32. #include <linux/module.h>
  33. #include <linux/init.h>
  34. #include <linux/skbuff.h>
  35. #include <linux/atm.h>
  36. #include <linux/atmdev.h>
  37. #include <linux/capability.h>
  38. #include <linux/ppp_defs.h>
  39. #include <linux/if_ppp.h>
  40. #include <linux/ppp_channel.h>
  41. #include <linux/atmppp.h>
  42. #include "common.h"
  43. #if 0
  44. #define DPRINTK(format, args...) \
  45. printk(KERN_DEBUG "pppoatm: " format, ##args)
  46. #else
  47. #define DPRINTK(format, args...)
  48. #endif
  49. enum pppoatm_encaps {
  50. e_autodetect = PPPOATM_ENCAPS_AUTODETECT,
  51. e_vc = PPPOATM_ENCAPS_VC,
  52. e_llc = PPPOATM_ENCAPS_LLC,
  53. };
  54. struct pppoatm_vcc {
  55. struct atm_vcc *atmvcc; /* VCC descriptor */
  56. void (*old_push)(struct atm_vcc *, struct sk_buff *);
  57. void (*old_pop)(struct atm_vcc *, struct sk_buff *);
  58. /* keep old push/pop for detaching */
  59. enum pppoatm_encaps encaps;
  60. int flags; /* SC_COMP_PROT - compress protocol */
  61. struct ppp_channel chan; /* interface to generic ppp layer */
  62. struct tasklet_struct wakeup_tasklet;
  63. };
  64. /*
  65. * Header used for LLC Encapsulated PPP (4 bytes) followed by the LCP protocol
  66. * ID (0xC021) used in autodetection
  67. */
  68. static const unsigned char pppllc[6] = { 0xFE, 0xFE, 0x03, 0xCF, 0xC0, 0x21 };
  69. #define LLC_LEN (4)
  70. static inline struct pppoatm_vcc *atmvcc_to_pvcc(const struct atm_vcc *atmvcc)
  71. {
  72. return (struct pppoatm_vcc *) (atmvcc->user_back);
  73. }
  74. static inline struct pppoatm_vcc *chan_to_pvcc(const struct ppp_channel *chan)
  75. {
  76. return (struct pppoatm_vcc *) (chan->private);
  77. }
  78. /*
  79. * We can't do this directly from our _pop handler, since the ppp code
  80. * doesn't want to be called in interrupt context, so we do it from
  81. * a tasklet
  82. */
  83. static void pppoatm_wakeup_sender(unsigned long arg)
  84. {
  85. ppp_output_wakeup((struct ppp_channel *) arg);
  86. }
  87. /*
  88. * This gets called every time the ATM card has finished sending our
  89. * skb. The ->old_pop will take care up normal atm flow control,
  90. * but we also need to wake up the device if we blocked it
  91. */
  92. static void pppoatm_pop(struct atm_vcc *atmvcc, struct sk_buff *skb)
  93. {
  94. struct pppoatm_vcc *pvcc = atmvcc_to_pvcc(atmvcc);
  95. pvcc->old_pop(atmvcc, skb);
  96. /*
  97. * We don't really always want to do this since it's
  98. * really inefficient - it would be much better if we could
  99. * test if we had actually throttled the generic layer.
  100. * Unfortunately then there would be a nasty SMP race where
  101. * we could clear that flag just as we refuse another packet.
  102. * For now we do the safe thing.
  103. */
  104. tasklet_schedule(&pvcc->wakeup_tasklet);
  105. }
  106. /*
  107. * Unbind from PPP - currently we only do this when closing the socket,
  108. * but we could put this into an ioctl if need be
  109. */
  110. static void pppoatm_unassign_vcc(struct atm_vcc *atmvcc)
  111. {
  112. struct pppoatm_vcc *pvcc;
  113. pvcc = atmvcc_to_pvcc(atmvcc);
  114. atmvcc->push = pvcc->old_push;
  115. atmvcc->pop = pvcc->old_pop;
  116. tasklet_kill(&pvcc->wakeup_tasklet);
  117. ppp_unregister_channel(&pvcc->chan);
  118. atmvcc->user_back = NULL;
  119. kfree(pvcc);
  120. /* Gee, I hope we have the big kernel lock here... */
  121. module_put(THIS_MODULE);
  122. }
  123. /* Called when an AAL5 PDU comes in */
  124. static void pppoatm_push(struct atm_vcc *atmvcc, struct sk_buff *skb)
  125. {
  126. struct pppoatm_vcc *pvcc = atmvcc_to_pvcc(atmvcc);
  127. DPRINTK("pppoatm push\n");
  128. if (skb == NULL) { /* VCC was closed */
  129. DPRINTK("removing ATMPPP VCC %p\n", pvcc);
  130. pppoatm_unassign_vcc(atmvcc);
  131. atmvcc->push(atmvcc, NULL); /* Pass along bad news */
  132. return;
  133. }
  134. atm_return(atmvcc, skb->truesize);
  135. switch (pvcc->encaps) {
  136. case e_llc:
  137. if (skb->len < LLC_LEN ||
  138. memcmp(skb->data, pppllc, LLC_LEN))
  139. goto error;
  140. skb_pull(skb, LLC_LEN);
  141. break;
  142. case e_autodetect:
  143. if (pvcc->chan.ppp == NULL) { /* Not bound yet! */
  144. kfree_skb(skb);
  145. return;
  146. }
  147. if (skb->len >= sizeof(pppllc) &&
  148. !memcmp(skb->data, pppllc, sizeof(pppllc))) {
  149. pvcc->encaps = e_llc;
  150. skb_pull(skb, LLC_LEN);
  151. break;
  152. }
  153. if (skb->len >= (sizeof(pppllc) - LLC_LEN) &&
  154. !memcmp(skb->data, &pppllc[LLC_LEN],
  155. sizeof(pppllc) - LLC_LEN)) {
  156. pvcc->encaps = e_vc;
  157. pvcc->chan.mtu += LLC_LEN;
  158. break;
  159. }
  160. DPRINTK("(unit %d): Couldn't autodetect yet "
  161. "(skb: %02X %02X %02X %02X %02X %02X)\n",
  162. pvcc->chan.unit,
  163. skb->data[0], skb->data[1], skb->data[2],
  164. skb->data[3], skb->data[4], skb->data[5]);
  165. goto error;
  166. case e_vc:
  167. break;
  168. }
  169. ppp_input(&pvcc->chan, skb);
  170. return;
  171. error:
  172. kfree_skb(skb);
  173. ppp_input_error(&pvcc->chan, 0);
  174. }
  175. /*
  176. * Called by the ppp_generic.c to send a packet - returns true if packet
  177. * was accepted. If we return false, then it's our job to call
  178. * ppp_output_wakeup(chan) when we're feeling more up to it.
  179. * Note that in the ENOMEM case (as opposed to the !atm_may_send case)
  180. * we should really drop the packet, but the generic layer doesn't
  181. * support this yet. We just return 'DROP_PACKET' which we actually define
  182. * as success, just to be clear what we're really doing.
  183. */
  184. #define DROP_PACKET 1
  185. static int pppoatm_send(struct ppp_channel *chan, struct sk_buff *skb)
  186. {
  187. struct pppoatm_vcc *pvcc = chan_to_pvcc(chan);
  188. ATM_SKB(skb)->vcc = pvcc->atmvcc;
  189. DPRINTK("(unit %d): pppoatm_send (skb=0x%p, vcc=0x%p)\n",
  190. pvcc->chan.unit, skb, pvcc->atmvcc);
  191. if (skb->data[0] == '\0' && (pvcc->flags & SC_COMP_PROT))
  192. (void) skb_pull(skb, 1);
  193. switch (pvcc->encaps) { /* LLC encapsulation needed */
  194. case e_llc:
  195. if (skb_headroom(skb) < LLC_LEN) {
  196. struct sk_buff *n;
  197. n = skb_realloc_headroom(skb, LLC_LEN);
  198. if (n != NULL &&
  199. !atm_may_send(pvcc->atmvcc, n->truesize)) {
  200. kfree_skb(n);
  201. goto nospace;
  202. }
  203. kfree_skb(skb);
  204. if ((skb = n) == NULL)
  205. return DROP_PACKET;
  206. } else if (!atm_may_send(pvcc->atmvcc, skb->truesize))
  207. goto nospace;
  208. memcpy(skb_push(skb, LLC_LEN), pppllc, LLC_LEN);
  209. break;
  210. case e_vc:
  211. if (!atm_may_send(pvcc->atmvcc, skb->truesize))
  212. goto nospace;
  213. break;
  214. case e_autodetect:
  215. DPRINTK("(unit %d): Trying to send without setting encaps!\n",
  216. pvcc->chan.unit);
  217. kfree_skb(skb);
  218. return 1;
  219. }
  220. atomic_add(skb->truesize, &sk_atm(ATM_SKB(skb)->vcc)->sk_wmem_alloc);
  221. ATM_SKB(skb)->atm_options = ATM_SKB(skb)->vcc->atm_options;
  222. DPRINTK("(unit %d): atm_skb(%p)->vcc(%p)->dev(%p)\n",
  223. pvcc->chan.unit, skb, ATM_SKB(skb)->vcc,
  224. ATM_SKB(skb)->vcc->dev);
  225. return ATM_SKB(skb)->vcc->send(ATM_SKB(skb)->vcc, skb)
  226. ? DROP_PACKET : 1;
  227. nospace:
  228. /*
  229. * We don't have space to send this SKB now, but we might have
  230. * already applied SC_COMP_PROT compression, so may need to undo
  231. */
  232. if ((pvcc->flags & SC_COMP_PROT) && skb_headroom(skb) > 0 &&
  233. skb->data[-1] == '\0')
  234. (void) skb_push(skb, 1);
  235. return 0;
  236. }
  237. /* This handles ioctls sent to the /dev/ppp interface */
  238. static int pppoatm_devppp_ioctl(struct ppp_channel *chan, unsigned int cmd,
  239. unsigned long arg)
  240. {
  241. switch (cmd) {
  242. case PPPIOCGFLAGS:
  243. return put_user(chan_to_pvcc(chan)->flags, (int __user *) arg)
  244. ? -EFAULT : 0;
  245. case PPPIOCSFLAGS:
  246. return get_user(chan_to_pvcc(chan)->flags, (int __user *) arg)
  247. ? -EFAULT : 0;
  248. }
  249. return -ENOTTY;
  250. }
  251. static /*const*/ struct ppp_channel_ops pppoatm_ops = {
  252. .start_xmit = pppoatm_send,
  253. .ioctl = pppoatm_devppp_ioctl,
  254. };
  255. static int pppoatm_assign_vcc(struct atm_vcc *atmvcc, void __user *arg)
  256. {
  257. struct atm_backend_ppp be;
  258. struct pppoatm_vcc *pvcc;
  259. int err;
  260. /*
  261. * Each PPPoATM instance has its own tasklet - this is just a
  262. * prototypical one used to initialize them
  263. */
  264. static const DECLARE_TASKLET(tasklet_proto, pppoatm_wakeup_sender, 0);
  265. if (copy_from_user(&be, arg, sizeof be))
  266. return -EFAULT;
  267. if (be.encaps != PPPOATM_ENCAPS_AUTODETECT &&
  268. be.encaps != PPPOATM_ENCAPS_VC && be.encaps != PPPOATM_ENCAPS_LLC)
  269. return -EINVAL;
  270. pvcc = kzalloc(sizeof(*pvcc), GFP_KERNEL);
  271. if (pvcc == NULL)
  272. return -ENOMEM;
  273. pvcc->atmvcc = atmvcc;
  274. pvcc->old_push = atmvcc->push;
  275. pvcc->old_pop = atmvcc->pop;
  276. pvcc->encaps = (enum pppoatm_encaps) be.encaps;
  277. pvcc->chan.private = pvcc;
  278. pvcc->chan.ops = &pppoatm_ops;
  279. pvcc->chan.mtu = atmvcc->qos.txtp.max_sdu - PPP_HDRLEN -
  280. (be.encaps == e_vc ? 0 : LLC_LEN);
  281. pvcc->wakeup_tasklet = tasklet_proto;
  282. pvcc->wakeup_tasklet.data = (unsigned long) &pvcc->chan;
  283. if ((err = ppp_register_channel(&pvcc->chan)) != 0) {
  284. kfree(pvcc);
  285. return err;
  286. }
  287. atmvcc->user_back = pvcc;
  288. atmvcc->push = pppoatm_push;
  289. atmvcc->pop = pppoatm_pop;
  290. __module_get(THIS_MODULE);
  291. return 0;
  292. }
  293. /*
  294. * This handles ioctls actually performed on our vcc - we must return
  295. * -ENOIOCTLCMD for any unrecognized ioctl
  296. */
  297. static int pppoatm_ioctl(struct socket *sock, unsigned int cmd,
  298. unsigned long arg)
  299. {
  300. struct atm_vcc *atmvcc = ATM_SD(sock);
  301. void __user *argp = (void __user *)arg;
  302. if (cmd != ATM_SETBACKEND && atmvcc->push != pppoatm_push)
  303. return -ENOIOCTLCMD;
  304. switch (cmd) {
  305. case ATM_SETBACKEND: {
  306. atm_backend_t b;
  307. if (get_user(b, (atm_backend_t __user *) argp))
  308. return -EFAULT;
  309. if (b != ATM_BACKEND_PPP)
  310. return -ENOIOCTLCMD;
  311. if (!capable(CAP_NET_ADMIN))
  312. return -EPERM;
  313. return pppoatm_assign_vcc(atmvcc, argp);
  314. }
  315. case PPPIOCGCHAN:
  316. return put_user(ppp_channel_index(&atmvcc_to_pvcc(atmvcc)->
  317. chan), (int __user *) argp) ? -EFAULT : 0;
  318. case PPPIOCGUNIT:
  319. return put_user(ppp_unit_number(&atmvcc_to_pvcc(atmvcc)->
  320. chan), (int __user *) argp) ? -EFAULT : 0;
  321. }
  322. return -ENOIOCTLCMD;
  323. }
  324. static struct atm_ioctl pppoatm_ioctl_ops = {
  325. .owner = THIS_MODULE,
  326. .ioctl = pppoatm_ioctl,
  327. };
  328. static int __init pppoatm_init(void)
  329. {
  330. register_atm_ioctl(&pppoatm_ioctl_ops);
  331. return 0;
  332. }
  333. static void __exit pppoatm_exit(void)
  334. {
  335. deregister_atm_ioctl(&pppoatm_ioctl_ops);
  336. }
  337. module_init(pppoatm_init);
  338. module_exit(pppoatm_exit);
  339. MODULE_AUTHOR("Mitchell Blank Jr <mitch@sfgoth.com>");
  340. MODULE_DESCRIPTION("RFC2364 PPP over ATM/AAL5");
  341. MODULE_LICENSE("GPL");