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