net: pppoe - introduce net-namespace functionality
[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 unsigned int pppoe_net_id;
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 /* to eliminate a race btw pppoe_flush_dev and pppoe_release */
115 static 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  */
125 static inline bool stage_session(__be16 sid)
126 {
127         return sid != 0;
128 }
129
130 static 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
137 static 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
142 static 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
151 static 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  **********************************************************************/
171 static 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
189 static 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
209 static 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  **********************************************************************/
237 static 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
251 static 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
273 static 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
292 static 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
352 static 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
377 static 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  ***********************************************************************/
386 static 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
411 abort_put:
412         sock_put(sk_pppox(relay_po));
413
414 abort_kfree:
415         kfree_skb(skb);
416         return NET_RX_DROP;
417 }
418
419 /************************************************************************
420  *
421  * Receive wrapper called in BH context.
422  *
423  ***********************************************************************/
424 static 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
456 drop:
457         kfree_skb(skb);
458 out:
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  ***********************************************************************/
468 static 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
510 abort:
511         kfree_skb(skb);
512 out:
513         return NET_RX_SUCCESS; /* Lies... :-) */
514 }
515
516 static struct packet_type pppoes_ptype = {
517         .type   = __constant_htons(ETH_P_PPP_SES),
518         .func   = pppoe_rcv,
519 };
520
521 static struct packet_type pppoed_ptype = {
522         .type   = __constant_htons(ETH_P_PPP_DISC),
523         .func   = pppoe_disc_rcv,
524 };
525
526 static struct proto pppoe_sk_proto = {
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  **********************************************************************/
537 static 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
559 static 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
611 out:
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
622 static 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_channel(&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
707 end:
708         release_sock(sk);
709         return error;
710 err_put:
711         if (po->pppoe_dev) {
712                 dev_put(po->pppoe_dev);
713                 po->pppoe_dev = NULL;
714         }
715         goto end;
716 }
717
718 static 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
736 static 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
836 static 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,
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);
875         skb_reset_network_header(skb);
876
877         skb->dev = dev;
878
879         skb->priority = sk->sk_priority;
880         skb->protocol = __constant_htons(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
901 end:
902         release_sock(sk);
903         return error;
904 }
905
906 /************************************************************************
907  *
908  * xmit function for internal use.
909  *
910  ***********************************************************************/
911 static 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 = __constant_htons(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
950 abort:
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  ***********************************************************************/
961 static 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
967 static struct ppp_channel_ops pppoe_chan_ops = {
968         .start_xmit = pppoe_xmit,
969 };
970
971 static 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);
998 end:
999         return error;
1000 }
1001
1002 #ifdef CONFIG_PROC_FS
1003 static int pppoe_seq_show(struct seq_file *seq, void *v)
1004 {
1005         struct pppox_sock *po;
1006         char *dev_name;
1007         DECLARE_MAC_BUF(mac);
1008
1009         if (v == SEQ_START_TOKEN) {
1010                 seq_puts(seq, "Id       Address              Device\n");
1011                 goto out;
1012         }
1013
1014         po = v;
1015         dev_name = po->pppoe_pa.dev;
1016
1017         seq_printf(seq, "%08X %pM %8s\n",
1018                 po->pppoe_pa.sid, po->pppoe_pa.remote, dev_name);
1019 out:
1020         return 0;
1021 }
1022
1023 static inline struct pppox_sock *pppoe_get_idx(struct pppoe_net *pn, loff_t pos)
1024 {
1025         struct pppox_sock *po;
1026         int i;
1027
1028         for (i = 0; i < PPPOE_HASH_SIZE; i++) {
1029                 po = pn->hash_table[i];
1030                 while (po) {
1031                         if (!pos--)
1032                                 goto out;
1033                         po = po->next;
1034                 }
1035         }
1036
1037 out:
1038         return po;
1039 }
1040
1041 static void *pppoe_seq_start(struct seq_file *seq, loff_t *pos)
1042         __acquires(pn->hash_lock)
1043 {
1044         struct pppoe_net *pn = pppoe_pernet(seq->private);
1045         loff_t l = *pos;
1046
1047         read_lock_bh(&pn->hash_lock);
1048         return l ? pppoe_get_idx(pn, --l) : SEQ_START_TOKEN;
1049 }
1050
1051 static void *pppoe_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1052 {
1053         struct pppoe_net *pn = pppoe_pernet(seq->private);
1054         struct pppox_sock *po;
1055
1056         ++*pos;
1057         if (v == SEQ_START_TOKEN) {
1058                 po = pppoe_get_idx(pn, 0);
1059                 goto out;
1060         }
1061         po = v;
1062         if (po->next)
1063                 po = po->next;
1064         else {
1065                 int hash = hash_item(po->pppoe_pa.sid, po->pppoe_pa.remote);
1066
1067                 while (++hash < PPPOE_HASH_SIZE) {
1068                         po = pn->hash_table[hash];
1069                         if (po)
1070                                 break;
1071                 }
1072         }
1073
1074 out:
1075         return po;
1076 }
1077
1078 static void pppoe_seq_stop(struct seq_file *seq, void *v)
1079         __releases(pn->hash_lock)
1080 {
1081         struct pppoe_net *pn = pppoe_pernet(seq->private);
1082         read_unlock_bh(&pn->hash_lock);
1083 }
1084
1085 static 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
1092 static int pppoe_seq_open(struct inode *inode, struct file *file)
1093 {
1094         struct seq_file *m;
1095         struct net *net;
1096         int err;
1097
1098         err = seq_open(file, &pppoe_seq_ops);
1099         if (err)
1100                 return err;
1101
1102         m = file->private_data;
1103         net = maybe_get_net(PDE_NET(PDE(inode)));
1104         BUG_ON(!net);
1105         m->private = net;
1106
1107         return err;
1108 }
1109
1110 static int pppoe_seq_release(struct inode *inode, struct file *file)
1111 {
1112         struct seq_file *m;
1113
1114         m = file->private_data;
1115         put_net((struct net*)m->private);
1116
1117         return seq_release(inode, file);
1118 }
1119
1120 static const struct file_operations pppoe_seq_fops = {
1121         .owner          = THIS_MODULE,
1122         .open           = pppoe_seq_open,
1123         .read           = seq_read,
1124         .llseek         = seq_lseek,
1125         .release        = pppoe_seq_release,
1126 };
1127
1128 #endif /* CONFIG_PROC_FS */
1129
1130 static const struct proto_ops pppoe_ops = {
1131         .family         = AF_PPPOX,
1132         .owner          = THIS_MODULE,
1133         .release        = pppoe_release,
1134         .bind           = sock_no_bind,
1135         .connect        = pppoe_connect,
1136         .socketpair     = sock_no_socketpair,
1137         .accept         = sock_no_accept,
1138         .getname        = pppoe_getname,
1139         .poll           = datagram_poll,
1140         .listen         = sock_no_listen,
1141         .shutdown       = sock_no_shutdown,
1142         .setsockopt     = sock_no_setsockopt,
1143         .getsockopt     = sock_no_getsockopt,
1144         .sendmsg        = pppoe_sendmsg,
1145         .recvmsg        = pppoe_recvmsg,
1146         .mmap           = sock_no_mmap,
1147         .ioctl          = pppox_ioctl,
1148 };
1149
1150 static struct pppox_proto pppoe_proto = {
1151         .create = pppoe_create,
1152         .ioctl  = pppoe_ioctl,
1153         .owner  = THIS_MODULE,
1154 };
1155
1156 static __net_init int pppoe_init_net(struct net *net)
1157 {
1158         struct pppoe_net *pn;
1159         struct proc_dir_entry *pde;
1160         int err;
1161
1162         pn = kzalloc(sizeof(*pn), GFP_KERNEL);
1163         if (!pn)
1164                 return -ENOMEM;
1165
1166         rwlock_init(&pn->hash_lock);
1167
1168         err = net_assign_generic(net, pppoe_net_id, pn);
1169         if (err)
1170                 goto out;
1171
1172         pde = proc_net_fops_create(net, "pppoe", S_IRUGO, &pppoe_seq_fops);
1173 #ifdef CONFIG_PROC_FS
1174         if (!pde) {
1175                 err = -ENOMEM;
1176                 goto out;
1177         }
1178 #endif
1179
1180         return 0;
1181
1182 out:
1183         kfree(pn);
1184         return err;
1185 }
1186
1187 static __net_exit void pppoe_exit_net(struct net *net)
1188 {
1189         struct pppoe_net *pn;
1190
1191         proc_net_remove(net, "pppoe");
1192         pn = net_generic(net, pppoe_net_id);
1193         /*
1194          * if someone has cached our net then
1195          * further net_generic call will return NULL
1196          */
1197         net_assign_generic(net, pppoe_net_id, NULL);
1198         kfree(pn);
1199 }
1200
1201 static __net_initdata struct pernet_operations pppoe_net_ops = {
1202         .init = pppoe_init_net,
1203         .exit = pppoe_exit_net,
1204 };
1205
1206 static int __init pppoe_init(void)
1207 {
1208         int err;
1209
1210         err = proto_register(&pppoe_sk_proto, 0);
1211         if (err)
1212                 goto out;
1213
1214         err = register_pppox_proto(PX_PROTO_OE, &pppoe_proto);
1215         if (err)
1216                 goto out_unregister_pppoe_proto;
1217
1218         err = register_pernet_gen_device(&pppoe_net_id, &pppoe_net_ops);
1219         if (err)
1220                 goto out_unregister_pppox_proto;
1221
1222         dev_add_pack(&pppoes_ptype);
1223         dev_add_pack(&pppoed_ptype);
1224         register_netdevice_notifier(&pppoe_notifier);
1225
1226         return 0;
1227
1228 out_unregister_pppox_proto:
1229         unregister_pppox_proto(PX_PROTO_OE);
1230 out_unregister_pppoe_proto:
1231         proto_unregister(&pppoe_sk_proto);
1232 out:
1233         return err;
1234 }
1235
1236 static void __exit pppoe_exit(void)
1237 {
1238         unregister_pppox_proto(PX_PROTO_OE);
1239         dev_remove_pack(&pppoes_ptype);
1240         dev_remove_pack(&pppoed_ptype);
1241         unregister_netdevice_notifier(&pppoe_notifier);
1242         unregister_pernet_gen_device(pppoe_net_id, &pppoe_net_ops);
1243         proto_unregister(&pppoe_sk_proto);
1244 }
1245
1246 module_init(pppoe_init);
1247 module_exit(pppoe_exit);
1248
1249 MODULE_AUTHOR("Michal Ostrowski <mostrows@speakeasy.net>");
1250 MODULE_DESCRIPTION("PPP over Ethernet driver");
1251 MODULE_LICENSE("GPL");
1252 MODULE_ALIAS_NETPROTO(PF_PPPOX);