blob: b062a98574f2e40e63d5b5eee8f1d7f2fda28425 [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
Herbert Xuc19e6542008-10-09 11:59:55 -0700123static struct rtnl_link_ops ipgre_link_ops __read_mostly;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124static int ipgre_tunnel_init(struct net_device *dev);
125static void ipgre_tunnel_setup(struct net_device *dev);
Herbert Xu42aa9162008-10-09 11:59:32 -0700126static int ipgre_tunnel_bind_dev(struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127
128/* Fallback tunnel: no source, no destination, no key, no options */
129
Pavel Emelyanoveb8ce742008-04-16 01:10:26 -0700130#define HASH_SIZE 16
131
Eric Dumazetf99189b2009-11-17 10:42:49 +0000132static int ipgre_net_id __read_mostly;
Pavel Emelyanov59a4c752008-04-16 01:08:53 -0700133struct ipgre_net {
Eric Dumazet15078502010-09-15 11:07:53 +0000134 struct ip_tunnel __rcu *tunnels[4][HASH_SIZE];
Pavel Emelyanoveb8ce742008-04-16 01:10:26 -0700135
Pavel Emelyanov7daa0002008-04-16 01:10:05 -0700136 struct net_device *fb_tunnel_dev;
Pavel Emelyanov59a4c752008-04-16 01:08:53 -0700137};
138
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139/* Tunnel hash table */
140
141/*
142 4 hash tables:
143
144 3: (remote,local)
145 2: (remote,*)
146 1: (*,local)
147 0: (*,*)
148
149 We require exact key match i.e. if a key is present in packet
150 it will match only tunnel with the same key; if it is not present,
151 it will match only keyless tunnel.
152
153 All keysless packets, if not matched configured keyless tunnels
154 will match fallback tunnel.
155 */
156
Al Virod5a0a1e2006-11-08 00:23:14 -0800157#define HASH(addr) (((__force u32)addr^((__force u32)addr>>4))&0xF)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158
Pavel Emelyanoveb8ce742008-04-16 01:10:26 -0700159#define tunnels_r_l tunnels[3]
160#define tunnels_r tunnels[2]
161#define tunnels_l tunnels[1]
162#define tunnels_wc tunnels[0]
Eric Dumazet8d5b2c02009-10-23 06:14:38 +0000163/*
Eric Dumazet15078502010-09-15 11:07:53 +0000164 * Locking : hash tables are protected by RCU and RTNL
Eric Dumazet8d5b2c02009-10-23 06:14:38 +0000165 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166
Eric Dumazet8d5b2c02009-10-23 06:14:38 +0000167#define for_each_ip_tunnel_rcu(start) \
168 for (t = rcu_dereference(start); t; t = rcu_dereference(t->next))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169
Eric Dumazete985aad2010-09-27 03:57:11 +0000170/* often modified stats are per cpu, other are shared (netdev->stats) */
171struct pcpu_tstats {
stephen hemminger87b6d212012-04-12 06:31:16 +0000172 u64 rx_packets;
173 u64 rx_bytes;
174 u64 tx_packets;
175 u64 tx_bytes;
176 struct u64_stats_sync syncp;
177};
Eric Dumazete985aad2010-09-27 03:57:11 +0000178
stephen hemminger87b6d212012-04-12 06:31:16 +0000179static struct rtnl_link_stats64 *ipgre_get_stats64(struct net_device *dev,
180 struct rtnl_link_stats64 *tot)
Eric Dumazete985aad2010-09-27 03:57:11 +0000181{
Eric Dumazete985aad2010-09-27 03:57:11 +0000182 int i;
183
184 for_each_possible_cpu(i) {
185 const struct pcpu_tstats *tstats = per_cpu_ptr(dev->tstats, i);
stephen hemminger87b6d212012-04-12 06:31:16 +0000186 u64 rx_packets, rx_bytes, tx_packets, tx_bytes;
187 unsigned int start;
Eric Dumazete985aad2010-09-27 03:57:11 +0000188
stephen hemminger87b6d212012-04-12 06:31:16 +0000189 do {
190 start = u64_stats_fetch_begin_bh(&tstats->syncp);
191 rx_packets = tstats->rx_packets;
192 tx_packets = tstats->tx_packets;
193 rx_bytes = tstats->rx_bytes;
194 tx_bytes = tstats->tx_bytes;
195 } while (u64_stats_fetch_retry_bh(&tstats->syncp, start));
196
197 tot->rx_packets += rx_packets;
198 tot->tx_packets += tx_packets;
199 tot->rx_bytes += rx_bytes;
200 tot->tx_bytes += tx_bytes;
Eric Dumazete985aad2010-09-27 03:57:11 +0000201 }
stephen hemminger87b6d212012-04-12 06:31:16 +0000202
203 tot->multicast = dev->stats.multicast;
204 tot->rx_crc_errors = dev->stats.rx_crc_errors;
205 tot->rx_fifo_errors = dev->stats.rx_fifo_errors;
206 tot->rx_length_errors = dev->stats.rx_length_errors;
207 tot->rx_errors = dev->stats.rx_errors;
208 tot->tx_fifo_errors = dev->stats.tx_fifo_errors;
209 tot->tx_carrier_errors = dev->stats.tx_carrier_errors;
210 tot->tx_dropped = dev->stats.tx_dropped;
211 tot->tx_aborted_errors = dev->stats.tx_aborted_errors;
212 tot->tx_errors = dev->stats.tx_errors;
213
214 return tot;
Eric Dumazete985aad2010-09-27 03:57:11 +0000215}
216
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217/* Given src, dst and key, find appropriate for input tunnel. */
218
Daniel Baluta5e73ea12012-04-15 01:34:41 +0000219static struct ip_tunnel *ipgre_tunnel_lookup(struct net_device *dev,
220 __be32 remote, __be32 local,
221 __be32 key, __be16 gre_proto)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222{
Timo Teras749c10f2009-01-19 17:22:12 -0800223 struct net *net = dev_net(dev);
224 int link = dev->ifindex;
Eric Dumazet15078502010-09-15 11:07:53 +0000225 unsigned int h0 = HASH(remote);
226 unsigned int h1 = HASH(key);
Timo Terasafcf1242009-01-26 20:56:10 -0800227 struct ip_tunnel *t, *cand = NULL;
Pavel Emelyanov7daa0002008-04-16 01:10:05 -0700228 struct ipgre_net *ign = net_generic(net, ipgre_net_id);
Herbert Xue1a80002008-10-09 12:00:17 -0700229 int dev_type = (gre_proto == htons(ETH_P_TEB)) ?
230 ARPHRD_ETHER : ARPHRD_IPGRE;
Timo Terasafcf1242009-01-26 20:56:10 -0800231 int score, cand_score = 4;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232
Eric Dumazet8d5b2c02009-10-23 06:14:38 +0000233 for_each_ip_tunnel_rcu(ign->tunnels_r_l[h0 ^ h1]) {
Timo Teras749c10f2009-01-19 17:22:12 -0800234 if (local != t->parms.iph.saddr ||
235 remote != t->parms.iph.daddr ||
236 key != t->parms.i_key ||
237 !(t->dev->flags & IFF_UP))
238 continue;
239
240 if (t->dev->type != ARPHRD_IPGRE &&
241 t->dev->type != dev_type)
242 continue;
243
Timo Terasafcf1242009-01-26 20:56:10 -0800244 score = 0;
Timo Teras749c10f2009-01-19 17:22:12 -0800245 if (t->parms.link != link)
Timo Terasafcf1242009-01-26 20:56:10 -0800246 score |= 1;
Timo Teras749c10f2009-01-19 17:22:12 -0800247 if (t->dev->type != dev_type)
Timo Terasafcf1242009-01-26 20:56:10 -0800248 score |= 2;
249 if (score == 0)
Timo Teras749c10f2009-01-19 17:22:12 -0800250 return t;
Timo Terasafcf1242009-01-26 20:56:10 -0800251
252 if (score < cand_score) {
253 cand = t;
254 cand_score = score;
255 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256 }
Herbert Xue1a80002008-10-09 12:00:17 -0700257
Eric Dumazet8d5b2c02009-10-23 06:14:38 +0000258 for_each_ip_tunnel_rcu(ign->tunnels_r[h0 ^ h1]) {
Timo Teras749c10f2009-01-19 17:22:12 -0800259 if (remote != t->parms.iph.daddr ||
260 key != t->parms.i_key ||
261 !(t->dev->flags & IFF_UP))
262 continue;
263
264 if (t->dev->type != ARPHRD_IPGRE &&
265 t->dev->type != dev_type)
266 continue;
267
Timo Terasafcf1242009-01-26 20:56:10 -0800268 score = 0;
Timo Teras749c10f2009-01-19 17:22:12 -0800269 if (t->parms.link != link)
Timo Terasafcf1242009-01-26 20:56:10 -0800270 score |= 1;
Timo Teras749c10f2009-01-19 17:22:12 -0800271 if (t->dev->type != dev_type)
Timo Terasafcf1242009-01-26 20:56:10 -0800272 score |= 2;
273 if (score == 0)
Timo Teras749c10f2009-01-19 17:22:12 -0800274 return t;
Timo Terasafcf1242009-01-26 20:56:10 -0800275
276 if (score < cand_score) {
277 cand = t;
278 cand_score = score;
279 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280 }
Herbert Xue1a80002008-10-09 12:00:17 -0700281
Eric Dumazet8d5b2c02009-10-23 06:14:38 +0000282 for_each_ip_tunnel_rcu(ign->tunnels_l[h1]) {
Timo Teras749c10f2009-01-19 17:22:12 -0800283 if ((local != t->parms.iph.saddr &&
284 (local != t->parms.iph.daddr ||
285 !ipv4_is_multicast(local))) ||
286 key != t->parms.i_key ||
287 !(t->dev->flags & IFF_UP))
288 continue;
289
290 if (t->dev->type != ARPHRD_IPGRE &&
291 t->dev->type != dev_type)
292 continue;
293
Timo Terasafcf1242009-01-26 20:56:10 -0800294 score = 0;
Timo Teras749c10f2009-01-19 17:22:12 -0800295 if (t->parms.link != link)
Timo Terasafcf1242009-01-26 20:56:10 -0800296 score |= 1;
Timo Teras749c10f2009-01-19 17:22:12 -0800297 if (t->dev->type != dev_type)
Timo Terasafcf1242009-01-26 20:56:10 -0800298 score |= 2;
299 if (score == 0)
Timo Teras749c10f2009-01-19 17:22:12 -0800300 return t;
Timo Terasafcf1242009-01-26 20:56:10 -0800301
302 if (score < cand_score) {
303 cand = t;
304 cand_score = score;
305 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306 }
Herbert Xue1a80002008-10-09 12:00:17 -0700307
Eric Dumazet8d5b2c02009-10-23 06:14:38 +0000308 for_each_ip_tunnel_rcu(ign->tunnels_wc[h1]) {
Timo Teras749c10f2009-01-19 17:22:12 -0800309 if (t->parms.i_key != key ||
310 !(t->dev->flags & IFF_UP))
311 continue;
312
313 if (t->dev->type != ARPHRD_IPGRE &&
314 t->dev->type != dev_type)
315 continue;
316
Timo Terasafcf1242009-01-26 20:56:10 -0800317 score = 0;
Timo Teras749c10f2009-01-19 17:22:12 -0800318 if (t->parms.link != link)
Timo Terasafcf1242009-01-26 20:56:10 -0800319 score |= 1;
Timo Teras749c10f2009-01-19 17:22:12 -0800320 if (t->dev->type != dev_type)
Timo Terasafcf1242009-01-26 20:56:10 -0800321 score |= 2;
322 if (score == 0)
Timo Teras749c10f2009-01-19 17:22:12 -0800323 return t;
Timo Terasafcf1242009-01-26 20:56:10 -0800324
325 if (score < cand_score) {
326 cand = t;
327 cand_score = score;
328 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329 }
330
Timo Terasafcf1242009-01-26 20:56:10 -0800331 if (cand != NULL)
332 return cand;
Herbert Xue1a80002008-10-09 12:00:17 -0700333
Eric Dumazet8d5b2c02009-10-23 06:14:38 +0000334 dev = ign->fb_tunnel_dev;
335 if (dev->flags & IFF_UP)
336 return netdev_priv(dev);
Timo Teras749c10f2009-01-19 17:22:12 -0800337
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338 return NULL;
339}
340
Eric Dumazet15078502010-09-15 11:07:53 +0000341static struct ip_tunnel __rcu **__ipgre_bucket(struct ipgre_net *ign,
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -0700342 struct ip_tunnel_parm *parms)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343{
YOSHIFUJI Hideaki5056a1e2007-04-24 20:44:48 +0900344 __be32 remote = parms->iph.daddr;
345 __be32 local = parms->iph.saddr;
346 __be32 key = parms->i_key;
Eric Dumazet15078502010-09-15 11:07:53 +0000347 unsigned int h = HASH(key);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348 int prio = 0;
349
350 if (local)
351 prio |= 1;
Joe Perchesf97c1e02007-12-16 13:45:43 -0800352 if (remote && !ipv4_is_multicast(remote)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353 prio |= 2;
354 h ^= HASH(remote);
355 }
356
Pavel Emelyanoveb8ce742008-04-16 01:10:26 -0700357 return &ign->tunnels[prio][h];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358}
359
Eric Dumazet15078502010-09-15 11:07:53 +0000360static inline struct ip_tunnel __rcu **ipgre_bucket(struct ipgre_net *ign,
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -0700361 struct ip_tunnel *t)
YOSHIFUJI Hideaki5056a1e2007-04-24 20:44:48 +0900362{
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -0700363 return __ipgre_bucket(ign, &t->parms);
YOSHIFUJI Hideaki5056a1e2007-04-24 20:44:48 +0900364}
365
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -0700366static void ipgre_tunnel_link(struct ipgre_net *ign, struct ip_tunnel *t)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367{
Eric Dumazet15078502010-09-15 11:07:53 +0000368 struct ip_tunnel __rcu **tp = ipgre_bucket(ign, t);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369
Eric Dumazet15078502010-09-15 11:07:53 +0000370 rcu_assign_pointer(t->next, rtnl_dereference(*tp));
Eric Dumazet8d5b2c02009-10-23 06:14:38 +0000371 rcu_assign_pointer(*tp, t);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372}
373
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -0700374static void ipgre_tunnel_unlink(struct ipgre_net *ign, struct ip_tunnel *t)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375{
Eric Dumazet15078502010-09-15 11:07:53 +0000376 struct ip_tunnel __rcu **tp;
377 struct ip_tunnel *iter;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378
Eric Dumazet15078502010-09-15 11:07:53 +0000379 for (tp = ipgre_bucket(ign, t);
380 (iter = rtnl_dereference(*tp)) != NULL;
381 tp = &iter->next) {
382 if (t == iter) {
383 rcu_assign_pointer(*tp, t->next);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384 break;
385 }
386 }
387}
388
Herbert Xue1a80002008-10-09 12:00:17 -0700389static struct ip_tunnel *ipgre_tunnel_find(struct net *net,
390 struct ip_tunnel_parm *parms,
391 int type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392{
Al Virod5a0a1e2006-11-08 00:23:14 -0800393 __be32 remote = parms->iph.daddr;
394 __be32 local = parms->iph.saddr;
395 __be32 key = parms->i_key;
Timo Teras749c10f2009-01-19 17:22:12 -0800396 int link = parms->link;
Eric Dumazet15078502010-09-15 11:07:53 +0000397 struct ip_tunnel *t;
398 struct ip_tunnel __rcu **tp;
Herbert Xue1a80002008-10-09 12:00:17 -0700399 struct ipgre_net *ign = net_generic(net, ipgre_net_id);
400
Eric Dumazet15078502010-09-15 11:07:53 +0000401 for (tp = __ipgre_bucket(ign, parms);
402 (t = rtnl_dereference(*tp)) != NULL;
403 tp = &t->next)
Herbert Xue1a80002008-10-09 12:00:17 -0700404 if (local == t->parms.iph.saddr &&
405 remote == t->parms.iph.daddr &&
406 key == t->parms.i_key &&
Timo Teras749c10f2009-01-19 17:22:12 -0800407 link == t->parms.link &&
Herbert Xue1a80002008-10-09 12:00:17 -0700408 type == t->dev->type)
409 break;
410
411 return t;
412}
413
Eric Dumazet15078502010-09-15 11:07:53 +0000414static struct ip_tunnel *ipgre_tunnel_locate(struct net *net,
Herbert Xue1a80002008-10-09 12:00:17 -0700415 struct ip_tunnel_parm *parms, int create)
416{
417 struct ip_tunnel *t, *nt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418 struct net_device *dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419 char name[IFNAMSIZ];
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -0700420 struct ipgre_net *ign = net_generic(net, ipgre_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421
Herbert Xue1a80002008-10-09 12:00:17 -0700422 t = ipgre_tunnel_find(net, parms, ARPHRD_IPGRE);
423 if (t || !create)
424 return t;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425
426 if (parms->name[0])
427 strlcpy(name, parms->name, IFNAMSIZ);
Pavel Emelyanov34cc7ba2008-02-23 20:19:20 -0800428 else
stephen hemminger407d6fc2010-11-29 09:47:47 +0000429 strcpy(name, "gre%d");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430
431 dev = alloc_netdev(sizeof(*t), name, ipgre_tunnel_setup);
432 if (!dev)
stephen hemminger407d6fc2010-11-29 09:47:47 +0000433 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434
Pavel Emelyanov0b67ece2008-04-16 01:11:13 -0700435 dev_net_set(dev, net);
436
Patrick McHardy2941a482006-01-08 22:05:26 -0800437 nt = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438 nt->parms = *parms;
Herbert Xuc19e6542008-10-09 11:59:55 -0700439 dev->rtnl_link_ops = &ipgre_link_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440
Herbert Xu42aa9162008-10-09 11:59:32 -0700441 dev->mtu = ipgre_tunnel_bind_dev(dev);
442
Pavel Emelyanovb37d428b2008-02-26 23:51:04 -0800443 if (register_netdevice(dev) < 0)
444 goto failed_free;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445
Willem de Bruijnf2b3ee92012-01-26 10:34:35 +0000446 /* Can use a lockless transmit, unless we generate output sequences */
447 if (!(nt->parms.o_flags & GRE_SEQ))
448 dev->features |= NETIF_F_LLTX;
449
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450 dev_hold(dev);
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -0700451 ipgre_tunnel_link(ign, nt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452 return nt;
453
Pavel Emelyanovb37d428b2008-02-26 23:51:04 -0800454failed_free:
455 free_netdev(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456 return NULL;
457}
458
459static void ipgre_tunnel_uninit(struct net_device *dev)
460{
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -0700461 struct net *net = dev_net(dev);
462 struct ipgre_net *ign = net_generic(net, ipgre_net_id);
463
464 ipgre_tunnel_unlink(ign, netdev_priv(dev));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465 dev_put(dev);
466}
467
468
469static void ipgre_err(struct sk_buff *skb, u32 info)
470{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471
Rami Rosen071f92d2008-05-21 17:47:54 -0700472/* All the routers (except for Linux) return only
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473 8 bytes of packet payload. It means, that precise relaying of
474 ICMP in the real Internet is absolutely infeasible.
475
476 Moreover, Cisco "wise men" put GRE key to the third word
477 in GRE header. It makes impossible maintaining even soft state for keyed
478 GRE tunnels with enabled checksum. Tell them "thank you".
479
480 Well, I wonder, rfc1812 was written by Cisco employee,
stephen hemmingerbff52852012-02-24 08:08:20 +0000481 what the hell these idiots break standards established
482 by themselves???
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483 */
484
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000485 const struct iphdr *iph = (const struct iphdr *)skb->data;
Daniel Baluta5e73ea12012-04-15 01:34:41 +0000486 __be16 *p = (__be16 *)(skb->data+(iph->ihl<<2));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487 int grehlen = (iph->ihl<<2) + 4;
Arnaldo Carvalho de Melo88c76642007-03-13 14:43:18 -0300488 const int type = icmp_hdr(skb)->type;
489 const int code = icmp_hdr(skb)->code;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490 struct ip_tunnel *t;
Al Virod5a0a1e2006-11-08 00:23:14 -0800491 __be16 flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492
493 flags = p[0];
494 if (flags&(GRE_CSUM|GRE_KEY|GRE_SEQ|GRE_ROUTING|GRE_VERSION)) {
495 if (flags&(GRE_VERSION|GRE_ROUTING))
496 return;
497 if (flags&GRE_KEY) {
498 grehlen += 4;
499 if (flags&GRE_CSUM)
500 grehlen += 4;
501 }
502 }
503
504 /* If only 8 bytes returned, keyed message will be dropped here */
505 if (skb_headlen(skb) < grehlen)
506 return;
507
508 switch (type) {
509 default:
510 case ICMP_PARAMETERPROB:
511 return;
512
513 case ICMP_DEST_UNREACH:
514 switch (code) {
515 case ICMP_SR_FAILED:
516 case ICMP_PORT_UNREACH:
517 /* Impossible event. */
518 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519 default:
520 /* All others are translated to HOST_UNREACH.
521 rfc2003 contains "deep thoughts" about NET_UNREACH,
522 I believe they are just ether pollution. --ANK
523 */
524 break;
525 }
526 break;
527 case ICMP_TIME_EXCEEDED:
528 if (code != ICMP_EXC_TTL)
529 return;
530 break;
David S. Miller55be7a92012-07-11 21:27:49 -0700531
532 case ICMP_REDIRECT:
533 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534 }
535
Eric Dumazet8d5b2c02009-10-23 06:14:38 +0000536 rcu_read_lock();
Timo Teras749c10f2009-01-19 17:22:12 -0800537 t = ipgre_tunnel_lookup(skb->dev, iph->daddr, iph->saddr,
Herbert Xue1a80002008-10-09 12:00:17 -0700538 flags & GRE_KEY ?
539 *(((__be32 *)p) + (grehlen / 4) - 1) : 0,
540 p[1]);
David S. Miller36393392012-06-14 22:21:46 -0700541 if (t == NULL)
542 goto out;
543
544 if (type == ICMP_DEST_UNREACH && code == ICMP_FRAG_NEEDED) {
545 ipv4_update_pmtu(skb, dev_net(skb->dev), info,
546 t->parms.link, 0, IPPROTO_GRE, 0);
547 goto out;
548 }
David S. Miller55be7a92012-07-11 21:27:49 -0700549 if (type == ICMP_REDIRECT) {
550 ipv4_redirect(skb, dev_net(skb->dev), t->parms.link, 0,
551 IPPROTO_GRE, 0);
552 goto out;
553 }
David S. Miller36393392012-06-14 22:21:46 -0700554 if (t->parms.iph.daddr == 0 ||
Joe Perchesf97c1e02007-12-16 13:45:43 -0800555 ipv4_is_multicast(t->parms.iph.daddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556 goto out;
557
558 if (t->parms.iph.ttl == 0 && type == ICMP_TIME_EXCEEDED)
559 goto out;
560
Wei Yongjunda6185d82009-02-24 23:34:48 -0800561 if (time_before(jiffies, t->err_time + IPTUNNEL_ERR_TIMEO))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562 t->err_count++;
563 else
564 t->err_count = 1;
565 t->err_time = jiffies;
566out:
Eric Dumazet8d5b2c02009-10-23 06:14:38 +0000567 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568}
569
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000570static inline void ipgre_ecn_decapsulate(const struct iphdr *iph, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571{
572 if (INET_ECN_is_ce(iph->tos)) {
573 if (skb->protocol == htons(ETH_P_IP)) {
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700574 IP_ECN_set_ce(ip_hdr(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575 } else if (skb->protocol == htons(ETH_P_IPV6)) {
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700576 IP6_ECN_set_ce(ipv6_hdr(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577 }
578 }
579}
580
581static 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700603
604 if (!pskb_may_pull(skb, 16))
605 goto drop_nolock;
606
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700607 iph = ip_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608 h = skb->data;
Daniel Baluta5e73ea12012-04-15 01:34:41 +0000609 flags = *(__be16 *)h;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610
611 if (flags&(GRE_CSUM|GRE_KEY|GRE_ROUTING|GRE_SEQ|GRE_VERSION)) {
612 /* - Version must be 0.
613 - We do not support routing headers.
614 */
615 if (flags&(GRE_VERSION|GRE_ROUTING))
616 goto drop_nolock;
617
618 if (flags&GRE_CSUM) {
Herbert Xufb286bb2005-11-10 13:01:24 -0800619 switch (skb->ip_summed) {
Patrick McHardy84fa7932006-08-29 16:44:56 -0700620 case CHECKSUM_COMPLETE:
Al Virod3bc23e2006-11-14 21:24:49 -0800621 csum = csum_fold(skb->csum);
Herbert Xufb286bb2005-11-10 13:01:24 -0800622 if (!csum)
623 break;
624 /* fall through */
625 case CHECKSUM_NONE:
626 skb->csum = 0;
627 csum = __skb_checksum_complete(skb);
Patrick McHardy84fa7932006-08-29 16:44:56 -0700628 skb->ip_summed = CHECKSUM_COMPLETE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629 }
630 offset += 4;
631 }
632 if (flags&GRE_KEY) {
Daniel Baluta5e73ea12012-04-15 01:34:41 +0000633 key = *(__be32 *)(h + offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634 offset += 4;
635 }
636 if (flags&GRE_SEQ) {
Daniel Baluta5e73ea12012-04-15 01:34:41 +0000637 seqno = ntohl(*(__be32 *)(h + offset));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638 offset += 4;
639 }
640 }
641
Herbert Xue1a80002008-10-09 12:00:17 -0700642 gre_proto = *(__be16 *)(h + 2);
643
Eric Dumazet8d5b2c02009-10-23 06:14:38 +0000644 rcu_read_lock();
Timo Teras749c10f2009-01-19 17:22:12 -0800645 if ((tunnel = ipgre_tunnel_lookup(skb->dev,
Herbert Xue1a80002008-10-09 12:00:17 -0700646 iph->saddr, iph->daddr, key,
647 gre_proto))) {
Eric Dumazete985aad2010-09-27 03:57:11 +0000648 struct pcpu_tstats *tstats;
Pavel Emelyanovaddd68e2008-05-21 14:14:22 -0700649
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650 secpath_reset(skb);
651
Herbert Xue1a80002008-10-09 12:00:17 -0700652 skb->protocol = gre_proto;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653 /* WCCP version 1 and 2 protocol decoding.
654 * - Change protocol to IP
655 * - When dealing with WCCPv2, Skip extra 4 bytes in GRE header
656 */
Herbert Xue1a80002008-10-09 12:00:17 -0700657 if (flags == 0 && gre_proto == htons(ETH_P_WCCP)) {
YOSHIFUJI Hideaki496c98d2006-10-10 19:41:21 -0700658 skb->protocol = htons(ETH_P_IP);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900659 if ((*(h + offset) & 0xF0) != 0x40)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660 offset += 4;
661 }
662
Timo Teras1d069162007-12-20 00:10:33 -0800663 skb->mac_header = skb->network_header;
Arnaldo Carvalho de Melo4209fb62007-03-10 18:42:03 -0300664 __pskb_pull(skb, offset);
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -0700665 skb_postpull_rcsum(skb, skb_transport_header(skb), offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666 skb->pkt_type = PACKET_HOST;
667#ifdef CONFIG_NET_IPGRE_BROADCAST
Joe Perchesf97c1e02007-12-16 13:45:43 -0800668 if (ipv4_is_multicast(iph->daddr)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669 /* Looped back packet, drop it! */
David S. Millerc7537962010-11-11 17:07:48 -0800670 if (rt_is_output_route(skb_rtable(skb)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671 goto drop;
Eric Dumazete985aad2010-09-27 03:57:11 +0000672 tunnel->dev->stats.multicast++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673 skb->pkt_type = PACKET_BROADCAST;
674 }
675#endif
676
677 if (((flags&GRE_CSUM) && csum) ||
678 (!(flags&GRE_CSUM) && tunnel->parms.i_flags&GRE_CSUM)) {
Eric Dumazete985aad2010-09-27 03:57:11 +0000679 tunnel->dev->stats.rx_crc_errors++;
680 tunnel->dev->stats.rx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681 goto drop;
682 }
683 if (tunnel->parms.i_flags&GRE_SEQ) {
684 if (!(flags&GRE_SEQ) ||
685 (tunnel->i_seqno && (s32)(seqno - tunnel->i_seqno) < 0)) {
Eric Dumazete985aad2010-09-27 03:57:11 +0000686 tunnel->dev->stats.rx_fifo_errors++;
687 tunnel->dev->stats.rx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700688 goto drop;
689 }
690 tunnel->i_seqno = seqno + 1;
691 }
Herbert Xue1a80002008-10-09 12:00:17 -0700692
693 /* Warning: All skb pointers will be invalidated! */
694 if (tunnel->dev->type == ARPHRD_ETHER) {
695 if (!pskb_may_pull(skb, ETH_HLEN)) {
Eric Dumazete985aad2010-09-27 03:57:11 +0000696 tunnel->dev->stats.rx_length_errors++;
697 tunnel->dev->stats.rx_errors++;
Herbert Xue1a80002008-10-09 12:00:17 -0700698 goto drop;
699 }
700
701 iph = ip_hdr(skb);
702 skb->protocol = eth_type_trans(skb, tunnel->dev);
703 skb_postpull_rcsum(skb, eth_hdr(skb), ETH_HLEN);
704 }
705
Eric Dumazete985aad2010-09-27 03:57:11 +0000706 tstats = this_cpu_ptr(tunnel->dev->tstats);
stephen hemminger87b6d212012-04-12 06:31:16 +0000707 u64_stats_update_begin(&tstats->syncp);
Eric Dumazete985aad2010-09-27 03:57:11 +0000708 tstats->rx_packets++;
709 tstats->rx_bytes += skb->len;
stephen hemminger87b6d212012-04-12 06:31:16 +0000710 u64_stats_update_end(&tstats->syncp);
Eric Dumazete985aad2010-09-27 03:57:11 +0000711
712 __skb_tunnel_rx(skb, tunnel->dev);
Herbert Xue1a80002008-10-09 12:00:17 -0700713
714 skb_reset_network_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715 ipgre_ecn_decapsulate(iph, skb);
Herbert Xue1a80002008-10-09 12:00:17 -0700716
Eric Dumazetcaf586e2010-09-30 21:06:55 +0000717 netif_rx(skb);
Eric Dumazet8990f462010-09-20 00:12:11 +0000718
Eric Dumazet8d5b2c02009-10-23 06:14:38 +0000719 rcu_read_unlock();
Eric Dumazet8990f462010-09-20 00:12:11 +0000720 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721 }
Herbert Xu45af08b2006-04-05 22:31:19 -0700722 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723
724drop:
Eric Dumazet8d5b2c02009-10-23 06:14:38 +0000725 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726drop_nolock:
727 kfree_skb(skb);
Eric Dumazeta02cec22010-09-22 20:43:57 +0000728 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700729}
730
Stephen Hemminger6fef4c02009-08-31 19:50:41 +0000731static netdev_tx_t ipgre_tunnel_xmit(struct sk_buff *skb, struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732{
Patrick McHardy2941a482006-01-08 22:05:26 -0800733 struct ip_tunnel *tunnel = netdev_priv(dev);
Eric Dumazete985aad2010-09-27 03:57:11 +0000734 struct pcpu_tstats *tstats;
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000735 const struct iphdr *old_iph = ip_hdr(skb);
736 const struct iphdr *tiph;
David S. Millercbb1e852011-05-04 12:33:34 -0700737 struct flowi4 fl4;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738 u8 tos;
Al Virod5a0a1e2006-11-08 00:23:14 -0800739 __be16 df;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740 struct rtable *rt; /* Route to the other host */
Eric Dumazet15078502010-09-15 11:07:53 +0000741 struct net_device *tdev; /* Device to other host */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742 struct iphdr *iph; /* Our new IP header */
Chuck Leverc2636b42007-10-23 21:07:32 -0700743 unsigned int max_headroom; /* The extra header space needed */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700744 int gre_hlen;
Al Virod5a0a1e2006-11-08 00:23:14 -0800745 __be32 dst;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746 int mtu;
747
Herbert Xue1a80002008-10-09 12:00:17 -0700748 if (dev->type == ARPHRD_ETHER)
749 IPCB(skb)->flags = 0;
750
751 if (dev->header_ops && dev->type == ARPHRD_IPGRE) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752 gre_hlen = 0;
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000753 tiph = (const struct iphdr *)skb->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754 } else {
755 gre_hlen = tunnel->hlen;
756 tiph = &tunnel->parms.iph;
757 }
758
759 if ((dst = tiph->daddr) == 0) {
760 /* NBMA tunnel */
761
Eric Dumazetadf30902009-06-02 05:19:30 +0000762 if (skb_dst(skb) == NULL) {
Eric Dumazete985aad2010-09-27 03:57:11 +0000763 dev->stats.tx_fifo_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764 goto tx_error;
765 }
766
David S. Miller61d57f82012-01-24 18:23:30 -0500767 if (skb->protocol == htons(ETH_P_IP)) {
Eric Dumazet511c3f92009-06-02 05:14:27 +0000768 rt = skb_rtable(skb);
David S. Millerf8126f12012-07-13 05:03:45 -0700769 dst = rt_nexthop(rt, old_iph->daddr);
David S. Miller61d57f82012-01-24 18:23:30 -0500770 }
Eric Dumazetdfd56b82011-12-10 09:48:31 +0000771#if IS_ENABLED(CONFIG_IPV6)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772 else if (skb->protocol == htons(ETH_P_IPV6)) {
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000773 const struct in6_addr *addr6;
David S. Miller0ec88662012-01-27 15:01:08 -0800774 struct neighbour *neigh;
775 bool do_tx_error_icmp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776 int addr_type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700777
David S. Miller0ec88662012-01-27 15:01:08 -0800778 neigh = dst_neigh_lookup(skb_dst(skb), &ipv6_hdr(skb)->daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700779 if (neigh == NULL)
780 goto tx_error;
781
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000782 addr6 = (const struct in6_addr *)&neigh->primary_key;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783 addr_type = ipv6_addr_type(addr6);
784
785 if (addr_type == IPV6_ADDR_ANY) {
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700786 addr6 = &ipv6_hdr(skb)->daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700787 addr_type = ipv6_addr_type(addr6);
788 }
789
790 if ((addr_type & IPV6_ADDR_COMPATv4) == 0)
David S. Miller0ec88662012-01-27 15:01:08 -0800791 do_tx_error_icmp = true;
792 else {
793 do_tx_error_icmp = false;
794 dst = addr6->s6_addr32[3];
795 }
796 neigh_release(neigh);
797 if (do_tx_error_icmp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798 goto tx_error_icmp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799 }
800#endif
801 else
802 goto tx_error;
803 }
804
805 tos = tiph->tos;
Andreas Jaggiee686ca2009-07-14 09:35:59 -0700806 if (tos == 1) {
807 tos = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808 if (skb->protocol == htons(ETH_P_IP))
809 tos = old_iph->tos;
Stephen Hemmingerdd4ba832010-07-08 21:35:58 -0700810 else if (skb->protocol == htons(ETH_P_IPV6))
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000811 tos = ipv6_get_dsfield((const struct ipv6hdr *)old_iph);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700812 }
813
David S. Millercbb1e852011-05-04 12:33:34 -0700814 rt = ip_route_output_gre(dev_net(dev), &fl4, dst, tiph->saddr,
David S. Miller78fbfd82011-03-12 00:00:52 -0500815 tunnel->parms.o_key, RT_TOS(tos),
816 tunnel->parms.link);
817 if (IS_ERR(rt)) {
818 dev->stats.tx_carrier_errors++;
819 goto tx_error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700820 }
Changli Gaod8d1f302010-06-10 23:31:35 -0700821 tdev = rt->dst.dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822
823 if (tdev == dev) {
824 ip_rt_put(rt);
Eric Dumazete985aad2010-09-27 03:57:11 +0000825 dev->stats.collisions++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700826 goto tx_error;
827 }
828
829 df = tiph->frag_off;
830 if (df)
Changli Gaod8d1f302010-06-10 23:31:35 -0700831 mtu = dst_mtu(&rt->dst) - dev->hard_header_len - tunnel->hlen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832 else
Eric Dumazetadf30902009-06-02 05:19:30 +0000833 mtu = skb_dst(skb) ? dst_mtu(skb_dst(skb)) : dev->mtu;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834
Eric Dumazetadf30902009-06-02 05:19:30 +0000835 if (skb_dst(skb))
David S. Miller6700c272012-07-17 03:29:28 -0700836 skb_dst(skb)->ops->update_pmtu(skb_dst(skb), NULL, skb, mtu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837
838 if (skb->protocol == htons(ETH_P_IP)) {
839 df |= (old_iph->frag_off&htons(IP_DF));
840
841 if ((old_iph->frag_off&htons(IP_DF)) &&
842 mtu < ntohs(old_iph->tot_len)) {
843 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED, htonl(mtu));
844 ip_rt_put(rt);
845 goto tx_error;
846 }
847 }
Eric Dumazetdfd56b82011-12-10 09:48:31 +0000848#if IS_ENABLED(CONFIG_IPV6)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700849 else if (skb->protocol == htons(ETH_P_IPV6)) {
Eric Dumazetadf30902009-06-02 05:19:30 +0000850 struct rt6_info *rt6 = (struct rt6_info *)skb_dst(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700851
Eric Dumazetadf30902009-06-02 05:19:30 +0000852 if (rt6 && mtu < dst_mtu(skb_dst(skb)) && mtu >= IPV6_MIN_MTU) {
Joe Perchesf97c1e02007-12-16 13:45:43 -0800853 if ((tunnel->parms.iph.daddr &&
854 !ipv4_is_multicast(tunnel->parms.iph.daddr)) ||
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855 rt6->rt6i_dst.plen == 128) {
856 rt6->rt6i_flags |= RTF_MODIFIED;
David S. Millerdefb3512010-12-08 21:16:57 -0800857 dst_metric_set(skb_dst(skb), RTAX_MTU, mtu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700858 }
859 }
860
861 if (mtu >= IPV6_MIN_MTU && mtu < skb->len - tunnel->hlen + gre_hlen) {
Alexey Dobriyan3ffe5332010-02-18 08:25:24 +0000862 icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, mtu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863 ip_rt_put(rt);
864 goto tx_error;
865 }
866 }
867#endif
868
869 if (tunnel->err_count > 0) {
Wei Yongjunda6185d82009-02-24 23:34:48 -0800870 if (time_before(jiffies,
871 tunnel->err_time + IPTUNNEL_ERR_TIMEO)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700872 tunnel->err_count--;
873
874 dst_link_failure(skb);
875 } else
876 tunnel->err_count = 0;
877 }
878
Changli Gaod8d1f302010-06-10 23:31:35 -0700879 max_headroom = LL_RESERVED_SPACE(tdev) + gre_hlen + rt->dst.header_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700880
Patrick McHardycfbba492007-07-09 15:33:40 -0700881 if (skb_headroom(skb) < max_headroom || skb_shared(skb)||
882 (skb_cloned(skb) && !skb_clone_writable(skb, 0))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700883 struct sk_buff *new_skb = skb_realloc_headroom(skb, max_headroom);
Herbert Xu805dc1d2011-11-18 02:20:06 +0000884 if (max_headroom > dev->needed_headroom)
885 dev->needed_headroom = max_headroom;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700886 if (!new_skb) {
887 ip_rt_put(rt);
Eric Dumazete985aad2010-09-27 03:57:11 +0000888 dev->stats.tx_dropped++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700889 dev_kfree_skb(skb);
Patrick McHardy6ed10652009-06-23 06:03:08 +0000890 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700891 }
892 if (skb->sk)
893 skb_set_owner_w(new_skb, skb->sk);
894 dev_kfree_skb(skb);
895 skb = new_skb;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700896 old_iph = ip_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700897 }
898
Herbert Xu64194c32008-10-09 12:03:17 -0700899 skb_reset_transport_header(skb);
Arnaldo Carvalho de Meloe2d1bca2007-04-10 20:46:21 -0700900 skb_push(skb, gre_hlen);
901 skb_reset_network_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700902 memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
Patrick McHardy48d5cad2006-02-15 15:10:22 -0800903 IPCB(skb)->flags &= ~(IPSKB_XFRM_TUNNEL_SIZE | IPSKB_XFRM_TRANSFORMED |
904 IPSKB_REROUTED);
Eric Dumazetadf30902009-06-02 05:19:30 +0000905 skb_dst_drop(skb);
Changli Gaod8d1f302010-06-10 23:31:35 -0700906 skb_dst_set(skb, &rt->dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700907
908 /*
909 * Push down and install the IPIP header.
910 */
911
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700912 iph = ip_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700913 iph->version = 4;
914 iph->ihl = sizeof(struct iphdr) >> 2;
915 iph->frag_off = df;
916 iph->protocol = IPPROTO_GRE;
917 iph->tos = ipgre_ecn_encapsulate(tos, old_iph, skb);
David S. Millercbb1e852011-05-04 12:33:34 -0700918 iph->daddr = fl4.daddr;
919 iph->saddr = fl4.saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700920
921 if ((iph->ttl = tiph->ttl) == 0) {
922 if (skb->protocol == htons(ETH_P_IP))
923 iph->ttl = old_iph->ttl;
Eric Dumazetdfd56b82011-12-10 09:48:31 +0000924#if IS_ENABLED(CONFIG_IPV6)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700925 else if (skb->protocol == htons(ETH_P_IPV6))
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000926 iph->ttl = ((const struct ipv6hdr *)old_iph)->hop_limit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927#endif
928 else
David S. Miller323e1262010-12-12 21:55:08 -0800929 iph->ttl = ip4_dst_hoplimit(&rt->dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700930 }
931
Herbert Xue1a80002008-10-09 12:00:17 -0700932 ((__be16 *)(iph + 1))[0] = tunnel->parms.o_flags;
933 ((__be16 *)(iph + 1))[1] = (dev->type == ARPHRD_ETHER) ?
934 htons(ETH_P_TEB) : skb->protocol;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700935
936 if (tunnel->parms.o_flags&(GRE_KEY|GRE_CSUM|GRE_SEQ)) {
Daniel Baluta5e73ea12012-04-15 01:34:41 +0000937 __be32 *ptr = (__be32 *)(((u8 *)iph) + tunnel->hlen - 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700938
939 if (tunnel->parms.o_flags&GRE_SEQ) {
940 ++tunnel->o_seqno;
941 *ptr = htonl(tunnel->o_seqno);
942 ptr--;
943 }
944 if (tunnel->parms.o_flags&GRE_KEY) {
945 *ptr = tunnel->parms.o_key;
946 ptr--;
947 }
948 if (tunnel->parms.o_flags&GRE_CSUM) {
949 *ptr = 0;
Daniel Baluta5e73ea12012-04-15 01:34:41 +0000950 *(__sum16 *)ptr = ip_compute_csum((void *)(iph+1), skb->len - sizeof(struct iphdr));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700951 }
952 }
953
954 nf_reset(skb);
Eric Dumazete985aad2010-09-27 03:57:11 +0000955 tstats = this_cpu_ptr(dev->tstats);
956 __IPTUNNEL_XMIT(tstats, &dev->stats);
Patrick McHardy6ed10652009-06-23 06:03:08 +0000957 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700958
David S. Miller496053f2012-01-11 16:46:32 -0800959#if IS_ENABLED(CONFIG_IPV6)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700960tx_error_icmp:
961 dst_link_failure(skb);
David S. Miller496053f2012-01-11 16:46:32 -0800962#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963tx_error:
Eric Dumazete985aad2010-09-27 03:57:11 +0000964 dev->stats.tx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700965 dev_kfree_skb(skb);
Patrick McHardy6ed10652009-06-23 06:03:08 +0000966 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700967}
968
Herbert Xu42aa9162008-10-09 11:59:32 -0700969static int ipgre_tunnel_bind_dev(struct net_device *dev)
Michal Schmidtee34c1e2007-12-13 09:46:32 -0800970{
971 struct net_device *tdev = NULL;
972 struct ip_tunnel *tunnel;
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000973 const struct iphdr *iph;
Michal Schmidtee34c1e2007-12-13 09:46:32 -0800974 int hlen = LL_MAX_HEADER;
975 int mtu = ETH_DATA_LEN;
976 int addend = sizeof(struct iphdr) + 4;
977
978 tunnel = netdev_priv(dev);
979 iph = &tunnel->parms.iph;
980
Herbert Xuc95b8192008-10-09 11:58:54 -0700981 /* Guess output device to choose reasonable mtu and needed_headroom */
Michal Schmidtee34c1e2007-12-13 09:46:32 -0800982
983 if (iph->daddr) {
David S. Millercbb1e852011-05-04 12:33:34 -0700984 struct flowi4 fl4;
985 struct rtable *rt;
Eric Dumazete985aad2010-09-27 03:57:11 +0000986
David S. Millercbb1e852011-05-04 12:33:34 -0700987 rt = ip_route_output_gre(dev_net(dev), &fl4,
988 iph->daddr, iph->saddr,
989 tunnel->parms.o_key,
990 RT_TOS(iph->tos),
991 tunnel->parms.link);
David S. Millerb23dd4f2011-03-02 14:31:35 -0800992 if (!IS_ERR(rt)) {
Changli Gaod8d1f302010-06-10 23:31:35 -0700993 tdev = rt->dst.dev;
Michal Schmidtee34c1e2007-12-13 09:46:32 -0800994 ip_rt_put(rt);
995 }
Herbert Xue1a80002008-10-09 12:00:17 -0700996
997 if (dev->type != ARPHRD_ETHER)
998 dev->flags |= IFF_POINTOPOINT;
Michal Schmidtee34c1e2007-12-13 09:46:32 -0800999 }
1000
1001 if (!tdev && tunnel->parms.link)
Pavel Emelyanov96635522008-04-16 01:10:44 -07001002 tdev = __dev_get_by_index(dev_net(dev), tunnel->parms.link);
Michal Schmidtee34c1e2007-12-13 09:46:32 -08001003
1004 if (tdev) {
Herbert Xuc95b8192008-10-09 11:58:54 -07001005 hlen = tdev->hard_header_len + tdev->needed_headroom;
Michal Schmidtee34c1e2007-12-13 09:46:32 -08001006 mtu = tdev->mtu;
1007 }
1008 dev->iflink = tunnel->parms.link;
1009
1010 /* Precalculate GRE options length */
1011 if (tunnel->parms.o_flags&(GRE_CSUM|GRE_KEY|GRE_SEQ)) {
1012 if (tunnel->parms.o_flags&GRE_CSUM)
1013 addend += 4;
1014 if (tunnel->parms.o_flags&GRE_KEY)
1015 addend += 4;
1016 if (tunnel->parms.o_flags&GRE_SEQ)
1017 addend += 4;
1018 }
Herbert Xuc95b8192008-10-09 11:58:54 -07001019 dev->needed_headroom = addend + hlen;
Tom Goff8cdb0452009-08-14 16:33:56 -07001020 mtu -= dev->hard_header_len + addend;
Herbert Xu42aa9162008-10-09 11:59:32 -07001021
1022 if (mtu < 68)
1023 mtu = 68;
1024
Michal Schmidtee34c1e2007-12-13 09:46:32 -08001025 tunnel->hlen = addend;
1026
Herbert Xu42aa9162008-10-09 11:59:32 -07001027 return mtu;
Michal Schmidtee34c1e2007-12-13 09:46:32 -08001028}
1029
Linus Torvalds1da177e2005-04-16 15:20:36 -07001030static int
1031ipgre_tunnel_ioctl (struct net_device *dev, struct ifreq *ifr, int cmd)
1032{
1033 int err = 0;
1034 struct ip_tunnel_parm p;
1035 struct ip_tunnel *t;
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -07001036 struct net *net = dev_net(dev);
1037 struct ipgre_net *ign = net_generic(net, ipgre_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001038
1039 switch (cmd) {
1040 case SIOCGETTUNNEL:
1041 t = NULL;
Pavel Emelyanov7daa0002008-04-16 01:10:05 -07001042 if (dev == ign->fb_tunnel_dev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001043 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p))) {
1044 err = -EFAULT;
1045 break;
1046 }
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -07001047 t = ipgre_tunnel_locate(net, &p, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001048 }
1049 if (t == NULL)
Patrick McHardy2941a482006-01-08 22:05:26 -08001050 t = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001051 memcpy(&p, &t->parms, sizeof(p));
1052 if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p)))
1053 err = -EFAULT;
1054 break;
1055
1056 case SIOCADDTUNNEL:
1057 case SIOCCHGTUNNEL:
1058 err = -EPERM;
1059 if (!capable(CAP_NET_ADMIN))
1060 goto done;
1061
1062 err = -EFAULT;
1063 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
1064 goto done;
1065
1066 err = -EINVAL;
1067 if (p.iph.version != 4 || p.iph.protocol != IPPROTO_GRE ||
1068 p.iph.ihl != 5 || (p.iph.frag_off&htons(~IP_DF)) ||
1069 ((p.i_flags|p.o_flags)&(GRE_VERSION|GRE_ROUTING)))
1070 goto done;
1071 if (p.iph.ttl)
1072 p.iph.frag_off |= htons(IP_DF);
1073
1074 if (!(p.i_flags&GRE_KEY))
1075 p.i_key = 0;
1076 if (!(p.o_flags&GRE_KEY))
1077 p.o_key = 0;
1078
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -07001079 t = ipgre_tunnel_locate(net, &p, cmd == SIOCADDTUNNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001080
Pavel Emelyanov7daa0002008-04-16 01:10:05 -07001081 if (dev != ign->fb_tunnel_dev && cmd == SIOCCHGTUNNEL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001082 if (t != NULL) {
1083 if (t->dev != dev) {
1084 err = -EEXIST;
1085 break;
1086 }
1087 } else {
Eric Dumazet15078502010-09-15 11:07:53 +00001088 unsigned int nflags = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001089
Patrick McHardy2941a482006-01-08 22:05:26 -08001090 t = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001091
Joe Perchesf97c1e02007-12-16 13:45:43 -08001092 if (ipv4_is_multicast(p.iph.daddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001093 nflags = IFF_BROADCAST;
1094 else if (p.iph.daddr)
1095 nflags = IFF_POINTOPOINT;
1096
1097 if ((dev->flags^nflags)&(IFF_POINTOPOINT|IFF_BROADCAST)) {
1098 err = -EINVAL;
1099 break;
1100 }
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -07001101 ipgre_tunnel_unlink(ign, t);
Pavel Emelyanov74b0b852010-10-27 05:43:53 +00001102 synchronize_net();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001103 t->parms.iph.saddr = p.iph.saddr;
1104 t->parms.iph.daddr = p.iph.daddr;
1105 t->parms.i_key = p.i_key;
1106 t->parms.o_key = p.o_key;
1107 memcpy(dev->dev_addr, &p.iph.saddr, 4);
1108 memcpy(dev->broadcast, &p.iph.daddr, 4);
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -07001109 ipgre_tunnel_link(ign, t);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001110 netdev_state_change(dev);
1111 }
1112 }
1113
1114 if (t) {
1115 err = 0;
1116 if (cmd == SIOCCHGTUNNEL) {
1117 t->parms.iph.ttl = p.iph.ttl;
1118 t->parms.iph.tos = p.iph.tos;
1119 t->parms.iph.frag_off = p.iph.frag_off;
Michal Schmidtee34c1e2007-12-13 09:46:32 -08001120 if (t->parms.link != p.link) {
1121 t->parms.link = p.link;
Herbert Xu42aa9162008-10-09 11:59:32 -07001122 dev->mtu = ipgre_tunnel_bind_dev(dev);
Michal Schmidtee34c1e2007-12-13 09:46:32 -08001123 netdev_state_change(dev);
1124 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001125 }
1126 if (copy_to_user(ifr->ifr_ifru.ifru_data, &t->parms, sizeof(p)))
1127 err = -EFAULT;
1128 } else
1129 err = (cmd == SIOCADDTUNNEL ? -ENOBUFS : -ENOENT);
1130 break;
1131
1132 case SIOCDELTUNNEL:
1133 err = -EPERM;
1134 if (!capable(CAP_NET_ADMIN))
1135 goto done;
1136
Pavel Emelyanov7daa0002008-04-16 01:10:05 -07001137 if (dev == ign->fb_tunnel_dev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001138 err = -EFAULT;
1139 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
1140 goto done;
1141 err = -ENOENT;
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -07001142 if ((t = ipgre_tunnel_locate(net, &p, 0)) == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001143 goto done;
1144 err = -EPERM;
Pavel Emelyanov7daa0002008-04-16 01:10:05 -07001145 if (t == netdev_priv(ign->fb_tunnel_dev))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001146 goto done;
1147 dev = t->dev;
1148 }
Stephen Hemminger22f8cde2007-02-07 00:09:58 -08001149 unregister_netdevice(dev);
1150 err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001151 break;
1152
1153 default:
1154 err = -EINVAL;
1155 }
1156
1157done:
1158 return err;
1159}
1160
Linus Torvalds1da177e2005-04-16 15:20:36 -07001161static int ipgre_tunnel_change_mtu(struct net_device *dev, int new_mtu)
1162{
Patrick McHardy2941a482006-01-08 22:05:26 -08001163 struct ip_tunnel *tunnel = netdev_priv(dev);
Herbert Xuc95b8192008-10-09 11:58:54 -07001164 if (new_mtu < 68 ||
1165 new_mtu > 0xFFF8 - dev->hard_header_len - tunnel->hlen)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001166 return -EINVAL;
1167 dev->mtu = new_mtu;
1168 return 0;
1169}
1170
Linus Torvalds1da177e2005-04-16 15:20:36 -07001171/* Nice toy. Unfortunately, useless in real life :-)
1172 It allows to construct virtual multiprotocol broadcast "LAN"
1173 over the Internet, provided multicast routing is tuned.
1174
1175
1176 I have no idea was this bicycle invented before me,
1177 so that I had to set ARPHRD_IPGRE to a random value.
1178 I have an impression, that Cisco could make something similar,
1179 but this feature is apparently missing in IOS<=11.2(8).
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001180
Linus Torvalds1da177e2005-04-16 15:20:36 -07001181 I set up 10.66.66/24 and fec0:6666:6666::0/96 as virtual networks
1182 with broadcast 224.66.66.66. If you have access to mbone, play with me :-)
1183
1184 ping -t 255 224.66.66.66
1185
1186 If nobody answers, mbone does not work.
1187
1188 ip tunnel add Universe mode gre remote 224.66.66.66 local <Your_real_addr> ttl 255
1189 ip addr add 10.66.66.<somewhat>/24 dev Universe
1190 ifconfig Universe up
1191 ifconfig Universe add fe80::<Your_real_addr>/10
1192 ifconfig Universe add fec0:6666:6666::<Your_real_addr>/96
1193 ftp 10.66.66.66
1194 ...
1195 ftp fec0:6666:6666::193.233.7.65
1196 ...
1197
1198 */
1199
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -07001200static int ipgre_header(struct sk_buff *skb, struct net_device *dev,
1201 unsigned short type,
Eric Dumazet15078502010-09-15 11:07:53 +00001202 const void *daddr, const void *saddr, unsigned int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001203{
Patrick McHardy2941a482006-01-08 22:05:26 -08001204 struct ip_tunnel *t = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001205 struct iphdr *iph = (struct iphdr *)skb_push(skb, t->hlen);
Daniel Baluta5e73ea12012-04-15 01:34:41 +00001206 __be16 *p = (__be16 *)(iph+1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001207
1208 memcpy(iph, &t->parms.iph, sizeof(struct iphdr));
1209 p[0] = t->parms.o_flags;
1210 p[1] = htons(type);
1211
1212 /*
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001213 * Set the source hardware address.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001214 */
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001215
Linus Torvalds1da177e2005-04-16 15:20:36 -07001216 if (saddr)
1217 memcpy(&iph->saddr, saddr, 4);
Timo Teräs6d55cb92010-03-03 04:01:13 +00001218 if (daddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001219 memcpy(&iph->daddr, daddr, 4);
Timo Teräs6d55cb92010-03-03 04:01:13 +00001220 if (iph->daddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001221 return t->hlen;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001222
Linus Torvalds1da177e2005-04-16 15:20:36 -07001223 return -t->hlen;
1224}
1225
Timo Teras6a5f44d2007-10-23 20:31:53 -07001226static int ipgre_header_parse(const struct sk_buff *skb, unsigned char *haddr)
1227{
Eric Dumazetb71d1d42011-04-22 04:53:02 +00001228 const struct iphdr *iph = (const struct iphdr *) skb_mac_header(skb);
Timo Teras6a5f44d2007-10-23 20:31:53 -07001229 memcpy(haddr, &iph->saddr, 4);
1230 return 4;
1231}
1232
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -07001233static const struct header_ops ipgre_header_ops = {
1234 .create = ipgre_header,
Timo Teras6a5f44d2007-10-23 20:31:53 -07001235 .parse = ipgre_header_parse,
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -07001236};
1237
Timo Teras6a5f44d2007-10-23 20:31:53 -07001238#ifdef CONFIG_NET_IPGRE_BROADCAST
Linus Torvalds1da177e2005-04-16 15:20:36 -07001239static int ipgre_open(struct net_device *dev)
1240{
Patrick McHardy2941a482006-01-08 22:05:26 -08001241 struct ip_tunnel *t = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001242
Joe Perchesf97c1e02007-12-16 13:45:43 -08001243 if (ipv4_is_multicast(t->parms.iph.daddr)) {
David S. Millercbb1e852011-05-04 12:33:34 -07001244 struct flowi4 fl4;
1245 struct rtable *rt;
Eric Dumazete985aad2010-09-27 03:57:11 +00001246
David S. Millercbb1e852011-05-04 12:33:34 -07001247 rt = ip_route_output_gre(dev_net(dev), &fl4,
1248 t->parms.iph.daddr,
1249 t->parms.iph.saddr,
1250 t->parms.o_key,
1251 RT_TOS(t->parms.iph.tos),
1252 t->parms.link);
David S. Millerb23dd4f2011-03-02 14:31:35 -08001253 if (IS_ERR(rt))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001254 return -EADDRNOTAVAIL;
Changli Gaod8d1f302010-06-10 23:31:35 -07001255 dev = rt->dst.dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001256 ip_rt_put(rt);
Herbert Xue5ed6392005-10-03 14:35:55 -07001257 if (__in_dev_get_rtnl(dev) == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001258 return -EADDRNOTAVAIL;
1259 t->mlink = dev->ifindex;
Herbert Xue5ed6392005-10-03 14:35:55 -07001260 ip_mc_inc_group(__in_dev_get_rtnl(dev), t->parms.iph.daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001261 }
1262 return 0;
1263}
1264
1265static int ipgre_close(struct net_device *dev)
1266{
Patrick McHardy2941a482006-01-08 22:05:26 -08001267 struct ip_tunnel *t = netdev_priv(dev);
Stephen Hemmingerb8c26a32008-11-20 20:34:29 -08001268
Joe Perchesf97c1e02007-12-16 13:45:43 -08001269 if (ipv4_is_multicast(t->parms.iph.daddr) && t->mlink) {
Denis V. Lunev7fee0ca2008-01-21 17:32:38 -08001270 struct in_device *in_dev;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001271 in_dev = inetdev_by_index(dev_net(dev), t->mlink);
Eric Dumazet8723e1b2010-10-19 00:39:26 +00001272 if (in_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001273 ip_mc_dec_group(in_dev, t->parms.iph.daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001274 }
1275 return 0;
1276}
1277
1278#endif
1279
Stephen Hemmingerb8c26a32008-11-20 20:34:29 -08001280static const struct net_device_ops ipgre_netdev_ops = {
1281 .ndo_init = ipgre_tunnel_init,
1282 .ndo_uninit = ipgre_tunnel_uninit,
1283#ifdef CONFIG_NET_IPGRE_BROADCAST
1284 .ndo_open = ipgre_open,
1285 .ndo_stop = ipgre_close,
1286#endif
1287 .ndo_start_xmit = ipgre_tunnel_xmit,
1288 .ndo_do_ioctl = ipgre_tunnel_ioctl,
1289 .ndo_change_mtu = ipgre_tunnel_change_mtu,
stephen hemminger87b6d212012-04-12 06:31:16 +00001290 .ndo_get_stats64 = ipgre_get_stats64,
Stephen Hemmingerb8c26a32008-11-20 20:34:29 -08001291};
1292
Eric Dumazete985aad2010-09-27 03:57:11 +00001293static void ipgre_dev_free(struct net_device *dev)
1294{
1295 free_percpu(dev->tstats);
1296 free_netdev(dev);
1297}
1298
Linus Torvalds1da177e2005-04-16 15:20:36 -07001299static void ipgre_tunnel_setup(struct net_device *dev)
1300{
Stephen Hemmingerb8c26a32008-11-20 20:34:29 -08001301 dev->netdev_ops = &ipgre_netdev_ops;
Eric Dumazete985aad2010-09-27 03:57:11 +00001302 dev->destructor = ipgre_dev_free;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001303
1304 dev->type = ARPHRD_IPGRE;
Herbert Xuc95b8192008-10-09 11:58:54 -07001305 dev->needed_headroom = LL_MAX_HEADER + sizeof(struct iphdr) + 4;
Kris Katterjohn46f25df2006-01-05 16:35:42 -08001306 dev->mtu = ETH_DATA_LEN - sizeof(struct iphdr) - 4;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001307 dev->flags = IFF_NOARP;
1308 dev->iflink = 0;
1309 dev->addr_len = 4;
Pavel Emelyanov0b67ece2008-04-16 01:11:13 -07001310 dev->features |= NETIF_F_NETNS_LOCAL;
Eric Dumazet108bfa82009-05-28 22:35:10 +00001311 dev->priv_flags &= ~IFF_XMIT_DST_RELEASE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001312}
1313
1314static int ipgre_tunnel_init(struct net_device *dev)
1315{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001316 struct ip_tunnel *tunnel;
1317 struct iphdr *iph;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001318
Patrick McHardy2941a482006-01-08 22:05:26 -08001319 tunnel = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001320 iph = &tunnel->parms.iph;
1321
1322 tunnel->dev = dev;
1323 strcpy(tunnel->parms.name, dev->name);
1324
1325 memcpy(dev->dev_addr, &tunnel->parms.iph.saddr, 4);
1326 memcpy(dev->broadcast, &tunnel->parms.iph.daddr, 4);
1327
Linus Torvalds1da177e2005-04-16 15:20:36 -07001328 if (iph->daddr) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001329#ifdef CONFIG_NET_IPGRE_BROADCAST
Joe Perchesf97c1e02007-12-16 13:45:43 -08001330 if (ipv4_is_multicast(iph->daddr)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001331 if (!iph->saddr)
1332 return -EINVAL;
1333 dev->flags = IFF_BROADCAST;
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -07001334 dev->header_ops = &ipgre_header_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001335 }
1336#endif
Michal Schmidtee34c1e2007-12-13 09:46:32 -08001337 } else
Timo Teras6a5f44d2007-10-23 20:31:53 -07001338 dev->header_ops = &ipgre_header_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001339
Eric Dumazete985aad2010-09-27 03:57:11 +00001340 dev->tstats = alloc_percpu(struct pcpu_tstats);
1341 if (!dev->tstats)
1342 return -ENOMEM;
1343
Linus Torvalds1da177e2005-04-16 15:20:36 -07001344 return 0;
1345}
1346
Stephen Hemmingerb8c26a32008-11-20 20:34:29 -08001347static void ipgre_fb_tunnel_init(struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001348{
Patrick McHardy2941a482006-01-08 22:05:26 -08001349 struct ip_tunnel *tunnel = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001350 struct iphdr *iph = &tunnel->parms.iph;
1351
1352 tunnel->dev = dev;
1353 strcpy(tunnel->parms.name, dev->name);
1354
1355 iph->version = 4;
1356 iph->protocol = IPPROTO_GRE;
1357 iph->ihl = 5;
1358 tunnel->hlen = sizeof(struct iphdr) + 4;
1359
1360 dev_hold(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001361}
1362
1363
Dmitry Kozlov00959ad2010-08-21 23:05:39 -07001364static const struct gre_protocol ipgre_protocol = {
1365 .handler = ipgre_rcv,
1366 .err_handler = ipgre_err,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001367};
1368
Eric Dumazeteef6dd62009-10-27 07:07:16 +00001369static void ipgre_destroy_tunnels(struct ipgre_net *ign, struct list_head *head)
Pavel Emelyanoveb8ce742008-04-16 01:10:26 -07001370{
1371 int prio;
1372
1373 for (prio = 0; prio < 4; prio++) {
1374 int h;
1375 for (h = 0; h < HASH_SIZE; h++) {
Eric Dumazet15078502010-09-15 11:07:53 +00001376 struct ip_tunnel *t;
1377
1378 t = rtnl_dereference(ign->tunnels[prio][h]);
Eric Dumazeteef6dd62009-10-27 07:07:16 +00001379
1380 while (t != NULL) {
1381 unregister_netdevice_queue(t->dev, head);
Eric Dumazet15078502010-09-15 11:07:53 +00001382 t = rtnl_dereference(t->next);
Eric Dumazeteef6dd62009-10-27 07:07:16 +00001383 }
Pavel Emelyanoveb8ce742008-04-16 01:10:26 -07001384 }
1385 }
1386}
1387
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00001388static int __net_init ipgre_init_net(struct net *net)
Pavel Emelyanov59a4c752008-04-16 01:08:53 -07001389{
Eric W. Biedermancfb8fbf2009-11-29 15:46:13 +00001390 struct ipgre_net *ign = net_generic(net, ipgre_net_id);
Pavel Emelyanov59a4c752008-04-16 01:08:53 -07001391 int err;
Pavel Emelyanov59a4c752008-04-16 01:08:53 -07001392
Pavel Emelyanov7daa0002008-04-16 01:10:05 -07001393 ign->fb_tunnel_dev = alloc_netdev(sizeof(struct ip_tunnel), "gre0",
1394 ipgre_tunnel_setup);
1395 if (!ign->fb_tunnel_dev) {
1396 err = -ENOMEM;
1397 goto err_alloc_dev;
1398 }
Alexey Dobriyanbe77e592008-11-23 17:26:26 -08001399 dev_net_set(ign->fb_tunnel_dev, net);
Pavel Emelyanov7daa0002008-04-16 01:10:05 -07001400
Stephen Hemmingerb8c26a32008-11-20 20:34:29 -08001401 ipgre_fb_tunnel_init(ign->fb_tunnel_dev);
Herbert Xuc19e6542008-10-09 11:59:55 -07001402 ign->fb_tunnel_dev->rtnl_link_ops = &ipgre_link_ops;
Pavel Emelyanov7daa0002008-04-16 01:10:05 -07001403
1404 if ((err = register_netdev(ign->fb_tunnel_dev)))
1405 goto err_reg_dev;
1406
Eric Dumazet3285ee32010-10-30 16:21:28 -07001407 rcu_assign_pointer(ign->tunnels_wc[0],
1408 netdev_priv(ign->fb_tunnel_dev));
Pavel Emelyanov59a4c752008-04-16 01:08:53 -07001409 return 0;
1410
Pavel Emelyanov7daa0002008-04-16 01:10:05 -07001411err_reg_dev:
Eric Dumazet3285ee32010-10-30 16:21:28 -07001412 ipgre_dev_free(ign->fb_tunnel_dev);
Pavel Emelyanov7daa0002008-04-16 01:10:05 -07001413err_alloc_dev:
Pavel Emelyanov59a4c752008-04-16 01:08:53 -07001414 return err;
1415}
1416
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00001417static void __net_exit ipgre_exit_net(struct net *net)
Pavel Emelyanov59a4c752008-04-16 01:08:53 -07001418{
1419 struct ipgre_net *ign;
Eric Dumazeteef6dd62009-10-27 07:07:16 +00001420 LIST_HEAD(list);
Pavel Emelyanov59a4c752008-04-16 01:08:53 -07001421
1422 ign = net_generic(net, ipgre_net_id);
Pavel Emelyanov7daa0002008-04-16 01:10:05 -07001423 rtnl_lock();
Eric Dumazeteef6dd62009-10-27 07:07:16 +00001424 ipgre_destroy_tunnels(ign, &list);
1425 unregister_netdevice_many(&list);
Pavel Emelyanov7daa0002008-04-16 01:10:05 -07001426 rtnl_unlock();
Pavel Emelyanov59a4c752008-04-16 01:08:53 -07001427}
1428
1429static struct pernet_operations ipgre_net_ops = {
1430 .init = ipgre_init_net,
1431 .exit = ipgre_exit_net,
Eric W. Biedermancfb8fbf2009-11-29 15:46:13 +00001432 .id = &ipgre_net_id,
1433 .size = sizeof(struct ipgre_net),
Pavel Emelyanov59a4c752008-04-16 01:08:53 -07001434};
Linus Torvalds1da177e2005-04-16 15:20:36 -07001435
Herbert Xuc19e6542008-10-09 11:59:55 -07001436static int ipgre_tunnel_validate(struct nlattr *tb[], struct nlattr *data[])
1437{
1438 __be16 flags;
1439
1440 if (!data)
1441 return 0;
1442
1443 flags = 0;
1444 if (data[IFLA_GRE_IFLAGS])
1445 flags |= nla_get_be16(data[IFLA_GRE_IFLAGS]);
1446 if (data[IFLA_GRE_OFLAGS])
1447 flags |= nla_get_be16(data[IFLA_GRE_OFLAGS]);
1448 if (flags & (GRE_VERSION|GRE_ROUTING))
1449 return -EINVAL;
1450
1451 return 0;
1452}
1453
Herbert Xue1a80002008-10-09 12:00:17 -07001454static int ipgre_tap_validate(struct nlattr *tb[], struct nlattr *data[])
1455{
1456 __be32 daddr;
1457
1458 if (tb[IFLA_ADDRESS]) {
1459 if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
1460 return -EINVAL;
1461 if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
1462 return -EADDRNOTAVAIL;
1463 }
1464
1465 if (!data)
1466 goto out;
1467
1468 if (data[IFLA_GRE_REMOTE]) {
1469 memcpy(&daddr, nla_data(data[IFLA_GRE_REMOTE]), 4);
1470 if (!daddr)
1471 return -EINVAL;
1472 }
1473
1474out:
1475 return ipgre_tunnel_validate(tb, data);
1476}
1477
Herbert Xuc19e6542008-10-09 11:59:55 -07001478static void ipgre_netlink_parms(struct nlattr *data[],
1479 struct ip_tunnel_parm *parms)
1480{
Herbert Xu7bb82d92008-10-11 12:20:15 -07001481 memset(parms, 0, sizeof(*parms));
Herbert Xuc19e6542008-10-09 11:59:55 -07001482
1483 parms->iph.protocol = IPPROTO_GRE;
1484
1485 if (!data)
1486 return;
1487
1488 if (data[IFLA_GRE_LINK])
1489 parms->link = nla_get_u32(data[IFLA_GRE_LINK]);
1490
1491 if (data[IFLA_GRE_IFLAGS])
1492 parms->i_flags = nla_get_be16(data[IFLA_GRE_IFLAGS]);
1493
1494 if (data[IFLA_GRE_OFLAGS])
1495 parms->o_flags = nla_get_be16(data[IFLA_GRE_OFLAGS]);
1496
1497 if (data[IFLA_GRE_IKEY])
1498 parms->i_key = nla_get_be32(data[IFLA_GRE_IKEY]);
1499
1500 if (data[IFLA_GRE_OKEY])
1501 parms->o_key = nla_get_be32(data[IFLA_GRE_OKEY]);
1502
1503 if (data[IFLA_GRE_LOCAL])
Patrick McHardy4d74f8b2008-10-10 12:11:06 -07001504 parms->iph.saddr = nla_get_be32(data[IFLA_GRE_LOCAL]);
Herbert Xuc19e6542008-10-09 11:59:55 -07001505
1506 if (data[IFLA_GRE_REMOTE])
Patrick McHardy4d74f8b2008-10-10 12:11:06 -07001507 parms->iph.daddr = nla_get_be32(data[IFLA_GRE_REMOTE]);
Herbert Xuc19e6542008-10-09 11:59:55 -07001508
1509 if (data[IFLA_GRE_TTL])
1510 parms->iph.ttl = nla_get_u8(data[IFLA_GRE_TTL]);
1511
1512 if (data[IFLA_GRE_TOS])
1513 parms->iph.tos = nla_get_u8(data[IFLA_GRE_TOS]);
1514
1515 if (!data[IFLA_GRE_PMTUDISC] || nla_get_u8(data[IFLA_GRE_PMTUDISC]))
1516 parms->iph.frag_off = htons(IP_DF);
1517}
1518
Herbert Xue1a80002008-10-09 12:00:17 -07001519static int ipgre_tap_init(struct net_device *dev)
1520{
1521 struct ip_tunnel *tunnel;
1522
1523 tunnel = netdev_priv(dev);
1524
1525 tunnel->dev = dev;
1526 strcpy(tunnel->parms.name, dev->name);
1527
1528 ipgre_tunnel_bind_dev(dev);
1529
Eric Dumazete985aad2010-09-27 03:57:11 +00001530 dev->tstats = alloc_percpu(struct pcpu_tstats);
1531 if (!dev->tstats)
1532 return -ENOMEM;
1533
Herbert Xue1a80002008-10-09 12:00:17 -07001534 return 0;
1535}
1536
Stephen Hemmingerb8c26a32008-11-20 20:34:29 -08001537static const struct net_device_ops ipgre_tap_netdev_ops = {
1538 .ndo_init = ipgre_tap_init,
1539 .ndo_uninit = ipgre_tunnel_uninit,
1540 .ndo_start_xmit = ipgre_tunnel_xmit,
1541 .ndo_set_mac_address = eth_mac_addr,
1542 .ndo_validate_addr = eth_validate_addr,
1543 .ndo_change_mtu = ipgre_tunnel_change_mtu,
stephen hemminger87b6d212012-04-12 06:31:16 +00001544 .ndo_get_stats64 = ipgre_get_stats64,
Stephen Hemmingerb8c26a32008-11-20 20:34:29 -08001545};
1546
Herbert Xue1a80002008-10-09 12:00:17 -07001547static void ipgre_tap_setup(struct net_device *dev)
1548{
1549
1550 ether_setup(dev);
1551
Herbert Xu2e9526b2009-10-30 05:51:48 +00001552 dev->netdev_ops = &ipgre_tap_netdev_ops;
Eric Dumazete985aad2010-09-27 03:57:11 +00001553 dev->destructor = ipgre_dev_free;
Herbert Xue1a80002008-10-09 12:00:17 -07001554
1555 dev->iflink = 0;
1556 dev->features |= NETIF_F_NETNS_LOCAL;
1557}
1558
Eric W. Biederman81adee42009-11-08 00:53:51 -08001559static int ipgre_newlink(struct net *src_net, struct net_device *dev, struct nlattr *tb[],
Herbert Xuc19e6542008-10-09 11:59:55 -07001560 struct nlattr *data[])
1561{
1562 struct ip_tunnel *nt;
1563 struct net *net = dev_net(dev);
1564 struct ipgre_net *ign = net_generic(net, ipgre_net_id);
1565 int mtu;
1566 int err;
1567
1568 nt = netdev_priv(dev);
1569 ipgre_netlink_parms(data, &nt->parms);
1570
Herbert Xue1a80002008-10-09 12:00:17 -07001571 if (ipgre_tunnel_find(net, &nt->parms, dev->type))
Herbert Xuc19e6542008-10-09 11:59:55 -07001572 return -EEXIST;
1573
Herbert Xue1a80002008-10-09 12:00:17 -07001574 if (dev->type == ARPHRD_ETHER && !tb[IFLA_ADDRESS])
Danny Kukawkaf2cedb62012-02-15 06:45:39 +00001575 eth_hw_addr_random(dev);
Herbert Xue1a80002008-10-09 12:00:17 -07001576
Herbert Xuc19e6542008-10-09 11:59:55 -07001577 mtu = ipgre_tunnel_bind_dev(dev);
1578 if (!tb[IFLA_MTU])
1579 dev->mtu = mtu;
1580
Eric Dumazetb790e012010-09-27 23:05:47 +00001581 /* Can use a lockless transmit, unless we generate output sequences */
1582 if (!(nt->parms.o_flags & GRE_SEQ))
1583 dev->features |= NETIF_F_LLTX;
1584
Herbert Xuc19e6542008-10-09 11:59:55 -07001585 err = register_netdevice(dev);
1586 if (err)
1587 goto out;
1588
1589 dev_hold(dev);
1590 ipgre_tunnel_link(ign, nt);
1591
1592out:
1593 return err;
1594}
1595
1596static int ipgre_changelink(struct net_device *dev, struct nlattr *tb[],
1597 struct nlattr *data[])
1598{
1599 struct ip_tunnel *t, *nt;
1600 struct net *net = dev_net(dev);
1601 struct ipgre_net *ign = net_generic(net, ipgre_net_id);
1602 struct ip_tunnel_parm p;
1603 int mtu;
1604
1605 if (dev == ign->fb_tunnel_dev)
1606 return -EINVAL;
1607
1608 nt = netdev_priv(dev);
1609 ipgre_netlink_parms(data, &p);
1610
1611 t = ipgre_tunnel_locate(net, &p, 0);
1612
1613 if (t) {
1614 if (t->dev != dev)
1615 return -EEXIST;
1616 } else {
Herbert Xuc19e6542008-10-09 11:59:55 -07001617 t = nt;
1618
Herbert Xu2e9526b2009-10-30 05:51:48 +00001619 if (dev->type != ARPHRD_ETHER) {
Eric Dumazet15078502010-09-15 11:07:53 +00001620 unsigned int nflags = 0;
Herbert Xuc19e6542008-10-09 11:59:55 -07001621
Herbert Xu2e9526b2009-10-30 05:51:48 +00001622 if (ipv4_is_multicast(p.iph.daddr))
1623 nflags = IFF_BROADCAST;
1624 else if (p.iph.daddr)
1625 nflags = IFF_POINTOPOINT;
1626
1627 if ((dev->flags ^ nflags) &
1628 (IFF_POINTOPOINT | IFF_BROADCAST))
1629 return -EINVAL;
1630 }
Herbert Xuc19e6542008-10-09 11:59:55 -07001631
1632 ipgre_tunnel_unlink(ign, t);
1633 t->parms.iph.saddr = p.iph.saddr;
1634 t->parms.iph.daddr = p.iph.daddr;
1635 t->parms.i_key = p.i_key;
Herbert Xu2e9526b2009-10-30 05:51:48 +00001636 if (dev->type != ARPHRD_ETHER) {
1637 memcpy(dev->dev_addr, &p.iph.saddr, 4);
1638 memcpy(dev->broadcast, &p.iph.daddr, 4);
1639 }
Herbert Xuc19e6542008-10-09 11:59:55 -07001640 ipgre_tunnel_link(ign, t);
1641 netdev_state_change(dev);
1642 }
1643
1644 t->parms.o_key = p.o_key;
1645 t->parms.iph.ttl = p.iph.ttl;
1646 t->parms.iph.tos = p.iph.tos;
1647 t->parms.iph.frag_off = p.iph.frag_off;
1648
1649 if (t->parms.link != p.link) {
1650 t->parms.link = p.link;
1651 mtu = ipgre_tunnel_bind_dev(dev);
1652 if (!tb[IFLA_MTU])
1653 dev->mtu = mtu;
1654 netdev_state_change(dev);
1655 }
1656
1657 return 0;
1658}
1659
1660static size_t ipgre_get_size(const struct net_device *dev)
1661{
1662 return
1663 /* IFLA_GRE_LINK */
1664 nla_total_size(4) +
1665 /* IFLA_GRE_IFLAGS */
1666 nla_total_size(2) +
1667 /* IFLA_GRE_OFLAGS */
1668 nla_total_size(2) +
1669 /* IFLA_GRE_IKEY */
1670 nla_total_size(4) +
1671 /* IFLA_GRE_OKEY */
1672 nla_total_size(4) +
1673 /* IFLA_GRE_LOCAL */
1674 nla_total_size(4) +
1675 /* IFLA_GRE_REMOTE */
1676 nla_total_size(4) +
1677 /* IFLA_GRE_TTL */
1678 nla_total_size(1) +
1679 /* IFLA_GRE_TOS */
1680 nla_total_size(1) +
1681 /* IFLA_GRE_PMTUDISC */
1682 nla_total_size(1) +
1683 0;
1684}
1685
1686static int ipgre_fill_info(struct sk_buff *skb, const struct net_device *dev)
1687{
1688 struct ip_tunnel *t = netdev_priv(dev);
1689 struct ip_tunnel_parm *p = &t->parms;
1690
David S. Millerf3756b72012-04-01 20:39:02 -04001691 if (nla_put_u32(skb, IFLA_GRE_LINK, p->link) ||
1692 nla_put_be16(skb, IFLA_GRE_IFLAGS, p->i_flags) ||
1693 nla_put_be16(skb, IFLA_GRE_OFLAGS, p->o_flags) ||
1694 nla_put_be32(skb, IFLA_GRE_IKEY, p->i_key) ||
1695 nla_put_be32(skb, IFLA_GRE_OKEY, p->o_key) ||
1696 nla_put_be32(skb, IFLA_GRE_LOCAL, p->iph.saddr) ||
1697 nla_put_be32(skb, IFLA_GRE_REMOTE, p->iph.daddr) ||
1698 nla_put_u8(skb, IFLA_GRE_TTL, p->iph.ttl) ||
1699 nla_put_u8(skb, IFLA_GRE_TOS, p->iph.tos) ||
1700 nla_put_u8(skb, IFLA_GRE_PMTUDISC,
1701 !!(p->iph.frag_off & htons(IP_DF))))
1702 goto nla_put_failure;
Herbert Xuc19e6542008-10-09 11:59:55 -07001703 return 0;
1704
1705nla_put_failure:
1706 return -EMSGSIZE;
1707}
1708
1709static const struct nla_policy ipgre_policy[IFLA_GRE_MAX + 1] = {
1710 [IFLA_GRE_LINK] = { .type = NLA_U32 },
1711 [IFLA_GRE_IFLAGS] = { .type = NLA_U16 },
1712 [IFLA_GRE_OFLAGS] = { .type = NLA_U16 },
1713 [IFLA_GRE_IKEY] = { .type = NLA_U32 },
1714 [IFLA_GRE_OKEY] = { .type = NLA_U32 },
Patrick McHardy4d74f8b2008-10-10 12:11:06 -07001715 [IFLA_GRE_LOCAL] = { .len = FIELD_SIZEOF(struct iphdr, saddr) },
1716 [IFLA_GRE_REMOTE] = { .len = FIELD_SIZEOF(struct iphdr, daddr) },
Herbert Xuc19e6542008-10-09 11:59:55 -07001717 [IFLA_GRE_TTL] = { .type = NLA_U8 },
1718 [IFLA_GRE_TOS] = { .type = NLA_U8 },
1719 [IFLA_GRE_PMTUDISC] = { .type = NLA_U8 },
1720};
1721
1722static struct rtnl_link_ops ipgre_link_ops __read_mostly = {
1723 .kind = "gre",
1724 .maxtype = IFLA_GRE_MAX,
1725 .policy = ipgre_policy,
1726 .priv_size = sizeof(struct ip_tunnel),
1727 .setup = ipgre_tunnel_setup,
1728 .validate = ipgre_tunnel_validate,
1729 .newlink = ipgre_newlink,
1730 .changelink = ipgre_changelink,
1731 .get_size = ipgre_get_size,
1732 .fill_info = ipgre_fill_info,
1733};
1734
Herbert Xue1a80002008-10-09 12:00:17 -07001735static struct rtnl_link_ops ipgre_tap_ops __read_mostly = {
1736 .kind = "gretap",
1737 .maxtype = IFLA_GRE_MAX,
1738 .policy = ipgre_policy,
1739 .priv_size = sizeof(struct ip_tunnel),
1740 .setup = ipgre_tap_setup,
1741 .validate = ipgre_tap_validate,
1742 .newlink = ipgre_newlink,
1743 .changelink = ipgre_changelink,
1744 .get_size = ipgre_get_size,
1745 .fill_info = ipgre_fill_info,
1746};
1747
Linus Torvalds1da177e2005-04-16 15:20:36 -07001748/*
1749 * And now the modules code and kernel interface.
1750 */
1751
1752static int __init ipgre_init(void)
1753{
1754 int err;
1755
Joe Perches058bd4d2012-03-11 18:36:11 +00001756 pr_info("GRE over IPv4 tunneling driver\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001757
Eric W. Biedermancfb8fbf2009-11-29 15:46:13 +00001758 err = register_pernet_device(&ipgre_net_ops);
Pavel Emelyanov59a4c752008-04-16 01:08:53 -07001759 if (err < 0)
Alexey Dobriyanc2892f02010-02-16 07:57:44 +00001760 return err;
1761
Dmitry Kozlov00959ad2010-08-21 23:05:39 -07001762 err = gre_add_protocol(&ipgre_protocol, GREPROTO_CISCO);
Alexey Dobriyanc2892f02010-02-16 07:57:44 +00001763 if (err < 0) {
Joe Perches058bd4d2012-03-11 18:36:11 +00001764 pr_info("%s: can't add protocol\n", __func__);
Alexey Dobriyanc2892f02010-02-16 07:57:44 +00001765 goto add_proto_failed;
1766 }
Pavel Emelyanov7daa0002008-04-16 01:10:05 -07001767
Herbert Xuc19e6542008-10-09 11:59:55 -07001768 err = rtnl_link_register(&ipgre_link_ops);
1769 if (err < 0)
1770 goto rtnl_link_failed;
1771
Herbert Xue1a80002008-10-09 12:00:17 -07001772 err = rtnl_link_register(&ipgre_tap_ops);
1773 if (err < 0)
1774 goto tap_ops_failed;
1775
Herbert Xuc19e6542008-10-09 11:59:55 -07001776out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001777 return err;
Herbert Xuc19e6542008-10-09 11:59:55 -07001778
Herbert Xue1a80002008-10-09 12:00:17 -07001779tap_ops_failed:
1780 rtnl_link_unregister(&ipgre_link_ops);
Herbert Xuc19e6542008-10-09 11:59:55 -07001781rtnl_link_failed:
Dmitry Kozlov00959ad2010-08-21 23:05:39 -07001782 gre_del_protocol(&ipgre_protocol, GREPROTO_CISCO);
Alexey Dobriyanc2892f02010-02-16 07:57:44 +00001783add_proto_failed:
1784 unregister_pernet_device(&ipgre_net_ops);
Herbert Xuc19e6542008-10-09 11:59:55 -07001785 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001786}
1787
Alexey Kuznetsovdb445752005-07-30 17:46:44 -07001788static void __exit ipgre_fini(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001789{
Herbert Xue1a80002008-10-09 12:00:17 -07001790 rtnl_link_unregister(&ipgre_tap_ops);
Herbert Xuc19e6542008-10-09 11:59:55 -07001791 rtnl_link_unregister(&ipgre_link_ops);
Dmitry Kozlov00959ad2010-08-21 23:05:39 -07001792 if (gre_del_protocol(&ipgre_protocol, GREPROTO_CISCO) < 0)
Joe Perches058bd4d2012-03-11 18:36:11 +00001793 pr_info("%s: can't remove protocol\n", __func__);
Alexey Dobriyanc2892f02010-02-16 07:57:44 +00001794 unregister_pernet_device(&ipgre_net_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001795}
1796
1797module_init(ipgre_init);
1798module_exit(ipgre_fini);
1799MODULE_LICENSE("GPL");
Patrick McHardy4d74f8b2008-10-10 12:11:06 -07001800MODULE_ALIAS_RTNL_LINK("gre");
1801MODULE_ALIAS_RTNL_LINK("gretap");
Vasiliy Kulikov8909c9a2011-03-02 00:33:13 +03001802MODULE_ALIAS_NETDEV("gre0");