1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /** -*- linux-c -*- ***********************************************************
3 * Linux PPP over Ethernet (PPPoX/PPPoE) Sockets
5 * PPPoX --- Generic PPP encapsulation socket family
6 * 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)
55 #include <linux/string.h>
56 #include <linux/module.h>
57 #include <linux/kernel.h>
58 #include <linux/slab.h>
59 #include <linux/errno.h>
60 #include <linux/netdevice.h>
61 #include <linux/net.h>
62 #include <linux/inetdevice.h>
63 #include <linux/etherdevice.h>
64 #include <linux/skbuff.h>
65 #include <linux/init.h>
66 #include <linux/if_ether.h>
67 #include <linux/if_pppox.h>
68 #include <linux/ppp_channel.h>
69 #include <linux/ppp_defs.h>
70 #include <linux/ppp-ioctl.h>
71 #include <linux/notifier.h>
72 #include <linux/file.h>
73 #include <linux/proc_fs.h>
74 #include <linux/seq_file.h>
76 #include <linux/nsproxy.h>
77 #include <net/net_namespace.h>
78 #include <net/netns/generic.h>
81 #include <linux/uaccess.h>
83 #define PPPOE_HASH_BITS 4
84 #define PPPOE_HASH_SIZE (1 << PPPOE_HASH_BITS)
85 #define PPPOE_HASH_MASK (PPPOE_HASH_SIZE - 1)
87 static int __pppoe_xmit(struct sock
*sk
, struct sk_buff
*skb
);
89 static const struct proto_ops pppoe_ops
;
90 static const struct ppp_channel_ops pppoe_chan_ops
;
92 /* per-net private data for this module */
93 static unsigned int pppoe_net_id __read_mostly
;
96 * we could use _single_ hash table for all
97 * nets by injecting net id into the hash but
98 * it would increase hash chains and add
99 * a few additional math comparations messy
100 * as well, moreover in case of SMP less locking
103 struct pppox_sock
*hash_table
[PPPOE_HASH_SIZE
];
108 * PPPoE could be in the following stages:
109 * 1) Discovery stage (to obtain remote MAC and Session ID)
110 * 2) Session stage (MAC and SID are known)
112 * Ethernet frames have a special tag for this but
113 * we use simpler approach based on session id
115 static inline bool stage_session(__be16 sid
)
120 static inline struct pppoe_net
*pppoe_pernet(struct net
*net
)
122 return net_generic(net
, pppoe_net_id
);
125 static inline int cmp_2_addr(struct pppoe_addr
*a
, struct pppoe_addr
*b
)
127 return a
->sid
== b
->sid
&& ether_addr_equal(a
->remote
, b
->remote
);
130 static inline int cmp_addr(struct pppoe_addr
*a
, __be16 sid
, char *addr
)
132 return a
->sid
== sid
&& ether_addr_equal(a
->remote
, addr
);
135 #if 8 % PPPOE_HASH_BITS
136 #error 8 must be a multiple of PPPOE_HASH_BITS
139 static int hash_item(__be16 sid
, unsigned char *addr
)
141 unsigned char hash
= 0;
144 for (i
= 0; i
< ETH_ALEN
; i
++)
146 for (i
= 0; i
< sizeof(sid_t
) * 8; i
+= 8)
147 hash
^= (__force __u32
)sid
>> i
;
148 for (i
= 8; (i
>>= 1) >= PPPOE_HASH_BITS
;)
151 return hash
& PPPOE_HASH_MASK
;
154 /**********************************************************************
156 * Set/get/delete/rehash items (internal versions)
158 **********************************************************************/
159 static struct pppox_sock
*__get_item(struct pppoe_net
*pn
, __be16 sid
,
160 unsigned char *addr
, int ifindex
)
162 int hash
= hash_item(sid
, addr
);
163 struct pppox_sock
*ret
;
165 ret
= pn
->hash_table
[hash
];
167 if (cmp_addr(&ret
->pppoe_pa
, sid
, addr
) &&
168 ret
->pppoe_ifindex
== ifindex
)
177 static int __set_item(struct pppoe_net
*pn
, struct pppox_sock
*po
)
179 int hash
= hash_item(po
->pppoe_pa
.sid
, po
->pppoe_pa
.remote
);
180 struct pppox_sock
*ret
;
182 ret
= pn
->hash_table
[hash
];
184 if (cmp_2_addr(&ret
->pppoe_pa
, &po
->pppoe_pa
) &&
185 ret
->pppoe_ifindex
== po
->pppoe_ifindex
)
191 po
->next
= pn
->hash_table
[hash
];
192 pn
->hash_table
[hash
] = po
;
197 static void __delete_item(struct pppoe_net
*pn
, __be16 sid
,
198 char *addr
, int ifindex
)
200 int hash
= hash_item(sid
, addr
);
201 struct pppox_sock
*ret
, **src
;
203 ret
= pn
->hash_table
[hash
];
204 src
= &pn
->hash_table
[hash
];
207 if (cmp_addr(&ret
->pppoe_pa
, sid
, addr
) &&
208 ret
->pppoe_ifindex
== ifindex
) {
218 /**********************************************************************
220 * Set/get/delete/rehash items
222 **********************************************************************/
223 static inline struct pppox_sock
*get_item(struct pppoe_net
*pn
, __be16 sid
,
224 unsigned char *addr
, int ifindex
)
226 struct pppox_sock
*po
;
228 read_lock_bh(&pn
->hash_lock
);
229 po
= __get_item(pn
, sid
, addr
, ifindex
);
231 sock_hold(sk_pppox(po
));
232 read_unlock_bh(&pn
->hash_lock
);
237 static inline struct pppox_sock
*get_item_by_addr(struct net
*net
,
238 struct sockaddr_pppox
*sp
)
240 struct net_device
*dev
;
241 struct pppoe_net
*pn
;
242 struct pppox_sock
*pppox_sock
= NULL
;
247 dev
= dev_get_by_name_rcu(net
, sp
->sa_addr
.pppoe
.dev
);
249 ifindex
= dev
->ifindex
;
250 pn
= pppoe_pernet(net
);
251 pppox_sock
= get_item(pn
, sp
->sa_addr
.pppoe
.sid
,
252 sp
->sa_addr
.pppoe
.remote
, ifindex
);
258 static inline void delete_item(struct pppoe_net
*pn
, __be16 sid
,
259 char *addr
, int ifindex
)
261 write_lock_bh(&pn
->hash_lock
);
262 __delete_item(pn
, sid
, addr
, ifindex
);
263 write_unlock_bh(&pn
->hash_lock
);
266 /***************************************************************************
268 * Handler for device events.
269 * Certain device events require that sockets be unconnected.
271 **************************************************************************/
273 static void pppoe_flush_dev(struct net_device
*dev
)
275 struct pppoe_net
*pn
;
278 pn
= pppoe_pernet(dev_net(dev
));
279 write_lock_bh(&pn
->hash_lock
);
280 for (i
= 0; i
< PPPOE_HASH_SIZE
; i
++) {
281 struct pppox_sock
*po
= pn
->hash_table
[i
];
285 while (po
&& po
->pppoe_dev
!= dev
) {
294 /* We always grab the socket lock, followed by the
295 * hash_lock, in that order. Since we should hold the
296 * sock lock while doing any unbinding, we need to
297 * release the lock we're holding. Hold a reference to
298 * the sock so it doesn't disappear as we're jumping
303 write_unlock_bh(&pn
->hash_lock
);
306 if (po
->pppoe_dev
== dev
&&
307 sk
->sk_state
& (PPPOX_CONNECTED
| PPPOX_BOUND
)) {
308 pppox_unbind_sock(sk
);
309 sk
->sk_state_change(sk
);
310 po
->pppoe_dev
= NULL
;
317 /* Restart the process from the start of the current
318 * hash chain. We dropped locks so the world may have
319 * change from underneath us.
322 BUG_ON(pppoe_pernet(dev_net(dev
)) == NULL
);
323 write_lock_bh(&pn
->hash_lock
);
324 po
= pn
->hash_table
[i
];
327 write_unlock_bh(&pn
->hash_lock
);
330 static int pppoe_device_event(struct notifier_block
*this,
331 unsigned long event
, void *ptr
)
333 struct net_device
*dev
= netdev_notifier_info_to_dev(ptr
);
335 /* Only look at sockets that are using this specific device. */
337 case NETDEV_CHANGEADDR
:
338 case NETDEV_CHANGEMTU
:
339 /* A change in mtu or address is a bad thing, requiring
340 * LCP re-negotiation.
343 case NETDEV_GOING_DOWN
:
345 /* Find every socket on this device and kill it. */
346 pppoe_flush_dev(dev
);
356 static struct notifier_block pppoe_notifier
= {
357 .notifier_call
= pppoe_device_event
,
360 /************************************************************************
362 * Do the real work of receiving a PPPoE Session frame.
364 ***********************************************************************/
365 static int pppoe_rcv_core(struct sock
*sk
, struct sk_buff
*skb
)
367 struct pppox_sock
*po
= pppox_sk(sk
);
368 struct pppox_sock
*relay_po
;
370 /* Backlog receive. Semantics of backlog rcv preclude any code from
371 * executing in lock_sock()/release_sock() bounds; meaning sk->sk_state
375 if (skb
->pkt_type
== PACKET_OTHERHOST
)
378 if (sk
->sk_state
& PPPOX_BOUND
) {
379 ppp_input(&po
->chan
, skb
);
380 } else if (sk
->sk_state
& PPPOX_RELAY
) {
381 relay_po
= get_item_by_addr(sock_net(sk
),
383 if (relay_po
== NULL
)
386 if ((sk_pppox(relay_po
)->sk_state
& PPPOX_CONNECTED
) == 0)
389 if (!__pppoe_xmit(sk_pppox(relay_po
), skb
))
392 sock_put(sk_pppox(relay_po
));
394 if (sock_queue_rcv_skb(sk
, skb
))
398 return NET_RX_SUCCESS
;
401 sock_put(sk_pppox(relay_po
));
408 /************************************************************************
410 * Receive wrapper called in BH context.
412 ***********************************************************************/
413 static int pppoe_rcv(struct sk_buff
*skb
, struct net_device
*dev
,
414 struct packet_type
*pt
, struct net_device
*orig_dev
)
416 struct pppoe_hdr
*ph
;
417 struct pppox_sock
*po
;
418 struct pppoe_net
*pn
;
421 skb
= skb_share_check(skb
, GFP_ATOMIC
);
425 if (skb_mac_header_len(skb
) < ETH_HLEN
)
428 if (!pskb_may_pull(skb
, sizeof(struct pppoe_hdr
)))
432 len
= ntohs(ph
->length
);
434 skb_pull_rcsum(skb
, sizeof(*ph
));
438 if (pskb_trim_rcsum(skb
, len
))
442 pn
= pppoe_pernet(dev_net(dev
));
444 /* Note that get_item does a sock_hold(), so sk_pppox(po)
445 * is known to be safe.
447 po
= get_item(pn
, ph
->sid
, eth_hdr(skb
)->h_source
, dev
->ifindex
);
451 return sk_receive_skb(sk_pppox(po
), skb
, 0);
459 static void pppoe_unbind_sock_work(struct work_struct
*work
)
461 struct pppox_sock
*po
= container_of(work
, struct pppox_sock
,
462 proto
.pppoe
.padt_work
);
463 struct sock
*sk
= sk_pppox(po
);
467 dev_put(po
->pppoe_dev
);
468 po
->pppoe_dev
= NULL
;
470 pppox_unbind_sock(sk
);
475 /************************************************************************
477 * Receive a PPPoE Discovery frame.
478 * This is solely for detection of PADT frames
480 ***********************************************************************/
481 static int pppoe_disc_rcv(struct sk_buff
*skb
, struct net_device
*dev
,
482 struct packet_type
*pt
, struct net_device
*orig_dev
)
485 struct pppoe_hdr
*ph
;
486 struct pppox_sock
*po
;
487 struct pppoe_net
*pn
;
489 skb
= skb_share_check(skb
, GFP_ATOMIC
);
493 if (!pskb_may_pull(skb
, sizeof(struct pppoe_hdr
)))
497 if (ph
->code
!= PADT_CODE
)
500 pn
= pppoe_pernet(dev_net(dev
));
501 po
= get_item(pn
, ph
->sid
, eth_hdr(skb
)->h_source
, dev
->ifindex
);
503 if (!schedule_work(&po
->proto
.pppoe
.padt_work
))
504 sock_put(sk_pppox(po
));
509 return NET_RX_SUCCESS
; /* Lies... :-) */
512 static struct packet_type pppoes_ptype __read_mostly
= {
513 .type
= cpu_to_be16(ETH_P_PPP_SES
),
517 static struct packet_type pppoed_ptype __read_mostly
= {
518 .type
= cpu_to_be16(ETH_P_PPP_DISC
),
519 .func
= pppoe_disc_rcv
,
522 static struct proto pppoe_sk_proto __read_mostly
= {
524 .owner
= THIS_MODULE
,
525 .obj_size
= sizeof(struct pppox_sock
),
528 /***********************************************************************
530 * Initialize a new struct sock.
532 **********************************************************************/
533 static int pppoe_create(struct net
*net
, struct socket
*sock
, int kern
)
537 sk
= sk_alloc(net
, PF_PPPOX
, GFP_KERNEL
, &pppoe_sk_proto
, kern
);
541 sock_init_data(sock
, sk
);
543 sock
->state
= SS_UNCONNECTED
;
544 sock
->ops
= &pppoe_ops
;
546 sk
->sk_backlog_rcv
= pppoe_rcv_core
;
547 sk
->sk_state
= PPPOX_NONE
;
548 sk
->sk_type
= SOCK_STREAM
;
549 sk
->sk_family
= PF_PPPOX
;
550 sk
->sk_protocol
= PX_PROTO_OE
;
552 INIT_WORK(&pppox_sk(sk
)->proto
.pppoe
.padt_work
,
553 pppoe_unbind_sock_work
);
558 static int pppoe_release(struct socket
*sock
)
560 struct sock
*sk
= sock
->sk
;
561 struct pppox_sock
*po
;
562 struct pppoe_net
*pn
;
563 struct net
*net
= NULL
;
569 if (sock_flag(sk
, SOCK_DEAD
)) {
577 dev_put(po
->pppoe_dev
);
578 po
->pppoe_dev
= NULL
;
581 pppox_unbind_sock(sk
);
583 /* Signal the death of the socket. */
584 sk
->sk_state
= PPPOX_DEAD
;
587 pn
= pppoe_pernet(net
);
590 * protect "po" from concurrent updates
593 delete_item(pn
, po
->pppoe_pa
.sid
, po
->pppoe_pa
.remote
,
599 skb_queue_purge(&sk
->sk_receive_queue
);
606 static int pppoe_connect(struct socket
*sock
, struct sockaddr
*uservaddr
,
607 int sockaddr_len
, int flags
)
609 struct sock
*sk
= sock
->sk
;
610 struct sockaddr_pppox
*sp
= (struct sockaddr_pppox
*)uservaddr
;
611 struct pppox_sock
*po
= pppox_sk(sk
);
612 struct net_device
*dev
= NULL
;
613 struct pppoe_net
*pn
;
614 struct net
*net
= NULL
;
621 if (sockaddr_len
!= sizeof(struct sockaddr_pppox
))
624 if (sp
->sa_protocol
!= PX_PROTO_OE
)
627 /* Check for already bound sockets */
629 if ((sk
->sk_state
& PPPOX_CONNECTED
) &&
630 stage_session(sp
->sa_addr
.pppoe
.sid
))
633 /* Check for already disconnected sockets, on attempts to disconnect */
635 if ((sk
->sk_state
& PPPOX_DEAD
) &&
636 !stage_session(sp
->sa_addr
.pppoe
.sid
))
641 /* Delete the old binding */
642 if (stage_session(po
->pppoe_pa
.sid
)) {
643 pppox_unbind_sock(sk
);
644 pn
= pppoe_pernet(sock_net(sk
));
645 delete_item(pn
, po
->pppoe_pa
.sid
,
646 po
->pppoe_pa
.remote
, po
->pppoe_ifindex
);
648 dev_put(po
->pppoe_dev
);
649 po
->pppoe_dev
= NULL
;
652 po
->pppoe_ifindex
= 0;
653 memset(&po
->pppoe_pa
, 0, sizeof(po
->pppoe_pa
));
654 memset(&po
->pppoe_relay
, 0, sizeof(po
->pppoe_relay
));
655 memset(&po
->chan
, 0, sizeof(po
->chan
));
659 sk
->sk_state
= PPPOX_NONE
;
662 /* Re-bind in session stage only */
663 if (stage_session(sp
->sa_addr
.pppoe
.sid
)) {
666 dev
= dev_get_by_name(net
, sp
->sa_addr
.pppoe
.dev
);
671 po
->pppoe_ifindex
= dev
->ifindex
;
672 pn
= pppoe_pernet(net
);
673 if (!(dev
->flags
& IFF_UP
)) {
677 memcpy(&po
->pppoe_pa
,
679 sizeof(struct pppoe_addr
));
681 write_lock_bh(&pn
->hash_lock
);
682 error
= __set_item(pn
, po
);
683 write_unlock_bh(&pn
->hash_lock
);
687 po
->chan
.hdrlen
= (sizeof(struct pppoe_hdr
) +
688 dev
->hard_header_len
);
690 po
->chan
.mtu
= dev
->mtu
- sizeof(struct pppoe_hdr
) - 2;
691 po
->chan
.private = sk
;
692 po
->chan
.ops
= &pppoe_chan_ops
;
694 error
= ppp_register_net_channel(dev_net(dev
), &po
->chan
);
696 delete_item(pn
, po
->pppoe_pa
.sid
,
697 po
->pppoe_pa
.remote
, po
->pppoe_ifindex
);
701 sk
->sk_state
= PPPOX_CONNECTED
;
704 po
->num
= sp
->sa_addr
.pppoe
.sid
;
711 dev_put(po
->pppoe_dev
);
712 po
->pppoe_dev
= NULL
;
717 static int pppoe_getname(struct socket
*sock
, struct sockaddr
*uaddr
,
720 int len
= sizeof(struct sockaddr_pppox
);
721 struct sockaddr_pppox sp
;
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
));
728 memcpy(uaddr
, &sp
, len
);
733 static int pppoe_ioctl(struct socket
*sock
, unsigned int cmd
,
736 struct sock
*sk
= sock
->sk
;
737 struct pppox_sock
*po
= pppox_sk(sk
);
744 if (!(sk
->sk_state
& PPPOX_CONNECTED
))
748 if (put_user(po
->pppoe_dev
->mtu
-
749 sizeof(struct pppoe_hdr
) -
758 if (!(sk
->sk_state
& PPPOX_CONNECTED
))
762 if (get_user(val
, (int __user
*)arg
))
765 if (val
< (po
->pppoe_dev
->mtu
766 - sizeof(struct pppoe_hdr
)
775 if (get_user(val
, (int __user
*)arg
))
782 struct pppox_sock
*relay_po
;
785 if (sk
->sk_state
& (PPPOX_BOUND
| PPPOX_DEAD
))
789 if (!(sk
->sk_state
& PPPOX_CONNECTED
))
792 /* PPPoE address from the user specifies an outbound
793 PPPoE address which frames are forwarded to */
795 if (copy_from_user(&po
->pppoe_relay
,
797 sizeof(struct sockaddr_pppox
)))
801 if (po
->pppoe_relay
.sa_family
!= AF_PPPOX
||
802 po
->pppoe_relay
.sa_protocol
!= PX_PROTO_OE
)
805 /* Check that the socket referenced by the address
807 relay_po
= get_item_by_addr(sock_net(sk
), &po
->pppoe_relay
);
811 sock_put(sk_pppox(relay_po
));
812 sk
->sk_state
|= PPPOX_RELAY
;
819 if (!(sk
->sk_state
& PPPOX_RELAY
))
822 sk
->sk_state
&= ~PPPOX_RELAY
;
833 static int pppoe_sendmsg(struct socket
*sock
, struct msghdr
*m
,
837 struct sock
*sk
= sock
->sk
;
838 struct pppox_sock
*po
= pppox_sk(sk
);
840 struct pppoe_hdr hdr
;
841 struct pppoe_hdr
*ph
;
842 struct net_device
*dev
;
847 if (sock_flag(sk
, SOCK_DEAD
) || !(sk
->sk_state
& PPPOX_CONNECTED
)) {
860 if (total_len
> (dev
->mtu
+ dev
->hard_header_len
))
863 hlen
= LL_RESERVED_SPACE(dev
);
864 skb
= sock_wmalloc(sk
, hlen
+ sizeof(*ph
) + total_len
+
865 dev
->needed_tailroom
, 0, GFP_KERNEL
);
871 /* Reserve space for headers. */
872 skb_reserve(skb
, hlen
);
873 skb_reset_network_header(skb
);
877 skb
->priority
= sk
->sk_priority
;
878 skb
->protocol
= cpu_to_be16(ETH_P_PPP_SES
);
880 ph
= skb_put(skb
, total_len
+ sizeof(struct pppoe_hdr
));
881 start
= (char *)&ph
->tag
[0];
883 error
= memcpy_from_msg(start
, m
, total_len
);
890 dev_hard_header(skb
, dev
, ETH_P_PPP_SES
,
891 po
->pppoe_pa
.remote
, NULL
, total_len
);
893 memcpy(ph
, &hdr
, sizeof(struct pppoe_hdr
));
895 ph
->length
= htons(total_len
);
904 /************************************************************************
906 * xmit function for internal use.
908 ***********************************************************************/
909 static int __pppoe_xmit(struct sock
*sk
, struct sk_buff
*skb
)
911 struct pppox_sock
*po
= pppox_sk(sk
);
912 struct net_device
*dev
= po
->pppoe_dev
;
913 struct pppoe_hdr
*ph
;
914 int data_len
= skb
->len
;
916 /* The higher-level PPP code (ppp_unregister_channel()) ensures the PPP
917 * xmit operations conclude prior to an unregistration call. Thus
918 * sk->sk_state cannot change, so we don't need to do lock_sock().
919 * But, we also can't do a lock_sock since that introduces a potential
920 * deadlock as we'd reverse the lock ordering used when calling
921 * ppp_unregister_channel().
924 if (sock_flag(sk
, SOCK_DEAD
) || !(sk
->sk_state
& PPPOX_CONNECTED
))
930 /* Copy the data if there is no space for the header or if it's
933 if (skb_cow_head(skb
, LL_RESERVED_SPACE(dev
) + sizeof(*ph
)))
936 __skb_push(skb
, sizeof(*ph
));
937 skb_reset_network_header(skb
);
944 ph
->length
= htons(data_len
);
946 skb
->protocol
= cpu_to_be16(ETH_P_PPP_SES
);
949 dev_hard_header(skb
, dev
, ETH_P_PPP_SES
,
950 po
->pppoe_pa
.remote
, NULL
, data_len
);
960 /************************************************************************
962 * xmit function called by generic PPP driver
963 * sends PPP frame over PPPoE socket
965 ***********************************************************************/
966 static int pppoe_xmit(struct ppp_channel
*chan
, struct sk_buff
*skb
)
968 struct sock
*sk
= (struct sock
*)chan
->private;
969 return __pppoe_xmit(sk
, skb
);
972 static const struct ppp_channel_ops pppoe_chan_ops
= {
973 .start_xmit
= pppoe_xmit
,
976 static int pppoe_recvmsg(struct socket
*sock
, struct msghdr
*m
,
977 size_t total_len
, int flags
)
979 struct sock
*sk
= sock
->sk
;
983 if (sk
->sk_state
& PPPOX_BOUND
) {
988 skb
= skb_recv_datagram(sk
, flags
& ~MSG_DONTWAIT
,
989 flags
& MSG_DONTWAIT
, &error
);
994 total_len
= min_t(size_t, total_len
, skb
->len
);
995 error
= skb_copy_datagram_msg(skb
, 0, m
, total_len
);
1007 #ifdef CONFIG_PROC_FS
1008 static int pppoe_seq_show(struct seq_file
*seq
, void *v
)
1010 struct pppox_sock
*po
;
1013 if (v
== SEQ_START_TOKEN
) {
1014 seq_puts(seq
, "Id Address Device\n");
1019 dev_name
= po
->pppoe_pa
.dev
;
1021 seq_printf(seq
, "%08X %pM %8s\n",
1022 po
->pppoe_pa
.sid
, po
->pppoe_pa
.remote
, dev_name
);
1027 static inline struct pppox_sock
*pppoe_get_idx(struct pppoe_net
*pn
, loff_t pos
)
1029 struct pppox_sock
*po
;
1032 for (i
= 0; i
< PPPOE_HASH_SIZE
; i
++) {
1033 po
= pn
->hash_table
[i
];
1045 static void *pppoe_seq_start(struct seq_file
*seq
, loff_t
*pos
)
1046 __acquires(pn
->hash_lock
)
1048 struct pppoe_net
*pn
= pppoe_pernet(seq_file_net(seq
));
1051 read_lock_bh(&pn
->hash_lock
);
1052 return l
? pppoe_get_idx(pn
, --l
) : SEQ_START_TOKEN
;
1055 static void *pppoe_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
1057 struct pppoe_net
*pn
= pppoe_pernet(seq_file_net(seq
));
1058 struct pppox_sock
*po
;
1061 if (v
== SEQ_START_TOKEN
) {
1062 po
= pppoe_get_idx(pn
, 0);
1069 int hash
= hash_item(po
->pppoe_pa
.sid
, po
->pppoe_pa
.remote
);
1072 while (++hash
< PPPOE_HASH_SIZE
) {
1073 po
= pn
->hash_table
[hash
];
1083 static void pppoe_seq_stop(struct seq_file
*seq
, void *v
)
1084 __releases(pn
->hash_lock
)
1086 struct pppoe_net
*pn
= pppoe_pernet(seq_file_net(seq
));
1087 read_unlock_bh(&pn
->hash_lock
);
1090 static const struct seq_operations pppoe_seq_ops
= {
1091 .start
= pppoe_seq_start
,
1092 .next
= pppoe_seq_next
,
1093 .stop
= pppoe_seq_stop
,
1094 .show
= pppoe_seq_show
,
1096 #endif /* CONFIG_PROC_FS */
1098 static const struct proto_ops pppoe_ops
= {
1100 .owner
= THIS_MODULE
,
1101 .release
= pppoe_release
,
1102 .bind
= sock_no_bind
,
1103 .connect
= pppoe_connect
,
1104 .socketpair
= sock_no_socketpair
,
1105 .accept
= sock_no_accept
,
1106 .getname
= pppoe_getname
,
1107 .poll
= datagram_poll
,
1108 .listen
= sock_no_listen
,
1109 .shutdown
= sock_no_shutdown
,
1110 .setsockopt
= sock_no_setsockopt
,
1111 .getsockopt
= sock_no_getsockopt
,
1112 .sendmsg
= pppoe_sendmsg
,
1113 .recvmsg
= pppoe_recvmsg
,
1114 .mmap
= sock_no_mmap
,
1115 .ioctl
= pppox_ioctl
,
1116 #ifdef CONFIG_COMPAT
1117 .compat_ioctl
= pppox_compat_ioctl
,
1121 static const struct pppox_proto pppoe_proto
= {
1122 .create
= pppoe_create
,
1123 .ioctl
= pppoe_ioctl
,
1124 .owner
= THIS_MODULE
,
1127 static __net_init
int pppoe_init_net(struct net
*net
)
1129 struct pppoe_net
*pn
= pppoe_pernet(net
);
1130 struct proc_dir_entry
*pde
;
1132 rwlock_init(&pn
->hash_lock
);
1134 pde
= proc_create_net("pppoe", 0444, net
->proc_net
,
1135 &pppoe_seq_ops
, sizeof(struct seq_net_private
));
1136 #ifdef CONFIG_PROC_FS
1144 static __net_exit
void pppoe_exit_net(struct net
*net
)
1146 remove_proc_entry("pppoe", net
->proc_net
);
1149 static struct pernet_operations pppoe_net_ops
= {
1150 .init
= pppoe_init_net
,
1151 .exit
= pppoe_exit_net
,
1152 .id
= &pppoe_net_id
,
1153 .size
= sizeof(struct pppoe_net
),
1156 static int __init
pppoe_init(void)
1160 err
= register_pernet_device(&pppoe_net_ops
);
1164 err
= proto_register(&pppoe_sk_proto
, 0);
1166 goto out_unregister_net_ops
;
1168 err
= register_pppox_proto(PX_PROTO_OE
, &pppoe_proto
);
1170 goto out_unregister_pppoe_proto
;
1172 dev_add_pack(&pppoes_ptype
);
1173 dev_add_pack(&pppoed_ptype
);
1174 register_netdevice_notifier(&pppoe_notifier
);
1178 out_unregister_pppoe_proto
:
1179 proto_unregister(&pppoe_sk_proto
);
1180 out_unregister_net_ops
:
1181 unregister_pernet_device(&pppoe_net_ops
);
1186 static void __exit
pppoe_exit(void)
1188 unregister_netdevice_notifier(&pppoe_notifier
);
1189 dev_remove_pack(&pppoed_ptype
);
1190 dev_remove_pack(&pppoes_ptype
);
1191 unregister_pppox_proto(PX_PROTO_OE
);
1192 proto_unregister(&pppoe_sk_proto
);
1193 unregister_pernet_device(&pppoe_net_ops
);
1196 module_init(pppoe_init
);
1197 module_exit(pppoe_exit
);
1199 MODULE_AUTHOR("Michal Ostrowski <mostrows@speakeasy.net>");
1200 MODULE_DESCRIPTION("PPP over Ethernet driver");
1201 MODULE_LICENSE("GPL");
1202 MODULE_ALIAS_NET_PF_PROTO(PF_PPPOX
, PX_PROTO_OE
);