1
2
3
4
5
6
7
8
9
10
11
12#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
13
14#include <linux/icmp.h>
15#include <linux/module.h>
16#include <linux/skbuff.h>
17#include <linux/random.h>
18#include <linux/socket.h>
19#include <linux/l2tp.h>
20#include <linux/in.h>
21#include <linux/in6.h>
22#include <net/sock.h>
23#include <net/ip.h>
24#include <net/icmp.h>
25#include <net/udp.h>
26#include <net/inet_common.h>
27#include <net/inet_hashtables.h>
28#include <net/inet6_hashtables.h>
29#include <net/tcp_states.h>
30#include <net/protocol.h>
31#include <net/xfrm.h>
32
33#include <net/transp_v6.h>
34#include <net/addrconf.h>
35#include <net/ip6_route.h>
36
37#include "l2tp_core.h"
38
39struct l2tp_ip6_sock {
40
41 struct inet_sock inet;
42
43 u32 conn_id;
44 u32 peer_conn_id;
45
46
47
48 struct ipv6_pinfo inet6;
49};
50
51static DEFINE_RWLOCK(l2tp_ip6_lock);
52static struct hlist_head l2tp_ip6_table;
53static struct hlist_head l2tp_ip6_bind_table;
54
55static inline struct l2tp_ip6_sock *l2tp_ip6_sk(const struct sock *sk)
56{
57 return (struct l2tp_ip6_sock *)sk;
58}
59
60static struct sock *__l2tp_ip6_bind_lookup(const struct net *net,
61 const struct in6_addr *laddr,
62 const struct in6_addr *raddr,
63 int dif, u32 tunnel_id)
64{
65 struct sock *sk;
66
67 sk_for_each_bound(sk, &l2tp_ip6_bind_table) {
68 const struct in6_addr *sk_laddr = inet6_rcv_saddr(sk);
69 const struct in6_addr *sk_raddr = &sk->sk_v6_daddr;
70 const struct l2tp_ip6_sock *l2tp = l2tp_ip6_sk(sk);
71
72 if (!net_eq(sock_net(sk), net))
73 continue;
74
75 if (sk->sk_bound_dev_if && dif && sk->sk_bound_dev_if != dif)
76 continue;
77
78 if (sk_laddr && !ipv6_addr_any(sk_laddr) &&
79 !ipv6_addr_any(laddr) && !ipv6_addr_equal(sk_laddr, laddr))
80 continue;
81
82 if (!ipv6_addr_any(sk_raddr) && raddr &&
83 !ipv6_addr_any(raddr) && !ipv6_addr_equal(sk_raddr, raddr))
84 continue;
85
86 if (l2tp->conn_id != tunnel_id)
87 continue;
88
89 goto found;
90 }
91
92 sk = NULL;
93found:
94 return sk;
95}
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130static int l2tp_ip6_recv(struct sk_buff *skb)
131{
132 struct net *net = dev_net(skb->dev);
133 struct sock *sk;
134 u32 session_id;
135 u32 tunnel_id;
136 unsigned char *ptr, *optr;
137 struct l2tp_session *session;
138 struct l2tp_tunnel *tunnel = NULL;
139 struct ipv6hdr *iph;
140 int length;
141
142 if (!pskb_may_pull(skb, 4))
143 goto discard;
144
145
146 optr = ptr = skb->data;
147 session_id = ntohl(*((__be32 *) ptr));
148 ptr += 4;
149
150
151
152
153
154 if (session_id == 0) {
155 __skb_pull(skb, 4);
156 goto pass_up;
157 }
158
159
160 session = l2tp_session_get(net, NULL, session_id);
161 if (!session)
162 goto discard;
163
164 tunnel = session->tunnel;
165 if (!tunnel)
166 goto discard_sess;
167
168
169 if (tunnel->debug & L2TP_MSG_DATA) {
170 length = min(32u, skb->len);
171 if (!pskb_may_pull(skb, length))
172 goto discard_sess;
173
174
175 optr = ptr = skb->data;
176 ptr += 4;
177 pr_debug("%s: ip recv\n", tunnel->name);
178 print_hex_dump_bytes("", DUMP_PREFIX_OFFSET, ptr, length);
179 }
180
181 l2tp_recv_common(session, skb, ptr, optr, 0, skb->len,
182 tunnel->recv_payload_hook);
183 l2tp_session_dec_refcount(session);
184
185 return 0;
186
187pass_up:
188
189 if (!pskb_may_pull(skb, 12))
190 goto discard;
191
192 if ((skb->data[0] & 0xc0) != 0xc0)
193 goto discard;
194
195 tunnel_id = ntohl(*(__be32 *) &skb->data[4]);
196 iph = ipv6_hdr(skb);
197
198 read_lock_bh(&l2tp_ip6_lock);
199 sk = __l2tp_ip6_bind_lookup(net, &iph->daddr, &iph->saddr,
200 inet6_iif(skb), tunnel_id);
201 if (!sk) {
202 read_unlock_bh(&l2tp_ip6_lock);
203 goto discard;
204 }
205 sock_hold(sk);
206 read_unlock_bh(&l2tp_ip6_lock);
207
208 if (!xfrm6_policy_check(sk, XFRM_POLICY_IN, skb))
209 goto discard_put;
210
211 nf_reset(skb);
212
213 return sk_receive_skb(sk, skb, 1);
214
215discard_sess:
216 l2tp_session_dec_refcount(session);
217 goto discard;
218
219discard_put:
220 sock_put(sk);
221
222discard:
223 kfree_skb(skb);
224 return 0;
225}
226
227static int l2tp_ip6_open(struct sock *sk)
228{
229
230 inet_sk(sk)->inet_num = IPPROTO_L2TP;
231
232 write_lock_bh(&l2tp_ip6_lock);
233 sk_add_node(sk, &l2tp_ip6_table);
234 write_unlock_bh(&l2tp_ip6_lock);
235
236 return 0;
237}
238
239static void l2tp_ip6_close(struct sock *sk, long timeout)
240{
241 write_lock_bh(&l2tp_ip6_lock);
242 hlist_del_init(&sk->sk_bind_node);
243 sk_del_node_init(sk);
244 write_unlock_bh(&l2tp_ip6_lock);
245
246 sk_common_release(sk);
247}
248
249static void l2tp_ip6_destroy_sock(struct sock *sk)
250{
251 struct l2tp_tunnel *tunnel = sk->sk_user_data;
252
253 lock_sock(sk);
254 ip6_flush_pending_frames(sk);
255 release_sock(sk);
256
257 if (tunnel)
258 l2tp_tunnel_delete(tunnel);
259
260 inet6_destroy_sock(sk);
261}
262
263static int l2tp_ip6_bind(struct sock *sk, struct sockaddr *uaddr, int addr_len)
264{
265 struct inet_sock *inet = inet_sk(sk);
266 struct ipv6_pinfo *np = inet6_sk(sk);
267 struct sockaddr_l2tpip6 *addr = (struct sockaddr_l2tpip6 *) uaddr;
268 struct net *net = sock_net(sk);
269 __be32 v4addr = 0;
270 int bound_dev_if;
271 int addr_type;
272 int err;
273
274 if (addr->l2tp_family != AF_INET6)
275 return -EINVAL;
276 if (addr_len < sizeof(*addr))
277 return -EINVAL;
278
279 addr_type = ipv6_addr_type(&addr->l2tp_addr);
280
281
282 if (addr_type == IPV6_ADDR_MAPPED)
283 return -EADDRNOTAVAIL;
284
285
286 if (addr_type & IPV6_ADDR_MULTICAST)
287 return -EADDRNOTAVAIL;
288
289 lock_sock(sk);
290
291 err = -EINVAL;
292 if (!sock_flag(sk, SOCK_ZAPPED))
293 goto out_unlock;
294
295 if (sk->sk_state != TCP_CLOSE)
296 goto out_unlock;
297
298 bound_dev_if = sk->sk_bound_dev_if;
299
300
301 rcu_read_lock();
302 if (addr_type != IPV6_ADDR_ANY) {
303 struct net_device *dev = NULL;
304
305 if (addr_type & IPV6_ADDR_LINKLOCAL) {
306 if (addr->l2tp_scope_id)
307 bound_dev_if = addr->l2tp_scope_id;
308
309
310
311
312 if (!bound_dev_if)
313 goto out_unlock_rcu;
314
315 err = -ENODEV;
316 dev = dev_get_by_index_rcu(sock_net(sk), bound_dev_if);
317 if (!dev)
318 goto out_unlock_rcu;
319 }
320
321
322
323
324 v4addr = LOOPBACK4_IPV6;
325 err = -EADDRNOTAVAIL;
326 if (!ipv6_chk_addr(sock_net(sk), &addr->l2tp_addr, dev, 0))
327 goto out_unlock_rcu;
328 }
329 rcu_read_unlock();
330
331 write_lock_bh(&l2tp_ip6_lock);
332 if (__l2tp_ip6_bind_lookup(net, &addr->l2tp_addr, NULL, bound_dev_if,
333 addr->l2tp_conn_id)) {
334 write_unlock_bh(&l2tp_ip6_lock);
335 err = -EADDRINUSE;
336 goto out_unlock;
337 }
338
339 inet->inet_saddr = v4addr;
340 inet->inet_rcv_saddr = v4addr;
341 sk->sk_bound_dev_if = bound_dev_if;
342 sk->sk_v6_rcv_saddr = addr->l2tp_addr;
343 np->saddr = addr->l2tp_addr;
344
345 l2tp_ip6_sk(sk)->conn_id = addr->l2tp_conn_id;
346
347 sk_add_bind_node(sk, &l2tp_ip6_bind_table);
348 sk_del_node_init(sk);
349 write_unlock_bh(&l2tp_ip6_lock);
350
351 sock_reset_flag(sk, SOCK_ZAPPED);
352 release_sock(sk);
353 return 0;
354
355out_unlock_rcu:
356 rcu_read_unlock();
357out_unlock:
358 release_sock(sk);
359
360 return err;
361}
362
363static int l2tp_ip6_connect(struct sock *sk, struct sockaddr *uaddr,
364 int addr_len)
365{
366 struct sockaddr_l2tpip6 *lsa = (struct sockaddr_l2tpip6 *) uaddr;
367 struct sockaddr_in6 *usin = (struct sockaddr_in6 *) uaddr;
368 struct in6_addr *daddr;
369 int addr_type;
370 int rc;
371
372 if (addr_len < sizeof(*lsa))
373 return -EINVAL;
374
375 if (usin->sin6_family != AF_INET6)
376 return -EINVAL;
377
378 addr_type = ipv6_addr_type(&usin->sin6_addr);
379 if (addr_type & IPV6_ADDR_MULTICAST)
380 return -EINVAL;
381
382 if (addr_type & IPV6_ADDR_MAPPED) {
383 daddr = &usin->sin6_addr;
384 if (ipv4_is_multicast(daddr->s6_addr32[3]))
385 return -EINVAL;
386 }
387
388 lock_sock(sk);
389
390
391 if (sock_flag(sk, SOCK_ZAPPED)) {
392 rc = -EINVAL;
393 goto out_sk;
394 }
395
396 rc = __ip6_datagram_connect(sk, uaddr, addr_len);
397 if (rc < 0)
398 goto out_sk;
399
400 l2tp_ip6_sk(sk)->peer_conn_id = lsa->l2tp_conn_id;
401
402 write_lock_bh(&l2tp_ip6_lock);
403 hlist_del_init(&sk->sk_bind_node);
404 sk_add_bind_node(sk, &l2tp_ip6_bind_table);
405 write_unlock_bh(&l2tp_ip6_lock);
406
407out_sk:
408 release_sock(sk);
409
410 return rc;
411}
412
413static int l2tp_ip6_disconnect(struct sock *sk, int flags)
414{
415 if (sock_flag(sk, SOCK_ZAPPED))
416 return 0;
417
418 return __udp_disconnect(sk, flags);
419}
420
421static int l2tp_ip6_getname(struct socket *sock, struct sockaddr *uaddr,
422 int peer)
423{
424 struct sockaddr_l2tpip6 *lsa = (struct sockaddr_l2tpip6 *)uaddr;
425 struct sock *sk = sock->sk;
426 struct ipv6_pinfo *np = inet6_sk(sk);
427 struct l2tp_ip6_sock *lsk = l2tp_ip6_sk(sk);
428
429 lsa->l2tp_family = AF_INET6;
430 lsa->l2tp_flowinfo = 0;
431 lsa->l2tp_scope_id = 0;
432 lsa->l2tp_unused = 0;
433 if (peer) {
434 if (!lsk->peer_conn_id)
435 return -ENOTCONN;
436 lsa->l2tp_conn_id = lsk->peer_conn_id;
437 lsa->l2tp_addr = sk->sk_v6_daddr;
438 if (np->sndflow)
439 lsa->l2tp_flowinfo = np->flow_label;
440 } else {
441 if (ipv6_addr_any(&sk->sk_v6_rcv_saddr))
442 lsa->l2tp_addr = np->saddr;
443 else
444 lsa->l2tp_addr = sk->sk_v6_rcv_saddr;
445
446 lsa->l2tp_conn_id = lsk->conn_id;
447 }
448 if (ipv6_addr_type(&lsa->l2tp_addr) & IPV6_ADDR_LINKLOCAL)
449 lsa->l2tp_scope_id = sk->sk_bound_dev_if;
450 return sizeof(*lsa);
451}
452
453static int l2tp_ip6_backlog_recv(struct sock *sk, struct sk_buff *skb)
454{
455 int rc;
456
457
458 rc = sock_queue_rcv_skb(sk, skb);
459 if (rc < 0)
460 goto drop;
461
462 return 0;
463
464drop:
465 IP_INC_STATS(sock_net(sk), IPSTATS_MIB_INDISCARDS);
466 kfree_skb(skb);
467 return -1;
468}
469
470static int l2tp_ip6_push_pending_frames(struct sock *sk)
471{
472 struct sk_buff *skb;
473 __be32 *transhdr = NULL;
474 int err = 0;
475
476 skb = skb_peek(&sk->sk_write_queue);
477 if (skb == NULL)
478 goto out;
479
480 transhdr = (__be32 *)skb_transport_header(skb);
481 *transhdr = 0;
482
483 err = ip6_push_pending_frames(sk);
484
485out:
486 return err;
487}
488
489
490
491
492static int l2tp_ip6_sendmsg(struct sock *sk, struct msghdr *msg, size_t len)
493{
494 struct ipv6_txoptions opt_space;
495 DECLARE_SOCKADDR(struct sockaddr_l2tpip6 *, lsa, msg->msg_name);
496 struct in6_addr *daddr, *final_p, final;
497 struct ipv6_pinfo *np = inet6_sk(sk);
498 struct ipv6_txoptions *opt_to_free = NULL;
499 struct ipv6_txoptions *opt = NULL;
500 struct ip6_flowlabel *flowlabel = NULL;
501 struct dst_entry *dst = NULL;
502 struct flowi6 fl6;
503 struct sockcm_cookie sockc_unused = {0};
504 struct ipcm6_cookie ipc6;
505 int addr_len = msg->msg_namelen;
506 int transhdrlen = 4;
507 int ulen = len + transhdrlen;
508 int err;
509
510
511
512
513 if (len > INT_MAX)
514 return -EMSGSIZE;
515
516
517 if (msg->msg_flags & MSG_OOB)
518 return -EOPNOTSUPP;
519
520
521
522
523 memset(&fl6, 0, sizeof(fl6));
524
525 fl6.flowi6_mark = sk->sk_mark;
526 fl6.flowi6_uid = sk->sk_uid;
527
528 ipc6.hlimit = -1;
529 ipc6.tclass = -1;
530 ipc6.dontfrag = -1;
531
532 if (lsa) {
533 if (addr_len < SIN6_LEN_RFC2133)
534 return -EINVAL;
535
536 if (lsa->l2tp_family && lsa->l2tp_family != AF_INET6)
537 return -EAFNOSUPPORT;
538
539 daddr = &lsa->l2tp_addr;
540 if (np->sndflow) {
541 fl6.flowlabel = lsa->l2tp_flowinfo & IPV6_FLOWINFO_MASK;
542 if (fl6.flowlabel&IPV6_FLOWLABEL_MASK) {
543 flowlabel = fl6_sock_lookup(sk, fl6.flowlabel);
544 if (flowlabel == NULL)
545 return -EINVAL;
546 }
547 }
548
549
550
551
552
553 if (sk->sk_state == TCP_ESTABLISHED &&
554 ipv6_addr_equal(daddr, &sk->sk_v6_daddr))
555 daddr = &sk->sk_v6_daddr;
556
557 if (addr_len >= sizeof(struct sockaddr_in6) &&
558 lsa->l2tp_scope_id &&
559 ipv6_addr_type(daddr) & IPV6_ADDR_LINKLOCAL)
560 fl6.flowi6_oif = lsa->l2tp_scope_id;
561 } else {
562 if (sk->sk_state != TCP_ESTABLISHED)
563 return -EDESTADDRREQ;
564
565 daddr = &sk->sk_v6_daddr;
566 fl6.flowlabel = np->flow_label;
567 }
568
569 if (fl6.flowi6_oif == 0)
570 fl6.flowi6_oif = sk->sk_bound_dev_if;
571
572 if (msg->msg_controllen) {
573 opt = &opt_space;
574 memset(opt, 0, sizeof(struct ipv6_txoptions));
575 opt->tot_len = sizeof(struct ipv6_txoptions);
576 ipc6.opt = opt;
577
578 err = ip6_datagram_send_ctl(sock_net(sk), sk, msg, &fl6, &ipc6,
579 &sockc_unused);
580 if (err < 0) {
581 fl6_sock_release(flowlabel);
582 return err;
583 }
584 if ((fl6.flowlabel & IPV6_FLOWLABEL_MASK) && !flowlabel) {
585 flowlabel = fl6_sock_lookup(sk, fl6.flowlabel);
586 if (flowlabel == NULL)
587 return -EINVAL;
588 }
589 if (!(opt->opt_nflen|opt->opt_flen))
590 opt = NULL;
591 }
592
593 if (!opt) {
594 opt = txopt_get(np);
595 opt_to_free = opt;
596 }
597 if (flowlabel)
598 opt = fl6_merge_options(&opt_space, flowlabel, opt);
599 opt = ipv6_fixup_options(&opt_space, opt);
600 ipc6.opt = opt;
601
602 fl6.flowi6_proto = sk->sk_protocol;
603 if (!ipv6_addr_any(daddr))
604 fl6.daddr = *daddr;
605 else
606 fl6.daddr.s6_addr[15] = 0x1;
607 if (ipv6_addr_any(&fl6.saddr) && !ipv6_addr_any(&np->saddr))
608 fl6.saddr = np->saddr;
609
610 final_p = fl6_update_dst(&fl6, opt, &final);
611
612 if (!fl6.flowi6_oif && ipv6_addr_is_multicast(&fl6.daddr))
613 fl6.flowi6_oif = np->mcast_oif;
614 else if (!fl6.flowi6_oif)
615 fl6.flowi6_oif = np->ucast_oif;
616
617 security_sk_classify_flow(sk, flowi6_to_flowi(&fl6));
618
619 if (ipc6.tclass < 0)
620 ipc6.tclass = np->tclass;
621
622 fl6.flowlabel = ip6_make_flowinfo(ipc6.tclass, fl6.flowlabel);
623
624 dst = ip6_dst_lookup_flow(sk, &fl6, final_p);
625 if (IS_ERR(dst)) {
626 err = PTR_ERR(dst);
627 goto out;
628 }
629
630 if (ipc6.hlimit < 0)
631 ipc6.hlimit = ip6_sk_dst_hoplimit(np, &fl6, dst);
632
633 if (ipc6.dontfrag < 0)
634 ipc6.dontfrag = np->dontfrag;
635
636 if (msg->msg_flags & MSG_CONFIRM)
637 goto do_confirm;
638
639back_from_confirm:
640 lock_sock(sk);
641 err = ip6_append_data(sk, ip_generic_getfrag, msg,
642 ulen, transhdrlen, &ipc6,
643 &fl6, (struct rt6_info *)dst,
644 msg->msg_flags, &sockc_unused);
645 if (err)
646 ip6_flush_pending_frames(sk);
647 else if (!(msg->msg_flags & MSG_MORE))
648 err = l2tp_ip6_push_pending_frames(sk);
649 release_sock(sk);
650done:
651 dst_release(dst);
652out:
653 fl6_sock_release(flowlabel);
654 txopt_put(opt_to_free);
655
656 return err < 0 ? err : len;
657
658do_confirm:
659 if (msg->msg_flags & MSG_PROBE)
660 dst_confirm_neigh(dst, &fl6.daddr);
661 if (!(msg->msg_flags & MSG_PROBE) || len)
662 goto back_from_confirm;
663 err = 0;
664 goto done;
665}
666
667static int l2tp_ip6_recvmsg(struct sock *sk, struct msghdr *msg, size_t len,
668 int noblock, int flags, int *addr_len)
669{
670 struct ipv6_pinfo *np = inet6_sk(sk);
671 DECLARE_SOCKADDR(struct sockaddr_l2tpip6 *, lsa, msg->msg_name);
672 size_t copied = 0;
673 int err = -EOPNOTSUPP;
674 struct sk_buff *skb;
675
676 if (flags & MSG_OOB)
677 goto out;
678
679 if (addr_len)
680 *addr_len = sizeof(*lsa);
681
682 if (flags & MSG_ERRQUEUE)
683 return ipv6_recv_error(sk, msg, len, addr_len);
684
685 skb = skb_recv_datagram(sk, flags, noblock, &err);
686 if (!skb)
687 goto out;
688
689 copied = skb->len;
690 if (len < copied) {
691 msg->msg_flags |= MSG_TRUNC;
692 copied = len;
693 }
694
695 err = skb_copy_datagram_msg(skb, 0, msg, copied);
696 if (err)
697 goto done;
698
699 sock_recv_timestamp(msg, sk, skb);
700
701
702 if (lsa) {
703 lsa->l2tp_family = AF_INET6;
704 lsa->l2tp_unused = 0;
705 lsa->l2tp_addr = ipv6_hdr(skb)->saddr;
706 lsa->l2tp_flowinfo = 0;
707 lsa->l2tp_scope_id = 0;
708 lsa->l2tp_conn_id = 0;
709 if (ipv6_addr_type(&lsa->l2tp_addr) & IPV6_ADDR_LINKLOCAL)
710 lsa->l2tp_scope_id = inet6_iif(skb);
711 }
712
713 if (np->rxopt.all)
714 ip6_datagram_recv_ctl(sk, msg, skb);
715
716 if (flags & MSG_TRUNC)
717 copied = skb->len;
718done:
719 skb_free_datagram(sk, skb);
720out:
721 return err ? err : copied;
722}
723
724static struct proto l2tp_ip6_prot = {
725 .name = "L2TP/IPv6",
726 .owner = THIS_MODULE,
727 .init = l2tp_ip6_open,
728 .close = l2tp_ip6_close,
729 .bind = l2tp_ip6_bind,
730 .connect = l2tp_ip6_connect,
731 .disconnect = l2tp_ip6_disconnect,
732 .ioctl = l2tp_ioctl,
733 .destroy = l2tp_ip6_destroy_sock,
734 .setsockopt = ipv6_setsockopt,
735 .getsockopt = ipv6_getsockopt,
736 .sendmsg = l2tp_ip6_sendmsg,
737 .recvmsg = l2tp_ip6_recvmsg,
738 .backlog_rcv = l2tp_ip6_backlog_recv,
739 .hash = inet6_hash,
740 .unhash = inet_unhash,
741 .obj_size = sizeof(struct l2tp_ip6_sock),
742#ifdef CONFIG_COMPAT
743 .compat_setsockopt = compat_ipv6_setsockopt,
744 .compat_getsockopt = compat_ipv6_getsockopt,
745#endif
746};
747
748static const struct proto_ops l2tp_ip6_ops = {
749 .family = PF_INET6,
750 .owner = THIS_MODULE,
751 .release = inet6_release,
752 .bind = inet6_bind,
753 .connect = inet_dgram_connect,
754 .socketpair = sock_no_socketpair,
755 .accept = sock_no_accept,
756 .getname = l2tp_ip6_getname,
757 .poll = datagram_poll,
758 .ioctl = inet6_ioctl,
759 .listen = sock_no_listen,
760 .shutdown = inet_shutdown,
761 .setsockopt = sock_common_setsockopt,
762 .getsockopt = sock_common_getsockopt,
763 .sendmsg = inet_sendmsg,
764 .recvmsg = sock_common_recvmsg,
765 .mmap = sock_no_mmap,
766 .sendpage = sock_no_sendpage,
767#ifdef CONFIG_COMPAT
768 .compat_setsockopt = compat_sock_common_setsockopt,
769 .compat_getsockopt = compat_sock_common_getsockopt,
770#endif
771};
772
773static struct inet_protosw l2tp_ip6_protosw = {
774 .type = SOCK_DGRAM,
775 .protocol = IPPROTO_L2TP,
776 .prot = &l2tp_ip6_prot,
777 .ops = &l2tp_ip6_ops,
778};
779
780static struct inet6_protocol l2tp_ip6_protocol __read_mostly = {
781 .handler = l2tp_ip6_recv,
782};
783
784static int __init l2tp_ip6_init(void)
785{
786 int err;
787
788 pr_info("L2TP IP encapsulation support for IPv6 (L2TPv3)\n");
789
790 err = proto_register(&l2tp_ip6_prot, 1);
791 if (err != 0)
792 goto out;
793
794 err = inet6_add_protocol(&l2tp_ip6_protocol, IPPROTO_L2TP);
795 if (err)
796 goto out1;
797
798 inet6_register_protosw(&l2tp_ip6_protosw);
799 return 0;
800
801out1:
802 proto_unregister(&l2tp_ip6_prot);
803out:
804 return err;
805}
806
807static void __exit l2tp_ip6_exit(void)
808{
809 inet6_unregister_protosw(&l2tp_ip6_protosw);
810 inet6_del_protocol(&l2tp_ip6_protocol, IPPROTO_L2TP);
811 proto_unregister(&l2tp_ip6_prot);
812}
813
814module_init(l2tp_ip6_init);
815module_exit(l2tp_ip6_exit);
816
817MODULE_LICENSE("GPL");
818MODULE_AUTHOR("Chris Elston <celston@katalix.com>");
819MODULE_DESCRIPTION("L2TP IP encapsulation for IPv6");
820MODULE_VERSION("1.0");
821
822
823
824
825MODULE_ALIAS_NET_PF_PROTO_TYPE(PF_INET6, 2, IPPROTO_L2TP);
826MODULE_ALIAS_NET_PF_PROTO(PF_INET6, IPPROTO_L2TP);
827