Root/drivers/net/pppoe.c

1/** -*- linux-c -*- ***********************************************************
2 * Linux PPP over Ethernet (PPPoX/PPPoE) Sockets
3 *
4 * PPPoX --- Generic PPP encapsulation socket family
5 * PPPoE --- PPP over Ethernet (RFC 2516)
6 *
7 *
8 * Version: 0.7.0
9 *
10 * 070228 : Fix to allow multiple sessions with same remote MAC and same
11 * session id by including the local device ifindex in the
12 * tuple identifying a session. This also ensures packets can't
13 * be injected into a session from interfaces other than the one
14 * specified by userspace. Florian Zumbiehl <florz@florz.de>
15 * (Oh, BTW, this one is YYMMDD, in case you were wondering ...)
16 * 220102 : Fix module use count on failure in pppoe_create, pppox_sk -acme
17 * 030700 : Fixed connect logic to allow for disconnect.
18 * 270700 : Fixed potential SMP problems; we must protect against
19 * simultaneous invocation of ppp_input
20 * and ppp_unregister_channel.
21 * 040800 : Respect reference count mechanisms on net-devices.
22 * 200800 : fix kfree(skb) in pppoe_rcv (acme)
23 * Module reference count is decremented in the right spot now,
24 * guards against sock_put not actually freeing the sk
25 * in pppoe_release.
26 * 051000 : Initialization cleanup.
27 * 111100 : Fix recvmsg.
28 * 050101 : Fix PADT procesing.
29 * 140501 : Use pppoe_rcv_core to handle all backlog. (Alexey)
30 * 170701 : Do not lock_sock with rwlock held. (DaveM)
31 * Ignore discovery frames if user has socket
32 * locked. (DaveM)
33 * Ignore return value of dev_queue_xmit in __pppoe_xmit
34 * or else we may kfree an SKB twice. (DaveM)
35 * 190701 : When doing copies of skb's in __pppoe_xmit, always delete
36 * the original skb that was passed in on success, never on
37 * failure. Delete the copy of the skb on failure to avoid
38 * a memory leak.
39 * 081001 : Misc. cleanup (licence string, non-blocking, prevent
40 * reference of device on close).
41 * 121301 : New ppp channels interface; cannot unregister a channel
42 * from interrupts. Thus, we mark the socket as a ZOMBIE
43 * and do the unregistration later.
44 * 081002 : seq_file support for proc stuff -acme
45 * 111602 : Merge all 2.4 fixes into 2.5/2.6 tree. Label 2.5/2.6
46 * as version 0.7. Spacing cleanup.
47 * Author: Michal Ostrowski <mostrows@speakeasy.net>
48 * Contributors:
49 * Arnaldo Carvalho de Melo <acme@conectiva.com.br>
50 * David S. Miller (davem@redhat.com)
51 *
52 * License:
53 * This program is free software; you can redistribute it and/or
54 * modify it under the terms of the GNU General Public License
55 * as published by the Free Software Foundation; either version
56 * 2 of the License, or (at your option) any later version.
57 *
58 */
59
60#include <linux/string.h>
61#include <linux/module.h>
62#include <linux/kernel.h>
63#include <linux/slab.h>
64#include <linux/errno.h>
65#include <linux/netdevice.h>
66#include <linux/net.h>
67#include <linux/inetdevice.h>
68#include <linux/etherdevice.h>
69#include <linux/skbuff.h>
70#include <linux/init.h>
71#include <linux/if_ether.h>
72#include <linux/if_pppox.h>
73#include <linux/ppp_channel.h>
74#include <linux/ppp_defs.h>
75#include <linux/if_ppp.h>
76#include <linux/notifier.h>
77#include <linux/file.h>
78#include <linux/proc_fs.h>
79#include <linux/seq_file.h>
80
81#include <linux/nsproxy.h>
82#include <net/net_namespace.h>
83#include <net/netns/generic.h>
84#include <net/sock.h>
85
86#include <asm/uaccess.h>
87
88#define PPPOE_HASH_BITS 4
89#define PPPOE_HASH_SIZE (1 << PPPOE_HASH_BITS)
90#define PPPOE_HASH_MASK (PPPOE_HASH_SIZE - 1)
91
92static int pppoe_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg);
93static int pppoe_xmit(struct ppp_channel *chan, struct sk_buff *skb);
94static int __pppoe_xmit(struct sock *sk, struct sk_buff *skb);
95
96static const struct proto_ops pppoe_ops;
97static struct ppp_channel_ops pppoe_chan_ops;
98
99/* per-net private data for this module */
100static int pppoe_net_id;
101struct pppoe_net {
102    /*
103     * we could use _single_ hash table for all
104     * nets by injecting net id into the hash but
105     * it would increase hash chains and add
106     * a few additional math comparations messy
107     * as well, moreover in case of SMP less locking
108     * controversy here
109     */
110    struct pppox_sock *hash_table[PPPOE_HASH_SIZE];
111    rwlock_t hash_lock;
112};
113
114/* to eliminate a race btw pppoe_flush_dev and pppoe_release */
115static DEFINE_SPINLOCK(flush_lock);
116
117/*
118 * PPPoE could be in the following stages:
119 * 1) Discovery stage (to obtain remote MAC and Session ID)
120 * 2) Session stage (MAC and SID are known)
121 *
122 * Ethernet frames have a special tag for this but
123 * we use simplier approach based on session id
124 */
125static inline bool stage_session(__be16 sid)
126{
127    return sid != 0;
128}
129
130static inline struct pppoe_net *pppoe_pernet(struct net *net)
131{
132    BUG_ON(!net);
133
134    return net_generic(net, pppoe_net_id);
135}
136
137static inline int cmp_2_addr(struct pppoe_addr *a, struct pppoe_addr *b)
138{
139    return a->sid == b->sid && !memcmp(a->remote, b->remote, ETH_ALEN);
140}
141
142static inline int cmp_addr(struct pppoe_addr *a, __be16 sid, char *addr)
143{
144    return a->sid == sid && !memcmp(a->remote, addr, ETH_ALEN);
145}
146
147#if 8 % PPPOE_HASH_BITS
148#error 8 must be a multiple of PPPOE_HASH_BITS
149#endif
150
151static int hash_item(__be16 sid, unsigned char *addr)
152{
153    unsigned char hash = 0;
154    unsigned int i;
155
156    for (i = 0; i < ETH_ALEN; i++)
157        hash ^= addr[i];
158    for (i = 0; i < sizeof(sid_t) * 8; i += 8)
159        hash ^= (__force __u32)sid >> i;
160    for (i = 8; (i >>= 1) >= PPPOE_HASH_BITS;)
161        hash ^= hash >> i;
162
163    return hash & PPPOE_HASH_MASK;
164}
165
166/**********************************************************************
167 *
168 * Set/get/delete/rehash items (internal versions)
169 *
170 **********************************************************************/
171static struct pppox_sock *__get_item(struct pppoe_net *pn, __be16 sid,
172                unsigned char *addr, int ifindex)
173{
174    int hash = hash_item(sid, addr);
175    struct pppox_sock *ret;
176
177    ret = pn->hash_table[hash];
178    while (ret) {
179        if (cmp_addr(&ret->pppoe_pa, sid, addr) &&
180            ret->pppoe_ifindex == ifindex)
181            return ret;
182
183        ret = ret->next;
184    }
185
186    return NULL;
187}
188
189static int __set_item(struct pppoe_net *pn, struct pppox_sock *po)
190{
191    int hash = hash_item(po->pppoe_pa.sid, po->pppoe_pa.remote);
192    struct pppox_sock *ret;
193
194    ret = pn->hash_table[hash];
195    while (ret) {
196        if (cmp_2_addr(&ret->pppoe_pa, &po->pppoe_pa) &&
197            ret->pppoe_ifindex == po->pppoe_ifindex)
198            return -EALREADY;
199
200        ret = ret->next;
201    }
202
203    po->next = pn->hash_table[hash];
204    pn->hash_table[hash] = po;
205
206    return 0;
207}
208
209static struct pppox_sock *__delete_item(struct pppoe_net *pn, __be16 sid,
210                    char *addr, int ifindex)
211{
212    int hash = hash_item(sid, addr);
213    struct pppox_sock *ret, **src;
214
215    ret = pn->hash_table[hash];
216    src = &pn->hash_table[hash];
217
218    while (ret) {
219        if (cmp_addr(&ret->pppoe_pa, sid, addr) &&
220            ret->pppoe_ifindex == ifindex) {
221            *src = ret->next;
222            break;
223        }
224
225        src = &ret->next;
226        ret = ret->next;
227    }
228
229    return ret;
230}
231
232/**********************************************************************
233 *
234 * Set/get/delete/rehash items
235 *
236 **********************************************************************/
237static inline struct pppox_sock *get_item(struct pppoe_net *pn, __be16 sid,
238                    unsigned char *addr, int ifindex)
239{
240    struct pppox_sock *po;
241
242    read_lock_bh(&pn->hash_lock);
243    po = __get_item(pn, sid, addr, ifindex);
244    if (po)
245        sock_hold(sk_pppox(po));
246    read_unlock_bh(&pn->hash_lock);
247
248    return po;
249}
250
251static inline struct pppox_sock *get_item_by_addr(struct net *net,
252                        struct sockaddr_pppox *sp)
253{
254    struct net_device *dev;
255    struct pppoe_net *pn;
256    struct pppox_sock *pppox_sock;
257
258    int ifindex;
259
260    dev = dev_get_by_name(net, sp->sa_addr.pppoe.dev);
261    if (!dev)
262        return NULL;
263
264    ifindex = dev->ifindex;
265    pn = net_generic(net, pppoe_net_id);
266    pppox_sock = get_item(pn, sp->sa_addr.pppoe.sid,
267                sp->sa_addr.pppoe.remote, ifindex);
268    dev_put(dev);
269
270    return pppox_sock;
271}
272
273static inline struct pppox_sock *delete_item(struct pppoe_net *pn, __be16 sid,
274                    char *addr, int ifindex)
275{
276    struct pppox_sock *ret;
277
278    write_lock_bh(&pn->hash_lock);
279    ret = __delete_item(pn, sid, addr, ifindex);
280    write_unlock_bh(&pn->hash_lock);
281
282    return ret;
283}
284
285/***************************************************************************
286 *
287 * Handler for device events.
288 * Certain device events require that sockets be unconnected.
289 *
290 **************************************************************************/
291
292static void pppoe_flush_dev(struct net_device *dev)
293{
294    struct pppoe_net *pn;
295    int i;
296
297    BUG_ON(dev == NULL);
298
299    pn = pppoe_pernet(dev_net(dev));
300    if (!pn) /* already freed */
301        return;
302
303    write_lock_bh(&pn->hash_lock);
304    for (i = 0; i < PPPOE_HASH_SIZE; i++) {
305        struct pppox_sock *po = pn->hash_table[i];
306
307        while (po != NULL) {
308            struct sock *sk;
309            if (po->pppoe_dev != dev) {
310                po = po->next;
311                continue;
312            }
313            sk = sk_pppox(po);
314            spin_lock(&flush_lock);
315            po->pppoe_dev = NULL;
316            spin_unlock(&flush_lock);
317            dev_put(dev);
318
319            /* We always grab the socket lock, followed by the
320             * hash_lock, in that order. Since we should
321             * hold the sock lock while doing any unbinding,
322             * we need to release the lock we're holding.
323             * Hold a reference to the sock so it doesn't disappear
324             * as we're jumping between locks.
325             */
326
327            sock_hold(sk);
328
329            write_unlock_bh(&pn->hash_lock);
330            lock_sock(sk);
331
332            if (sk->sk_state & (PPPOX_CONNECTED | PPPOX_BOUND)) {
333                pppox_unbind_sock(sk);
334                sk->sk_state = PPPOX_ZOMBIE;
335                sk->sk_state_change(sk);
336            }
337
338            release_sock(sk);
339            sock_put(sk);
340
341            /* Restart scan at the beginning of this hash chain.
342             * While the lock was dropped the chain contents may
343             * have changed.
344             */
345            write_lock_bh(&pn->hash_lock);
346            po = pn->hash_table[i];
347        }
348    }
349    write_unlock_bh(&pn->hash_lock);
350}
351
352static int pppoe_device_event(struct notifier_block *this,
353                  unsigned long event, void *ptr)
354{
355    struct net_device *dev = (struct net_device *)ptr;
356
357    /* Only look at sockets that are using this specific device. */
358    switch (event) {
359    case NETDEV_CHANGEMTU:
360        /* A change in mtu is a bad thing, requiring
361         * LCP re-negotiation.
362         */
363
364    case NETDEV_GOING_DOWN:
365    case NETDEV_DOWN:
366        /* Find every socket on this device and kill it. */
367        pppoe_flush_dev(dev);
368        break;
369
370    default:
371        break;
372    };
373
374    return NOTIFY_DONE;
375}
376
377static struct notifier_block pppoe_notifier = {
378    .notifier_call = pppoe_device_event,
379};
380
381/************************************************************************
382 *
383 * Do the real work of receiving a PPPoE Session frame.
384 *
385 ***********************************************************************/
386static int pppoe_rcv_core(struct sock *sk, struct sk_buff *skb)
387{
388    struct pppox_sock *po = pppox_sk(sk);
389    struct pppox_sock *relay_po;
390
391    if (sk->sk_state & PPPOX_BOUND) {
392        ppp_input(&po->chan, skb);
393    } else if (sk->sk_state & PPPOX_RELAY) {
394        relay_po = get_item_by_addr(dev_net(po->pppoe_dev),
395                        &po->pppoe_relay);
396        if (relay_po == NULL)
397            goto abort_kfree;
398
399        if ((sk_pppox(relay_po)->sk_state & PPPOX_CONNECTED) == 0)
400            goto abort_put;
401
402        if (!__pppoe_xmit(sk_pppox(relay_po), skb))
403            goto abort_put;
404    } else {
405        if (sock_queue_rcv_skb(sk, skb))
406            goto abort_kfree;
407    }
408
409    return NET_RX_SUCCESS;
410
411abort_put:
412    sock_put(sk_pppox(relay_po));
413
414abort_kfree:
415    kfree_skb(skb);
416    return NET_RX_DROP;
417}
418
419/************************************************************************
420 *
421 * Receive wrapper called in BH context.
422 *
423 ***********************************************************************/
424static int pppoe_rcv(struct sk_buff *skb, struct net_device *dev,
425             struct packet_type *pt, struct net_device *orig_dev)
426{
427    struct pppoe_hdr *ph;
428    struct pppox_sock *po;
429    struct pppoe_net *pn;
430    int len;
431
432    skb = skb_share_check(skb, GFP_ATOMIC);
433    if (!skb)
434        goto out;
435
436    if (!pskb_may_pull(skb, sizeof(struct pppoe_hdr)))
437        goto drop;
438
439    ph = pppoe_hdr(skb);
440    len = ntohs(ph->length);
441
442    skb_pull_rcsum(skb, sizeof(*ph));
443    if (skb->len < len)
444        goto drop;
445
446    if (pskb_trim_rcsum(skb, len))
447        goto drop;
448
449    pn = pppoe_pernet(dev_net(dev));
450    po = get_item(pn, ph->sid, eth_hdr(skb)->h_source, dev->ifindex);
451    if (!po)
452        goto drop;
453
454    return sk_receive_skb(sk_pppox(po), skb, 0);
455
456drop:
457    kfree_skb(skb);
458out:
459    return NET_RX_DROP;
460}
461
462/************************************************************************
463 *
464 * Receive a PPPoE Discovery frame.
465 * This is solely for detection of PADT frames
466 *
467 ***********************************************************************/
468static int pppoe_disc_rcv(struct sk_buff *skb, struct net_device *dev,
469              struct packet_type *pt, struct net_device *orig_dev)
470
471{
472    struct pppoe_hdr *ph;
473    struct pppox_sock *po;
474    struct pppoe_net *pn;
475
476    skb = skb_share_check(skb, GFP_ATOMIC);
477    if (!skb)
478        goto out;
479
480    if (!pskb_may_pull(skb, sizeof(struct pppoe_hdr)))
481        goto abort;
482
483    ph = pppoe_hdr(skb);
484    if (ph->code != PADT_CODE)
485        goto abort;
486
487    pn = pppoe_pernet(dev_net(dev));
488    po = get_item(pn, ph->sid, eth_hdr(skb)->h_source, dev->ifindex);
489    if (po) {
490        struct sock *sk = sk_pppox(po);
491
492        bh_lock_sock(sk);
493
494        /* If the user has locked the socket, just ignore
495         * the packet. With the way two rcv protocols hook into
496         * one socket family type, we cannot (easily) distinguish
497         * what kind of SKB it is during backlog rcv.
498         */
499        if (sock_owned_by_user(sk) == 0) {
500            /* We're no longer connect at the PPPOE layer,
501             * and must wait for ppp channel to disconnect us.
502             */
503            sk->sk_state = PPPOX_ZOMBIE;
504        }
505
506        bh_unlock_sock(sk);
507        sock_put(sk);
508    }
509
510abort:
511    kfree_skb(skb);
512out:
513    return NET_RX_SUCCESS; /* Lies... :-) */
514}
515
516static struct packet_type pppoes_ptype __read_mostly = {
517    .type = cpu_to_be16(ETH_P_PPP_SES),
518    .func = pppoe_rcv,
519};
520
521static struct packet_type pppoed_ptype __read_mostly = {
522    .type = cpu_to_be16(ETH_P_PPP_DISC),
523    .func = pppoe_disc_rcv,
524};
525
526static struct proto pppoe_sk_proto __read_mostly = {
527    .name = "PPPOE",
528    .owner = THIS_MODULE,
529    .obj_size = sizeof(struct pppox_sock),
530};
531
532/***********************************************************************
533 *
534 * Initialize a new struct sock.
535 *
536 **********************************************************************/
537static int pppoe_create(struct net *net, struct socket *sock)
538{
539    struct sock *sk;
540
541    sk = sk_alloc(net, PF_PPPOX, GFP_KERNEL, &pppoe_sk_proto);
542    if (!sk)
543        return -ENOMEM;
544
545    sock_init_data(sock, sk);
546
547    sock->state = SS_UNCONNECTED;
548    sock->ops = &pppoe_ops;
549
550    sk->sk_backlog_rcv = pppoe_rcv_core;
551    sk->sk_state = PPPOX_NONE;
552    sk->sk_type = SOCK_STREAM;
553    sk->sk_family = PF_PPPOX;
554    sk->sk_protocol = PX_PROTO_OE;
555
556    return 0;
557}
558
559static int pppoe_release(struct socket *sock)
560{
561    struct sock *sk = sock->sk;
562    struct pppox_sock *po;
563    struct pppoe_net *pn;
564
565    if (!sk)
566        return 0;
567
568    lock_sock(sk);
569    if (sock_flag(sk, SOCK_DEAD)) {
570        release_sock(sk);
571        return -EBADF;
572    }
573
574    pppox_unbind_sock(sk);
575
576    /* Signal the death of the socket. */
577    sk->sk_state = PPPOX_DEAD;
578
579    /*
580     * pppoe_flush_dev could lead to a race with
581     * this routine so we use flush_lock to eliminate
582     * such a case (we only need per-net specific data)
583     */
584    spin_lock(&flush_lock);
585    po = pppox_sk(sk);
586    if (!po->pppoe_dev) {
587        spin_unlock(&flush_lock);
588        goto out;
589    }
590    pn = pppoe_pernet(dev_net(po->pppoe_dev));
591    spin_unlock(&flush_lock);
592
593    /*
594     * protect "po" from concurrent updates
595     * on pppoe_flush_dev
596     */
597    write_lock_bh(&pn->hash_lock);
598
599    po = pppox_sk(sk);
600    if (stage_session(po->pppoe_pa.sid))
601        __delete_item(pn, po->pppoe_pa.sid, po->pppoe_pa.remote,
602                po->pppoe_ifindex);
603
604    if (po->pppoe_dev) {
605        dev_put(po->pppoe_dev);
606        po->pppoe_dev = NULL;
607    }
608
609    write_unlock_bh(&pn->hash_lock);
610
611out:
612    sock_orphan(sk);
613    sock->sk = NULL;
614
615    skb_queue_purge(&sk->sk_receive_queue);
616    release_sock(sk);
617    sock_put(sk);
618
619    return 0;
620}
621
622static int pppoe_connect(struct socket *sock, struct sockaddr *uservaddr,
623          int sockaddr_len, int flags)
624{
625    struct sock *sk = sock->sk;
626    struct sockaddr_pppox *sp = (struct sockaddr_pppox *)uservaddr;
627    struct pppox_sock *po = pppox_sk(sk);
628    struct net_device *dev;
629    struct pppoe_net *pn;
630    int error;
631
632    lock_sock(sk);
633
634    error = -EINVAL;
635    if (sp->sa_protocol != PX_PROTO_OE)
636        goto end;
637
638    /* Check for already bound sockets */
639    error = -EBUSY;
640    if ((sk->sk_state & PPPOX_CONNECTED) &&
641         stage_session(sp->sa_addr.pppoe.sid))
642        goto end;
643
644    /* Check for already disconnected sockets, on attempts to disconnect */
645    error = -EALREADY;
646    if ((sk->sk_state & PPPOX_DEAD) &&
647         !stage_session(sp->sa_addr.pppoe.sid))
648        goto end;
649
650    error = 0;
651
652    /* Delete the old binding */
653    if (stage_session(po->pppoe_pa.sid)) {
654        pppox_unbind_sock(sk);
655        if (po->pppoe_dev) {
656            pn = pppoe_pernet(dev_net(po->pppoe_dev));
657            delete_item(pn, po->pppoe_pa.sid,
658                po->pppoe_pa.remote, po->pppoe_ifindex);
659            dev_put(po->pppoe_dev);
660        }
661        memset(sk_pppox(po) + 1, 0,
662               sizeof(struct pppox_sock) - sizeof(struct sock));
663        sk->sk_state = PPPOX_NONE;
664    }
665
666    /* Re-bind in session stage only */
667    if (stage_session(sp->sa_addr.pppoe.sid)) {
668        error = -ENODEV;
669        dev = dev_get_by_name(sock_net(sk), sp->sa_addr.pppoe.dev);
670        if (!dev)
671            goto end;
672
673        po->pppoe_dev = dev;
674        po->pppoe_ifindex = dev->ifindex;
675        pn = pppoe_pernet(dev_net(dev));
676        write_lock_bh(&pn->hash_lock);
677        if (!(dev->flags & IFF_UP)) {
678            write_unlock_bh(&pn->hash_lock);
679            goto err_put;
680        }
681
682        memcpy(&po->pppoe_pa,
683               &sp->sa_addr.pppoe,
684               sizeof(struct pppoe_addr));
685
686        error = __set_item(pn, po);
687        write_unlock_bh(&pn->hash_lock);
688        if (error < 0)
689            goto err_put;
690
691        po->chan.hdrlen = (sizeof(struct pppoe_hdr) +
692                   dev->hard_header_len);
693
694        po->chan.mtu = dev->mtu - sizeof(struct pppoe_hdr);
695        po->chan.private = sk;
696        po->chan.ops = &pppoe_chan_ops;
697
698        error = ppp_register_net_channel(dev_net(dev), &po->chan);
699        if (error)
700            goto err_put;
701
702        sk->sk_state = PPPOX_CONNECTED;
703    }
704
705    po->num = sp->sa_addr.pppoe.sid;
706
707end:
708    release_sock(sk);
709    return error;
710err_put:
711    if (po->pppoe_dev) {
712        dev_put(po->pppoe_dev);
713        po->pppoe_dev = NULL;
714    }
715    goto end;
716}
717
718static int pppoe_getname(struct socket *sock, struct sockaddr *uaddr,
719          int *usockaddr_len, int peer)
720{
721    int len = sizeof(struct sockaddr_pppox);
722    struct sockaddr_pppox sp;
723
724    sp.sa_family = AF_PPPOX;
725    sp.sa_protocol = PX_PROTO_OE;
726    memcpy(&sp.sa_addr.pppoe, &pppox_sk(sock->sk)->pppoe_pa,
727           sizeof(struct pppoe_addr));
728
729    memcpy(uaddr, &sp, len);
730
731    *usockaddr_len = len;
732
733    return 0;
734}
735
736static int pppoe_ioctl(struct socket *sock, unsigned int cmd,
737        unsigned long arg)
738{
739    struct sock *sk = sock->sk;
740    struct pppox_sock *po = pppox_sk(sk);
741    int val;
742    int err;
743
744    switch (cmd) {
745    case PPPIOCGMRU:
746        err = -ENXIO;
747        if (!(sk->sk_state & PPPOX_CONNECTED))
748            break;
749
750        err = -EFAULT;
751        if (put_user(po->pppoe_dev->mtu -
752                 sizeof(struct pppoe_hdr) -
753                 PPP_HDRLEN,
754                 (int __user *)arg))
755            break;
756        err = 0;
757        break;
758
759    case PPPIOCSMRU:
760        err = -ENXIO;
761        if (!(sk->sk_state & PPPOX_CONNECTED))
762            break;
763
764        err = -EFAULT;
765        if (get_user(val, (int __user *)arg))
766            break;
767
768        if (val < (po->pppoe_dev->mtu
769               - sizeof(struct pppoe_hdr)
770               - PPP_HDRLEN))
771            err = 0;
772        else
773            err = -EINVAL;
774        break;
775
776    case PPPIOCSFLAGS:
777        err = -EFAULT;
778        if (get_user(val, (int __user *)arg))
779            break;
780        err = 0;
781        break;
782
783    case PPPOEIOCSFWD:
784    {
785        struct pppox_sock *relay_po;
786
787        err = -EBUSY;
788        if (sk->sk_state & (PPPOX_BOUND | PPPOX_ZOMBIE | PPPOX_DEAD))
789            break;
790
791        err = -ENOTCONN;
792        if (!(sk->sk_state & PPPOX_CONNECTED))
793            break;
794
795        /* PPPoE address from the user specifies an outbound
796           PPPoE address which frames are forwarded to */
797        err = -EFAULT;
798        if (copy_from_user(&po->pppoe_relay,
799                   (void __user *)arg,
800                   sizeof(struct sockaddr_pppox)))
801            break;
802
803        err = -EINVAL;
804        if (po->pppoe_relay.sa_family != AF_PPPOX ||
805            po->pppoe_relay.sa_protocol != PX_PROTO_OE)
806            break;
807
808        /* Check that the socket referenced by the address
809           actually exists. */
810        relay_po = get_item_by_addr(sock_net(sk), &po->pppoe_relay);
811        if (!relay_po)
812            break;
813
814        sock_put(sk_pppox(relay_po));
815        sk->sk_state |= PPPOX_RELAY;
816        err = 0;
817        break;
818    }
819
820    case PPPOEIOCDFWD:
821        err = -EALREADY;
822        if (!(sk->sk_state & PPPOX_RELAY))
823            break;
824
825        sk->sk_state &= ~PPPOX_RELAY;
826        err = 0;
827        break;
828
829    default:
830        err = -ENOTTY;
831    }
832
833    return err;
834}
835
836static int pppoe_sendmsg(struct kiocb *iocb, struct socket *sock,
837          struct msghdr *m, size_t total_len)
838{
839    struct sk_buff *skb;
840    struct sock *sk = sock->sk;
841    struct pppox_sock *po = pppox_sk(sk);
842    int error;
843    struct pppoe_hdr hdr;
844    struct pppoe_hdr *ph;
845    struct net_device *dev;
846    char *start;
847
848    lock_sock(sk);
849    if (sock_flag(sk, SOCK_DEAD) || !(sk->sk_state & PPPOX_CONNECTED)) {
850        error = -ENOTCONN;
851        goto end;
852    }
853
854    hdr.ver = 1;
855    hdr.type = 1;
856    hdr.code = 0;
857    hdr.sid = po->num;
858
859    dev = po->pppoe_dev;
860
861    error = -EMSGSIZE;
862    if (total_len > (dev->mtu + dev->hard_header_len))
863        goto end;
864
865
866    skb = sock_wmalloc(sk, total_len + dev->hard_header_len + 32 + NET_SKB_PAD,
867               0, GFP_KERNEL);
868    if (!skb) {
869        error = -ENOMEM;
870        goto end;
871    }
872
873    /* Reserve space for headers. */
874    skb_reserve(skb, dev->hard_header_len + NET_SKB_PAD);
875    skb_reset_network_header(skb);
876
877    skb->dev = dev;
878
879    skb->priority = sk->sk_priority;
880    skb->protocol = cpu_to_be16(ETH_P_PPP_SES);
881
882    ph = (struct pppoe_hdr *)skb_put(skb, total_len + sizeof(struct pppoe_hdr));
883    start = (char *)&ph->tag[0];
884
885    error = memcpy_fromiovec(start, m->msg_iov, total_len);
886    if (error < 0) {
887        kfree_skb(skb);
888        goto end;
889    }
890
891    error = total_len;
892    dev_hard_header(skb, dev, ETH_P_PPP_SES,
893            po->pppoe_pa.remote, NULL, total_len);
894
895    memcpy(ph, &hdr, sizeof(struct pppoe_hdr));
896
897    ph->length = htons(total_len);
898
899    dev_queue_xmit(skb);
900
901end:
902    release_sock(sk);
903    return error;
904}
905
906/************************************************************************
907 *
908 * xmit function for internal use.
909 *
910 ***********************************************************************/
911static int __pppoe_xmit(struct sock *sk, struct sk_buff *skb)
912{
913    struct pppox_sock *po = pppox_sk(sk);
914    struct net_device *dev = po->pppoe_dev;
915    struct pppoe_hdr *ph;
916    int data_len = skb->len;
917
918    if (sock_flag(sk, SOCK_DEAD) || !(sk->sk_state & PPPOX_CONNECTED))
919        goto abort;
920
921    if (!dev)
922        goto abort;
923
924    /* Copy the data if there is no space for the header or if it's
925     * read-only.
926     */
927    if (skb_cow_head(skb, sizeof(*ph) + dev->hard_header_len))
928        goto abort;
929
930    __skb_push(skb, sizeof(*ph));
931    skb_reset_network_header(skb);
932
933    ph = pppoe_hdr(skb);
934    ph->ver = 1;
935    ph->type = 1;
936    ph->code = 0;
937    ph->sid = po->num;
938    ph->length = htons(data_len);
939
940    skb->protocol = cpu_to_be16(ETH_P_PPP_SES);
941    skb->dev = dev;
942
943    dev_hard_header(skb, dev, ETH_P_PPP_SES,
944            po->pppoe_pa.remote, NULL, data_len);
945
946    dev_queue_xmit(skb);
947
948    return 1;
949
950abort:
951    kfree_skb(skb);
952    return 1;
953}
954
955/************************************************************************
956 *
957 * xmit function called by generic PPP driver
958 * sends PPP frame over PPPoE socket
959 *
960 ***********************************************************************/
961static int pppoe_xmit(struct ppp_channel *chan, struct sk_buff *skb)
962{
963    struct sock *sk = (struct sock *)chan->private;
964    return __pppoe_xmit(sk, skb);
965}
966
967static struct ppp_channel_ops pppoe_chan_ops = {
968    .start_xmit = pppoe_xmit,
969};
970
971static int pppoe_recvmsg(struct kiocb *iocb, struct socket *sock,
972          struct msghdr *m, size_t total_len, int flags)
973{
974    struct sock *sk = sock->sk;
975    struct sk_buff *skb;
976    int error = 0;
977
978    if (sk->sk_state & PPPOX_BOUND) {
979        error = -EIO;
980        goto end;
981    }
982
983    skb = skb_recv_datagram(sk, flags & ~MSG_DONTWAIT,
984                flags & MSG_DONTWAIT, &error);
985    if (error < 0)
986        goto end;
987
988    m->msg_namelen = 0;
989
990    if (skb) {
991        total_len = min_t(size_t, total_len, skb->len);
992        error = skb_copy_datagram_iovec(skb, 0, m->msg_iov, total_len);
993        if (error == 0)
994            error = total_len;
995    }
996
997    kfree_skb(skb);
998end:
999    return error;
1000}
1001
1002#ifdef CONFIG_PROC_FS
1003static int pppoe_seq_show(struct seq_file *seq, void *v)
1004{
1005    struct pppox_sock *po;
1006    char *dev_name;
1007
1008    if (v == SEQ_START_TOKEN) {
1009        seq_puts(seq, "Id Address Device\n");
1010        goto out;
1011    }
1012
1013    po = v;
1014    dev_name = po->pppoe_pa.dev;
1015
1016    seq_printf(seq, "%08X %pM %8s\n",
1017        po->pppoe_pa.sid, po->pppoe_pa.remote, dev_name);
1018out:
1019    return 0;
1020}
1021
1022static inline struct pppox_sock *pppoe_get_idx(struct pppoe_net *pn, loff_t pos)
1023{
1024    struct pppox_sock *po;
1025    int i;
1026
1027    for (i = 0; i < PPPOE_HASH_SIZE; i++) {
1028        po = pn->hash_table[i];
1029        while (po) {
1030            if (!pos--)
1031                goto out;
1032            po = po->next;
1033        }
1034    }
1035
1036out:
1037    return po;
1038}
1039
1040static void *pppoe_seq_start(struct seq_file *seq, loff_t *pos)
1041    __acquires(pn->hash_lock)
1042{
1043    struct pppoe_net *pn = pppoe_pernet(seq_file_net(seq));
1044    loff_t l = *pos;
1045
1046    read_lock_bh(&pn->hash_lock);
1047    return l ? pppoe_get_idx(pn, --l) : SEQ_START_TOKEN;
1048}
1049
1050static void *pppoe_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1051{
1052    struct pppoe_net *pn = pppoe_pernet(seq_file_net(seq));
1053    struct pppox_sock *po;
1054
1055    ++*pos;
1056    if (v == SEQ_START_TOKEN) {
1057        po = pppoe_get_idx(pn, 0);
1058        goto out;
1059    }
1060    po = v;
1061    if (po->next)
1062        po = po->next;
1063    else {
1064        int hash = hash_item(po->pppoe_pa.sid, po->pppoe_pa.remote);
1065
1066        po = NULL;
1067        while (++hash < PPPOE_HASH_SIZE) {
1068            po = pn->hash_table[hash];
1069            if (po)
1070                break;
1071        }
1072    }
1073
1074out:
1075    return po;
1076}
1077
1078static void pppoe_seq_stop(struct seq_file *seq, void *v)
1079    __releases(pn->hash_lock)
1080{
1081    struct pppoe_net *pn = pppoe_pernet(seq_file_net(seq));
1082    read_unlock_bh(&pn->hash_lock);
1083}
1084
1085static const struct seq_operations pppoe_seq_ops = {
1086    .start = pppoe_seq_start,
1087    .next = pppoe_seq_next,
1088    .stop = pppoe_seq_stop,
1089    .show = pppoe_seq_show,
1090};
1091
1092static int pppoe_seq_open(struct inode *inode, struct file *file)
1093{
1094    return seq_open_net(inode, file, &pppoe_seq_ops,
1095            sizeof(struct seq_net_private));
1096}
1097
1098static const struct file_operations pppoe_seq_fops = {
1099    .owner = THIS_MODULE,
1100    .open = pppoe_seq_open,
1101    .read = seq_read,
1102    .llseek = seq_lseek,
1103    .release = seq_release_net,
1104};
1105
1106#endif /* CONFIG_PROC_FS */
1107
1108static const struct proto_ops pppoe_ops = {
1109    .family = AF_PPPOX,
1110    .owner = THIS_MODULE,
1111    .release = pppoe_release,
1112    .bind = sock_no_bind,
1113    .connect = pppoe_connect,
1114    .socketpair = sock_no_socketpair,
1115    .accept = sock_no_accept,
1116    .getname = pppoe_getname,
1117    .poll = datagram_poll,
1118    .listen = sock_no_listen,
1119    .shutdown = sock_no_shutdown,
1120    .setsockopt = sock_no_setsockopt,
1121    .getsockopt = sock_no_getsockopt,
1122    .sendmsg = pppoe_sendmsg,
1123    .recvmsg = pppoe_recvmsg,
1124    .mmap = sock_no_mmap,
1125    .ioctl = pppox_ioctl,
1126};
1127
1128static struct pppox_proto pppoe_proto = {
1129    .create = pppoe_create,
1130    .ioctl = pppoe_ioctl,
1131    .owner = THIS_MODULE,
1132};
1133
1134static __net_init int pppoe_init_net(struct net *net)
1135{
1136    struct pppoe_net *pn;
1137    struct proc_dir_entry *pde;
1138    int err;
1139
1140    pn = kzalloc(sizeof(*pn), GFP_KERNEL);
1141    if (!pn)
1142        return -ENOMEM;
1143
1144    rwlock_init(&pn->hash_lock);
1145
1146    err = net_assign_generic(net, pppoe_net_id, pn);
1147    if (err)
1148        goto out;
1149
1150    pde = proc_net_fops_create(net, "pppoe", S_IRUGO, &pppoe_seq_fops);
1151#ifdef CONFIG_PROC_FS
1152    if (!pde) {
1153        err = -ENOMEM;
1154        goto out;
1155    }
1156#endif
1157
1158    return 0;
1159
1160out:
1161    kfree(pn);
1162    return err;
1163}
1164
1165static __net_exit void pppoe_exit_net(struct net *net)
1166{
1167    struct pppoe_net *pn;
1168
1169    proc_net_remove(net, "pppoe");
1170    pn = net_generic(net, pppoe_net_id);
1171    /*
1172     * if someone has cached our net then
1173     * further net_generic call will return NULL
1174     */
1175    net_assign_generic(net, pppoe_net_id, NULL);
1176    kfree(pn);
1177}
1178
1179static struct pernet_operations pppoe_net_ops = {
1180    .init = pppoe_init_net,
1181    .exit = pppoe_exit_net,
1182};
1183
1184static int __init pppoe_init(void)
1185{
1186    int err;
1187
1188    err = proto_register(&pppoe_sk_proto, 0);
1189    if (err)
1190        goto out;
1191
1192    err = register_pppox_proto(PX_PROTO_OE, &pppoe_proto);
1193    if (err)
1194        goto out_unregister_pppoe_proto;
1195
1196    err = register_pernet_gen_device(&pppoe_net_id, &pppoe_net_ops);
1197    if (err)
1198        goto out_unregister_pppox_proto;
1199
1200    dev_add_pack(&pppoes_ptype);
1201    dev_add_pack(&pppoed_ptype);
1202    register_netdevice_notifier(&pppoe_notifier);
1203
1204    return 0;
1205
1206out_unregister_pppox_proto:
1207    unregister_pppox_proto(PX_PROTO_OE);
1208out_unregister_pppoe_proto:
1209    proto_unregister(&pppoe_sk_proto);
1210out:
1211    return err;
1212}
1213
1214static void __exit pppoe_exit(void)
1215{
1216    unregister_pppox_proto(PX_PROTO_OE);
1217    dev_remove_pack(&pppoes_ptype);
1218    dev_remove_pack(&pppoed_ptype);
1219    unregister_netdevice_notifier(&pppoe_notifier);
1220    unregister_pernet_gen_device(pppoe_net_id, &pppoe_net_ops);
1221    proto_unregister(&pppoe_sk_proto);
1222}
1223
1224module_init(pppoe_init);
1225module_exit(pppoe_exit);
1226
1227MODULE_AUTHOR("Michal Ostrowski <mostrows@speakeasy.net>");
1228MODULE_DESCRIPTION("PPP over Ethernet driver");
1229MODULE_LICENSE("GPL");
1230MODULE_ALIAS_NETPROTO(PF_PPPOX);
1231

Archive Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.2
jz-3.3
jz-3.4
jz47xx
jz47xx-2.6.38
master
xiangfu/openwrt/v3.0.0
xiangfu/openwrt/v3.2.1

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7



interactive