blob: 51fc2a1dcdd3aa564147933d7485ec6356e9ad12 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09002 * Linux NET3: IP/IP protocol decoder.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 * Authors:
5 * Sam Lantinga (slouken@cs.ucdavis.edu) 02/01/95
6 *
7 * Fixes:
8 * Alan Cox : Merged and made usable non modular (its so tiny its silly as
9 * a module taking up 2 pages).
10 * Alan Cox : Fixed bug with 1.3.18 and IPIP not working (now needs to set skb->h.iph)
11 * to keep ip_forward happy.
12 * Alan Cox : More fixes for 1.3.21, and firewall fix. Maybe this will work soon 8).
13 * Kai Schulte : Fixed #defines for IP_FIREWALL->FIREWALL
14 * David Woodhouse : Perform some basic ICMP handling.
15 * IPIP Routing without decapsulation.
16 * Carlos Picoto : GRE over IP support
17 * Alexey Kuznetsov: Reworked. Really, now it is truncated version of ipv4/ip_gre.c.
18 * I do not want to merge them together.
19 *
20 * This program is free software; you can redistribute it and/or
21 * modify it under the terms of the GNU General Public License
22 * as published by the Free Software Foundation; either version
23 * 2 of the License, or (at your option) any later version.
24 *
25 */
26
27/* tunnel.c: an IP tunnel driver
28
29 The purpose of this driver is to provide an IP tunnel through
30 which you can tunnel network traffic transparently across subnets.
31
32 This was written by looking at Nick Holloway's dummy driver
33 Thanks for the great code!
34
35 -Sam Lantinga (slouken@cs.ucdavis.edu) 02/01/95
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +090036
Linus Torvalds1da177e2005-04-16 15:20:36 -070037 Minor tweaks:
38 Cleaned up the code a little and added some pre-1.3.0 tweaks.
39 dev->hard_header/hard_header_len changed to use no headers.
40 Comments/bracketing tweaked.
41 Made the tunnels use dev->name not tunnel: when error reporting.
42 Added tx_dropped stat
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +090043
Alan Cox113aa832008-10-13 19:01:08 -070044 -Alan Cox (alan@lxorguk.ukuu.org.uk) 21 March 95
Linus Torvalds1da177e2005-04-16 15:20:36 -070045
46 Reworked:
47 Changed to tunnel to destination gateway in addition to the
48 tunnel's pointopoint address
49 Almost completely rewritten
50 Note: There is currently no firewall or ICMP handling done.
51
52 -Sam Lantinga (slouken@cs.ucdavis.edu) 02/13/96
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +090053
Linus Torvalds1da177e2005-04-16 15:20:36 -070054*/
55
56/* Things I wish I had known when writing the tunnel driver:
57
58 When the tunnel_xmit() function is called, the skb contains the
59 packet to be sent (plus a great deal of extra info), and dev
60 contains the tunnel device that _we_ are.
61
62 When we are passed a packet, we are expected to fill in the
63 source address with our source IP address.
64
65 What is the proper way to allocate, copy and free a buffer?
66 After you allocate it, it is a "0 length" chunk of memory
67 starting at zero. If you want to add headers to the buffer
68 later, you'll have to call "skb_reserve(skb, amount)" with
69 the amount of memory you want reserved. Then, you call
70 "skb_put(skb, amount)" with the amount of space you want in
71 the buffer. skb_put() returns a pointer to the top (#0) of
72 that buffer. skb->len is set to the amount of space you have
73 "allocated" with skb_put(). You can then write up to skb->len
74 bytes to that buffer. If you need more, you can call skb_put()
75 again with the additional amount of space you need. You can
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +090076 find out how much more space you can allocate by calling
Linus Torvalds1da177e2005-04-16 15:20:36 -070077 "skb_tailroom(skb)".
78 Now, to add header space, call "skb_push(skb, header_len)".
79 This creates space at the beginning of the buffer and returns
80 a pointer to this new space. If later you need to strip a
81 header from a buffer, call "skb_pull(skb, header_len)".
82 skb_headroom() will return how much space is left at the top
83 of the buffer (before the main data). Remember, this headroom
84 space must be reserved before the skb_put() function is called.
85 */
86
87/*
88 This version of net/ipv4/ipip.c is cloned of net/ipv4/ip_gre.c
89
90 For comments look at net/ipv4/ip_gre.c --ANK
91 */
92
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +090093
Randy Dunlap4fc268d2006-01-11 12:17:47 -080094#include <linux/capability.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070095#include <linux/module.h>
96#include <linux/types.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070097#include <linux/kernel.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090098#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070099#include <asm/uaccess.h>
100#include <linux/skbuff.h>
101#include <linux/netdevice.h>
102#include <linux/in.h>
103#include <linux/tcp.h>
104#include <linux/udp.h>
105#include <linux/if_arp.h>
106#include <linux/mroute.h>
107#include <linux/init.h>
108#include <linux/netfilter_ipv4.h>
Kris Katterjohn46f25df2006-01-05 16:35:42 -0800109#include <linux/if_ether.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110
111#include <net/sock.h>
112#include <net/ip.h>
113#include <net/icmp.h>
Pravin B Shelarc5441932013-03-25 14:49:35 +0000114#include <net/ip_tunnels.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115#include <net/inet_ecn.h>
116#include <net/xfrm.h>
Pavel Emelyanov10dc4c72008-04-16 01:03:13 -0700117#include <net/net_namespace.h>
118#include <net/netns/generic.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119
stephen hemmingereccc1bb2012-09-25 11:02:48 +0000120static bool log_ecn_error = true;
121module_param(log_ecn_error, bool, 0644);
122MODULE_PARM_DESC(log_ecn_error, "Log packets received with corrupted ECN");
123
Eric Dumazetf99189b2009-11-17 10:42:49 +0000124static int ipip_net_id __read_mostly;
Pavel Emelyanov10dc4c72008-04-16 01:03:13 -0700125
Eric Dumazet3c97af92010-09-27 00:35:50 +0000126static int ipip_tunnel_init(struct net_device *dev);
Nicolas Dichtel09746582012-11-09 06:09:59 +0000127static struct rtnl_link_ops ipip_link_ops __read_mostly;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128
Herbert Xud2acc342006-03-28 01:12:13 -0800129static int ipip_err(struct sk_buff *skb, u32 info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131
Rami Rosen071f92d2008-05-21 17:47:54 -0700132/* All the routers (except for Linux) return only
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133 8 bytes of packet payload. It means, that precise relaying of
134 ICMP in the real Internet is absolutely infeasible.
135 */
Pravin B Shelarfd581562013-03-25 14:49:41 +0000136 struct net *net = dev_net(skb->dev);
137 struct ip_tunnel_net *itn = net_generic(net, ipip_net_id);
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000138 const struct iphdr *iph = (const struct iphdr *)skb->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139 struct ip_tunnel *t;
Herbert Xud2acc342006-03-28 01:12:13 -0800140 int err;
Pravin B Shelarfd581562013-03-25 14:49:41 +0000141 const int type = icmp_hdr(skb)->type;
142 const int code = icmp_hdr(skb)->code;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143
Herbert Xud2acc342006-03-28 01:12:13 -0800144 err = -ENOENT;
Pravin B Shelarfd581562013-03-25 14:49:41 +0000145 t = ip_tunnel_lookup(itn, skb->dev->ifindex, TUNNEL_NO_KEY,
146 iph->daddr, iph->saddr, 0);
David S. Miller36393392012-06-14 22:21:46 -0700147 if (t == NULL)
148 goto out;
149
150 if (type == ICMP_DEST_UNREACH && code == ICMP_FRAG_NEEDED) {
151 ipv4_update_pmtu(skb, dev_net(skb->dev), info,
152 t->dev->ifindex, 0, IPPROTO_IPIP, 0);
153 err = 0;
154 goto out;
155 }
156
David S. Miller55be7a92012-07-11 21:27:49 -0700157 if (type == ICMP_REDIRECT) {
158 ipv4_redirect(skb, dev_net(skb->dev), t->dev->ifindex, 0,
159 IPPROTO_IPIP, 0);
160 err = 0;
161 goto out;
162 }
163
David S. Miller36393392012-06-14 22:21:46 -0700164 if (t->parms.iph.daddr == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165 goto out;
Herbert Xud2acc342006-03-28 01:12:13 -0800166
167 err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168 if (t->parms.iph.ttl == 0 && type == ICMP_TIME_EXCEEDED)
169 goto out;
170
Wei Yongjun26d94b42009-02-24 23:36:47 -0800171 if (time_before(jiffies, t->err_time + IPTUNNEL_ERR_TIMEO))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172 t->err_count++;
173 else
174 t->err_count = 1;
175 t->err_time = jiffies;
stephen hemmingerb0558ef2012-09-24 18:12:25 +0000176
Pravin B Shelarfd581562013-03-25 14:49:41 +0000177out:
Herbert Xud2acc342006-03-28 01:12:13 -0800178 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179}
180
Pravin B Shelarfd581562013-03-25 14:49:41 +0000181static const struct tnl_ptk_info tpi = {
182 /* no tunnel info required for ipip. */
183 .proto = htons(ETH_P_IP),
184};
185
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186static int ipip_rcv(struct sk_buff *skb)
187{
Pravin B Shelarfd581562013-03-25 14:49:41 +0000188 struct net *net = dev_net(skb->dev);
189 struct ip_tunnel_net *itn = net_generic(net, ipip_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190 struct ip_tunnel *tunnel;
Pravin B Shelar3d7b46c2013-06-17 17:50:02 -0700191 const struct iphdr *iph;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192
Pravin B Shelar3d7b46c2013-06-17 17:50:02 -0700193 if (iptunnel_pull_header(skb, 0, tpi.proto))
194 goto drop;
195
196 iph = ip_hdr(skb);
Pravin B Shelarfd581562013-03-25 14:49:41 +0000197 tunnel = ip_tunnel_lookup(itn, skb->dev->ifindex, TUNNEL_NO_KEY,
198 iph->saddr, iph->daddr, 0);
199 if (tunnel) {
stephen hemmingereccc1bb2012-09-25 11:02:48 +0000200 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb))
201 goto drop;
Pravin B Shelarfd581562013-03-25 14:49:41 +0000202 return ip_tunnel_rcv(tunnel, skb, &tpi, log_ecn_error);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205 return -1;
stephen hemmingereccc1bb2012-09-25 11:02:48 +0000206
207drop:
208 kfree_skb(skb);
209 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210}
211
212/*
213 * This function assumes it is being called from dev_queue_xmit()
214 * and that skb is filled properly by that function.
215 */
Stephen Hemminger6fef4c02009-08-31 19:50:41 +0000216static netdev_tx_t ipip_tunnel_xmit(struct sk_buff *skb, struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217{
Patrick McHardy2941a482006-01-08 22:05:26 -0800218 struct ip_tunnel *tunnel = netdev_priv(dev);
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000219 const struct iphdr *tiph = &tunnel->parms.iph;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220
Pravin B Shelarfd581562013-03-25 14:49:41 +0000221 if (unlikely(skb->protocol != htons(ETH_P_IP)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222 goto tx_error;
Eric Dumazetcef401d2013-01-25 20:34:37 +0000223
Pravin B Shelarfd581562013-03-25 14:49:41 +0000224 if (likely(!skb->encapsulation)) {
Pravin B Shelar4f3ed922013-03-08 15:12:52 +0000225 skb_reset_inner_headers(skb);
226 skb->encapsulation = 1;
227 }
Pravin B Shelar4f3ed922013-03-08 15:12:52 +0000228
Nicolas Dichtelbf3d6a82013-05-27 23:48:15 +0000229 ip_tunnel_xmit(skb, dev, tiph, tiph->protocol);
Patrick McHardy6ed10652009-06-23 06:03:08 +0000230 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232tx_error:
Eric Dumazet3c97af92010-09-27 00:35:50 +0000233 dev->stats.tx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234 dev_kfree_skb(skb);
Patrick McHardy6ed10652009-06-23 06:03:08 +0000235 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236}
237
238static int
Pravin B Shelarfd581562013-03-25 14:49:41 +0000239ipip_tunnel_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240{
241 int err = 0;
242 struct ip_tunnel_parm p;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243
Pravin B Shelarfd581562013-03-25 14:49:41 +0000244 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
245 return -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246
Cong Wang3b7b5142013-07-02 14:49:34 +0800247 if (cmd == SIOCADDTUNNEL || cmd == SIOCCHGTUNNEL) {
248 if (p.iph.version != 4 || p.iph.protocol != IPPROTO_IPIP ||
249 p.iph.ihl != 5 || (p.iph.frag_off&htons(~IP_DF)))
250 return -EINVAL;
251 }
252
253 p.i_key = p.o_key = p.i_flags = p.o_flags = 0;
Pravin B Shelarfd581562013-03-25 14:49:41 +0000254 if (p.iph.ttl)
255 p.iph.frag_off |= htons(IP_DF);
256
257 err = ip_tunnel_ioctl(dev, &p, cmd);
258 if (err)
259 return err;
260
261 if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p)))
262 return -EFAULT;
263
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264 return 0;
265}
266
Stephen Hemminger23a12b12008-11-20 20:33:21 -0800267static const struct net_device_ops ipip_netdev_ops = {
Pravin B Shelarfd581562013-03-25 14:49:41 +0000268 .ndo_init = ipip_tunnel_init,
269 .ndo_uninit = ip_tunnel_uninit,
Stephen Hemminger23a12b12008-11-20 20:33:21 -0800270 .ndo_start_xmit = ipip_tunnel_xmit,
271 .ndo_do_ioctl = ipip_tunnel_ioctl,
Pravin B Shelarfd581562013-03-25 14:49:41 +0000272 .ndo_change_mtu = ip_tunnel_change_mtu,
273 .ndo_get_stats64 = ip_tunnel_get_stats64,
Stephen Hemminger23a12b12008-11-20 20:33:21 -0800274};
275
Eric Dumazetc3b89fb2012-11-08 09:59:52 +0000276#define IPIP_FEATURES (NETIF_F_SG | \
277 NETIF_F_FRAGLIST | \
278 NETIF_F_HIGHDMA | \
279 NETIF_F_HW_CSUM)
280
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281static void ipip_tunnel_setup(struct net_device *dev)
282{
Stephen Hemminger23a12b12008-11-20 20:33:21 -0800283 dev->netdev_ops = &ipip_netdev_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284
285 dev->type = ARPHRD_TUNNEL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286 dev->flags = IFF_NOARP;
287 dev->iflink = 0;
288 dev->addr_len = 4;
Pavel Emelyanov0a826402008-04-16 01:06:18 -0700289 dev->features |= NETIF_F_NETNS_LOCAL;
Eric Dumazet153f0942010-09-28 00:17:17 +0000290 dev->features |= NETIF_F_LLTX;
Eric Dumazet28e72212009-05-28 10:44:30 +0000291 dev->priv_flags &= ~IFF_XMIT_DST_RELEASE;
Eric Dumazetc3b89fb2012-11-08 09:59:52 +0000292
293 dev->features |= IPIP_FEATURES;
294 dev->hw_features |= IPIP_FEATURES;
Pravin B Shelarfd581562013-03-25 14:49:41 +0000295 ip_tunnel_setup(dev, ipip_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296}
297
Eric Dumazet3c97af92010-09-27 00:35:50 +0000298static int ipip_tunnel_init(struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299{
Stephen Hemminger23a12b12008-11-20 20:33:21 -0800300 struct ip_tunnel *tunnel = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302 memcpy(dev->dev_addr, &tunnel->parms.iph.saddr, 4);
303 memcpy(dev->broadcast, &tunnel->parms.iph.daddr, 4);
304
Pravin B Shelarfd581562013-03-25 14:49:41 +0000305 tunnel->hlen = 0;
306 tunnel->parms.iph.protocol = IPPROTO_IPIP;
307 return ip_tunnel_init(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308}
309
Nicolas Dichtelbe42da02012-11-14 05:14:03 +0000310static void ipip_netlink_parms(struct nlattr *data[],
311 struct ip_tunnel_parm *parms)
312{
313 memset(parms, 0, sizeof(*parms));
314
315 parms->iph.version = 4;
316 parms->iph.protocol = IPPROTO_IPIP;
317 parms->iph.ihl = 5;
318
319 if (!data)
320 return;
321
322 if (data[IFLA_IPTUN_LINK])
323 parms->link = nla_get_u32(data[IFLA_IPTUN_LINK]);
324
325 if (data[IFLA_IPTUN_LOCAL])
Nicolas Dichtelfea379b2012-11-15 04:06:40 +0000326 parms->iph.saddr = nla_get_be32(data[IFLA_IPTUN_LOCAL]);
Nicolas Dichtelbe42da02012-11-14 05:14:03 +0000327
328 if (data[IFLA_IPTUN_REMOTE])
Nicolas Dichtelfea379b2012-11-15 04:06:40 +0000329 parms->iph.daddr = nla_get_be32(data[IFLA_IPTUN_REMOTE]);
Nicolas Dichtelbe42da02012-11-14 05:14:03 +0000330
331 if (data[IFLA_IPTUN_TTL]) {
332 parms->iph.ttl = nla_get_u8(data[IFLA_IPTUN_TTL]);
333 if (parms->iph.ttl)
334 parms->iph.frag_off = htons(IP_DF);
335 }
336
337 if (data[IFLA_IPTUN_TOS])
338 parms->iph.tos = nla_get_u8(data[IFLA_IPTUN_TOS]);
339
340 if (!data[IFLA_IPTUN_PMTUDISC] || nla_get_u8(data[IFLA_IPTUN_PMTUDISC]))
341 parms->iph.frag_off = htons(IP_DF);
342}
343
344static int ipip_newlink(struct net *src_net, struct net_device *dev,
345 struct nlattr *tb[], struct nlattr *data[])
346{
Pravin B Shelarfd581562013-03-25 14:49:41 +0000347 struct ip_tunnel_parm p;
Nicolas Dichtelbe42da02012-11-14 05:14:03 +0000348
Pravin B Shelarfd581562013-03-25 14:49:41 +0000349 ipip_netlink_parms(data, &p);
350 return ip_tunnel_newlink(dev, tb, &p);
Nicolas Dichtelbe42da02012-11-14 05:14:03 +0000351}
352
353static int ipip_changelink(struct net_device *dev, struct nlattr *tb[],
354 struct nlattr *data[])
355{
Nicolas Dichtelbe42da02012-11-14 05:14:03 +0000356 struct ip_tunnel_parm p;
Nicolas Dichtelbe42da02012-11-14 05:14:03 +0000357
358 ipip_netlink_parms(data, &p);
359
360 if (((dev->flags & IFF_POINTOPOINT) && !p.iph.daddr) ||
361 (!(dev->flags & IFF_POINTOPOINT) && p.iph.daddr))
362 return -EINVAL;
363
Pravin B Shelarfd581562013-03-25 14:49:41 +0000364 return ip_tunnel_changelink(dev, tb, &p);
Nicolas Dichtelbe42da02012-11-14 05:14:03 +0000365}
366
Nicolas Dichtel09746582012-11-09 06:09:59 +0000367static size_t ipip_get_size(const struct net_device *dev)
368{
369 return
370 /* IFLA_IPTUN_LINK */
371 nla_total_size(4) +
372 /* IFLA_IPTUN_LOCAL */
373 nla_total_size(4) +
374 /* IFLA_IPTUN_REMOTE */
375 nla_total_size(4) +
376 /* IFLA_IPTUN_TTL */
377 nla_total_size(1) +
378 /* IFLA_IPTUN_TOS */
379 nla_total_size(1) +
Nicolas Dichtelbefe2aa2012-11-14 05:14:02 +0000380 /* IFLA_IPTUN_PMTUDISC */
381 nla_total_size(1) +
Nicolas Dichtel09746582012-11-09 06:09:59 +0000382 0;
383}
384
385static int ipip_fill_info(struct sk_buff *skb, const struct net_device *dev)
386{
387 struct ip_tunnel *tunnel = netdev_priv(dev);
388 struct ip_tunnel_parm *parm = &tunnel->parms;
389
390 if (nla_put_u32(skb, IFLA_IPTUN_LINK, parm->link) ||
391 nla_put_be32(skb, IFLA_IPTUN_LOCAL, parm->iph.saddr) ||
392 nla_put_be32(skb, IFLA_IPTUN_REMOTE, parm->iph.daddr) ||
393 nla_put_u8(skb, IFLA_IPTUN_TTL, parm->iph.ttl) ||
Nicolas Dichtelbefe2aa2012-11-14 05:14:02 +0000394 nla_put_u8(skb, IFLA_IPTUN_TOS, parm->iph.tos) ||
395 nla_put_u8(skb, IFLA_IPTUN_PMTUDISC,
396 !!(parm->iph.frag_off & htons(IP_DF))))
Nicolas Dichtel09746582012-11-09 06:09:59 +0000397 goto nla_put_failure;
398 return 0;
399
400nla_put_failure:
401 return -EMSGSIZE;
402}
403
Nicolas Dichtelbe42da02012-11-14 05:14:03 +0000404static const struct nla_policy ipip_policy[IFLA_IPTUN_MAX + 1] = {
405 [IFLA_IPTUN_LINK] = { .type = NLA_U32 },
406 [IFLA_IPTUN_LOCAL] = { .type = NLA_U32 },
407 [IFLA_IPTUN_REMOTE] = { .type = NLA_U32 },
408 [IFLA_IPTUN_TTL] = { .type = NLA_U8 },
409 [IFLA_IPTUN_TOS] = { .type = NLA_U8 },
410 [IFLA_IPTUN_PMTUDISC] = { .type = NLA_U8 },
411};
412
Nicolas Dichtel09746582012-11-09 06:09:59 +0000413static struct rtnl_link_ops ipip_link_ops __read_mostly = {
414 .kind = "ipip",
415 .maxtype = IFLA_IPTUN_MAX,
Nicolas Dichtelbe42da02012-11-14 05:14:03 +0000416 .policy = ipip_policy,
Nicolas Dichtel09746582012-11-09 06:09:59 +0000417 .priv_size = sizeof(struct ip_tunnel),
Nicolas Dichtelbe42da02012-11-14 05:14:03 +0000418 .setup = ipip_tunnel_setup,
419 .newlink = ipip_newlink,
420 .changelink = ipip_changelink,
Pravin B Shelarfd581562013-03-25 14:49:41 +0000421 .dellink = ip_tunnel_dellink,
Nicolas Dichtel09746582012-11-09 06:09:59 +0000422 .get_size = ipip_get_size,
423 .fill_info = ipip_fill_info,
424};
425
Eric Dumazet6dcd8142010-08-30 07:04:14 +0000426static struct xfrm_tunnel ipip_handler __read_mostly = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427 .handler = ipip_rcv,
428 .err_handler = ipip_err,
Herbert Xud2acc342006-03-28 01:12:13 -0800429 .priority = 1,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430};
431
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +0000432static int __net_init ipip_init_net(struct net *net)
Pavel Emelyanov10dc4c72008-04-16 01:03:13 -0700433{
Pravin B Shelarfd581562013-03-25 14:49:41 +0000434 return ip_tunnel_init_net(net, ipip_net_id, &ipip_link_ops, "tunl0");
Pavel Emelyanov10dc4c72008-04-16 01:03:13 -0700435}
436
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +0000437static void __net_exit ipip_exit_net(struct net *net)
Pavel Emelyanov10dc4c72008-04-16 01:03:13 -0700438{
Pravin B Shelarfd581562013-03-25 14:49:41 +0000439 struct ip_tunnel_net *itn = net_generic(net, ipip_net_id);
440 ip_tunnel_delete_net(itn);
Pavel Emelyanov10dc4c72008-04-16 01:03:13 -0700441}
442
443static struct pernet_operations ipip_net_ops = {
444 .init = ipip_init_net,
445 .exit = ipip_exit_net,
Eric W. Biederman86de8a62009-11-29 15:46:14 +0000446 .id = &ipip_net_id,
Pravin B Shelarfd581562013-03-25 14:49:41 +0000447 .size = sizeof(struct ip_tunnel_net),
Pavel Emelyanov10dc4c72008-04-16 01:03:13 -0700448};
449
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450static int __init ipip_init(void)
451{
452 int err;
453
Pravin B Shelarfd581562013-03-25 14:49:41 +0000454 pr_info("ipip: IPv4 over IPv4 tunneling driver\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455
Eric W. Biederman86de8a62009-11-29 15:46:14 +0000456 err = register_pernet_device(&ipip_net_ops);
Alexey Dobriyand5aa4072010-02-16 09:05:04 +0000457 if (err < 0)
458 return err;
459 err = xfrm4_tunnel_register(&ipip_handler, AF_INET);
460 if (err < 0) {
Joe Perches058bd4d2012-03-11 18:36:11 +0000461 pr_info("%s: can't register tunnel\n", __func__);
Nicolas Dichtel09746582012-11-09 06:09:59 +0000462 goto xfrm_tunnel_failed;
Alexey Dobriyand5aa4072010-02-16 09:05:04 +0000463 }
Nicolas Dichtel09746582012-11-09 06:09:59 +0000464 err = rtnl_link_register(&ipip_link_ops);
465 if (err < 0)
466 goto rtnl_link_failed;
467
468out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469 return err;
Nicolas Dichtel09746582012-11-09 06:09:59 +0000470
471rtnl_link_failed:
472 xfrm4_tunnel_deregister(&ipip_handler, AF_INET);
473xfrm_tunnel_failed:
474 unregister_pernet_device(&ipip_net_ops);
475 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476}
477
478static void __exit ipip_fini(void)
479{
Nicolas Dichtel09746582012-11-09 06:09:59 +0000480 rtnl_link_unregister(&ipip_link_ops);
Kazunori MIYAZAWAc0d56402007-02-13 12:54:47 -0800481 if (xfrm4_tunnel_deregister(&ipip_handler, AF_INET))
Joe Perches058bd4d2012-03-11 18:36:11 +0000482 pr_info("%s: can't deregister tunnel\n", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483
Eric W. Biederman86de8a62009-11-29 15:46:14 +0000484 unregister_pernet_device(&ipip_net_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485}
486
487module_init(ipip_init);
488module_exit(ipip_fini);
489MODULE_LICENSE("GPL");
Vasiliy Kulikov8909c9a2011-03-02 00:33:13 +0300490MODULE_ALIAS_NETDEV("tunl0");