1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36#include <linux/module.h>
37#include <linux/init.h>
38#include <linux/skbuff.h>
39#include <linux/atm.h>
40#include <linux/atmdev.h>
41#include <linux/capability.h>
42#include <linux/ppp_defs.h>
43#include <linux/if_ppp.h>
44#include <linux/ppp_channel.h>
45#include <linux/atmppp.h>
46
47#include "common.h"
48
49enum pppoatm_encaps {
50 e_autodetect = PPPOATM_ENCAPS_AUTODETECT,
51 e_vc = PPPOATM_ENCAPS_VC,
52 e_llc = PPPOATM_ENCAPS_LLC,
53};
54
55struct pppoatm_vcc {
56 struct atm_vcc *atmvcc;
57 void (*old_push)(struct atm_vcc *, struct sk_buff *);
58 void (*old_pop)(struct atm_vcc *, struct sk_buff *);
59
60 enum pppoatm_encaps encaps;
61 int flags;
62 struct ppp_channel chan;
63 struct tasklet_struct wakeup_tasklet;
64};
65
66
67
68
69
70static const unsigned char pppllc[6] = { 0xFE, 0xFE, 0x03, 0xCF, 0xC0, 0x21 };
71#define LLC_LEN (4)
72
73static inline struct pppoatm_vcc *atmvcc_to_pvcc(const struct atm_vcc *atmvcc)
74{
75 return (struct pppoatm_vcc *) (atmvcc->user_back);
76}
77
78static inline struct pppoatm_vcc *chan_to_pvcc(const struct ppp_channel *chan)
79{
80 return (struct pppoatm_vcc *) (chan->private);
81}
82
83
84
85
86
87
88static void pppoatm_wakeup_sender(unsigned long arg)
89{
90 ppp_output_wakeup((struct ppp_channel *) arg);
91}
92
93
94
95
96
97
98static void pppoatm_pop(struct atm_vcc *atmvcc, struct sk_buff *skb)
99{
100 struct pppoatm_vcc *pvcc = atmvcc_to_pvcc(atmvcc);
101 pvcc->old_pop(atmvcc, skb);
102
103
104
105
106
107
108
109
110 tasklet_schedule(&pvcc->wakeup_tasklet);
111}
112
113
114
115
116
117static void pppoatm_unassign_vcc(struct atm_vcc *atmvcc)
118{
119 struct pppoatm_vcc *pvcc;
120 pvcc = atmvcc_to_pvcc(atmvcc);
121 atmvcc->push = pvcc->old_push;
122 atmvcc->pop = pvcc->old_pop;
123 tasklet_kill(&pvcc->wakeup_tasklet);
124 ppp_unregister_channel(&pvcc->chan);
125 atmvcc->user_back = NULL;
126 kfree(pvcc);
127
128 module_put(THIS_MODULE);
129}
130
131
132static void pppoatm_push(struct atm_vcc *atmvcc, struct sk_buff *skb)
133{
134 struct pppoatm_vcc *pvcc = atmvcc_to_pvcc(atmvcc);
135 pr_debug("pppoatm push\n");
136 if (skb == NULL) {
137 pr_debug("removing ATMPPP VCC %p\n", pvcc);
138 pppoatm_unassign_vcc(atmvcc);
139 atmvcc->push(atmvcc, NULL);
140 return;
141 }
142 atm_return(atmvcc, skb->truesize);
143 switch (pvcc->encaps) {
144 case e_llc:
145 if (skb->len < LLC_LEN ||
146 memcmp(skb->data, pppllc, LLC_LEN))
147 goto error;
148 skb_pull(skb, LLC_LEN);
149 break;
150 case e_autodetect:
151 if (pvcc->chan.ppp == NULL) {
152 kfree_skb(skb);
153 return;
154 }
155 if (skb->len >= sizeof(pppllc) &&
156 !memcmp(skb->data, pppllc, sizeof(pppllc))) {
157 pvcc->encaps = e_llc;
158 skb_pull(skb, LLC_LEN);
159 break;
160 }
161 if (skb->len >= (sizeof(pppllc) - LLC_LEN) &&
162 !memcmp(skb->data, &pppllc[LLC_LEN],
163 sizeof(pppllc) - LLC_LEN)) {
164 pvcc->encaps = e_vc;
165 pvcc->chan.mtu += LLC_LEN;
166 break;
167 }
168 pr_debug("Couldn't autodetect yet "
169 "(skb: %02X %02X %02X %02X %02X %02X)\n",
170 skb->data[0], skb->data[1], skb->data[2],
171 skb->data[3], skb->data[4], skb->data[5]);
172 goto error;
173 case e_vc:
174 break;
175 }
176 ppp_input(&pvcc->chan, skb);
177 return;
178 error:
179 kfree_skb(skb);
180 ppp_input_error(&pvcc->chan, 0);
181}
182
183
184
185
186
187
188
189
190
191
192#define DROP_PACKET 1
193static int pppoatm_send(struct ppp_channel *chan, struct sk_buff *skb)
194{
195 struct pppoatm_vcc *pvcc = chan_to_pvcc(chan);
196 ATM_SKB(skb)->vcc = pvcc->atmvcc;
197 pr_debug("pppoatm_send (skb=0x%p, vcc=0x%p)\n", skb, pvcc->atmvcc);
198 if (skb->data[0] == '\0' && (pvcc->flags & SC_COMP_PROT))
199 (void) skb_pull(skb, 1);
200 switch (pvcc->encaps) {
201 case e_llc:
202 if (skb_headroom(skb) < LLC_LEN) {
203 struct sk_buff *n;
204 n = skb_realloc_headroom(skb, LLC_LEN);
205 if (n != NULL &&
206 !atm_may_send(pvcc->atmvcc, n->truesize)) {
207 kfree_skb(n);
208 goto nospace;
209 }
210 kfree_skb(skb);
211 if ((skb = n) == NULL)
212 return DROP_PACKET;
213 } else if (!atm_may_send(pvcc->atmvcc, skb->truesize))
214 goto nospace;
215 memcpy(skb_push(skb, LLC_LEN), pppllc, LLC_LEN);
216 break;
217 case e_vc:
218 if (!atm_may_send(pvcc->atmvcc, skb->truesize))
219 goto nospace;
220 break;
221 case e_autodetect:
222 pr_debug("Trying to send without setting encaps!\n");
223 kfree_skb(skb);
224 return 1;
225 }
226
227 atomic_add(skb->truesize, &sk_atm(ATM_SKB(skb)->vcc)->sk_wmem_alloc);
228 ATM_SKB(skb)->atm_options = ATM_SKB(skb)->vcc->atm_options;
229 pr_debug("atm_skb(%p)->vcc(%p)->dev(%p)\n", skb, ATM_SKB(skb)->vcc,
230 ATM_SKB(skb)->vcc->dev);
231 return ATM_SKB(skb)->vcc->send(ATM_SKB(skb)->vcc, skb)
232 ? DROP_PACKET : 1;
233 nospace:
234
235
236
237
238 if ((pvcc->flags & SC_COMP_PROT) && skb_headroom(skb) > 0 &&
239 skb->data[-1] == '\0')
240 (void) skb_push(skb, 1);
241 return 0;
242}
243
244
245static int pppoatm_devppp_ioctl(struct ppp_channel *chan, unsigned int cmd,
246 unsigned long arg)
247{
248 switch (cmd) {
249 case PPPIOCGFLAGS:
250 return put_user(chan_to_pvcc(chan)->flags, (int __user *) arg)
251 ? -EFAULT : 0;
252 case PPPIOCSFLAGS:
253 return get_user(chan_to_pvcc(chan)->flags, (int __user *) arg)
254 ? -EFAULT : 0;
255 }
256 return -ENOTTY;
257}
258
259static struct ppp_channel_ops pppoatm_ops = {
260 .start_xmit = pppoatm_send,
261 .ioctl = pppoatm_devppp_ioctl,
262};
263
264static int pppoatm_assign_vcc(struct atm_vcc *atmvcc, void __user *arg)
265{
266 struct atm_backend_ppp be;
267 struct pppoatm_vcc *pvcc;
268 int err;
269
270
271
272
273 static const DECLARE_TASKLET(tasklet_proto, pppoatm_wakeup_sender, 0);
274 if (copy_from_user(&be, arg, sizeof be))
275 return -EFAULT;
276 if (be.encaps != PPPOATM_ENCAPS_AUTODETECT &&
277 be.encaps != PPPOATM_ENCAPS_VC && be.encaps != PPPOATM_ENCAPS_LLC)
278 return -EINVAL;
279 pvcc = kzalloc(sizeof(*pvcc), GFP_KERNEL);
280 if (pvcc == NULL)
281 return -ENOMEM;
282 pvcc->atmvcc = atmvcc;
283 pvcc->old_push = atmvcc->push;
284 pvcc->old_pop = atmvcc->pop;
285 pvcc->encaps = (enum pppoatm_encaps) be.encaps;
286 pvcc->chan.private = pvcc;
287 pvcc->chan.ops = &pppoatm_ops;
288 pvcc->chan.mtu = atmvcc->qos.txtp.max_sdu - PPP_HDRLEN -
289 (be.encaps == e_vc ? 0 : LLC_LEN);
290 pvcc->wakeup_tasklet = tasklet_proto;
291 pvcc->wakeup_tasklet.data = (unsigned long) &pvcc->chan;
292 if ((err = ppp_register_channel(&pvcc->chan)) != 0) {
293 kfree(pvcc);
294 return err;
295 }
296 atmvcc->user_back = pvcc;
297 atmvcc->push = pppoatm_push;
298 atmvcc->pop = pppoatm_pop;
299 __module_get(THIS_MODULE);
300 return 0;
301}
302
303
304
305
306
307static int pppoatm_ioctl(struct socket *sock, unsigned int cmd,
308 unsigned long arg)
309{
310 struct atm_vcc *atmvcc = ATM_SD(sock);
311 void __user *argp = (void __user *)arg;
312
313 if (cmd != ATM_SETBACKEND && atmvcc->push != pppoatm_push)
314 return -ENOIOCTLCMD;
315 switch (cmd) {
316 case ATM_SETBACKEND: {
317 atm_backend_t b;
318 if (get_user(b, (atm_backend_t __user *) argp))
319 return -EFAULT;
320 if (b != ATM_BACKEND_PPP)
321 return -ENOIOCTLCMD;
322 if (!capable(CAP_NET_ADMIN))
323 return -EPERM;
324 return pppoatm_assign_vcc(atmvcc, argp);
325 }
326 case PPPIOCGCHAN:
327 return put_user(ppp_channel_index(&atmvcc_to_pvcc(atmvcc)->
328 chan), (int __user *) argp) ? -EFAULT : 0;
329 case PPPIOCGUNIT:
330 return put_user(ppp_unit_number(&atmvcc_to_pvcc(atmvcc)->
331 chan), (int __user *) argp) ? -EFAULT : 0;
332 }
333 return -ENOIOCTLCMD;
334}
335
336static struct atm_ioctl pppoatm_ioctl_ops = {
337 .owner = THIS_MODULE,
338 .ioctl = pppoatm_ioctl,
339};
340
341static int __init pppoatm_init(void)
342{
343 register_atm_ioctl(&pppoatm_ioctl_ops);
344 return 0;
345}
346
347static void __exit pppoatm_exit(void)
348{
349 deregister_atm_ioctl(&pppoatm_ioctl_ops);
350}
351
352module_init(pppoatm_init);
353module_exit(pppoatm_exit);
354
355MODULE_AUTHOR("Mitchell Blank Jr <mitch@sfgoth.com>");
356MODULE_DESCRIPTION("RFC2364 PPP over ATM/AAL5");
357MODULE_LICENSE("GPL");
358