blob: 191fc24a745a9668332f74106fd39831d9f01c53 [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>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114#include <net/ipip.h>
115#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
120#define HASH_SIZE 16
Al Virod5a0a1e2006-11-08 00:23:14 -0800121#define HASH(addr) (((__force u32)addr^((__force u32)addr>>4))&0xF)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122
stephen hemmingereccc1bb2012-09-25 11:02:48 +0000123static bool log_ecn_error = true;
124module_param(log_ecn_error, bool, 0644);
125MODULE_PARM_DESC(log_ecn_error, "Log packets received with corrupted ECN");
126
Eric Dumazetf99189b2009-11-17 10:42:49 +0000127static int ipip_net_id __read_mostly;
Pavel Emelyanov10dc4c72008-04-16 01:03:13 -0700128struct ipip_net {
Eric Dumazetb7285b72010-09-15 11:07:24 +0000129 struct ip_tunnel __rcu *tunnels_r_l[HASH_SIZE];
130 struct ip_tunnel __rcu *tunnels_r[HASH_SIZE];
131 struct ip_tunnel __rcu *tunnels_l[HASH_SIZE];
132 struct ip_tunnel __rcu *tunnels_wc[1];
133 struct ip_tunnel __rcu **tunnels[4];
Pavel Emelyanov44d3c292008-04-16 01:05:32 -0700134
Pavel Emelyanovb9855c52008-04-16 01:04:13 -0700135 struct net_device *fb_tunnel_dev;
Pavel Emelyanov10dc4c72008-04-16 01:03:13 -0700136};
137
Eric Dumazet3c97af92010-09-27 00:35:50 +0000138static int ipip_tunnel_init(struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139static void ipip_tunnel_setup(struct net_device *dev);
Eric Dumazet3c97af92010-09-27 00:35:50 +0000140static void ipip_dev_free(struct net_device *dev);
Nicolas Dichtel09746582012-11-09 06:09:59 +0000141static struct rtnl_link_ops ipip_link_ops __read_mostly;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142
stephen hemminger87b6d212012-04-12 06:31:16 +0000143static struct rtnl_link_stats64 *ipip_get_stats64(struct net_device *dev,
144 struct rtnl_link_stats64 *tot)
Eric Dumazet3c97af92010-09-27 00:35:50 +0000145{
Eric Dumazet3c97af92010-09-27 00:35:50 +0000146 int i;
147
148 for_each_possible_cpu(i) {
149 const struct pcpu_tstats *tstats = per_cpu_ptr(dev->tstats, i);
stephen hemminger87b6d212012-04-12 06:31:16 +0000150 u64 rx_packets, rx_bytes, tx_packets, tx_bytes;
151 unsigned int start;
Eric Dumazet3c97af92010-09-27 00:35:50 +0000152
stephen hemminger87b6d212012-04-12 06:31:16 +0000153 do {
154 start = u64_stats_fetch_begin_bh(&tstats->syncp);
155 rx_packets = tstats->rx_packets;
156 tx_packets = tstats->tx_packets;
157 rx_bytes = tstats->rx_bytes;
158 tx_bytes = tstats->tx_bytes;
159 } while (u64_stats_fetch_retry_bh(&tstats->syncp, start));
160
161 tot->rx_packets += rx_packets;
162 tot->tx_packets += tx_packets;
163 tot->rx_bytes += rx_bytes;
164 tot->tx_bytes += tx_bytes;
Eric Dumazet3c97af92010-09-27 00:35:50 +0000165 }
stephen hemminger87b6d212012-04-12 06:31:16 +0000166
167 tot->tx_fifo_errors = dev->stats.tx_fifo_errors;
168 tot->tx_carrier_errors = dev->stats.tx_carrier_errors;
169 tot->tx_dropped = dev->stats.tx_dropped;
170 tot->tx_aborted_errors = dev->stats.tx_aborted_errors;
171 tot->tx_errors = dev->stats.tx_errors;
172 tot->collisions = dev->stats.collisions;
173
174 return tot;
Eric Dumazet3c97af92010-09-27 00:35:50 +0000175}
176
Daniel Baluta5e73ea12012-04-15 01:34:41 +0000177static struct ip_tunnel *ipip_tunnel_lookup(struct net *net,
Pavel Emelyanovb9fae5c2008-04-16 01:04:35 -0700178 __be32 remote, __be32 local)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179{
Eric Dumazetb7285b72010-09-15 11:07:24 +0000180 unsigned int h0 = HASH(remote);
181 unsigned int h1 = HASH(local);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182 struct ip_tunnel *t;
Pavel Emelyanov44d3c292008-04-16 01:05:32 -0700183 struct ipip_net *ipn = net_generic(net, ipip_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184
Amerigo Wange086cad2012-11-11 21:52:34 +0000185 for_each_ip_tunnel_rcu(t, ipn->tunnels_r_l[h0 ^ h1])
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186 if (local == t->parms.iph.saddr &&
187 remote == t->parms.iph.daddr && (t->dev->flags&IFF_UP))
188 return t;
Eric Dumazet8f95dd62009-10-23 05:42:02 +0000189
Amerigo Wange086cad2012-11-11 21:52:34 +0000190 for_each_ip_tunnel_rcu(t, ipn->tunnels_r[h0])
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191 if (remote == t->parms.iph.daddr && (t->dev->flags&IFF_UP))
192 return t;
Eric Dumazet8f95dd62009-10-23 05:42:02 +0000193
Amerigo Wange086cad2012-11-11 21:52:34 +0000194 for_each_ip_tunnel_rcu(t, ipn->tunnels_l[h1])
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195 if (local == t->parms.iph.saddr && (t->dev->flags&IFF_UP))
196 return t;
Eric Dumazet8f95dd62009-10-23 05:42:02 +0000197
198 t = rcu_dereference(ipn->tunnels_wc[0]);
199 if (t && (t->dev->flags&IFF_UP))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200 return t;
201 return NULL;
202}
203
Eric Dumazetb7285b72010-09-15 11:07:24 +0000204static struct ip_tunnel __rcu **__ipip_bucket(struct ipip_net *ipn,
Pavel Emelyanovb9fae5c2008-04-16 01:04:35 -0700205 struct ip_tunnel_parm *parms)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206{
YOSHIFUJI Hideaki87d1a162007-04-24 20:44:47 +0900207 __be32 remote = parms->iph.daddr;
208 __be32 local = parms->iph.saddr;
Eric Dumazetb7285b72010-09-15 11:07:24 +0000209 unsigned int h = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210 int prio = 0;
211
212 if (remote) {
213 prio |= 2;
214 h ^= HASH(remote);
215 }
216 if (local) {
217 prio |= 1;
218 h ^= HASH(local);
219 }
Pavel Emelyanov44d3c292008-04-16 01:05:32 -0700220 return &ipn->tunnels[prio][h];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221}
222
Eric Dumazetb7285b72010-09-15 11:07:24 +0000223static inline struct ip_tunnel __rcu **ipip_bucket(struct ipip_net *ipn,
Pavel Emelyanovb9fae5c2008-04-16 01:04:35 -0700224 struct ip_tunnel *t)
YOSHIFUJI Hideaki87d1a162007-04-24 20:44:47 +0900225{
Pavel Emelyanovb9fae5c2008-04-16 01:04:35 -0700226 return __ipip_bucket(ipn, &t->parms);
YOSHIFUJI Hideaki87d1a162007-04-24 20:44:47 +0900227}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228
Pavel Emelyanovb9fae5c2008-04-16 01:04:35 -0700229static void ipip_tunnel_unlink(struct ipip_net *ipn, struct ip_tunnel *t)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230{
Eric Dumazetb7285b72010-09-15 11:07:24 +0000231 struct ip_tunnel __rcu **tp;
232 struct ip_tunnel *iter;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233
Eric Dumazetb7285b72010-09-15 11:07:24 +0000234 for (tp = ipip_bucket(ipn, t);
235 (iter = rtnl_dereference(*tp)) != NULL;
236 tp = &iter->next) {
237 if (t == iter) {
Eric Dumazetcf778b02012-01-12 04:41:32 +0000238 rcu_assign_pointer(*tp, t->next);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239 break;
240 }
241 }
242}
243
Pavel Emelyanovb9fae5c2008-04-16 01:04:35 -0700244static void ipip_tunnel_link(struct ipip_net *ipn, struct ip_tunnel *t)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245{
Eric Dumazetb7285b72010-09-15 11:07:24 +0000246 struct ip_tunnel __rcu **tp = ipip_bucket(ipn, t);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247
Eric Dumazetcf778b02012-01-12 04:41:32 +0000248 rcu_assign_pointer(t->next, rtnl_dereference(*tp));
249 rcu_assign_pointer(*tp, t);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250}
251
Nicolas Dichtelbe42da02012-11-14 05:14:03 +0000252static int ipip_tunnel_create(struct net_device *dev)
253{
254 struct ip_tunnel *t = netdev_priv(dev);
255 struct net *net = dev_net(dev);
256 struct ipip_net *ipn = net_generic(net, ipip_net_id);
257 int err;
258
259 err = ipip_tunnel_init(dev);
260 if (err < 0)
261 goto out;
262
263 err = register_netdevice(dev);
264 if (err < 0)
265 goto out;
266
267 strcpy(t->parms.name, dev->name);
268 dev->rtnl_link_ops = &ipip_link_ops;
269
270 dev_hold(dev);
271 ipip_tunnel_link(ipn, t);
272 return 0;
273
274out:
275 return err;
276}
277
Daniel Baluta5e73ea12012-04-15 01:34:41 +0000278static struct ip_tunnel *ipip_tunnel_locate(struct net *net,
Pavel Emelyanovb9fae5c2008-04-16 01:04:35 -0700279 struct ip_tunnel_parm *parms, int create)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280{
Al Virod5a0a1e2006-11-08 00:23:14 -0800281 __be32 remote = parms->iph.daddr;
282 __be32 local = parms->iph.saddr;
Eric Dumazetb7285b72010-09-15 11:07:24 +0000283 struct ip_tunnel *t, *nt;
284 struct ip_tunnel __rcu **tp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285 struct net_device *dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286 char name[IFNAMSIZ];
Pavel Emelyanovb9fae5c2008-04-16 01:04:35 -0700287 struct ipip_net *ipn = net_generic(net, ipip_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288
Eric Dumazetb7285b72010-09-15 11:07:24 +0000289 for (tp = __ipip_bucket(ipn, parms);
290 (t = rtnl_dereference(*tp)) != NULL;
291 tp = &t->next) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292 if (local == t->parms.iph.saddr && remote == t->parms.iph.daddr)
293 return t;
294 }
295 if (!create)
296 return NULL;
297
298 if (parms->name[0])
299 strlcpy(name, parms->name, IFNAMSIZ);
Pavel Emelyanov34cc7ba2008-02-23 20:19:20 -0800300 else
Eric Dumazet3c97af92010-09-27 00:35:50 +0000301 strcpy(name, "tunl%d");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302
303 dev = alloc_netdev(sizeof(*t), name, ipip_tunnel_setup);
304 if (dev == NULL)
305 return NULL;
306
Pavel Emelyanov0a826402008-04-16 01:06:18 -0700307 dev_net_set(dev, net);
308
Patrick McHardy2941a482006-01-08 22:05:26 -0800309 nt = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310 nt->parms = *parms;
311
Nicolas Dichtelbe42da02012-11-14 05:14:03 +0000312 if (ipip_tunnel_create(dev) < 0)
Eric Dumazet3c97af92010-09-27 00:35:50 +0000313 goto failed_free;
Stephen Hemminger23a12b12008-11-20 20:33:21 -0800314
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315 return nt;
316
Pavel Emelyanovb37d428b2008-02-26 23:51:04 -0800317failed_free:
Eric Dumazet3c97af92010-09-27 00:35:50 +0000318 ipip_dev_free(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319 return NULL;
320}
321
Eric Dumazetb7285b72010-09-15 11:07:24 +0000322/* called with RTNL */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323static void ipip_tunnel_uninit(struct net_device *dev)
324{
Pavel Emelyanovb9855c52008-04-16 01:04:13 -0700325 struct net *net = dev_net(dev);
326 struct ipip_net *ipn = net_generic(net, ipip_net_id);
327
Eric Dumazetb7285b72010-09-15 11:07:24 +0000328 if (dev == ipn->fb_tunnel_dev)
Stephen Hemmingera9b3cd72011-08-01 16:19:00 +0000329 RCU_INIT_POINTER(ipn->tunnels_wc[0], NULL);
Eric Dumazetb7285b72010-09-15 11:07:24 +0000330 else
Pavel Emelyanovb9fae5c2008-04-16 01:04:35 -0700331 ipip_tunnel_unlink(ipn, netdev_priv(dev));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332 dev_put(dev);
333}
334
Herbert Xud2acc342006-03-28 01:12:13 -0800335static int ipip_err(struct sk_buff *skb, u32 info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337
Rami Rosen071f92d2008-05-21 17:47:54 -0700338/* All the routers (except for Linux) return only
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339 8 bytes of packet payload. It means, that precise relaying of
340 ICMP in the real Internet is absolutely infeasible.
341 */
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000342 const struct iphdr *iph = (const struct iphdr *)skb->data;
Arnaldo Carvalho de Melo88c76642007-03-13 14:43:18 -0300343 const int type = icmp_hdr(skb)->type;
344 const int code = icmp_hdr(skb)->code;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345 struct ip_tunnel *t;
Herbert Xud2acc342006-03-28 01:12:13 -0800346 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347
348 switch (type) {
349 default:
350 case ICMP_PARAMETERPROB:
Herbert Xud2acc342006-03-28 01:12:13 -0800351 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352
353 case ICMP_DEST_UNREACH:
354 switch (code) {
355 case ICMP_SR_FAILED:
356 case ICMP_PORT_UNREACH:
357 /* Impossible event. */
Herbert Xud2acc342006-03-28 01:12:13 -0800358 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359 default:
360 /* All others are translated to HOST_UNREACH.
361 rfc2003 contains "deep thoughts" about NET_UNREACH,
362 I believe they are just ether pollution. --ANK
363 */
364 break;
365 }
366 break;
367 case ICMP_TIME_EXCEEDED:
368 if (code != ICMP_EXC_TTL)
Herbert Xud2acc342006-03-28 01:12:13 -0800369 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370 break;
David S. Miller55be7a92012-07-11 21:27:49 -0700371 case ICMP_REDIRECT:
372 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373 }
374
Herbert Xud2acc342006-03-28 01:12:13 -0800375 err = -ENOENT;
Pavel Emelyanovcec3ffa2008-04-16 01:05:03 -0700376 t = ipip_tunnel_lookup(dev_net(skb->dev), iph->daddr, iph->saddr);
David S. Miller36393392012-06-14 22:21:46 -0700377 if (t == NULL)
378 goto out;
379
380 if (type == ICMP_DEST_UNREACH && code == ICMP_FRAG_NEEDED) {
381 ipv4_update_pmtu(skb, dev_net(skb->dev), info,
382 t->dev->ifindex, 0, IPPROTO_IPIP, 0);
383 err = 0;
384 goto out;
385 }
386
David S. Miller55be7a92012-07-11 21:27:49 -0700387 if (type == ICMP_REDIRECT) {
388 ipv4_redirect(skb, dev_net(skb->dev), t->dev->ifindex, 0,
389 IPPROTO_IPIP, 0);
390 err = 0;
391 goto out;
392 }
393
David S. Miller36393392012-06-14 22:21:46 -0700394 if (t->parms.iph.daddr == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395 goto out;
Herbert Xud2acc342006-03-28 01:12:13 -0800396
397 err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398 if (t->parms.iph.ttl == 0 && type == ICMP_TIME_EXCEEDED)
399 goto out;
400
Wei Yongjun26d94b42009-02-24 23:36:47 -0800401 if (time_before(jiffies, t->err_time + IPTUNNEL_ERR_TIMEO))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 t->err_count++;
403 else
404 t->err_count = 1;
405 t->err_time = jiffies;
406out:
stephen hemmingerb0558ef2012-09-24 18:12:25 +0000407
Herbert Xud2acc342006-03-28 01:12:13 -0800408 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409}
410
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411static int ipip_rcv(struct sk_buff *skb)
412{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413 struct ip_tunnel *tunnel;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700414 const struct iphdr *iph = ip_hdr(skb);
stephen hemmingereccc1bb2012-09-25 11:02:48 +0000415 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416
Eric Dumazet3c97af92010-09-27 00:35:50 +0000417 tunnel = ipip_tunnel_lookup(dev_net(skb->dev), iph->saddr, iph->daddr);
418 if (tunnel != NULL) {
419 struct pcpu_tstats *tstats;
420
stephen hemmingereccc1bb2012-09-25 11:02:48 +0000421 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb))
422 goto drop;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423
424 secpath_reset(skb);
425
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -0700426 skb->mac_header = skb->network_header;
Arnaldo Carvalho de Meloc1d2bbe2007-04-10 20:45:18 -0700427 skb_reset_network_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428 skb->protocol = htons(ETH_P_IP);
429 skb->pkt_type = PACKET_HOST;
430
stephen hemmingereccc1bb2012-09-25 11:02:48 +0000431 __skb_tunnel_rx(skb, tunnel->dev);
432
433 err = IP_ECN_decapsulate(iph, skb);
434 if (unlikely(err)) {
435 if (log_ecn_error)
436 net_info_ratelimited("non-ECT from %pI4 with TOS=%#x\n",
437 &iph->saddr, iph->tos);
438 if (err > 1) {
439 ++tunnel->dev->stats.rx_frame_errors;
440 ++tunnel->dev->stats.rx_errors;
441 goto drop;
442 }
443 }
444
Eric Dumazet3c97af92010-09-27 00:35:50 +0000445 tstats = this_cpu_ptr(tunnel->dev->tstats);
stephen hemminger87b6d212012-04-12 06:31:16 +0000446 u64_stats_update_begin(&tstats->syncp);
Eric Dumazet3c97af92010-09-27 00:35:50 +0000447 tstats->rx_packets++;
448 tstats->rx_bytes += skb->len;
stephen hemminger87b6d212012-04-12 06:31:16 +0000449 u64_stats_update_end(&tstats->syncp);
Eric Dumazet3c97af92010-09-27 00:35:50 +0000450
Eric Dumazetcaf586e2010-09-30 21:06:55 +0000451 netif_rx(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452 return 0;
453 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455 return -1;
stephen hemmingereccc1bb2012-09-25 11:02:48 +0000456
457drop:
458 kfree_skb(skb);
459 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460}
461
462/*
463 * This function assumes it is being called from dev_queue_xmit()
464 * and that skb is filled properly by that function.
465 */
466
Stephen Hemminger6fef4c02009-08-31 19:50:41 +0000467static netdev_tx_t ipip_tunnel_xmit(struct sk_buff *skb, struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468{
Patrick McHardy2941a482006-01-08 22:05:26 -0800469 struct ip_tunnel *tunnel = netdev_priv(dev);
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000470 const struct iphdr *tiph = &tunnel->parms.iph;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471 u8 tos = tunnel->parms.iph.tos;
Al Virod5a0a1e2006-11-08 00:23:14 -0800472 __be16 df = tiph->frag_off;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473 struct rtable *rt; /* Route to the other host */
Eric Dumazet3c97af92010-09-27 00:35:50 +0000474 struct net_device *tdev; /* Device to other host */
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000475 const struct iphdr *old_iph = ip_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476 struct iphdr *iph; /* Our new IP header */
Chuck Leverc2636b42007-10-23 21:07:32 -0700477 unsigned int max_headroom; /* The extra header space needed */
Al Virod5a0a1e2006-11-08 00:23:14 -0800478 __be32 dst = tiph->daddr;
David S. Miller31e4543d2011-05-03 20:25:42 -0700479 struct flowi4 fl4;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480 int mtu;
481
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482 if (skb->protocol != htons(ETH_P_IP))
483 goto tx_error;
484
Eric Dumazetc3b89fb2012-11-08 09:59:52 +0000485 if (skb->ip_summed == CHECKSUM_PARTIAL &&
486 skb_checksum_help(skb))
487 goto tx_error;
488
Eric Dumazet3c97af92010-09-27 00:35:50 +0000489 if (tos & 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490 tos = old_iph->tos;
491
492 if (!dst) {
493 /* NBMA tunnel */
Eric Dumazet511c3f92009-06-02 05:14:27 +0000494 if ((rt = skb_rtable(skb)) == NULL) {
Eric Dumazet3c97af92010-09-27 00:35:50 +0000495 dev->stats.tx_fifo_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496 goto tx_error;
497 }
David S. Millerf8126f12012-07-13 05:03:45 -0700498 dst = rt_nexthop(rt, old_iph->daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499 }
500
David S. Miller31e4543d2011-05-03 20:25:42 -0700501 rt = ip_route_output_ports(dev_net(dev), &fl4, NULL,
David S. Miller78fbfd82011-03-12 00:00:52 -0500502 dst, tiph->saddr,
503 0, 0,
504 IPPROTO_IPIP, RT_TOS(tos),
505 tunnel->parms.link);
506 if (IS_ERR(rt)) {
507 dev->stats.tx_carrier_errors++;
508 goto tx_error_icmp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509 }
Changli Gaod8d1f302010-06-10 23:31:35 -0700510 tdev = rt->dst.dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511
512 if (tdev == dev) {
513 ip_rt_put(rt);
Eric Dumazet3c97af92010-09-27 00:35:50 +0000514 dev->stats.collisions++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515 goto tx_error;
516 }
517
Herbert Xu23ca0c92009-11-06 10:37:41 +0000518 df |= old_iph->frag_off & htons(IP_DF);
519
520 if (df) {
Changli Gaod8d1f302010-06-10 23:31:35 -0700521 mtu = dst_mtu(&rt->dst) - sizeof(struct iphdr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522
Herbert Xu23ca0c92009-11-06 10:37:41 +0000523 if (mtu < 68) {
Eric Dumazet3c97af92010-09-27 00:35:50 +0000524 dev->stats.collisions++;
Herbert Xu23ca0c92009-11-06 10:37:41 +0000525 ip_rt_put(rt);
526 goto tx_error;
527 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528
Herbert Xu23ca0c92009-11-06 10:37:41 +0000529 if (skb_dst(skb))
David S. Miller6700c272012-07-17 03:29:28 -0700530 skb_dst(skb)->ops->update_pmtu(skb_dst(skb), NULL, skb, mtu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531
Herbert Xu23ca0c92009-11-06 10:37:41 +0000532 if ((old_iph->frag_off & htons(IP_DF)) &&
533 mtu < ntohs(old_iph->tot_len)) {
534 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED,
535 htonl(mtu));
536 ip_rt_put(rt);
537 goto tx_error;
538 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539 }
540
541 if (tunnel->err_count > 0) {
Wei Yongjun26d94b42009-02-24 23:36:47 -0800542 if (time_before(jiffies,
543 tunnel->err_time + IPTUNNEL_ERR_TIMEO)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544 tunnel->err_count--;
545 dst_link_failure(skb);
546 } else
547 tunnel->err_count = 0;
548 }
549
550 /*
551 * Okay, now see if we can stuff it in the buffer as-is.
552 */
553 max_headroom = (LL_RESERVED_SPACE(tdev)+sizeof(struct iphdr));
554
Patrick McHardycfbba492007-07-09 15:33:40 -0700555 if (skb_headroom(skb) < max_headroom || skb_shared(skb) ||
556 (skb_cloned(skb) && !skb_clone_writable(skb, 0))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557 struct sk_buff *new_skb = skb_realloc_headroom(skb, max_headroom);
558 if (!new_skb) {
559 ip_rt_put(rt);
Eric Dumazet3c97af92010-09-27 00:35:50 +0000560 dev->stats.tx_dropped++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561 dev_kfree_skb(skb);
Patrick McHardy6ed10652009-06-23 06:03:08 +0000562 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563 }
564 if (skb->sk)
565 skb_set_owner_w(new_skb, skb->sk);
566 dev_kfree_skb(skb);
567 skb = new_skb;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700568 old_iph = ip_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569 }
570
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -0700571 skb->transport_header = skb->network_header;
Arnaldo Carvalho de Meloe2d1bca2007-04-10 20:46:21 -0700572 skb_push(skb, sizeof(struct iphdr));
573 skb_reset_network_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574 memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
Patrick McHardy48d5cad2006-02-15 15:10:22 -0800575 IPCB(skb)->flags &= ~(IPSKB_XFRM_TUNNEL_SIZE | IPSKB_XFRM_TRANSFORMED |
576 IPSKB_REROUTED);
Eric Dumazetadf30902009-06-02 05:19:30 +0000577 skb_dst_drop(skb);
Changli Gaod8d1f302010-06-10 23:31:35 -0700578 skb_dst_set(skb, &rt->dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579
580 /*
581 * Push down and install the IPIP header.
582 */
583
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700584 iph = ip_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585 iph->version = 4;
586 iph->ihl = sizeof(struct iphdr)>>2;
587 iph->frag_off = df;
588 iph->protocol = IPPROTO_IPIP;
589 iph->tos = INET_ECN_encapsulate(tos, old_iph->tos);
David S. Miller69458cb2011-05-04 11:10:28 -0700590 iph->daddr = fl4.daddr;
591 iph->saddr = fl4.saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592
593 if ((iph->ttl = tiph->ttl) == 0)
594 iph->ttl = old_iph->ttl;
595
Amerigo Wangaa0010f2012-11-11 21:52:33 +0000596 iptunnel_xmit(skb, dev);
Patrick McHardy6ed10652009-06-23 06:03:08 +0000597 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598
599tx_error_icmp:
600 dst_link_failure(skb);
601tx_error:
Eric Dumazet3c97af92010-09-27 00:35:50 +0000602 dev->stats.tx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700603 dev_kfree_skb(skb);
Patrick McHardy6ed10652009-06-23 06:03:08 +0000604 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605}
606
Michal Schmidt55339952007-12-12 11:01:43 -0800607static void ipip_tunnel_bind_dev(struct net_device *dev)
608{
609 struct net_device *tdev = NULL;
610 struct ip_tunnel *tunnel;
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000611 const struct iphdr *iph;
Michal Schmidt55339952007-12-12 11:01:43 -0800612
613 tunnel = netdev_priv(dev);
614 iph = &tunnel->parms.iph;
615
616 if (iph->daddr) {
David S. Miller31e4543d2011-05-03 20:25:42 -0700617 struct rtable *rt;
618 struct flowi4 fl4;
Eric Dumazet3c97af92010-09-27 00:35:50 +0000619
David S. Miller31e4543d2011-05-03 20:25:42 -0700620 rt = ip_route_output_ports(dev_net(dev), &fl4, NULL,
621 iph->daddr, iph->saddr,
622 0, 0,
623 IPPROTO_IPIP,
624 RT_TOS(iph->tos),
625 tunnel->parms.link);
David S. Millerb23dd4f2011-03-02 14:31:35 -0800626 if (!IS_ERR(rt)) {
Changli Gaod8d1f302010-06-10 23:31:35 -0700627 tdev = rt->dst.dev;
Michal Schmidt55339952007-12-12 11:01:43 -0800628 ip_rt_put(rt);
629 }
630 dev->flags |= IFF_POINTOPOINT;
631 }
632
633 if (!tdev && tunnel->parms.link)
Pavel Emelyanovb99f0152008-04-16 01:05:57 -0700634 tdev = __dev_get_by_index(dev_net(dev), tunnel->parms.link);
Michal Schmidt55339952007-12-12 11:01:43 -0800635
636 if (tdev) {
637 dev->hard_header_len = tdev->hard_header_len + sizeof(struct iphdr);
638 dev->mtu = tdev->mtu - sizeof(struct iphdr);
639 }
640 dev->iflink = tunnel->parms.link;
641}
642
Nicolas Dichtelbe42da02012-11-14 05:14:03 +0000643static void ipip_tunnel_update(struct ip_tunnel *t, struct ip_tunnel_parm *p)
644{
645 struct net *net = dev_net(t->dev);
646 struct ipip_net *ipn = net_generic(net, ipip_net_id);
647
648 ipip_tunnel_unlink(ipn, t);
649 synchronize_net();
650 t->parms.iph.saddr = p->iph.saddr;
651 t->parms.iph.daddr = p->iph.daddr;
652 memcpy(t->dev->dev_addr, &p->iph.saddr, 4);
653 memcpy(t->dev->broadcast, &p->iph.daddr, 4);
654 ipip_tunnel_link(ipn, t);
655 t->parms.iph.ttl = p->iph.ttl;
656 t->parms.iph.tos = p->iph.tos;
657 t->parms.iph.frag_off = p->iph.frag_off;
658 if (t->parms.link != p->link) {
659 t->parms.link = p->link;
660 ipip_tunnel_bind_dev(t->dev);
661 }
662 netdev_state_change(t->dev);
663}
664
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665static int
666ipip_tunnel_ioctl (struct net_device *dev, struct ifreq *ifr, int cmd)
667{
668 int err = 0;
669 struct ip_tunnel_parm p;
670 struct ip_tunnel *t;
Pavel Emelyanovb9855c52008-04-16 01:04:13 -0700671 struct net *net = dev_net(dev);
672 struct ipip_net *ipn = net_generic(net, ipip_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673
674 switch (cmd) {
675 case SIOCGETTUNNEL:
676 t = NULL;
Pavel Emelyanovb9855c52008-04-16 01:04:13 -0700677 if (dev == ipn->fb_tunnel_dev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700678 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p))) {
679 err = -EFAULT;
680 break;
681 }
Pavel Emelyanovb9fae5c2008-04-16 01:04:35 -0700682 t = ipip_tunnel_locate(net, &p, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683 }
684 if (t == NULL)
Patrick McHardy2941a482006-01-08 22:05:26 -0800685 t = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686 memcpy(&p, &t->parms, sizeof(p));
687 if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p)))
688 err = -EFAULT;
689 break;
690
691 case SIOCADDTUNNEL:
692 case SIOCCHGTUNNEL:
693 err = -EPERM;
Eric W. Biederman52e804c2012-11-16 03:03:05 +0000694 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695 goto done;
696
697 err = -EFAULT;
698 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
699 goto done;
700
701 err = -EINVAL;
702 if (p.iph.version != 4 || p.iph.protocol != IPPROTO_IPIP ||
703 p.iph.ihl != 5 || (p.iph.frag_off&htons(~IP_DF)))
704 goto done;
705 if (p.iph.ttl)
706 p.iph.frag_off |= htons(IP_DF);
707
Pavel Emelyanovb9fae5c2008-04-16 01:04:35 -0700708 t = ipip_tunnel_locate(net, &p, cmd == SIOCADDTUNNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709
Pavel Emelyanovb9855c52008-04-16 01:04:13 -0700710 if (dev != ipn->fb_tunnel_dev && cmd == SIOCCHGTUNNEL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711 if (t != NULL) {
712 if (t->dev != dev) {
713 err = -EEXIST;
714 break;
715 }
716 } else {
717 if (((dev->flags&IFF_POINTOPOINT) && !p.iph.daddr) ||
718 (!(dev->flags&IFF_POINTOPOINT) && p.iph.daddr)) {
719 err = -EINVAL;
720 break;
721 }
Patrick McHardy2941a482006-01-08 22:05:26 -0800722 t = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723 }
Nicolas Dichtelc38cc4b2012-11-14 05:14:01 +0000724
Nicolas Dichtelbe42da02012-11-14 05:14:03 +0000725 ipip_tunnel_update(t, &p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726 }
727
728 if (t) {
729 err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730 if (copy_to_user(ifr->ifr_ifru.ifru_data, &t->parms, sizeof(p)))
731 err = -EFAULT;
732 } else
733 err = (cmd == SIOCADDTUNNEL ? -ENOBUFS : -ENOENT);
734 break;
735
736 case SIOCDELTUNNEL:
737 err = -EPERM;
Eric W. Biederman52e804c2012-11-16 03:03:05 +0000738 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739 goto done;
740
Pavel Emelyanovb9855c52008-04-16 01:04:13 -0700741 if (dev == ipn->fb_tunnel_dev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742 err = -EFAULT;
743 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
744 goto done;
745 err = -ENOENT;
Pavel Emelyanovb9fae5c2008-04-16 01:04:35 -0700746 if ((t = ipip_tunnel_locate(net, &p, 0)) == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700747 goto done;
748 err = -EPERM;
Pavel Emelyanovb9855c52008-04-16 01:04:13 -0700749 if (t->dev == ipn->fb_tunnel_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750 goto done;
751 dev = t->dev;
752 }
Stephen Hemminger22f8cde2007-02-07 00:09:58 -0800753 unregister_netdevice(dev);
754 err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700755 break;
756
757 default:
758 err = -EINVAL;
759 }
760
761done:
762 return err;
763}
764
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765static int ipip_tunnel_change_mtu(struct net_device *dev, int new_mtu)
766{
767 if (new_mtu < 68 || new_mtu > 0xFFF8 - sizeof(struct iphdr))
768 return -EINVAL;
769 dev->mtu = new_mtu;
770 return 0;
771}
772
Stephen Hemminger23a12b12008-11-20 20:33:21 -0800773static const struct net_device_ops ipip_netdev_ops = {
774 .ndo_uninit = ipip_tunnel_uninit,
775 .ndo_start_xmit = ipip_tunnel_xmit,
776 .ndo_do_ioctl = ipip_tunnel_ioctl,
777 .ndo_change_mtu = ipip_tunnel_change_mtu,
stephen hemminger87b6d212012-04-12 06:31:16 +0000778 .ndo_get_stats64 = ipip_get_stats64,
Stephen Hemminger23a12b12008-11-20 20:33:21 -0800779};
780
Eric Dumazet3c97af92010-09-27 00:35:50 +0000781static void ipip_dev_free(struct net_device *dev)
782{
783 free_percpu(dev->tstats);
784 free_netdev(dev);
785}
786
Eric Dumazetc3b89fb2012-11-08 09:59:52 +0000787#define IPIP_FEATURES (NETIF_F_SG | \
788 NETIF_F_FRAGLIST | \
789 NETIF_F_HIGHDMA | \
790 NETIF_F_HW_CSUM)
791
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792static void ipip_tunnel_setup(struct net_device *dev)
793{
Stephen Hemminger23a12b12008-11-20 20:33:21 -0800794 dev->netdev_ops = &ipip_netdev_ops;
Eric Dumazet3c97af92010-09-27 00:35:50 +0000795 dev->destructor = ipip_dev_free;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796
797 dev->type = ARPHRD_TUNNEL;
798 dev->hard_header_len = LL_MAX_HEADER + sizeof(struct iphdr);
Kris Katterjohn46f25df2006-01-05 16:35:42 -0800799 dev->mtu = ETH_DATA_LEN - sizeof(struct iphdr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700800 dev->flags = IFF_NOARP;
801 dev->iflink = 0;
802 dev->addr_len = 4;
Pavel Emelyanov0a826402008-04-16 01:06:18 -0700803 dev->features |= NETIF_F_NETNS_LOCAL;
Eric Dumazet153f0942010-09-28 00:17:17 +0000804 dev->features |= NETIF_F_LLTX;
Eric Dumazet28e72212009-05-28 10:44:30 +0000805 dev->priv_flags &= ~IFF_XMIT_DST_RELEASE;
Eric Dumazetc3b89fb2012-11-08 09:59:52 +0000806
807 dev->features |= IPIP_FEATURES;
808 dev->hw_features |= IPIP_FEATURES;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700809}
810
Eric Dumazet3c97af92010-09-27 00:35:50 +0000811static int ipip_tunnel_init(struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700812{
Stephen Hemminger23a12b12008-11-20 20:33:21 -0800813 struct ip_tunnel *tunnel = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700814
815 tunnel->dev = dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700816
817 memcpy(dev->dev_addr, &tunnel->parms.iph.saddr, 4);
818 memcpy(dev->broadcast, &tunnel->parms.iph.daddr, 4);
819
Michal Schmidt55339952007-12-12 11:01:43 -0800820 ipip_tunnel_bind_dev(dev);
Eric Dumazet3c97af92010-09-27 00:35:50 +0000821
822 dev->tstats = alloc_percpu(struct pcpu_tstats);
823 if (!dev->tstats)
824 return -ENOMEM;
825
826 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827}
828
Eric Dumazetfada5632010-09-27 23:56:46 +0000829static int __net_init ipip_fb_tunnel_init(struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830{
Patrick McHardy2941a482006-01-08 22:05:26 -0800831 struct ip_tunnel *tunnel = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832 struct iphdr *iph = &tunnel->parms.iph;
Pavel Emelyanov44d3c292008-04-16 01:05:32 -0700833 struct ipip_net *ipn = net_generic(dev_net(dev), ipip_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834
835 tunnel->dev = dev;
836 strcpy(tunnel->parms.name, dev->name);
837
838 iph->version = 4;
839 iph->protocol = IPPROTO_IPIP;
840 iph->ihl = 5;
841
Eric Dumazetfada5632010-09-27 23:56:46 +0000842 dev->tstats = alloc_percpu(struct pcpu_tstats);
843 if (!dev->tstats)
844 return -ENOMEM;
845
Linus Torvalds1da177e2005-04-16 15:20:36 -0700846 dev_hold(dev);
Eric Dumazetcf778b02012-01-12 04:41:32 +0000847 rcu_assign_pointer(ipn->tunnels_wc[0], tunnel);
Eric Dumazetfada5632010-09-27 23:56:46 +0000848 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700849}
850
Nicolas Dichtelbe42da02012-11-14 05:14:03 +0000851static void ipip_netlink_parms(struct nlattr *data[],
852 struct ip_tunnel_parm *parms)
853{
854 memset(parms, 0, sizeof(*parms));
855
856 parms->iph.version = 4;
857 parms->iph.protocol = IPPROTO_IPIP;
858 parms->iph.ihl = 5;
859
860 if (!data)
861 return;
862
863 if (data[IFLA_IPTUN_LINK])
864 parms->link = nla_get_u32(data[IFLA_IPTUN_LINK]);
865
866 if (data[IFLA_IPTUN_LOCAL])
Nicolas Dichtelfea379b2012-11-15 04:06:40 +0000867 parms->iph.saddr = nla_get_be32(data[IFLA_IPTUN_LOCAL]);
Nicolas Dichtelbe42da02012-11-14 05:14:03 +0000868
869 if (data[IFLA_IPTUN_REMOTE])
Nicolas Dichtelfea379b2012-11-15 04:06:40 +0000870 parms->iph.daddr = nla_get_be32(data[IFLA_IPTUN_REMOTE]);
Nicolas Dichtelbe42da02012-11-14 05:14:03 +0000871
872 if (data[IFLA_IPTUN_TTL]) {
873 parms->iph.ttl = nla_get_u8(data[IFLA_IPTUN_TTL]);
874 if (parms->iph.ttl)
875 parms->iph.frag_off = htons(IP_DF);
876 }
877
878 if (data[IFLA_IPTUN_TOS])
879 parms->iph.tos = nla_get_u8(data[IFLA_IPTUN_TOS]);
880
881 if (!data[IFLA_IPTUN_PMTUDISC] || nla_get_u8(data[IFLA_IPTUN_PMTUDISC]))
882 parms->iph.frag_off = htons(IP_DF);
883}
884
885static int ipip_newlink(struct net *src_net, struct net_device *dev,
886 struct nlattr *tb[], struct nlattr *data[])
887{
888 struct net *net = dev_net(dev);
889 struct ip_tunnel *nt;
890
891 nt = netdev_priv(dev);
892 ipip_netlink_parms(data, &nt->parms);
893
894 if (ipip_tunnel_locate(net, &nt->parms, 0))
895 return -EEXIST;
896
897 return ipip_tunnel_create(dev);
898}
899
900static int ipip_changelink(struct net_device *dev, struct nlattr *tb[],
901 struct nlattr *data[])
902{
903 struct ip_tunnel *t;
904 struct ip_tunnel_parm p;
905 struct net *net = dev_net(dev);
906 struct ipip_net *ipn = net_generic(net, ipip_net_id);
907
908 if (dev == ipn->fb_tunnel_dev)
909 return -EINVAL;
910
911 ipip_netlink_parms(data, &p);
912
913 if (((dev->flags & IFF_POINTOPOINT) && !p.iph.daddr) ||
914 (!(dev->flags & IFF_POINTOPOINT) && p.iph.daddr))
915 return -EINVAL;
916
917 t = ipip_tunnel_locate(net, &p, 0);
918
919 if (t) {
920 if (t->dev != dev)
921 return -EEXIST;
922 } else
923 t = netdev_priv(dev);
924
925 ipip_tunnel_update(t, &p);
926 return 0;
927}
928
Nicolas Dichtel09746582012-11-09 06:09:59 +0000929static size_t ipip_get_size(const struct net_device *dev)
930{
931 return
932 /* IFLA_IPTUN_LINK */
933 nla_total_size(4) +
934 /* IFLA_IPTUN_LOCAL */
935 nla_total_size(4) +
936 /* IFLA_IPTUN_REMOTE */
937 nla_total_size(4) +
938 /* IFLA_IPTUN_TTL */
939 nla_total_size(1) +
940 /* IFLA_IPTUN_TOS */
941 nla_total_size(1) +
Nicolas Dichtelbefe2aa2012-11-14 05:14:02 +0000942 /* IFLA_IPTUN_PMTUDISC */
943 nla_total_size(1) +
Nicolas Dichtel09746582012-11-09 06:09:59 +0000944 0;
945}
946
947static int ipip_fill_info(struct sk_buff *skb, const struct net_device *dev)
948{
949 struct ip_tunnel *tunnel = netdev_priv(dev);
950 struct ip_tunnel_parm *parm = &tunnel->parms;
951
952 if (nla_put_u32(skb, IFLA_IPTUN_LINK, parm->link) ||
953 nla_put_be32(skb, IFLA_IPTUN_LOCAL, parm->iph.saddr) ||
954 nla_put_be32(skb, IFLA_IPTUN_REMOTE, parm->iph.daddr) ||
955 nla_put_u8(skb, IFLA_IPTUN_TTL, parm->iph.ttl) ||
Nicolas Dichtelbefe2aa2012-11-14 05:14:02 +0000956 nla_put_u8(skb, IFLA_IPTUN_TOS, parm->iph.tos) ||
957 nla_put_u8(skb, IFLA_IPTUN_PMTUDISC,
958 !!(parm->iph.frag_off & htons(IP_DF))))
Nicolas Dichtel09746582012-11-09 06:09:59 +0000959 goto nla_put_failure;
960 return 0;
961
962nla_put_failure:
963 return -EMSGSIZE;
964}
965
Nicolas Dichtelbe42da02012-11-14 05:14:03 +0000966static const struct nla_policy ipip_policy[IFLA_IPTUN_MAX + 1] = {
967 [IFLA_IPTUN_LINK] = { .type = NLA_U32 },
968 [IFLA_IPTUN_LOCAL] = { .type = NLA_U32 },
969 [IFLA_IPTUN_REMOTE] = { .type = NLA_U32 },
970 [IFLA_IPTUN_TTL] = { .type = NLA_U8 },
971 [IFLA_IPTUN_TOS] = { .type = NLA_U8 },
972 [IFLA_IPTUN_PMTUDISC] = { .type = NLA_U8 },
973};
974
Nicolas Dichtel09746582012-11-09 06:09:59 +0000975static struct rtnl_link_ops ipip_link_ops __read_mostly = {
976 .kind = "ipip",
977 .maxtype = IFLA_IPTUN_MAX,
Nicolas Dichtelbe42da02012-11-14 05:14:03 +0000978 .policy = ipip_policy,
Nicolas Dichtel09746582012-11-09 06:09:59 +0000979 .priv_size = sizeof(struct ip_tunnel),
Nicolas Dichtelbe42da02012-11-14 05:14:03 +0000980 .setup = ipip_tunnel_setup,
981 .newlink = ipip_newlink,
982 .changelink = ipip_changelink,
Nicolas Dichtel09746582012-11-09 06:09:59 +0000983 .get_size = ipip_get_size,
984 .fill_info = ipip_fill_info,
985};
986
Eric Dumazet6dcd8142010-08-30 07:04:14 +0000987static struct xfrm_tunnel ipip_handler __read_mostly = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700988 .handler = ipip_rcv,
989 .err_handler = ipip_err,
Herbert Xud2acc342006-03-28 01:12:13 -0800990 .priority = 1,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700991};
992
Stephen Hemminger5747a1a2009-02-22 00:02:08 -0800993static const char banner[] __initconst =
Linus Torvalds1da177e2005-04-16 15:20:36 -0700994 KERN_INFO "IPv4 over IPv4 tunneling driver\n";
995
Eric Dumazet0694c4c2009-10-27 07:06:59 +0000996static void ipip_destroy_tunnels(struct ipip_net *ipn, struct list_head *head)
Pavel Emelyanov44d3c292008-04-16 01:05:32 -0700997{
998 int prio;
999
1000 for (prio = 1; prio < 4; prio++) {
1001 int h;
1002 for (h = 0; h < HASH_SIZE; h++) {
Eric Dumazetb7285b72010-09-15 11:07:24 +00001003 struct ip_tunnel *t;
Eric Dumazet0694c4c2009-10-27 07:06:59 +00001004
Eric Dumazetb7285b72010-09-15 11:07:24 +00001005 t = rtnl_dereference(ipn->tunnels[prio][h]);
Eric Dumazet0694c4c2009-10-27 07:06:59 +00001006 while (t != NULL) {
1007 unregister_netdevice_queue(t->dev, head);
Eric Dumazetb7285b72010-09-15 11:07:24 +00001008 t = rtnl_dereference(t->next);
Eric Dumazet0694c4c2009-10-27 07:06:59 +00001009 }
Pavel Emelyanov44d3c292008-04-16 01:05:32 -07001010 }
1011 }
1012}
1013
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00001014static int __net_init ipip_init_net(struct net *net)
Pavel Emelyanov10dc4c72008-04-16 01:03:13 -07001015{
Eric W. Biederman86de8a62009-11-29 15:46:14 +00001016 struct ipip_net *ipn = net_generic(net, ipip_net_id);
Ted Feng72b36012011-12-08 00:46:21 +00001017 struct ip_tunnel *t;
Pavel Emelyanov10dc4c72008-04-16 01:03:13 -07001018 int err;
Pavel Emelyanov10dc4c72008-04-16 01:03:13 -07001019
Pavel Emelyanov44d3c292008-04-16 01:05:32 -07001020 ipn->tunnels[0] = ipn->tunnels_wc;
1021 ipn->tunnels[1] = ipn->tunnels_l;
1022 ipn->tunnels[2] = ipn->tunnels_r;
1023 ipn->tunnels[3] = ipn->tunnels_r_l;
1024
Pavel Emelyanovb9855c52008-04-16 01:04:13 -07001025 ipn->fb_tunnel_dev = alloc_netdev(sizeof(struct ip_tunnel),
1026 "tunl0",
1027 ipip_tunnel_setup);
1028 if (!ipn->fb_tunnel_dev) {
1029 err = -ENOMEM;
1030 goto err_alloc_dev;
1031 }
Alexey Dobriyanbe77e592008-11-23 17:26:26 -08001032 dev_net_set(ipn->fb_tunnel_dev, net);
Pavel Emelyanovb9855c52008-04-16 01:04:13 -07001033
Eric Dumazetfada5632010-09-27 23:56:46 +00001034 err = ipip_fb_tunnel_init(ipn->fb_tunnel_dev);
1035 if (err)
1036 goto err_reg_dev;
Pavel Emelyanovb9855c52008-04-16 01:04:13 -07001037
1038 if ((err = register_netdev(ipn->fb_tunnel_dev)))
1039 goto err_reg_dev;
1040
Ted Feng72b36012011-12-08 00:46:21 +00001041 t = netdev_priv(ipn->fb_tunnel_dev);
1042
1043 strcpy(t->parms.name, ipn->fb_tunnel_dev->name);
Pavel Emelyanov10dc4c72008-04-16 01:03:13 -07001044 return 0;
1045
Pavel Emelyanovb9855c52008-04-16 01:04:13 -07001046err_reg_dev:
Eric Dumazetfada5632010-09-27 23:56:46 +00001047 ipip_dev_free(ipn->fb_tunnel_dev);
Pavel Emelyanovb9855c52008-04-16 01:04:13 -07001048err_alloc_dev:
1049 /* nothing */
Pavel Emelyanov10dc4c72008-04-16 01:03:13 -07001050 return err;
1051}
1052
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00001053static void __net_exit ipip_exit_net(struct net *net)
Pavel Emelyanov10dc4c72008-04-16 01:03:13 -07001054{
Eric W. Biederman86de8a62009-11-29 15:46:14 +00001055 struct ipip_net *ipn = net_generic(net, ipip_net_id);
Eric Dumazet0694c4c2009-10-27 07:06:59 +00001056 LIST_HEAD(list);
Pavel Emelyanov10dc4c72008-04-16 01:03:13 -07001057
Pavel Emelyanovb9855c52008-04-16 01:04:13 -07001058 rtnl_lock();
Eric Dumazet0694c4c2009-10-27 07:06:59 +00001059 ipip_destroy_tunnels(ipn, &list);
1060 unregister_netdevice_queue(ipn->fb_tunnel_dev, &list);
1061 unregister_netdevice_many(&list);
Pavel Emelyanovb9855c52008-04-16 01:04:13 -07001062 rtnl_unlock();
Pavel Emelyanov10dc4c72008-04-16 01:03:13 -07001063}
1064
1065static struct pernet_operations ipip_net_ops = {
1066 .init = ipip_init_net,
1067 .exit = ipip_exit_net,
Eric W. Biederman86de8a62009-11-29 15:46:14 +00001068 .id = &ipip_net_id,
1069 .size = sizeof(struct ipip_net),
Pavel Emelyanov10dc4c72008-04-16 01:03:13 -07001070};
1071
Linus Torvalds1da177e2005-04-16 15:20:36 -07001072static int __init ipip_init(void)
1073{
1074 int err;
1075
1076 printk(banner);
1077
Eric W. Biederman86de8a62009-11-29 15:46:14 +00001078 err = register_pernet_device(&ipip_net_ops);
Alexey Dobriyand5aa4072010-02-16 09:05:04 +00001079 if (err < 0)
1080 return err;
1081 err = xfrm4_tunnel_register(&ipip_handler, AF_INET);
1082 if (err < 0) {
Joe Perches058bd4d2012-03-11 18:36:11 +00001083 pr_info("%s: can't register tunnel\n", __func__);
Nicolas Dichtel09746582012-11-09 06:09:59 +00001084 goto xfrm_tunnel_failed;
Alexey Dobriyand5aa4072010-02-16 09:05:04 +00001085 }
Nicolas Dichtel09746582012-11-09 06:09:59 +00001086 err = rtnl_link_register(&ipip_link_ops);
1087 if (err < 0)
1088 goto rtnl_link_failed;
1089
1090out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001091 return err;
Nicolas Dichtel09746582012-11-09 06:09:59 +00001092
1093rtnl_link_failed:
1094 xfrm4_tunnel_deregister(&ipip_handler, AF_INET);
1095xfrm_tunnel_failed:
1096 unregister_pernet_device(&ipip_net_ops);
1097 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001098}
1099
1100static void __exit ipip_fini(void)
1101{
Nicolas Dichtel09746582012-11-09 06:09:59 +00001102 rtnl_link_unregister(&ipip_link_ops);
Kazunori MIYAZAWAc0d56402007-02-13 12:54:47 -08001103 if (xfrm4_tunnel_deregister(&ipip_handler, AF_INET))
Joe Perches058bd4d2012-03-11 18:36:11 +00001104 pr_info("%s: can't deregister tunnel\n", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001105
Eric W. Biederman86de8a62009-11-29 15:46:14 +00001106 unregister_pernet_device(&ipip_net_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001107}
1108
1109module_init(ipip_init);
1110module_exit(ipip_fini);
1111MODULE_LICENSE("GPL");
Vasiliy Kulikov8909c9a2011-03-02 00:33:13 +03001112MODULE_ALIAS_NETDEV("tunl0");