net: replace ipfragok with skb->local_df
[linux-3.10.git] / net / l2tp / l2tp_ip.c
1 /*
2  * L2TPv3 IP encapsulation support
3  *
4  * Copyright (c) 2008,2009,2010 Katalix Systems Ltd
5  *
6  *      This program is free software; you can redistribute it and/or
7  *      modify it under the terms of the GNU General Public License
8  *      as published by the Free Software Foundation; either version
9  *      2 of the License, or (at your option) any later version.
10  */
11
12 #include <linux/icmp.h>
13 #include <linux/module.h>
14 #include <linux/skbuff.h>
15 #include <linux/random.h>
16 #include <linux/socket.h>
17 #include <linux/l2tp.h>
18 #include <linux/in.h>
19 #include <net/sock.h>
20 #include <net/ip.h>
21 #include <net/icmp.h>
22 #include <net/udp.h>
23 #include <net/inet_common.h>
24 #include <net/inet_hashtables.h>
25 #include <net/tcp_states.h>
26 #include <net/protocol.h>
27 #include <net/xfrm.h>
28
29 #include "l2tp_core.h"
30
31 struct l2tp_ip_sock {
32         /* inet_sock has to be the first member of l2tp_ip_sock */
33         struct inet_sock        inet;
34
35         __u32                   conn_id;
36         __u32                   peer_conn_id;
37
38         __u64                   tx_packets;
39         __u64                   tx_bytes;
40         __u64                   tx_errors;
41         __u64                   rx_packets;
42         __u64                   rx_bytes;
43         __u64                   rx_errors;
44 };
45
46 static DEFINE_RWLOCK(l2tp_ip_lock);
47 static struct hlist_head l2tp_ip_table;
48 static struct hlist_head l2tp_ip_bind_table;
49
50 static inline struct l2tp_ip_sock *l2tp_ip_sk(const struct sock *sk)
51 {
52         return (struct l2tp_ip_sock *)sk;
53 }
54
55 static struct sock *__l2tp_ip_bind_lookup(struct net *net, __be32 laddr, int dif, u32 tunnel_id)
56 {
57         struct hlist_node *node;
58         struct sock *sk;
59
60         sk_for_each_bound(sk, node, &l2tp_ip_bind_table) {
61                 struct inet_sock *inet = inet_sk(sk);
62                 struct l2tp_ip_sock *l2tp = l2tp_ip_sk(sk);
63
64                 if (l2tp == NULL)
65                         continue;
66
67                 if ((l2tp->conn_id == tunnel_id) &&
68 #ifdef CONFIG_NET_NS
69                     (sk->sk_net == net) &&
70 #endif
71                     !(inet->inet_rcv_saddr && inet->inet_rcv_saddr != laddr) &&
72                     !(sk->sk_bound_dev_if && sk->sk_bound_dev_if != dif))
73                         goto found;
74         }
75
76         sk = NULL;
77 found:
78         return sk;
79 }
80
81 static inline struct sock *l2tp_ip_bind_lookup(struct net *net, __be32 laddr, int dif, u32 tunnel_id)
82 {
83         struct sock *sk = __l2tp_ip_bind_lookup(net, laddr, dif, tunnel_id);
84         if (sk)
85                 sock_hold(sk);
86
87         return sk;
88 }
89
90 /* When processing receive frames, there are two cases to
91  * consider. Data frames consist of a non-zero session-id and an
92  * optional cookie. Control frames consist of a regular L2TP header
93  * preceded by 32-bits of zeros.
94  *
95  * L2TPv3 Session Header Over IP
96  *
97  *  0                   1                   2                   3
98  *  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
99  * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
100  * |                           Session ID                          |
101  * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
102  * |               Cookie (optional, maximum 64 bits)...
103  * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
104  *                                                                 |
105  * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
106  *
107  * L2TPv3 Control Message Header Over IP
108  *
109  *  0                   1                   2                   3
110  *  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
111  * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
112  * |                      (32 bits of zeros)                       |
113  * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
114  * |T|L|x|x|S|x|x|x|x|x|x|x|  Ver  |             Length            |
115  * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
116  * |                     Control Connection ID                     |
117  * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
118  * |               Ns              |               Nr              |
119  * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
120  *
121  * All control frames are passed to userspace.
122  */
123 static int l2tp_ip_recv(struct sk_buff *skb)
124 {
125         struct sock *sk;
126         u32 session_id;
127         u32 tunnel_id;
128         unsigned char *ptr, *optr;
129         struct l2tp_session *session;
130         struct l2tp_tunnel *tunnel = NULL;
131         int length;
132         int offset;
133
134         /* Point to L2TP header */
135         optr = ptr = skb->data;
136
137         if (!pskb_may_pull(skb, 4))
138                 goto discard;
139
140         session_id = ntohl(*((__be32 *) ptr));
141         ptr += 4;
142
143         /* RFC3931: L2TP/IP packets have the first 4 bytes containing
144          * the session_id. If it is 0, the packet is a L2TP control
145          * frame and the session_id value can be discarded.
146          */
147         if (session_id == 0) {
148                 __skb_pull(skb, 4);
149                 goto pass_up;
150         }
151
152         /* Ok, this is a data packet. Lookup the session. */
153         session = l2tp_session_find(&init_net, NULL, session_id);
154         if (session == NULL)
155                 goto discard;
156
157         tunnel = session->tunnel;
158         if (tunnel == NULL)
159                 goto discard;
160
161         /* Trace packet contents, if enabled */
162         if (tunnel->debug & L2TP_MSG_DATA) {
163                 length = min(32u, skb->len);
164                 if (!pskb_may_pull(skb, length))
165                         goto discard;
166
167                 printk(KERN_DEBUG "%s: ip recv: ", tunnel->name);
168
169                 offset = 0;
170                 do {
171                         printk(" %02X", ptr[offset]);
172                 } while (++offset < length);
173
174                 printk("\n");
175         }
176
177         l2tp_recv_common(session, skb, ptr, optr, 0, skb->len, tunnel->recv_payload_hook);
178
179         return 0;
180
181 pass_up:
182         /* Get the tunnel_id from the L2TP header */
183         if (!pskb_may_pull(skb, 12))
184                 goto discard;
185
186         if ((skb->data[0] & 0xc0) != 0xc0)
187                 goto discard;
188
189         tunnel_id = ntohl(*(__be32 *) &skb->data[4]);
190         tunnel = l2tp_tunnel_find(&init_net, tunnel_id);
191         if (tunnel != NULL)
192                 sk = tunnel->sock;
193         else {
194                 struct iphdr *iph = (struct iphdr *) skb_network_header(skb);
195
196                 read_lock_bh(&l2tp_ip_lock);
197                 sk = __l2tp_ip_bind_lookup(&init_net, iph->daddr, 0, tunnel_id);
198                 read_unlock_bh(&l2tp_ip_lock);
199         }
200
201         if (sk == NULL)
202                 goto discard;
203
204         sock_hold(sk);
205
206         if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb))
207                 goto discard_put;
208
209         nf_reset(skb);
210
211         return sk_receive_skb(sk, skb, 1);
212
213 discard_put:
214         sock_put(sk);
215
216 discard:
217         kfree_skb(skb);
218         return 0;
219 }
220
221 static int l2tp_ip_open(struct sock *sk)
222 {
223         /* Prevent autobind. We don't have ports. */
224         inet_sk(sk)->inet_num = IPPROTO_L2TP;
225
226         write_lock_bh(&l2tp_ip_lock);
227         sk_add_node(sk, &l2tp_ip_table);
228         write_unlock_bh(&l2tp_ip_lock);
229
230         return 0;
231 }
232
233 static void l2tp_ip_close(struct sock *sk, long timeout)
234 {
235         write_lock_bh(&l2tp_ip_lock);
236         hlist_del_init(&sk->sk_bind_node);
237         hlist_del_init(&sk->sk_node);
238         write_unlock_bh(&l2tp_ip_lock);
239         sk_common_release(sk);
240 }
241
242 static void l2tp_ip_destroy_sock(struct sock *sk)
243 {
244         struct sk_buff *skb;
245
246         while ((skb = __skb_dequeue_tail(&sk->sk_write_queue)) != NULL)
247                 kfree_skb(skb);
248
249         sk_refcnt_debug_dec(sk);
250 }
251
252 static int l2tp_ip_bind(struct sock *sk, struct sockaddr *uaddr, int addr_len)
253 {
254         struct inet_sock *inet = inet_sk(sk);
255         struct sockaddr_l2tpip *addr = (struct sockaddr_l2tpip *) uaddr;
256         int ret = -EINVAL;
257         int chk_addr_ret;
258
259         ret = -EADDRINUSE;
260         read_lock_bh(&l2tp_ip_lock);
261         if (__l2tp_ip_bind_lookup(&init_net, addr->l2tp_addr.s_addr, sk->sk_bound_dev_if, addr->l2tp_conn_id))
262                 goto out_in_use;
263
264         read_unlock_bh(&l2tp_ip_lock);
265
266         lock_sock(sk);
267         if (sk->sk_state != TCP_CLOSE || addr_len < sizeof(struct sockaddr_l2tpip))
268                 goto out;
269
270         chk_addr_ret = inet_addr_type(&init_net, addr->l2tp_addr.s_addr);
271         ret = -EADDRNOTAVAIL;
272         if (addr->l2tp_addr.s_addr && chk_addr_ret != RTN_LOCAL &&
273             chk_addr_ret != RTN_MULTICAST && chk_addr_ret != RTN_BROADCAST)
274                 goto out;
275
276         inet->inet_rcv_saddr = inet->inet_saddr = addr->l2tp_addr.s_addr;
277         if (chk_addr_ret == RTN_MULTICAST || chk_addr_ret == RTN_BROADCAST)
278                 inet->inet_saddr = 0;  /* Use device */
279         sk_dst_reset(sk);
280
281         l2tp_ip_sk(sk)->conn_id = addr->l2tp_conn_id;
282
283         write_lock_bh(&l2tp_ip_lock);
284         sk_add_bind_node(sk, &l2tp_ip_bind_table);
285         sk_del_node_init(sk);
286         write_unlock_bh(&l2tp_ip_lock);
287         ret = 0;
288 out:
289         release_sock(sk);
290
291         return ret;
292
293 out_in_use:
294         read_unlock_bh(&l2tp_ip_lock);
295
296         return ret;
297 }
298
299 static int l2tp_ip_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
300 {
301         int rc;
302         struct inet_sock *inet = inet_sk(sk);
303         struct sockaddr_l2tpip *lsa = (struct sockaddr_l2tpip *) uaddr;
304         struct rtable *rt;
305         __be32 saddr;
306         int oif;
307
308         rc = -EINVAL;
309         if (addr_len < sizeof(*lsa))
310                 goto out;
311
312         rc = -EAFNOSUPPORT;
313         if (lsa->l2tp_family != AF_INET)
314                 goto out;
315
316         sk_dst_reset(sk);
317
318         oif = sk->sk_bound_dev_if;
319         saddr = inet->inet_saddr;
320
321         rc = -EINVAL;
322         if (ipv4_is_multicast(lsa->l2tp_addr.s_addr))
323                 goto out;
324
325         rc = ip_route_connect(&rt, lsa->l2tp_addr.s_addr, saddr,
326                               RT_CONN_FLAGS(sk), oif,
327                               IPPROTO_L2TP,
328                               0, 0, sk, 1);
329         if (rc) {
330                 if (rc == -ENETUNREACH)
331                         IP_INC_STATS_BH(&init_net, IPSTATS_MIB_OUTNOROUTES);
332                 goto out;
333         }
334
335         rc = -ENETUNREACH;
336         if (rt->rt_flags & (RTCF_MULTICAST | RTCF_BROADCAST)) {
337                 ip_rt_put(rt);
338                 goto out;
339         }
340
341         l2tp_ip_sk(sk)->peer_conn_id = lsa->l2tp_conn_id;
342
343         if (!inet->inet_saddr)
344                 inet->inet_saddr = rt->rt_src;
345         if (!inet->inet_rcv_saddr)
346                 inet->inet_rcv_saddr = rt->rt_src;
347         inet->inet_daddr = rt->rt_dst;
348         sk->sk_state = TCP_ESTABLISHED;
349         inet->inet_id = jiffies;
350
351         sk_dst_set(sk, &rt->u.dst);
352
353         write_lock_bh(&l2tp_ip_lock);
354         hlist_del_init(&sk->sk_bind_node);
355         sk_add_bind_node(sk, &l2tp_ip_bind_table);
356         write_unlock_bh(&l2tp_ip_lock);
357
358         rc = 0;
359 out:
360         return rc;
361 }
362
363 static int l2tp_ip_getname(struct socket *sock, struct sockaddr *uaddr,
364                            int *uaddr_len, int peer)
365 {
366         struct sock *sk         = sock->sk;
367         struct inet_sock *inet  = inet_sk(sk);
368         struct l2tp_ip_sock *lsk = l2tp_ip_sk(sk);
369         struct sockaddr_l2tpip *lsa = (struct sockaddr_l2tpip *)uaddr;
370
371         memset(lsa, 0, sizeof(*lsa));
372         lsa->l2tp_family = AF_INET;
373         if (peer) {
374                 if (!inet->inet_dport)
375                         return -ENOTCONN;
376                 lsa->l2tp_conn_id = lsk->peer_conn_id;
377                 lsa->l2tp_addr.s_addr = inet->inet_daddr;
378         } else {
379                 __be32 addr = inet->inet_rcv_saddr;
380                 if (!addr)
381                         addr = inet->inet_saddr;
382                 lsa->l2tp_conn_id = lsk->conn_id;
383                 lsa->l2tp_addr.s_addr = addr;
384         }
385         *uaddr_len = sizeof(*lsa);
386         return 0;
387 }
388
389 static int l2tp_ip_backlog_recv(struct sock *sk, struct sk_buff *skb)
390 {
391         int rc;
392
393         if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb))
394                 goto drop;
395
396         nf_reset(skb);
397
398         /* Charge it to the socket, dropping if the queue is full. */
399         rc = sock_queue_rcv_skb(sk, skb);
400         if (rc < 0)
401                 goto drop;
402
403         return 0;
404
405 drop:
406         IP_INC_STATS(&init_net, IPSTATS_MIB_INDISCARDS);
407         kfree_skb(skb);
408         return -1;
409 }
410
411 /* Userspace will call sendmsg() on the tunnel socket to send L2TP
412  * control frames.
413  */
414 static int l2tp_ip_sendmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg, size_t len)
415 {
416         struct sk_buff *skb;
417         int rc;
418         struct l2tp_ip_sock *lsa = l2tp_ip_sk(sk);
419         struct inet_sock *inet = inet_sk(sk);
420         struct ip_options *opt = inet->opt;
421         struct rtable *rt = NULL;
422         int connected = 0;
423         __be32 daddr;
424
425         if (sock_flag(sk, SOCK_DEAD))
426                 return -ENOTCONN;
427
428         /* Get and verify the address. */
429         if (msg->msg_name) {
430                 struct sockaddr_l2tpip *lip = (struct sockaddr_l2tpip *) msg->msg_name;
431                 if (msg->msg_namelen < sizeof(*lip))
432                         return -EINVAL;
433
434                 if (lip->l2tp_family != AF_INET) {
435                         if (lip->l2tp_family != AF_UNSPEC)
436                                 return -EAFNOSUPPORT;
437                 }
438
439                 daddr = lip->l2tp_addr.s_addr;
440         } else {
441                 if (sk->sk_state != TCP_ESTABLISHED)
442                         return -EDESTADDRREQ;
443
444                 daddr = inet->inet_daddr;
445                 connected = 1;
446         }
447
448         /* Allocate a socket buffer */
449         rc = -ENOMEM;
450         skb = sock_wmalloc(sk, 2 + NET_SKB_PAD + sizeof(struct iphdr) +
451                            4 + len, 0, GFP_KERNEL);
452         if (!skb)
453                 goto error;
454
455         /* Reserve space for headers, putting IP header on 4-byte boundary. */
456         skb_reserve(skb, 2 + NET_SKB_PAD);
457         skb_reset_network_header(skb);
458         skb_reserve(skb, sizeof(struct iphdr));
459         skb_reset_transport_header(skb);
460
461         /* Insert 0 session_id */
462         *((__be32 *) skb_put(skb, 4)) = 0;
463
464         /* Copy user data into skb */
465         rc = memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len);
466         if (rc < 0) {
467                 kfree_skb(skb);
468                 goto error;
469         }
470
471         if (connected)
472                 rt = (struct rtable *) __sk_dst_check(sk, 0);
473
474         if (rt == NULL) {
475                 /* Use correct destination address if we have options. */
476                 if (opt && opt->srr)
477                         daddr = opt->faddr;
478
479                 {
480                         struct flowi fl = { .oif = sk->sk_bound_dev_if,
481                                             .nl_u = { .ip4_u = {
482                                                         .daddr = daddr,
483                                                         .saddr = inet->inet_saddr,
484                                                         .tos = RT_CONN_FLAGS(sk) } },
485                                             .proto = sk->sk_protocol,
486                                             .flags = inet_sk_flowi_flags(sk),
487                                             .uli_u = { .ports = {
488                                                          .sport = inet->inet_sport,
489                                                          .dport = inet->inet_dport } } };
490
491                         /* If this fails, retransmit mechanism of transport layer will
492                          * keep trying until route appears or the connection times
493                          * itself out.
494                          */
495                         security_sk_classify_flow(sk, &fl);
496                         if (ip_route_output_flow(sock_net(sk), &rt, &fl, sk, 0))
497                                 goto no_route;
498                 }
499                 sk_setup_caps(sk, &rt->u.dst);
500         }
501         skb_dst_set(skb, dst_clone(&rt->u.dst));
502
503         /* Queue the packet to IP for output */
504         rc = ip_queue_xmit(skb);
505
506 error:
507         /* Update stats */
508         if (rc >= 0) {
509                 lsa->tx_packets++;
510                 lsa->tx_bytes += len;
511                 rc = len;
512         } else {
513                 lsa->tx_errors++;
514         }
515
516         return rc;
517
518 no_route:
519         IP_INC_STATS(sock_net(sk), IPSTATS_MIB_OUTNOROUTES);
520         kfree_skb(skb);
521         return -EHOSTUNREACH;
522 }
523
524 static int l2tp_ip_recvmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
525                            size_t len, int noblock, int flags, int *addr_len)
526 {
527         struct inet_sock *inet = inet_sk(sk);
528         struct l2tp_ip_sock *lsk = l2tp_ip_sk(sk);
529         size_t copied = 0;
530         int err = -EOPNOTSUPP;
531         struct sockaddr_in *sin = (struct sockaddr_in *)msg->msg_name;
532         struct sk_buff *skb;
533
534         if (flags & MSG_OOB)
535                 goto out;
536
537         if (addr_len)
538                 *addr_len = sizeof(*sin);
539
540         skb = skb_recv_datagram(sk, flags, noblock, &err);
541         if (!skb)
542                 goto out;
543
544         copied = skb->len;
545         if (len < copied) {
546                 msg->msg_flags |= MSG_TRUNC;
547                 copied = len;
548         }
549
550         err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
551         if (err)
552                 goto done;
553
554         sock_recv_timestamp(msg, sk, skb);
555
556         /* Copy the address. */
557         if (sin) {
558                 sin->sin_family = AF_INET;
559                 sin->sin_addr.s_addr = ip_hdr(skb)->saddr;
560                 sin->sin_port = 0;
561                 memset(&sin->sin_zero, 0, sizeof(sin->sin_zero));
562         }
563         if (inet->cmsg_flags)
564                 ip_cmsg_recv(msg, skb);
565         if (flags & MSG_TRUNC)
566                 copied = skb->len;
567 done:
568         skb_free_datagram(sk, skb);
569 out:
570         if (err) {
571                 lsk->rx_errors++;
572                 return err;
573         }
574
575         lsk->rx_packets++;
576         lsk->rx_bytes += copied;
577
578         return copied;
579 }
580
581 struct proto l2tp_ip_prot = {
582         .name              = "L2TP/IP",
583         .owner             = THIS_MODULE,
584         .init              = l2tp_ip_open,
585         .close             = l2tp_ip_close,
586         .bind              = l2tp_ip_bind,
587         .connect           = l2tp_ip_connect,
588         .disconnect        = udp_disconnect,
589         .ioctl             = udp_ioctl,
590         .destroy           = l2tp_ip_destroy_sock,
591         .setsockopt        = ip_setsockopt,
592         .getsockopt        = ip_getsockopt,
593         .sendmsg           = l2tp_ip_sendmsg,
594         .recvmsg           = l2tp_ip_recvmsg,
595         .backlog_rcv       = l2tp_ip_backlog_recv,
596         .hash              = inet_hash,
597         .unhash            = inet_unhash,
598         .obj_size          = sizeof(struct l2tp_ip_sock),
599 #ifdef CONFIG_COMPAT
600         .compat_setsockopt = compat_ip_setsockopt,
601         .compat_getsockopt = compat_ip_getsockopt,
602 #endif
603 };
604
605 static const struct proto_ops l2tp_ip_ops = {
606         .family            = PF_INET,
607         .owner             = THIS_MODULE,
608         .release           = inet_release,
609         .bind              = inet_bind,
610         .connect           = inet_dgram_connect,
611         .socketpair        = sock_no_socketpair,
612         .accept            = sock_no_accept,
613         .getname           = l2tp_ip_getname,
614         .poll              = datagram_poll,
615         .ioctl             = inet_ioctl,
616         .listen            = sock_no_listen,
617         .shutdown          = inet_shutdown,
618         .setsockopt        = sock_common_setsockopt,
619         .getsockopt        = sock_common_getsockopt,
620         .sendmsg           = inet_sendmsg,
621         .recvmsg           = sock_common_recvmsg,
622         .mmap              = sock_no_mmap,
623         .sendpage          = sock_no_sendpage,
624 #ifdef CONFIG_COMPAT
625         .compat_setsockopt = compat_sock_common_setsockopt,
626         .compat_getsockopt = compat_sock_common_getsockopt,
627 #endif
628 };
629
630 static struct inet_protosw l2tp_ip_protosw = {
631         .type           = SOCK_DGRAM,
632         .protocol       = IPPROTO_L2TP,
633         .prot           = &l2tp_ip_prot,
634         .ops            = &l2tp_ip_ops,
635         .no_check       = 0,
636 };
637
638 static struct net_protocol l2tp_ip_protocol __read_mostly = {
639         .handler        = l2tp_ip_recv,
640 };
641
642 static int __init l2tp_ip_init(void)
643 {
644         int err;
645
646         printk(KERN_INFO "L2TP IP encapsulation support (L2TPv3)\n");
647
648         err = proto_register(&l2tp_ip_prot, 1);
649         if (err != 0)
650                 goto out;
651
652         err = inet_add_protocol(&l2tp_ip_protocol, IPPROTO_L2TP);
653         if (err)
654                 goto out1;
655
656         inet_register_protosw(&l2tp_ip_protosw);
657         return 0;
658
659 out1:
660         proto_unregister(&l2tp_ip_prot);
661 out:
662         return err;
663 }
664
665 static void __exit l2tp_ip_exit(void)
666 {
667         inet_unregister_protosw(&l2tp_ip_protosw);
668         inet_del_protocol(&l2tp_ip_protocol, IPPROTO_L2TP);
669         proto_unregister(&l2tp_ip_prot);
670 }
671
672 module_init(l2tp_ip_init);
673 module_exit(l2tp_ip_exit);
674
675 MODULE_LICENSE("GPL");
676 MODULE_AUTHOR("James Chapman <jchapman@katalix.com>");
677 MODULE_DESCRIPTION("L2TP over IP");
678 MODULE_VERSION("1.0");
679 MODULE_ALIAS_NET_PF_PROTO_TYPE(PF_INET, SOCK_DGRAM, IPPROTO_L2TP);