1 /** -*- linux-c -*- ***********************************************************
2 * Linux PPP over Ethernet (PPPoX/PPPoE) Sockets
4 * PPPoX --- Generic PPP encapsulation socket family
5 * PPPoE --- PPP over Ethernet (RFC 2516)
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
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
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
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>
49 * Arnaldo Carvalho de Melo <acme@conectiva.com.br>
50 * David S. Miller (davem@redhat.com)
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.
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>
81 #include <linux/nsproxy.h>
82 #include <net/net_namespace.h>
83 #include <net/netns/generic.h>
86 #include <asm/uaccess.h>
88 #define PPPOE_HASH_BITS 4
89 #define PPPOE_HASH_SIZE (1 << PPPOE_HASH_BITS)
90 #define PPPOE_HASH_MASK (PPPOE_HASH_SIZE - 1)
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
);
96 static const struct proto_ops pppoe_ops
;
97 static struct ppp_channel_ops pppoe_chan_ops
;
99 /* per-net private data for this module */
100 static int pppoe_net_id
;
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
110 struct pppox_sock
*hash_table
[PPPOE_HASH_SIZE
];
114 /* to eliminate a race btw pppoe_flush_dev and pppoe_release */
115 static DEFINE_SPINLOCK(flush_lock
);
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)
122 * Ethernet frames have a special tag for this but
123 * we use simplier approach based on session id
125 static inline bool stage_session(__be16 sid
)
130 static inline struct pppoe_net
*pppoe_pernet(struct net
*net
)
134 return net_generic(net
, pppoe_net_id
);
137 static inline int cmp_2_addr(struct pppoe_addr
*a
, struct pppoe_addr
*b
)
139 return a
->sid
== b
->sid
&& !memcmp(a
->remote
, b
->remote
, ETH_ALEN
);
142 static inline int cmp_addr(struct pppoe_addr
*a
, __be16 sid
, char *addr
)
144 return a
->sid
== sid
&& !memcmp(a
->remote
, addr
, ETH_ALEN
);
147 #if 8 % PPPOE_HASH_BITS
148 #error 8 must be a multiple of PPPOE_HASH_BITS
151 static int hash_item(__be16 sid
, unsigned char *addr
)
153 unsigned char hash
= 0;
156 for (i
= 0; i
< ETH_ALEN
; 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
;)
163 return hash
& PPPOE_HASH_MASK
;
166 /**********************************************************************
168 * Set/get/delete/rehash items (internal versions)
170 **********************************************************************/
171 static struct pppox_sock
*__get_item(struct pppoe_net
*pn
, __be16 sid
,
172 unsigned char *addr
, int ifindex
)
174 int hash
= hash_item(sid
, addr
);
175 struct pppox_sock
*ret
;
177 ret
= pn
->hash_table
[hash
];
179 if (cmp_addr(&ret
->pppoe_pa
, sid
, addr
) &&
180 ret
->pppoe_ifindex
== ifindex
)
189 static int __set_item(struct pppoe_net
*pn
, struct pppox_sock
*po
)
191 int hash
= hash_item(po
->pppoe_pa
.sid
, po
->pppoe_pa
.remote
);
192 struct pppox_sock
*ret
;
194 ret
= pn
->hash_table
[hash
];
196 if (cmp_2_addr(&ret
->pppoe_pa
, &po
->pppoe_pa
) &&
197 ret
->pppoe_ifindex
== po
->pppoe_ifindex
)
203 po
->next
= pn
->hash_table
[hash
];
204 pn
->hash_table
[hash
] = po
;
209 static struct pppox_sock
*__delete_item(struct pppoe_net
*pn
, __be16 sid
,
210 char *addr
, int ifindex
)
212 int hash
= hash_item(sid
, addr
);
213 struct pppox_sock
*ret
, **src
;
215 ret
= pn
->hash_table
[hash
];
216 src
= &pn
->hash_table
[hash
];
219 if (cmp_addr(&ret
->pppoe_pa
, sid
, addr
) &&
220 ret
->pppoe_ifindex
== ifindex
) {
232 /**********************************************************************
234 * Set/get/delete/rehash items
236 **********************************************************************/
237 static inline struct pppox_sock
*get_item(struct pppoe_net
*pn
, __be16 sid
,
238 unsigned char *addr
, int ifindex
)
240 struct pppox_sock
*po
;
242 read_lock_bh(&pn
->hash_lock
);
243 po
= __get_item(pn
, sid
, addr
, ifindex
);
245 sock_hold(sk_pppox(po
));
246 read_unlock_bh(&pn
->hash_lock
);
251 static inline struct pppox_sock
*get_item_by_addr(struct net
*net
,
252 struct sockaddr_pppox
*sp
)
254 struct net_device
*dev
;
255 struct pppoe_net
*pn
;
256 struct pppox_sock
*pppox_sock
;
260 dev
= dev_get_by_name(net
, sp
->sa_addr
.pppoe
.dev
);
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
);
273 static inline struct pppox_sock
*delete_item(struct pppoe_net
*pn
, __be16 sid
,
274 char *addr
, int ifindex
)
276 struct pppox_sock
*ret
;
278 write_lock_bh(&pn
->hash_lock
);
279 ret
= __delete_item(pn
, sid
, addr
, ifindex
);
280 write_unlock_bh(&pn
->hash_lock
);
285 /***************************************************************************
287 * Handler for device events.
288 * Certain device events require that sockets be unconnected.
290 **************************************************************************/
292 static void pppoe_flush_dev(struct net_device
*dev
)
294 struct pppoe_net
*pn
;
299 pn
= pppoe_pernet(dev_net(dev
));
300 if (!pn
) /* already freed */
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
];
309 if (po
->pppoe_dev
!= dev
) {
314 spin_lock(&flush_lock
);
315 po
->pppoe_dev
= NULL
;
316 spin_unlock(&flush_lock
);
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.
329 write_unlock_bh(&pn
->hash_lock
);
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
);
341 /* Restart scan at the beginning of this hash chain.
342 * While the lock was dropped the chain contents may
345 write_lock_bh(&pn
->hash_lock
);
346 po
= pn
->hash_table
[i
];
349 write_unlock_bh(&pn
->hash_lock
);
352 static int pppoe_device_event(struct notifier_block
*this,
353 unsigned long event
, void *ptr
)
355 struct net_device
*dev
= (struct net_device
*)ptr
;
357 /* Only look at sockets that are using this specific device. */
359 case NETDEV_CHANGEMTU
:
360 /* A change in mtu is a bad thing, requiring
361 * LCP re-negotiation.
364 case NETDEV_GOING_DOWN
:
366 /* Find every socket on this device and kill it. */
367 pppoe_flush_dev(dev
);
377 static struct notifier_block pppoe_notifier
= {
378 .notifier_call
= pppoe_device_event
,
381 /************************************************************************
383 * Do the real work of receiving a PPPoE Session frame.
385 ***********************************************************************/
386 static int pppoe_rcv_core(struct sock
*sk
, struct sk_buff
*skb
)
388 struct pppox_sock
*po
= pppox_sk(sk
);
389 struct pppox_sock
*relay_po
;
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
),
396 if (relay_po
== NULL
)
399 if ((sk_pppox(relay_po
)->sk_state
& PPPOX_CONNECTED
) == 0)
402 if (!__pppoe_xmit(sk_pppox(relay_po
), skb
))
405 if (sock_queue_rcv_skb(sk
, skb
))
409 return NET_RX_SUCCESS
;
412 sock_put(sk_pppox(relay_po
));
419 /************************************************************************
421 * Receive wrapper called in BH context.
423 ***********************************************************************/
424 static int pppoe_rcv(struct sk_buff
*skb
, struct net_device
*dev
,
425 struct packet_type
*pt
, struct net_device
*orig_dev
)
427 struct pppoe_hdr
*ph
;
428 struct pppox_sock
*po
;
429 struct pppoe_net
*pn
;
432 skb
= skb_share_check(skb
, GFP_ATOMIC
);
436 if (!pskb_may_pull(skb
, sizeof(struct pppoe_hdr
)))
440 len
= ntohs(ph
->length
);
442 skb_pull_rcsum(skb
, sizeof(*ph
));
446 if (pskb_trim_rcsum(skb
, len
))
449 pn
= pppoe_pernet(dev_net(dev
));
450 po
= get_item(pn
, ph
->sid
, eth_hdr(skb
)->h_source
, dev
->ifindex
);
454 return sk_receive_skb(sk_pppox(po
), skb
, 0);
462 /************************************************************************
464 * Receive a PPPoE Discovery frame.
465 * This is solely for detection of PADT frames
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
)
472 struct pppoe_hdr
*ph
;
473 struct pppox_sock
*po
;
474 struct pppoe_net
*pn
;
476 skb
= skb_share_check(skb
, GFP_ATOMIC
);
480 if (!pskb_may_pull(skb
, sizeof(struct pppoe_hdr
)))
484 if (ph
->code
!= PADT_CODE
)
487 pn
= pppoe_pernet(dev_net(dev
));
488 po
= get_item(pn
, ph
->sid
, eth_hdr(skb
)->h_source
, dev
->ifindex
);
490 struct sock
*sk
= sk_pppox(po
);
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.
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.
503 sk
->sk_state
= PPPOX_ZOMBIE
;
513 return NET_RX_SUCCESS
; /* Lies... :-) */
516 static struct packet_type pppoes_ptype __read_mostly
= {
517 .type
= cpu_to_be16(ETH_P_PPP_SES
),
521 static struct packet_type pppoed_ptype __read_mostly
= {
522 .type
= cpu_to_be16(ETH_P_PPP_DISC
),
523 .func
= pppoe_disc_rcv
,
526 static struct proto pppoe_sk_proto __read_mostly
= {
528 .owner
= THIS_MODULE
,
529 .obj_size
= sizeof(struct pppox_sock
),
532 /***********************************************************************
534 * Initialize a new struct sock.
536 **********************************************************************/
537 static int pppoe_create(struct net
*net
, struct socket
*sock
)
541 sk
= sk_alloc(net
, PF_PPPOX
, GFP_KERNEL
, &pppoe_sk_proto
);
545 sock_init_data(sock
, sk
);
547 sock
->state
= SS_UNCONNECTED
;
548 sock
->ops
= &pppoe_ops
;
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
;
559 static int pppoe_release(struct socket
*sock
)
561 struct sock
*sk
= sock
->sk
;
562 struct pppox_sock
*po
;
563 struct pppoe_net
*pn
;
569 if (sock_flag(sk
, SOCK_DEAD
)) {
574 pppox_unbind_sock(sk
);
576 /* Signal the death of the socket. */
577 sk
->sk_state
= PPPOX_DEAD
;
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)
584 spin_lock(&flush_lock
);
586 if (!po
->pppoe_dev
) {
587 spin_unlock(&flush_lock
);
590 pn
= pppoe_pernet(dev_net(po
->pppoe_dev
));
591 spin_unlock(&flush_lock
);
594 * protect "po" from concurrent updates
597 write_lock_bh(&pn
->hash_lock
);
600 if (stage_session(po
->pppoe_pa
.sid
))
601 __delete_item(pn
, po
->pppoe_pa
.sid
, po
->pppoe_pa
.remote
,
605 dev_put(po
->pppoe_dev
);
606 po
->pppoe_dev
= NULL
;
609 write_unlock_bh(&pn
->hash_lock
);
615 skb_queue_purge(&sk
->sk_receive_queue
);
622 static int pppoe_connect(struct socket
*sock
, struct sockaddr
*uservaddr
,
623 int sockaddr_len
, int flags
)
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
;
635 if (sp
->sa_protocol
!= PX_PROTO_OE
)
638 /* Check for already bound sockets */
640 if ((sk
->sk_state
& PPPOX_CONNECTED
) &&
641 stage_session(sp
->sa_addr
.pppoe
.sid
))
644 /* Check for already disconnected sockets, on attempts to disconnect */
646 if ((sk
->sk_state
& PPPOX_DEAD
) &&
647 !stage_session(sp
->sa_addr
.pppoe
.sid
))
652 /* Delete the old binding */
653 if (stage_session(po
->pppoe_pa
.sid
)) {
654 pppox_unbind_sock(sk
);
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
);
661 memset(sk_pppox(po
) + 1, 0,
662 sizeof(struct pppox_sock
) - sizeof(struct sock
));
663 sk
->sk_state
= PPPOX_NONE
;
666 /* Re-bind in session stage only */
667 if (stage_session(sp
->sa_addr
.pppoe
.sid
)) {
669 dev
= dev_get_by_name(sock_net(sk
), sp
->sa_addr
.pppoe
.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
);
682 memcpy(&po
->pppoe_pa
,
684 sizeof(struct pppoe_addr
));
686 error
= __set_item(pn
, po
);
687 write_unlock_bh(&pn
->hash_lock
);
691 po
->chan
.hdrlen
= (sizeof(struct pppoe_hdr
) +
692 dev
->hard_header_len
);
694 po
->chan
.mtu
= dev
->mtu
- sizeof(struct pppoe_hdr
);
695 po
->chan
.private = sk
;
696 po
->chan
.ops
= &pppoe_chan_ops
;
698 error
= ppp_register_net_channel(dev_net(dev
), &po
->chan
);
702 sk
->sk_state
= PPPOX_CONNECTED
;
705 po
->num
= sp
->sa_addr
.pppoe
.sid
;
712 dev_put(po
->pppoe_dev
);
713 po
->pppoe_dev
= NULL
;
718 static int pppoe_getname(struct socket
*sock
, struct sockaddr
*uaddr
,
719 int *usockaddr_len
, int peer
)
721 int len
= sizeof(struct sockaddr_pppox
);
722 struct sockaddr_pppox sp
;
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
));
729 memcpy(uaddr
, &sp
, len
);
731 *usockaddr_len
= len
;
736 static int pppoe_ioctl(struct socket
*sock
, unsigned int cmd
,
739 struct sock
*sk
= sock
->sk
;
740 struct pppox_sock
*po
= pppox_sk(sk
);
747 if (!(sk
->sk_state
& PPPOX_CONNECTED
))
751 if (put_user(po
->pppoe_dev
->mtu
-
752 sizeof(struct pppoe_hdr
) -
761 if (!(sk
->sk_state
& PPPOX_CONNECTED
))
765 if (get_user(val
, (int __user
*)arg
))
768 if (val
< (po
->pppoe_dev
->mtu
769 - sizeof(struct pppoe_hdr
)
778 if (get_user(val
, (int __user
*)arg
))
785 struct pppox_sock
*relay_po
;
788 if (sk
->sk_state
& (PPPOX_BOUND
| PPPOX_ZOMBIE
| PPPOX_DEAD
))
792 if (!(sk
->sk_state
& PPPOX_CONNECTED
))
795 /* PPPoE address from the user specifies an outbound
796 PPPoE address which frames are forwarded to */
798 if (copy_from_user(&po
->pppoe_relay
,
800 sizeof(struct sockaddr_pppox
)))
804 if (po
->pppoe_relay
.sa_family
!= AF_PPPOX
||
805 po
->pppoe_relay
.sa_protocol
!= PX_PROTO_OE
)
808 /* Check that the socket referenced by the address
810 relay_po
= get_item_by_addr(sock_net(sk
), &po
->pppoe_relay
);
814 sock_put(sk_pppox(relay_po
));
815 sk
->sk_state
|= PPPOX_RELAY
;
822 if (!(sk
->sk_state
& PPPOX_RELAY
))
825 sk
->sk_state
&= ~PPPOX_RELAY
;
836 static int pppoe_sendmsg(struct kiocb
*iocb
, struct socket
*sock
,
837 struct msghdr
*m
, size_t total_len
)
840 struct sock
*sk
= sock
->sk
;
841 struct pppox_sock
*po
= pppox_sk(sk
);
843 struct pppoe_hdr hdr
;
844 struct pppoe_hdr
*ph
;
845 struct net_device
*dev
;
849 if (sock_flag(sk
, SOCK_DEAD
) || !(sk
->sk_state
& PPPOX_CONNECTED
)) {
862 if (total_len
> (dev
->mtu
+ dev
->hard_header_len
))
866 skb
= sock_wmalloc(sk
, total_len
+ dev
->hard_header_len
+ 32,
873 /* Reserve space for headers. */
874 skb_reserve(skb
, dev
->hard_header_len
);
875 skb_reset_network_header(skb
);
879 skb
->priority
= sk
->sk_priority
;
880 skb
->protocol
= cpu_to_be16(ETH_P_PPP_SES
);
882 ph
= (struct pppoe_hdr
*)skb_put(skb
, total_len
+ sizeof(struct pppoe_hdr
));
883 start
= (char *)&ph
->tag
[0];
885 error
= memcpy_fromiovec(start
, m
->msg_iov
, total_len
);
892 dev_hard_header(skb
, dev
, ETH_P_PPP_SES
,
893 po
->pppoe_pa
.remote
, NULL
, total_len
);
895 memcpy(ph
, &hdr
, sizeof(struct pppoe_hdr
));
897 ph
->length
= htons(total_len
);
906 /************************************************************************
908 * xmit function for internal use.
910 ***********************************************************************/
911 static int __pppoe_xmit(struct sock
*sk
, struct sk_buff
*skb
)
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
;
918 if (sock_flag(sk
, SOCK_DEAD
) || !(sk
->sk_state
& PPPOX_CONNECTED
))
924 /* Copy the data if there is no space for the header or if it's
927 if (skb_cow_head(skb
, sizeof(*ph
) + dev
->hard_header_len
))
930 __skb_push(skb
, sizeof(*ph
));
931 skb_reset_network_header(skb
);
938 ph
->length
= htons(data_len
);
940 skb
->protocol
= cpu_to_be16(ETH_P_PPP_SES
);
943 dev_hard_header(skb
, dev
, ETH_P_PPP_SES
,
944 po
->pppoe_pa
.remote
, NULL
, data_len
);
955 /************************************************************************
957 * xmit function called by generic PPP driver
958 * sends PPP frame over PPPoE socket
960 ***********************************************************************/
961 static int pppoe_xmit(struct ppp_channel
*chan
, struct sk_buff
*skb
)
963 struct sock
*sk
= (struct sock
*)chan
->private;
964 return __pppoe_xmit(sk
, skb
);
967 static struct ppp_channel_ops pppoe_chan_ops
= {
968 .start_xmit
= pppoe_xmit
,
971 static int pppoe_recvmsg(struct kiocb
*iocb
, struct socket
*sock
,
972 struct msghdr
*m
, size_t total_len
, int flags
)
974 struct sock
*sk
= sock
->sk
;
978 if (sk
->sk_state
& PPPOX_BOUND
) {
983 skb
= skb_recv_datagram(sk
, flags
& ~MSG_DONTWAIT
,
984 flags
& MSG_DONTWAIT
, &error
);
991 total_len
= min_t(size_t, total_len
, skb
->len
);
992 error
= skb_copy_datagram_iovec(skb
, 0, m
->msg_iov
, total_len
);
1002 #ifdef CONFIG_PROC_FS
1003 static int pppoe_seq_show(struct seq_file
*seq
, void *v
)
1005 struct pppox_sock
*po
;
1008 if (v
== SEQ_START_TOKEN
) {
1009 seq_puts(seq
, "Id Address Device\n");
1014 dev_name
= po
->pppoe_pa
.dev
;
1016 seq_printf(seq
, "%08X %pM %8s\n",
1017 po
->pppoe_pa
.sid
, po
->pppoe_pa
.remote
, dev_name
);
1022 static inline struct pppox_sock
*pppoe_get_idx(struct pppoe_net
*pn
, loff_t pos
)
1024 struct pppox_sock
*po
;
1027 for (i
= 0; i
< PPPOE_HASH_SIZE
; i
++) {
1028 po
= pn
->hash_table
[i
];
1040 static void *pppoe_seq_start(struct seq_file
*seq
, loff_t
*pos
)
1041 __acquires(pn
->hash_lock
)
1043 struct pppoe_net
*pn
= pppoe_pernet(seq_file_net(seq
));
1046 read_lock_bh(&pn
->hash_lock
);
1047 return l
? pppoe_get_idx(pn
, --l
) : SEQ_START_TOKEN
;
1050 static void *pppoe_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
1052 struct pppoe_net
*pn
= pppoe_pernet(seq_file_net(seq
));
1053 struct pppox_sock
*po
;
1056 if (v
== SEQ_START_TOKEN
) {
1057 po
= pppoe_get_idx(pn
, 0);
1064 int hash
= hash_item(po
->pppoe_pa
.sid
, po
->pppoe_pa
.remote
);
1067 while (++hash
< PPPOE_HASH_SIZE
) {
1068 po
= pn
->hash_table
[hash
];
1078 static void pppoe_seq_stop(struct seq_file
*seq
, void *v
)
1079 __releases(pn
->hash_lock
)
1081 struct pppoe_net
*pn
= pppoe_pernet(seq_file_net(seq
));
1082 read_unlock_bh(&pn
->hash_lock
);
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
,
1092 static int pppoe_seq_open(struct inode
*inode
, struct file
*file
)
1094 return seq_open_net(inode
, file
, &pppoe_seq_ops
,
1095 sizeof(struct seq_net_private
));
1098 static const struct file_operations pppoe_seq_fops
= {
1099 .owner
= THIS_MODULE
,
1100 .open
= pppoe_seq_open
,
1102 .llseek
= seq_lseek
,
1103 .release
= seq_release_net
,
1106 #endif /* CONFIG_PROC_FS */
1108 static const struct proto_ops pppoe_ops
= {
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
,
1128 static struct pppox_proto pppoe_proto
= {
1129 .create
= pppoe_create
,
1130 .ioctl
= pppoe_ioctl
,
1131 .owner
= THIS_MODULE
,
1134 static __net_init
int pppoe_init_net(struct net
*net
)
1136 struct pppoe_net
*pn
;
1137 struct proc_dir_entry
*pde
;
1140 pn
= kzalloc(sizeof(*pn
), GFP_KERNEL
);
1144 rwlock_init(&pn
->hash_lock
);
1146 err
= net_assign_generic(net
, pppoe_net_id
, pn
);
1150 pde
= proc_net_fops_create(net
, "pppoe", S_IRUGO
, &pppoe_seq_fops
);
1151 #ifdef CONFIG_PROC_FS
1165 static __net_exit
void pppoe_exit_net(struct net
*net
)
1167 struct pppoe_net
*pn
;
1169 proc_net_remove(net
, "pppoe");
1170 pn
= net_generic(net
, pppoe_net_id
);
1172 * if someone has cached our net then
1173 * further net_generic call will return NULL
1175 net_assign_generic(net
, pppoe_net_id
, NULL
);
1179 static struct pernet_operations pppoe_net_ops
= {
1180 .init
= pppoe_init_net
,
1181 .exit
= pppoe_exit_net
,
1184 static int __init
pppoe_init(void)
1188 err
= register_pernet_gen_device(&pppoe_net_id
, &pppoe_net_ops
);
1192 err
= proto_register(&pppoe_sk_proto
, 0);
1194 goto out_unregister_net_ops
;
1196 err
= register_pppox_proto(PX_PROTO_OE
, &pppoe_proto
);
1198 goto out_unregister_pppoe_proto
;
1200 dev_add_pack(&pppoes_ptype
);
1201 dev_add_pack(&pppoed_ptype
);
1202 register_netdevice_notifier(&pppoe_notifier
);
1206 out_unregister_pppoe_proto
:
1207 proto_unregister(&pppoe_sk_proto
);
1208 out_unregister_net_ops
:
1209 unregister_pernet_gen_device(pppoe_net_id
, &pppoe_net_ops
);
1214 static void __exit
pppoe_exit(void)
1216 unregister_netdevice_notifier(&pppoe_notifier
);
1217 dev_remove_pack(&pppoed_ptype
);
1218 dev_remove_pack(&pppoes_ptype
);
1219 unregister_pppox_proto(PX_PROTO_OE
);
1220 proto_unregister(&pppoe_sk_proto
);
1221 unregister_pernet_gen_device(pppoe_net_id
, &pppoe_net_ops
);
1224 module_init(pppoe_init
);
1225 module_exit(pppoe_exit
);
1227 MODULE_AUTHOR("Michal Ostrowski <mostrows@speakeasy.net>");
1228 MODULE_DESCRIPTION("PPP over Ethernet driver");
1229 MODULE_LICENSE("GPL");
1230 MODULE_ALIAS_NETPROTO(PF_PPPOX
);