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