1 /* Modified by Broadcom Corp. Portions Copyright (c) Broadcom Corp, 2012. */
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)
11 * 070228 : Fix to allow multiple sessions with same remote MAC and same
12 * session id by including the local device ifindex in the
13 * tuple identifying a session. This also ensures packets can't
14 * be injected into a session from interfaces other than the one
15 * specified by userspace. Florian Zumbiehl <florz@florz.de>
16 * (Oh, BTW, this one is YYMMDD, in case you were wondering ...)
17 * 220102 : Fix module use count on failure in pppoe_create, pppox_sk -acme
18 * 030700 : Fixed connect logic to allow for disconnect.
19 * 270700 : Fixed potential SMP problems; we must protect against
20 * simultaneous invocation of ppp_input
21 * and ppp_unregister_channel.
22 * 040800 : Respect reference count mechanisms on net-devices.
23 * 200800 : fix kfree(skb) in pppoe_rcv (acme)
24 * Module reference count is decremented in the right spot now,
25 * guards against sock_put not actually freeing the sk
27 * 051000 : Initialization cleanup.
28 * 111100 : Fix recvmsg.
29 * 050101 : Fix PADT procesing.
30 * 140501 : Use pppoe_rcv_core to handle all backlog. (Alexey)
31 * 170701 : Do not lock_sock with rwlock held. (DaveM)
32 * Ignore discovery frames if user has socket
34 * Ignore return value of dev_queue_xmit in __pppoe_xmit
35 * or else we may kfree an SKB twice. (DaveM)
36 * 190701 : When doing copies of skb's in __pppoe_xmit, always delete
37 * the original skb that was passed in on success, never on
38 * failure. Delete the copy of the skb on failure to avoid
40 * 081001 : Misc. cleanup (licence string, non-blocking, prevent
41 * reference of device on close).
42 * 121301 : New ppp channels interface; cannot unregister a channel
43 * from interrupts. Thus, we mark the socket as a ZOMBIE
44 * and do the unregistration later.
45 * 081002 : seq_file support for proc stuff -acme
46 * 111602 : Merge all 2.4 fixes into 2.5/2.6 tree. Label 2.5/2.6
47 * as version 0.7. Spacing cleanup.
48 * Author: Michal Ostrowski <mostrows@speakeasy.net>
50 * Arnaldo Carvalho de Melo <acme@conectiva.com.br>
51 * David S. Miller (davem@redhat.com)
54 * This program is free software; you can redistribute it and/or
55 * modify it under the terms of the GNU General Public License
56 * as published by the Free Software Foundation; either version
57 * 2 of the License, or (at your option) any later version.
61 #include <linux/string.h>
62 #include <linux/module.h>
63 #include <linux/kernel.h>
64 #include <linux/slab.h>
65 #include <linux/errno.h>
66 #include <linux/netdevice.h>
67 #include <linux/net.h>
68 #include <linux/inetdevice.h>
69 #include <linux/etherdevice.h>
70 #include <linux/skbuff.h>
71 #include <linux/init.h>
72 #include <linux/if_ether.h>
73 #include <linux/if_pppox.h>
74 #include <linux/ppp_channel.h>
75 #include <linux/ppp_defs.h>
76 #include <linux/if_ppp.h>
77 #include <linux/notifier.h>
78 #include <linux/file.h>
79 #include <linux/proc_fs.h>
80 #include <linux/seq_file.h>
82 #include <linux/nsproxy.h>
83 #include <net/net_namespace.h>
84 #include <net/netns/generic.h>
87 #include <asm/uaccess.h>
90 #include <ctf/hndctf.h>
93 #define PPPOE_HASH_BITS 4
94 #define PPPOE_HASH_SIZE (1 << PPPOE_HASH_BITS)
95 #define PPPOE_HASH_MASK (PPPOE_HASH_SIZE - 1)
97 static int __pppoe_xmit(struct sock
*sk
, struct sk_buff
*skb
);
99 static const struct proto_ops pppoe_ops
;
100 static const struct ppp_channel_ops pppoe_chan_ops
;
102 /* per-net private data for this module */
103 static int pppoe_net_id __read_mostly
;
106 * we could use _single_ hash table for all
107 * nets by injecting net id into the hash but
108 * it would increase hash chains and add
109 * a few additional math comparations messy
110 * as well, moreover in case of SMP less locking
113 struct pppox_sock
*hash_table
[PPPOE_HASH_SIZE
];
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
= NULL
;
261 dev
= dev_get_by_name_rcu(net
, sp
->sa_addr
.pppoe
.dev
);
263 ifindex
= dev
->ifindex
;
264 pn
= pppoe_pernet(net
);
265 pppox_sock
= get_item(pn
, sp
->sa_addr
.pppoe
.sid
,
266 sp
->sa_addr
.pppoe
.remote
, ifindex
);
272 static inline struct pppox_sock
*delete_item(struct pppoe_net
*pn
, __be16 sid
,
273 char *addr
, int ifindex
)
275 struct pppox_sock
*ret
;
277 write_lock_bh(&pn
->hash_lock
);
278 ret
= __delete_item(pn
, sid
, addr
, ifindex
);
279 write_unlock_bh(&pn
->hash_lock
);
284 /***************************************************************************
286 * Handler for device events.
287 * Certain device events require that sockets be unconnected.
289 **************************************************************************/
291 static void pppoe_flush_dev(struct net_device
*dev
)
293 struct pppoe_net
*pn
;
296 pn
= pppoe_pernet(dev_net(dev
));
297 write_lock_bh(&pn
->hash_lock
);
298 for (i
= 0; i
< PPPOE_HASH_SIZE
; i
++) {
299 struct pppox_sock
*po
= pn
->hash_table
[i
];
303 while (po
&& po
->pppoe_dev
!= dev
) {
312 /* We always grab the socket lock, followed by the
313 * hash_lock, in that order. Since we should hold the
314 * sock lock while doing any unbinding, we need to
315 * release the lock we're holding. Hold a reference to
316 * the sock so it doesn't disappear as we're jumping
321 write_unlock_bh(&pn
->hash_lock
);
324 if (po
->pppoe_dev
== dev
&&
325 sk
->sk_state
& (PPPOX_CONNECTED
| PPPOX_BOUND
)) {
326 pppox_unbind_sock(sk
);
327 sk
->sk_state
= PPPOX_ZOMBIE
;
328 sk
->sk_state_change(sk
);
329 po
->pppoe_dev
= NULL
;
336 /* Restart the process from the start of the current
337 * hash chain. We dropped locks so the world may have
338 * change from underneath us.
341 BUG_ON(pppoe_pernet(dev_net(dev
)) == NULL
);
342 write_lock_bh(&pn
->hash_lock
);
343 po
= pn
->hash_table
[i
];
346 write_unlock_bh(&pn
->hash_lock
);
349 static int pppoe_device_event(struct notifier_block
*this,
350 unsigned long event
, void *ptr
)
352 struct net_device
*dev
= (struct net_device
*)ptr
;
354 /* Only look at sockets that are using this specific device. */
356 case NETDEV_CHANGEMTU
:
357 /* A change in mtu is a bad thing, requiring
358 * LCP re-negotiation.
361 case NETDEV_GOING_DOWN
:
363 /* Find every socket on this device and kill it. */
364 pppoe_flush_dev(dev
);
374 static struct notifier_block pppoe_notifier
= {
375 .notifier_call
= pppoe_device_event
,
378 /************************************************************************
380 * Do the real work of receiving a PPPoE Session frame.
382 ***********************************************************************/
383 static int pppoe_rcv_core(struct sock
*sk
, struct sk_buff
*skb
)
385 struct pppox_sock
*po
= pppox_sk(sk
);
386 struct pppox_sock
*relay_po
;
388 /* Backlog receive. Semantics of backlog rcv preclude any code from
389 * executing in lock_sock()/release_sock() bounds; meaning sk->sk_state
393 if (sk
->sk_state
& PPPOX_BOUND
) {
394 ppp_input(&po
->chan
, skb
);
395 } else if (sk
->sk_state
& PPPOX_RELAY
) {
396 relay_po
= get_item_by_addr(sock_net(sk
),
398 if (relay_po
== NULL
)
401 if ((sk_pppox(relay_po
)->sk_state
& PPPOX_CONNECTED
) == 0)
404 if (!__pppoe_xmit(sk_pppox(relay_po
), skb
))
407 if (sock_queue_rcv_skb(sk
, skb
))
411 return NET_RX_SUCCESS
;
414 sock_put(sk_pppox(relay_po
));
421 /************************************************************************
423 * Receive wrapper called in BH context.
425 ***********************************************************************/
426 static int pppoe_rcv(struct sk_buff
*skb
, struct net_device
*dev
,
427 struct packet_type
*pt
, struct net_device
*orig_dev
)
429 struct pppoe_hdr
*ph
;
430 struct pppox_sock
*po
;
431 struct pppoe_net
*pn
;
434 skb
= skb_share_check(skb
, GFP_ATOMIC
);
438 if (!pskb_may_pull(skb
, sizeof(struct pppoe_hdr
)))
442 len
= ntohs(ph
->length
);
444 skb_pull_rcsum(skb
, sizeof(*ph
));
448 if (pskb_trim_rcsum(skb
, len
))
451 pn
= pppoe_pernet(dev_net(dev
));
453 /* Note that get_item does a sock_hold(), so sk_pppox(po)
454 * is known to be safe.
456 po
= get_item(pn
, ph
->sid
, eth_hdr(skb
)->h_source
, dev
->ifindex
);
461 return sk_receive_skb(sk_pppox(po
), skb
, 0);
469 /************************************************************************
471 * Receive a PPPoE Discovery frame.
472 * This is solely for detection of PADT frames
474 ***********************************************************************/
475 static int pppoe_disc_rcv(struct sk_buff
*skb
, struct net_device
*dev
,
476 struct packet_type
*pt
, struct net_device
*orig_dev
)
479 struct pppoe_hdr
*ph
;
480 struct pppox_sock
*po
;
481 struct pppoe_net
*pn
;
483 skb
= skb_share_check(skb
, GFP_ATOMIC
);
487 if (!pskb_may_pull(skb
, sizeof(struct pppoe_hdr
)))
491 if (ph
->code
!= PADT_CODE
)
494 pn
= pppoe_pernet(dev_net(dev
));
495 po
= get_item(pn
, ph
->sid
, eth_hdr(skb
)->h_source
, dev
->ifindex
);
497 struct sock
*sk
= sk_pppox(po
);
501 /* If the user has locked the socket, just ignore
502 * the packet. With the way two rcv protocols hook into
503 * one socket family type, we cannot (easily) distinguish
504 * what kind of SKB it is during backlog rcv.
506 if (sock_owned_by_user(sk
) == 0) {
507 /* We're no longer connect at the PPPOE layer,
508 * and must wait for ppp channel to disconnect us.
510 sk
->sk_state
= PPPOX_ZOMBIE
;
520 return NET_RX_SUCCESS
; /* Lies... :-) */
523 static struct packet_type pppoes_ptype __read_mostly
= {
524 .type
= cpu_to_be16(ETH_P_PPP_SES
),
528 static struct packet_type pppoed_ptype __read_mostly
= {
529 .type
= cpu_to_be16(ETH_P_PPP_DISC
),
530 .func
= pppoe_disc_rcv
,
533 static struct proto pppoe_sk_proto __read_mostly
= {
535 .owner
= THIS_MODULE
,
536 .obj_size
= sizeof(struct pppox_sock
),
539 /***********************************************************************
541 * Initialize a new struct sock.
543 **********************************************************************/
544 static int pppoe_create(struct net
*net
, struct socket
*sock
)
548 sk
= sk_alloc(net
, PF_PPPOX
, GFP_KERNEL
, &pppoe_sk_proto
);
552 sock_init_data(sock
, sk
);
554 sock
->state
= SS_UNCONNECTED
;
555 sock
->ops
= &pppoe_ops
;
557 sk
->sk_backlog_rcv
= pppoe_rcv_core
;
558 sk
->sk_state
= PPPOX_NONE
;
559 sk
->sk_type
= SOCK_STREAM
;
560 sk
->sk_family
= PF_PPPOX
;
561 sk
->sk_protocol
= PX_PROTO_OE
;
566 static int pppoe_release(struct socket
*sock
)
568 struct sock
*sk
= sock
->sk
;
569 struct pppox_sock
*po
;
570 struct pppoe_net
*pn
;
571 struct net
*net
= NULL
;
577 if (sock_flag(sk
, SOCK_DEAD
)) {
584 if (sk
->sk_state
& (PPPOX_CONNECTED
| PPPOX_BOUND
)) {
585 dev_put(po
->pppoe_dev
);
586 po
->pppoe_dev
= NULL
;
589 pppox_unbind_sock(sk
);
591 /* Signal the death of the socket. */
592 sk
->sk_state
= PPPOX_DEAD
;
595 pn
= pppoe_pernet(net
);
598 * protect "po" from concurrent updates
601 delete_item(pn
, po
->pppoe_pa
.sid
, po
->pppoe_pa
.remote
,
607 skb_queue_purge(&sk
->sk_receive_queue
);
614 static int pppoe_connect(struct socket
*sock
, struct sockaddr
*uservaddr
,
615 int sockaddr_len
, int flags
)
617 struct sock
*sk
= sock
->sk
;
618 struct sockaddr_pppox
*sp
= (struct sockaddr_pppox
*)uservaddr
;
619 struct pppox_sock
*po
= pppox_sk(sk
);
620 struct net_device
*dev
= NULL
;
621 struct pppoe_net
*pn
;
622 struct net
*net
= NULL
;
628 if (sp
->sa_protocol
!= PX_PROTO_OE
)
631 /* Check for already bound sockets */
633 if ((sk
->sk_state
& PPPOX_CONNECTED
) &&
634 stage_session(sp
->sa_addr
.pppoe
.sid
))
637 /* Check for already disconnected sockets, on attempts to disconnect */
639 if ((sk
->sk_state
& PPPOX_DEAD
) &&
640 !stage_session(sp
->sa_addr
.pppoe
.sid
))
645 /* Delete the old binding */
646 if (stage_session(po
->pppoe_pa
.sid
)) {
647 pppox_unbind_sock(sk
);
648 pn
= pppoe_pernet(sock_net(sk
));
649 delete_item(pn
, po
->pppoe_pa
.sid
,
650 po
->pppoe_pa
.remote
, po
->pppoe_ifindex
);
652 dev_put(po
->pppoe_dev
);
653 po
->pppoe_dev
= NULL
;
656 memset(sk_pppox(po
) + 1, 0,
657 sizeof(struct pppox_sock
) - sizeof(struct sock
));
658 sk
->sk_state
= PPPOX_NONE
;
661 /* Re-bind in session stage only */
662 if (stage_session(sp
->sa_addr
.pppoe
.sid
)) {
665 dev
= dev_get_by_name(net
, sp
->sa_addr
.pppoe
.dev
);
670 po
->pppoe_ifindex
= dev
->ifindex
;
671 pn
= pppoe_pernet(net
);
672 if (!(dev
->flags
& IFF_UP
)) {
676 memcpy(&po
->pppoe_pa
,
678 sizeof(struct pppoe_addr
));
680 write_lock_bh(&pn
->hash_lock
);
681 error
= __set_item(pn
, po
);
682 write_unlock_bh(&pn
->hash_lock
);
686 po
->chan
.hdrlen
= (sizeof(struct pppoe_hdr
) +
687 dev
->hard_header_len
);
689 po
->chan
.mtu
= dev
->mtu
- sizeof(struct pppoe_hdr
);
690 po
->chan
.private = sk
;
691 po
->chan
.ops
= &pppoe_chan_ops
;
693 error
= ppp_register_net_channel(dev_net(dev
), &po
->chan
);
695 delete_item(pn
, po
->pppoe_pa
.sid
,
696 po
->pppoe_pa
.remote
, po
->pppoe_ifindex
);
700 sk
->sk_state
= PPPOX_CONNECTED
;
703 po
->num
= sp
->sa_addr
.pppoe
.sid
;
710 dev_put(po
->pppoe_dev
);
711 po
->pppoe_dev
= NULL
;
716 static int pppoe_getname(struct socket
*sock
, struct sockaddr
*uaddr
,
717 int *usockaddr_len
, int peer
)
719 int len
= sizeof(struct sockaddr_pppox
);
720 struct sockaddr_pppox sp
;
722 sp
.sa_family
= AF_PPPOX
;
723 sp
.sa_protocol
= PX_PROTO_OE
;
724 memcpy(&sp
.sa_addr
.pppoe
, &pppox_sk(sock
->sk
)->pppoe_pa
,
725 sizeof(struct pppoe_addr
));
727 memcpy(uaddr
, &sp
, len
);
729 *usockaddr_len
= len
;
734 static int pppoe_ioctl(struct socket
*sock
, unsigned int cmd
,
737 struct sock
*sk
= sock
->sk
;
738 struct pppox_sock
*po
= pppox_sk(sk
);
745 if (!(sk
->sk_state
& PPPOX_CONNECTED
))
749 if (put_user(po
->pppoe_dev
->mtu
-
750 sizeof(struct pppoe_hdr
) -
759 if (!(sk
->sk_state
& PPPOX_CONNECTED
))
763 if (get_user(val
, (int __user
*)arg
))
766 if (val
< (po
->pppoe_dev
->mtu
767 - sizeof(struct pppoe_hdr
)
776 if (get_user(val
, (int __user
*)arg
))
783 struct pppox_sock
*relay_po
;
786 if (sk
->sk_state
& (PPPOX_BOUND
| PPPOX_ZOMBIE
| PPPOX_DEAD
))
790 if (!(sk
->sk_state
& PPPOX_CONNECTED
))
793 /* PPPoE address from the user specifies an outbound
794 PPPoE address which frames are forwarded to */
796 if (copy_from_user(&po
->pppoe_relay
,
798 sizeof(struct sockaddr_pppox
)))
802 if (po
->pppoe_relay
.sa_family
!= AF_PPPOX
||
803 po
->pppoe_relay
.sa_protocol
!= PX_PROTO_OE
)
806 /* Check that the socket referenced by the address
808 relay_po
= get_item_by_addr(sock_net(sk
), &po
->pppoe_relay
);
812 sock_put(sk_pppox(relay_po
));
813 sk
->sk_state
|= PPPOX_RELAY
;
820 if (!(sk
->sk_state
& PPPOX_RELAY
))
823 sk
->sk_state
&= ~PPPOX_RELAY
;
834 static int pppoe_sendmsg(struct kiocb
*iocb
, struct socket
*sock
,
835 struct msghdr
*m
, size_t total_len
)
838 struct sock
*sk
= sock
->sk
;
839 struct pppox_sock
*po
= pppox_sk(sk
);
841 struct pppoe_hdr hdr
;
842 struct pppoe_hdr
*ph
;
843 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
))
864 skb
= sock_wmalloc(sk
, total_len
+ dev
->hard_header_len
+ 32,
871 /* Reserve space for headers. */
872 skb_reserve(skb
, dev
->hard_header_len
);
873 skb_reset_network_header(skb
);
877 skb
->priority
= sk
->sk_priority
;
878 skb
->protocol
= cpu_to_be16(ETH_P_PPP_SES
);
880 ph
= (struct pppoe_hdr
*)skb_put(skb
, total_len
+ sizeof(struct pppoe_hdr
));
881 start
= (char *)&ph
->tag
[0];
883 error
= memcpy_fromiovec(start
, m
->msg_iov
, 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
, sizeof(*ph
) + dev
->hard_header_len
))
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
);
950 dev_hard_header(skb
, dev
, ETH_P_PPP_SES
,
951 po
->pppoe_pa
.remote
, NULL
, data_len
);
961 /************************************************************************
963 * xmit function called by generic PPP driver
964 * sends PPP frame over PPPoE socket
966 ***********************************************************************/
967 static int pppoe_xmit(struct ppp_channel
*chan
, struct sk_buff
*skb
)
969 struct sock
*sk
= (struct sock
*)chan
->private;
970 return __pppoe_xmit(sk
, skb
);
973 static const struct ppp_channel_ops pppoe_chan_ops
= {
974 .start_xmit
= pppoe_xmit
,
977 static int pppoe_recvmsg(struct kiocb
*iocb
, struct socket
*sock
,
978 struct msghdr
*m
, size_t total_len
, int flags
)
980 struct sock
*sk
= sock
->sk
;
984 if (sk
->sk_state
& PPPOX_BOUND
) {
989 skb
= skb_recv_datagram(sk
, flags
& ~MSG_DONTWAIT
,
990 flags
& MSG_DONTWAIT
, &error
);
997 total_len
= min_t(size_t, total_len
, skb
->len
);
998 error
= skb_copy_datagram_iovec(skb
, 0, m
->msg_iov
, total_len
);
1008 #ifdef CONFIG_PROC_FS
1009 static int pppoe_seq_show(struct seq_file
*seq
, void *v
)
1011 struct pppox_sock
*po
;
1014 if (v
== SEQ_START_TOKEN
) {
1015 seq_puts(seq
, "Id Address Device\n");
1020 dev_name
= po
->pppoe_pa
.dev
;
1022 seq_printf(seq
, "%08X %pM %8s\n",
1023 po
->pppoe_pa
.sid
, po
->pppoe_pa
.remote
, dev_name
);
1028 static inline struct pppox_sock
*pppoe_get_idx(struct pppoe_net
*pn
, loff_t pos
)
1030 struct pppox_sock
*po
;
1033 for (i
= 0; i
< PPPOE_HASH_SIZE
; i
++) {
1034 po
= pn
->hash_table
[i
];
1046 static void *pppoe_seq_start(struct seq_file
*seq
, loff_t
*pos
)
1047 __acquires(pn
->hash_lock
)
1049 struct pppoe_net
*pn
= pppoe_pernet(seq_file_net(seq
));
1052 read_lock_bh(&pn
->hash_lock
);
1053 return l
? pppoe_get_idx(pn
, --l
) : SEQ_START_TOKEN
;
1056 static void *pppoe_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
1058 struct pppoe_net
*pn
= pppoe_pernet(seq_file_net(seq
));
1059 struct pppox_sock
*po
;
1062 if (v
== SEQ_START_TOKEN
) {
1063 po
= pppoe_get_idx(pn
, 0);
1070 int hash
= hash_item(po
->pppoe_pa
.sid
, po
->pppoe_pa
.remote
);
1073 while (++hash
< PPPOE_HASH_SIZE
) {
1074 po
= pn
->hash_table
[hash
];
1084 static void pppoe_seq_stop(struct seq_file
*seq
, void *v
)
1085 __releases(pn
->hash_lock
)
1087 struct pppoe_net
*pn
= pppoe_pernet(seq_file_net(seq
));
1088 read_unlock_bh(&pn
->hash_lock
);
1091 static const struct seq_operations pppoe_seq_ops
= {
1092 .start
= pppoe_seq_start
,
1093 .next
= pppoe_seq_next
,
1094 .stop
= pppoe_seq_stop
,
1095 .show
= pppoe_seq_show
,
1098 static int pppoe_seq_open(struct inode
*inode
, struct file
*file
)
1100 return seq_open_net(inode
, file
, &pppoe_seq_ops
,
1101 sizeof(struct seq_net_private
));
1104 static const struct file_operations pppoe_seq_fops
= {
1105 .owner
= THIS_MODULE
,
1106 .open
= pppoe_seq_open
,
1108 .llseek
= seq_lseek
,
1109 .release
= seq_release_net
,
1112 #endif /* CONFIG_PROC_FS */
1114 static const struct proto_ops pppoe_ops
= {
1116 .owner
= THIS_MODULE
,
1117 .release
= pppoe_release
,
1118 .bind
= sock_no_bind
,
1119 .connect
= pppoe_connect
,
1120 .socketpair
= sock_no_socketpair
,
1121 .accept
= sock_no_accept
,
1122 .getname
= pppoe_getname
,
1123 .poll
= datagram_poll
,
1124 .listen
= sock_no_listen
,
1125 .shutdown
= sock_no_shutdown
,
1126 .setsockopt
= sock_no_setsockopt
,
1127 .getsockopt
= sock_no_getsockopt
,
1128 .sendmsg
= pppoe_sendmsg
,
1129 .recvmsg
= pppoe_recvmsg
,
1130 .mmap
= sock_no_mmap
,
1131 .ioctl
= pppox_ioctl
,
1134 static struct pppox_proto pppoe_proto
= {
1135 .create
= pppoe_create
,
1136 .ioctl
= pppoe_ioctl
,
1137 .owner
= THIS_MODULE
,
1140 static __net_init
int pppoe_init_net(struct net
*net
)
1142 struct pppoe_net
*pn
= pppoe_pernet(net
);
1143 struct proc_dir_entry
*pde
;
1145 rwlock_init(&pn
->hash_lock
);
1147 pde
= proc_net_fops_create(net
, "pppoe", S_IRUGO
, &pppoe_seq_fops
);
1148 #ifdef CONFIG_PROC_FS
1156 static __net_exit
void pppoe_exit_net(struct net
*net
)
1158 proc_net_remove(net
, "pppoe");
1161 static struct pernet_operations pppoe_net_ops
= {
1162 .init
= pppoe_init_net
,
1163 .exit
= pppoe_exit_net
,
1164 .id
= &pppoe_net_id
,
1165 .size
= sizeof(struct pppoe_net
),
1168 static int __init
pppoe_init(void)
1172 err
= register_pernet_device(&pppoe_net_ops
);
1176 err
= proto_register(&pppoe_sk_proto
, 0);
1178 goto out_unregister_net_ops
;
1180 err
= register_pppox_proto(PX_PROTO_OE
, &pppoe_proto
);
1182 goto out_unregister_pppoe_proto
;
1184 dev_add_pack(&pppoes_ptype
);
1185 dev_add_pack(&pppoed_ptype
);
1186 register_netdevice_notifier(&pppoe_notifier
);
1190 out_unregister_pppoe_proto
:
1191 proto_unregister(&pppoe_sk_proto
);
1192 out_unregister_net_ops
:
1193 unregister_pernet_device(&pppoe_net_ops
);
1198 static void __exit
pppoe_exit(void)
1200 unregister_netdevice_notifier(&pppoe_notifier
);
1201 dev_remove_pack(&pppoed_ptype
);
1202 dev_remove_pack(&pppoes_ptype
);
1203 unregister_pppox_proto(PX_PROTO_OE
);
1204 proto_unregister(&pppoe_sk_proto
);
1205 unregister_pernet_device(&pppoe_net_ops
);
1208 module_init(pppoe_init
);
1209 module_exit(pppoe_exit
);
1211 MODULE_AUTHOR("Michal Ostrowski <mostrows@speakeasy.net>");
1212 MODULE_DESCRIPTION("PPP over Ethernet driver");
1213 MODULE_LICENSE("GPL");
1214 MODULE_ALIAS_NETPROTO(PF_PPPOX
);