l2tp: prevent pppol2tp_connect() from creating kernel sockets
[muen/linux.git] / net / l2tp / l2tp_ppp.c
1 /*****************************************************************************
2  * Linux PPP over L2TP (PPPoX/PPPoL2TP) Sockets
3  *
4  * PPPoX    --- Generic PPP encapsulation socket family
5  * PPPoL2TP --- PPP over L2TP (RFC 2661)
6  *
7  * Version:     2.0.0
8  *
9  * Authors:     James Chapman (jchapman@katalix.com)
10  *
11  * Based on original work by Martijn van Oosterhout <kleptog@svana.org>
12  *
13  * License:
14  *              This program is free software; you can redistribute it and/or
15  *              modify it under the terms of the GNU General Public License
16  *              as published by the Free Software Foundation; either version
17  *              2 of the License, or (at your option) any later version.
18  *
19  */
20
21 /* This driver handles only L2TP data frames; control frames are handled by a
22  * userspace application.
23  *
24  * To send data in an L2TP session, userspace opens a PPPoL2TP socket and
25  * attaches it to a bound UDP socket with local tunnel_id / session_id and
26  * peer tunnel_id / session_id set. Data can then be sent or received using
27  * regular socket sendmsg() / recvmsg() calls. Kernel parameters of the socket
28  * can be read or modified using ioctl() or [gs]etsockopt() calls.
29  *
30  * When a PPPoL2TP socket is connected with local and peer session_id values
31  * zero, the socket is treated as a special tunnel management socket.
32  *
33  * Here's example userspace code to create a socket for sending/receiving data
34  * over an L2TP session:-
35  *
36  *      struct sockaddr_pppol2tp sax;
37  *      int fd;
38  *      int session_fd;
39  *
40  *      fd = socket(AF_PPPOX, SOCK_DGRAM, PX_PROTO_OL2TP);
41  *
42  *      sax.sa_family = AF_PPPOX;
43  *      sax.sa_protocol = PX_PROTO_OL2TP;
44  *      sax.pppol2tp.fd = tunnel_fd;    // bound UDP socket
45  *      sax.pppol2tp.addr.sin_addr.s_addr = addr->sin_addr.s_addr;
46  *      sax.pppol2tp.addr.sin_port = addr->sin_port;
47  *      sax.pppol2tp.addr.sin_family = AF_INET;
48  *      sax.pppol2tp.s_tunnel  = tunnel_id;
49  *      sax.pppol2tp.s_session = session_id;
50  *      sax.pppol2tp.d_tunnel  = peer_tunnel_id;
51  *      sax.pppol2tp.d_session = peer_session_id;
52  *
53  *      session_fd = connect(fd, (struct sockaddr *)&sax, sizeof(sax));
54  *
55  * A pppd plugin that allows PPP traffic to be carried over L2TP using
56  * this driver is available from the OpenL2TP project at
57  * http://openl2tp.sourceforge.net.
58  */
59
60 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
61
62 #include <linux/module.h>
63 #include <linux/string.h>
64 #include <linux/list.h>
65 #include <linux/uaccess.h>
66
67 #include <linux/kernel.h>
68 #include <linux/spinlock.h>
69 #include <linux/kthread.h>
70 #include <linux/sched.h>
71 #include <linux/slab.h>
72 #include <linux/errno.h>
73 #include <linux/jiffies.h>
74
75 #include <linux/netdevice.h>
76 #include <linux/net.h>
77 #include <linux/inetdevice.h>
78 #include <linux/skbuff.h>
79 #include <linux/init.h>
80 #include <linux/ip.h>
81 #include <linux/udp.h>
82 #include <linux/if_pppox.h>
83 #include <linux/if_pppol2tp.h>
84 #include <net/sock.h>
85 #include <linux/ppp_channel.h>
86 #include <linux/ppp_defs.h>
87 #include <linux/ppp-ioctl.h>
88 #include <linux/file.h>
89 #include <linux/hash.h>
90 #include <linux/sort.h>
91 #include <linux/proc_fs.h>
92 #include <linux/l2tp.h>
93 #include <linux/nsproxy.h>
94 #include <net/net_namespace.h>
95 #include <net/netns/generic.h>
96 #include <net/dst.h>
97 #include <net/ip.h>
98 #include <net/udp.h>
99 #include <net/xfrm.h>
100 #include <net/inet_common.h>
101
102 #include <asm/byteorder.h>
103 #include <linux/atomic.h>
104
105 #include "l2tp_core.h"
106
107 #define PPPOL2TP_DRV_VERSION    "V2.0"
108
109 /* Space for UDP, L2TP and PPP headers */
110 #define PPPOL2TP_HEADER_OVERHEAD        40
111
112 /* Number of bytes to build transmit L2TP headers.
113  * Unfortunately the size is different depending on whether sequence numbers
114  * are enabled.
115  */
116 #define PPPOL2TP_L2TP_HDR_SIZE_SEQ              10
117 #define PPPOL2TP_L2TP_HDR_SIZE_NOSEQ            6
118
119 /* Private data of each session. This data lives at the end of struct
120  * l2tp_session, referenced via session->priv[].
121  */
122 struct pppol2tp_session {
123         int                     owner;          /* pid that opened the socket */
124
125         struct mutex            sk_lock;        /* Protects .sk */
126         struct sock __rcu       *sk;            /* Pointer to the session
127                                                  * PPPoX socket */
128         struct sock             *__sk;          /* Copy of .sk, for cleanup */
129         struct rcu_head         rcu;            /* For asynchronous release */
130         int                     flags;          /* accessed by PPPIOCGFLAGS.
131                                                  * Unused. */
132 };
133
134 static int pppol2tp_xmit(struct ppp_channel *chan, struct sk_buff *skb);
135
136 static const struct ppp_channel_ops pppol2tp_chan_ops = {
137         .start_xmit =  pppol2tp_xmit,
138 };
139
140 static const struct proto_ops pppol2tp_ops;
141
142 /* Retrieves the pppol2tp socket associated to a session.
143  * A reference is held on the returned socket, so this function must be paired
144  * with sock_put().
145  */
146 static struct sock *pppol2tp_session_get_sock(struct l2tp_session *session)
147 {
148         struct pppol2tp_session *ps = l2tp_session_priv(session);
149         struct sock *sk;
150
151         rcu_read_lock();
152         sk = rcu_dereference(ps->sk);
153         if (sk)
154                 sock_hold(sk);
155         rcu_read_unlock();
156
157         return sk;
158 }
159
160 /* Helpers to obtain tunnel/session contexts from sockets.
161  */
162 static inline struct l2tp_session *pppol2tp_sock_to_session(struct sock *sk)
163 {
164         struct l2tp_session *session;
165
166         if (sk == NULL)
167                 return NULL;
168
169         sock_hold(sk);
170         session = (struct l2tp_session *)(sk->sk_user_data);
171         if (session == NULL) {
172                 sock_put(sk);
173                 goto out;
174         }
175
176         BUG_ON(session->magic != L2TP_SESSION_MAGIC);
177
178 out:
179         return session;
180 }
181
182 /*****************************************************************************
183  * Receive data handling
184  *****************************************************************************/
185
186 static int pppol2tp_recv_payload_hook(struct sk_buff *skb)
187 {
188         /* Skip PPP header, if present.  In testing, Microsoft L2TP clients
189          * don't send the PPP header (PPP header compression enabled), but
190          * other clients can include the header. So we cope with both cases
191          * here. The PPP header is always FF03 when using L2TP.
192          *
193          * Note that skb->data[] isn't dereferenced from a u16 ptr here since
194          * the field may be unaligned.
195          */
196         if (!pskb_may_pull(skb, 2))
197                 return 1;
198
199         if ((skb->data[0] == PPP_ALLSTATIONS) && (skb->data[1] == PPP_UI))
200                 skb_pull(skb, 2);
201
202         return 0;
203 }
204
205 /* Receive message. This is the recvmsg for the PPPoL2TP socket.
206  */
207 static int pppol2tp_recvmsg(struct socket *sock, struct msghdr *msg,
208                             size_t len, int flags)
209 {
210         int err;
211         struct sk_buff *skb;
212         struct sock *sk = sock->sk;
213
214         err = -EIO;
215         if (sk->sk_state & PPPOX_BOUND)
216                 goto end;
217
218         err = 0;
219         skb = skb_recv_datagram(sk, flags & ~MSG_DONTWAIT,
220                                 flags & MSG_DONTWAIT, &err);
221         if (!skb)
222                 goto end;
223
224         if (len > skb->len)
225                 len = skb->len;
226         else if (len < skb->len)
227                 msg->msg_flags |= MSG_TRUNC;
228
229         err = skb_copy_datagram_msg(skb, 0, msg, len);
230         if (likely(err == 0))
231                 err = len;
232
233         kfree_skb(skb);
234 end:
235         return err;
236 }
237
238 static void pppol2tp_recv(struct l2tp_session *session, struct sk_buff *skb, int data_len)
239 {
240         struct pppol2tp_session *ps = l2tp_session_priv(session);
241         struct sock *sk = NULL;
242
243         /* If the socket is bound, send it in to PPP's input queue. Otherwise
244          * queue it on the session socket.
245          */
246         rcu_read_lock();
247         sk = rcu_dereference(ps->sk);
248         if (sk == NULL)
249                 goto no_sock;
250
251         if (sk->sk_state & PPPOX_BOUND) {
252                 struct pppox_sock *po;
253
254                 l2tp_dbg(session, L2TP_MSG_DATA,
255                          "%s: recv %d byte data frame, passing to ppp\n",
256                          session->name, data_len);
257
258                 po = pppox_sk(sk);
259                 ppp_input(&po->chan, skb);
260         } else {
261                 l2tp_dbg(session, L2TP_MSG_DATA,
262                          "%s: recv %d byte data frame, passing to L2TP socket\n",
263                          session->name, data_len);
264
265                 if (sock_queue_rcv_skb(sk, skb) < 0) {
266                         atomic_long_inc(&session->stats.rx_errors);
267                         kfree_skb(skb);
268                 }
269         }
270         rcu_read_unlock();
271
272         return;
273
274 no_sock:
275         rcu_read_unlock();
276         l2tp_info(session, L2TP_MSG_DATA, "%s: no socket\n", session->name);
277         kfree_skb(skb);
278 }
279
280 /************************************************************************
281  * Transmit handling
282  ***********************************************************************/
283
284 /* This is the sendmsg for the PPPoL2TP pppol2tp_session socket.  We come here
285  * when a user application does a sendmsg() on the session socket. L2TP and
286  * PPP headers must be inserted into the user's data.
287  */
288 static int pppol2tp_sendmsg(struct socket *sock, struct msghdr *m,
289                             size_t total_len)
290 {
291         struct sock *sk = sock->sk;
292         struct sk_buff *skb;
293         int error;
294         struct l2tp_session *session;
295         struct l2tp_tunnel *tunnel;
296         int uhlen;
297
298         error = -ENOTCONN;
299         if (sock_flag(sk, SOCK_DEAD) || !(sk->sk_state & PPPOX_CONNECTED))
300                 goto error;
301
302         /* Get session and tunnel contexts */
303         error = -EBADF;
304         session = pppol2tp_sock_to_session(sk);
305         if (session == NULL)
306                 goto error;
307
308         tunnel = session->tunnel;
309
310         uhlen = (tunnel->encap == L2TP_ENCAPTYPE_UDP) ? sizeof(struct udphdr) : 0;
311
312         /* Allocate a socket buffer */
313         error = -ENOMEM;
314         skb = sock_wmalloc(sk, NET_SKB_PAD + sizeof(struct iphdr) +
315                            uhlen + session->hdr_len +
316                            2 + total_len, /* 2 bytes for PPP_ALLSTATIONS & PPP_UI */
317                            0, GFP_KERNEL);
318         if (!skb)
319                 goto error_put_sess;
320
321         /* Reserve space for headers. */
322         skb_reserve(skb, NET_SKB_PAD);
323         skb_reset_network_header(skb);
324         skb_reserve(skb, sizeof(struct iphdr));
325         skb_reset_transport_header(skb);
326         skb_reserve(skb, uhlen);
327
328         /* Add PPP header */
329         skb->data[0] = PPP_ALLSTATIONS;
330         skb->data[1] = PPP_UI;
331         skb_put(skb, 2);
332
333         /* Copy user data into skb */
334         error = memcpy_from_msg(skb_put(skb, total_len), m, total_len);
335         if (error < 0) {
336                 kfree_skb(skb);
337                 goto error_put_sess;
338         }
339
340         local_bh_disable();
341         l2tp_xmit_skb(session, skb, session->hdr_len);
342         local_bh_enable();
343
344         sock_put(sk);
345
346         return total_len;
347
348 error_put_sess:
349         sock_put(sk);
350 error:
351         return error;
352 }
353
354 /* Transmit function called by generic PPP driver.  Sends PPP frame
355  * over PPPoL2TP socket.
356  *
357  * This is almost the same as pppol2tp_sendmsg(), but rather than
358  * being called with a msghdr from userspace, it is called with a skb
359  * from the kernel.
360  *
361  * The supplied skb from ppp doesn't have enough headroom for the
362  * insertion of L2TP, UDP and IP headers so we need to allocate more
363  * headroom in the skb. This will create a cloned skb. But we must be
364  * careful in the error case because the caller will expect to free
365  * the skb it supplied, not our cloned skb. So we take care to always
366  * leave the original skb unfreed if we return an error.
367  */
368 static int pppol2tp_xmit(struct ppp_channel *chan, struct sk_buff *skb)
369 {
370         struct sock *sk = (struct sock *) chan->private;
371         struct l2tp_session *session;
372         struct l2tp_tunnel *tunnel;
373         int uhlen, headroom;
374
375         if (sock_flag(sk, SOCK_DEAD) || !(sk->sk_state & PPPOX_CONNECTED))
376                 goto abort;
377
378         /* Get session and tunnel contexts from the socket */
379         session = pppol2tp_sock_to_session(sk);
380         if (session == NULL)
381                 goto abort;
382
383         tunnel = session->tunnel;
384
385         uhlen = (tunnel->encap == L2TP_ENCAPTYPE_UDP) ? sizeof(struct udphdr) : 0;
386         headroom = NET_SKB_PAD +
387                    sizeof(struct iphdr) + /* IP header */
388                    uhlen +              /* UDP header (if L2TP_ENCAPTYPE_UDP) */
389                    session->hdr_len +   /* L2TP header */
390                    2;                   /* 2 bytes for PPP_ALLSTATIONS & PPP_UI */
391         if (skb_cow_head(skb, headroom))
392                 goto abort_put_sess;
393
394         /* Setup PPP header */
395         __skb_push(skb, 2);
396         skb->data[0] = PPP_ALLSTATIONS;
397         skb->data[1] = PPP_UI;
398
399         local_bh_disable();
400         l2tp_xmit_skb(session, skb, session->hdr_len);
401         local_bh_enable();
402
403         sock_put(sk);
404
405         return 1;
406
407 abort_put_sess:
408         sock_put(sk);
409 abort:
410         /* Free the original skb */
411         kfree_skb(skb);
412         return 1;
413 }
414
415 /*****************************************************************************
416  * Session (and tunnel control) socket create/destroy.
417  *****************************************************************************/
418
419 static void pppol2tp_put_sk(struct rcu_head *head)
420 {
421         struct pppol2tp_session *ps;
422
423         ps = container_of(head, typeof(*ps), rcu);
424         sock_put(ps->__sk);
425 }
426
427 /* Called by l2tp_core when a session socket is being closed.
428  */
429 static void pppol2tp_session_close(struct l2tp_session *session)
430 {
431 }
432
433 /* Really kill the session socket. (Called from sock_put() if
434  * refcnt == 0.)
435  */
436 static void pppol2tp_session_destruct(struct sock *sk)
437 {
438         struct l2tp_session *session = sk->sk_user_data;
439
440         skb_queue_purge(&sk->sk_receive_queue);
441         skb_queue_purge(&sk->sk_write_queue);
442
443         if (session) {
444                 sk->sk_user_data = NULL;
445                 BUG_ON(session->magic != L2TP_SESSION_MAGIC);
446                 l2tp_session_dec_refcount(session);
447         }
448 }
449
450 /* Called when the PPPoX socket (session) is closed.
451  */
452 static int pppol2tp_release(struct socket *sock)
453 {
454         struct sock *sk = sock->sk;
455         struct l2tp_session *session;
456         int error;
457
458         if (!sk)
459                 return 0;
460
461         error = -EBADF;
462         lock_sock(sk);
463         if (sock_flag(sk, SOCK_DEAD) != 0)
464                 goto error;
465
466         pppox_unbind_sock(sk);
467
468         /* Signal the death of the socket. */
469         sk->sk_state = PPPOX_DEAD;
470         sock_orphan(sk);
471         sock->sk = NULL;
472
473         session = pppol2tp_sock_to_session(sk);
474         if (session) {
475                 struct pppol2tp_session *ps;
476
477                 l2tp_session_delete(session);
478
479                 ps = l2tp_session_priv(session);
480                 mutex_lock(&ps->sk_lock);
481                 ps->__sk = rcu_dereference_protected(ps->sk,
482                                                      lockdep_is_held(&ps->sk_lock));
483                 RCU_INIT_POINTER(ps->sk, NULL);
484                 mutex_unlock(&ps->sk_lock);
485                 call_rcu(&ps->rcu, pppol2tp_put_sk);
486
487                 /* Rely on the sock_put() call at the end of the function for
488                  * dropping the reference held by pppol2tp_sock_to_session().
489                  * The last reference will be dropped by pppol2tp_put_sk().
490                  */
491         }
492
493         release_sock(sk);
494
495         /* This will delete the session context via
496          * pppol2tp_session_destruct() if the socket's refcnt drops to
497          * zero.
498          */
499         sock_put(sk);
500
501         return 0;
502
503 error:
504         release_sock(sk);
505         return error;
506 }
507
508 static struct proto pppol2tp_sk_proto = {
509         .name     = "PPPOL2TP",
510         .owner    = THIS_MODULE,
511         .obj_size = sizeof(struct pppox_sock),
512 };
513
514 static int pppol2tp_backlog_recv(struct sock *sk, struct sk_buff *skb)
515 {
516         int rc;
517
518         rc = l2tp_udp_encap_recv(sk, skb);
519         if (rc)
520                 kfree_skb(skb);
521
522         return NET_RX_SUCCESS;
523 }
524
525 /* socket() handler. Initialize a new struct sock.
526  */
527 static int pppol2tp_create(struct net *net, struct socket *sock, int kern)
528 {
529         int error = -ENOMEM;
530         struct sock *sk;
531
532         sk = sk_alloc(net, PF_PPPOX, GFP_KERNEL, &pppol2tp_sk_proto, kern);
533         if (!sk)
534                 goto out;
535
536         sock_init_data(sock, sk);
537
538         sock->state  = SS_UNCONNECTED;
539         sock->ops    = &pppol2tp_ops;
540
541         sk->sk_backlog_rcv = pppol2tp_backlog_recv;
542         sk->sk_protocol    = PX_PROTO_OL2TP;
543         sk->sk_family      = PF_PPPOX;
544         sk->sk_state       = PPPOX_NONE;
545         sk->sk_type        = SOCK_STREAM;
546         sk->sk_destruct    = pppol2tp_session_destruct;
547
548         error = 0;
549
550 out:
551         return error;
552 }
553
554 #if IS_ENABLED(CONFIG_L2TP_DEBUGFS)
555 static void pppol2tp_show(struct seq_file *m, void *arg)
556 {
557         struct l2tp_session *session = arg;
558         struct sock *sk;
559
560         sk = pppol2tp_session_get_sock(session);
561         if (sk) {
562                 struct pppox_sock *po = pppox_sk(sk);
563
564                 seq_printf(m, "   interface %s\n", ppp_dev_name(&po->chan));
565                 sock_put(sk);
566         }
567 }
568 #endif
569
570 static void pppol2tp_session_init(struct l2tp_session *session)
571 {
572         struct pppol2tp_session *ps;
573         struct dst_entry *dst;
574
575         session->recv_skb = pppol2tp_recv;
576         session->session_close = pppol2tp_session_close;
577 #if IS_ENABLED(CONFIG_L2TP_DEBUGFS)
578         session->show = pppol2tp_show;
579 #endif
580
581         ps = l2tp_session_priv(session);
582         mutex_init(&ps->sk_lock);
583         ps->owner = current->pid;
584
585         /* If PMTU discovery was enabled, use the MTU that was discovered */
586         dst = sk_dst_get(session->tunnel->sock);
587         if (dst) {
588                 u32 pmtu = dst_mtu(dst);
589
590                 if (pmtu) {
591                         session->mtu = pmtu - PPPOL2TP_HEADER_OVERHEAD;
592                         session->mru = pmtu - PPPOL2TP_HEADER_OVERHEAD;
593                 }
594                 dst_release(dst);
595         }
596 }
597
598 /* connect() handler. Attach a PPPoX socket to a tunnel UDP socket
599  */
600 static int pppol2tp_connect(struct socket *sock, struct sockaddr *uservaddr,
601                             int sockaddr_len, int flags)
602 {
603         struct sock *sk = sock->sk;
604         struct sockaddr_pppol2tp *sp = (struct sockaddr_pppol2tp *) uservaddr;
605         struct pppox_sock *po = pppox_sk(sk);
606         struct l2tp_session *session = NULL;
607         struct l2tp_tunnel *tunnel;
608         struct pppol2tp_session *ps;
609         struct l2tp_session_cfg cfg = { 0, };
610         int error = 0;
611         u32 tunnel_id, peer_tunnel_id;
612         u32 session_id, peer_session_id;
613         bool drop_refcnt = false;
614         bool drop_tunnel = false;
615         int ver = 2;
616         int fd;
617
618         lock_sock(sk);
619
620         error = -EINVAL;
621
622         if (sockaddr_len != sizeof(struct sockaddr_pppol2tp) &&
623             sockaddr_len != sizeof(struct sockaddr_pppol2tpv3) &&
624             sockaddr_len != sizeof(struct sockaddr_pppol2tpin6) &&
625             sockaddr_len != sizeof(struct sockaddr_pppol2tpv3in6))
626                 goto end;
627
628         if (sp->sa_protocol != PX_PROTO_OL2TP)
629                 goto end;
630
631         /* Check for already bound sockets */
632         error = -EBUSY;
633         if (sk->sk_state & PPPOX_CONNECTED)
634                 goto end;
635
636         /* We don't supporting rebinding anyway */
637         error = -EALREADY;
638         if (sk->sk_user_data)
639                 goto end; /* socket is already attached */
640
641         /* Get params from socket address. Handle L2TPv2 and L2TPv3.
642          * This is nasty because there are different sockaddr_pppol2tp
643          * structs for L2TPv2, L2TPv3, over IPv4 and IPv6. We use
644          * the sockaddr size to determine which structure the caller
645          * is using.
646          */
647         peer_tunnel_id = 0;
648         if (sockaddr_len == sizeof(struct sockaddr_pppol2tp)) {
649                 fd = sp->pppol2tp.fd;
650                 tunnel_id = sp->pppol2tp.s_tunnel;
651                 peer_tunnel_id = sp->pppol2tp.d_tunnel;
652                 session_id = sp->pppol2tp.s_session;
653                 peer_session_id = sp->pppol2tp.d_session;
654         } else if (sockaddr_len == sizeof(struct sockaddr_pppol2tpv3)) {
655                 struct sockaddr_pppol2tpv3 *sp3 =
656                         (struct sockaddr_pppol2tpv3 *) sp;
657                 ver = 3;
658                 fd = sp3->pppol2tp.fd;
659                 tunnel_id = sp3->pppol2tp.s_tunnel;
660                 peer_tunnel_id = sp3->pppol2tp.d_tunnel;
661                 session_id = sp3->pppol2tp.s_session;
662                 peer_session_id = sp3->pppol2tp.d_session;
663         } else if (sockaddr_len == sizeof(struct sockaddr_pppol2tpin6)) {
664                 struct sockaddr_pppol2tpin6 *sp6 =
665                         (struct sockaddr_pppol2tpin6 *) sp;
666                 fd = sp6->pppol2tp.fd;
667                 tunnel_id = sp6->pppol2tp.s_tunnel;
668                 peer_tunnel_id = sp6->pppol2tp.d_tunnel;
669                 session_id = sp6->pppol2tp.s_session;
670                 peer_session_id = sp6->pppol2tp.d_session;
671         } else if (sockaddr_len == sizeof(struct sockaddr_pppol2tpv3in6)) {
672                 struct sockaddr_pppol2tpv3in6 *sp6 =
673                         (struct sockaddr_pppol2tpv3in6 *) sp;
674                 ver = 3;
675                 fd = sp6->pppol2tp.fd;
676                 tunnel_id = sp6->pppol2tp.s_tunnel;
677                 peer_tunnel_id = sp6->pppol2tp.d_tunnel;
678                 session_id = sp6->pppol2tp.s_session;
679                 peer_session_id = sp6->pppol2tp.d_session;
680         } else {
681                 error = -EINVAL;
682                 goto end; /* bad socket address */
683         }
684
685         /* Don't bind if tunnel_id is 0 */
686         error = -EINVAL;
687         if (tunnel_id == 0)
688                 goto end;
689
690         tunnel = l2tp_tunnel_get(sock_net(sk), tunnel_id);
691         if (tunnel)
692                 drop_tunnel = true;
693
694         /* Special case: create tunnel context if session_id and
695          * peer_session_id is 0. Otherwise look up tunnel using supplied
696          * tunnel id.
697          */
698         if ((session_id == 0) && (peer_session_id == 0)) {
699                 if (tunnel == NULL) {
700                         struct l2tp_tunnel_cfg tcfg = {
701                                 .encap = L2TP_ENCAPTYPE_UDP,
702                                 .debug = 0,
703                         };
704
705                         /* Prevent l2tp_tunnel_register() from trying to set up
706                          * a kernel socket.
707                          */
708                         if (fd < 0) {
709                                 error = -EBADF;
710                                 goto end;
711                         }
712
713                         error = l2tp_tunnel_create(sock_net(sk), fd, ver, tunnel_id, peer_tunnel_id, &tcfg, &tunnel);
714                         if (error < 0)
715                                 goto end;
716
717                         l2tp_tunnel_inc_refcount(tunnel);
718                         error = l2tp_tunnel_register(tunnel, sock_net(sk),
719                                                      &tcfg);
720                         if (error < 0) {
721                                 kfree(tunnel);
722                                 goto end;
723                         }
724                         drop_tunnel = true;
725                 }
726         } else {
727                 /* Error if we can't find the tunnel */
728                 error = -ENOENT;
729                 if (tunnel == NULL)
730                         goto end;
731
732                 /* Error if socket is not prepped */
733                 if (tunnel->sock == NULL)
734                         goto end;
735         }
736
737         if (tunnel->recv_payload_hook == NULL)
738                 tunnel->recv_payload_hook = pppol2tp_recv_payload_hook;
739
740         if (tunnel->peer_tunnel_id == 0)
741                 tunnel->peer_tunnel_id = peer_tunnel_id;
742
743         session = l2tp_session_get(sock_net(sk), tunnel, session_id);
744         if (session) {
745                 drop_refcnt = true;
746
747                 if (session->pwtype != L2TP_PWTYPE_PPP) {
748                         error = -EPROTOTYPE;
749                         goto end;
750                 }
751
752                 ps = l2tp_session_priv(session);
753
754                 /* Using a pre-existing session is fine as long as it hasn't
755                  * been connected yet.
756                  */
757                 mutex_lock(&ps->sk_lock);
758                 if (rcu_dereference_protected(ps->sk,
759                                               lockdep_is_held(&ps->sk_lock)) ||
760                     ps->__sk) {
761                         mutex_unlock(&ps->sk_lock);
762                         error = -EEXIST;
763                         goto end;
764                 }
765         } else {
766                 /* Default MTU must allow space for UDP/L2TP/PPP headers */
767                 cfg.mtu = 1500 - PPPOL2TP_HEADER_OVERHEAD;
768                 cfg.mru = cfg.mtu;
769                 cfg.pw_type = L2TP_PWTYPE_PPP;
770
771                 session = l2tp_session_create(sizeof(struct pppol2tp_session),
772                                               tunnel, session_id,
773                                               peer_session_id, &cfg);
774                 if (IS_ERR(session)) {
775                         error = PTR_ERR(session);
776                         goto end;
777                 }
778
779                 pppol2tp_session_init(session);
780                 ps = l2tp_session_priv(session);
781                 l2tp_session_inc_refcount(session);
782
783                 mutex_lock(&ps->sk_lock);
784                 error = l2tp_session_register(session, tunnel);
785                 if (error < 0) {
786                         mutex_unlock(&ps->sk_lock);
787                         kfree(session);
788                         goto end;
789                 }
790                 drop_refcnt = true;
791         }
792
793         /* Special case: if source & dest session_id == 0x0000, this
794          * socket is being created to manage the tunnel. Just set up
795          * the internal context for use by ioctl() and sockopt()
796          * handlers.
797          */
798         if ((session->session_id == 0) &&
799             (session->peer_session_id == 0)) {
800                 error = 0;
801                 goto out_no_ppp;
802         }
803
804         /* The only header we need to worry about is the L2TP
805          * header. This size is different depending on whether
806          * sequence numbers are enabled for the data channel.
807          */
808         po->chan.hdrlen = PPPOL2TP_L2TP_HDR_SIZE_NOSEQ;
809
810         po->chan.private = sk;
811         po->chan.ops     = &pppol2tp_chan_ops;
812         po->chan.mtu     = session->mtu;
813
814         error = ppp_register_net_channel(sock_net(sk), &po->chan);
815         if (error) {
816                 mutex_unlock(&ps->sk_lock);
817                 goto end;
818         }
819
820 out_no_ppp:
821         /* This is how we get the session context from the socket. */
822         sk->sk_user_data = session;
823         rcu_assign_pointer(ps->sk, sk);
824         mutex_unlock(&ps->sk_lock);
825
826         /* Keep the reference we've grabbed on the session: sk doesn't expect
827          * the session to disappear. pppol2tp_session_destruct() is responsible
828          * for dropping it.
829          */
830         drop_refcnt = false;
831
832         sk->sk_state = PPPOX_CONNECTED;
833         l2tp_info(session, L2TP_MSG_CONTROL, "%s: created\n",
834                   session->name);
835
836 end:
837         if (drop_refcnt)
838                 l2tp_session_dec_refcount(session);
839         if (drop_tunnel)
840                 l2tp_tunnel_dec_refcount(tunnel);
841         release_sock(sk);
842
843         return error;
844 }
845
846 #ifdef CONFIG_L2TP_V3
847
848 /* Called when creating sessions via the netlink interface. */
849 static int pppol2tp_session_create(struct net *net, struct l2tp_tunnel *tunnel,
850                                    u32 session_id, u32 peer_session_id,
851                                    struct l2tp_session_cfg *cfg)
852 {
853         int error;
854         struct l2tp_session *session;
855
856         /* Error if tunnel socket is not prepped */
857         if (!tunnel->sock) {
858                 error = -ENOENT;
859                 goto err;
860         }
861
862         /* Default MTU values. */
863         if (cfg->mtu == 0)
864                 cfg->mtu = 1500 - PPPOL2TP_HEADER_OVERHEAD;
865         if (cfg->mru == 0)
866                 cfg->mru = cfg->mtu;
867
868         /* Allocate and initialize a new session context. */
869         session = l2tp_session_create(sizeof(struct pppol2tp_session),
870                                       tunnel, session_id,
871                                       peer_session_id, cfg);
872         if (IS_ERR(session)) {
873                 error = PTR_ERR(session);
874                 goto err;
875         }
876
877         pppol2tp_session_init(session);
878
879         error = l2tp_session_register(session, tunnel);
880         if (error < 0)
881                 goto err_sess;
882
883         return 0;
884
885 err_sess:
886         kfree(session);
887 err:
888         return error;
889 }
890
891 #endif /* CONFIG_L2TP_V3 */
892
893 /* getname() support.
894  */
895 static int pppol2tp_getname(struct socket *sock, struct sockaddr *uaddr,
896                             int peer)
897 {
898         int len = 0;
899         int error = 0;
900         struct l2tp_session *session;
901         struct l2tp_tunnel *tunnel;
902         struct sock *sk = sock->sk;
903         struct inet_sock *inet;
904         struct pppol2tp_session *pls;
905
906         error = -ENOTCONN;
907         if (sk == NULL)
908                 goto end;
909         if (!(sk->sk_state & PPPOX_CONNECTED))
910                 goto end;
911
912         error = -EBADF;
913         session = pppol2tp_sock_to_session(sk);
914         if (session == NULL)
915                 goto end;
916
917         pls = l2tp_session_priv(session);
918         tunnel = session->tunnel;
919
920         inet = inet_sk(tunnel->sock);
921         if ((tunnel->version == 2) && (tunnel->sock->sk_family == AF_INET)) {
922                 struct sockaddr_pppol2tp sp;
923                 len = sizeof(sp);
924                 memset(&sp, 0, len);
925                 sp.sa_family    = AF_PPPOX;
926                 sp.sa_protocol  = PX_PROTO_OL2TP;
927                 sp.pppol2tp.fd  = tunnel->fd;
928                 sp.pppol2tp.pid = pls->owner;
929                 sp.pppol2tp.s_tunnel = tunnel->tunnel_id;
930                 sp.pppol2tp.d_tunnel = tunnel->peer_tunnel_id;
931                 sp.pppol2tp.s_session = session->session_id;
932                 sp.pppol2tp.d_session = session->peer_session_id;
933                 sp.pppol2tp.addr.sin_family = AF_INET;
934                 sp.pppol2tp.addr.sin_port = inet->inet_dport;
935                 sp.pppol2tp.addr.sin_addr.s_addr = inet->inet_daddr;
936                 memcpy(uaddr, &sp, len);
937 #if IS_ENABLED(CONFIG_IPV6)
938         } else if ((tunnel->version == 2) &&
939                    (tunnel->sock->sk_family == AF_INET6)) {
940                 struct sockaddr_pppol2tpin6 sp;
941
942                 len = sizeof(sp);
943                 memset(&sp, 0, len);
944                 sp.sa_family    = AF_PPPOX;
945                 sp.sa_protocol  = PX_PROTO_OL2TP;
946                 sp.pppol2tp.fd  = tunnel->fd;
947                 sp.pppol2tp.pid = pls->owner;
948                 sp.pppol2tp.s_tunnel = tunnel->tunnel_id;
949                 sp.pppol2tp.d_tunnel = tunnel->peer_tunnel_id;
950                 sp.pppol2tp.s_session = session->session_id;
951                 sp.pppol2tp.d_session = session->peer_session_id;
952                 sp.pppol2tp.addr.sin6_family = AF_INET6;
953                 sp.pppol2tp.addr.sin6_port = inet->inet_dport;
954                 memcpy(&sp.pppol2tp.addr.sin6_addr, &tunnel->sock->sk_v6_daddr,
955                        sizeof(tunnel->sock->sk_v6_daddr));
956                 memcpy(uaddr, &sp, len);
957         } else if ((tunnel->version == 3) &&
958                    (tunnel->sock->sk_family == AF_INET6)) {
959                 struct sockaddr_pppol2tpv3in6 sp;
960
961                 len = sizeof(sp);
962                 memset(&sp, 0, len);
963                 sp.sa_family    = AF_PPPOX;
964                 sp.sa_protocol  = PX_PROTO_OL2TP;
965                 sp.pppol2tp.fd  = tunnel->fd;
966                 sp.pppol2tp.pid = pls->owner;
967                 sp.pppol2tp.s_tunnel = tunnel->tunnel_id;
968                 sp.pppol2tp.d_tunnel = tunnel->peer_tunnel_id;
969                 sp.pppol2tp.s_session = session->session_id;
970                 sp.pppol2tp.d_session = session->peer_session_id;
971                 sp.pppol2tp.addr.sin6_family = AF_INET6;
972                 sp.pppol2tp.addr.sin6_port = inet->inet_dport;
973                 memcpy(&sp.pppol2tp.addr.sin6_addr, &tunnel->sock->sk_v6_daddr,
974                        sizeof(tunnel->sock->sk_v6_daddr));
975                 memcpy(uaddr, &sp, len);
976 #endif
977         } else if (tunnel->version == 3) {
978                 struct sockaddr_pppol2tpv3 sp;
979                 len = sizeof(sp);
980                 memset(&sp, 0, len);
981                 sp.sa_family    = AF_PPPOX;
982                 sp.sa_protocol  = PX_PROTO_OL2TP;
983                 sp.pppol2tp.fd  = tunnel->fd;
984                 sp.pppol2tp.pid = pls->owner;
985                 sp.pppol2tp.s_tunnel = tunnel->tunnel_id;
986                 sp.pppol2tp.d_tunnel = tunnel->peer_tunnel_id;
987                 sp.pppol2tp.s_session = session->session_id;
988                 sp.pppol2tp.d_session = session->peer_session_id;
989                 sp.pppol2tp.addr.sin_family = AF_INET;
990                 sp.pppol2tp.addr.sin_port = inet->inet_dport;
991                 sp.pppol2tp.addr.sin_addr.s_addr = inet->inet_daddr;
992                 memcpy(uaddr, &sp, len);
993         }
994
995         error = len;
996
997         sock_put(sk);
998 end:
999         return error;
1000 }
1001
1002 /****************************************************************************
1003  * ioctl() handlers.
1004  *
1005  * The PPPoX socket is created for L2TP sessions: tunnels have their own UDP
1006  * sockets. However, in order to control kernel tunnel features, we allow
1007  * userspace to create a special "tunnel" PPPoX socket which is used for
1008  * control only.  Tunnel PPPoX sockets have session_id == 0 and simply allow
1009  * the user application to issue L2TP setsockopt(), getsockopt() and ioctl()
1010  * calls.
1011  ****************************************************************************/
1012
1013 static void pppol2tp_copy_stats(struct pppol2tp_ioc_stats *dest,
1014                                 struct l2tp_stats *stats)
1015 {
1016         dest->tx_packets = atomic_long_read(&stats->tx_packets);
1017         dest->tx_bytes = atomic_long_read(&stats->tx_bytes);
1018         dest->tx_errors = atomic_long_read(&stats->tx_errors);
1019         dest->rx_packets = atomic_long_read(&stats->rx_packets);
1020         dest->rx_bytes = atomic_long_read(&stats->rx_bytes);
1021         dest->rx_seq_discards = atomic_long_read(&stats->rx_seq_discards);
1022         dest->rx_oos_packets = atomic_long_read(&stats->rx_oos_packets);
1023         dest->rx_errors = atomic_long_read(&stats->rx_errors);
1024 }
1025
1026 /* Session ioctl helper.
1027  */
1028 static int pppol2tp_session_ioctl(struct l2tp_session *session,
1029                                   unsigned int cmd, unsigned long arg)
1030 {
1031         struct ifreq ifr;
1032         int err = 0;
1033         struct sock *sk;
1034         int val = (int) arg;
1035         struct pppol2tp_session *ps = l2tp_session_priv(session);
1036         struct l2tp_tunnel *tunnel = session->tunnel;
1037         struct pppol2tp_ioc_stats stats;
1038
1039         l2tp_dbg(session, L2TP_MSG_CONTROL,
1040                  "%s: pppol2tp_session_ioctl(cmd=%#x, arg=%#lx)\n",
1041                  session->name, cmd, arg);
1042
1043         sk = pppol2tp_session_get_sock(session);
1044         if (!sk)
1045                 return -EBADR;
1046
1047         switch (cmd) {
1048         case SIOCGIFMTU:
1049                 err = -ENXIO;
1050                 if (!(sk->sk_state & PPPOX_CONNECTED))
1051                         break;
1052
1053                 err = -EFAULT;
1054                 if (copy_from_user(&ifr, (void __user *) arg, sizeof(struct ifreq)))
1055                         break;
1056                 ifr.ifr_mtu = session->mtu;
1057                 if (copy_to_user((void __user *) arg, &ifr, sizeof(struct ifreq)))
1058                         break;
1059
1060                 l2tp_info(session, L2TP_MSG_CONTROL, "%s: get mtu=%d\n",
1061                           session->name, session->mtu);
1062                 err = 0;
1063                 break;
1064
1065         case SIOCSIFMTU:
1066                 err = -ENXIO;
1067                 if (!(sk->sk_state & PPPOX_CONNECTED))
1068                         break;
1069
1070                 err = -EFAULT;
1071                 if (copy_from_user(&ifr, (void __user *) arg, sizeof(struct ifreq)))
1072                         break;
1073
1074                 session->mtu = ifr.ifr_mtu;
1075
1076                 l2tp_info(session, L2TP_MSG_CONTROL, "%s: set mtu=%d\n",
1077                           session->name, session->mtu);
1078                 err = 0;
1079                 break;
1080
1081         case PPPIOCGMRU:
1082                 err = -ENXIO;
1083                 if (!(sk->sk_state & PPPOX_CONNECTED))
1084                         break;
1085
1086                 err = -EFAULT;
1087                 if (put_user(session->mru, (int __user *) arg))
1088                         break;
1089
1090                 l2tp_info(session, L2TP_MSG_CONTROL, "%s: get mru=%d\n",
1091                           session->name, session->mru);
1092                 err = 0;
1093                 break;
1094
1095         case PPPIOCSMRU:
1096                 err = -ENXIO;
1097                 if (!(sk->sk_state & PPPOX_CONNECTED))
1098                         break;
1099
1100                 err = -EFAULT;
1101                 if (get_user(val, (int __user *) arg))
1102                         break;
1103
1104                 session->mru = val;
1105                 l2tp_info(session, L2TP_MSG_CONTROL, "%s: set mru=%d\n",
1106                           session->name, session->mru);
1107                 err = 0;
1108                 break;
1109
1110         case PPPIOCGFLAGS:
1111                 err = -EFAULT;
1112                 if (put_user(ps->flags, (int __user *) arg))
1113                         break;
1114
1115                 l2tp_info(session, L2TP_MSG_CONTROL, "%s: get flags=%d\n",
1116                           session->name, ps->flags);
1117                 err = 0;
1118                 break;
1119
1120         case PPPIOCSFLAGS:
1121                 err = -EFAULT;
1122                 if (get_user(val, (int __user *) arg))
1123                         break;
1124                 ps->flags = val;
1125                 l2tp_info(session, L2TP_MSG_CONTROL, "%s: set flags=%d\n",
1126                           session->name, ps->flags);
1127                 err = 0;
1128                 break;
1129
1130         case PPPIOCGL2TPSTATS:
1131                 err = -ENXIO;
1132                 if (!(sk->sk_state & PPPOX_CONNECTED))
1133                         break;
1134
1135                 memset(&stats, 0, sizeof(stats));
1136                 stats.tunnel_id = tunnel->tunnel_id;
1137                 stats.session_id = session->session_id;
1138                 pppol2tp_copy_stats(&stats, &session->stats);
1139                 if (copy_to_user((void __user *) arg, &stats,
1140                                  sizeof(stats)))
1141                         break;
1142                 l2tp_info(session, L2TP_MSG_CONTROL, "%s: get L2TP stats\n",
1143                           session->name);
1144                 err = 0;
1145                 break;
1146
1147         default:
1148                 err = -ENOSYS;
1149                 break;
1150         }
1151
1152         sock_put(sk);
1153
1154         return err;
1155 }
1156
1157 /* Tunnel ioctl helper.
1158  *
1159  * Note the special handling for PPPIOCGL2TPSTATS below. If the ioctl data
1160  * specifies a session_id, the session ioctl handler is called. This allows an
1161  * application to retrieve session stats via a tunnel socket.
1162  */
1163 static int pppol2tp_tunnel_ioctl(struct l2tp_tunnel *tunnel,
1164                                  unsigned int cmd, unsigned long arg)
1165 {
1166         int err = 0;
1167         struct sock *sk;
1168         struct pppol2tp_ioc_stats stats;
1169
1170         l2tp_dbg(tunnel, L2TP_MSG_CONTROL,
1171                  "%s: pppol2tp_tunnel_ioctl(cmd=%#x, arg=%#lx)\n",
1172                  tunnel->name, cmd, arg);
1173
1174         sk = tunnel->sock;
1175         sock_hold(sk);
1176
1177         switch (cmd) {
1178         case PPPIOCGL2TPSTATS:
1179                 err = -ENXIO;
1180                 if (!(sk->sk_state & PPPOX_CONNECTED))
1181                         break;
1182
1183                 if (copy_from_user(&stats, (void __user *) arg,
1184                                    sizeof(stats))) {
1185                         err = -EFAULT;
1186                         break;
1187                 }
1188                 if (stats.session_id != 0) {
1189                         /* resend to session ioctl handler */
1190                         struct l2tp_session *session =
1191                                 l2tp_session_get(sock_net(sk), tunnel,
1192                                                  stats.session_id);
1193
1194                         if (session) {
1195                                 err = pppol2tp_session_ioctl(session, cmd,
1196                                                              arg);
1197                                 l2tp_session_dec_refcount(session);
1198                         } else {
1199                                 err = -EBADR;
1200                         }
1201                         break;
1202                 }
1203 #ifdef CONFIG_XFRM
1204                 stats.using_ipsec = (sk->sk_policy[0] || sk->sk_policy[1]) ? 1 : 0;
1205 #endif
1206                 pppol2tp_copy_stats(&stats, &tunnel->stats);
1207                 if (copy_to_user((void __user *) arg, &stats, sizeof(stats))) {
1208                         err = -EFAULT;
1209                         break;
1210                 }
1211                 l2tp_info(tunnel, L2TP_MSG_CONTROL, "%s: get L2TP stats\n",
1212                           tunnel->name);
1213                 err = 0;
1214                 break;
1215
1216         default:
1217                 err = -ENOSYS;
1218                 break;
1219         }
1220
1221         sock_put(sk);
1222
1223         return err;
1224 }
1225
1226 /* Main ioctl() handler.
1227  * Dispatch to tunnel or session helpers depending on the socket.
1228  */
1229 static int pppol2tp_ioctl(struct socket *sock, unsigned int cmd,
1230                           unsigned long arg)
1231 {
1232         struct sock *sk = sock->sk;
1233         struct l2tp_session *session;
1234         struct l2tp_tunnel *tunnel;
1235         int err;
1236
1237         if (!sk)
1238                 return 0;
1239
1240         err = -EBADF;
1241         if (sock_flag(sk, SOCK_DEAD) != 0)
1242                 goto end;
1243
1244         err = -ENOTCONN;
1245         if ((sk->sk_user_data == NULL) ||
1246             (!(sk->sk_state & (PPPOX_CONNECTED | PPPOX_BOUND))))
1247                 goto end;
1248
1249         /* Get session context from the socket */
1250         err = -EBADF;
1251         session = pppol2tp_sock_to_session(sk);
1252         if (session == NULL)
1253                 goto end;
1254
1255         /* Special case: if session's session_id is zero, treat ioctl as a
1256          * tunnel ioctl
1257          */
1258         if ((session->session_id == 0) &&
1259             (session->peer_session_id == 0)) {
1260                 tunnel = session->tunnel;
1261                 err = pppol2tp_tunnel_ioctl(tunnel, cmd, arg);
1262                 goto end_put_sess;
1263         }
1264
1265         err = pppol2tp_session_ioctl(session, cmd, arg);
1266
1267 end_put_sess:
1268         sock_put(sk);
1269 end:
1270         return err;
1271 }
1272
1273 /*****************************************************************************
1274  * setsockopt() / getsockopt() support.
1275  *
1276  * The PPPoX socket is created for L2TP sessions: tunnels have their own UDP
1277  * sockets. In order to control kernel tunnel features, we allow userspace to
1278  * create a special "tunnel" PPPoX socket which is used for control only.
1279  * Tunnel PPPoX sockets have session_id == 0 and simply allow the user
1280  * application to issue L2TP setsockopt(), getsockopt() and ioctl() calls.
1281  *****************************************************************************/
1282
1283 /* Tunnel setsockopt() helper.
1284  */
1285 static int pppol2tp_tunnel_setsockopt(struct sock *sk,
1286                                       struct l2tp_tunnel *tunnel,
1287                                       int optname, int val)
1288 {
1289         int err = 0;
1290
1291         switch (optname) {
1292         case PPPOL2TP_SO_DEBUG:
1293                 tunnel->debug = val;
1294                 l2tp_info(tunnel, L2TP_MSG_CONTROL, "%s: set debug=%x\n",
1295                           tunnel->name, tunnel->debug);
1296                 break;
1297
1298         default:
1299                 err = -ENOPROTOOPT;
1300                 break;
1301         }
1302
1303         return err;
1304 }
1305
1306 /* Session setsockopt helper.
1307  */
1308 static int pppol2tp_session_setsockopt(struct sock *sk,
1309                                        struct l2tp_session *session,
1310                                        int optname, int val)
1311 {
1312         int err = 0;
1313
1314         switch (optname) {
1315         case PPPOL2TP_SO_RECVSEQ:
1316                 if ((val != 0) && (val != 1)) {
1317                         err = -EINVAL;
1318                         break;
1319                 }
1320                 session->recv_seq = !!val;
1321                 l2tp_info(session, L2TP_MSG_CONTROL,
1322                           "%s: set recv_seq=%d\n",
1323                           session->name, session->recv_seq);
1324                 break;
1325
1326         case PPPOL2TP_SO_SENDSEQ:
1327                 if ((val != 0) && (val != 1)) {
1328                         err = -EINVAL;
1329                         break;
1330                 }
1331                 session->send_seq = !!val;
1332                 {
1333                         struct pppox_sock *po = pppox_sk(sk);
1334
1335                         po->chan.hdrlen = val ? PPPOL2TP_L2TP_HDR_SIZE_SEQ :
1336                                 PPPOL2TP_L2TP_HDR_SIZE_NOSEQ;
1337                 }
1338                 l2tp_session_set_header_len(session, session->tunnel->version);
1339                 l2tp_info(session, L2TP_MSG_CONTROL,
1340                           "%s: set send_seq=%d\n",
1341                           session->name, session->send_seq);
1342                 break;
1343
1344         case PPPOL2TP_SO_LNSMODE:
1345                 if ((val != 0) && (val != 1)) {
1346                         err = -EINVAL;
1347                         break;
1348                 }
1349                 session->lns_mode = !!val;
1350                 l2tp_info(session, L2TP_MSG_CONTROL,
1351                           "%s: set lns_mode=%d\n",
1352                           session->name, session->lns_mode);
1353                 break;
1354
1355         case PPPOL2TP_SO_DEBUG:
1356                 session->debug = val;
1357                 l2tp_info(session, L2TP_MSG_CONTROL, "%s: set debug=%x\n",
1358                           session->name, session->debug);
1359                 break;
1360
1361         case PPPOL2TP_SO_REORDERTO:
1362                 session->reorder_timeout = msecs_to_jiffies(val);
1363                 l2tp_info(session, L2TP_MSG_CONTROL,
1364                           "%s: set reorder_timeout=%d\n",
1365                           session->name, session->reorder_timeout);
1366                 break;
1367
1368         default:
1369                 err = -ENOPROTOOPT;
1370                 break;
1371         }
1372
1373         return err;
1374 }
1375
1376 /* Main setsockopt() entry point.
1377  * Does API checks, then calls either the tunnel or session setsockopt
1378  * handler, according to whether the PPPoL2TP socket is a for a regular
1379  * session or the special tunnel type.
1380  */
1381 static int pppol2tp_setsockopt(struct socket *sock, int level, int optname,
1382                                char __user *optval, unsigned int optlen)
1383 {
1384         struct sock *sk = sock->sk;
1385         struct l2tp_session *session;
1386         struct l2tp_tunnel *tunnel;
1387         int val;
1388         int err;
1389
1390         if (level != SOL_PPPOL2TP)
1391                 return -EINVAL;
1392
1393         if (optlen < sizeof(int))
1394                 return -EINVAL;
1395
1396         if (get_user(val, (int __user *)optval))
1397                 return -EFAULT;
1398
1399         err = -ENOTCONN;
1400         if (sk->sk_user_data == NULL)
1401                 goto end;
1402
1403         /* Get session context from the socket */
1404         err = -EBADF;
1405         session = pppol2tp_sock_to_session(sk);
1406         if (session == NULL)
1407                 goto end;
1408
1409         /* Special case: if session_id == 0x0000, treat as operation on tunnel
1410          */
1411         if ((session->session_id == 0) &&
1412             (session->peer_session_id == 0)) {
1413                 tunnel = session->tunnel;
1414                 err = pppol2tp_tunnel_setsockopt(sk, tunnel, optname, val);
1415         } else {
1416                 err = pppol2tp_session_setsockopt(sk, session, optname, val);
1417         }
1418
1419         sock_put(sk);
1420 end:
1421         return err;
1422 }
1423
1424 /* Tunnel getsockopt helper. Called with sock locked.
1425  */
1426 static int pppol2tp_tunnel_getsockopt(struct sock *sk,
1427                                       struct l2tp_tunnel *tunnel,
1428                                       int optname, int *val)
1429 {
1430         int err = 0;
1431
1432         switch (optname) {
1433         case PPPOL2TP_SO_DEBUG:
1434                 *val = tunnel->debug;
1435                 l2tp_info(tunnel, L2TP_MSG_CONTROL, "%s: get debug=%x\n",
1436                           tunnel->name, tunnel->debug);
1437                 break;
1438
1439         default:
1440                 err = -ENOPROTOOPT;
1441                 break;
1442         }
1443
1444         return err;
1445 }
1446
1447 /* Session getsockopt helper. Called with sock locked.
1448  */
1449 static int pppol2tp_session_getsockopt(struct sock *sk,
1450                                        struct l2tp_session *session,
1451                                        int optname, int *val)
1452 {
1453         int err = 0;
1454
1455         switch (optname) {
1456         case PPPOL2TP_SO_RECVSEQ:
1457                 *val = session->recv_seq;
1458                 l2tp_info(session, L2TP_MSG_CONTROL,
1459                           "%s: get recv_seq=%d\n", session->name, *val);
1460                 break;
1461
1462         case PPPOL2TP_SO_SENDSEQ:
1463                 *val = session->send_seq;
1464                 l2tp_info(session, L2TP_MSG_CONTROL,
1465                           "%s: get send_seq=%d\n", session->name, *val);
1466                 break;
1467
1468         case PPPOL2TP_SO_LNSMODE:
1469                 *val = session->lns_mode;
1470                 l2tp_info(session, L2TP_MSG_CONTROL,
1471                           "%s: get lns_mode=%d\n", session->name, *val);
1472                 break;
1473
1474         case PPPOL2TP_SO_DEBUG:
1475                 *val = session->debug;
1476                 l2tp_info(session, L2TP_MSG_CONTROL, "%s: get debug=%d\n",
1477                           session->name, *val);
1478                 break;
1479
1480         case PPPOL2TP_SO_REORDERTO:
1481                 *val = (int) jiffies_to_msecs(session->reorder_timeout);
1482                 l2tp_info(session, L2TP_MSG_CONTROL,
1483                           "%s: get reorder_timeout=%d\n", session->name, *val);
1484                 break;
1485
1486         default:
1487                 err = -ENOPROTOOPT;
1488         }
1489
1490         return err;
1491 }
1492
1493 /* Main getsockopt() entry point.
1494  * Does API checks, then calls either the tunnel or session getsockopt
1495  * handler, according to whether the PPPoX socket is a for a regular session
1496  * or the special tunnel type.
1497  */
1498 static int pppol2tp_getsockopt(struct socket *sock, int level, int optname,
1499                                char __user *optval, int __user *optlen)
1500 {
1501         struct sock *sk = sock->sk;
1502         struct l2tp_session *session;
1503         struct l2tp_tunnel *tunnel;
1504         int val, len;
1505         int err;
1506
1507         if (level != SOL_PPPOL2TP)
1508                 return -EINVAL;
1509
1510         if (get_user(len, optlen))
1511                 return -EFAULT;
1512
1513         len = min_t(unsigned int, len, sizeof(int));
1514
1515         if (len < 0)
1516                 return -EINVAL;
1517
1518         err = -ENOTCONN;
1519         if (sk->sk_user_data == NULL)
1520                 goto end;
1521
1522         /* Get the session context */
1523         err = -EBADF;
1524         session = pppol2tp_sock_to_session(sk);
1525         if (session == NULL)
1526                 goto end;
1527
1528         /* Special case: if session_id == 0x0000, treat as operation on tunnel */
1529         if ((session->session_id == 0) &&
1530             (session->peer_session_id == 0)) {
1531                 tunnel = session->tunnel;
1532                 err = pppol2tp_tunnel_getsockopt(sk, tunnel, optname, &val);
1533                 if (err)
1534                         goto end_put_sess;
1535         } else {
1536                 err = pppol2tp_session_getsockopt(sk, session, optname, &val);
1537                 if (err)
1538                         goto end_put_sess;
1539         }
1540
1541         err = -EFAULT;
1542         if (put_user(len, optlen))
1543                 goto end_put_sess;
1544
1545         if (copy_to_user((void __user *) optval, &val, len))
1546                 goto end_put_sess;
1547
1548         err = 0;
1549
1550 end_put_sess:
1551         sock_put(sk);
1552 end:
1553         return err;
1554 }
1555
1556 /*****************************************************************************
1557  * /proc filesystem for debug
1558  * Since the original pppol2tp driver provided /proc/net/pppol2tp for
1559  * L2TPv2, we dump only L2TPv2 tunnels and sessions here.
1560  *****************************************************************************/
1561
1562 static unsigned int pppol2tp_net_id;
1563
1564 #ifdef CONFIG_PROC_FS
1565
1566 struct pppol2tp_seq_data {
1567         struct seq_net_private p;
1568         int tunnel_idx;                 /* current tunnel */
1569         int session_idx;                /* index of session within current tunnel */
1570         struct l2tp_tunnel *tunnel;
1571         struct l2tp_session *session;   /* NULL means get next tunnel */
1572 };
1573
1574 static void pppol2tp_next_tunnel(struct net *net, struct pppol2tp_seq_data *pd)
1575 {
1576         /* Drop reference taken during previous invocation */
1577         if (pd->tunnel)
1578                 l2tp_tunnel_dec_refcount(pd->tunnel);
1579
1580         for (;;) {
1581                 pd->tunnel = l2tp_tunnel_get_nth(net, pd->tunnel_idx);
1582                 pd->tunnel_idx++;
1583
1584                 /* Only accept L2TPv2 tunnels */
1585                 if (!pd->tunnel || pd->tunnel->version == 2)
1586                         return;
1587
1588                 l2tp_tunnel_dec_refcount(pd->tunnel);
1589         }
1590 }
1591
1592 static void pppol2tp_next_session(struct net *net, struct pppol2tp_seq_data *pd)
1593 {
1594         /* Drop reference taken during previous invocation */
1595         if (pd->session)
1596                 l2tp_session_dec_refcount(pd->session);
1597
1598         pd->session = l2tp_session_get_nth(pd->tunnel, pd->session_idx);
1599         pd->session_idx++;
1600
1601         if (pd->session == NULL) {
1602                 pd->session_idx = 0;
1603                 pppol2tp_next_tunnel(net, pd);
1604         }
1605 }
1606
1607 static void *pppol2tp_seq_start(struct seq_file *m, loff_t *offs)
1608 {
1609         struct pppol2tp_seq_data *pd = SEQ_START_TOKEN;
1610         loff_t pos = *offs;
1611         struct net *net;
1612
1613         if (!pos)
1614                 goto out;
1615
1616         BUG_ON(m->private == NULL);
1617         pd = m->private;
1618         net = seq_file_net(m);
1619
1620         if (pd->tunnel == NULL)
1621                 pppol2tp_next_tunnel(net, pd);
1622         else
1623                 pppol2tp_next_session(net, pd);
1624
1625         /* NULL tunnel and session indicates end of list */
1626         if ((pd->tunnel == NULL) && (pd->session == NULL))
1627                 pd = NULL;
1628
1629 out:
1630         return pd;
1631 }
1632
1633 static void *pppol2tp_seq_next(struct seq_file *m, void *v, loff_t *pos)
1634 {
1635         (*pos)++;
1636         return NULL;
1637 }
1638
1639 static void pppol2tp_seq_stop(struct seq_file *p, void *v)
1640 {
1641         struct pppol2tp_seq_data *pd = v;
1642
1643         if (!pd || pd == SEQ_START_TOKEN)
1644                 return;
1645
1646         /* Drop reference taken by last invocation of pppol2tp_next_session()
1647          * or pppol2tp_next_tunnel().
1648          */
1649         if (pd->session) {
1650                 l2tp_session_dec_refcount(pd->session);
1651                 pd->session = NULL;
1652         }
1653         if (pd->tunnel) {
1654                 l2tp_tunnel_dec_refcount(pd->tunnel);
1655                 pd->tunnel = NULL;
1656         }
1657 }
1658
1659 static void pppol2tp_seq_tunnel_show(struct seq_file *m, void *v)
1660 {
1661         struct l2tp_tunnel *tunnel = v;
1662
1663         seq_printf(m, "\nTUNNEL '%s', %c %d\n",
1664                    tunnel->name,
1665                    (tunnel == tunnel->sock->sk_user_data) ? 'Y' : 'N',
1666                    refcount_read(&tunnel->ref_count) - 1);
1667         seq_printf(m, " %08x %ld/%ld/%ld %ld/%ld/%ld\n",
1668                    tunnel->debug,
1669                    atomic_long_read(&tunnel->stats.tx_packets),
1670                    atomic_long_read(&tunnel->stats.tx_bytes),
1671                    atomic_long_read(&tunnel->stats.tx_errors),
1672                    atomic_long_read(&tunnel->stats.rx_packets),
1673                    atomic_long_read(&tunnel->stats.rx_bytes),
1674                    atomic_long_read(&tunnel->stats.rx_errors));
1675 }
1676
1677 static void pppol2tp_seq_session_show(struct seq_file *m, void *v)
1678 {
1679         struct l2tp_session *session = v;
1680         struct l2tp_tunnel *tunnel = session->tunnel;
1681         unsigned char state;
1682         char user_data_ok;
1683         struct sock *sk;
1684         u32 ip = 0;
1685         u16 port = 0;
1686
1687         if (tunnel->sock) {
1688                 struct inet_sock *inet = inet_sk(tunnel->sock);
1689                 ip = ntohl(inet->inet_saddr);
1690                 port = ntohs(inet->inet_sport);
1691         }
1692
1693         sk = pppol2tp_session_get_sock(session);
1694         if (sk) {
1695                 state = sk->sk_state;
1696                 user_data_ok = (session == sk->sk_user_data) ? 'Y' : 'N';
1697         } else {
1698                 state = 0;
1699                 user_data_ok = 'N';
1700         }
1701
1702         seq_printf(m, "  SESSION '%s' %08X/%d %04X/%04X -> "
1703                    "%04X/%04X %d %c\n",
1704                    session->name, ip, port,
1705                    tunnel->tunnel_id,
1706                    session->session_id,
1707                    tunnel->peer_tunnel_id,
1708                    session->peer_session_id,
1709                    state, user_data_ok);
1710         seq_printf(m, "   %d/%d/%c/%c/%s %08x %u\n",
1711                    session->mtu, session->mru,
1712                    session->recv_seq ? 'R' : '-',
1713                    session->send_seq ? 'S' : '-',
1714                    session->lns_mode ? "LNS" : "LAC",
1715                    session->debug,
1716                    jiffies_to_msecs(session->reorder_timeout));
1717         seq_printf(m, "   %hu/%hu %ld/%ld/%ld %ld/%ld/%ld\n",
1718                    session->nr, session->ns,
1719                    atomic_long_read(&session->stats.tx_packets),
1720                    atomic_long_read(&session->stats.tx_bytes),
1721                    atomic_long_read(&session->stats.tx_errors),
1722                    atomic_long_read(&session->stats.rx_packets),
1723                    atomic_long_read(&session->stats.rx_bytes),
1724                    atomic_long_read(&session->stats.rx_errors));
1725
1726         if (sk) {
1727                 struct pppox_sock *po = pppox_sk(sk);
1728
1729                 seq_printf(m, "   interface %s\n", ppp_dev_name(&po->chan));
1730                 sock_put(sk);
1731         }
1732 }
1733
1734 static int pppol2tp_seq_show(struct seq_file *m, void *v)
1735 {
1736         struct pppol2tp_seq_data *pd = v;
1737
1738         /* display header on line 1 */
1739         if (v == SEQ_START_TOKEN) {
1740                 seq_puts(m, "PPPoL2TP driver info, " PPPOL2TP_DRV_VERSION "\n");
1741                 seq_puts(m, "TUNNEL name, user-data-ok session-count\n");
1742                 seq_puts(m, " debug tx-pkts/bytes/errs rx-pkts/bytes/errs\n");
1743                 seq_puts(m, "  SESSION name, addr/port src-tid/sid "
1744                          "dest-tid/sid state user-data-ok\n");
1745                 seq_puts(m, "   mtu/mru/rcvseq/sendseq/lns debug reorderto\n");
1746                 seq_puts(m, "   nr/ns tx-pkts/bytes/errs rx-pkts/bytes/errs\n");
1747                 goto out;
1748         }
1749
1750         if (!pd->session)
1751                 pppol2tp_seq_tunnel_show(m, pd->tunnel);
1752         else
1753                 pppol2tp_seq_session_show(m, pd->session);
1754
1755 out:
1756         return 0;
1757 }
1758
1759 static const struct seq_operations pppol2tp_seq_ops = {
1760         .start          = pppol2tp_seq_start,
1761         .next           = pppol2tp_seq_next,
1762         .stop           = pppol2tp_seq_stop,
1763         .show           = pppol2tp_seq_show,
1764 };
1765 #endif /* CONFIG_PROC_FS */
1766
1767 /*****************************************************************************
1768  * Network namespace
1769  *****************************************************************************/
1770
1771 static __net_init int pppol2tp_init_net(struct net *net)
1772 {
1773         struct proc_dir_entry *pde;
1774         int err = 0;
1775
1776         pde = proc_create_net("pppol2tp", 0444, net->proc_net,
1777                         &pppol2tp_seq_ops, sizeof(struct pppol2tp_seq_data));
1778         if (!pde) {
1779                 err = -ENOMEM;
1780                 goto out;
1781         }
1782
1783 out:
1784         return err;
1785 }
1786
1787 static __net_exit void pppol2tp_exit_net(struct net *net)
1788 {
1789         remove_proc_entry("pppol2tp", net->proc_net);
1790 }
1791
1792 static struct pernet_operations pppol2tp_net_ops = {
1793         .init = pppol2tp_init_net,
1794         .exit = pppol2tp_exit_net,
1795         .id   = &pppol2tp_net_id,
1796 };
1797
1798 /*****************************************************************************
1799  * Init and cleanup
1800  *****************************************************************************/
1801
1802 static const struct proto_ops pppol2tp_ops = {
1803         .family         = AF_PPPOX,
1804         .owner          = THIS_MODULE,
1805         .release        = pppol2tp_release,
1806         .bind           = sock_no_bind,
1807         .connect        = pppol2tp_connect,
1808         .socketpair     = sock_no_socketpair,
1809         .accept         = sock_no_accept,
1810         .getname        = pppol2tp_getname,
1811         .poll_mask      = datagram_poll_mask,
1812         .listen         = sock_no_listen,
1813         .shutdown       = sock_no_shutdown,
1814         .setsockopt     = pppol2tp_setsockopt,
1815         .getsockopt     = pppol2tp_getsockopt,
1816         .sendmsg        = pppol2tp_sendmsg,
1817         .recvmsg        = pppol2tp_recvmsg,
1818         .mmap           = sock_no_mmap,
1819         .ioctl          = pppox_ioctl,
1820 };
1821
1822 static const struct pppox_proto pppol2tp_proto = {
1823         .create         = pppol2tp_create,
1824         .ioctl          = pppol2tp_ioctl,
1825         .owner          = THIS_MODULE,
1826 };
1827
1828 #ifdef CONFIG_L2TP_V3
1829
1830 static const struct l2tp_nl_cmd_ops pppol2tp_nl_cmd_ops = {
1831         .session_create = pppol2tp_session_create,
1832         .session_delete = l2tp_session_delete,
1833 };
1834
1835 #endif /* CONFIG_L2TP_V3 */
1836
1837 static int __init pppol2tp_init(void)
1838 {
1839         int err;
1840
1841         err = register_pernet_device(&pppol2tp_net_ops);
1842         if (err)
1843                 goto out;
1844
1845         err = proto_register(&pppol2tp_sk_proto, 0);
1846         if (err)
1847                 goto out_unregister_pppol2tp_pernet;
1848
1849         err = register_pppox_proto(PX_PROTO_OL2TP, &pppol2tp_proto);
1850         if (err)
1851                 goto out_unregister_pppol2tp_proto;
1852
1853 #ifdef CONFIG_L2TP_V3
1854         err = l2tp_nl_register_ops(L2TP_PWTYPE_PPP, &pppol2tp_nl_cmd_ops);
1855         if (err)
1856                 goto out_unregister_pppox;
1857 #endif
1858
1859         pr_info("PPPoL2TP kernel driver, %s\n", PPPOL2TP_DRV_VERSION);
1860
1861 out:
1862         return err;
1863
1864 #ifdef CONFIG_L2TP_V3
1865 out_unregister_pppox:
1866         unregister_pppox_proto(PX_PROTO_OL2TP);
1867 #endif
1868 out_unregister_pppol2tp_proto:
1869         proto_unregister(&pppol2tp_sk_proto);
1870 out_unregister_pppol2tp_pernet:
1871         unregister_pernet_device(&pppol2tp_net_ops);
1872         goto out;
1873 }
1874
1875 static void __exit pppol2tp_exit(void)
1876 {
1877 #ifdef CONFIG_L2TP_V3
1878         l2tp_nl_unregister_ops(L2TP_PWTYPE_PPP);
1879 #endif
1880         unregister_pppox_proto(PX_PROTO_OL2TP);
1881         proto_unregister(&pppol2tp_sk_proto);
1882         unregister_pernet_device(&pppol2tp_net_ops);
1883 }
1884
1885 module_init(pppol2tp_init);
1886 module_exit(pppol2tp_exit);
1887
1888 MODULE_AUTHOR("James Chapman <jchapman@katalix.com>");
1889 MODULE_DESCRIPTION("PPP over L2TP over UDP");
1890 MODULE_LICENSE("GPL");
1891 MODULE_VERSION(PPPOL2TP_DRV_VERSION);
1892 MODULE_ALIAS_NET_PF_PROTO(PF_PPPOX, PX_PROTO_OL2TP);
1893 MODULE_ALIAS_L2TP_PWTYPE(7);