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 *uaddr_len, 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 *uaddr_len = sizeof(*lsa);
451 return 0;
452}
453
454static int l2tp_ip6_backlog_recv(struct sock *sk, struct sk_buff *skb)
455{
456 int rc;
457
458
459 rc = sock_queue_rcv_skb(sk, skb);
460 if (rc < 0)
461 goto drop;
462
463 return 0;
464
465drop:
466 IP_INC_STATS(sock_net(sk), IPSTATS_MIB_INDISCARDS);
467 kfree_skb(skb);
468 return -1;
469}
470
471static int l2tp_ip6_push_pending_frames(struct sock *sk)
472{
473 struct sk_buff *skb;
474 __be32 *transhdr = NULL;
475 int err = 0;
476
477 skb = skb_peek(&sk->sk_write_queue);
478 if (skb == NULL)
479 goto out;
480
481 transhdr = (__be32 *)skb_transport_header(skb);
482 *transhdr = 0;
483
484 err = ip6_push_pending_frames(sk);
485
486out:
487 return err;
488}
489
490
491
492
493static int l2tp_ip6_sendmsg(struct sock *sk, struct msghdr *msg, size_t len)
494{
495 struct ipv6_txoptions opt_space;
496 DECLARE_SOCKADDR(struct sockaddr_l2tpip6 *, lsa, msg->msg_name);
497 struct in6_addr *daddr, *final_p, final;
498 struct ipv6_pinfo *np = inet6_sk(sk);
499 struct ipv6_txoptions *opt_to_free = NULL;
500 struct ipv6_txoptions *opt = NULL;
501 struct ip6_flowlabel *flowlabel = NULL;
502 struct dst_entry *dst = NULL;
503 struct flowi6 fl6;
504 struct sockcm_cookie sockc_unused = {0};
505 struct ipcm6_cookie ipc6;
506 int addr_len = msg->msg_namelen;
507 int transhdrlen = 4;
508 int ulen = len + transhdrlen;
509 int err;
510
511
512
513
514 if (len > INT_MAX)
515 return -EMSGSIZE;
516
517
518 if (msg->msg_flags & MSG_OOB)
519 return -EOPNOTSUPP;
520
521
522
523
524 memset(&fl6, 0, sizeof(fl6));
525
526 fl6.flowi6_mark = sk->sk_mark;
527 fl6.flowi6_uid = sk->sk_uid;
528
529 ipc6.hlimit = -1;
530 ipc6.tclass = -1;
531 ipc6.dontfrag = -1;
532
533 if (lsa) {
534 if (addr_len < SIN6_LEN_RFC2133)
535 return -EINVAL;
536
537 if (lsa->l2tp_family && lsa->l2tp_family != AF_INET6)
538 return -EAFNOSUPPORT;
539
540 daddr = &lsa->l2tp_addr;
541 if (np->sndflow) {
542 fl6.flowlabel = lsa->l2tp_flowinfo & IPV6_FLOWINFO_MASK;
543 if (fl6.flowlabel&IPV6_FLOWLABEL_MASK) {
544 flowlabel = fl6_sock_lookup(sk, fl6.flowlabel);
545 if (flowlabel == NULL)
546 return -EINVAL;
547 }
548 }
549
550
551
552
553
554 if (sk->sk_state == TCP_ESTABLISHED &&
555 ipv6_addr_equal(daddr, &sk->sk_v6_daddr))
556 daddr = &sk->sk_v6_daddr;
557
558 if (addr_len >= sizeof(struct sockaddr_in6) &&
559 lsa->l2tp_scope_id &&
560 ipv6_addr_type(daddr) & IPV6_ADDR_LINKLOCAL)
561 fl6.flowi6_oif = lsa->l2tp_scope_id;
562 } else {
563 if (sk->sk_state != TCP_ESTABLISHED)
564 return -EDESTADDRREQ;
565
566 daddr = &sk->sk_v6_daddr;
567 fl6.flowlabel = np->flow_label;
568 }
569
570 if (fl6.flowi6_oif == 0)
571 fl6.flowi6_oif = sk->sk_bound_dev_if;
572
573 if (msg->msg_controllen) {
574 opt = &opt_space;
575 memset(opt, 0, sizeof(struct ipv6_txoptions));
576 opt->tot_len = sizeof(struct ipv6_txoptions);
577 ipc6.opt = opt;
578
579 err = ip6_datagram_send_ctl(sock_net(sk), sk, msg, &fl6, &ipc6,
580 &sockc_unused);
581 if (err < 0) {
582 fl6_sock_release(flowlabel);
583 return err;
584 }
585 if ((fl6.flowlabel & IPV6_FLOWLABEL_MASK) && !flowlabel) {
586 flowlabel = fl6_sock_lookup(sk, fl6.flowlabel);
587 if (flowlabel == NULL)
588 return -EINVAL;
589 }
590 if (!(opt->opt_nflen|opt->opt_flen))
591 opt = NULL;
592 }
593
594 if (!opt) {
595 opt = txopt_get(np);
596 opt_to_free = opt;
597 }
598 if (flowlabel)
599 opt = fl6_merge_options(&opt_space, flowlabel, opt);
600 opt = ipv6_fixup_options(&opt_space, opt);
601 ipc6.opt = opt;
602
603 fl6.flowi6_proto = sk->sk_protocol;
604 if (!ipv6_addr_any(daddr))
605 fl6.daddr = *daddr;
606 else
607 fl6.daddr.s6_addr[15] = 0x1;
608 if (ipv6_addr_any(&fl6.saddr) && !ipv6_addr_any(&np->saddr))
609 fl6.saddr = np->saddr;
610
611 final_p = fl6_update_dst(&fl6, opt, &final);
612
613 if (!fl6.flowi6_oif && ipv6_addr_is_multicast(&fl6.daddr))
614 fl6.flowi6_oif = np->mcast_oif;
615 else if (!fl6.flowi6_oif)
616 fl6.flowi6_oif = np->ucast_oif;
617
618 security_sk_classify_flow(sk, flowi6_to_flowi(&fl6));
619
620 if (ipc6.tclass < 0)
621 ipc6.tclass = np->tclass;
622
623 fl6.flowlabel = ip6_make_flowinfo(ipc6.tclass, fl6.flowlabel);
624
625 dst = ip6_dst_lookup_flow(sk, &fl6, final_p);
626 if (IS_ERR(dst)) {
627 err = PTR_ERR(dst);
628 goto out;
629 }
630
631 if (ipc6.hlimit < 0)
632 ipc6.hlimit = ip6_sk_dst_hoplimit(np, &fl6, dst);
633
634 if (ipc6.dontfrag < 0)
635 ipc6.dontfrag = np->dontfrag;
636
637 if (msg->msg_flags & MSG_CONFIRM)
638 goto do_confirm;
639
640back_from_confirm:
641 lock_sock(sk);
642 err = ip6_append_data(sk, ip_generic_getfrag, msg,
643 ulen, transhdrlen, &ipc6,
644 &fl6, (struct rt6_info *)dst,
645 msg->msg_flags, &sockc_unused);
646 if (err)
647 ip6_flush_pending_frames(sk);
648 else if (!(msg->msg_flags & MSG_MORE))
649 err = l2tp_ip6_push_pending_frames(sk);
650 release_sock(sk);
651done:
652 dst_release(dst);
653out:
654 fl6_sock_release(flowlabel);
655 txopt_put(opt_to_free);
656
657 return err < 0 ? err : len;
658
659do_confirm:
660 if (msg->msg_flags & MSG_PROBE)
661 dst_confirm_neigh(dst, &fl6.daddr);
662 if (!(msg->msg_flags & MSG_PROBE) || len)
663 goto back_from_confirm;
664 err = 0;
665 goto done;
666}
667
668static int l2tp_ip6_recvmsg(struct sock *sk, struct msghdr *msg, size_t len,
669 int noblock, int flags, int *addr_len)
670{
671 struct ipv6_pinfo *np = inet6_sk(sk);
672 DECLARE_SOCKADDR(struct sockaddr_l2tpip6 *, lsa, msg->msg_name);
673 size_t copied = 0;
674 int err = -EOPNOTSUPP;
675 struct sk_buff *skb;
676
677 if (flags & MSG_OOB)
678 goto out;
679
680 if (addr_len)
681 *addr_len = sizeof(*lsa);
682
683 if (flags & MSG_ERRQUEUE)
684 return ipv6_recv_error(sk, msg, len, addr_len);
685
686 skb = skb_recv_datagram(sk, flags, noblock, &err);
687 if (!skb)
688 goto out;
689
690 copied = skb->len;
691 if (len < copied) {
692 msg->msg_flags |= MSG_TRUNC;
693 copied = len;
694 }
695
696 err = skb_copy_datagram_msg(skb, 0, msg, copied);
697 if (err)
698 goto done;
699
700 sock_recv_timestamp(msg, sk, skb);
701
702
703 if (lsa) {
704 lsa->l2tp_family = AF_INET6;
705 lsa->l2tp_unused = 0;
706 lsa->l2tp_addr = ipv6_hdr(skb)->saddr;
707 lsa->l2tp_flowinfo = 0;
708 lsa->l2tp_scope_id = 0;
709 lsa->l2tp_conn_id = 0;
710 if (ipv6_addr_type(&lsa->l2tp_addr) & IPV6_ADDR_LINKLOCAL)
711 lsa->l2tp_scope_id = inet6_iif(skb);
712 }
713
714 if (np->rxopt.all)
715 ip6_datagram_recv_ctl(sk, msg, skb);
716
717 if (flags & MSG_TRUNC)
718 copied = skb->len;
719done:
720 skb_free_datagram(sk, skb);
721out:
722 return err ? err : copied;
723}
724
725static struct proto l2tp_ip6_prot = {
726 .name = "L2TP/IPv6",
727 .owner = THIS_MODULE,
728 .init = l2tp_ip6_open,
729 .close = l2tp_ip6_close,
730 .bind = l2tp_ip6_bind,
731 .connect = l2tp_ip6_connect,
732 .disconnect = l2tp_ip6_disconnect,
733 .ioctl = l2tp_ioctl,
734 .destroy = l2tp_ip6_destroy_sock,
735 .setsockopt = ipv6_setsockopt,
736 .getsockopt = ipv6_getsockopt,
737 .sendmsg = l2tp_ip6_sendmsg,
738 .recvmsg = l2tp_ip6_recvmsg,
739 .backlog_rcv = l2tp_ip6_backlog_recv,
740 .hash = inet6_hash,
741 .unhash = inet_unhash,
742 .obj_size = sizeof(struct l2tp_ip6_sock),
743#ifdef CONFIG_COMPAT
744 .compat_setsockopt = compat_ipv6_setsockopt,
745 .compat_getsockopt = compat_ipv6_getsockopt,
746#endif
747};
748
749static const struct proto_ops l2tp_ip6_ops = {
750 .family = PF_INET6,
751 .owner = THIS_MODULE,
752 .release = inet6_release,
753 .bind = inet6_bind,
754 .connect = inet_dgram_connect,
755 .socketpair = sock_no_socketpair,
756 .accept = sock_no_accept,
757 .getname = l2tp_ip6_getname,
758 .poll = datagram_poll,
759 .ioctl = inet6_ioctl,
760 .listen = sock_no_listen,
761 .shutdown = inet_shutdown,
762 .setsockopt = sock_common_setsockopt,
763 .getsockopt = sock_common_getsockopt,
764 .sendmsg = inet_sendmsg,
765 .recvmsg = sock_common_recvmsg,
766 .mmap = sock_no_mmap,
767 .sendpage = sock_no_sendpage,
768#ifdef CONFIG_COMPAT
769 .compat_setsockopt = compat_sock_common_setsockopt,
770 .compat_getsockopt = compat_sock_common_getsockopt,
771#endif
772};
773
774static struct inet_protosw l2tp_ip6_protosw = {
775 .type = SOCK_DGRAM,
776 .protocol = IPPROTO_L2TP,
777 .prot = &l2tp_ip6_prot,
778 .ops = &l2tp_ip6_ops,
779};
780
781static struct inet6_protocol l2tp_ip6_protocol __read_mostly = {
782 .handler = l2tp_ip6_recv,
783};
784
785static int __init l2tp_ip6_init(void)
786{
787 int err;
788
789 pr_info("L2TP IP encapsulation support for IPv6 (L2TPv3)\n");
790
791 err = proto_register(&l2tp_ip6_prot, 1);
792 if (err != 0)
793 goto out;
794
795 err = inet6_add_protocol(&l2tp_ip6_protocol, IPPROTO_L2TP);
796 if (err)
797 goto out1;
798
799 inet6_register_protosw(&l2tp_ip6_protosw);
800 return 0;
801
802out1:
803 proto_unregister(&l2tp_ip6_prot);
804out:
805 return err;
806}
807
808static void __exit l2tp_ip6_exit(void)
809{
810 inet6_unregister_protosw(&l2tp_ip6_protosw);
811 inet6_del_protocol(&l2tp_ip6_protocol, IPPROTO_L2TP);
812 proto_unregister(&l2tp_ip6_prot);
813}
814
815module_init(l2tp_ip6_init);
816module_exit(l2tp_ip6_exit);
817
818MODULE_LICENSE("GPL");
819MODULE_AUTHOR("Chris Elston <celston@katalix.com>");
820MODULE_DESCRIPTION("L2TP IP encapsulation for IPv6");
821MODULE_VERSION("1.0");
822
823
824
825
826MODULE_ALIAS_NET_PF_PROTO_TYPE(PF_INET6, 2, IPPROTO_L2TP);
827MODULE_ALIAS_NET_PF_PROTO(PF_INET6, IPPROTO_L2TP);
828