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 <net/net_namespace.h>
84 #include <asm/uaccess.h>
86 #define PPPOE_HASH_BITS 4
87 #define PPPOE_HASH_SIZE (1<<PPPOE_HASH_BITS)
89 static struct ppp_channel_ops pppoe_chan_ops
;
91 static int pppoe_ioctl(struct socket
*sock
, unsigned int cmd
, unsigned long arg
);
92 static int pppoe_xmit(struct ppp_channel
*chan
, struct sk_buff
*skb
);
93 static int __pppoe_xmit(struct sock
*sk
, struct sk_buff
*skb
);
95 static const struct proto_ops pppoe_ops
;
96 static DEFINE_RWLOCK(pppoe_hash_lock
);
98 static struct ppp_channel_ops pppoe_chan_ops
;
100 static inline int cmp_2_addr(struct pppoe_addr
*a
, struct pppoe_addr
*b
)
102 return (a
->sid
== b
->sid
&&
103 (memcmp(a
->remote
, b
->remote
, ETH_ALEN
) == 0));
106 static inline int cmp_addr(struct pppoe_addr
*a
, unsigned long sid
, char *addr
)
108 return (a
->sid
== sid
&&
109 (memcmp(a
->remote
,addr
,ETH_ALEN
) == 0));
112 #if 8%PPPOE_HASH_BITS
113 #error 8 must be a multiple of PPPOE_HASH_BITS
116 static int hash_item(unsigned int sid
, unsigned char *addr
)
118 unsigned char hash
= 0;
121 for (i
= 0 ; i
< ETH_ALEN
; i
++) {
124 for (i
= 0 ; i
< sizeof(sid_t
)*8 ; i
+= 8 ){
127 for (i
= 8 ; (i
>>=1) >= PPPOE_HASH_BITS
; ) {
131 return hash
& ( PPPOE_HASH_SIZE
- 1 );
134 /* zeroed because its in .bss */
135 static struct pppox_sock
*item_hash_table
[PPPOE_HASH_SIZE
];
137 /**********************************************************************
139 * Set/get/delete/rehash items (internal versions)
141 **********************************************************************/
142 static struct pppox_sock
*__get_item(unsigned long sid
, unsigned char *addr
, int ifindex
)
144 int hash
= hash_item(sid
, addr
);
145 struct pppox_sock
*ret
;
147 ret
= item_hash_table
[hash
];
149 while (ret
&& !(cmp_addr(&ret
->pppoe_pa
, sid
, addr
) && ret
->pppoe_ifindex
== ifindex
))
155 static int __set_item(struct pppox_sock
*po
)
157 int hash
= hash_item(po
->pppoe_pa
.sid
, po
->pppoe_pa
.remote
);
158 struct pppox_sock
*ret
;
160 ret
= item_hash_table
[hash
];
162 if (cmp_2_addr(&ret
->pppoe_pa
, &po
->pppoe_pa
) && ret
->pppoe_ifindex
== po
->pppoe_ifindex
)
168 po
->next
= item_hash_table
[hash
];
169 item_hash_table
[hash
] = po
;
174 static struct pppox_sock
*__delete_item(unsigned long sid
, char *addr
, int ifindex
)
176 int hash
= hash_item(sid
, addr
);
177 struct pppox_sock
*ret
, **src
;
179 ret
= item_hash_table
[hash
];
180 src
= &item_hash_table
[hash
];
183 if (cmp_addr(&ret
->pppoe_pa
, sid
, addr
) && ret
->pppoe_ifindex
== ifindex
) {
195 /**********************************************************************
197 * Set/get/delete/rehash items
199 **********************************************************************/
200 static inline struct pppox_sock
*get_item(unsigned long sid
,
201 unsigned char *addr
, int ifindex
)
203 struct pppox_sock
*po
;
205 read_lock_bh(&pppoe_hash_lock
);
206 po
= __get_item(sid
, addr
, ifindex
);
208 sock_hold(sk_pppox(po
));
209 read_unlock_bh(&pppoe_hash_lock
);
214 static inline struct pppox_sock
*get_item_by_addr(struct sockaddr_pppox
*sp
)
216 struct net_device
*dev
;
219 dev
= dev_get_by_name(sp
->sa_addr
.pppoe
.dev
);
222 ifindex
= dev
->ifindex
;
224 return get_item(sp
->sa_addr
.pppoe
.sid
, sp
->sa_addr
.pppoe
.remote
, ifindex
);
227 static inline struct pppox_sock
*delete_item(unsigned long sid
, char *addr
, int ifindex
)
229 struct pppox_sock
*ret
;
231 write_lock_bh(&pppoe_hash_lock
);
232 ret
= __delete_item(sid
, addr
, ifindex
);
233 write_unlock_bh(&pppoe_hash_lock
);
240 /***************************************************************************
242 * Handler for device events.
243 * Certain device events require that sockets be unconnected.
245 **************************************************************************/
247 static void pppoe_flush_dev(struct net_device
*dev
)
252 write_lock_bh(&pppoe_hash_lock
);
253 for (hash
= 0; hash
< PPPOE_HASH_SIZE
; hash
++) {
254 struct pppox_sock
*po
= item_hash_table
[hash
];
257 struct sock
*sk
= sk_pppox(po
);
258 if (po
->pppoe_dev
!= dev
) {
262 po
->pppoe_dev
= NULL
;
266 /* We always grab the socket lock, followed by the
267 * pppoe_hash_lock, in that order. Since we should
268 * hold the sock lock while doing any unbinding,
269 * we need to release the lock we're holding.
270 * Hold a reference to the sock so it doesn't disappear
271 * as we're jumping between locks.
276 write_unlock_bh(&pppoe_hash_lock
);
279 if (sk
->sk_state
& (PPPOX_CONNECTED
| PPPOX_BOUND
)) {
280 pppox_unbind_sock(sk
);
281 sk
->sk_state
= PPPOX_ZOMBIE
;
282 sk
->sk_state_change(sk
);
288 /* Restart scan at the beginning of this hash chain.
289 * While the lock was dropped the chain contents may
292 write_lock_bh(&pppoe_hash_lock
);
293 po
= item_hash_table
[hash
];
296 write_unlock_bh(&pppoe_hash_lock
);
299 static int pppoe_device_event(struct notifier_block
*this,
300 unsigned long event
, void *ptr
)
302 struct net_device
*dev
= (struct net_device
*) ptr
;
304 /* Only look at sockets that are using this specific device. */
306 case NETDEV_CHANGEMTU
:
307 /* A change in mtu is a bad thing, requiring
308 * LCP re-negotiation.
311 case NETDEV_GOING_DOWN
:
313 /* Find every socket on this device and kill it. */
314 pppoe_flush_dev(dev
);
325 static struct notifier_block pppoe_notifier
= {
326 .notifier_call
= pppoe_device_event
,
330 /************************************************************************
332 * Do the real work of receiving a PPPoE Session frame.
334 ***********************************************************************/
335 static int pppoe_rcv_core(struct sock
*sk
, struct sk_buff
*skb
)
337 struct pppox_sock
*po
= pppox_sk(sk
);
338 struct pppox_sock
*relay_po
;
340 if (sk
->sk_state
& PPPOX_BOUND
) {
341 struct pppoe_hdr
*ph
= pppoe_hdr(skb
);
342 int len
= ntohs(ph
->length
);
343 skb_pull_rcsum(skb
, sizeof(struct pppoe_hdr
));
344 if (pskb_trim_rcsum(skb
, len
))
347 ppp_input(&po
->chan
, skb
);
348 } else if (sk
->sk_state
& PPPOX_RELAY
) {
349 relay_po
= get_item_by_addr(&po
->pppoe_relay
);
351 if (relay_po
== NULL
)
354 if ((sk_pppox(relay_po
)->sk_state
& PPPOX_CONNECTED
) == 0)
357 skb_pull(skb
, sizeof(struct pppoe_hdr
));
358 if (!__pppoe_xmit(sk_pppox(relay_po
), skb
))
361 if (sock_queue_rcv_skb(sk
, skb
))
365 return NET_RX_SUCCESS
;
368 sock_put(sk_pppox(relay_po
));
375 /************************************************************************
377 * Receive wrapper called in BH context.
379 ***********************************************************************/
380 static int pppoe_rcv(struct sk_buff
*skb
,
381 struct net_device
*dev
,
382 struct packet_type
*pt
,
383 struct net_device
*orig_dev
)
386 struct pppoe_hdr
*ph
;
387 struct pppox_sock
*po
;
389 if (!(skb
= skb_share_check(skb
, GFP_ATOMIC
)))
392 if (!pskb_may_pull(skb
, sizeof(struct pppoe_hdr
)))
397 po
= get_item((unsigned long) ph
->sid
, eth_hdr(skb
)->h_source
, dev
->ifindex
);
399 return sk_receive_skb(sk_pppox(po
), skb
, 0);
406 /************************************************************************
408 * Receive a PPPoE Discovery frame.
409 * This is solely for detection of PADT frames
411 ***********************************************************************/
412 static int pppoe_disc_rcv(struct sk_buff
*skb
,
413 struct net_device
*dev
,
414 struct packet_type
*pt
,
415 struct net_device
*orig_dev
)
418 struct pppoe_hdr
*ph
;
419 struct pppox_sock
*po
;
421 if (!pskb_may_pull(skb
, sizeof(struct pppoe_hdr
)))
424 if (!(skb
= skb_share_check(skb
, GFP_ATOMIC
)))
428 if (ph
->code
!= PADT_CODE
)
431 po
= get_item((unsigned long) ph
->sid
, eth_hdr(skb
)->h_source
, dev
->ifindex
);
433 struct sock
*sk
= sk_pppox(po
);
437 /* If the user has locked the socket, just ignore
438 * the packet. With the way two rcv protocols hook into
439 * one socket family type, we cannot (easily) distinguish
440 * what kind of SKB it is during backlog rcv.
442 if (sock_owned_by_user(sk
) == 0) {
443 /* We're no longer connect at the PPPOE layer,
444 * and must wait for ppp channel to disconnect us.
446 sk
->sk_state
= PPPOX_ZOMBIE
;
456 return NET_RX_SUCCESS
; /* Lies... :-) */
459 static struct packet_type pppoes_ptype
= {
460 .type
= __constant_htons(ETH_P_PPP_SES
),
464 static struct packet_type pppoed_ptype
= {
465 .type
= __constant_htons(ETH_P_PPP_DISC
),
466 .func
= pppoe_disc_rcv
,
469 static struct proto pppoe_sk_proto
= {
471 .owner
= THIS_MODULE
,
472 .obj_size
= sizeof(struct pppox_sock
),
475 /***********************************************************************
477 * Initialize a new struct sock.
479 **********************************************************************/
480 static int pppoe_create(struct socket
*sock
)
485 sk
= sk_alloc(PF_PPPOX
, GFP_KERNEL
, &pppoe_sk_proto
, 1);
489 sock_init_data(sock
, sk
);
491 sock
->state
= SS_UNCONNECTED
;
492 sock
->ops
= &pppoe_ops
;
494 sk
->sk_backlog_rcv
= pppoe_rcv_core
;
495 sk
->sk_state
= PPPOX_NONE
;
496 sk
->sk_type
= SOCK_STREAM
;
497 sk
->sk_family
= PF_PPPOX
;
498 sk
->sk_protocol
= PX_PROTO_OE
;
504 static int pppoe_release(struct socket
*sock
)
506 struct sock
*sk
= sock
->sk
;
507 struct pppox_sock
*po
;
513 if (sock_flag(sk
, SOCK_DEAD
)){
518 pppox_unbind_sock(sk
);
520 /* Signal the death of the socket. */
521 sk
->sk_state
= PPPOX_DEAD
;
524 /* Write lock on hash lock protects the entire "po" struct from
525 * concurrent updates via pppoe_flush_dev. The "po" struct should
526 * be considered part of the hash table contents, thus protected
527 * by the hash table lock */
528 write_lock_bh(&pppoe_hash_lock
);
531 if (po
->pppoe_pa
.sid
) {
532 __delete_item(po
->pppoe_pa
.sid
,
533 po
->pppoe_pa
.remote
, po
->pppoe_ifindex
);
537 dev_put(po
->pppoe_dev
);
538 po
->pppoe_dev
= NULL
;
541 write_unlock_bh(&pppoe_hash_lock
);
546 skb_queue_purge(&sk
->sk_receive_queue
);
554 static int pppoe_connect(struct socket
*sock
, struct sockaddr
*uservaddr
,
555 int sockaddr_len
, int flags
)
557 struct sock
*sk
= sock
->sk
;
558 struct net_device
*dev
;
559 struct sockaddr_pppox
*sp
= (struct sockaddr_pppox
*) uservaddr
;
560 struct pppox_sock
*po
= pppox_sk(sk
);
566 if (sp
->sa_protocol
!= PX_PROTO_OE
)
569 /* Check for already bound sockets */
571 if ((sk
->sk_state
& PPPOX_CONNECTED
) && sp
->sa_addr
.pppoe
.sid
)
574 /* Check for already disconnected sockets, on attempts to disconnect */
576 if ((sk
->sk_state
& PPPOX_DEAD
) && !sp
->sa_addr
.pppoe
.sid
)
580 if (po
->pppoe_pa
.sid
) {
581 pppox_unbind_sock(sk
);
583 /* Delete the old binding */
584 delete_item(po
->pppoe_pa
.sid
,po
->pppoe_pa
.remote
,po
->pppoe_ifindex
);
587 dev_put(po
->pppoe_dev
);
589 memset(sk_pppox(po
) + 1, 0,
590 sizeof(struct pppox_sock
) - sizeof(struct sock
));
592 sk
->sk_state
= PPPOX_NONE
;
595 /* Don't re-bind if sid==0 */
596 if (sp
->sa_addr
.pppoe
.sid
!= 0) {
597 dev
= dev_get_by_name(sp
->sa_addr
.pppoe
.dev
);
604 po
->pppoe_ifindex
= dev
->ifindex
;
606 write_lock_bh(&pppoe_hash_lock
);
607 if (!(dev
->flags
& IFF_UP
)){
608 write_unlock_bh(&pppoe_hash_lock
);
612 memcpy(&po
->pppoe_pa
,
614 sizeof(struct pppoe_addr
));
616 error
= __set_item(po
);
617 write_unlock_bh(&pppoe_hash_lock
);
621 po
->chan
.hdrlen
= (sizeof(struct pppoe_hdr
) +
622 dev
->hard_header_len
);
624 po
->chan
.mtu
= dev
->mtu
- sizeof(struct pppoe_hdr
);
625 po
->chan
.private = sk
;
626 po
->chan
.ops
= &pppoe_chan_ops
;
628 error
= ppp_register_channel(&po
->chan
);
632 sk
->sk_state
= PPPOX_CONNECTED
;
635 po
->num
= sp
->sa_addr
.pppoe
.sid
;
642 dev_put(po
->pppoe_dev
);
643 po
->pppoe_dev
= NULL
;
649 static int pppoe_getname(struct socket
*sock
, struct sockaddr
*uaddr
,
650 int *usockaddr_len
, int peer
)
652 int len
= sizeof(struct sockaddr_pppox
);
653 struct sockaddr_pppox sp
;
655 sp
.sa_family
= AF_PPPOX
;
656 sp
.sa_protocol
= PX_PROTO_OE
;
657 memcpy(&sp
.sa_addr
.pppoe
, &pppox_sk(sock
->sk
)->pppoe_pa
,
658 sizeof(struct pppoe_addr
));
660 memcpy(uaddr
, &sp
, len
);
662 *usockaddr_len
= len
;
668 static int pppoe_ioctl(struct socket
*sock
, unsigned int cmd
,
671 struct sock
*sk
= sock
->sk
;
672 struct pppox_sock
*po
= pppox_sk(sk
);
680 if (!(sk
->sk_state
& PPPOX_CONNECTED
))
684 if (put_user(po
->pppoe_dev
->mtu
-
685 sizeof(struct pppoe_hdr
) -
694 if (!(sk
->sk_state
& PPPOX_CONNECTED
))
698 if (get_user(val
,(int __user
*) arg
))
701 if (val
< (po
->pppoe_dev
->mtu
702 - sizeof(struct pppoe_hdr
)
711 if (get_user(val
, (int __user
*) arg
))
718 struct pppox_sock
*relay_po
;
721 if (sk
->sk_state
& (PPPOX_BOUND
| PPPOX_ZOMBIE
| PPPOX_DEAD
))
725 if (!(sk
->sk_state
& PPPOX_CONNECTED
))
728 /* PPPoE address from the user specifies an outbound
729 PPPoE address which frames are forwarded to */
731 if (copy_from_user(&po
->pppoe_relay
,
733 sizeof(struct sockaddr_pppox
)))
737 if (po
->pppoe_relay
.sa_family
!= AF_PPPOX
||
738 po
->pppoe_relay
.sa_protocol
!= PX_PROTO_OE
)
741 /* Check that the socket referenced by the address
743 relay_po
= get_item_by_addr(&po
->pppoe_relay
);
748 sock_put(sk_pppox(relay_po
));
749 sk
->sk_state
|= PPPOX_RELAY
;
756 if (!(sk
->sk_state
& PPPOX_RELAY
))
759 sk
->sk_state
&= ~PPPOX_RELAY
;
771 static int pppoe_sendmsg(struct kiocb
*iocb
, struct socket
*sock
,
772 struct msghdr
*m
, size_t total_len
)
775 struct sock
*sk
= sock
->sk
;
776 struct pppox_sock
*po
= pppox_sk(sk
);
778 struct pppoe_hdr hdr
;
779 struct pppoe_hdr
*ph
;
780 struct net_device
*dev
;
784 if (sock_flag(sk
, SOCK_DEAD
) || !(sk
->sk_state
& PPPOX_CONNECTED
)) {
797 if (total_len
> (dev
->mtu
+ dev
->hard_header_len
))
801 skb
= sock_wmalloc(sk
, total_len
+ dev
->hard_header_len
+ 32,
808 /* Reserve space for headers. */
809 skb_reserve(skb
, dev
->hard_header_len
);
810 skb_reset_network_header(skb
);
814 skb
->priority
= sk
->sk_priority
;
815 skb
->protocol
= __constant_htons(ETH_P_PPP_SES
);
817 ph
= (struct pppoe_hdr
*) skb_put(skb
, total_len
+ sizeof(struct pppoe_hdr
));
818 start
= (char *) &ph
->tag
[0];
820 error
= memcpy_fromiovec(start
, m
->msg_iov
, total_len
);
828 dev
->hard_header(skb
, dev
, ETH_P_PPP_SES
,
829 po
->pppoe_pa
.remote
, NULL
, total_len
);
831 memcpy(ph
, &hdr
, sizeof(struct pppoe_hdr
));
833 ph
->length
= htons(total_len
);
843 /************************************************************************
845 * xmit function for internal use.
847 ***********************************************************************/
848 static int __pppoe_xmit(struct sock
*sk
, struct sk_buff
*skb
)
850 struct pppox_sock
*po
= pppox_sk(sk
);
851 struct net_device
*dev
= po
->pppoe_dev
;
852 struct pppoe_hdr
*ph
;
853 int data_len
= skb
->len
;
855 if (sock_flag(sk
, SOCK_DEAD
) || !(sk
->sk_state
& PPPOX_CONNECTED
))
861 /* Copy the data if there is no space for the header or if it's
864 if (skb_cow_head(skb
, sizeof(*ph
) + dev
->hard_header_len
))
867 __skb_push(skb
, sizeof(*ph
));
868 skb_reset_network_header(skb
);
875 ph
->length
= htons(data_len
);
877 skb
->protocol
= __constant_htons(ETH_P_PPP_SES
);
880 dev
->hard_header(skb
, dev
, ETH_P_PPP_SES
,
881 po
->pppoe_pa
.remote
, NULL
, data_len
);
893 /************************************************************************
895 * xmit function called by generic PPP driver
896 * sends PPP frame over PPPoE socket
898 ***********************************************************************/
899 static int pppoe_xmit(struct ppp_channel
*chan
, struct sk_buff
*skb
)
901 struct sock
*sk
= (struct sock
*) chan
->private;
902 return __pppoe_xmit(sk
, skb
);
906 static struct ppp_channel_ops pppoe_chan_ops
= {
907 .start_xmit
= pppoe_xmit
,
910 static int pppoe_recvmsg(struct kiocb
*iocb
, struct socket
*sock
,
911 struct msghdr
*m
, size_t total_len
, int flags
)
913 struct sock
*sk
= sock
->sk
;
917 if (sk
->sk_state
& PPPOX_BOUND
) {
922 skb
= skb_recv_datagram(sk
, flags
& ~MSG_DONTWAIT
,
923 flags
& MSG_DONTWAIT
, &error
);
931 struct pppoe_hdr
*ph
= pppoe_hdr(skb
);
932 const int len
= ntohs(ph
->length
);
934 error
= memcpy_toiovec(m
->msg_iov
, (unsigned char *) &ph
->tag
[0], len
);
944 #ifdef CONFIG_PROC_FS
945 static int pppoe_seq_show(struct seq_file
*seq
, void *v
)
947 struct pppox_sock
*po
;
950 if (v
== SEQ_START_TOKEN
) {
951 seq_puts(seq
, "Id Address Device\n");
956 dev_name
= po
->pppoe_pa
.dev
;
958 seq_printf(seq
, "%08X %02X:%02X:%02X:%02X:%02X:%02X %8s\n",
960 po
->pppoe_pa
.remote
[0], po
->pppoe_pa
.remote
[1],
961 po
->pppoe_pa
.remote
[2], po
->pppoe_pa
.remote
[3],
962 po
->pppoe_pa
.remote
[4], po
->pppoe_pa
.remote
[5], dev_name
);
967 static __inline__
struct pppox_sock
*pppoe_get_idx(loff_t pos
)
969 struct pppox_sock
*po
;
972 for (; i
< PPPOE_HASH_SIZE
; i
++) {
973 po
= item_hash_table
[i
];
984 static void *pppoe_seq_start(struct seq_file
*seq
, loff_t
*pos
)
988 read_lock_bh(&pppoe_hash_lock
);
989 return l
? pppoe_get_idx(--l
) : SEQ_START_TOKEN
;
992 static void *pppoe_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
994 struct pppox_sock
*po
;
997 if (v
== SEQ_START_TOKEN
) {
998 po
= pppoe_get_idx(0);
1005 int hash
= hash_item(po
->pppoe_pa
.sid
, po
->pppoe_pa
.remote
);
1007 while (++hash
< PPPOE_HASH_SIZE
) {
1008 po
= item_hash_table
[hash
];
1017 static void pppoe_seq_stop(struct seq_file
*seq
, void *v
)
1019 read_unlock_bh(&pppoe_hash_lock
);
1022 static struct seq_operations pppoe_seq_ops
= {
1023 .start
= pppoe_seq_start
,
1024 .next
= pppoe_seq_next
,
1025 .stop
= pppoe_seq_stop
,
1026 .show
= pppoe_seq_show
,
1029 static int pppoe_seq_open(struct inode
*inode
, struct file
*file
)
1031 return seq_open(file
, &pppoe_seq_ops
);
1034 static const struct file_operations pppoe_seq_fops
= {
1035 .owner
= THIS_MODULE
,
1036 .open
= pppoe_seq_open
,
1038 .llseek
= seq_lseek
,
1039 .release
= seq_release
,
1042 static int __init
pppoe_proc_init(void)
1044 struct proc_dir_entry
*p
;
1046 p
= create_proc_entry("pppoe", S_IRUGO
, init_net
.proc_net
);
1050 p
->proc_fops
= &pppoe_seq_fops
;
1053 #else /* CONFIG_PROC_FS */
1054 static inline int pppoe_proc_init(void) { return 0; }
1055 #endif /* CONFIG_PROC_FS */
1057 static const struct proto_ops pppoe_ops
= {
1059 .owner
= THIS_MODULE
,
1060 .release
= pppoe_release
,
1061 .bind
= sock_no_bind
,
1062 .connect
= pppoe_connect
,
1063 .socketpair
= sock_no_socketpair
,
1064 .accept
= sock_no_accept
,
1065 .getname
= pppoe_getname
,
1066 .poll
= datagram_poll
,
1067 .listen
= sock_no_listen
,
1068 .shutdown
= sock_no_shutdown
,
1069 .setsockopt
= sock_no_setsockopt
,
1070 .getsockopt
= sock_no_getsockopt
,
1071 .sendmsg
= pppoe_sendmsg
,
1072 .recvmsg
= pppoe_recvmsg
,
1073 .mmap
= sock_no_mmap
,
1074 .ioctl
= pppox_ioctl
,
1077 static struct pppox_proto pppoe_proto
= {
1078 .create
= pppoe_create
,
1079 .ioctl
= pppoe_ioctl
,
1080 .owner
= THIS_MODULE
,
1084 static int __init
pppoe_init(void)
1086 int err
= proto_register(&pppoe_sk_proto
, 0);
1091 err
= register_pppox_proto(PX_PROTO_OE
, &pppoe_proto
);
1093 goto out_unregister_pppoe_proto
;
1095 err
= pppoe_proc_init();
1097 goto out_unregister_pppox_proto
;
1099 dev_add_pack(&pppoes_ptype
);
1100 dev_add_pack(&pppoed_ptype
);
1101 register_netdevice_notifier(&pppoe_notifier
);
1104 out_unregister_pppox_proto
:
1105 unregister_pppox_proto(PX_PROTO_OE
);
1106 out_unregister_pppoe_proto
:
1107 proto_unregister(&pppoe_sk_proto
);
1111 static void __exit
pppoe_exit(void)
1113 unregister_pppox_proto(PX_PROTO_OE
);
1114 dev_remove_pack(&pppoes_ptype
);
1115 dev_remove_pack(&pppoed_ptype
);
1116 unregister_netdevice_notifier(&pppoe_notifier
);
1117 remove_proc_entry("pppoe", init_net
.proc_net
);
1118 proto_unregister(&pppoe_sk_proto
);
1121 module_init(pppoe_init
);
1122 module_exit(pppoe_exit
);
1124 MODULE_AUTHOR("Michal Ostrowski <mostrows@speakeasy.net>");
1125 MODULE_DESCRIPTION("PPP over Ethernet driver");
1126 MODULE_LICENSE("GPL");
1127 MODULE_ALIAS_NETPROTO(PF_PPPOX
);