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