blob: e81b1caf2ea2a0ceaa20ef8e1847ebd4f71cd98e [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09002 * Linux NET3: GRE over IP protocol decoder.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003 *
4 * Authors: Alexey Kuznetsov (kuznet@ms2.inr.ac.ru)
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 *
11 */
12
Joe Perchesafd465032012-03-12 07:03:32 +000013#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
14
Randy Dunlap4fc268d2006-01-11 12:17:47 -080015#include <linux/capability.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070016#include <linux/module.h>
17#include <linux/types.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#include <linux/kernel.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090019#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#include <asm/uaccess.h>
21#include <linux/skbuff.h>
22#include <linux/netdevice.h>
23#include <linux/in.h>
24#include <linux/tcp.h>
25#include <linux/udp.h>
26#include <linux/if_arp.h>
27#include <linux/mroute.h>
28#include <linux/init.h>
29#include <linux/in6.h>
30#include <linux/inetdevice.h>
31#include <linux/igmp.h>
32#include <linux/netfilter_ipv4.h>
Herbert Xue1a80002008-10-09 12:00:17 -070033#include <linux/etherdevice.h>
Kris Katterjohn46f25df2006-01-05 16:35:42 -080034#include <linux/if_ether.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070035
36#include <net/sock.h>
37#include <net/ip.h>
38#include <net/icmp.h>
39#include <net/protocol.h>
40#include <net/ipip.h>
41#include <net/arp.h>
42#include <net/checksum.h>
43#include <net/dsfield.h>
44#include <net/inet_ecn.h>
45#include <net/xfrm.h>
Pavel Emelyanov59a4c752008-04-16 01:08:53 -070046#include <net/net_namespace.h>
47#include <net/netns/generic.h>
Herbert Xuc19e6542008-10-09 11:59:55 -070048#include <net/rtnetlink.h>
Dmitry Kozlov00959ad2010-08-21 23:05:39 -070049#include <net/gre.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070050
Eric Dumazetdfd56b82011-12-10 09:48:31 +000051#if IS_ENABLED(CONFIG_IPV6)
Linus Torvalds1da177e2005-04-16 15:20:36 -070052#include <net/ipv6.h>
53#include <net/ip6_fib.h>
54#include <net/ip6_route.h>
55#endif
56
57/*
58 Problems & solutions
59 --------------------
60
61 1. The most important issue is detecting local dead loops.
62 They would cause complete host lockup in transmit, which
63 would be "resolved" by stack overflow or, if queueing is enabled,
64 with infinite looping in net_bh.
65
66 We cannot track such dead loops during route installation,
67 it is infeasible task. The most general solutions would be
68 to keep skb->encapsulation counter (sort of local ttl),
Eric Dumazet6d0722a2010-09-29 23:35:10 -070069 and silently drop packet when it expires. It is a good
stephen hemmingerbff52852012-02-24 08:08:20 +000070 solution, but it supposes maintaining new variable in ALL
Linus Torvalds1da177e2005-04-16 15:20:36 -070071 skb, even if no tunneling is used.
72
Eric Dumazet6d0722a2010-09-29 23:35:10 -070073 Current solution: xmit_recursion breaks dead loops. This is a percpu
74 counter, since when we enter the first ndo_xmit(), cpu migration is
75 forbidden. We force an exit if this counter reaches RECURSION_LIMIT
Linus Torvalds1da177e2005-04-16 15:20:36 -070076
77 2. Networking dead loops would not kill routers, but would really
78 kill network. IP hop limit plays role of "t->recursion" in this case,
79 if we copy it from packet being encapsulated to upper header.
80 It is very good solution, but it introduces two problems:
81
82 - Routing protocols, using packets with ttl=1 (OSPF, RIP2),
83 do not work over tunnels.
84 - traceroute does not work. I planned to relay ICMP from tunnel,
85 so that this problem would be solved and traceroute output
86 would even more informative. This idea appeared to be wrong:
87 only Linux complies to rfc1812 now (yes, guys, Linux is the only
88 true router now :-)), all routers (at least, in neighbourhood of mine)
89 return only 8 bytes of payload. It is the end.
90
91 Hence, if we want that OSPF worked or traceroute said something reasonable,
92 we should search for another solution.
93
94 One of them is to parse packet trying to detect inner encapsulation
95 made by our node. It is difficult or even impossible, especially,
stephen hemmingerbff52852012-02-24 08:08:20 +000096 taking into account fragmentation. TO be short, ttl is not solution at all.
Linus Torvalds1da177e2005-04-16 15:20:36 -070097
98 Current solution: The solution was UNEXPECTEDLY SIMPLE.
99 We force DF flag on tunnels with preconfigured hop limit,
100 that is ALL. :-) Well, it does not remove the problem completely,
101 but exponential growth of network traffic is changed to linear
102 (branches, that exceed pmtu are pruned) and tunnel mtu
stephen hemmingerbff52852012-02-24 08:08:20 +0000103 rapidly degrades to value <68, where looping stops.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104 Yes, it is not good if there exists a router in the loop,
105 which does not force DF, even when encapsulating packets have DF set.
106 But it is not our problem! Nobody could accuse us, we made
107 all that we could make. Even if it is your gated who injected
108 fatal route to network, even if it were you who configured
109 fatal static route: you are innocent. :-)
110
111
112
113 3. Really, ipv4/ipip.c, ipv4/ip_gre.c and ipv6/sit.c contain
114 practically identical code. It would be good to glue them
115 together, but it is not very evident, how to make them modular.
116 sit is integral part of IPv6, ipip and gre are naturally modular.
117 We could extract common parts (hash table, ioctl etc)
118 to a separate module (ip_tunnel.c).
119
120 Alexey Kuznetsov.
121 */
122
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
Herbert Xuc19e6542008-10-09 11:59:55 -0700127static struct rtnl_link_ops ipgre_link_ops __read_mostly;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128static int ipgre_tunnel_init(struct net_device *dev);
129static void ipgre_tunnel_setup(struct net_device *dev);
Herbert Xu42aa9162008-10-09 11:59:32 -0700130static int ipgre_tunnel_bind_dev(struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131
132/* Fallback tunnel: no source, no destination, no key, no options */
133
Pavel Emelyanoveb8ce742008-04-16 01:10:26 -0700134#define HASH_SIZE 16
135
Eric Dumazetf99189b2009-11-17 10:42:49 +0000136static int ipgre_net_id __read_mostly;
Pavel Emelyanov59a4c752008-04-16 01:08:53 -0700137struct ipgre_net {
Eric Dumazet15078502010-09-15 11:07:53 +0000138 struct ip_tunnel __rcu *tunnels[4][HASH_SIZE];
Pavel Emelyanoveb8ce742008-04-16 01:10:26 -0700139
Pavel Emelyanov7daa0002008-04-16 01:10:05 -0700140 struct net_device *fb_tunnel_dev;
Pavel Emelyanov59a4c752008-04-16 01:08:53 -0700141};
142
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143/* Tunnel hash table */
144
145/*
146 4 hash tables:
147
148 3: (remote,local)
149 2: (remote,*)
150 1: (*,local)
151 0: (*,*)
152
153 We require exact key match i.e. if a key is present in packet
154 it will match only tunnel with the same key; if it is not present,
155 it will match only keyless tunnel.
156
157 All keysless packets, if not matched configured keyless tunnels
158 will match fallback tunnel.
159 */
160
Al Virod5a0a1e2006-11-08 00:23:14 -0800161#define HASH(addr) (((__force u32)addr^((__force u32)addr>>4))&0xF)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162
Pavel Emelyanoveb8ce742008-04-16 01:10:26 -0700163#define tunnels_r_l tunnels[3]
164#define tunnels_r tunnels[2]
165#define tunnels_l tunnels[1]
166#define tunnels_wc tunnels[0]
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167
stephen hemminger87b6d212012-04-12 06:31:16 +0000168static struct rtnl_link_stats64 *ipgre_get_stats64(struct net_device *dev,
169 struct rtnl_link_stats64 *tot)
Eric Dumazete985aad2010-09-27 03:57:11 +0000170{
Eric Dumazete985aad2010-09-27 03:57:11 +0000171 int i;
172
173 for_each_possible_cpu(i) {
174 const struct pcpu_tstats *tstats = per_cpu_ptr(dev->tstats, i);
stephen hemminger87b6d212012-04-12 06:31:16 +0000175 u64 rx_packets, rx_bytes, tx_packets, tx_bytes;
176 unsigned int start;
Eric Dumazete985aad2010-09-27 03:57:11 +0000177
stephen hemminger87b6d212012-04-12 06:31:16 +0000178 do {
179 start = u64_stats_fetch_begin_bh(&tstats->syncp);
180 rx_packets = tstats->rx_packets;
181 tx_packets = tstats->tx_packets;
182 rx_bytes = tstats->rx_bytes;
183 tx_bytes = tstats->tx_bytes;
184 } while (u64_stats_fetch_retry_bh(&tstats->syncp, start));
185
186 tot->rx_packets += rx_packets;
187 tot->tx_packets += tx_packets;
188 tot->rx_bytes += rx_bytes;
189 tot->tx_bytes += tx_bytes;
Eric Dumazete985aad2010-09-27 03:57:11 +0000190 }
stephen hemminger87b6d212012-04-12 06:31:16 +0000191
192 tot->multicast = dev->stats.multicast;
193 tot->rx_crc_errors = dev->stats.rx_crc_errors;
194 tot->rx_fifo_errors = dev->stats.rx_fifo_errors;
195 tot->rx_length_errors = dev->stats.rx_length_errors;
stephen hemmingereccc1bb2012-09-25 11:02:48 +0000196 tot->rx_frame_errors = dev->stats.rx_frame_errors;
stephen hemminger87b6d212012-04-12 06:31:16 +0000197 tot->rx_errors = dev->stats.rx_errors;
stephen hemmingereccc1bb2012-09-25 11:02:48 +0000198
stephen hemminger87b6d212012-04-12 06:31:16 +0000199 tot->tx_fifo_errors = dev->stats.tx_fifo_errors;
200 tot->tx_carrier_errors = dev->stats.tx_carrier_errors;
201 tot->tx_dropped = dev->stats.tx_dropped;
202 tot->tx_aborted_errors = dev->stats.tx_aborted_errors;
203 tot->tx_errors = dev->stats.tx_errors;
204
205 return tot;
Eric Dumazete985aad2010-09-27 03:57:11 +0000206}
207
stephen hemmingerd2083282012-09-24 18:12:23 +0000208/* Does key in tunnel parameters match packet */
209static bool ipgre_key_match(const struct ip_tunnel_parm *p,
stephen hemminger9fbef052012-10-01 05:21:14 +0000210 __be16 flags, __be32 key)
stephen hemmingerd2083282012-09-24 18:12:23 +0000211{
212 if (p->i_flags & GRE_KEY) {
213 if (flags & GRE_KEY)
214 return key == p->i_key;
215 else
216 return false; /* key expected, none present */
217 } else
218 return !(flags & GRE_KEY);
219}
220
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221/* Given src, dst and key, find appropriate for input tunnel. */
222
Daniel Baluta5e73ea12012-04-15 01:34:41 +0000223static struct ip_tunnel *ipgre_tunnel_lookup(struct net_device *dev,
224 __be32 remote, __be32 local,
stephen hemminger9fbef052012-10-01 05:21:14 +0000225 __be16 flags, __be32 key,
stephen hemmingerd2083282012-09-24 18:12:23 +0000226 __be16 gre_proto)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227{
Timo Teras749c10f2009-01-19 17:22:12 -0800228 struct net *net = dev_net(dev);
229 int link = dev->ifindex;
Eric Dumazet15078502010-09-15 11:07:53 +0000230 unsigned int h0 = HASH(remote);
231 unsigned int h1 = HASH(key);
Timo Terasafcf1242009-01-26 20:56:10 -0800232 struct ip_tunnel *t, *cand = NULL;
Pavel Emelyanov7daa0002008-04-16 01:10:05 -0700233 struct ipgre_net *ign = net_generic(net, ipgre_net_id);
Herbert Xue1a80002008-10-09 12:00:17 -0700234 int dev_type = (gre_proto == htons(ETH_P_TEB)) ?
235 ARPHRD_ETHER : ARPHRD_IPGRE;
Timo Terasafcf1242009-01-26 20:56:10 -0800236 int score, cand_score = 4;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237
Amerigo Wange086cad2012-11-11 21:52:34 +0000238 for_each_ip_tunnel_rcu(t, ign->tunnels_r_l[h0 ^ h1]) {
Timo Teras749c10f2009-01-19 17:22:12 -0800239 if (local != t->parms.iph.saddr ||
240 remote != t->parms.iph.daddr ||
Timo Teras749c10f2009-01-19 17:22:12 -0800241 !(t->dev->flags & IFF_UP))
242 continue;
243
stephen hemmingerd2083282012-09-24 18:12:23 +0000244 if (!ipgre_key_match(&t->parms, flags, key))
245 continue;
246
Timo Teras749c10f2009-01-19 17:22:12 -0800247 if (t->dev->type != ARPHRD_IPGRE &&
248 t->dev->type != dev_type)
249 continue;
250
Timo Terasafcf1242009-01-26 20:56:10 -0800251 score = 0;
Timo Teras749c10f2009-01-19 17:22:12 -0800252 if (t->parms.link != link)
Timo Terasafcf1242009-01-26 20:56:10 -0800253 score |= 1;
Timo Teras749c10f2009-01-19 17:22:12 -0800254 if (t->dev->type != dev_type)
Timo Terasafcf1242009-01-26 20:56:10 -0800255 score |= 2;
256 if (score == 0)
Timo Teras749c10f2009-01-19 17:22:12 -0800257 return t;
Timo Terasafcf1242009-01-26 20:56:10 -0800258
259 if (score < cand_score) {
260 cand = t;
261 cand_score = score;
262 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263 }
Herbert Xue1a80002008-10-09 12:00:17 -0700264
Amerigo Wange086cad2012-11-11 21:52:34 +0000265 for_each_ip_tunnel_rcu(t, ign->tunnels_r[h0 ^ h1]) {
Timo Teras749c10f2009-01-19 17:22:12 -0800266 if (remote != t->parms.iph.daddr ||
Timo Teras749c10f2009-01-19 17:22:12 -0800267 !(t->dev->flags & IFF_UP))
268 continue;
269
stephen hemmingerd2083282012-09-24 18:12:23 +0000270 if (!ipgre_key_match(&t->parms, flags, key))
271 continue;
272
Timo Teras749c10f2009-01-19 17:22:12 -0800273 if (t->dev->type != ARPHRD_IPGRE &&
274 t->dev->type != dev_type)
275 continue;
276
Timo Terasafcf1242009-01-26 20:56:10 -0800277 score = 0;
Timo Teras749c10f2009-01-19 17:22:12 -0800278 if (t->parms.link != link)
Timo Terasafcf1242009-01-26 20:56:10 -0800279 score |= 1;
Timo Teras749c10f2009-01-19 17:22:12 -0800280 if (t->dev->type != dev_type)
Timo Terasafcf1242009-01-26 20:56:10 -0800281 score |= 2;
282 if (score == 0)
Timo Teras749c10f2009-01-19 17:22:12 -0800283 return t;
Timo Terasafcf1242009-01-26 20:56:10 -0800284
285 if (score < cand_score) {
286 cand = t;
287 cand_score = score;
288 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289 }
Herbert Xue1a80002008-10-09 12:00:17 -0700290
Amerigo Wange086cad2012-11-11 21:52:34 +0000291 for_each_ip_tunnel_rcu(t, ign->tunnels_l[h1]) {
Timo Teras749c10f2009-01-19 17:22:12 -0800292 if ((local != t->parms.iph.saddr &&
293 (local != t->parms.iph.daddr ||
294 !ipv4_is_multicast(local))) ||
Timo Teras749c10f2009-01-19 17:22:12 -0800295 !(t->dev->flags & IFF_UP))
296 continue;
297
stephen hemmingerd2083282012-09-24 18:12:23 +0000298 if (!ipgre_key_match(&t->parms, flags, key))
299 continue;
300
Timo Teras749c10f2009-01-19 17:22:12 -0800301 if (t->dev->type != ARPHRD_IPGRE &&
302 t->dev->type != dev_type)
303 continue;
304
Timo Terasafcf1242009-01-26 20:56:10 -0800305 score = 0;
Timo Teras749c10f2009-01-19 17:22:12 -0800306 if (t->parms.link != link)
Timo Terasafcf1242009-01-26 20:56:10 -0800307 score |= 1;
Timo Teras749c10f2009-01-19 17:22:12 -0800308 if (t->dev->type != dev_type)
Timo Terasafcf1242009-01-26 20:56:10 -0800309 score |= 2;
310 if (score == 0)
Timo Teras749c10f2009-01-19 17:22:12 -0800311 return t;
Timo Terasafcf1242009-01-26 20:56:10 -0800312
313 if (score < cand_score) {
314 cand = t;
315 cand_score = score;
316 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317 }
Herbert Xue1a80002008-10-09 12:00:17 -0700318
Amerigo Wange086cad2012-11-11 21:52:34 +0000319 for_each_ip_tunnel_rcu(t, ign->tunnels_wc[h1]) {
Timo Teras749c10f2009-01-19 17:22:12 -0800320 if (t->parms.i_key != key ||
321 !(t->dev->flags & IFF_UP))
322 continue;
323
324 if (t->dev->type != ARPHRD_IPGRE &&
325 t->dev->type != dev_type)
326 continue;
327
Timo Terasafcf1242009-01-26 20:56:10 -0800328 score = 0;
Timo Teras749c10f2009-01-19 17:22:12 -0800329 if (t->parms.link != link)
Timo Terasafcf1242009-01-26 20:56:10 -0800330 score |= 1;
Timo Teras749c10f2009-01-19 17:22:12 -0800331 if (t->dev->type != dev_type)
Timo Terasafcf1242009-01-26 20:56:10 -0800332 score |= 2;
333 if (score == 0)
Timo Teras749c10f2009-01-19 17:22:12 -0800334 return t;
Timo Terasafcf1242009-01-26 20:56:10 -0800335
336 if (score < cand_score) {
337 cand = t;
338 cand_score = score;
339 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340 }
341
Timo Terasafcf1242009-01-26 20:56:10 -0800342 if (cand != NULL)
343 return cand;
Herbert Xue1a80002008-10-09 12:00:17 -0700344
Eric Dumazet8d5b2c02009-10-23 06:14:38 +0000345 dev = ign->fb_tunnel_dev;
346 if (dev->flags & IFF_UP)
347 return netdev_priv(dev);
Timo Teras749c10f2009-01-19 17:22:12 -0800348
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349 return NULL;
350}
351
Eric Dumazet15078502010-09-15 11:07:53 +0000352static struct ip_tunnel __rcu **__ipgre_bucket(struct ipgre_net *ign,
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -0700353 struct ip_tunnel_parm *parms)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354{
YOSHIFUJI Hideaki5056a1e2007-04-24 20:44:48 +0900355 __be32 remote = parms->iph.daddr;
356 __be32 local = parms->iph.saddr;
357 __be32 key = parms->i_key;
Eric Dumazet15078502010-09-15 11:07:53 +0000358 unsigned int h = HASH(key);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359 int prio = 0;
360
361 if (local)
362 prio |= 1;
Joe Perchesf97c1e02007-12-16 13:45:43 -0800363 if (remote && !ipv4_is_multicast(remote)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364 prio |= 2;
365 h ^= HASH(remote);
366 }
367
Pavel Emelyanoveb8ce742008-04-16 01:10:26 -0700368 return &ign->tunnels[prio][h];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369}
370
Eric Dumazet15078502010-09-15 11:07:53 +0000371static inline struct ip_tunnel __rcu **ipgre_bucket(struct ipgre_net *ign,
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -0700372 struct ip_tunnel *t)
YOSHIFUJI Hideaki5056a1e2007-04-24 20:44:48 +0900373{
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -0700374 return __ipgre_bucket(ign, &t->parms);
YOSHIFUJI Hideaki5056a1e2007-04-24 20:44:48 +0900375}
376
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -0700377static void ipgre_tunnel_link(struct ipgre_net *ign, struct ip_tunnel *t)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378{
Eric Dumazet15078502010-09-15 11:07:53 +0000379 struct ip_tunnel __rcu **tp = ipgre_bucket(ign, t);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380
Eric Dumazet15078502010-09-15 11:07:53 +0000381 rcu_assign_pointer(t->next, rtnl_dereference(*tp));
Eric Dumazet8d5b2c02009-10-23 06:14:38 +0000382 rcu_assign_pointer(*tp, t);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383}
384
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -0700385static void ipgre_tunnel_unlink(struct ipgre_net *ign, struct ip_tunnel *t)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386{
Eric Dumazet15078502010-09-15 11:07:53 +0000387 struct ip_tunnel __rcu **tp;
388 struct ip_tunnel *iter;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389
Eric Dumazet15078502010-09-15 11:07:53 +0000390 for (tp = ipgre_bucket(ign, t);
391 (iter = rtnl_dereference(*tp)) != NULL;
392 tp = &iter->next) {
393 if (t == iter) {
394 rcu_assign_pointer(*tp, t->next);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395 break;
396 }
397 }
398}
399
Herbert Xue1a80002008-10-09 12:00:17 -0700400static struct ip_tunnel *ipgre_tunnel_find(struct net *net,
401 struct ip_tunnel_parm *parms,
402 int type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403{
Al Virod5a0a1e2006-11-08 00:23:14 -0800404 __be32 remote = parms->iph.daddr;
405 __be32 local = parms->iph.saddr;
406 __be32 key = parms->i_key;
Timo Teras749c10f2009-01-19 17:22:12 -0800407 int link = parms->link;
Eric Dumazet15078502010-09-15 11:07:53 +0000408 struct ip_tunnel *t;
409 struct ip_tunnel __rcu **tp;
Herbert Xue1a80002008-10-09 12:00:17 -0700410 struct ipgre_net *ign = net_generic(net, ipgre_net_id);
411
Eric Dumazet15078502010-09-15 11:07:53 +0000412 for (tp = __ipgre_bucket(ign, parms);
413 (t = rtnl_dereference(*tp)) != NULL;
414 tp = &t->next)
Herbert Xue1a80002008-10-09 12:00:17 -0700415 if (local == t->parms.iph.saddr &&
416 remote == t->parms.iph.daddr &&
417 key == t->parms.i_key &&
Timo Teras749c10f2009-01-19 17:22:12 -0800418 link == t->parms.link &&
Herbert Xue1a80002008-10-09 12:00:17 -0700419 type == t->dev->type)
420 break;
421
422 return t;
423}
424
Eric Dumazet15078502010-09-15 11:07:53 +0000425static struct ip_tunnel *ipgre_tunnel_locate(struct net *net,
Herbert Xue1a80002008-10-09 12:00:17 -0700426 struct ip_tunnel_parm *parms, int create)
427{
428 struct ip_tunnel *t, *nt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429 struct net_device *dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430 char name[IFNAMSIZ];
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -0700431 struct ipgre_net *ign = net_generic(net, ipgre_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432
Herbert Xue1a80002008-10-09 12:00:17 -0700433 t = ipgre_tunnel_find(net, parms, ARPHRD_IPGRE);
434 if (t || !create)
435 return t;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436
437 if (parms->name[0])
438 strlcpy(name, parms->name, IFNAMSIZ);
Pavel Emelyanov34cc7ba2008-02-23 20:19:20 -0800439 else
stephen hemminger407d6fc2010-11-29 09:47:47 +0000440 strcpy(name, "gre%d");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441
442 dev = alloc_netdev(sizeof(*t), name, ipgre_tunnel_setup);
443 if (!dev)
stephen hemminger407d6fc2010-11-29 09:47:47 +0000444 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445
Pavel Emelyanov0b67ece2008-04-16 01:11:13 -0700446 dev_net_set(dev, net);
447
Patrick McHardy2941a482006-01-08 22:05:26 -0800448 nt = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449 nt->parms = *parms;
Herbert Xuc19e6542008-10-09 11:59:55 -0700450 dev->rtnl_link_ops = &ipgre_link_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451
Herbert Xu42aa9162008-10-09 11:59:32 -0700452 dev->mtu = ipgre_tunnel_bind_dev(dev);
453
Pavel Emelyanovb37d428b2008-02-26 23:51:04 -0800454 if (register_netdevice(dev) < 0)
455 goto failed_free;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456
Willem de Bruijnf2b3ee92012-01-26 10:34:35 +0000457 /* Can use a lockless transmit, unless we generate output sequences */
458 if (!(nt->parms.o_flags & GRE_SEQ))
459 dev->features |= NETIF_F_LLTX;
460
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461 dev_hold(dev);
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -0700462 ipgre_tunnel_link(ign, nt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463 return nt;
464
Pavel Emelyanovb37d428b2008-02-26 23:51:04 -0800465failed_free:
466 free_netdev(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467 return NULL;
468}
469
470static void ipgre_tunnel_uninit(struct net_device *dev)
471{
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -0700472 struct net *net = dev_net(dev);
473 struct ipgre_net *ign = net_generic(net, ipgre_net_id);
474
475 ipgre_tunnel_unlink(ign, netdev_priv(dev));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476 dev_put(dev);
477}
478
479
480static void ipgre_err(struct sk_buff *skb, u32 info)
481{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482
Rami Rosen071f92d2008-05-21 17:47:54 -0700483/* All the routers (except for Linux) return only
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484 8 bytes of packet payload. It means, that precise relaying of
485 ICMP in the real Internet is absolutely infeasible.
486
487 Moreover, Cisco "wise men" put GRE key to the third word
488 in GRE header. It makes impossible maintaining even soft state for keyed
489 GRE tunnels with enabled checksum. Tell them "thank you".
490
491 Well, I wonder, rfc1812 was written by Cisco employee,
stephen hemmingerbff52852012-02-24 08:08:20 +0000492 what the hell these idiots break standards established
493 by themselves???
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494 */
495
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000496 const struct iphdr *iph = (const struct iphdr *)skb->data;
Daniel Baluta5e73ea12012-04-15 01:34:41 +0000497 __be16 *p = (__be16 *)(skb->data+(iph->ihl<<2));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498 int grehlen = (iph->ihl<<2) + 4;
Arnaldo Carvalho de Melo88c76642007-03-13 14:43:18 -0300499 const int type = icmp_hdr(skb)->type;
500 const int code = icmp_hdr(skb)->code;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501 struct ip_tunnel *t;
Al Virod5a0a1e2006-11-08 00:23:14 -0800502 __be16 flags;
stephen hemmingerd2083282012-09-24 18:12:23 +0000503 __be32 key = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504
505 flags = p[0];
506 if (flags&(GRE_CSUM|GRE_KEY|GRE_SEQ|GRE_ROUTING|GRE_VERSION)) {
507 if (flags&(GRE_VERSION|GRE_ROUTING))
508 return;
509 if (flags&GRE_KEY) {
510 grehlen += 4;
511 if (flags&GRE_CSUM)
512 grehlen += 4;
513 }
514 }
515
516 /* If only 8 bytes returned, keyed message will be dropped here */
517 if (skb_headlen(skb) < grehlen)
518 return;
519
stephen hemmingerd2083282012-09-24 18:12:23 +0000520 if (flags & GRE_KEY)
521 key = *(((__be32 *)p) + (grehlen / 4) - 1);
522
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523 switch (type) {
524 default:
525 case ICMP_PARAMETERPROB:
526 return;
527
528 case ICMP_DEST_UNREACH:
529 switch (code) {
530 case ICMP_SR_FAILED:
531 case ICMP_PORT_UNREACH:
532 /* Impossible event. */
533 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534 default:
535 /* All others are translated to HOST_UNREACH.
536 rfc2003 contains "deep thoughts" about NET_UNREACH,
537 I believe they are just ether pollution. --ANK
538 */
539 break;
540 }
541 break;
542 case ICMP_TIME_EXCEEDED:
543 if (code != ICMP_EXC_TTL)
544 return;
545 break;
David S. Miller55be7a92012-07-11 21:27:49 -0700546
547 case ICMP_REDIRECT:
548 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549 }
550
Timo Teras749c10f2009-01-19 17:22:12 -0800551 t = ipgre_tunnel_lookup(skb->dev, iph->daddr, iph->saddr,
stephen hemmingerd2083282012-09-24 18:12:23 +0000552 flags, key, p[1]);
553
David S. Miller36393392012-06-14 22:21:46 -0700554 if (t == NULL)
stephen hemminger0c5794a2012-09-24 18:12:24 +0000555 return;
David S. Miller36393392012-06-14 22:21:46 -0700556
557 if (type == ICMP_DEST_UNREACH && code == ICMP_FRAG_NEEDED) {
558 ipv4_update_pmtu(skb, dev_net(skb->dev), info,
559 t->parms.link, 0, IPPROTO_GRE, 0);
stephen hemminger0c5794a2012-09-24 18:12:24 +0000560 return;
David S. Miller36393392012-06-14 22:21:46 -0700561 }
David S. Miller55be7a92012-07-11 21:27:49 -0700562 if (type == ICMP_REDIRECT) {
563 ipv4_redirect(skb, dev_net(skb->dev), t->parms.link, 0,
564 IPPROTO_GRE, 0);
stephen hemminger0c5794a2012-09-24 18:12:24 +0000565 return;
David S. Miller55be7a92012-07-11 21:27:49 -0700566 }
David S. Miller36393392012-06-14 22:21:46 -0700567 if (t->parms.iph.daddr == 0 ||
Joe Perchesf97c1e02007-12-16 13:45:43 -0800568 ipv4_is_multicast(t->parms.iph.daddr))
stephen hemminger0c5794a2012-09-24 18:12:24 +0000569 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570
571 if (t->parms.iph.ttl == 0 && type == ICMP_TIME_EXCEEDED)
stephen hemminger0c5794a2012-09-24 18:12:24 +0000572 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573
Wei Yongjunda6185d82009-02-24 23:34:48 -0800574 if (time_before(jiffies, t->err_time + IPTUNNEL_ERR_TIMEO))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575 t->err_count++;
576 else
577 t->err_count = 1;
578 t->err_time = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579}
580
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581static inline u8
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000582ipgre_ecn_encapsulate(u8 tos, const struct iphdr *old_iph, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583{
584 u8 inner = 0;
585 if (skb->protocol == htons(ETH_P_IP))
586 inner = old_iph->tos;
587 else if (skb->protocol == htons(ETH_P_IPV6))
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000588 inner = ipv6_get_dsfield((const struct ipv6hdr *)old_iph);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589 return INET_ECN_encapsulate(tos, inner);
590}
591
592static int ipgre_rcv(struct sk_buff *skb)
593{
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000594 const struct iphdr *iph;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595 u8 *h;
Al Virod5a0a1e2006-11-08 00:23:14 -0800596 __be16 flags;
Al Virod3bc23e2006-11-14 21:24:49 -0800597 __sum16 csum = 0;
Al Virod5a0a1e2006-11-08 00:23:14 -0800598 __be32 key = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599 u32 seqno = 0;
600 struct ip_tunnel *tunnel;
601 int offset = 4;
Herbert Xue1a80002008-10-09 12:00:17 -0700602 __be16 gre_proto;
stephen hemmingereccc1bb2012-09-25 11:02:48 +0000603 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604
605 if (!pskb_may_pull(skb, 16))
stephen hemminger0c5794a2012-09-24 18:12:24 +0000606 goto drop;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700608 iph = ip_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609 h = skb->data;
Daniel Baluta5e73ea12012-04-15 01:34:41 +0000610 flags = *(__be16 *)h;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611
612 if (flags&(GRE_CSUM|GRE_KEY|GRE_ROUTING|GRE_SEQ|GRE_VERSION)) {
613 /* - Version must be 0.
614 - We do not support routing headers.
615 */
616 if (flags&(GRE_VERSION|GRE_ROUTING))
stephen hemminger0c5794a2012-09-24 18:12:24 +0000617 goto drop;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618
619 if (flags&GRE_CSUM) {
Herbert Xufb286bb2005-11-10 13:01:24 -0800620 switch (skb->ip_summed) {
Patrick McHardy84fa7932006-08-29 16:44:56 -0700621 case CHECKSUM_COMPLETE:
Al Virod3bc23e2006-11-14 21:24:49 -0800622 csum = csum_fold(skb->csum);
Herbert Xufb286bb2005-11-10 13:01:24 -0800623 if (!csum)
624 break;
625 /* fall through */
626 case CHECKSUM_NONE:
627 skb->csum = 0;
628 csum = __skb_checksum_complete(skb);
Patrick McHardy84fa7932006-08-29 16:44:56 -0700629 skb->ip_summed = CHECKSUM_COMPLETE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630 }
631 offset += 4;
632 }
633 if (flags&GRE_KEY) {
Daniel Baluta5e73ea12012-04-15 01:34:41 +0000634 key = *(__be32 *)(h + offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635 offset += 4;
636 }
637 if (flags&GRE_SEQ) {
Daniel Baluta5e73ea12012-04-15 01:34:41 +0000638 seqno = ntohl(*(__be32 *)(h + offset));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639 offset += 4;
640 }
641 }
642
Herbert Xue1a80002008-10-09 12:00:17 -0700643 gre_proto = *(__be16 *)(h + 2);
644
stephen hemmingerd2083282012-09-24 18:12:23 +0000645 tunnel = ipgre_tunnel_lookup(skb->dev,
646 iph->saddr, iph->daddr, flags, key,
647 gre_proto);
648 if (tunnel) {
Eric Dumazete985aad2010-09-27 03:57:11 +0000649 struct pcpu_tstats *tstats;
Pavel Emelyanovaddd68e2008-05-21 14:14:22 -0700650
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651 secpath_reset(skb);
652
Herbert Xue1a80002008-10-09 12:00:17 -0700653 skb->protocol = gre_proto;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654 /* WCCP version 1 and 2 protocol decoding.
655 * - Change protocol to IP
656 * - When dealing with WCCPv2, Skip extra 4 bytes in GRE header
657 */
Herbert Xue1a80002008-10-09 12:00:17 -0700658 if (flags == 0 && gre_proto == htons(ETH_P_WCCP)) {
YOSHIFUJI Hideaki496c98d2006-10-10 19:41:21 -0700659 skb->protocol = htons(ETH_P_IP);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900660 if ((*(h + offset) & 0xF0) != 0x40)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661 offset += 4;
662 }
663
Timo Teras1d069162007-12-20 00:10:33 -0800664 skb->mac_header = skb->network_header;
Arnaldo Carvalho de Melo4209fb62007-03-10 18:42:03 -0300665 __pskb_pull(skb, offset);
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -0700666 skb_postpull_rcsum(skb, skb_transport_header(skb), offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700667 skb->pkt_type = PACKET_HOST;
668#ifdef CONFIG_NET_IPGRE_BROADCAST
Joe Perchesf97c1e02007-12-16 13:45:43 -0800669 if (ipv4_is_multicast(iph->daddr)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670 /* Looped back packet, drop it! */
David S. Millerc7537962010-11-11 17:07:48 -0800671 if (rt_is_output_route(skb_rtable(skb)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672 goto drop;
Eric Dumazete985aad2010-09-27 03:57:11 +0000673 tunnel->dev->stats.multicast++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674 skb->pkt_type = PACKET_BROADCAST;
675 }
676#endif
677
678 if (((flags&GRE_CSUM) && csum) ||
679 (!(flags&GRE_CSUM) && tunnel->parms.i_flags&GRE_CSUM)) {
Eric Dumazete985aad2010-09-27 03:57:11 +0000680 tunnel->dev->stats.rx_crc_errors++;
681 tunnel->dev->stats.rx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682 goto drop;
683 }
684 if (tunnel->parms.i_flags&GRE_SEQ) {
685 if (!(flags&GRE_SEQ) ||
686 (tunnel->i_seqno && (s32)(seqno - tunnel->i_seqno) < 0)) {
Eric Dumazete985aad2010-09-27 03:57:11 +0000687 tunnel->dev->stats.rx_fifo_errors++;
688 tunnel->dev->stats.rx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689 goto drop;
690 }
691 tunnel->i_seqno = seqno + 1;
692 }
Herbert Xue1a80002008-10-09 12:00:17 -0700693
694 /* Warning: All skb pointers will be invalidated! */
695 if (tunnel->dev->type == ARPHRD_ETHER) {
696 if (!pskb_may_pull(skb, ETH_HLEN)) {
Eric Dumazete985aad2010-09-27 03:57:11 +0000697 tunnel->dev->stats.rx_length_errors++;
698 tunnel->dev->stats.rx_errors++;
Herbert Xue1a80002008-10-09 12:00:17 -0700699 goto drop;
700 }
701
702 iph = ip_hdr(skb);
703 skb->protocol = eth_type_trans(skb, tunnel->dev);
704 skb_postpull_rcsum(skb, eth_hdr(skb), ETH_HLEN);
705 }
706
stephen hemmingereccc1bb2012-09-25 11:02:48 +0000707 __skb_tunnel_rx(skb, tunnel->dev);
708
709 skb_reset_network_header(skb);
710 err = IP_ECN_decapsulate(iph, skb);
711 if (unlikely(err)) {
712 if (log_ecn_error)
713 net_info_ratelimited("non-ECT from %pI4 with TOS=%#x\n",
714 &iph->saddr, iph->tos);
715 if (err > 1) {
716 ++tunnel->dev->stats.rx_frame_errors;
717 ++tunnel->dev->stats.rx_errors;
718 goto drop;
719 }
720 }
721
Eric Dumazete985aad2010-09-27 03:57:11 +0000722 tstats = this_cpu_ptr(tunnel->dev->tstats);
stephen hemminger87b6d212012-04-12 06:31:16 +0000723 u64_stats_update_begin(&tstats->syncp);
Eric Dumazete985aad2010-09-27 03:57:11 +0000724 tstats->rx_packets++;
725 tstats->rx_bytes += skb->len;
stephen hemminger87b6d212012-04-12 06:31:16 +0000726 u64_stats_update_end(&tstats->syncp);
Eric Dumazete985aad2010-09-27 03:57:11 +0000727
Eric Dumazet60769a52012-09-27 02:48:50 +0000728 gro_cells_receive(&tunnel->gro_cells, skb);
Eric Dumazet8990f462010-09-20 00:12:11 +0000729 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730 }
Herbert Xu45af08b2006-04-05 22:31:19 -0700731 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732
733drop:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734 kfree_skb(skb);
Eric Dumazeta02cec22010-09-22 20:43:57 +0000735 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736}
737
Stephen Hemminger6fef4c02009-08-31 19:50:41 +0000738static netdev_tx_t ipgre_tunnel_xmit(struct sk_buff *skb, struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739{
Patrick McHardy2941a482006-01-08 22:05:26 -0800740 struct ip_tunnel *tunnel = netdev_priv(dev);
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000741 const struct iphdr *old_iph = ip_hdr(skb);
742 const struct iphdr *tiph;
David S. Millercbb1e852011-05-04 12:33:34 -0700743 struct flowi4 fl4;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700744 u8 tos;
Al Virod5a0a1e2006-11-08 00:23:14 -0800745 __be16 df;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746 struct rtable *rt; /* Route to the other host */
Eric Dumazet15078502010-09-15 11:07:53 +0000747 struct net_device *tdev; /* Device to other host */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748 struct iphdr *iph; /* Our new IP header */
Chuck Leverc2636b42007-10-23 21:07:32 -0700749 unsigned int max_headroom; /* The extra header space needed */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750 int gre_hlen;
Al Virod5a0a1e2006-11-08 00:23:14 -0800751 __be32 dst;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752 int mtu;
Eric Dumazetf7e75ba2012-12-20 16:00:27 +0000753 u8 ttl;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754
Eric Dumazet6b78f162012-09-13 21:25:33 +0000755 if (skb->ip_summed == CHECKSUM_PARTIAL &&
756 skb_checksum_help(skb))
757 goto tx_error;
758
Herbert Xue1a80002008-10-09 12:00:17 -0700759 if (dev->type == ARPHRD_ETHER)
760 IPCB(skb)->flags = 0;
761
762 if (dev->header_ops && dev->type == ARPHRD_IPGRE) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700763 gre_hlen = 0;
Isaku Yamahata412ed942012-12-20 15:12:52 +0000764 if (skb->protocol == htons(ETH_P_IP))
765 tiph = (const struct iphdr *)skb->data;
766 else
767 tiph = &tunnel->parms.iph;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768 } else {
769 gre_hlen = tunnel->hlen;
770 tiph = &tunnel->parms.iph;
771 }
772
773 if ((dst = tiph->daddr) == 0) {
774 /* NBMA tunnel */
775
Eric Dumazetadf30902009-06-02 05:19:30 +0000776 if (skb_dst(skb) == NULL) {
Eric Dumazete985aad2010-09-27 03:57:11 +0000777 dev->stats.tx_fifo_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700778 goto tx_error;
779 }
780
David S. Miller61d57f82012-01-24 18:23:30 -0500781 if (skb->protocol == htons(ETH_P_IP)) {
Eric Dumazet511c3f92009-06-02 05:14:27 +0000782 rt = skb_rtable(skb);
David S. Millerf8126f12012-07-13 05:03:45 -0700783 dst = rt_nexthop(rt, old_iph->daddr);
David S. Miller61d57f82012-01-24 18:23:30 -0500784 }
Eric Dumazetdfd56b82011-12-10 09:48:31 +0000785#if IS_ENABLED(CONFIG_IPV6)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700786 else if (skb->protocol == htons(ETH_P_IPV6)) {
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000787 const struct in6_addr *addr6;
David S. Miller0ec88662012-01-27 15:01:08 -0800788 struct neighbour *neigh;
789 bool do_tx_error_icmp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700790 int addr_type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791
David S. Miller0ec88662012-01-27 15:01:08 -0800792 neigh = dst_neigh_lookup(skb_dst(skb), &ipv6_hdr(skb)->daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793 if (neigh == NULL)
794 goto tx_error;
795
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000796 addr6 = (const struct in6_addr *)&neigh->primary_key;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797 addr_type = ipv6_addr_type(addr6);
798
799 if (addr_type == IPV6_ADDR_ANY) {
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700800 addr6 = &ipv6_hdr(skb)->daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801 addr_type = ipv6_addr_type(addr6);
802 }
803
804 if ((addr_type & IPV6_ADDR_COMPATv4) == 0)
David S. Miller0ec88662012-01-27 15:01:08 -0800805 do_tx_error_icmp = true;
806 else {
807 do_tx_error_icmp = false;
808 dst = addr6->s6_addr32[3];
809 }
810 neigh_release(neigh);
811 if (do_tx_error_icmp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700812 goto tx_error_icmp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813 }
814#endif
815 else
816 goto tx_error;
817 }
818
Eric Dumazetf7e75ba2012-12-20 16:00:27 +0000819 ttl = tiph->ttl;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700820 tos = tiph->tos;
Andreas Jaggiee686ca2009-07-14 09:35:59 -0700821 if (tos == 1) {
822 tos = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823 if (skb->protocol == htons(ETH_P_IP))
824 tos = old_iph->tos;
Stephen Hemmingerdd4ba832010-07-08 21:35:58 -0700825 else if (skb->protocol == htons(ETH_P_IPV6))
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000826 tos = ipv6_get_dsfield((const struct ipv6hdr *)old_iph);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827 }
828
David S. Millercbb1e852011-05-04 12:33:34 -0700829 rt = ip_route_output_gre(dev_net(dev), &fl4, dst, tiph->saddr,
David S. Miller78fbfd82011-03-12 00:00:52 -0500830 tunnel->parms.o_key, RT_TOS(tos),
831 tunnel->parms.link);
832 if (IS_ERR(rt)) {
833 dev->stats.tx_carrier_errors++;
834 goto tx_error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700835 }
Changli Gaod8d1f302010-06-10 23:31:35 -0700836 tdev = rt->dst.dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837
838 if (tdev == dev) {
839 ip_rt_put(rt);
Eric Dumazete985aad2010-09-27 03:57:11 +0000840 dev->stats.collisions++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841 goto tx_error;
842 }
843
844 df = tiph->frag_off;
845 if (df)
Changli Gaod8d1f302010-06-10 23:31:35 -0700846 mtu = dst_mtu(&rt->dst) - dev->hard_header_len - tunnel->hlen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700847 else
Eric Dumazetadf30902009-06-02 05:19:30 +0000848 mtu = skb_dst(skb) ? dst_mtu(skb_dst(skb)) : dev->mtu;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700849
Eric Dumazetadf30902009-06-02 05:19:30 +0000850 if (skb_dst(skb))
David S. Miller6700c272012-07-17 03:29:28 -0700851 skb_dst(skb)->ops->update_pmtu(skb_dst(skb), NULL, skb, mtu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852
853 if (skb->protocol == htons(ETH_P_IP)) {
854 df |= (old_iph->frag_off&htons(IP_DF));
855
856 if ((old_iph->frag_off&htons(IP_DF)) &&
857 mtu < ntohs(old_iph->tot_len)) {
858 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED, htonl(mtu));
859 ip_rt_put(rt);
860 goto tx_error;
861 }
862 }
Eric Dumazetdfd56b82011-12-10 09:48:31 +0000863#if IS_ENABLED(CONFIG_IPV6)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864 else if (skb->protocol == htons(ETH_P_IPV6)) {
Eric Dumazetadf30902009-06-02 05:19:30 +0000865 struct rt6_info *rt6 = (struct rt6_info *)skb_dst(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866
Eric Dumazetadf30902009-06-02 05:19:30 +0000867 if (rt6 && mtu < dst_mtu(skb_dst(skb)) && mtu >= IPV6_MIN_MTU) {
Joe Perchesf97c1e02007-12-16 13:45:43 -0800868 if ((tunnel->parms.iph.daddr &&
869 !ipv4_is_multicast(tunnel->parms.iph.daddr)) ||
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870 rt6->rt6i_dst.plen == 128) {
871 rt6->rt6i_flags |= RTF_MODIFIED;
David S. Millerdefb3512010-12-08 21:16:57 -0800872 dst_metric_set(skb_dst(skb), RTAX_MTU, mtu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700873 }
874 }
875
876 if (mtu >= IPV6_MIN_MTU && mtu < skb->len - tunnel->hlen + gre_hlen) {
Alexey Dobriyan3ffe5332010-02-18 08:25:24 +0000877 icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, mtu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700878 ip_rt_put(rt);
879 goto tx_error;
880 }
881 }
882#endif
883
884 if (tunnel->err_count > 0) {
Wei Yongjunda6185d82009-02-24 23:34:48 -0800885 if (time_before(jiffies,
886 tunnel->err_time + IPTUNNEL_ERR_TIMEO)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700887 tunnel->err_count--;
888
889 dst_link_failure(skb);
890 } else
891 tunnel->err_count = 0;
892 }
893
Changli Gaod8d1f302010-06-10 23:31:35 -0700894 max_headroom = LL_RESERVED_SPACE(tdev) + gre_hlen + rt->dst.header_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700895
Patrick McHardycfbba492007-07-09 15:33:40 -0700896 if (skb_headroom(skb) < max_headroom || skb_shared(skb)||
897 (skb_cloned(skb) && !skb_clone_writable(skb, 0))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700898 struct sk_buff *new_skb = skb_realloc_headroom(skb, max_headroom);
Herbert Xu805dc1d2011-11-18 02:20:06 +0000899 if (max_headroom > dev->needed_headroom)
900 dev->needed_headroom = max_headroom;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700901 if (!new_skb) {
902 ip_rt_put(rt);
Eric Dumazete985aad2010-09-27 03:57:11 +0000903 dev->stats.tx_dropped++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700904 dev_kfree_skb(skb);
Patrick McHardy6ed10652009-06-23 06:03:08 +0000905 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700906 }
907 if (skb->sk)
908 skb_set_owner_w(new_skb, skb->sk);
909 dev_kfree_skb(skb);
910 skb = new_skb;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700911 old_iph = ip_hdr(skb);
Eric Dumazetf7e75ba2012-12-20 16:00:27 +0000912 /* Warning : tiph value might point to freed memory */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700913 }
914
Arnaldo Carvalho de Meloe2d1bca2007-04-10 20:46:21 -0700915 skb_push(skb, gre_hlen);
916 skb_reset_network_header(skb);
Isaku Yamahata861aa6d2012-12-24 16:51:03 +0000917 skb_set_transport_header(skb, sizeof(*iph));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700918 memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
Patrick McHardy48d5cad2006-02-15 15:10:22 -0800919 IPCB(skb)->flags &= ~(IPSKB_XFRM_TUNNEL_SIZE | IPSKB_XFRM_TRANSFORMED |
920 IPSKB_REROUTED);
Eric Dumazetadf30902009-06-02 05:19:30 +0000921 skb_dst_drop(skb);
Changli Gaod8d1f302010-06-10 23:31:35 -0700922 skb_dst_set(skb, &rt->dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700923
924 /*
925 * Push down and install the IPIP header.
926 */
927
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700928 iph = ip_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929 iph->version = 4;
930 iph->ihl = sizeof(struct iphdr) >> 2;
931 iph->frag_off = df;
932 iph->protocol = IPPROTO_GRE;
933 iph->tos = ipgre_ecn_encapsulate(tos, old_iph, skb);
David S. Millercbb1e852011-05-04 12:33:34 -0700934 iph->daddr = fl4.daddr;
935 iph->saddr = fl4.saddr;
Eric Dumazetf7e75ba2012-12-20 16:00:27 +0000936 iph->ttl = ttl;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700937
Eric Dumazetf7e75ba2012-12-20 16:00:27 +0000938 if (ttl == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700939 if (skb->protocol == htons(ETH_P_IP))
940 iph->ttl = old_iph->ttl;
Eric Dumazetdfd56b82011-12-10 09:48:31 +0000941#if IS_ENABLED(CONFIG_IPV6)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700942 else if (skb->protocol == htons(ETH_P_IPV6))
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000943 iph->ttl = ((const struct ipv6hdr *)old_iph)->hop_limit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700944#endif
945 else
David S. Miller323e1262010-12-12 21:55:08 -0800946 iph->ttl = ip4_dst_hoplimit(&rt->dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700947 }
948
Herbert Xue1a80002008-10-09 12:00:17 -0700949 ((__be16 *)(iph + 1))[0] = tunnel->parms.o_flags;
950 ((__be16 *)(iph + 1))[1] = (dev->type == ARPHRD_ETHER) ?
951 htons(ETH_P_TEB) : skb->protocol;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700952
953 if (tunnel->parms.o_flags&(GRE_KEY|GRE_CSUM|GRE_SEQ)) {
Daniel Baluta5e73ea12012-04-15 01:34:41 +0000954 __be32 *ptr = (__be32 *)(((u8 *)iph) + tunnel->hlen - 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700955
956 if (tunnel->parms.o_flags&GRE_SEQ) {
957 ++tunnel->o_seqno;
958 *ptr = htonl(tunnel->o_seqno);
959 ptr--;
960 }
961 if (tunnel->parms.o_flags&GRE_KEY) {
962 *ptr = tunnel->parms.o_key;
963 ptr--;
964 }
965 if (tunnel->parms.o_flags&GRE_CSUM) {
Pravin B Shelar54657402013-01-23 11:45:42 +0000966 int offset = skb_transport_offset(skb);
967
Linus Torvalds1da177e2005-04-16 15:20:36 -0700968 *ptr = 0;
Pravin B Shelar54657402013-01-23 11:45:42 +0000969 *(__sum16 *)ptr = csum_fold(skb_checksum(skb, offset,
970 skb->len - offset,
971 0));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700972 }
973 }
974
Amerigo Wangaa0010f2012-11-11 21:52:33 +0000975 iptunnel_xmit(skb, dev);
Patrick McHardy6ed10652009-06-23 06:03:08 +0000976 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700977
David S. Miller496053f2012-01-11 16:46:32 -0800978#if IS_ENABLED(CONFIG_IPV6)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700979tx_error_icmp:
980 dst_link_failure(skb);
David S. Miller496053f2012-01-11 16:46:32 -0800981#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700982tx_error:
Eric Dumazete985aad2010-09-27 03:57:11 +0000983 dev->stats.tx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700984 dev_kfree_skb(skb);
Patrick McHardy6ed10652009-06-23 06:03:08 +0000985 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700986}
987
Herbert Xu42aa9162008-10-09 11:59:32 -0700988static int ipgre_tunnel_bind_dev(struct net_device *dev)
Michal Schmidtee34c1e2007-12-13 09:46:32 -0800989{
990 struct net_device *tdev = NULL;
991 struct ip_tunnel *tunnel;
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000992 const struct iphdr *iph;
Michal Schmidtee34c1e2007-12-13 09:46:32 -0800993 int hlen = LL_MAX_HEADER;
994 int mtu = ETH_DATA_LEN;
995 int addend = sizeof(struct iphdr) + 4;
996
997 tunnel = netdev_priv(dev);
998 iph = &tunnel->parms.iph;
999
Herbert Xuc95b8192008-10-09 11:58:54 -07001000 /* Guess output device to choose reasonable mtu and needed_headroom */
Michal Schmidtee34c1e2007-12-13 09:46:32 -08001001
1002 if (iph->daddr) {
David S. Millercbb1e852011-05-04 12:33:34 -07001003 struct flowi4 fl4;
1004 struct rtable *rt;
Eric Dumazete985aad2010-09-27 03:57:11 +00001005
David S. Millercbb1e852011-05-04 12:33:34 -07001006 rt = ip_route_output_gre(dev_net(dev), &fl4,
1007 iph->daddr, iph->saddr,
1008 tunnel->parms.o_key,
1009 RT_TOS(iph->tos),
1010 tunnel->parms.link);
David S. Millerb23dd4f2011-03-02 14:31:35 -08001011 if (!IS_ERR(rt)) {
Changli Gaod8d1f302010-06-10 23:31:35 -07001012 tdev = rt->dst.dev;
Michal Schmidtee34c1e2007-12-13 09:46:32 -08001013 ip_rt_put(rt);
1014 }
Herbert Xue1a80002008-10-09 12:00:17 -07001015
1016 if (dev->type != ARPHRD_ETHER)
1017 dev->flags |= IFF_POINTOPOINT;
Michal Schmidtee34c1e2007-12-13 09:46:32 -08001018 }
1019
1020 if (!tdev && tunnel->parms.link)
Pavel Emelyanov96635522008-04-16 01:10:44 -07001021 tdev = __dev_get_by_index(dev_net(dev), tunnel->parms.link);
Michal Schmidtee34c1e2007-12-13 09:46:32 -08001022
1023 if (tdev) {
Herbert Xuc95b8192008-10-09 11:58:54 -07001024 hlen = tdev->hard_header_len + tdev->needed_headroom;
Michal Schmidtee34c1e2007-12-13 09:46:32 -08001025 mtu = tdev->mtu;
1026 }
1027 dev->iflink = tunnel->parms.link;
1028
1029 /* Precalculate GRE options length */
1030 if (tunnel->parms.o_flags&(GRE_CSUM|GRE_KEY|GRE_SEQ)) {
1031 if (tunnel->parms.o_flags&GRE_CSUM)
1032 addend += 4;
1033 if (tunnel->parms.o_flags&GRE_KEY)
1034 addend += 4;
1035 if (tunnel->parms.o_flags&GRE_SEQ)
1036 addend += 4;
1037 }
Herbert Xuc95b8192008-10-09 11:58:54 -07001038 dev->needed_headroom = addend + hlen;
Tom Goff8cdb0452009-08-14 16:33:56 -07001039 mtu -= dev->hard_header_len + addend;
Herbert Xu42aa9162008-10-09 11:59:32 -07001040
1041 if (mtu < 68)
1042 mtu = 68;
1043
Michal Schmidtee34c1e2007-12-13 09:46:32 -08001044 tunnel->hlen = addend;
1045
Herbert Xu42aa9162008-10-09 11:59:32 -07001046 return mtu;
Michal Schmidtee34c1e2007-12-13 09:46:32 -08001047}
1048
Linus Torvalds1da177e2005-04-16 15:20:36 -07001049static int
1050ipgre_tunnel_ioctl (struct net_device *dev, struct ifreq *ifr, int cmd)
1051{
1052 int err = 0;
1053 struct ip_tunnel_parm p;
1054 struct ip_tunnel *t;
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -07001055 struct net *net = dev_net(dev);
1056 struct ipgre_net *ign = net_generic(net, ipgre_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001057
1058 switch (cmd) {
1059 case SIOCGETTUNNEL:
1060 t = NULL;
Pavel Emelyanov7daa0002008-04-16 01:10:05 -07001061 if (dev == ign->fb_tunnel_dev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001062 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p))) {
1063 err = -EFAULT;
1064 break;
1065 }
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -07001066 t = ipgre_tunnel_locate(net, &p, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001067 }
1068 if (t == NULL)
Patrick McHardy2941a482006-01-08 22:05:26 -08001069 t = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001070 memcpy(&p, &t->parms, sizeof(p));
1071 if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p)))
1072 err = -EFAULT;
1073 break;
1074
1075 case SIOCADDTUNNEL:
1076 case SIOCCHGTUNNEL:
1077 err = -EPERM;
Eric W. Biederman52e804c2012-11-16 03:03:05 +00001078 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001079 goto done;
1080
1081 err = -EFAULT;
1082 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
1083 goto done;
1084
1085 err = -EINVAL;
1086 if (p.iph.version != 4 || p.iph.protocol != IPPROTO_GRE ||
1087 p.iph.ihl != 5 || (p.iph.frag_off&htons(~IP_DF)) ||
1088 ((p.i_flags|p.o_flags)&(GRE_VERSION|GRE_ROUTING)))
1089 goto done;
1090 if (p.iph.ttl)
1091 p.iph.frag_off |= htons(IP_DF);
1092
1093 if (!(p.i_flags&GRE_KEY))
1094 p.i_key = 0;
1095 if (!(p.o_flags&GRE_KEY))
1096 p.o_key = 0;
1097
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -07001098 t = ipgre_tunnel_locate(net, &p, cmd == SIOCADDTUNNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001099
Pavel Emelyanov7daa0002008-04-16 01:10:05 -07001100 if (dev != ign->fb_tunnel_dev && cmd == SIOCCHGTUNNEL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001101 if (t != NULL) {
1102 if (t->dev != dev) {
1103 err = -EEXIST;
1104 break;
1105 }
1106 } else {
Eric Dumazet15078502010-09-15 11:07:53 +00001107 unsigned int nflags = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001108
Patrick McHardy2941a482006-01-08 22:05:26 -08001109 t = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001110
Joe Perchesf97c1e02007-12-16 13:45:43 -08001111 if (ipv4_is_multicast(p.iph.daddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001112 nflags = IFF_BROADCAST;
1113 else if (p.iph.daddr)
1114 nflags = IFF_POINTOPOINT;
1115
1116 if ((dev->flags^nflags)&(IFF_POINTOPOINT|IFF_BROADCAST)) {
1117 err = -EINVAL;
1118 break;
1119 }
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -07001120 ipgre_tunnel_unlink(ign, t);
Pavel Emelyanov74b0b852010-10-27 05:43:53 +00001121 synchronize_net();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001122 t->parms.iph.saddr = p.iph.saddr;
1123 t->parms.iph.daddr = p.iph.daddr;
1124 t->parms.i_key = p.i_key;
1125 t->parms.o_key = p.o_key;
1126 memcpy(dev->dev_addr, &p.iph.saddr, 4);
1127 memcpy(dev->broadcast, &p.iph.daddr, 4);
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -07001128 ipgre_tunnel_link(ign, t);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001129 netdev_state_change(dev);
1130 }
1131 }
1132
1133 if (t) {
1134 err = 0;
1135 if (cmd == SIOCCHGTUNNEL) {
1136 t->parms.iph.ttl = p.iph.ttl;
1137 t->parms.iph.tos = p.iph.tos;
1138 t->parms.iph.frag_off = p.iph.frag_off;
Michal Schmidtee34c1e2007-12-13 09:46:32 -08001139 if (t->parms.link != p.link) {
1140 t->parms.link = p.link;
Herbert Xu42aa9162008-10-09 11:59:32 -07001141 dev->mtu = ipgre_tunnel_bind_dev(dev);
Michal Schmidtee34c1e2007-12-13 09:46:32 -08001142 netdev_state_change(dev);
1143 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001144 }
1145 if (copy_to_user(ifr->ifr_ifru.ifru_data, &t->parms, sizeof(p)))
1146 err = -EFAULT;
1147 } else
1148 err = (cmd == SIOCADDTUNNEL ? -ENOBUFS : -ENOENT);
1149 break;
1150
1151 case SIOCDELTUNNEL:
1152 err = -EPERM;
Eric W. Biederman52e804c2012-11-16 03:03:05 +00001153 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001154 goto done;
1155
Pavel Emelyanov7daa0002008-04-16 01:10:05 -07001156 if (dev == ign->fb_tunnel_dev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001157 err = -EFAULT;
1158 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
1159 goto done;
1160 err = -ENOENT;
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -07001161 if ((t = ipgre_tunnel_locate(net, &p, 0)) == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001162 goto done;
1163 err = -EPERM;
Pavel Emelyanov7daa0002008-04-16 01:10:05 -07001164 if (t == netdev_priv(ign->fb_tunnel_dev))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001165 goto done;
1166 dev = t->dev;
1167 }
Stephen Hemminger22f8cde2007-02-07 00:09:58 -08001168 unregister_netdevice(dev);
1169 err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001170 break;
1171
1172 default:
1173 err = -EINVAL;
1174 }
1175
1176done:
1177 return err;
1178}
1179
Linus Torvalds1da177e2005-04-16 15:20:36 -07001180static int ipgre_tunnel_change_mtu(struct net_device *dev, int new_mtu)
1181{
Patrick McHardy2941a482006-01-08 22:05:26 -08001182 struct ip_tunnel *tunnel = netdev_priv(dev);
Herbert Xuc95b8192008-10-09 11:58:54 -07001183 if (new_mtu < 68 ||
1184 new_mtu > 0xFFF8 - dev->hard_header_len - tunnel->hlen)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001185 return -EINVAL;
1186 dev->mtu = new_mtu;
1187 return 0;
1188}
1189
Linus Torvalds1da177e2005-04-16 15:20:36 -07001190/* Nice toy. Unfortunately, useless in real life :-)
1191 It allows to construct virtual multiprotocol broadcast "LAN"
1192 over the Internet, provided multicast routing is tuned.
1193
1194
1195 I have no idea was this bicycle invented before me,
1196 so that I had to set ARPHRD_IPGRE to a random value.
1197 I have an impression, that Cisco could make something similar,
1198 but this feature is apparently missing in IOS<=11.2(8).
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001199
Linus Torvalds1da177e2005-04-16 15:20:36 -07001200 I set up 10.66.66/24 and fec0:6666:6666::0/96 as virtual networks
1201 with broadcast 224.66.66.66. If you have access to mbone, play with me :-)
1202
1203 ping -t 255 224.66.66.66
1204
1205 If nobody answers, mbone does not work.
1206
1207 ip tunnel add Universe mode gre remote 224.66.66.66 local <Your_real_addr> ttl 255
1208 ip addr add 10.66.66.<somewhat>/24 dev Universe
1209 ifconfig Universe up
1210 ifconfig Universe add fe80::<Your_real_addr>/10
1211 ifconfig Universe add fec0:6666:6666::<Your_real_addr>/96
1212 ftp 10.66.66.66
1213 ...
1214 ftp fec0:6666:6666::193.233.7.65
1215 ...
1216
1217 */
1218
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -07001219static int ipgre_header(struct sk_buff *skb, struct net_device *dev,
1220 unsigned short type,
Eric Dumazet15078502010-09-15 11:07:53 +00001221 const void *daddr, const void *saddr, unsigned int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001222{
Patrick McHardy2941a482006-01-08 22:05:26 -08001223 struct ip_tunnel *t = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001224 struct iphdr *iph = (struct iphdr *)skb_push(skb, t->hlen);
Daniel Baluta5e73ea12012-04-15 01:34:41 +00001225 __be16 *p = (__be16 *)(iph+1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001226
1227 memcpy(iph, &t->parms.iph, sizeof(struct iphdr));
1228 p[0] = t->parms.o_flags;
1229 p[1] = htons(type);
1230
1231 /*
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001232 * Set the source hardware address.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001233 */
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001234
Linus Torvalds1da177e2005-04-16 15:20:36 -07001235 if (saddr)
1236 memcpy(&iph->saddr, saddr, 4);
Timo Teräs6d55cb92010-03-03 04:01:13 +00001237 if (daddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001238 memcpy(&iph->daddr, daddr, 4);
Timo Teräs6d55cb92010-03-03 04:01:13 +00001239 if (iph->daddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001240 return t->hlen;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001241
Linus Torvalds1da177e2005-04-16 15:20:36 -07001242 return -t->hlen;
1243}
1244
Timo Teras6a5f44d2007-10-23 20:31:53 -07001245static int ipgre_header_parse(const struct sk_buff *skb, unsigned char *haddr)
1246{
Eric Dumazetb71d1d42011-04-22 04:53:02 +00001247 const struct iphdr *iph = (const struct iphdr *) skb_mac_header(skb);
Timo Teras6a5f44d2007-10-23 20:31:53 -07001248 memcpy(haddr, &iph->saddr, 4);
1249 return 4;
1250}
1251
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -07001252static const struct header_ops ipgre_header_ops = {
1253 .create = ipgre_header,
Timo Teras6a5f44d2007-10-23 20:31:53 -07001254 .parse = ipgre_header_parse,
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -07001255};
1256
Timo Teras6a5f44d2007-10-23 20:31:53 -07001257#ifdef CONFIG_NET_IPGRE_BROADCAST
Linus Torvalds1da177e2005-04-16 15:20:36 -07001258static int ipgre_open(struct net_device *dev)
1259{
Patrick McHardy2941a482006-01-08 22:05:26 -08001260 struct ip_tunnel *t = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001261
Joe Perchesf97c1e02007-12-16 13:45:43 -08001262 if (ipv4_is_multicast(t->parms.iph.daddr)) {
David S. Millercbb1e852011-05-04 12:33:34 -07001263 struct flowi4 fl4;
1264 struct rtable *rt;
Eric Dumazete985aad2010-09-27 03:57:11 +00001265
David S. Millercbb1e852011-05-04 12:33:34 -07001266 rt = ip_route_output_gre(dev_net(dev), &fl4,
1267 t->parms.iph.daddr,
1268 t->parms.iph.saddr,
1269 t->parms.o_key,
1270 RT_TOS(t->parms.iph.tos),
1271 t->parms.link);
David S. Millerb23dd4f2011-03-02 14:31:35 -08001272 if (IS_ERR(rt))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001273 return -EADDRNOTAVAIL;
Changli Gaod8d1f302010-06-10 23:31:35 -07001274 dev = rt->dst.dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001275 ip_rt_put(rt);
Herbert Xue5ed6392005-10-03 14:35:55 -07001276 if (__in_dev_get_rtnl(dev) == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001277 return -EADDRNOTAVAIL;
1278 t->mlink = dev->ifindex;
Herbert Xue5ed6392005-10-03 14:35:55 -07001279 ip_mc_inc_group(__in_dev_get_rtnl(dev), t->parms.iph.daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001280 }
1281 return 0;
1282}
1283
1284static int ipgre_close(struct net_device *dev)
1285{
Patrick McHardy2941a482006-01-08 22:05:26 -08001286 struct ip_tunnel *t = netdev_priv(dev);
Stephen Hemmingerb8c26a32008-11-20 20:34:29 -08001287
Joe Perchesf97c1e02007-12-16 13:45:43 -08001288 if (ipv4_is_multicast(t->parms.iph.daddr) && t->mlink) {
Denis V. Lunev7fee0ca2008-01-21 17:32:38 -08001289 struct in_device *in_dev;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001290 in_dev = inetdev_by_index(dev_net(dev), t->mlink);
Eric Dumazet8723e1b2010-10-19 00:39:26 +00001291 if (in_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001292 ip_mc_dec_group(in_dev, t->parms.iph.daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001293 }
1294 return 0;
1295}
1296
1297#endif
1298
Stephen Hemmingerb8c26a32008-11-20 20:34:29 -08001299static const struct net_device_ops ipgre_netdev_ops = {
1300 .ndo_init = ipgre_tunnel_init,
1301 .ndo_uninit = ipgre_tunnel_uninit,
1302#ifdef CONFIG_NET_IPGRE_BROADCAST
1303 .ndo_open = ipgre_open,
1304 .ndo_stop = ipgre_close,
1305#endif
1306 .ndo_start_xmit = ipgre_tunnel_xmit,
1307 .ndo_do_ioctl = ipgre_tunnel_ioctl,
1308 .ndo_change_mtu = ipgre_tunnel_change_mtu,
stephen hemminger87b6d212012-04-12 06:31:16 +00001309 .ndo_get_stats64 = ipgre_get_stats64,
Stephen Hemmingerb8c26a32008-11-20 20:34:29 -08001310};
1311
Eric Dumazete985aad2010-09-27 03:57:11 +00001312static void ipgre_dev_free(struct net_device *dev)
1313{
Eric Dumazet60769a52012-09-27 02:48:50 +00001314 struct ip_tunnel *tunnel = netdev_priv(dev);
1315
1316 gro_cells_destroy(&tunnel->gro_cells);
Eric Dumazete985aad2010-09-27 03:57:11 +00001317 free_percpu(dev->tstats);
1318 free_netdev(dev);
1319}
1320
Eric Dumazet6b78f162012-09-13 21:25:33 +00001321#define GRE_FEATURES (NETIF_F_SG | \
1322 NETIF_F_FRAGLIST | \
1323 NETIF_F_HIGHDMA | \
1324 NETIF_F_HW_CSUM)
1325
Linus Torvalds1da177e2005-04-16 15:20:36 -07001326static void ipgre_tunnel_setup(struct net_device *dev)
1327{
Stephen Hemmingerb8c26a32008-11-20 20:34:29 -08001328 dev->netdev_ops = &ipgre_netdev_ops;
Eric Dumazete985aad2010-09-27 03:57:11 +00001329 dev->destructor = ipgre_dev_free;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001330
1331 dev->type = ARPHRD_IPGRE;
Herbert Xuc95b8192008-10-09 11:58:54 -07001332 dev->needed_headroom = LL_MAX_HEADER + sizeof(struct iphdr) + 4;
Kris Katterjohn46f25df2006-01-05 16:35:42 -08001333 dev->mtu = ETH_DATA_LEN - sizeof(struct iphdr) - 4;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001334 dev->flags = IFF_NOARP;
1335 dev->iflink = 0;
1336 dev->addr_len = 4;
Pavel Emelyanov0b67ece2008-04-16 01:11:13 -07001337 dev->features |= NETIF_F_NETNS_LOCAL;
Eric Dumazet108bfa82009-05-28 22:35:10 +00001338 dev->priv_flags &= ~IFF_XMIT_DST_RELEASE;
Eric Dumazet6b78f162012-09-13 21:25:33 +00001339
1340 dev->features |= GRE_FEATURES;
1341 dev->hw_features |= GRE_FEATURES;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001342}
1343
1344static int ipgre_tunnel_init(struct net_device *dev)
1345{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001346 struct ip_tunnel *tunnel;
1347 struct iphdr *iph;
Eric Dumazet60769a52012-09-27 02:48:50 +00001348 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001349
Patrick McHardy2941a482006-01-08 22:05:26 -08001350 tunnel = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001351 iph = &tunnel->parms.iph;
1352
1353 tunnel->dev = dev;
1354 strcpy(tunnel->parms.name, dev->name);
1355
1356 memcpy(dev->dev_addr, &tunnel->parms.iph.saddr, 4);
1357 memcpy(dev->broadcast, &tunnel->parms.iph.daddr, 4);
1358
Linus Torvalds1da177e2005-04-16 15:20:36 -07001359 if (iph->daddr) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001360#ifdef CONFIG_NET_IPGRE_BROADCAST
Joe Perchesf97c1e02007-12-16 13:45:43 -08001361 if (ipv4_is_multicast(iph->daddr)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001362 if (!iph->saddr)
1363 return -EINVAL;
1364 dev->flags = IFF_BROADCAST;
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -07001365 dev->header_ops = &ipgre_header_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001366 }
1367#endif
Michal Schmidtee34c1e2007-12-13 09:46:32 -08001368 } else
Timo Teras6a5f44d2007-10-23 20:31:53 -07001369 dev->header_ops = &ipgre_header_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001370
Eric Dumazete985aad2010-09-27 03:57:11 +00001371 dev->tstats = alloc_percpu(struct pcpu_tstats);
1372 if (!dev->tstats)
1373 return -ENOMEM;
1374
Eric Dumazet60769a52012-09-27 02:48:50 +00001375 err = gro_cells_init(&tunnel->gro_cells, dev);
1376 if (err) {
1377 free_percpu(dev->tstats);
1378 return err;
1379 }
1380
Linus Torvalds1da177e2005-04-16 15:20:36 -07001381 return 0;
1382}
1383
Stephen Hemmingerb8c26a32008-11-20 20:34:29 -08001384static void ipgre_fb_tunnel_init(struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001385{
Patrick McHardy2941a482006-01-08 22:05:26 -08001386 struct ip_tunnel *tunnel = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001387 struct iphdr *iph = &tunnel->parms.iph;
1388
1389 tunnel->dev = dev;
1390 strcpy(tunnel->parms.name, dev->name);
1391
1392 iph->version = 4;
1393 iph->protocol = IPPROTO_GRE;
1394 iph->ihl = 5;
1395 tunnel->hlen = sizeof(struct iphdr) + 4;
1396
1397 dev_hold(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001398}
1399
1400
Dmitry Kozlov00959ad2010-08-21 23:05:39 -07001401static const struct gre_protocol ipgre_protocol = {
1402 .handler = ipgre_rcv,
1403 .err_handler = ipgre_err,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001404};
1405
Eric Dumazeteef6dd62009-10-27 07:07:16 +00001406static void ipgre_destroy_tunnels(struct ipgre_net *ign, struct list_head *head)
Pavel Emelyanoveb8ce742008-04-16 01:10:26 -07001407{
1408 int prio;
1409
1410 for (prio = 0; prio < 4; prio++) {
1411 int h;
1412 for (h = 0; h < HASH_SIZE; h++) {
Eric Dumazet15078502010-09-15 11:07:53 +00001413 struct ip_tunnel *t;
1414
1415 t = rtnl_dereference(ign->tunnels[prio][h]);
Eric Dumazeteef6dd62009-10-27 07:07:16 +00001416
1417 while (t != NULL) {
1418 unregister_netdevice_queue(t->dev, head);
Eric Dumazet15078502010-09-15 11:07:53 +00001419 t = rtnl_dereference(t->next);
Eric Dumazeteef6dd62009-10-27 07:07:16 +00001420 }
Pavel Emelyanoveb8ce742008-04-16 01:10:26 -07001421 }
1422 }
1423}
1424
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00001425static int __net_init ipgre_init_net(struct net *net)
Pavel Emelyanov59a4c752008-04-16 01:08:53 -07001426{
Eric W. Biedermancfb8fbf2009-11-29 15:46:13 +00001427 struct ipgre_net *ign = net_generic(net, ipgre_net_id);
Pavel Emelyanov59a4c752008-04-16 01:08:53 -07001428 int err;
Pavel Emelyanov59a4c752008-04-16 01:08:53 -07001429
Pavel Emelyanov7daa0002008-04-16 01:10:05 -07001430 ign->fb_tunnel_dev = alloc_netdev(sizeof(struct ip_tunnel), "gre0",
1431 ipgre_tunnel_setup);
1432 if (!ign->fb_tunnel_dev) {
1433 err = -ENOMEM;
1434 goto err_alloc_dev;
1435 }
Alexey Dobriyanbe77e592008-11-23 17:26:26 -08001436 dev_net_set(ign->fb_tunnel_dev, net);
Pavel Emelyanov7daa0002008-04-16 01:10:05 -07001437
Stephen Hemmingerb8c26a32008-11-20 20:34:29 -08001438 ipgre_fb_tunnel_init(ign->fb_tunnel_dev);
Herbert Xuc19e6542008-10-09 11:59:55 -07001439 ign->fb_tunnel_dev->rtnl_link_ops = &ipgre_link_ops;
Pavel Emelyanov7daa0002008-04-16 01:10:05 -07001440
1441 if ((err = register_netdev(ign->fb_tunnel_dev)))
1442 goto err_reg_dev;
1443
Eric Dumazet3285ee32010-10-30 16:21:28 -07001444 rcu_assign_pointer(ign->tunnels_wc[0],
1445 netdev_priv(ign->fb_tunnel_dev));
Pavel Emelyanov59a4c752008-04-16 01:08:53 -07001446 return 0;
1447
Pavel Emelyanov7daa0002008-04-16 01:10:05 -07001448err_reg_dev:
Eric Dumazet3285ee32010-10-30 16:21:28 -07001449 ipgre_dev_free(ign->fb_tunnel_dev);
Pavel Emelyanov7daa0002008-04-16 01:10:05 -07001450err_alloc_dev:
Pavel Emelyanov59a4c752008-04-16 01:08:53 -07001451 return err;
1452}
1453
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00001454static void __net_exit ipgre_exit_net(struct net *net)
Pavel Emelyanov59a4c752008-04-16 01:08:53 -07001455{
1456 struct ipgre_net *ign;
Eric Dumazeteef6dd62009-10-27 07:07:16 +00001457 LIST_HEAD(list);
Pavel Emelyanov59a4c752008-04-16 01:08:53 -07001458
1459 ign = net_generic(net, ipgre_net_id);
Pavel Emelyanov7daa0002008-04-16 01:10:05 -07001460 rtnl_lock();
Eric Dumazeteef6dd62009-10-27 07:07:16 +00001461 ipgre_destroy_tunnels(ign, &list);
1462 unregister_netdevice_many(&list);
Pavel Emelyanov7daa0002008-04-16 01:10:05 -07001463 rtnl_unlock();
Pavel Emelyanov59a4c752008-04-16 01:08:53 -07001464}
1465
1466static struct pernet_operations ipgre_net_ops = {
1467 .init = ipgre_init_net,
1468 .exit = ipgre_exit_net,
Eric W. Biedermancfb8fbf2009-11-29 15:46:13 +00001469 .id = &ipgre_net_id,
1470 .size = sizeof(struct ipgre_net),
Pavel Emelyanov59a4c752008-04-16 01:08:53 -07001471};
Linus Torvalds1da177e2005-04-16 15:20:36 -07001472
Herbert Xuc19e6542008-10-09 11:59:55 -07001473static int ipgre_tunnel_validate(struct nlattr *tb[], struct nlattr *data[])
1474{
1475 __be16 flags;
1476
1477 if (!data)
1478 return 0;
1479
1480 flags = 0;
1481 if (data[IFLA_GRE_IFLAGS])
1482 flags |= nla_get_be16(data[IFLA_GRE_IFLAGS]);
1483 if (data[IFLA_GRE_OFLAGS])
1484 flags |= nla_get_be16(data[IFLA_GRE_OFLAGS]);
1485 if (flags & (GRE_VERSION|GRE_ROUTING))
1486 return -EINVAL;
1487
1488 return 0;
1489}
1490
Herbert Xue1a80002008-10-09 12:00:17 -07001491static int ipgre_tap_validate(struct nlattr *tb[], struct nlattr *data[])
1492{
1493 __be32 daddr;
1494
1495 if (tb[IFLA_ADDRESS]) {
1496 if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
1497 return -EINVAL;
1498 if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
1499 return -EADDRNOTAVAIL;
1500 }
1501
1502 if (!data)
1503 goto out;
1504
1505 if (data[IFLA_GRE_REMOTE]) {
1506 memcpy(&daddr, nla_data(data[IFLA_GRE_REMOTE]), 4);
1507 if (!daddr)
1508 return -EINVAL;
1509 }
1510
1511out:
1512 return ipgre_tunnel_validate(tb, data);
1513}
1514
Herbert Xuc19e6542008-10-09 11:59:55 -07001515static void ipgre_netlink_parms(struct nlattr *data[],
1516 struct ip_tunnel_parm *parms)
1517{
Herbert Xu7bb82d92008-10-11 12:20:15 -07001518 memset(parms, 0, sizeof(*parms));
Herbert Xuc19e6542008-10-09 11:59:55 -07001519
1520 parms->iph.protocol = IPPROTO_GRE;
1521
1522 if (!data)
1523 return;
1524
1525 if (data[IFLA_GRE_LINK])
1526 parms->link = nla_get_u32(data[IFLA_GRE_LINK]);
1527
1528 if (data[IFLA_GRE_IFLAGS])
1529 parms->i_flags = nla_get_be16(data[IFLA_GRE_IFLAGS]);
1530
1531 if (data[IFLA_GRE_OFLAGS])
1532 parms->o_flags = nla_get_be16(data[IFLA_GRE_OFLAGS]);
1533
1534 if (data[IFLA_GRE_IKEY])
1535 parms->i_key = nla_get_be32(data[IFLA_GRE_IKEY]);
1536
1537 if (data[IFLA_GRE_OKEY])
1538 parms->o_key = nla_get_be32(data[IFLA_GRE_OKEY]);
1539
1540 if (data[IFLA_GRE_LOCAL])
Patrick McHardy4d74f8b2008-10-10 12:11:06 -07001541 parms->iph.saddr = nla_get_be32(data[IFLA_GRE_LOCAL]);
Herbert Xuc19e6542008-10-09 11:59:55 -07001542
1543 if (data[IFLA_GRE_REMOTE])
Patrick McHardy4d74f8b2008-10-10 12:11:06 -07001544 parms->iph.daddr = nla_get_be32(data[IFLA_GRE_REMOTE]);
Herbert Xuc19e6542008-10-09 11:59:55 -07001545
1546 if (data[IFLA_GRE_TTL])
1547 parms->iph.ttl = nla_get_u8(data[IFLA_GRE_TTL]);
1548
1549 if (data[IFLA_GRE_TOS])
1550 parms->iph.tos = nla_get_u8(data[IFLA_GRE_TOS]);
1551
1552 if (!data[IFLA_GRE_PMTUDISC] || nla_get_u8(data[IFLA_GRE_PMTUDISC]))
1553 parms->iph.frag_off = htons(IP_DF);
1554}
1555
Herbert Xue1a80002008-10-09 12:00:17 -07001556static int ipgre_tap_init(struct net_device *dev)
1557{
1558 struct ip_tunnel *tunnel;
1559
1560 tunnel = netdev_priv(dev);
1561
1562 tunnel->dev = dev;
1563 strcpy(tunnel->parms.name, dev->name);
1564
1565 ipgre_tunnel_bind_dev(dev);
1566
Eric Dumazete985aad2010-09-27 03:57:11 +00001567 dev->tstats = alloc_percpu(struct pcpu_tstats);
1568 if (!dev->tstats)
1569 return -ENOMEM;
1570
Herbert Xue1a80002008-10-09 12:00:17 -07001571 return 0;
1572}
1573
Stephen Hemmingerb8c26a32008-11-20 20:34:29 -08001574static const struct net_device_ops ipgre_tap_netdev_ops = {
1575 .ndo_init = ipgre_tap_init,
1576 .ndo_uninit = ipgre_tunnel_uninit,
1577 .ndo_start_xmit = ipgre_tunnel_xmit,
1578 .ndo_set_mac_address = eth_mac_addr,
1579 .ndo_validate_addr = eth_validate_addr,
1580 .ndo_change_mtu = ipgre_tunnel_change_mtu,
stephen hemminger87b6d212012-04-12 06:31:16 +00001581 .ndo_get_stats64 = ipgre_get_stats64,
Stephen Hemmingerb8c26a32008-11-20 20:34:29 -08001582};
1583
Herbert Xue1a80002008-10-09 12:00:17 -07001584static void ipgre_tap_setup(struct net_device *dev)
1585{
1586
1587 ether_setup(dev);
1588
Herbert Xu2e9526b2009-10-30 05:51:48 +00001589 dev->netdev_ops = &ipgre_tap_netdev_ops;
Eric Dumazete985aad2010-09-27 03:57:11 +00001590 dev->destructor = ipgre_dev_free;
Herbert Xue1a80002008-10-09 12:00:17 -07001591
1592 dev->iflink = 0;
1593 dev->features |= NETIF_F_NETNS_LOCAL;
1594}
1595
Eric W. Biederman81adee42009-11-08 00:53:51 -08001596static int ipgre_newlink(struct net *src_net, struct net_device *dev, struct nlattr *tb[],
Herbert Xuc19e6542008-10-09 11:59:55 -07001597 struct nlattr *data[])
1598{
1599 struct ip_tunnel *nt;
1600 struct net *net = dev_net(dev);
1601 struct ipgre_net *ign = net_generic(net, ipgre_net_id);
1602 int mtu;
1603 int err;
1604
1605 nt = netdev_priv(dev);
1606 ipgre_netlink_parms(data, &nt->parms);
1607
Herbert Xue1a80002008-10-09 12:00:17 -07001608 if (ipgre_tunnel_find(net, &nt->parms, dev->type))
Herbert Xuc19e6542008-10-09 11:59:55 -07001609 return -EEXIST;
1610
Herbert Xue1a80002008-10-09 12:00:17 -07001611 if (dev->type == ARPHRD_ETHER && !tb[IFLA_ADDRESS])
Danny Kukawkaf2cedb62012-02-15 06:45:39 +00001612 eth_hw_addr_random(dev);
Herbert Xue1a80002008-10-09 12:00:17 -07001613
Herbert Xuc19e6542008-10-09 11:59:55 -07001614 mtu = ipgre_tunnel_bind_dev(dev);
1615 if (!tb[IFLA_MTU])
1616 dev->mtu = mtu;
1617
Eric Dumazetb790e012010-09-27 23:05:47 +00001618 /* Can use a lockless transmit, unless we generate output sequences */
1619 if (!(nt->parms.o_flags & GRE_SEQ))
1620 dev->features |= NETIF_F_LLTX;
1621
Herbert Xuc19e6542008-10-09 11:59:55 -07001622 err = register_netdevice(dev);
1623 if (err)
1624 goto out;
1625
1626 dev_hold(dev);
1627 ipgre_tunnel_link(ign, nt);
1628
1629out:
1630 return err;
1631}
1632
1633static int ipgre_changelink(struct net_device *dev, struct nlattr *tb[],
1634 struct nlattr *data[])
1635{
1636 struct ip_tunnel *t, *nt;
1637 struct net *net = dev_net(dev);
1638 struct ipgre_net *ign = net_generic(net, ipgre_net_id);
1639 struct ip_tunnel_parm p;
1640 int mtu;
1641
1642 if (dev == ign->fb_tunnel_dev)
1643 return -EINVAL;
1644
1645 nt = netdev_priv(dev);
1646 ipgre_netlink_parms(data, &p);
1647
1648 t = ipgre_tunnel_locate(net, &p, 0);
1649
1650 if (t) {
1651 if (t->dev != dev)
1652 return -EEXIST;
1653 } else {
Herbert Xuc19e6542008-10-09 11:59:55 -07001654 t = nt;
1655
Herbert Xu2e9526b2009-10-30 05:51:48 +00001656 if (dev->type != ARPHRD_ETHER) {
Eric Dumazet15078502010-09-15 11:07:53 +00001657 unsigned int nflags = 0;
Herbert Xuc19e6542008-10-09 11:59:55 -07001658
Herbert Xu2e9526b2009-10-30 05:51:48 +00001659 if (ipv4_is_multicast(p.iph.daddr))
1660 nflags = IFF_BROADCAST;
1661 else if (p.iph.daddr)
1662 nflags = IFF_POINTOPOINT;
1663
1664 if ((dev->flags ^ nflags) &
1665 (IFF_POINTOPOINT | IFF_BROADCAST))
1666 return -EINVAL;
1667 }
Herbert Xuc19e6542008-10-09 11:59:55 -07001668
1669 ipgre_tunnel_unlink(ign, t);
1670 t->parms.iph.saddr = p.iph.saddr;
1671 t->parms.iph.daddr = p.iph.daddr;
1672 t->parms.i_key = p.i_key;
Herbert Xu2e9526b2009-10-30 05:51:48 +00001673 if (dev->type != ARPHRD_ETHER) {
1674 memcpy(dev->dev_addr, &p.iph.saddr, 4);
1675 memcpy(dev->broadcast, &p.iph.daddr, 4);
1676 }
Herbert Xuc19e6542008-10-09 11:59:55 -07001677 ipgre_tunnel_link(ign, t);
1678 netdev_state_change(dev);
1679 }
1680
1681 t->parms.o_key = p.o_key;
1682 t->parms.iph.ttl = p.iph.ttl;
1683 t->parms.iph.tos = p.iph.tos;
1684 t->parms.iph.frag_off = p.iph.frag_off;
1685
1686 if (t->parms.link != p.link) {
1687 t->parms.link = p.link;
1688 mtu = ipgre_tunnel_bind_dev(dev);
1689 if (!tb[IFLA_MTU])
1690 dev->mtu = mtu;
1691 netdev_state_change(dev);
1692 }
1693
1694 return 0;
1695}
1696
1697static size_t ipgre_get_size(const struct net_device *dev)
1698{
1699 return
1700 /* IFLA_GRE_LINK */
1701 nla_total_size(4) +
1702 /* IFLA_GRE_IFLAGS */
1703 nla_total_size(2) +
1704 /* IFLA_GRE_OFLAGS */
1705 nla_total_size(2) +
1706 /* IFLA_GRE_IKEY */
1707 nla_total_size(4) +
1708 /* IFLA_GRE_OKEY */
1709 nla_total_size(4) +
1710 /* IFLA_GRE_LOCAL */
1711 nla_total_size(4) +
1712 /* IFLA_GRE_REMOTE */
1713 nla_total_size(4) +
1714 /* IFLA_GRE_TTL */
1715 nla_total_size(1) +
1716 /* IFLA_GRE_TOS */
1717 nla_total_size(1) +
1718 /* IFLA_GRE_PMTUDISC */
1719 nla_total_size(1) +
1720 0;
1721}
1722
1723static int ipgre_fill_info(struct sk_buff *skb, const struct net_device *dev)
1724{
1725 struct ip_tunnel *t = netdev_priv(dev);
1726 struct ip_tunnel_parm *p = &t->parms;
1727
David S. Millerf3756b72012-04-01 20:39:02 -04001728 if (nla_put_u32(skb, IFLA_GRE_LINK, p->link) ||
1729 nla_put_be16(skb, IFLA_GRE_IFLAGS, p->i_flags) ||
1730 nla_put_be16(skb, IFLA_GRE_OFLAGS, p->o_flags) ||
1731 nla_put_be32(skb, IFLA_GRE_IKEY, p->i_key) ||
1732 nla_put_be32(skb, IFLA_GRE_OKEY, p->o_key) ||
1733 nla_put_be32(skb, IFLA_GRE_LOCAL, p->iph.saddr) ||
1734 nla_put_be32(skb, IFLA_GRE_REMOTE, p->iph.daddr) ||
1735 nla_put_u8(skb, IFLA_GRE_TTL, p->iph.ttl) ||
1736 nla_put_u8(skb, IFLA_GRE_TOS, p->iph.tos) ||
1737 nla_put_u8(skb, IFLA_GRE_PMTUDISC,
1738 !!(p->iph.frag_off & htons(IP_DF))))
1739 goto nla_put_failure;
Herbert Xuc19e6542008-10-09 11:59:55 -07001740 return 0;
1741
1742nla_put_failure:
1743 return -EMSGSIZE;
1744}
1745
1746static const struct nla_policy ipgre_policy[IFLA_GRE_MAX + 1] = {
1747 [IFLA_GRE_LINK] = { .type = NLA_U32 },
1748 [IFLA_GRE_IFLAGS] = { .type = NLA_U16 },
1749 [IFLA_GRE_OFLAGS] = { .type = NLA_U16 },
1750 [IFLA_GRE_IKEY] = { .type = NLA_U32 },
1751 [IFLA_GRE_OKEY] = { .type = NLA_U32 },
Patrick McHardy4d74f8b2008-10-10 12:11:06 -07001752 [IFLA_GRE_LOCAL] = { .len = FIELD_SIZEOF(struct iphdr, saddr) },
1753 [IFLA_GRE_REMOTE] = { .len = FIELD_SIZEOF(struct iphdr, daddr) },
Herbert Xuc19e6542008-10-09 11:59:55 -07001754 [IFLA_GRE_TTL] = { .type = NLA_U8 },
1755 [IFLA_GRE_TOS] = { .type = NLA_U8 },
1756 [IFLA_GRE_PMTUDISC] = { .type = NLA_U8 },
1757};
1758
1759static struct rtnl_link_ops ipgre_link_ops __read_mostly = {
1760 .kind = "gre",
1761 .maxtype = IFLA_GRE_MAX,
1762 .policy = ipgre_policy,
1763 .priv_size = sizeof(struct ip_tunnel),
1764 .setup = ipgre_tunnel_setup,
1765 .validate = ipgre_tunnel_validate,
1766 .newlink = ipgre_newlink,
1767 .changelink = ipgre_changelink,
1768 .get_size = ipgre_get_size,
1769 .fill_info = ipgre_fill_info,
1770};
1771
Herbert Xue1a80002008-10-09 12:00:17 -07001772static struct rtnl_link_ops ipgre_tap_ops __read_mostly = {
1773 .kind = "gretap",
1774 .maxtype = IFLA_GRE_MAX,
1775 .policy = ipgre_policy,
1776 .priv_size = sizeof(struct ip_tunnel),
1777 .setup = ipgre_tap_setup,
1778 .validate = ipgre_tap_validate,
1779 .newlink = ipgre_newlink,
1780 .changelink = ipgre_changelink,
1781 .get_size = ipgre_get_size,
1782 .fill_info = ipgre_fill_info,
1783};
1784
Linus Torvalds1da177e2005-04-16 15:20:36 -07001785/*
1786 * And now the modules code and kernel interface.
1787 */
1788
1789static int __init ipgre_init(void)
1790{
1791 int err;
1792
Joe Perches058bd4d2012-03-11 18:36:11 +00001793 pr_info("GRE over IPv4 tunneling driver\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001794
Eric W. Biedermancfb8fbf2009-11-29 15:46:13 +00001795 err = register_pernet_device(&ipgre_net_ops);
Pavel Emelyanov59a4c752008-04-16 01:08:53 -07001796 if (err < 0)
Alexey Dobriyanc2892f02010-02-16 07:57:44 +00001797 return err;
1798
Dmitry Kozlov00959ad2010-08-21 23:05:39 -07001799 err = gre_add_protocol(&ipgre_protocol, GREPROTO_CISCO);
Alexey Dobriyanc2892f02010-02-16 07:57:44 +00001800 if (err < 0) {
Joe Perches058bd4d2012-03-11 18:36:11 +00001801 pr_info("%s: can't add protocol\n", __func__);
Alexey Dobriyanc2892f02010-02-16 07:57:44 +00001802 goto add_proto_failed;
1803 }
Pavel Emelyanov7daa0002008-04-16 01:10:05 -07001804
Herbert Xuc19e6542008-10-09 11:59:55 -07001805 err = rtnl_link_register(&ipgre_link_ops);
1806 if (err < 0)
1807 goto rtnl_link_failed;
1808
Herbert Xue1a80002008-10-09 12:00:17 -07001809 err = rtnl_link_register(&ipgre_tap_ops);
1810 if (err < 0)
1811 goto tap_ops_failed;
1812
Herbert Xuc19e6542008-10-09 11:59:55 -07001813out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001814 return err;
Herbert Xuc19e6542008-10-09 11:59:55 -07001815
Herbert Xue1a80002008-10-09 12:00:17 -07001816tap_ops_failed:
1817 rtnl_link_unregister(&ipgre_link_ops);
Herbert Xuc19e6542008-10-09 11:59:55 -07001818rtnl_link_failed:
Dmitry Kozlov00959ad2010-08-21 23:05:39 -07001819 gre_del_protocol(&ipgre_protocol, GREPROTO_CISCO);
Alexey Dobriyanc2892f02010-02-16 07:57:44 +00001820add_proto_failed:
1821 unregister_pernet_device(&ipgre_net_ops);
Herbert Xuc19e6542008-10-09 11:59:55 -07001822 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001823}
1824
Alexey Kuznetsovdb445752005-07-30 17:46:44 -07001825static void __exit ipgre_fini(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001826{
Herbert Xue1a80002008-10-09 12:00:17 -07001827 rtnl_link_unregister(&ipgre_tap_ops);
Herbert Xuc19e6542008-10-09 11:59:55 -07001828 rtnl_link_unregister(&ipgre_link_ops);
Dmitry Kozlov00959ad2010-08-21 23:05:39 -07001829 if (gre_del_protocol(&ipgre_protocol, GREPROTO_CISCO) < 0)
Joe Perches058bd4d2012-03-11 18:36:11 +00001830 pr_info("%s: can't remove protocol\n", __func__);
Alexey Dobriyanc2892f02010-02-16 07:57:44 +00001831 unregister_pernet_device(&ipgre_net_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001832}
1833
1834module_init(ipgre_init);
1835module_exit(ipgre_fini);
1836MODULE_LICENSE("GPL");
Patrick McHardy4d74f8b2008-10-10 12:11:06 -07001837MODULE_ALIAS_RTNL_LINK("gre");
1838MODULE_ALIAS_RTNL_LINK("gretap");
Vasiliy Kulikov8909c9a2011-03-02 00:33:13 +03001839MODULE_ALIAS_NETDEV("gre0");