1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*****************************************************************************
3 * Linux PPP over L2TP (PPPoX/PPPoL2TP) Sockets
5 * PPPoX --- Generic PPP encapsulation socket family
6 * PPPoL2TP --- PPP over L2TP (RFC 2661)
10 * Authors: James Chapman (jchapman@katalix.com)
12 * Based on original work by Martijn van Oosterhout <kleptog@svana.org>
17 /* This driver handles only L2TP data frames; control frames are handled by a
18 * userspace application.
20 * To send data in an L2TP session, userspace opens a PPPoL2TP socket and
21 * attaches it to a bound UDP socket with local tunnel_id / session_id and
22 * peer tunnel_id / session_id set. Data can then be sent or received using
23 * regular socket sendmsg() / recvmsg() calls. Kernel parameters of the socket
24 * can be read or modified using ioctl() or [gs]etsockopt() calls.
26 * When a PPPoL2TP socket is connected with local and peer session_id values
27 * zero, the socket is treated as a special tunnel management socket.
29 * Here's example userspace code to create a socket for sending/receiving data
30 * over an L2TP session:-
32 * struct sockaddr_pppol2tp sax;
36 * fd = socket(AF_PPPOX, SOCK_DGRAM, PX_PROTO_OL2TP);
38 * sax.sa_family = AF_PPPOX;
39 * sax.sa_protocol = PX_PROTO_OL2TP;
40 * sax.pppol2tp.fd = tunnel_fd; // bound UDP socket
41 * sax.pppol2tp.addr.sin_addr.s_addr = addr->sin_addr.s_addr;
42 * sax.pppol2tp.addr.sin_port = addr->sin_port;
43 * sax.pppol2tp.addr.sin_family = AF_INET;
44 * sax.pppol2tp.s_tunnel = tunnel_id;
45 * sax.pppol2tp.s_session = session_id;
46 * sax.pppol2tp.d_tunnel = peer_tunnel_id;
47 * sax.pppol2tp.d_session = peer_session_id;
49 * session_fd = connect(fd, (struct sockaddr *)&sax, sizeof(sax));
51 * A pppd plugin that allows PPP traffic to be carried over L2TP using
52 * this driver is available from the OpenL2TP project at
53 * http://openl2tp.sourceforge.net.
56 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
58 #include <linux/module.h>
59 #include <linux/string.h>
60 #include <linux/list.h>
61 #include <linux/uaccess.h>
63 #include <linux/kernel.h>
64 #include <linux/spinlock.h>
65 #include <linux/kthread.h>
66 #include <linux/sched.h>
67 #include <linux/slab.h>
68 #include <linux/errno.h>
69 #include <linux/jiffies.h>
71 #include <linux/netdevice.h>
72 #include <linux/net.h>
73 #include <linux/inetdevice.h>
74 #include <linux/skbuff.h>
75 #include <linux/init.h>
77 #include <linux/udp.h>
78 #include <linux/if_pppox.h>
79 #include <linux/if_pppol2tp.h>
81 #include <linux/ppp_channel.h>
82 #include <linux/ppp_defs.h>
83 #include <linux/ppp-ioctl.h>
84 #include <linux/file.h>
85 #include <linux/hash.h>
86 #include <linux/sort.h>
87 #include <linux/proc_fs.h>
88 #include <linux/l2tp.h>
89 #include <linux/nsproxy.h>
90 #include <net/net_namespace.h>
91 #include <net/netns/generic.h>
94 #include <net/inet_common.h>
96 #include <asm/byteorder.h>
97 #include <linux/atomic.h>
99 #include "l2tp_core.h"
101 #define PPPOL2TP_DRV_VERSION "V2.0"
103 /* Space for UDP, L2TP and PPP headers */
104 #define PPPOL2TP_HEADER_OVERHEAD 40
106 /* Number of bytes to build transmit L2TP headers.
107 * Unfortunately the size is different depending on whether sequence numbers
110 #define PPPOL2TP_L2TP_HDR_SIZE_SEQ 10
111 #define PPPOL2TP_L2TP_HDR_SIZE_NOSEQ 6
113 /* Private data of each session. This data lives at the end of struct
114 * l2tp_session, referenced via session->priv[].
116 struct pppol2tp_session
{
117 int owner
; /* pid that opened the socket */
119 struct mutex sk_lock
; /* Protects .sk */
120 struct sock __rcu
*sk
; /* Pointer to the session PPPoX socket */
121 struct sock
*__sk
; /* Copy of .sk, for cleanup */
122 struct rcu_head rcu
; /* For asynchronous release */
125 static int pppol2tp_xmit(struct ppp_channel
*chan
, struct sk_buff
*skb
);
127 static const struct ppp_channel_ops pppol2tp_chan_ops
= {
128 .start_xmit
= pppol2tp_xmit
,
131 static const struct proto_ops pppol2tp_ops
;
133 /* Retrieves the pppol2tp socket associated to a session.
134 * A reference is held on the returned socket, so this function must be paired
137 static struct sock
*pppol2tp_session_get_sock(struct l2tp_session
*session
)
139 struct pppol2tp_session
*ps
= l2tp_session_priv(session
);
143 sk
= rcu_dereference(ps
->sk
);
151 /* Helpers to obtain tunnel/session contexts from sockets.
153 static inline struct l2tp_session
*pppol2tp_sock_to_session(struct sock
*sk
)
155 struct l2tp_session
*session
;
161 session
= (struct l2tp_session
*)(sk
->sk_user_data
);
166 if (WARN_ON(session
->magic
!= L2TP_SESSION_MAGIC
)) {
176 /*****************************************************************************
177 * Receive data handling
178 *****************************************************************************/
180 /* Receive message. This is the recvmsg for the PPPoL2TP socket.
182 static int pppol2tp_recvmsg(struct socket
*sock
, struct msghdr
*msg
,
183 size_t len
, int flags
)
187 struct sock
*sk
= sock
->sk
;
190 if (sk
->sk_state
& PPPOX_BOUND
)
194 skb
= skb_recv_datagram(sk
, flags
, &err
);
200 else if (len
< skb
->len
)
201 msg
->msg_flags
|= MSG_TRUNC
;
203 err
= skb_copy_datagram_msg(skb
, 0, msg
, len
);
204 if (likely(err
== 0))
212 static void pppol2tp_recv(struct l2tp_session
*session
, struct sk_buff
*skb
, int data_len
)
214 struct pppol2tp_session
*ps
= l2tp_session_priv(session
);
215 struct sock
*sk
= NULL
;
217 /* If the socket is bound, send it in to PPP's input queue. Otherwise
218 * queue it on the session socket.
221 sk
= rcu_dereference(ps
->sk
);
225 /* If the first two bytes are 0xFF03, consider that it is the PPP's
226 * Address and Control fields and skip them. The L2TP module has always
227 * worked this way, although, in theory, the use of these fields should
228 * be negotiated and handled at the PPP layer. These fields are
229 * constant: 0xFF is the All-Stations Address and 0x03 the Unnumbered
230 * Information command with Poll/Final bit set to zero (RFC 1662).
232 if (pskb_may_pull(skb
, 2) && skb
->data
[0] == PPP_ALLSTATIONS
&&
233 skb
->data
[1] == PPP_UI
)
236 if (sk
->sk_state
& PPPOX_BOUND
) {
237 struct pppox_sock
*po
;
240 ppp_input(&po
->chan
, skb
);
242 if (sock_queue_rcv_skb(sk
, skb
) < 0) {
243 atomic_long_inc(&session
->stats
.rx_errors
);
253 pr_warn_ratelimited("%s: no socket in recv\n", session
->name
);
257 /************************************************************************
259 ***********************************************************************/
261 /* This is the sendmsg for the PPPoL2TP pppol2tp_session socket. We come here
262 * when a user application does a sendmsg() on the session socket. L2TP and
263 * PPP headers must be inserted into the user's data.
265 static int pppol2tp_sendmsg(struct socket
*sock
, struct msghdr
*m
,
268 struct sock
*sk
= sock
->sk
;
271 struct l2tp_session
*session
;
272 struct l2tp_tunnel
*tunnel
;
276 if (sock_flag(sk
, SOCK_DEAD
) || !(sk
->sk_state
& PPPOX_CONNECTED
))
279 /* Get session and tunnel contexts */
281 session
= pppol2tp_sock_to_session(sk
);
285 tunnel
= session
->tunnel
;
287 uhlen
= (tunnel
->encap
== L2TP_ENCAPTYPE_UDP
) ? sizeof(struct udphdr
) : 0;
289 /* Allocate a socket buffer */
291 skb
= sock_wmalloc(sk
, NET_SKB_PAD
+ sizeof(struct iphdr
) +
292 uhlen
+ session
->hdr_len
+
293 2 + total_len
, /* 2 bytes for PPP_ALLSTATIONS & PPP_UI */
298 /* Reserve space for headers. */
299 skb_reserve(skb
, NET_SKB_PAD
);
300 skb_reset_network_header(skb
);
301 skb_reserve(skb
, sizeof(struct iphdr
));
302 skb_reset_transport_header(skb
);
303 skb_reserve(skb
, uhlen
);
306 skb
->data
[0] = PPP_ALLSTATIONS
;
307 skb
->data
[1] = PPP_UI
;
310 /* Copy user data into skb */
311 error
= memcpy_from_msg(skb_put(skb
, total_len
), m
, total_len
);
318 l2tp_xmit_skb(session
, skb
);
331 /* Transmit function called by generic PPP driver. Sends PPP frame
332 * over PPPoL2TP socket.
334 * This is almost the same as pppol2tp_sendmsg(), but rather than
335 * being called with a msghdr from userspace, it is called with a skb
338 * The supplied skb from ppp doesn't have enough headroom for the
339 * insertion of L2TP, UDP and IP headers so we need to allocate more
340 * headroom in the skb. This will create a cloned skb. But we must be
341 * careful in the error case because the caller will expect to free
342 * the skb it supplied, not our cloned skb. So we take care to always
343 * leave the original skb unfreed if we return an error.
345 static int pppol2tp_xmit(struct ppp_channel
*chan
, struct sk_buff
*skb
)
347 struct sock
*sk
= (struct sock
*)chan
->private;
348 struct l2tp_session
*session
;
349 struct l2tp_tunnel
*tunnel
;
352 if (sock_flag(sk
, SOCK_DEAD
) || !(sk
->sk_state
& PPPOX_CONNECTED
))
355 /* Get session and tunnel contexts from the socket */
356 session
= pppol2tp_sock_to_session(sk
);
360 tunnel
= session
->tunnel
;
362 uhlen
= (tunnel
->encap
== L2TP_ENCAPTYPE_UDP
) ? sizeof(struct udphdr
) : 0;
363 headroom
= NET_SKB_PAD
+
364 sizeof(struct iphdr
) + /* IP header */
365 uhlen
+ /* UDP header (if L2TP_ENCAPTYPE_UDP) */
366 session
->hdr_len
+ /* L2TP header */
367 2; /* 2 bytes for PPP_ALLSTATIONS & PPP_UI */
368 if (skb_cow_head(skb
, headroom
))
371 /* Setup PPP header */
373 skb
->data
[0] = PPP_ALLSTATIONS
;
374 skb
->data
[1] = PPP_UI
;
377 l2tp_xmit_skb(session
, skb
);
387 /* Free the original skb */
392 /*****************************************************************************
393 * Session (and tunnel control) socket create/destroy.
394 *****************************************************************************/
396 static void pppol2tp_put_sk(struct rcu_head
*head
)
398 struct pppol2tp_session
*ps
;
400 ps
= container_of(head
, typeof(*ps
), rcu
);
404 /* Really kill the session socket. (Called from sock_put() if
407 static void pppol2tp_session_destruct(struct sock
*sk
)
409 struct l2tp_session
*session
= sk
->sk_user_data
;
411 skb_queue_purge(&sk
->sk_receive_queue
);
412 skb_queue_purge(&sk
->sk_write_queue
);
415 sk
->sk_user_data
= NULL
;
416 if (WARN_ON(session
->magic
!= L2TP_SESSION_MAGIC
))
418 l2tp_session_dec_refcount(session
);
422 /* Called when the PPPoX socket (session) is closed.
424 static int pppol2tp_release(struct socket
*sock
)
426 struct sock
*sk
= sock
->sk
;
427 struct l2tp_session
*session
;
435 if (sock_flag(sk
, SOCK_DEAD
) != 0)
438 pppox_unbind_sock(sk
);
440 /* Signal the death of the socket. */
441 sk
->sk_state
= PPPOX_DEAD
;
445 session
= pppol2tp_sock_to_session(sk
);
447 struct pppol2tp_session
*ps
;
449 l2tp_session_delete(session
);
451 ps
= l2tp_session_priv(session
);
452 mutex_lock(&ps
->sk_lock
);
453 ps
->__sk
= rcu_dereference_protected(ps
->sk
,
454 lockdep_is_held(&ps
->sk_lock
));
455 RCU_INIT_POINTER(ps
->sk
, NULL
);
456 mutex_unlock(&ps
->sk_lock
);
457 call_rcu(&ps
->rcu
, pppol2tp_put_sk
);
459 /* Rely on the sock_put() call at the end of the function for
460 * dropping the reference held by pppol2tp_sock_to_session().
461 * The last reference will be dropped by pppol2tp_put_sk().
467 /* This will delete the session context via
468 * pppol2tp_session_destruct() if the socket's refcnt drops to
480 static struct proto pppol2tp_sk_proto
= {
482 .owner
= THIS_MODULE
,
483 .obj_size
= sizeof(struct pppox_sock
),
486 static int pppol2tp_backlog_recv(struct sock
*sk
, struct sk_buff
*skb
)
490 rc
= l2tp_udp_encap_recv(sk
, skb
);
494 return NET_RX_SUCCESS
;
497 /* socket() handler. Initialize a new struct sock.
499 static int pppol2tp_create(struct net
*net
, struct socket
*sock
, int kern
)
504 sk
= sk_alloc(net
, PF_PPPOX
, GFP_KERNEL
, &pppol2tp_sk_proto
, kern
);
508 sock_init_data(sock
, sk
);
510 sock
->state
= SS_UNCONNECTED
;
511 sock
->ops
= &pppol2tp_ops
;
513 sk
->sk_backlog_rcv
= pppol2tp_backlog_recv
;
514 sk
->sk_protocol
= PX_PROTO_OL2TP
;
515 sk
->sk_family
= PF_PPPOX
;
516 sk
->sk_state
= PPPOX_NONE
;
517 sk
->sk_type
= SOCK_STREAM
;
518 sk
->sk_destruct
= pppol2tp_session_destruct
;
526 static void pppol2tp_show(struct seq_file
*m
, void *arg
)
528 struct l2tp_session
*session
= arg
;
531 sk
= pppol2tp_session_get_sock(session
);
533 struct pppox_sock
*po
= pppox_sk(sk
);
535 seq_printf(m
, " interface %s\n", ppp_dev_name(&po
->chan
));
540 static void pppol2tp_session_init(struct l2tp_session
*session
)
542 struct pppol2tp_session
*ps
;
544 session
->recv_skb
= pppol2tp_recv
;
545 if (IS_ENABLED(CONFIG_L2TP_DEBUGFS
))
546 session
->show
= pppol2tp_show
;
548 ps
= l2tp_session_priv(session
);
549 mutex_init(&ps
->sk_lock
);
550 ps
->owner
= current
->pid
;
553 struct l2tp_connect_info
{
562 static int pppol2tp_sockaddr_get_info(const void *sa
, int sa_len
,
563 struct l2tp_connect_info
*info
)
566 case sizeof(struct sockaddr_pppol2tp
):
568 const struct sockaddr_pppol2tp
*sa_v2in4
= sa
;
570 if (sa_v2in4
->sa_protocol
!= PX_PROTO_OL2TP
)
574 info
->fd
= sa_v2in4
->pppol2tp
.fd
;
575 info
->tunnel_id
= sa_v2in4
->pppol2tp
.s_tunnel
;
576 info
->peer_tunnel_id
= sa_v2in4
->pppol2tp
.d_tunnel
;
577 info
->session_id
= sa_v2in4
->pppol2tp
.s_session
;
578 info
->peer_session_id
= sa_v2in4
->pppol2tp
.d_session
;
582 case sizeof(struct sockaddr_pppol2tpv3
):
584 const struct sockaddr_pppol2tpv3
*sa_v3in4
= sa
;
586 if (sa_v3in4
->sa_protocol
!= PX_PROTO_OL2TP
)
590 info
->fd
= sa_v3in4
->pppol2tp
.fd
;
591 info
->tunnel_id
= sa_v3in4
->pppol2tp
.s_tunnel
;
592 info
->peer_tunnel_id
= sa_v3in4
->pppol2tp
.d_tunnel
;
593 info
->session_id
= sa_v3in4
->pppol2tp
.s_session
;
594 info
->peer_session_id
= sa_v3in4
->pppol2tp
.d_session
;
598 case sizeof(struct sockaddr_pppol2tpin6
):
600 const struct sockaddr_pppol2tpin6
*sa_v2in6
= sa
;
602 if (sa_v2in6
->sa_protocol
!= PX_PROTO_OL2TP
)
606 info
->fd
= sa_v2in6
->pppol2tp
.fd
;
607 info
->tunnel_id
= sa_v2in6
->pppol2tp
.s_tunnel
;
608 info
->peer_tunnel_id
= sa_v2in6
->pppol2tp
.d_tunnel
;
609 info
->session_id
= sa_v2in6
->pppol2tp
.s_session
;
610 info
->peer_session_id
= sa_v2in6
->pppol2tp
.d_session
;
614 case sizeof(struct sockaddr_pppol2tpv3in6
):
616 const struct sockaddr_pppol2tpv3in6
*sa_v3in6
= sa
;
618 if (sa_v3in6
->sa_protocol
!= PX_PROTO_OL2TP
)
622 info
->fd
= sa_v3in6
->pppol2tp
.fd
;
623 info
->tunnel_id
= sa_v3in6
->pppol2tp
.s_tunnel
;
624 info
->peer_tunnel_id
= sa_v3in6
->pppol2tp
.d_tunnel
;
625 info
->session_id
= sa_v3in6
->pppol2tp
.s_session
;
626 info
->peer_session_id
= sa_v3in6
->pppol2tp
.d_session
;
637 /* Rough estimation of the maximum payload size a tunnel can transmit without
638 * fragmenting at the lower IP layer. Assumes L2TPv2 with sequence
639 * numbers and no IP option. Not quite accurate, but the result is mostly
642 static int pppol2tp_tunnel_mtu(const struct l2tp_tunnel
*tunnel
)
646 mtu
= l2tp_tunnel_dst_mtu(tunnel
);
647 if (mtu
<= PPPOL2TP_HEADER_OVERHEAD
)
648 return 1500 - PPPOL2TP_HEADER_OVERHEAD
;
650 return mtu
- PPPOL2TP_HEADER_OVERHEAD
;
653 static struct l2tp_tunnel
*pppol2tp_tunnel_get(struct net
*net
,
654 const struct l2tp_connect_info
*info
,
657 struct l2tp_tunnel
*tunnel
;
662 tunnel
= l2tp_tunnel_get(net
, info
->tunnel_id
);
664 /* Special case: create tunnel context if session_id and
665 * peer_session_id is 0. Otherwise look up tunnel using supplied
668 if (!info
->session_id
&& !info
->peer_session_id
) {
670 struct l2tp_tunnel_cfg tcfg
= {
671 .encap
= L2TP_ENCAPTYPE_UDP
,
674 /* Prevent l2tp_tunnel_register() from trying to set up
678 return ERR_PTR(-EBADF
);
680 error
= l2tp_tunnel_create(info
->fd
,
683 info
->peer_tunnel_id
, &tcfg
,
686 return ERR_PTR(error
);
688 l2tp_tunnel_inc_refcount(tunnel
);
689 error
= l2tp_tunnel_register(tunnel
, net
, &tcfg
);
692 return ERR_PTR(error
);
698 /* Error if we can't find the tunnel */
700 return ERR_PTR(-ENOENT
);
702 /* Error if socket is not prepped */
704 l2tp_tunnel_dec_refcount(tunnel
);
705 return ERR_PTR(-ENOENT
);
712 /* connect() handler. Attach a PPPoX socket to a tunnel UDP socket
714 static int pppol2tp_connect(struct socket
*sock
, struct sockaddr
*uservaddr
,
715 int sockaddr_len
, int flags
)
717 struct sock
*sk
= sock
->sk
;
718 struct pppox_sock
*po
= pppox_sk(sk
);
719 struct l2tp_session
*session
= NULL
;
720 struct l2tp_connect_info info
;
721 struct l2tp_tunnel
*tunnel
;
722 struct pppol2tp_session
*ps
;
723 struct l2tp_session_cfg cfg
= { 0, };
724 bool drop_refcnt
= false;
725 bool new_session
= false;
726 bool new_tunnel
= false;
729 error
= pppol2tp_sockaddr_get_info(uservaddr
, sockaddr_len
, &info
);
733 /* Don't bind if tunnel_id is 0 */
737 tunnel
= pppol2tp_tunnel_get(sock_net(sk
), &info
, &new_tunnel
);
739 return PTR_ERR(tunnel
);
743 /* Check for already bound sockets */
745 if (sk
->sk_state
& PPPOX_CONNECTED
)
748 /* We don't supporting rebinding anyway */
750 if (sk
->sk_user_data
)
751 goto end
; /* socket is already attached */
753 if (tunnel
->peer_tunnel_id
== 0)
754 tunnel
->peer_tunnel_id
= info
.peer_tunnel_id
;
756 session
= l2tp_tunnel_get_session(tunnel
, info
.session_id
);
760 if (session
->pwtype
!= L2TP_PWTYPE_PPP
) {
765 ps
= l2tp_session_priv(session
);
767 /* Using a pre-existing session is fine as long as it hasn't
768 * been connected yet.
770 mutex_lock(&ps
->sk_lock
);
771 if (rcu_dereference_protected(ps
->sk
,
772 lockdep_is_held(&ps
->sk_lock
)) ||
774 mutex_unlock(&ps
->sk_lock
);
779 cfg
.pw_type
= L2TP_PWTYPE_PPP
;
781 session
= l2tp_session_create(sizeof(struct pppol2tp_session
),
782 tunnel
, info
.session_id
,
783 info
.peer_session_id
, &cfg
);
784 if (IS_ERR(session
)) {
785 error
= PTR_ERR(session
);
789 pppol2tp_session_init(session
);
790 ps
= l2tp_session_priv(session
);
791 l2tp_session_inc_refcount(session
);
793 mutex_lock(&ps
->sk_lock
);
794 error
= l2tp_session_register(session
, tunnel
);
796 mutex_unlock(&ps
->sk_lock
);
804 /* Special case: if source & dest session_id == 0x0000, this
805 * socket is being created to manage the tunnel. Just set up
806 * the internal context for use by ioctl() and sockopt()
809 if (session
->session_id
== 0 && session
->peer_session_id
== 0) {
814 /* The only header we need to worry about is the L2TP
815 * header. This size is different depending on whether
816 * sequence numbers are enabled for the data channel.
818 po
->chan
.hdrlen
= PPPOL2TP_L2TP_HDR_SIZE_NOSEQ
;
820 po
->chan
.private = sk
;
821 po
->chan
.ops
= &pppol2tp_chan_ops
;
822 po
->chan
.mtu
= pppol2tp_tunnel_mtu(tunnel
);
824 error
= ppp_register_net_channel(sock_net(sk
), &po
->chan
);
826 mutex_unlock(&ps
->sk_lock
);
831 /* This is how we get the session context from the socket. */
832 sk
->sk_user_data
= session
;
833 rcu_assign_pointer(ps
->sk
, sk
);
834 mutex_unlock(&ps
->sk_lock
);
836 /* Keep the reference we've grabbed on the session: sk doesn't expect
837 * the session to disappear. pppol2tp_session_destruct() is responsible
842 sk
->sk_state
= PPPOX_CONNECTED
;
847 l2tp_session_delete(session
);
849 l2tp_tunnel_delete(tunnel
);
852 l2tp_session_dec_refcount(session
);
853 l2tp_tunnel_dec_refcount(tunnel
);
859 #ifdef CONFIG_L2TP_V3
861 /* Called when creating sessions via the netlink interface. */
862 static int pppol2tp_session_create(struct net
*net
, struct l2tp_tunnel
*tunnel
,
863 u32 session_id
, u32 peer_session_id
,
864 struct l2tp_session_cfg
*cfg
)
867 struct l2tp_session
*session
;
869 /* Error if tunnel socket is not prepped */
875 /* Allocate and initialize a new session context. */
876 session
= l2tp_session_create(sizeof(struct pppol2tp_session
),
878 peer_session_id
, cfg
);
879 if (IS_ERR(session
)) {
880 error
= PTR_ERR(session
);
884 pppol2tp_session_init(session
);
886 error
= l2tp_session_register(session
, tunnel
);
898 #endif /* CONFIG_L2TP_V3 */
900 /* getname() support.
902 static int pppol2tp_getname(struct socket
*sock
, struct sockaddr
*uaddr
,
907 struct l2tp_session
*session
;
908 struct l2tp_tunnel
*tunnel
;
909 struct sock
*sk
= sock
->sk
;
910 struct inet_sock
*inet
;
911 struct pppol2tp_session
*pls
;
916 if (!(sk
->sk_state
& PPPOX_CONNECTED
))
920 session
= pppol2tp_sock_to_session(sk
);
924 pls
= l2tp_session_priv(session
);
925 tunnel
= session
->tunnel
;
927 inet
= inet_sk(tunnel
->sock
);
928 if (tunnel
->version
== 2 && tunnel
->sock
->sk_family
== AF_INET
) {
929 struct sockaddr_pppol2tp sp
;
933 sp
.sa_family
= AF_PPPOX
;
934 sp
.sa_protocol
= PX_PROTO_OL2TP
;
935 sp
.pppol2tp
.fd
= tunnel
->fd
;
936 sp
.pppol2tp
.pid
= pls
->owner
;
937 sp
.pppol2tp
.s_tunnel
= tunnel
->tunnel_id
;
938 sp
.pppol2tp
.d_tunnel
= tunnel
->peer_tunnel_id
;
939 sp
.pppol2tp
.s_session
= session
->session_id
;
940 sp
.pppol2tp
.d_session
= session
->peer_session_id
;
941 sp
.pppol2tp
.addr
.sin_family
= AF_INET
;
942 sp
.pppol2tp
.addr
.sin_port
= inet
->inet_dport
;
943 sp
.pppol2tp
.addr
.sin_addr
.s_addr
= inet
->inet_daddr
;
944 memcpy(uaddr
, &sp
, len
);
945 #if IS_ENABLED(CONFIG_IPV6)
946 } else if (tunnel
->version
== 2 && tunnel
->sock
->sk_family
== AF_INET6
) {
947 struct sockaddr_pppol2tpin6 sp
;
951 sp
.sa_family
= AF_PPPOX
;
952 sp
.sa_protocol
= PX_PROTO_OL2TP
;
953 sp
.pppol2tp
.fd
= tunnel
->fd
;
954 sp
.pppol2tp
.pid
= pls
->owner
;
955 sp
.pppol2tp
.s_tunnel
= tunnel
->tunnel_id
;
956 sp
.pppol2tp
.d_tunnel
= tunnel
->peer_tunnel_id
;
957 sp
.pppol2tp
.s_session
= session
->session_id
;
958 sp
.pppol2tp
.d_session
= session
->peer_session_id
;
959 sp
.pppol2tp
.addr
.sin6_family
= AF_INET6
;
960 sp
.pppol2tp
.addr
.sin6_port
= inet
->inet_dport
;
961 memcpy(&sp
.pppol2tp
.addr
.sin6_addr
, &tunnel
->sock
->sk_v6_daddr
,
962 sizeof(tunnel
->sock
->sk_v6_daddr
));
963 memcpy(uaddr
, &sp
, len
);
964 } else if (tunnel
->version
== 3 && tunnel
->sock
->sk_family
== AF_INET6
) {
965 struct sockaddr_pppol2tpv3in6 sp
;
969 sp
.sa_family
= AF_PPPOX
;
970 sp
.sa_protocol
= PX_PROTO_OL2TP
;
971 sp
.pppol2tp
.fd
= tunnel
->fd
;
972 sp
.pppol2tp
.pid
= pls
->owner
;
973 sp
.pppol2tp
.s_tunnel
= tunnel
->tunnel_id
;
974 sp
.pppol2tp
.d_tunnel
= tunnel
->peer_tunnel_id
;
975 sp
.pppol2tp
.s_session
= session
->session_id
;
976 sp
.pppol2tp
.d_session
= session
->peer_session_id
;
977 sp
.pppol2tp
.addr
.sin6_family
= AF_INET6
;
978 sp
.pppol2tp
.addr
.sin6_port
= inet
->inet_dport
;
979 memcpy(&sp
.pppol2tp
.addr
.sin6_addr
, &tunnel
->sock
->sk_v6_daddr
,
980 sizeof(tunnel
->sock
->sk_v6_daddr
));
981 memcpy(uaddr
, &sp
, len
);
983 } else if (tunnel
->version
== 3) {
984 struct sockaddr_pppol2tpv3 sp
;
988 sp
.sa_family
= AF_PPPOX
;
989 sp
.sa_protocol
= PX_PROTO_OL2TP
;
990 sp
.pppol2tp
.fd
= tunnel
->fd
;
991 sp
.pppol2tp
.pid
= pls
->owner
;
992 sp
.pppol2tp
.s_tunnel
= tunnel
->tunnel_id
;
993 sp
.pppol2tp
.d_tunnel
= tunnel
->peer_tunnel_id
;
994 sp
.pppol2tp
.s_session
= session
->session_id
;
995 sp
.pppol2tp
.d_session
= session
->peer_session_id
;
996 sp
.pppol2tp
.addr
.sin_family
= AF_INET
;
997 sp
.pppol2tp
.addr
.sin_port
= inet
->inet_dport
;
998 sp
.pppol2tp
.addr
.sin_addr
.s_addr
= inet
->inet_daddr
;
999 memcpy(uaddr
, &sp
, len
);
1009 /****************************************************************************
1012 * The PPPoX socket is created for L2TP sessions: tunnels have their own UDP
1013 * sockets. However, in order to control kernel tunnel features, we allow
1014 * userspace to create a special "tunnel" PPPoX socket which is used for
1015 * control only. Tunnel PPPoX sockets have session_id == 0 and simply allow
1016 * the user application to issue L2TP setsockopt(), getsockopt() and ioctl()
1018 ****************************************************************************/
1020 static void pppol2tp_copy_stats(struct pppol2tp_ioc_stats
*dest
,
1021 const struct l2tp_stats
*stats
)
1023 memset(dest
, 0, sizeof(*dest
));
1025 dest
->tx_packets
= atomic_long_read(&stats
->tx_packets
);
1026 dest
->tx_bytes
= atomic_long_read(&stats
->tx_bytes
);
1027 dest
->tx_errors
= atomic_long_read(&stats
->tx_errors
);
1028 dest
->rx_packets
= atomic_long_read(&stats
->rx_packets
);
1029 dest
->rx_bytes
= atomic_long_read(&stats
->rx_bytes
);
1030 dest
->rx_seq_discards
= atomic_long_read(&stats
->rx_seq_discards
);
1031 dest
->rx_oos_packets
= atomic_long_read(&stats
->rx_oos_packets
);
1032 dest
->rx_errors
= atomic_long_read(&stats
->rx_errors
);
1035 static int pppol2tp_tunnel_copy_stats(struct pppol2tp_ioc_stats
*stats
,
1036 struct l2tp_tunnel
*tunnel
)
1038 struct l2tp_session
*session
;
1040 if (!stats
->session_id
) {
1041 pppol2tp_copy_stats(stats
, &tunnel
->stats
);
1045 /* If session_id is set, search the corresponding session in the
1046 * context of this tunnel and record the session's statistics.
1048 session
= l2tp_tunnel_get_session(tunnel
, stats
->session_id
);
1052 if (session
->pwtype
!= L2TP_PWTYPE_PPP
) {
1053 l2tp_session_dec_refcount(session
);
1057 pppol2tp_copy_stats(stats
, &session
->stats
);
1058 l2tp_session_dec_refcount(session
);
1063 static int pppol2tp_ioctl(struct socket
*sock
, unsigned int cmd
,
1066 struct pppol2tp_ioc_stats stats
;
1067 struct l2tp_session
*session
;
1072 session
= sock
->sk
->sk_user_data
;
1076 if (WARN_ON(session
->magic
!= L2TP_SESSION_MAGIC
))
1079 /* Not defined for tunnels */
1080 if (!session
->session_id
&& !session
->peer_session_id
)
1083 if (put_user(0, (int __user
*)arg
))
1089 session
= sock
->sk
->sk_user_data
;
1093 if (WARN_ON(session
->magic
!= L2TP_SESSION_MAGIC
))
1096 /* Not defined for tunnels */
1097 if (!session
->session_id
&& !session
->peer_session_id
)
1100 if (!access_ok((int __user
*)arg
, sizeof(int)))
1104 case PPPIOCGL2TPSTATS
:
1105 session
= sock
->sk
->sk_user_data
;
1109 if (WARN_ON(session
->magic
!= L2TP_SESSION_MAGIC
))
1112 /* Session 0 represents the parent tunnel */
1113 if (!session
->session_id
&& !session
->peer_session_id
) {
1117 if (copy_from_user(&stats
, (void __user
*)arg
,
1121 session_id
= stats
.session_id
;
1122 err
= pppol2tp_tunnel_copy_stats(&stats
,
1127 stats
.session_id
= session_id
;
1129 pppol2tp_copy_stats(&stats
, &session
->stats
);
1130 stats
.session_id
= session
->session_id
;
1132 stats
.tunnel_id
= session
->tunnel
->tunnel_id
;
1133 stats
.using_ipsec
= l2tp_tunnel_uses_xfrm(session
->tunnel
);
1135 if (copy_to_user((void __user
*)arg
, &stats
, sizeof(stats
)))
1140 return -ENOIOCTLCMD
;
1146 /*****************************************************************************
1147 * setsockopt() / getsockopt() support.
1149 * The PPPoX socket is created for L2TP sessions: tunnels have their own UDP
1150 * sockets. In order to control kernel tunnel features, we allow userspace to
1151 * create a special "tunnel" PPPoX socket which is used for control only.
1152 * Tunnel PPPoX sockets have session_id == 0 and simply allow the user
1153 * application to issue L2TP setsockopt(), getsockopt() and ioctl() calls.
1154 *****************************************************************************/
1156 /* Tunnel setsockopt() helper.
1158 static int pppol2tp_tunnel_setsockopt(struct sock
*sk
,
1159 struct l2tp_tunnel
*tunnel
,
1160 int optname
, int val
)
1165 case PPPOL2TP_SO_DEBUG
:
1166 /* Tunnel debug flags option is deprecated */
1177 /* Session setsockopt helper.
1179 static int pppol2tp_session_setsockopt(struct sock
*sk
,
1180 struct l2tp_session
*session
,
1181 int optname
, int val
)
1186 case PPPOL2TP_SO_RECVSEQ
:
1187 if (val
!= 0 && val
!= 1) {
1191 session
->recv_seq
= !!val
;
1194 case PPPOL2TP_SO_SENDSEQ
:
1195 if (val
!= 0 && val
!= 1) {
1199 session
->send_seq
= !!val
;
1201 struct pppox_sock
*po
= pppox_sk(sk
);
1203 po
->chan
.hdrlen
= val
? PPPOL2TP_L2TP_HDR_SIZE_SEQ
:
1204 PPPOL2TP_L2TP_HDR_SIZE_NOSEQ
;
1206 l2tp_session_set_header_len(session
, session
->tunnel
->version
);
1209 case PPPOL2TP_SO_LNSMODE
:
1210 if (val
!= 0 && val
!= 1) {
1214 session
->lns_mode
= !!val
;
1217 case PPPOL2TP_SO_DEBUG
:
1218 /* Session debug flags option is deprecated */
1221 case PPPOL2TP_SO_REORDERTO
:
1222 session
->reorder_timeout
= msecs_to_jiffies(val
);
1233 /* Main setsockopt() entry point.
1234 * Does API checks, then calls either the tunnel or session setsockopt
1235 * handler, according to whether the PPPoL2TP socket is a for a regular
1236 * session or the special tunnel type.
1238 static int pppol2tp_setsockopt(struct socket
*sock
, int level
, int optname
,
1239 sockptr_t optval
, unsigned int optlen
)
1241 struct sock
*sk
= sock
->sk
;
1242 struct l2tp_session
*session
;
1243 struct l2tp_tunnel
*tunnel
;
1247 if (level
!= SOL_PPPOL2TP
)
1250 if (optlen
< sizeof(int))
1253 if (copy_from_sockptr(&val
, optval
, sizeof(int)))
1257 if (!sk
->sk_user_data
)
1260 /* Get session context from the socket */
1262 session
= pppol2tp_sock_to_session(sk
);
1266 /* Special case: if session_id == 0x0000, treat as operation on tunnel
1268 if (session
->session_id
== 0 && session
->peer_session_id
== 0) {
1269 tunnel
= session
->tunnel
;
1270 err
= pppol2tp_tunnel_setsockopt(sk
, tunnel
, optname
, val
);
1272 err
= pppol2tp_session_setsockopt(sk
, session
, optname
, val
);
1280 /* Tunnel getsockopt helper. Called with sock locked.
1282 static int pppol2tp_tunnel_getsockopt(struct sock
*sk
,
1283 struct l2tp_tunnel
*tunnel
,
1284 int optname
, int *val
)
1289 case PPPOL2TP_SO_DEBUG
:
1290 /* Tunnel debug flags option is deprecated */
1302 /* Session getsockopt helper. Called with sock locked.
1304 static int pppol2tp_session_getsockopt(struct sock
*sk
,
1305 struct l2tp_session
*session
,
1306 int optname
, int *val
)
1311 case PPPOL2TP_SO_RECVSEQ
:
1312 *val
= session
->recv_seq
;
1315 case PPPOL2TP_SO_SENDSEQ
:
1316 *val
= session
->send_seq
;
1319 case PPPOL2TP_SO_LNSMODE
:
1320 *val
= session
->lns_mode
;
1323 case PPPOL2TP_SO_DEBUG
:
1324 /* Session debug flags option is deprecated */
1328 case PPPOL2TP_SO_REORDERTO
:
1329 *val
= (int)jiffies_to_msecs(session
->reorder_timeout
);
1339 /* Main getsockopt() entry point.
1340 * Does API checks, then calls either the tunnel or session getsockopt
1341 * handler, according to whether the PPPoX socket is a for a regular session
1342 * or the special tunnel type.
1344 static int pppol2tp_getsockopt(struct socket
*sock
, int level
, int optname
,
1345 char __user
*optval
, int __user
*optlen
)
1347 struct sock
*sk
= sock
->sk
;
1348 struct l2tp_session
*session
;
1349 struct l2tp_tunnel
*tunnel
;
1353 if (level
!= SOL_PPPOL2TP
)
1356 if (get_user(len
, optlen
))
1359 len
= min_t(unsigned int, len
, sizeof(int));
1365 if (!sk
->sk_user_data
)
1368 /* Get the session context */
1370 session
= pppol2tp_sock_to_session(sk
);
1374 /* Special case: if session_id == 0x0000, treat as operation on tunnel */
1375 if (session
->session_id
== 0 && session
->peer_session_id
== 0) {
1376 tunnel
= session
->tunnel
;
1377 err
= pppol2tp_tunnel_getsockopt(sk
, tunnel
, optname
, &val
);
1381 err
= pppol2tp_session_getsockopt(sk
, session
, optname
, &val
);
1387 if (put_user(len
, optlen
))
1390 if (copy_to_user((void __user
*)optval
, &val
, len
))
1401 /*****************************************************************************
1402 * /proc filesystem for debug
1403 * Since the original pppol2tp driver provided /proc/net/pppol2tp for
1404 * L2TPv2, we dump only L2TPv2 tunnels and sessions here.
1405 *****************************************************************************/
1407 static unsigned int pppol2tp_net_id
;
1409 #ifdef CONFIG_PROC_FS
1411 struct pppol2tp_seq_data
{
1412 struct seq_net_private p
;
1413 int tunnel_idx
; /* current tunnel */
1414 int session_idx
; /* index of session within current tunnel */
1415 struct l2tp_tunnel
*tunnel
;
1416 struct l2tp_session
*session
; /* NULL means get next tunnel */
1419 static void pppol2tp_next_tunnel(struct net
*net
, struct pppol2tp_seq_data
*pd
)
1421 /* Drop reference taken during previous invocation */
1423 l2tp_tunnel_dec_refcount(pd
->tunnel
);
1426 pd
->tunnel
= l2tp_tunnel_get_nth(net
, pd
->tunnel_idx
);
1429 /* Only accept L2TPv2 tunnels */
1430 if (!pd
->tunnel
|| pd
->tunnel
->version
== 2)
1433 l2tp_tunnel_dec_refcount(pd
->tunnel
);
1437 static void pppol2tp_next_session(struct net
*net
, struct pppol2tp_seq_data
*pd
)
1439 /* Drop reference taken during previous invocation */
1441 l2tp_session_dec_refcount(pd
->session
);
1443 pd
->session
= l2tp_session_get_nth(pd
->tunnel
, pd
->session_idx
);
1447 pd
->session_idx
= 0;
1448 pppol2tp_next_tunnel(net
, pd
);
1452 static void *pppol2tp_seq_start(struct seq_file
*m
, loff_t
*offs
)
1454 struct pppol2tp_seq_data
*pd
= SEQ_START_TOKEN
;
1461 if (WARN_ON(!m
->private)) {
1467 net
= seq_file_net(m
);
1470 pppol2tp_next_tunnel(net
, pd
);
1472 pppol2tp_next_session(net
, pd
);
1474 /* NULL tunnel and session indicates end of list */
1475 if (!pd
->tunnel
&& !pd
->session
)
1482 static void *pppol2tp_seq_next(struct seq_file
*m
, void *v
, loff_t
*pos
)
1488 static void pppol2tp_seq_stop(struct seq_file
*p
, void *v
)
1490 struct pppol2tp_seq_data
*pd
= v
;
1492 if (!pd
|| pd
== SEQ_START_TOKEN
)
1495 /* Drop reference taken by last invocation of pppol2tp_next_session()
1496 * or pppol2tp_next_tunnel().
1499 l2tp_session_dec_refcount(pd
->session
);
1503 l2tp_tunnel_dec_refcount(pd
->tunnel
);
1508 static void pppol2tp_seq_tunnel_show(struct seq_file
*m
, void *v
)
1510 struct l2tp_tunnel
*tunnel
= v
;
1512 seq_printf(m
, "\nTUNNEL '%s', %c %d\n",
1514 (tunnel
== tunnel
->sock
->sk_user_data
) ? 'Y' : 'N',
1515 refcount_read(&tunnel
->ref_count
) - 1);
1516 seq_printf(m
, " %08x %ld/%ld/%ld %ld/%ld/%ld\n",
1518 atomic_long_read(&tunnel
->stats
.tx_packets
),
1519 atomic_long_read(&tunnel
->stats
.tx_bytes
),
1520 atomic_long_read(&tunnel
->stats
.tx_errors
),
1521 atomic_long_read(&tunnel
->stats
.rx_packets
),
1522 atomic_long_read(&tunnel
->stats
.rx_bytes
),
1523 atomic_long_read(&tunnel
->stats
.rx_errors
));
1526 static void pppol2tp_seq_session_show(struct seq_file
*m
, void *v
)
1528 struct l2tp_session
*session
= v
;
1529 struct l2tp_tunnel
*tunnel
= session
->tunnel
;
1530 unsigned char state
;
1537 struct inet_sock
*inet
= inet_sk(tunnel
->sock
);
1539 ip
= ntohl(inet
->inet_saddr
);
1540 port
= ntohs(inet
->inet_sport
);
1543 sk
= pppol2tp_session_get_sock(session
);
1545 state
= sk
->sk_state
;
1546 user_data_ok
= (session
== sk
->sk_user_data
) ? 'Y' : 'N';
1552 seq_printf(m
, " SESSION '%s' %08X/%d %04X/%04X -> %04X/%04X %d %c\n",
1553 session
->name
, ip
, port
,
1555 session
->session_id
,
1556 tunnel
->peer_tunnel_id
,
1557 session
->peer_session_id
,
1558 state
, user_data_ok
);
1559 seq_printf(m
, " 0/0/%c/%c/%s %08x %u\n",
1560 session
->recv_seq
? 'R' : '-',
1561 session
->send_seq
? 'S' : '-',
1562 session
->lns_mode
? "LNS" : "LAC",
1564 jiffies_to_msecs(session
->reorder_timeout
));
1565 seq_printf(m
, " %u/%u %ld/%ld/%ld %ld/%ld/%ld\n",
1566 session
->nr
, session
->ns
,
1567 atomic_long_read(&session
->stats
.tx_packets
),
1568 atomic_long_read(&session
->stats
.tx_bytes
),
1569 atomic_long_read(&session
->stats
.tx_errors
),
1570 atomic_long_read(&session
->stats
.rx_packets
),
1571 atomic_long_read(&session
->stats
.rx_bytes
),
1572 atomic_long_read(&session
->stats
.rx_errors
));
1575 struct pppox_sock
*po
= pppox_sk(sk
);
1577 seq_printf(m
, " interface %s\n", ppp_dev_name(&po
->chan
));
1582 static int pppol2tp_seq_show(struct seq_file
*m
, void *v
)
1584 struct pppol2tp_seq_data
*pd
= v
;
1586 /* display header on line 1 */
1587 if (v
== SEQ_START_TOKEN
) {
1588 seq_puts(m
, "PPPoL2TP driver info, " PPPOL2TP_DRV_VERSION
"\n");
1589 seq_puts(m
, "TUNNEL name, user-data-ok session-count\n");
1590 seq_puts(m
, " debug tx-pkts/bytes/errs rx-pkts/bytes/errs\n");
1591 seq_puts(m
, " SESSION name, addr/port src-tid/sid dest-tid/sid state user-data-ok\n");
1592 seq_puts(m
, " mtu/mru/rcvseq/sendseq/lns debug reorderto\n");
1593 seq_puts(m
, " nr/ns tx-pkts/bytes/errs rx-pkts/bytes/errs\n");
1598 pppol2tp_seq_tunnel_show(m
, pd
->tunnel
);
1600 pppol2tp_seq_session_show(m
, pd
->session
);
1606 static const struct seq_operations pppol2tp_seq_ops
= {
1607 .start
= pppol2tp_seq_start
,
1608 .next
= pppol2tp_seq_next
,
1609 .stop
= pppol2tp_seq_stop
,
1610 .show
= pppol2tp_seq_show
,
1612 #endif /* CONFIG_PROC_FS */
1614 /*****************************************************************************
1616 *****************************************************************************/
1618 static __net_init
int pppol2tp_init_net(struct net
*net
)
1620 struct proc_dir_entry
*pde
;
1623 pde
= proc_create_net("pppol2tp", 0444, net
->proc_net
,
1624 &pppol2tp_seq_ops
, sizeof(struct pppol2tp_seq_data
));
1634 static __net_exit
void pppol2tp_exit_net(struct net
*net
)
1636 remove_proc_entry("pppol2tp", net
->proc_net
);
1639 static struct pernet_operations pppol2tp_net_ops
= {
1640 .init
= pppol2tp_init_net
,
1641 .exit
= pppol2tp_exit_net
,
1642 .id
= &pppol2tp_net_id
,
1645 /*****************************************************************************
1647 *****************************************************************************/
1649 static const struct proto_ops pppol2tp_ops
= {
1651 .owner
= THIS_MODULE
,
1652 .release
= pppol2tp_release
,
1653 .bind
= sock_no_bind
,
1654 .connect
= pppol2tp_connect
,
1655 .socketpair
= sock_no_socketpair
,
1656 .accept
= sock_no_accept
,
1657 .getname
= pppol2tp_getname
,
1658 .poll
= datagram_poll
,
1659 .listen
= sock_no_listen
,
1660 .shutdown
= sock_no_shutdown
,
1661 .setsockopt
= pppol2tp_setsockopt
,
1662 .getsockopt
= pppol2tp_getsockopt
,
1663 .sendmsg
= pppol2tp_sendmsg
,
1664 .recvmsg
= pppol2tp_recvmsg
,
1665 .mmap
= sock_no_mmap
,
1666 .ioctl
= pppox_ioctl
,
1667 #ifdef CONFIG_COMPAT
1668 .compat_ioctl
= pppox_compat_ioctl
,
1672 static const struct pppox_proto pppol2tp_proto
= {
1673 .create
= pppol2tp_create
,
1674 .ioctl
= pppol2tp_ioctl
,
1675 .owner
= THIS_MODULE
,
1678 #ifdef CONFIG_L2TP_V3
1680 static const struct l2tp_nl_cmd_ops pppol2tp_nl_cmd_ops
= {
1681 .session_create
= pppol2tp_session_create
,
1682 .session_delete
= l2tp_session_delete
,
1685 #endif /* CONFIG_L2TP_V3 */
1687 static int __init
pppol2tp_init(void)
1691 err
= register_pernet_device(&pppol2tp_net_ops
);
1695 err
= proto_register(&pppol2tp_sk_proto
, 0);
1697 goto out_unregister_pppol2tp_pernet
;
1699 err
= register_pppox_proto(PX_PROTO_OL2TP
, &pppol2tp_proto
);
1701 goto out_unregister_pppol2tp_proto
;
1703 #ifdef CONFIG_L2TP_V3
1704 err
= l2tp_nl_register_ops(L2TP_PWTYPE_PPP
, &pppol2tp_nl_cmd_ops
);
1706 goto out_unregister_pppox
;
1709 pr_info("PPPoL2TP kernel driver, %s\n", PPPOL2TP_DRV_VERSION
);
1714 #ifdef CONFIG_L2TP_V3
1715 out_unregister_pppox
:
1716 unregister_pppox_proto(PX_PROTO_OL2TP
);
1718 out_unregister_pppol2tp_proto
:
1719 proto_unregister(&pppol2tp_sk_proto
);
1720 out_unregister_pppol2tp_pernet
:
1721 unregister_pernet_device(&pppol2tp_net_ops
);
1725 static void __exit
pppol2tp_exit(void)
1727 #ifdef CONFIG_L2TP_V3
1728 l2tp_nl_unregister_ops(L2TP_PWTYPE_PPP
);
1730 unregister_pppox_proto(PX_PROTO_OL2TP
);
1731 proto_unregister(&pppol2tp_sk_proto
);
1732 unregister_pernet_device(&pppol2tp_net_ops
);
1735 module_init(pppol2tp_init
);
1736 module_exit(pppol2tp_exit
);
1738 MODULE_AUTHOR("James Chapman <jchapman@katalix.com>");
1739 MODULE_DESCRIPTION("PPP over L2TP over UDP");
1740 MODULE_LICENSE("GPL");
1741 MODULE_VERSION(PPPOL2TP_DRV_VERSION
);
1742 MODULE_ALIAS_NET_PF_PROTO(PF_PPPOX
, PX_PROTO_OL2TP
);
1743 MODULE_ALIAS_L2TP_PWTYPE(7);