blob: 915d215a7d145028ced69ea6e17f2c0ff40d1c7f [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,
Dmitry Popov23468292014-06-06 23:19:21 +0400152 t->parms.link, 0, IPPROTO_IPIP, 0);
David S. Miller36393392012-06-14 22:21:46 -0700153 err = 0;
154 goto out;
155 }
156
David S. Miller55be7a92012-07-11 21:27:49 -0700157 if (type == ICMP_REDIRECT) {
Dmitry Popov23468292014-06-06 23:19:21 +0400158 ipv4_redirect(skb, dev_net(skb->dev), t->parms.link, 0,
David S. Miller55be7a92012-07-11 21:27:49 -0700159 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 iph = ip_hdr(skb);
Pravin B Shelarfd581562013-03-25 14:49:41 +0000194 tunnel = ip_tunnel_lookup(itn, skb->dev->ifindex, TUNNEL_NO_KEY,
195 iph->saddr, iph->daddr, 0);
196 if (tunnel) {
stephen hemmingereccc1bb2012-09-25 11:02:48 +0000197 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb))
198 goto drop;
Li Hongjun737e8282013-08-28 11:54:50 +0200199 if (iptunnel_pull_header(skb, 0, tpi.proto))
200 goto drop;
Pravin B Shelarfd581562013-03-25 14:49:41 +0000201 return ip_tunnel_rcv(tunnel, skb, &tpi, log_ecn_error);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204 return -1;
stephen hemmingereccc1bb2012-09-25 11:02:48 +0000205
206drop:
207 kfree_skb(skb);
208 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209}
210
211/*
212 * This function assumes it is being called from dev_queue_xmit()
213 * and that skb is filled properly by that function.
214 */
Stephen Hemminger6fef4c02009-08-31 19:50:41 +0000215static netdev_tx_t ipip_tunnel_xmit(struct sk_buff *skb, struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216{
Patrick McHardy2941a482006-01-08 22:05:26 -0800217 struct ip_tunnel *tunnel = netdev_priv(dev);
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000218 const struct iphdr *tiph = &tunnel->parms.iph;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219
Pravin B Shelarfd581562013-03-25 14:49:41 +0000220 if (unlikely(skb->protocol != htons(ETH_P_IP)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221 goto tx_error;
Eric Dumazetcef401d2013-01-25 20:34:37 +0000222
Eric Dumazetcb32f512013-10-19 11:42:57 -0700223 skb = iptunnel_handle_offloads(skb, false, SKB_GSO_IPIP);
224 if (IS_ERR(skb))
225 goto out;
Pravin B Shelar4f3ed922013-03-08 15:12:52 +0000226
Tom Herbert077c5a02014-09-29 20:22:31 -0700227 skb_set_inner_ipproto(skb, IPPROTO_IPIP);
228
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 Dumazet3acfa1e2014-01-18 18:27:49 -0800233 kfree_skb(skb);
Eric Dumazetcb32f512013-10-19 11:42:57 -0700234out:
235 dev->stats.tx_errors++;
Patrick McHardy6ed10652009-06-23 06:03:08 +0000236 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237}
238
239static int
Pravin B Shelarfd581562013-03-25 14:49:41 +0000240ipip_tunnel_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241{
242 int err = 0;
243 struct ip_tunnel_parm p;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244
Pravin B Shelarfd581562013-03-25 14:49:41 +0000245 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
246 return -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247
Cong Wang3b7b5142013-07-02 14:49:34 +0800248 if (cmd == SIOCADDTUNNEL || cmd == SIOCCHGTUNNEL) {
249 if (p.iph.version != 4 || p.iph.protocol != IPPROTO_IPIP ||
250 p.iph.ihl != 5 || (p.iph.frag_off&htons(~IP_DF)))
251 return -EINVAL;
252 }
253
254 p.i_key = p.o_key = p.i_flags = p.o_flags = 0;
Pravin B Shelarfd581562013-03-25 14:49:41 +0000255 if (p.iph.ttl)
256 p.iph.frag_off |= htons(IP_DF);
257
258 err = ip_tunnel_ioctl(dev, &p, cmd);
259 if (err)
260 return err;
261
262 if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p)))
263 return -EFAULT;
264
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265 return 0;
266}
267
Stephen Hemminger23a12b12008-11-20 20:33:21 -0800268static const struct net_device_ops ipip_netdev_ops = {
Pravin B Shelarfd581562013-03-25 14:49:41 +0000269 .ndo_init = ipip_tunnel_init,
270 .ndo_uninit = ip_tunnel_uninit,
Stephen Hemminger23a12b12008-11-20 20:33:21 -0800271 .ndo_start_xmit = ipip_tunnel_xmit,
272 .ndo_do_ioctl = ipip_tunnel_ioctl,
Pravin B Shelarfd581562013-03-25 14:49:41 +0000273 .ndo_change_mtu = ip_tunnel_change_mtu,
274 .ndo_get_stats64 = ip_tunnel_get_stats64,
Stephen Hemminger23a12b12008-11-20 20:33:21 -0800275};
276
Eric Dumazetc3b89fb2012-11-08 09:59:52 +0000277#define IPIP_FEATURES (NETIF_F_SG | \
278 NETIF_F_FRAGLIST | \
279 NETIF_F_HIGHDMA | \
Eric Dumazetcb32f512013-10-19 11:42:57 -0700280 NETIF_F_GSO_SOFTWARE | \
Eric Dumazetc3b89fb2012-11-08 09:59:52 +0000281 NETIF_F_HW_CSUM)
282
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283static void ipip_tunnel_setup(struct net_device *dev)
284{
Stephen Hemminger23a12b12008-11-20 20:33:21 -0800285 dev->netdev_ops = &ipip_netdev_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286
287 dev->type = ARPHRD_TUNNEL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288 dev->flags = IFF_NOARP;
289 dev->iflink = 0;
290 dev->addr_len = 4;
Eric Dumazet153f0942010-09-28 00:17:17 +0000291 dev->features |= NETIF_F_LLTX;
Eric Dumazet02875872014-10-05 18:38:35 -0700292 netif_keep_dst(dev);
Eric Dumazetc3b89fb2012-11-08 09:59:52 +0000293
294 dev->features |= IPIP_FEATURES;
295 dev->hw_features |= IPIP_FEATURES;
Pravin B Shelarfd581562013-03-25 14:49:41 +0000296 ip_tunnel_setup(dev, ipip_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297}
298
Eric Dumazet3c97af92010-09-27 00:35:50 +0000299static int ipip_tunnel_init(struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300{
Stephen Hemminger23a12b12008-11-20 20:33:21 -0800301 struct ip_tunnel *tunnel = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303 memcpy(dev->dev_addr, &tunnel->parms.iph.saddr, 4);
304 memcpy(dev->broadcast, &tunnel->parms.iph.daddr, 4);
305
Tom Herbert473ab822014-09-17 12:26:00 -0700306 tunnel->tun_hlen = 0;
307 tunnel->hlen = tunnel->tun_hlen + tunnel->encap_hlen;
Pravin B Shelarfd581562013-03-25 14:49:41 +0000308 tunnel->parms.iph.protocol = IPPROTO_IPIP;
309 return ip_tunnel_init(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310}
311
Nicolas Dichtelbe42da02012-11-14 05:14:03 +0000312static void ipip_netlink_parms(struct nlattr *data[],
313 struct ip_tunnel_parm *parms)
314{
315 memset(parms, 0, sizeof(*parms));
316
317 parms->iph.version = 4;
318 parms->iph.protocol = IPPROTO_IPIP;
319 parms->iph.ihl = 5;
320
321 if (!data)
322 return;
323
324 if (data[IFLA_IPTUN_LINK])
325 parms->link = nla_get_u32(data[IFLA_IPTUN_LINK]);
326
327 if (data[IFLA_IPTUN_LOCAL])
Nicolas Dichtelfea379b2012-11-15 04:06:40 +0000328 parms->iph.saddr = nla_get_be32(data[IFLA_IPTUN_LOCAL]);
Nicolas Dichtelbe42da02012-11-14 05:14:03 +0000329
330 if (data[IFLA_IPTUN_REMOTE])
Nicolas Dichtelfea379b2012-11-15 04:06:40 +0000331 parms->iph.daddr = nla_get_be32(data[IFLA_IPTUN_REMOTE]);
Nicolas Dichtelbe42da02012-11-14 05:14:03 +0000332
333 if (data[IFLA_IPTUN_TTL]) {
334 parms->iph.ttl = nla_get_u8(data[IFLA_IPTUN_TTL]);
335 if (parms->iph.ttl)
336 parms->iph.frag_off = htons(IP_DF);
337 }
338
339 if (data[IFLA_IPTUN_TOS])
340 parms->iph.tos = nla_get_u8(data[IFLA_IPTUN_TOS]);
341
342 if (!data[IFLA_IPTUN_PMTUDISC] || nla_get_u8(data[IFLA_IPTUN_PMTUDISC]))
343 parms->iph.frag_off = htons(IP_DF);
344}
345
Tom Herbert473ab822014-09-17 12:26:00 -0700346/* This function returns true when ENCAP attributes are present in the nl msg */
347static bool ipip_netlink_encap_parms(struct nlattr *data[],
348 struct ip_tunnel_encap *ipencap)
349{
350 bool ret = false;
351
352 memset(ipencap, 0, sizeof(*ipencap));
353
354 if (!data)
355 return ret;
356
357 if (data[IFLA_IPTUN_ENCAP_TYPE]) {
358 ret = true;
359 ipencap->type = nla_get_u16(data[IFLA_IPTUN_ENCAP_TYPE]);
360 }
361
362 if (data[IFLA_IPTUN_ENCAP_FLAGS]) {
363 ret = true;
364 ipencap->flags = nla_get_u16(data[IFLA_IPTUN_ENCAP_FLAGS]);
365 }
366
367 if (data[IFLA_IPTUN_ENCAP_SPORT]) {
368 ret = true;
Sabrina Dubroca3e97fa72015-02-06 17:22:22 +0100369 ipencap->sport = nla_get_be16(data[IFLA_IPTUN_ENCAP_SPORT]);
Tom Herbert473ab822014-09-17 12:26:00 -0700370 }
371
372 if (data[IFLA_IPTUN_ENCAP_DPORT]) {
373 ret = true;
Sabrina Dubroca3e97fa72015-02-06 17:22:22 +0100374 ipencap->dport = nla_get_be16(data[IFLA_IPTUN_ENCAP_DPORT]);
Tom Herbert473ab822014-09-17 12:26:00 -0700375 }
376
377 return ret;
378}
379
Nicolas Dichtelbe42da02012-11-14 05:14:03 +0000380static int ipip_newlink(struct net *src_net, struct net_device *dev,
381 struct nlattr *tb[], struct nlattr *data[])
382{
Pravin B Shelarfd581562013-03-25 14:49:41 +0000383 struct ip_tunnel_parm p;
Tom Herbert473ab822014-09-17 12:26:00 -0700384 struct ip_tunnel_encap ipencap;
385
386 if (ipip_netlink_encap_parms(data, &ipencap)) {
387 struct ip_tunnel *t = netdev_priv(dev);
388 int err = ip_tunnel_encap_setup(t, &ipencap);
389
390 if (err < 0)
391 return err;
392 }
Nicolas Dichtelbe42da02012-11-14 05:14:03 +0000393
Pravin B Shelarfd581562013-03-25 14:49:41 +0000394 ipip_netlink_parms(data, &p);
395 return ip_tunnel_newlink(dev, tb, &p);
Nicolas Dichtelbe42da02012-11-14 05:14:03 +0000396}
397
398static int ipip_changelink(struct net_device *dev, struct nlattr *tb[],
399 struct nlattr *data[])
400{
Nicolas Dichtelbe42da02012-11-14 05:14:03 +0000401 struct ip_tunnel_parm p;
Tom Herbert473ab822014-09-17 12:26:00 -0700402 struct ip_tunnel_encap ipencap;
403
404 if (ipip_netlink_encap_parms(data, &ipencap)) {
405 struct ip_tunnel *t = netdev_priv(dev);
406 int err = ip_tunnel_encap_setup(t, &ipencap);
407
408 if (err < 0)
409 return err;
410 }
Nicolas Dichtelbe42da02012-11-14 05:14:03 +0000411
412 ipip_netlink_parms(data, &p);
413
414 if (((dev->flags & IFF_POINTOPOINT) && !p.iph.daddr) ||
415 (!(dev->flags & IFF_POINTOPOINT) && p.iph.daddr))
416 return -EINVAL;
417
Pravin B Shelarfd581562013-03-25 14:49:41 +0000418 return ip_tunnel_changelink(dev, tb, &p);
Nicolas Dichtelbe42da02012-11-14 05:14:03 +0000419}
420
Nicolas Dichtel09746582012-11-09 06:09:59 +0000421static size_t ipip_get_size(const struct net_device *dev)
422{
423 return
424 /* IFLA_IPTUN_LINK */
425 nla_total_size(4) +
426 /* IFLA_IPTUN_LOCAL */
427 nla_total_size(4) +
428 /* IFLA_IPTUN_REMOTE */
429 nla_total_size(4) +
430 /* IFLA_IPTUN_TTL */
431 nla_total_size(1) +
432 /* IFLA_IPTUN_TOS */
433 nla_total_size(1) +
Nicolas Dichtelbefe2aa2012-11-14 05:14:02 +0000434 /* IFLA_IPTUN_PMTUDISC */
435 nla_total_size(1) +
Tom Herbert473ab822014-09-17 12:26:00 -0700436 /* IFLA_IPTUN_ENCAP_TYPE */
437 nla_total_size(2) +
438 /* IFLA_IPTUN_ENCAP_FLAGS */
439 nla_total_size(2) +
440 /* IFLA_IPTUN_ENCAP_SPORT */
441 nla_total_size(2) +
442 /* IFLA_IPTUN_ENCAP_DPORT */
443 nla_total_size(2) +
Nicolas Dichtel09746582012-11-09 06:09:59 +0000444 0;
445}
446
447static int ipip_fill_info(struct sk_buff *skb, const struct net_device *dev)
448{
449 struct ip_tunnel *tunnel = netdev_priv(dev);
450 struct ip_tunnel_parm *parm = &tunnel->parms;
451
452 if (nla_put_u32(skb, IFLA_IPTUN_LINK, parm->link) ||
453 nla_put_be32(skb, IFLA_IPTUN_LOCAL, parm->iph.saddr) ||
454 nla_put_be32(skb, IFLA_IPTUN_REMOTE, parm->iph.daddr) ||
455 nla_put_u8(skb, IFLA_IPTUN_TTL, parm->iph.ttl) ||
Nicolas Dichtelbefe2aa2012-11-14 05:14:02 +0000456 nla_put_u8(skb, IFLA_IPTUN_TOS, parm->iph.tos) ||
457 nla_put_u8(skb, IFLA_IPTUN_PMTUDISC,
458 !!(parm->iph.frag_off & htons(IP_DF))))
Nicolas Dichtel09746582012-11-09 06:09:59 +0000459 goto nla_put_failure;
Tom Herbert473ab822014-09-17 12:26:00 -0700460
461 if (nla_put_u16(skb, IFLA_IPTUN_ENCAP_TYPE,
462 tunnel->encap.type) ||
Sabrina Dubroca3e97fa72015-02-06 17:22:22 +0100463 nla_put_be16(skb, IFLA_IPTUN_ENCAP_SPORT,
464 tunnel->encap.sport) ||
465 nla_put_be16(skb, IFLA_IPTUN_ENCAP_DPORT,
466 tunnel->encap.dport) ||
Tom Herbert473ab822014-09-17 12:26:00 -0700467 nla_put_u16(skb, IFLA_IPTUN_ENCAP_FLAGS,
Tom Herberte1b2cb62014-11-05 16:49:38 -0800468 tunnel->encap.flags))
Tom Herbert473ab822014-09-17 12:26:00 -0700469 goto nla_put_failure;
470
Nicolas Dichtel09746582012-11-09 06:09:59 +0000471 return 0;
472
473nla_put_failure:
474 return -EMSGSIZE;
475}
476
Nicolas Dichtelbe42da02012-11-14 05:14:03 +0000477static const struct nla_policy ipip_policy[IFLA_IPTUN_MAX + 1] = {
478 [IFLA_IPTUN_LINK] = { .type = NLA_U32 },
479 [IFLA_IPTUN_LOCAL] = { .type = NLA_U32 },
480 [IFLA_IPTUN_REMOTE] = { .type = NLA_U32 },
481 [IFLA_IPTUN_TTL] = { .type = NLA_U8 },
482 [IFLA_IPTUN_TOS] = { .type = NLA_U8 },
483 [IFLA_IPTUN_PMTUDISC] = { .type = NLA_U8 },
Tom Herbert473ab822014-09-17 12:26:00 -0700484 [IFLA_IPTUN_ENCAP_TYPE] = { .type = NLA_U16 },
485 [IFLA_IPTUN_ENCAP_FLAGS] = { .type = NLA_U16 },
486 [IFLA_IPTUN_ENCAP_SPORT] = { .type = NLA_U16 },
487 [IFLA_IPTUN_ENCAP_DPORT] = { .type = NLA_U16 },
Nicolas Dichtelbe42da02012-11-14 05:14:03 +0000488};
489
Nicolas Dichtel09746582012-11-09 06:09:59 +0000490static struct rtnl_link_ops ipip_link_ops __read_mostly = {
491 .kind = "ipip",
492 .maxtype = IFLA_IPTUN_MAX,
Nicolas Dichtelbe42da02012-11-14 05:14:03 +0000493 .policy = ipip_policy,
Nicolas Dichtel09746582012-11-09 06:09:59 +0000494 .priv_size = sizeof(struct ip_tunnel),
Nicolas Dichtelbe42da02012-11-14 05:14:03 +0000495 .setup = ipip_tunnel_setup,
496 .newlink = ipip_newlink,
497 .changelink = ipip_changelink,
Pravin B Shelarfd581562013-03-25 14:49:41 +0000498 .dellink = ip_tunnel_dellink,
Nicolas Dichtel09746582012-11-09 06:09:59 +0000499 .get_size = ipip_get_size,
500 .fill_info = ipip_fill_info,
Nicolas Dichtel1728d4f2015-01-15 15:11:17 +0100501 .get_link_net = ip_tunnel_get_link_net,
Nicolas Dichtel09746582012-11-09 06:09:59 +0000502};
503
Eric Dumazet6dcd8142010-08-30 07:04:14 +0000504static struct xfrm_tunnel ipip_handler __read_mostly = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505 .handler = ipip_rcv,
506 .err_handler = ipip_err,
Herbert Xud2acc342006-03-28 01:12:13 -0800507 .priority = 1,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508};
509
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +0000510static int __net_init ipip_init_net(struct net *net)
Pavel Emelyanov10dc4c72008-04-16 01:03:13 -0700511{
Pravin B Shelarfd581562013-03-25 14:49:41 +0000512 return ip_tunnel_init_net(net, ipip_net_id, &ipip_link_ops, "tunl0");
Pavel Emelyanov10dc4c72008-04-16 01:03:13 -0700513}
514
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +0000515static void __net_exit ipip_exit_net(struct net *net)
Pavel Emelyanov10dc4c72008-04-16 01:03:13 -0700516{
Pravin B Shelarfd581562013-03-25 14:49:41 +0000517 struct ip_tunnel_net *itn = net_generic(net, ipip_net_id);
Nicolas Dichtel6c742e72013-08-13 17:51:11 +0200518 ip_tunnel_delete_net(itn, &ipip_link_ops);
Pavel Emelyanov10dc4c72008-04-16 01:03:13 -0700519}
520
521static struct pernet_operations ipip_net_ops = {
522 .init = ipip_init_net,
523 .exit = ipip_exit_net,
Eric W. Biederman86de8a62009-11-29 15:46:14 +0000524 .id = &ipip_net_id,
Pravin B Shelarfd581562013-03-25 14:49:41 +0000525 .size = sizeof(struct ip_tunnel_net),
Pavel Emelyanov10dc4c72008-04-16 01:03:13 -0700526};
527
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528static int __init ipip_init(void)
529{
530 int err;
531
Pravin B Shelarfd581562013-03-25 14:49:41 +0000532 pr_info("ipip: IPv4 over IPv4 tunneling driver\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533
Eric W. Biederman86de8a62009-11-29 15:46:14 +0000534 err = register_pernet_device(&ipip_net_ops);
Alexey Dobriyand5aa4072010-02-16 09:05:04 +0000535 if (err < 0)
536 return err;
537 err = xfrm4_tunnel_register(&ipip_handler, AF_INET);
538 if (err < 0) {
Joe Perches058bd4d2012-03-11 18:36:11 +0000539 pr_info("%s: can't register tunnel\n", __func__);
Nicolas Dichtel09746582012-11-09 06:09:59 +0000540 goto xfrm_tunnel_failed;
Alexey Dobriyand5aa4072010-02-16 09:05:04 +0000541 }
Nicolas Dichtel09746582012-11-09 06:09:59 +0000542 err = rtnl_link_register(&ipip_link_ops);
543 if (err < 0)
544 goto rtnl_link_failed;
545
546out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547 return err;
Nicolas Dichtel09746582012-11-09 06:09:59 +0000548
549rtnl_link_failed:
550 xfrm4_tunnel_deregister(&ipip_handler, AF_INET);
551xfrm_tunnel_failed:
552 unregister_pernet_device(&ipip_net_ops);
553 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554}
555
556static void __exit ipip_fini(void)
557{
Nicolas Dichtel09746582012-11-09 06:09:59 +0000558 rtnl_link_unregister(&ipip_link_ops);
Kazunori MIYAZAWAc0d56402007-02-13 12:54:47 -0800559 if (xfrm4_tunnel_deregister(&ipip_handler, AF_INET))
Joe Perches058bd4d2012-03-11 18:36:11 +0000560 pr_info("%s: can't deregister tunnel\n", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561
Eric W. Biederman86de8a62009-11-29 15:46:14 +0000562 unregister_pernet_device(&ipip_net_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563}
564
565module_init(ipip_init);
566module_exit(ipip_fini);
567MODULE_LICENSE("GPL");
Tom Gundersenf98f89a2014-05-15 23:21:30 +0200568MODULE_ALIAS_RTNL_LINK("ipip");
Vasiliy Kulikov8909c9a2011-03-02 00:33:13 +0300569MODULE_ALIAS_NETDEV("tunl0");