blob: 99af1f0cc65827c3faa40407c17b38527ac8a211 [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
Eric Dumazetf99189b2009-11-17 10:42:49 +0000123static int ipip_net_id __read_mostly;
Pavel Emelyanov10dc4c72008-04-16 01:03:13 -0700124struct ipip_net {
Eric Dumazetb7285b72010-09-15 11:07:24 +0000125 struct ip_tunnel __rcu *tunnels_r_l[HASH_SIZE];
126 struct ip_tunnel __rcu *tunnels_r[HASH_SIZE];
127 struct ip_tunnel __rcu *tunnels_l[HASH_SIZE];
128 struct ip_tunnel __rcu *tunnels_wc[1];
129 struct ip_tunnel __rcu **tunnels[4];
Pavel Emelyanov44d3c292008-04-16 01:05:32 -0700130
Pavel Emelyanovb9855c52008-04-16 01:04:13 -0700131 struct net_device *fb_tunnel_dev;
Pavel Emelyanov10dc4c72008-04-16 01:03:13 -0700132};
133
Eric Dumazet3c97af92010-09-27 00:35:50 +0000134static int ipip_tunnel_init(struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135static void ipip_tunnel_setup(struct net_device *dev);
Eric Dumazet3c97af92010-09-27 00:35:50 +0000136static void ipip_dev_free(struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137
Eric Dumazet8f95dd62009-10-23 05:42:02 +0000138/*
Eric Dumazetb7285b72010-09-15 11:07:24 +0000139 * Locking : hash tables are protected by RCU and RTNL
Eric Dumazet8f95dd62009-10-23 05:42:02 +0000140 */
Eric Dumazet8f95dd62009-10-23 05:42:02 +0000141
142#define for_each_ip_tunnel_rcu(start) \
143 for (t = rcu_dereference(start); t; t = rcu_dereference(t->next))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144
Eric Dumazet3c97af92010-09-27 00:35:50 +0000145/* often modified stats are per cpu, other are shared (netdev->stats) */
146struct pcpu_tstats {
stephen hemminger87b6d212012-04-12 06:31:16 +0000147 u64 rx_packets;
148 u64 rx_bytes;
149 u64 tx_packets;
150 u64 tx_bytes;
151 struct u64_stats_sync syncp;
152};
Eric Dumazet3c97af92010-09-27 00:35:50 +0000153
stephen hemminger87b6d212012-04-12 06:31:16 +0000154static struct rtnl_link_stats64 *ipip_get_stats64(struct net_device *dev,
155 struct rtnl_link_stats64 *tot)
Eric Dumazet3c97af92010-09-27 00:35:50 +0000156{
Eric Dumazet3c97af92010-09-27 00:35:50 +0000157 int i;
158
159 for_each_possible_cpu(i) {
160 const struct pcpu_tstats *tstats = per_cpu_ptr(dev->tstats, i);
stephen hemminger87b6d212012-04-12 06:31:16 +0000161 u64 rx_packets, rx_bytes, tx_packets, tx_bytes;
162 unsigned int start;
Eric Dumazet3c97af92010-09-27 00:35:50 +0000163
stephen hemminger87b6d212012-04-12 06:31:16 +0000164 do {
165 start = u64_stats_fetch_begin_bh(&tstats->syncp);
166 rx_packets = tstats->rx_packets;
167 tx_packets = tstats->tx_packets;
168 rx_bytes = tstats->rx_bytes;
169 tx_bytes = tstats->tx_bytes;
170 } while (u64_stats_fetch_retry_bh(&tstats->syncp, start));
171
172 tot->rx_packets += rx_packets;
173 tot->tx_packets += tx_packets;
174 tot->rx_bytes += rx_bytes;
175 tot->tx_bytes += tx_bytes;
Eric Dumazet3c97af92010-09-27 00:35:50 +0000176 }
stephen hemminger87b6d212012-04-12 06:31:16 +0000177
178 tot->tx_fifo_errors = dev->stats.tx_fifo_errors;
179 tot->tx_carrier_errors = dev->stats.tx_carrier_errors;
180 tot->tx_dropped = dev->stats.tx_dropped;
181 tot->tx_aborted_errors = dev->stats.tx_aborted_errors;
182 tot->tx_errors = dev->stats.tx_errors;
183 tot->collisions = dev->stats.collisions;
184
185 return tot;
Eric Dumazet3c97af92010-09-27 00:35:50 +0000186}
187
Daniel Baluta5e73ea12012-04-15 01:34:41 +0000188static struct ip_tunnel *ipip_tunnel_lookup(struct net *net,
Pavel Emelyanovb9fae5c2008-04-16 01:04:35 -0700189 __be32 remote, __be32 local)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190{
Eric Dumazetb7285b72010-09-15 11:07:24 +0000191 unsigned int h0 = HASH(remote);
192 unsigned int h1 = HASH(local);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193 struct ip_tunnel *t;
Pavel Emelyanov44d3c292008-04-16 01:05:32 -0700194 struct ipip_net *ipn = net_generic(net, ipip_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195
Eric Dumazet8f95dd62009-10-23 05:42:02 +0000196 for_each_ip_tunnel_rcu(ipn->tunnels_r_l[h0 ^ h1])
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 if (local == t->parms.iph.saddr &&
198 remote == t->parms.iph.daddr && (t->dev->flags&IFF_UP))
199 return t;
Eric Dumazet8f95dd62009-10-23 05:42:02 +0000200
201 for_each_ip_tunnel_rcu(ipn->tunnels_r[h0])
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202 if (remote == t->parms.iph.daddr && (t->dev->flags&IFF_UP))
203 return t;
Eric Dumazet8f95dd62009-10-23 05:42:02 +0000204
205 for_each_ip_tunnel_rcu(ipn->tunnels_l[h1])
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206 if (local == t->parms.iph.saddr && (t->dev->flags&IFF_UP))
207 return t;
Eric Dumazet8f95dd62009-10-23 05:42:02 +0000208
209 t = rcu_dereference(ipn->tunnels_wc[0]);
210 if (t && (t->dev->flags&IFF_UP))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211 return t;
212 return NULL;
213}
214
Eric Dumazetb7285b72010-09-15 11:07:24 +0000215static struct ip_tunnel __rcu **__ipip_bucket(struct ipip_net *ipn,
Pavel Emelyanovb9fae5c2008-04-16 01:04:35 -0700216 struct ip_tunnel_parm *parms)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217{
YOSHIFUJI Hideaki87d1a162007-04-24 20:44:47 +0900218 __be32 remote = parms->iph.daddr;
219 __be32 local = parms->iph.saddr;
Eric Dumazetb7285b72010-09-15 11:07:24 +0000220 unsigned int h = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221 int prio = 0;
222
223 if (remote) {
224 prio |= 2;
225 h ^= HASH(remote);
226 }
227 if (local) {
228 prio |= 1;
229 h ^= HASH(local);
230 }
Pavel Emelyanov44d3c292008-04-16 01:05:32 -0700231 return &ipn->tunnels[prio][h];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232}
233
Eric Dumazetb7285b72010-09-15 11:07:24 +0000234static inline struct ip_tunnel __rcu **ipip_bucket(struct ipip_net *ipn,
Pavel Emelyanovb9fae5c2008-04-16 01:04:35 -0700235 struct ip_tunnel *t)
YOSHIFUJI Hideaki87d1a162007-04-24 20:44:47 +0900236{
Pavel Emelyanovb9fae5c2008-04-16 01:04:35 -0700237 return __ipip_bucket(ipn, &t->parms);
YOSHIFUJI Hideaki87d1a162007-04-24 20:44:47 +0900238}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239
Pavel Emelyanovb9fae5c2008-04-16 01:04:35 -0700240static void ipip_tunnel_unlink(struct ipip_net *ipn, struct ip_tunnel *t)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241{
Eric Dumazetb7285b72010-09-15 11:07:24 +0000242 struct ip_tunnel __rcu **tp;
243 struct ip_tunnel *iter;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244
Eric Dumazetb7285b72010-09-15 11:07:24 +0000245 for (tp = ipip_bucket(ipn, t);
246 (iter = rtnl_dereference(*tp)) != NULL;
247 tp = &iter->next) {
248 if (t == iter) {
Eric Dumazetcf778b02012-01-12 04:41:32 +0000249 rcu_assign_pointer(*tp, t->next);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250 break;
251 }
252 }
253}
254
Pavel Emelyanovb9fae5c2008-04-16 01:04:35 -0700255static void ipip_tunnel_link(struct ipip_net *ipn, struct ip_tunnel *t)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256{
Eric Dumazetb7285b72010-09-15 11:07:24 +0000257 struct ip_tunnel __rcu **tp = ipip_bucket(ipn, t);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258
Eric Dumazetcf778b02012-01-12 04:41:32 +0000259 rcu_assign_pointer(t->next, rtnl_dereference(*tp));
260 rcu_assign_pointer(*tp, t);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261}
262
Daniel Baluta5e73ea12012-04-15 01:34:41 +0000263static struct ip_tunnel *ipip_tunnel_locate(struct net *net,
Pavel Emelyanovb9fae5c2008-04-16 01:04:35 -0700264 struct ip_tunnel_parm *parms, int create)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265{
Al Virod5a0a1e2006-11-08 00:23:14 -0800266 __be32 remote = parms->iph.daddr;
267 __be32 local = parms->iph.saddr;
Eric Dumazetb7285b72010-09-15 11:07:24 +0000268 struct ip_tunnel *t, *nt;
269 struct ip_tunnel __rcu **tp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270 struct net_device *dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271 char name[IFNAMSIZ];
Pavel Emelyanovb9fae5c2008-04-16 01:04:35 -0700272 struct ipip_net *ipn = net_generic(net, ipip_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273
Eric Dumazetb7285b72010-09-15 11:07:24 +0000274 for (tp = __ipip_bucket(ipn, parms);
275 (t = rtnl_dereference(*tp)) != NULL;
276 tp = &t->next) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277 if (local == t->parms.iph.saddr && remote == t->parms.iph.daddr)
278 return t;
279 }
280 if (!create)
281 return NULL;
282
283 if (parms->name[0])
284 strlcpy(name, parms->name, IFNAMSIZ);
Pavel Emelyanov34cc7ba2008-02-23 20:19:20 -0800285 else
Eric Dumazet3c97af92010-09-27 00:35:50 +0000286 strcpy(name, "tunl%d");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287
288 dev = alloc_netdev(sizeof(*t), name, ipip_tunnel_setup);
289 if (dev == NULL)
290 return NULL;
291
Pavel Emelyanov0a826402008-04-16 01:06:18 -0700292 dev_net_set(dev, net);
293
Patrick McHardy2941a482006-01-08 22:05:26 -0800294 nt = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295 nt->parms = *parms;
296
Eric Dumazet3c97af92010-09-27 00:35:50 +0000297 if (ipip_tunnel_init(dev) < 0)
298 goto failed_free;
Stephen Hemminger23a12b12008-11-20 20:33:21 -0800299
Pavel Emelyanovb37d428b2008-02-26 23:51:04 -0800300 if (register_netdevice(dev) < 0)
301 goto failed_free;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302
Ted Feng72b36012011-12-08 00:46:21 +0000303 strcpy(nt->parms.name, dev->name);
304
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305 dev_hold(dev);
Pavel Emelyanovb9fae5c2008-04-16 01:04:35 -0700306 ipip_tunnel_link(ipn, nt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307 return nt;
308
Pavel Emelyanovb37d428b2008-02-26 23:51:04 -0800309failed_free:
Eric Dumazet3c97af92010-09-27 00:35:50 +0000310 ipip_dev_free(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311 return NULL;
312}
313
Eric Dumazetb7285b72010-09-15 11:07:24 +0000314/* called with RTNL */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315static void ipip_tunnel_uninit(struct net_device *dev)
316{
Pavel Emelyanovb9855c52008-04-16 01:04:13 -0700317 struct net *net = dev_net(dev);
318 struct ipip_net *ipn = net_generic(net, ipip_net_id);
319
Eric Dumazetb7285b72010-09-15 11:07:24 +0000320 if (dev == ipn->fb_tunnel_dev)
Stephen Hemmingera9b3cd72011-08-01 16:19:00 +0000321 RCU_INIT_POINTER(ipn->tunnels_wc[0], NULL);
Eric Dumazetb7285b72010-09-15 11:07:24 +0000322 else
Pavel Emelyanovb9fae5c2008-04-16 01:04:35 -0700323 ipip_tunnel_unlink(ipn, netdev_priv(dev));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324 dev_put(dev);
325}
326
Herbert Xud2acc342006-03-28 01:12:13 -0800327static int ipip_err(struct sk_buff *skb, u32 info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329
Rami Rosen071f92d2008-05-21 17:47:54 -0700330/* All the routers (except for Linux) return only
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331 8 bytes of packet payload. It means, that precise relaying of
332 ICMP in the real Internet is absolutely infeasible.
333 */
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000334 const struct iphdr *iph = (const struct iphdr *)skb->data;
Arnaldo Carvalho de Melo88c76642007-03-13 14:43:18 -0300335 const int type = icmp_hdr(skb)->type;
336 const int code = icmp_hdr(skb)->code;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337 struct ip_tunnel *t;
Herbert Xud2acc342006-03-28 01:12:13 -0800338 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339
340 switch (type) {
341 default:
342 case ICMP_PARAMETERPROB:
Herbert Xud2acc342006-03-28 01:12:13 -0800343 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344
345 case ICMP_DEST_UNREACH:
346 switch (code) {
347 case ICMP_SR_FAILED:
348 case ICMP_PORT_UNREACH:
349 /* Impossible event. */
Herbert Xud2acc342006-03-28 01:12:13 -0800350 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351 default:
352 /* All others are translated to HOST_UNREACH.
353 rfc2003 contains "deep thoughts" about NET_UNREACH,
354 I believe they are just ether pollution. --ANK
355 */
356 break;
357 }
358 break;
359 case ICMP_TIME_EXCEEDED:
360 if (code != ICMP_EXC_TTL)
Herbert Xud2acc342006-03-28 01:12:13 -0800361 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362 break;
David S. Miller55be7a92012-07-11 21:27:49 -0700363 case ICMP_REDIRECT:
364 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365 }
366
Herbert Xud2acc342006-03-28 01:12:13 -0800367 err = -ENOENT;
368
Eric Dumazet8f95dd62009-10-23 05:42:02 +0000369 rcu_read_lock();
Pavel Emelyanovcec3ffa2008-04-16 01:05:03 -0700370 t = ipip_tunnel_lookup(dev_net(skb->dev), iph->daddr, iph->saddr);
David S. Miller36393392012-06-14 22:21:46 -0700371 if (t == NULL)
372 goto out;
373
374 if (type == ICMP_DEST_UNREACH && code == ICMP_FRAG_NEEDED) {
375 ipv4_update_pmtu(skb, dev_net(skb->dev), info,
376 t->dev->ifindex, 0, IPPROTO_IPIP, 0);
377 err = 0;
378 goto out;
379 }
380
David S. Miller55be7a92012-07-11 21:27:49 -0700381 if (type == ICMP_REDIRECT) {
382 ipv4_redirect(skb, dev_net(skb->dev), t->dev->ifindex, 0,
383 IPPROTO_IPIP, 0);
384 err = 0;
385 goto out;
386 }
387
David S. Miller36393392012-06-14 22:21:46 -0700388 if (t->parms.iph.daddr == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389 goto out;
Herbert Xud2acc342006-03-28 01:12:13 -0800390
391 err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392 if (t->parms.iph.ttl == 0 && type == ICMP_TIME_EXCEEDED)
393 goto out;
394
Wei Yongjun26d94b42009-02-24 23:36:47 -0800395 if (time_before(jiffies, t->err_time + IPTUNNEL_ERR_TIMEO))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396 t->err_count++;
397 else
398 t->err_count = 1;
399 t->err_time = jiffies;
400out:
Eric Dumazet8f95dd62009-10-23 05:42:02 +0000401 rcu_read_unlock();
Herbert Xud2acc342006-03-28 01:12:13 -0800402 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403}
404
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700405static inline void ipip_ecn_decapsulate(const struct iphdr *outer_iph,
406 struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407{
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700408 struct iphdr *inner_iph = ip_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409
410 if (INET_ECN_is_ce(outer_iph->tos))
411 IP_ECN_set_ce(inner_iph);
412}
413
414static int ipip_rcv(struct sk_buff *skb)
415{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 struct ip_tunnel *tunnel;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700417 const struct iphdr *iph = ip_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418
Eric Dumazet8f95dd62009-10-23 05:42:02 +0000419 rcu_read_lock();
Eric Dumazet3c97af92010-09-27 00:35:50 +0000420 tunnel = ipip_tunnel_lookup(dev_net(skb->dev), iph->saddr, iph->daddr);
421 if (tunnel != NULL) {
422 struct pcpu_tstats *tstats;
423
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424 if (!xfrm4_policy_check(NULL, XFRM_POLICY_IN, skb)) {
Eric Dumazet8f95dd62009-10-23 05:42:02 +0000425 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426 kfree_skb(skb);
427 return 0;
428 }
429
430 secpath_reset(skb);
431
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -0700432 skb->mac_header = skb->network_header;
Arnaldo Carvalho de Meloc1d2bbe2007-04-10 20:45:18 -0700433 skb_reset_network_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434 skb->protocol = htons(ETH_P_IP);
435 skb->pkt_type = PACKET_HOST;
436
Eric Dumazet3c97af92010-09-27 00:35:50 +0000437 tstats = this_cpu_ptr(tunnel->dev->tstats);
stephen hemminger87b6d212012-04-12 06:31:16 +0000438 u64_stats_update_begin(&tstats->syncp);
Eric Dumazet3c97af92010-09-27 00:35:50 +0000439 tstats->rx_packets++;
440 tstats->rx_bytes += skb->len;
stephen hemminger87b6d212012-04-12 06:31:16 +0000441 u64_stats_update_end(&tstats->syncp);
Eric Dumazet3c97af92010-09-27 00:35:50 +0000442
443 __skb_tunnel_rx(skb, tunnel->dev);
Eric Dumazetd19d56d2010-05-17 22:36:55 -0700444
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445 ipip_ecn_decapsulate(iph, skb);
Eric Dumazet8990f462010-09-20 00:12:11 +0000446
Eric Dumazetcaf586e2010-09-30 21:06:55 +0000447 netif_rx(skb);
Eric Dumazet8990f462010-09-20 00:12:11 +0000448
Eric Dumazet8f95dd62009-10-23 05:42:02 +0000449 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450 return 0;
451 }
Eric Dumazet8f95dd62009-10-23 05:42:02 +0000452 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454 return -1;
455}
456
457/*
458 * This function assumes it is being called from dev_queue_xmit()
459 * and that skb is filled properly by that function.
460 */
461
Stephen Hemminger6fef4c02009-08-31 19:50:41 +0000462static netdev_tx_t ipip_tunnel_xmit(struct sk_buff *skb, struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463{
Patrick McHardy2941a482006-01-08 22:05:26 -0800464 struct ip_tunnel *tunnel = netdev_priv(dev);
Eric Dumazet3c97af92010-09-27 00:35:50 +0000465 struct pcpu_tstats *tstats;
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000466 const struct iphdr *tiph = &tunnel->parms.iph;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467 u8 tos = tunnel->parms.iph.tos;
Al Virod5a0a1e2006-11-08 00:23:14 -0800468 __be16 df = tiph->frag_off;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469 struct rtable *rt; /* Route to the other host */
Eric Dumazet3c97af92010-09-27 00:35:50 +0000470 struct net_device *tdev; /* Device to other host */
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000471 const struct iphdr *old_iph = ip_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472 struct iphdr *iph; /* Our new IP header */
Chuck Leverc2636b42007-10-23 21:07:32 -0700473 unsigned int max_headroom; /* The extra header space needed */
Al Virod5a0a1e2006-11-08 00:23:14 -0800474 __be32 dst = tiph->daddr;
David S. Miller31e4543d2011-05-03 20:25:42 -0700475 struct flowi4 fl4;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476 int mtu;
477
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478 if (skb->protocol != htons(ETH_P_IP))
479 goto tx_error;
480
Eric Dumazet3c97af92010-09-27 00:35:50 +0000481 if (tos & 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482 tos = old_iph->tos;
483
484 if (!dst) {
485 /* NBMA tunnel */
Eric Dumazet511c3f92009-06-02 05:14:27 +0000486 if ((rt = skb_rtable(skb)) == NULL) {
Eric Dumazet3c97af92010-09-27 00:35:50 +0000487 dev->stats.tx_fifo_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488 goto tx_error;
489 }
David S. Millerf8126f12012-07-13 05:03:45 -0700490 dst = rt_nexthop(rt, old_iph->daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491 }
492
David S. Miller31e4543d2011-05-03 20:25:42 -0700493 rt = ip_route_output_ports(dev_net(dev), &fl4, NULL,
David S. Miller78fbfd82011-03-12 00:00:52 -0500494 dst, tiph->saddr,
495 0, 0,
496 IPPROTO_IPIP, RT_TOS(tos),
497 tunnel->parms.link);
498 if (IS_ERR(rt)) {
499 dev->stats.tx_carrier_errors++;
500 goto tx_error_icmp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501 }
Changli Gaod8d1f302010-06-10 23:31:35 -0700502 tdev = rt->dst.dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503
504 if (tdev == dev) {
505 ip_rt_put(rt);
Eric Dumazet3c97af92010-09-27 00:35:50 +0000506 dev->stats.collisions++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507 goto tx_error;
508 }
509
Herbert Xu23ca0c92009-11-06 10:37:41 +0000510 df |= old_iph->frag_off & htons(IP_DF);
511
512 if (df) {
Changli Gaod8d1f302010-06-10 23:31:35 -0700513 mtu = dst_mtu(&rt->dst) - sizeof(struct iphdr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514
Herbert Xu23ca0c92009-11-06 10:37:41 +0000515 if (mtu < 68) {
Eric Dumazet3c97af92010-09-27 00:35:50 +0000516 dev->stats.collisions++;
Herbert Xu23ca0c92009-11-06 10:37:41 +0000517 ip_rt_put(rt);
518 goto tx_error;
519 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520
Herbert Xu23ca0c92009-11-06 10:37:41 +0000521 if (skb_dst(skb))
David S. Miller6700c272012-07-17 03:29:28 -0700522 skb_dst(skb)->ops->update_pmtu(skb_dst(skb), NULL, skb, mtu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523
Herbert Xu23ca0c92009-11-06 10:37:41 +0000524 if ((old_iph->frag_off & htons(IP_DF)) &&
525 mtu < ntohs(old_iph->tot_len)) {
526 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED,
527 htonl(mtu));
528 ip_rt_put(rt);
529 goto tx_error;
530 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531 }
532
533 if (tunnel->err_count > 0) {
Wei Yongjun26d94b42009-02-24 23:36:47 -0800534 if (time_before(jiffies,
535 tunnel->err_time + IPTUNNEL_ERR_TIMEO)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536 tunnel->err_count--;
537 dst_link_failure(skb);
538 } else
539 tunnel->err_count = 0;
540 }
541
542 /*
543 * Okay, now see if we can stuff it in the buffer as-is.
544 */
545 max_headroom = (LL_RESERVED_SPACE(tdev)+sizeof(struct iphdr));
546
Patrick McHardycfbba492007-07-09 15:33:40 -0700547 if (skb_headroom(skb) < max_headroom || skb_shared(skb) ||
548 (skb_cloned(skb) && !skb_clone_writable(skb, 0))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549 struct sk_buff *new_skb = skb_realloc_headroom(skb, max_headroom);
550 if (!new_skb) {
551 ip_rt_put(rt);
Eric Dumazet3c97af92010-09-27 00:35:50 +0000552 dev->stats.tx_dropped++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553 dev_kfree_skb(skb);
Patrick McHardy6ed10652009-06-23 06:03:08 +0000554 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555 }
556 if (skb->sk)
557 skb_set_owner_w(new_skb, skb->sk);
558 dev_kfree_skb(skb);
559 skb = new_skb;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700560 old_iph = ip_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561 }
562
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -0700563 skb->transport_header = skb->network_header;
Arnaldo Carvalho de Meloe2d1bca2007-04-10 20:46:21 -0700564 skb_push(skb, sizeof(struct iphdr));
565 skb_reset_network_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566 memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
Patrick McHardy48d5cad2006-02-15 15:10:22 -0800567 IPCB(skb)->flags &= ~(IPSKB_XFRM_TUNNEL_SIZE | IPSKB_XFRM_TRANSFORMED |
568 IPSKB_REROUTED);
Eric Dumazetadf30902009-06-02 05:19:30 +0000569 skb_dst_drop(skb);
Changli Gaod8d1f302010-06-10 23:31:35 -0700570 skb_dst_set(skb, &rt->dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571
572 /*
573 * Push down and install the IPIP header.
574 */
575
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700576 iph = ip_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577 iph->version = 4;
578 iph->ihl = sizeof(struct iphdr)>>2;
579 iph->frag_off = df;
580 iph->protocol = IPPROTO_IPIP;
581 iph->tos = INET_ECN_encapsulate(tos, old_iph->tos);
David S. Miller69458cb2011-05-04 11:10:28 -0700582 iph->daddr = fl4.daddr;
583 iph->saddr = fl4.saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584
585 if ((iph->ttl = tiph->ttl) == 0)
586 iph->ttl = old_iph->ttl;
587
588 nf_reset(skb);
Eric Dumazet3c97af92010-09-27 00:35:50 +0000589 tstats = this_cpu_ptr(dev->tstats);
590 __IPTUNNEL_XMIT(tstats, &dev->stats);
Patrick McHardy6ed10652009-06-23 06:03:08 +0000591 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592
593tx_error_icmp:
594 dst_link_failure(skb);
595tx_error:
Eric Dumazet3c97af92010-09-27 00:35:50 +0000596 dev->stats.tx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597 dev_kfree_skb(skb);
Patrick McHardy6ed10652009-06-23 06:03:08 +0000598 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599}
600
Michal Schmidt55339952007-12-12 11:01:43 -0800601static void ipip_tunnel_bind_dev(struct net_device *dev)
602{
603 struct net_device *tdev = NULL;
604 struct ip_tunnel *tunnel;
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000605 const struct iphdr *iph;
Michal Schmidt55339952007-12-12 11:01:43 -0800606
607 tunnel = netdev_priv(dev);
608 iph = &tunnel->parms.iph;
609
610 if (iph->daddr) {
David S. Miller31e4543d2011-05-03 20:25:42 -0700611 struct rtable *rt;
612 struct flowi4 fl4;
Eric Dumazet3c97af92010-09-27 00:35:50 +0000613
David S. Miller31e4543d2011-05-03 20:25:42 -0700614 rt = ip_route_output_ports(dev_net(dev), &fl4, NULL,
615 iph->daddr, iph->saddr,
616 0, 0,
617 IPPROTO_IPIP,
618 RT_TOS(iph->tos),
619 tunnel->parms.link);
David S. Millerb23dd4f2011-03-02 14:31:35 -0800620 if (!IS_ERR(rt)) {
Changli Gaod8d1f302010-06-10 23:31:35 -0700621 tdev = rt->dst.dev;
Michal Schmidt55339952007-12-12 11:01:43 -0800622 ip_rt_put(rt);
623 }
624 dev->flags |= IFF_POINTOPOINT;
625 }
626
627 if (!tdev && tunnel->parms.link)
Pavel Emelyanovb99f0152008-04-16 01:05:57 -0700628 tdev = __dev_get_by_index(dev_net(dev), tunnel->parms.link);
Michal Schmidt55339952007-12-12 11:01:43 -0800629
630 if (tdev) {
631 dev->hard_header_len = tdev->hard_header_len + sizeof(struct iphdr);
632 dev->mtu = tdev->mtu - sizeof(struct iphdr);
633 }
634 dev->iflink = tunnel->parms.link;
635}
636
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637static int
638ipip_tunnel_ioctl (struct net_device *dev, struct ifreq *ifr, int cmd)
639{
640 int err = 0;
641 struct ip_tunnel_parm p;
642 struct ip_tunnel *t;
Pavel Emelyanovb9855c52008-04-16 01:04:13 -0700643 struct net *net = dev_net(dev);
644 struct ipip_net *ipn = net_generic(net, ipip_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645
646 switch (cmd) {
647 case SIOCGETTUNNEL:
648 t = NULL;
Pavel Emelyanovb9855c52008-04-16 01:04:13 -0700649 if (dev == ipn->fb_tunnel_dev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p))) {
651 err = -EFAULT;
652 break;
653 }
Pavel Emelyanovb9fae5c2008-04-16 01:04:35 -0700654 t = ipip_tunnel_locate(net, &p, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700655 }
656 if (t == NULL)
Patrick McHardy2941a482006-01-08 22:05:26 -0800657 t = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658 memcpy(&p, &t->parms, sizeof(p));
659 if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p)))
660 err = -EFAULT;
661 break;
662
663 case SIOCADDTUNNEL:
664 case SIOCCHGTUNNEL:
665 err = -EPERM;
666 if (!capable(CAP_NET_ADMIN))
667 goto done;
668
669 err = -EFAULT;
670 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
671 goto done;
672
673 err = -EINVAL;
674 if (p.iph.version != 4 || p.iph.protocol != IPPROTO_IPIP ||
675 p.iph.ihl != 5 || (p.iph.frag_off&htons(~IP_DF)))
676 goto done;
677 if (p.iph.ttl)
678 p.iph.frag_off |= htons(IP_DF);
679
Pavel Emelyanovb9fae5c2008-04-16 01:04:35 -0700680 t = ipip_tunnel_locate(net, &p, cmd == SIOCADDTUNNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681
Pavel Emelyanovb9855c52008-04-16 01:04:13 -0700682 if (dev != ipn->fb_tunnel_dev && cmd == SIOCCHGTUNNEL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683 if (t != NULL) {
684 if (t->dev != dev) {
685 err = -EEXIST;
686 break;
687 }
688 } else {
689 if (((dev->flags&IFF_POINTOPOINT) && !p.iph.daddr) ||
690 (!(dev->flags&IFF_POINTOPOINT) && p.iph.daddr)) {
691 err = -EINVAL;
692 break;
693 }
Patrick McHardy2941a482006-01-08 22:05:26 -0800694 t = netdev_priv(dev);
Pavel Emelyanovb9fae5c2008-04-16 01:04:35 -0700695 ipip_tunnel_unlink(ipn, t);
Pavel Emelyanov74b0b852010-10-27 05:43:53 +0000696 synchronize_net();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697 t->parms.iph.saddr = p.iph.saddr;
698 t->parms.iph.daddr = p.iph.daddr;
699 memcpy(dev->dev_addr, &p.iph.saddr, 4);
700 memcpy(dev->broadcast, &p.iph.daddr, 4);
Pavel Emelyanovb9fae5c2008-04-16 01:04:35 -0700701 ipip_tunnel_link(ipn, t);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702 netdev_state_change(dev);
703 }
704 }
705
706 if (t) {
707 err = 0;
708 if (cmd == SIOCCHGTUNNEL) {
709 t->parms.iph.ttl = p.iph.ttl;
710 t->parms.iph.tos = p.iph.tos;
711 t->parms.iph.frag_off = p.iph.frag_off;
Michal Schmidt55339952007-12-12 11:01:43 -0800712 if (t->parms.link != p.link) {
713 t->parms.link = p.link;
714 ipip_tunnel_bind_dev(dev);
715 netdev_state_change(dev);
716 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717 }
718 if (copy_to_user(ifr->ifr_ifru.ifru_data, &t->parms, sizeof(p)))
719 err = -EFAULT;
720 } else
721 err = (cmd == SIOCADDTUNNEL ? -ENOBUFS : -ENOENT);
722 break;
723
724 case SIOCDELTUNNEL:
725 err = -EPERM;
726 if (!capable(CAP_NET_ADMIN))
727 goto done;
728
Pavel Emelyanovb9855c52008-04-16 01:04:13 -0700729 if (dev == ipn->fb_tunnel_dev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730 err = -EFAULT;
731 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
732 goto done;
733 err = -ENOENT;
Pavel Emelyanovb9fae5c2008-04-16 01:04:35 -0700734 if ((t = ipip_tunnel_locate(net, &p, 0)) == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735 goto done;
736 err = -EPERM;
Pavel Emelyanovb9855c52008-04-16 01:04:13 -0700737 if (t->dev == ipn->fb_tunnel_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738 goto done;
739 dev = t->dev;
740 }
Stephen Hemminger22f8cde2007-02-07 00:09:58 -0800741 unregister_netdevice(dev);
742 err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743 break;
744
745 default:
746 err = -EINVAL;
747 }
748
749done:
750 return err;
751}
752
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753static int ipip_tunnel_change_mtu(struct net_device *dev, int new_mtu)
754{
755 if (new_mtu < 68 || new_mtu > 0xFFF8 - sizeof(struct iphdr))
756 return -EINVAL;
757 dev->mtu = new_mtu;
758 return 0;
759}
760
Stephen Hemminger23a12b12008-11-20 20:33:21 -0800761static const struct net_device_ops ipip_netdev_ops = {
762 .ndo_uninit = ipip_tunnel_uninit,
763 .ndo_start_xmit = ipip_tunnel_xmit,
764 .ndo_do_ioctl = ipip_tunnel_ioctl,
765 .ndo_change_mtu = ipip_tunnel_change_mtu,
stephen hemminger87b6d212012-04-12 06:31:16 +0000766 .ndo_get_stats64 = ipip_get_stats64,
Stephen Hemminger23a12b12008-11-20 20:33:21 -0800767};
768
Eric Dumazet3c97af92010-09-27 00:35:50 +0000769static void ipip_dev_free(struct net_device *dev)
770{
771 free_percpu(dev->tstats);
772 free_netdev(dev);
773}
774
Linus Torvalds1da177e2005-04-16 15:20:36 -0700775static void ipip_tunnel_setup(struct net_device *dev)
776{
Stephen Hemminger23a12b12008-11-20 20:33:21 -0800777 dev->netdev_ops = &ipip_netdev_ops;
Eric Dumazet3c97af92010-09-27 00:35:50 +0000778 dev->destructor = ipip_dev_free;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700779
780 dev->type = ARPHRD_TUNNEL;
781 dev->hard_header_len = LL_MAX_HEADER + sizeof(struct iphdr);
Kris Katterjohn46f25df2006-01-05 16:35:42 -0800782 dev->mtu = ETH_DATA_LEN - sizeof(struct iphdr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783 dev->flags = IFF_NOARP;
784 dev->iflink = 0;
785 dev->addr_len = 4;
Pavel Emelyanov0a826402008-04-16 01:06:18 -0700786 dev->features |= NETIF_F_NETNS_LOCAL;
Eric Dumazet153f0942010-09-28 00:17:17 +0000787 dev->features |= NETIF_F_LLTX;
Eric Dumazet28e72212009-05-28 10:44:30 +0000788 dev->priv_flags &= ~IFF_XMIT_DST_RELEASE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789}
790
Eric Dumazet3c97af92010-09-27 00:35:50 +0000791static int ipip_tunnel_init(struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792{
Stephen Hemminger23a12b12008-11-20 20:33:21 -0800793 struct ip_tunnel *tunnel = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794
795 tunnel->dev = dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796
797 memcpy(dev->dev_addr, &tunnel->parms.iph.saddr, 4);
798 memcpy(dev->broadcast, &tunnel->parms.iph.daddr, 4);
799
Michal Schmidt55339952007-12-12 11:01:43 -0800800 ipip_tunnel_bind_dev(dev);
Eric Dumazet3c97af92010-09-27 00:35:50 +0000801
802 dev->tstats = alloc_percpu(struct pcpu_tstats);
803 if (!dev->tstats)
804 return -ENOMEM;
805
806 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700807}
808
Eric Dumazetfada5632010-09-27 23:56:46 +0000809static int __net_init ipip_fb_tunnel_init(struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810{
Patrick McHardy2941a482006-01-08 22:05:26 -0800811 struct ip_tunnel *tunnel = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700812 struct iphdr *iph = &tunnel->parms.iph;
Pavel Emelyanov44d3c292008-04-16 01:05:32 -0700813 struct ipip_net *ipn = net_generic(dev_net(dev), ipip_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700814
815 tunnel->dev = dev;
816 strcpy(tunnel->parms.name, dev->name);
817
818 iph->version = 4;
819 iph->protocol = IPPROTO_IPIP;
820 iph->ihl = 5;
821
Eric Dumazetfada5632010-09-27 23:56:46 +0000822 dev->tstats = alloc_percpu(struct pcpu_tstats);
823 if (!dev->tstats)
824 return -ENOMEM;
825
Linus Torvalds1da177e2005-04-16 15:20:36 -0700826 dev_hold(dev);
Eric Dumazetcf778b02012-01-12 04:41:32 +0000827 rcu_assign_pointer(ipn->tunnels_wc[0], tunnel);
Eric Dumazetfada5632010-09-27 23:56:46 +0000828 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829}
830
Eric Dumazet6dcd8142010-08-30 07:04:14 +0000831static struct xfrm_tunnel ipip_handler __read_mostly = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832 .handler = ipip_rcv,
833 .err_handler = ipip_err,
Herbert Xud2acc342006-03-28 01:12:13 -0800834 .priority = 1,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700835};
836
Stephen Hemminger5747a1a2009-02-22 00:02:08 -0800837static const char banner[] __initconst =
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838 KERN_INFO "IPv4 over IPv4 tunneling driver\n";
839
Eric Dumazet0694c4c2009-10-27 07:06:59 +0000840static void ipip_destroy_tunnels(struct ipip_net *ipn, struct list_head *head)
Pavel Emelyanov44d3c292008-04-16 01:05:32 -0700841{
842 int prio;
843
844 for (prio = 1; prio < 4; prio++) {
845 int h;
846 for (h = 0; h < HASH_SIZE; h++) {
Eric Dumazetb7285b72010-09-15 11:07:24 +0000847 struct ip_tunnel *t;
Eric Dumazet0694c4c2009-10-27 07:06:59 +0000848
Eric Dumazetb7285b72010-09-15 11:07:24 +0000849 t = rtnl_dereference(ipn->tunnels[prio][h]);
Eric Dumazet0694c4c2009-10-27 07:06:59 +0000850 while (t != NULL) {
851 unregister_netdevice_queue(t->dev, head);
Eric Dumazetb7285b72010-09-15 11:07:24 +0000852 t = rtnl_dereference(t->next);
Eric Dumazet0694c4c2009-10-27 07:06:59 +0000853 }
Pavel Emelyanov44d3c292008-04-16 01:05:32 -0700854 }
855 }
856}
857
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +0000858static int __net_init ipip_init_net(struct net *net)
Pavel Emelyanov10dc4c72008-04-16 01:03:13 -0700859{
Eric W. Biederman86de8a62009-11-29 15:46:14 +0000860 struct ipip_net *ipn = net_generic(net, ipip_net_id);
Ted Feng72b36012011-12-08 00:46:21 +0000861 struct ip_tunnel *t;
Pavel Emelyanov10dc4c72008-04-16 01:03:13 -0700862 int err;
Pavel Emelyanov10dc4c72008-04-16 01:03:13 -0700863
Pavel Emelyanov44d3c292008-04-16 01:05:32 -0700864 ipn->tunnels[0] = ipn->tunnels_wc;
865 ipn->tunnels[1] = ipn->tunnels_l;
866 ipn->tunnels[2] = ipn->tunnels_r;
867 ipn->tunnels[3] = ipn->tunnels_r_l;
868
Pavel Emelyanovb9855c52008-04-16 01:04:13 -0700869 ipn->fb_tunnel_dev = alloc_netdev(sizeof(struct ip_tunnel),
870 "tunl0",
871 ipip_tunnel_setup);
872 if (!ipn->fb_tunnel_dev) {
873 err = -ENOMEM;
874 goto err_alloc_dev;
875 }
Alexey Dobriyanbe77e592008-11-23 17:26:26 -0800876 dev_net_set(ipn->fb_tunnel_dev, net);
Pavel Emelyanovb9855c52008-04-16 01:04:13 -0700877
Eric Dumazetfada5632010-09-27 23:56:46 +0000878 err = ipip_fb_tunnel_init(ipn->fb_tunnel_dev);
879 if (err)
880 goto err_reg_dev;
Pavel Emelyanovb9855c52008-04-16 01:04:13 -0700881
882 if ((err = register_netdev(ipn->fb_tunnel_dev)))
883 goto err_reg_dev;
884
Ted Feng72b36012011-12-08 00:46:21 +0000885 t = netdev_priv(ipn->fb_tunnel_dev);
886
887 strcpy(t->parms.name, ipn->fb_tunnel_dev->name);
Pavel Emelyanov10dc4c72008-04-16 01:03:13 -0700888 return 0;
889
Pavel Emelyanovb9855c52008-04-16 01:04:13 -0700890err_reg_dev:
Eric Dumazetfada5632010-09-27 23:56:46 +0000891 ipip_dev_free(ipn->fb_tunnel_dev);
Pavel Emelyanovb9855c52008-04-16 01:04:13 -0700892err_alloc_dev:
893 /* nothing */
Pavel Emelyanov10dc4c72008-04-16 01:03:13 -0700894 return err;
895}
896
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +0000897static void __net_exit ipip_exit_net(struct net *net)
Pavel Emelyanov10dc4c72008-04-16 01:03:13 -0700898{
Eric W. Biederman86de8a62009-11-29 15:46:14 +0000899 struct ipip_net *ipn = net_generic(net, ipip_net_id);
Eric Dumazet0694c4c2009-10-27 07:06:59 +0000900 LIST_HEAD(list);
Pavel Emelyanov10dc4c72008-04-16 01:03:13 -0700901
Pavel Emelyanovb9855c52008-04-16 01:04:13 -0700902 rtnl_lock();
Eric Dumazet0694c4c2009-10-27 07:06:59 +0000903 ipip_destroy_tunnels(ipn, &list);
904 unregister_netdevice_queue(ipn->fb_tunnel_dev, &list);
905 unregister_netdevice_many(&list);
Pavel Emelyanovb9855c52008-04-16 01:04:13 -0700906 rtnl_unlock();
Pavel Emelyanov10dc4c72008-04-16 01:03:13 -0700907}
908
909static struct pernet_operations ipip_net_ops = {
910 .init = ipip_init_net,
911 .exit = ipip_exit_net,
Eric W. Biederman86de8a62009-11-29 15:46:14 +0000912 .id = &ipip_net_id,
913 .size = sizeof(struct ipip_net),
Pavel Emelyanov10dc4c72008-04-16 01:03:13 -0700914};
915
Linus Torvalds1da177e2005-04-16 15:20:36 -0700916static int __init ipip_init(void)
917{
918 int err;
919
920 printk(banner);
921
Eric W. Biederman86de8a62009-11-29 15:46:14 +0000922 err = register_pernet_device(&ipip_net_ops);
Alexey Dobriyand5aa4072010-02-16 09:05:04 +0000923 if (err < 0)
924 return err;
925 err = xfrm4_tunnel_register(&ipip_handler, AF_INET);
926 if (err < 0) {
927 unregister_pernet_device(&ipip_net_ops);
Joe Perches058bd4d2012-03-11 18:36:11 +0000928 pr_info("%s: can't register tunnel\n", __func__);
Alexey Dobriyand5aa4072010-02-16 09:05:04 +0000929 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700930 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700931}
932
933static void __exit ipip_fini(void)
934{
Kazunori MIYAZAWAc0d56402007-02-13 12:54:47 -0800935 if (xfrm4_tunnel_deregister(&ipip_handler, AF_INET))
Joe Perches058bd4d2012-03-11 18:36:11 +0000936 pr_info("%s: can't deregister tunnel\n", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700937
Eric W. Biederman86de8a62009-11-29 15:46:14 +0000938 unregister_pernet_device(&ipip_net_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700939}
940
941module_init(ipip_init);
942module_exit(ipip_fini);
943MODULE_LICENSE("GPL");
Vasiliy Kulikov8909c9a2011-03-02 00:33:13 +0300944MODULE_ALIAS_NETDEV("tunl0");