blob: f49047b796096d1ce8ccd577db04556b576bc120 [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;
519 case ICMP_FRAG_NEEDED:
520 /* Soft state for pmtu is maintained by IP core. */
521 return;
522 default:
523 /* All others are translated to HOST_UNREACH.
524 rfc2003 contains "deep thoughts" about NET_UNREACH,
525 I believe they are just ether pollution. --ANK
526 */
527 break;
528 }
529 break;
530 case ICMP_TIME_EXCEEDED:
531 if (code != ICMP_EXC_TTL)
532 return;
533 break;
534 }
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]);
Joe Perchesf97c1e02007-12-16 13:45:43 -0800541 if (t == NULL || t->parms.iph.daddr == 0 ||
542 ipv4_is_multicast(t->parms.iph.daddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543 goto out;
544
545 if (t->parms.iph.ttl == 0 && type == ICMP_TIME_EXCEEDED)
546 goto out;
547
Wei Yongjunda6185d82009-02-24 23:34:48 -0800548 if (time_before(jiffies, t->err_time + IPTUNNEL_ERR_TIMEO))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549 t->err_count++;
550 else
551 t->err_count = 1;
552 t->err_time = jiffies;
553out:
Eric Dumazet8d5b2c02009-10-23 06:14:38 +0000554 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555}
556
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000557static inline void ipgre_ecn_decapsulate(const struct iphdr *iph, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558{
559 if (INET_ECN_is_ce(iph->tos)) {
560 if (skb->protocol == htons(ETH_P_IP)) {
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700561 IP_ECN_set_ce(ip_hdr(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562 } else if (skb->protocol == htons(ETH_P_IPV6)) {
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700563 IP6_ECN_set_ce(ipv6_hdr(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564 }
565 }
566}
567
568static inline u8
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000569ipgre_ecn_encapsulate(u8 tos, const struct iphdr *old_iph, struct sk_buff *skb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570{
571 u8 inner = 0;
572 if (skb->protocol == htons(ETH_P_IP))
573 inner = old_iph->tos;
574 else if (skb->protocol == htons(ETH_P_IPV6))
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000575 inner = ipv6_get_dsfield((const struct ipv6hdr *)old_iph);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576 return INET_ECN_encapsulate(tos, inner);
577}
578
579static int ipgre_rcv(struct sk_buff *skb)
580{
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000581 const struct iphdr *iph;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582 u8 *h;
Al Virod5a0a1e2006-11-08 00:23:14 -0800583 __be16 flags;
Al Virod3bc23e2006-11-14 21:24:49 -0800584 __sum16 csum = 0;
Al Virod5a0a1e2006-11-08 00:23:14 -0800585 __be32 key = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586 u32 seqno = 0;
587 struct ip_tunnel *tunnel;
588 int offset = 4;
Herbert Xue1a80002008-10-09 12:00:17 -0700589 __be16 gre_proto;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590
591 if (!pskb_may_pull(skb, 16))
592 goto drop_nolock;
593
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700594 iph = ip_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595 h = skb->data;
Daniel Baluta5e73ea12012-04-15 01:34:41 +0000596 flags = *(__be16 *)h;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597
598 if (flags&(GRE_CSUM|GRE_KEY|GRE_ROUTING|GRE_SEQ|GRE_VERSION)) {
599 /* - Version must be 0.
600 - We do not support routing headers.
601 */
602 if (flags&(GRE_VERSION|GRE_ROUTING))
603 goto drop_nolock;
604
605 if (flags&GRE_CSUM) {
Herbert Xufb286bb2005-11-10 13:01:24 -0800606 switch (skb->ip_summed) {
Patrick McHardy84fa7932006-08-29 16:44:56 -0700607 case CHECKSUM_COMPLETE:
Al Virod3bc23e2006-11-14 21:24:49 -0800608 csum = csum_fold(skb->csum);
Herbert Xufb286bb2005-11-10 13:01:24 -0800609 if (!csum)
610 break;
611 /* fall through */
612 case CHECKSUM_NONE:
613 skb->csum = 0;
614 csum = __skb_checksum_complete(skb);
Patrick McHardy84fa7932006-08-29 16:44:56 -0700615 skb->ip_summed = CHECKSUM_COMPLETE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616 }
617 offset += 4;
618 }
619 if (flags&GRE_KEY) {
Daniel Baluta5e73ea12012-04-15 01:34:41 +0000620 key = *(__be32 *)(h + offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621 offset += 4;
622 }
623 if (flags&GRE_SEQ) {
Daniel Baluta5e73ea12012-04-15 01:34:41 +0000624 seqno = ntohl(*(__be32 *)(h + offset));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625 offset += 4;
626 }
627 }
628
Herbert Xue1a80002008-10-09 12:00:17 -0700629 gre_proto = *(__be16 *)(h + 2);
630
Eric Dumazet8d5b2c02009-10-23 06:14:38 +0000631 rcu_read_lock();
Timo Teras749c10f2009-01-19 17:22:12 -0800632 if ((tunnel = ipgre_tunnel_lookup(skb->dev,
Herbert Xue1a80002008-10-09 12:00:17 -0700633 iph->saddr, iph->daddr, key,
634 gre_proto))) {
Eric Dumazete985aad2010-09-27 03:57:11 +0000635 struct pcpu_tstats *tstats;
Pavel Emelyanovaddd68e2008-05-21 14:14:22 -0700636
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637 secpath_reset(skb);
638
Herbert Xue1a80002008-10-09 12:00:17 -0700639 skb->protocol = gre_proto;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640 /* WCCP version 1 and 2 protocol decoding.
641 * - Change protocol to IP
642 * - When dealing with WCCPv2, Skip extra 4 bytes in GRE header
643 */
Herbert Xue1a80002008-10-09 12:00:17 -0700644 if (flags == 0 && gre_proto == htons(ETH_P_WCCP)) {
YOSHIFUJI Hideaki496c98d2006-10-10 19:41:21 -0700645 skb->protocol = htons(ETH_P_IP);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900646 if ((*(h + offset) & 0xF0) != 0x40)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647 offset += 4;
648 }
649
Timo Teras1d069162007-12-20 00:10:33 -0800650 skb->mac_header = skb->network_header;
Arnaldo Carvalho de Melo4209fb62007-03-10 18:42:03 -0300651 __pskb_pull(skb, offset);
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -0700652 skb_postpull_rcsum(skb, skb_transport_header(skb), offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653 skb->pkt_type = PACKET_HOST;
654#ifdef CONFIG_NET_IPGRE_BROADCAST
Joe Perchesf97c1e02007-12-16 13:45:43 -0800655 if (ipv4_is_multicast(iph->daddr)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656 /* Looped back packet, drop it! */
David S. Millerc7537962010-11-11 17:07:48 -0800657 if (rt_is_output_route(skb_rtable(skb)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658 goto drop;
Eric Dumazete985aad2010-09-27 03:57:11 +0000659 tunnel->dev->stats.multicast++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660 skb->pkt_type = PACKET_BROADCAST;
661 }
662#endif
663
664 if (((flags&GRE_CSUM) && csum) ||
665 (!(flags&GRE_CSUM) && tunnel->parms.i_flags&GRE_CSUM)) {
Eric Dumazete985aad2010-09-27 03:57:11 +0000666 tunnel->dev->stats.rx_crc_errors++;
667 tunnel->dev->stats.rx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668 goto drop;
669 }
670 if (tunnel->parms.i_flags&GRE_SEQ) {
671 if (!(flags&GRE_SEQ) ||
672 (tunnel->i_seqno && (s32)(seqno - tunnel->i_seqno) < 0)) {
Eric Dumazete985aad2010-09-27 03:57:11 +0000673 tunnel->dev->stats.rx_fifo_errors++;
674 tunnel->dev->stats.rx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675 goto drop;
676 }
677 tunnel->i_seqno = seqno + 1;
678 }
Herbert Xue1a80002008-10-09 12:00:17 -0700679
680 /* Warning: All skb pointers will be invalidated! */
681 if (tunnel->dev->type == ARPHRD_ETHER) {
682 if (!pskb_may_pull(skb, ETH_HLEN)) {
Eric Dumazete985aad2010-09-27 03:57:11 +0000683 tunnel->dev->stats.rx_length_errors++;
684 tunnel->dev->stats.rx_errors++;
Herbert Xue1a80002008-10-09 12:00:17 -0700685 goto drop;
686 }
687
688 iph = ip_hdr(skb);
689 skb->protocol = eth_type_trans(skb, tunnel->dev);
690 skb_postpull_rcsum(skb, eth_hdr(skb), ETH_HLEN);
691 }
692
Eric Dumazete985aad2010-09-27 03:57:11 +0000693 tstats = this_cpu_ptr(tunnel->dev->tstats);
stephen hemminger87b6d212012-04-12 06:31:16 +0000694 u64_stats_update_begin(&tstats->syncp);
Eric Dumazete985aad2010-09-27 03:57:11 +0000695 tstats->rx_packets++;
696 tstats->rx_bytes += skb->len;
stephen hemminger87b6d212012-04-12 06:31:16 +0000697 u64_stats_update_end(&tstats->syncp);
Eric Dumazete985aad2010-09-27 03:57:11 +0000698
699 __skb_tunnel_rx(skb, tunnel->dev);
Herbert Xue1a80002008-10-09 12:00:17 -0700700
701 skb_reset_network_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702 ipgre_ecn_decapsulate(iph, skb);
Herbert Xue1a80002008-10-09 12:00:17 -0700703
Eric Dumazetcaf586e2010-09-30 21:06:55 +0000704 netif_rx(skb);
Eric Dumazet8990f462010-09-20 00:12:11 +0000705
Eric Dumazet8d5b2c02009-10-23 06:14:38 +0000706 rcu_read_unlock();
Eric Dumazet8990f462010-09-20 00:12:11 +0000707 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708 }
Herbert Xu45af08b2006-04-05 22:31:19 -0700709 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710
711drop:
Eric Dumazet8d5b2c02009-10-23 06:14:38 +0000712 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713drop_nolock:
714 kfree_skb(skb);
Eric Dumazeta02cec22010-09-22 20:43:57 +0000715 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716}
717
Stephen Hemminger6fef4c02009-08-31 19:50:41 +0000718static netdev_tx_t ipgre_tunnel_xmit(struct sk_buff *skb, struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719{
Patrick McHardy2941a482006-01-08 22:05:26 -0800720 struct ip_tunnel *tunnel = netdev_priv(dev);
Eric Dumazete985aad2010-09-27 03:57:11 +0000721 struct pcpu_tstats *tstats;
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000722 const struct iphdr *old_iph = ip_hdr(skb);
723 const struct iphdr *tiph;
David S. Millercbb1e852011-05-04 12:33:34 -0700724 struct flowi4 fl4;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725 u8 tos;
Al Virod5a0a1e2006-11-08 00:23:14 -0800726 __be16 df;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727 struct rtable *rt; /* Route to the other host */
Eric Dumazet15078502010-09-15 11:07:53 +0000728 struct net_device *tdev; /* Device to other host */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700729 struct iphdr *iph; /* Our new IP header */
Chuck Leverc2636b42007-10-23 21:07:32 -0700730 unsigned int max_headroom; /* The extra header space needed */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731 int gre_hlen;
Al Virod5a0a1e2006-11-08 00:23:14 -0800732 __be32 dst;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733 int mtu;
734
Herbert Xue1a80002008-10-09 12:00:17 -0700735 if (dev->type == ARPHRD_ETHER)
736 IPCB(skb)->flags = 0;
737
738 if (dev->header_ops && dev->type == ARPHRD_IPGRE) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739 gre_hlen = 0;
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000740 tiph = (const struct iphdr *)skb->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741 } else {
742 gre_hlen = tunnel->hlen;
743 tiph = &tunnel->parms.iph;
744 }
745
746 if ((dst = tiph->daddr) == 0) {
747 /* NBMA tunnel */
748
Eric Dumazetadf30902009-06-02 05:19:30 +0000749 if (skb_dst(skb) == NULL) {
Eric Dumazete985aad2010-09-27 03:57:11 +0000750 dev->stats.tx_fifo_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751 goto tx_error;
752 }
753
David S. Miller61d57f82012-01-24 18:23:30 -0500754 if (skb->protocol == htons(ETH_P_IP)) {
Eric Dumazet511c3f92009-06-02 05:14:27 +0000755 rt = skb_rtable(skb);
David S. Miller61d57f82012-01-24 18:23:30 -0500756 dst = rt->rt_gateway;
757 }
Eric Dumazetdfd56b82011-12-10 09:48:31 +0000758#if IS_ENABLED(CONFIG_IPV6)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759 else if (skb->protocol == htons(ETH_P_IPV6)) {
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000760 const struct in6_addr *addr6;
David S. Miller0ec88662012-01-27 15:01:08 -0800761 struct neighbour *neigh;
762 bool do_tx_error_icmp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700763 int addr_type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764
David S. Miller0ec88662012-01-27 15:01:08 -0800765 neigh = dst_neigh_lookup(skb_dst(skb), &ipv6_hdr(skb)->daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766 if (neigh == NULL)
767 goto tx_error;
768
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000769 addr6 = (const struct in6_addr *)&neigh->primary_key;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770 addr_type = ipv6_addr_type(addr6);
771
772 if (addr_type == IPV6_ADDR_ANY) {
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700773 addr6 = &ipv6_hdr(skb)->daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774 addr_type = ipv6_addr_type(addr6);
775 }
776
777 if ((addr_type & IPV6_ADDR_COMPATv4) == 0)
David S. Miller0ec88662012-01-27 15:01:08 -0800778 do_tx_error_icmp = true;
779 else {
780 do_tx_error_icmp = false;
781 dst = addr6->s6_addr32[3];
782 }
783 neigh_release(neigh);
784 if (do_tx_error_icmp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785 goto tx_error_icmp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700786 }
787#endif
788 else
789 goto tx_error;
790 }
791
792 tos = tiph->tos;
Andreas Jaggiee686ca2009-07-14 09:35:59 -0700793 if (tos == 1) {
794 tos = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795 if (skb->protocol == htons(ETH_P_IP))
796 tos = old_iph->tos;
Stephen Hemmingerdd4ba832010-07-08 21:35:58 -0700797 else if (skb->protocol == htons(ETH_P_IPV6))
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000798 tos = ipv6_get_dsfield((const struct ipv6hdr *)old_iph);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799 }
800
David S. Millercbb1e852011-05-04 12:33:34 -0700801 rt = ip_route_output_gre(dev_net(dev), &fl4, dst, tiph->saddr,
David S. Miller78fbfd82011-03-12 00:00:52 -0500802 tunnel->parms.o_key, RT_TOS(tos),
803 tunnel->parms.link);
804 if (IS_ERR(rt)) {
805 dev->stats.tx_carrier_errors++;
806 goto tx_error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700807 }
Changli Gaod8d1f302010-06-10 23:31:35 -0700808 tdev = rt->dst.dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700809
810 if (tdev == dev) {
811 ip_rt_put(rt);
Eric Dumazete985aad2010-09-27 03:57:11 +0000812 dev->stats.collisions++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813 goto tx_error;
814 }
815
816 df = tiph->frag_off;
817 if (df)
Changli Gaod8d1f302010-06-10 23:31:35 -0700818 mtu = dst_mtu(&rt->dst) - dev->hard_header_len - tunnel->hlen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700819 else
Eric Dumazetadf30902009-06-02 05:19:30 +0000820 mtu = skb_dst(skb) ? dst_mtu(skb_dst(skb)) : dev->mtu;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821
Eric Dumazetadf30902009-06-02 05:19:30 +0000822 if (skb_dst(skb))
823 skb_dst(skb)->ops->update_pmtu(skb_dst(skb), mtu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824
825 if (skb->protocol == htons(ETH_P_IP)) {
826 df |= (old_iph->frag_off&htons(IP_DF));
827
828 if ((old_iph->frag_off&htons(IP_DF)) &&
829 mtu < ntohs(old_iph->tot_len)) {
830 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED, htonl(mtu));
831 ip_rt_put(rt);
832 goto tx_error;
833 }
834 }
Eric Dumazetdfd56b82011-12-10 09:48:31 +0000835#if IS_ENABLED(CONFIG_IPV6)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700836 else if (skb->protocol == htons(ETH_P_IPV6)) {
Eric Dumazetadf30902009-06-02 05:19:30 +0000837 struct rt6_info *rt6 = (struct rt6_info *)skb_dst(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838
Eric Dumazetadf30902009-06-02 05:19:30 +0000839 if (rt6 && mtu < dst_mtu(skb_dst(skb)) && mtu >= IPV6_MIN_MTU) {
Joe Perchesf97c1e02007-12-16 13:45:43 -0800840 if ((tunnel->parms.iph.daddr &&
841 !ipv4_is_multicast(tunnel->parms.iph.daddr)) ||
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842 rt6->rt6i_dst.plen == 128) {
843 rt6->rt6i_flags |= RTF_MODIFIED;
David S. Millerdefb3512010-12-08 21:16:57 -0800844 dst_metric_set(skb_dst(skb), RTAX_MTU, mtu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700845 }
846 }
847
848 if (mtu >= IPV6_MIN_MTU && mtu < skb->len - tunnel->hlen + gre_hlen) {
Alexey Dobriyan3ffe5332010-02-18 08:25:24 +0000849 icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, mtu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850 ip_rt_put(rt);
851 goto tx_error;
852 }
853 }
854#endif
855
856 if (tunnel->err_count > 0) {
Wei Yongjunda6185d82009-02-24 23:34:48 -0800857 if (time_before(jiffies,
858 tunnel->err_time + IPTUNNEL_ERR_TIMEO)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700859 tunnel->err_count--;
860
861 dst_link_failure(skb);
862 } else
863 tunnel->err_count = 0;
864 }
865
Changli Gaod8d1f302010-06-10 23:31:35 -0700866 max_headroom = LL_RESERVED_SPACE(tdev) + gre_hlen + rt->dst.header_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867
Patrick McHardycfbba492007-07-09 15:33:40 -0700868 if (skb_headroom(skb) < max_headroom || skb_shared(skb)||
869 (skb_cloned(skb) && !skb_clone_writable(skb, 0))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870 struct sk_buff *new_skb = skb_realloc_headroom(skb, max_headroom);
Herbert Xu805dc1d2011-11-18 02:20:06 +0000871 if (max_headroom > dev->needed_headroom)
872 dev->needed_headroom = max_headroom;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700873 if (!new_skb) {
874 ip_rt_put(rt);
Eric Dumazete985aad2010-09-27 03:57:11 +0000875 dev->stats.tx_dropped++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700876 dev_kfree_skb(skb);
Patrick McHardy6ed10652009-06-23 06:03:08 +0000877 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700878 }
879 if (skb->sk)
880 skb_set_owner_w(new_skb, skb->sk);
881 dev_kfree_skb(skb);
882 skb = new_skb;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700883 old_iph = ip_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700884 }
885
Herbert Xu64194c32008-10-09 12:03:17 -0700886 skb_reset_transport_header(skb);
Arnaldo Carvalho de Meloe2d1bca2007-04-10 20:46:21 -0700887 skb_push(skb, gre_hlen);
888 skb_reset_network_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700889 memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
Patrick McHardy48d5cad2006-02-15 15:10:22 -0800890 IPCB(skb)->flags &= ~(IPSKB_XFRM_TUNNEL_SIZE | IPSKB_XFRM_TRANSFORMED |
891 IPSKB_REROUTED);
Eric Dumazetadf30902009-06-02 05:19:30 +0000892 skb_dst_drop(skb);
Changli Gaod8d1f302010-06-10 23:31:35 -0700893 skb_dst_set(skb, &rt->dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700894
895 /*
896 * Push down and install the IPIP header.
897 */
898
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700899 iph = ip_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700900 iph->version = 4;
901 iph->ihl = sizeof(struct iphdr) >> 2;
902 iph->frag_off = df;
903 iph->protocol = IPPROTO_GRE;
904 iph->tos = ipgre_ecn_encapsulate(tos, old_iph, skb);
David S. Millercbb1e852011-05-04 12:33:34 -0700905 iph->daddr = fl4.daddr;
906 iph->saddr = fl4.saddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700907
908 if ((iph->ttl = tiph->ttl) == 0) {
909 if (skb->protocol == htons(ETH_P_IP))
910 iph->ttl = old_iph->ttl;
Eric Dumazetdfd56b82011-12-10 09:48:31 +0000911#if IS_ENABLED(CONFIG_IPV6)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700912 else if (skb->protocol == htons(ETH_P_IPV6))
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000913 iph->ttl = ((const struct ipv6hdr *)old_iph)->hop_limit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700914#endif
915 else
David S. Miller323e1262010-12-12 21:55:08 -0800916 iph->ttl = ip4_dst_hoplimit(&rt->dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700917 }
918
Herbert Xue1a80002008-10-09 12:00:17 -0700919 ((__be16 *)(iph + 1))[0] = tunnel->parms.o_flags;
920 ((__be16 *)(iph + 1))[1] = (dev->type == ARPHRD_ETHER) ?
921 htons(ETH_P_TEB) : skb->protocol;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700922
923 if (tunnel->parms.o_flags&(GRE_KEY|GRE_CSUM|GRE_SEQ)) {
Daniel Baluta5e73ea12012-04-15 01:34:41 +0000924 __be32 *ptr = (__be32 *)(((u8 *)iph) + tunnel->hlen - 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700925
926 if (tunnel->parms.o_flags&GRE_SEQ) {
927 ++tunnel->o_seqno;
928 *ptr = htonl(tunnel->o_seqno);
929 ptr--;
930 }
931 if (tunnel->parms.o_flags&GRE_KEY) {
932 *ptr = tunnel->parms.o_key;
933 ptr--;
934 }
935 if (tunnel->parms.o_flags&GRE_CSUM) {
936 *ptr = 0;
Daniel Baluta5e73ea12012-04-15 01:34:41 +0000937 *(__sum16 *)ptr = ip_compute_csum((void *)(iph+1), skb->len - sizeof(struct iphdr));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700938 }
939 }
940
941 nf_reset(skb);
Eric Dumazete985aad2010-09-27 03:57:11 +0000942 tstats = this_cpu_ptr(dev->tstats);
943 __IPTUNNEL_XMIT(tstats, &dev->stats);
Patrick McHardy6ed10652009-06-23 06:03:08 +0000944 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945
David S. Miller496053f2012-01-11 16:46:32 -0800946#if IS_ENABLED(CONFIG_IPV6)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700947tx_error_icmp:
948 dst_link_failure(skb);
David S. Miller496053f2012-01-11 16:46:32 -0800949#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700950tx_error:
Eric Dumazete985aad2010-09-27 03:57:11 +0000951 dev->stats.tx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700952 dev_kfree_skb(skb);
Patrick McHardy6ed10652009-06-23 06:03:08 +0000953 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700954}
955
Herbert Xu42aa9162008-10-09 11:59:32 -0700956static int ipgre_tunnel_bind_dev(struct net_device *dev)
Michal Schmidtee34c1e2007-12-13 09:46:32 -0800957{
958 struct net_device *tdev = NULL;
959 struct ip_tunnel *tunnel;
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000960 const struct iphdr *iph;
Michal Schmidtee34c1e2007-12-13 09:46:32 -0800961 int hlen = LL_MAX_HEADER;
962 int mtu = ETH_DATA_LEN;
963 int addend = sizeof(struct iphdr) + 4;
964
965 tunnel = netdev_priv(dev);
966 iph = &tunnel->parms.iph;
967
Herbert Xuc95b8192008-10-09 11:58:54 -0700968 /* Guess output device to choose reasonable mtu and needed_headroom */
Michal Schmidtee34c1e2007-12-13 09:46:32 -0800969
970 if (iph->daddr) {
David S. Millercbb1e852011-05-04 12:33:34 -0700971 struct flowi4 fl4;
972 struct rtable *rt;
Eric Dumazete985aad2010-09-27 03:57:11 +0000973
David S. Millercbb1e852011-05-04 12:33:34 -0700974 rt = ip_route_output_gre(dev_net(dev), &fl4,
975 iph->daddr, iph->saddr,
976 tunnel->parms.o_key,
977 RT_TOS(iph->tos),
978 tunnel->parms.link);
David S. Millerb23dd4f2011-03-02 14:31:35 -0800979 if (!IS_ERR(rt)) {
Changli Gaod8d1f302010-06-10 23:31:35 -0700980 tdev = rt->dst.dev;
Michal Schmidtee34c1e2007-12-13 09:46:32 -0800981 ip_rt_put(rt);
982 }
Herbert Xue1a80002008-10-09 12:00:17 -0700983
984 if (dev->type != ARPHRD_ETHER)
985 dev->flags |= IFF_POINTOPOINT;
Michal Schmidtee34c1e2007-12-13 09:46:32 -0800986 }
987
988 if (!tdev && tunnel->parms.link)
Pavel Emelyanov96635522008-04-16 01:10:44 -0700989 tdev = __dev_get_by_index(dev_net(dev), tunnel->parms.link);
Michal Schmidtee34c1e2007-12-13 09:46:32 -0800990
991 if (tdev) {
Herbert Xuc95b8192008-10-09 11:58:54 -0700992 hlen = tdev->hard_header_len + tdev->needed_headroom;
Michal Schmidtee34c1e2007-12-13 09:46:32 -0800993 mtu = tdev->mtu;
994 }
995 dev->iflink = tunnel->parms.link;
996
997 /* Precalculate GRE options length */
998 if (tunnel->parms.o_flags&(GRE_CSUM|GRE_KEY|GRE_SEQ)) {
999 if (tunnel->parms.o_flags&GRE_CSUM)
1000 addend += 4;
1001 if (tunnel->parms.o_flags&GRE_KEY)
1002 addend += 4;
1003 if (tunnel->parms.o_flags&GRE_SEQ)
1004 addend += 4;
1005 }
Herbert Xuc95b8192008-10-09 11:58:54 -07001006 dev->needed_headroom = addend + hlen;
Tom Goff8cdb0452009-08-14 16:33:56 -07001007 mtu -= dev->hard_header_len + addend;
Herbert Xu42aa9162008-10-09 11:59:32 -07001008
1009 if (mtu < 68)
1010 mtu = 68;
1011
Michal Schmidtee34c1e2007-12-13 09:46:32 -08001012 tunnel->hlen = addend;
1013
Herbert Xu42aa9162008-10-09 11:59:32 -07001014 return mtu;
Michal Schmidtee34c1e2007-12-13 09:46:32 -08001015}
1016
Linus Torvalds1da177e2005-04-16 15:20:36 -07001017static int
1018ipgre_tunnel_ioctl (struct net_device *dev, struct ifreq *ifr, int cmd)
1019{
1020 int err = 0;
1021 struct ip_tunnel_parm p;
1022 struct ip_tunnel *t;
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -07001023 struct net *net = dev_net(dev);
1024 struct ipgre_net *ign = net_generic(net, ipgre_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001025
1026 switch (cmd) {
1027 case SIOCGETTUNNEL:
1028 t = NULL;
Pavel Emelyanov7daa0002008-04-16 01:10:05 -07001029 if (dev == ign->fb_tunnel_dev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001030 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p))) {
1031 err = -EFAULT;
1032 break;
1033 }
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -07001034 t = ipgre_tunnel_locate(net, &p, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001035 }
1036 if (t == NULL)
Patrick McHardy2941a482006-01-08 22:05:26 -08001037 t = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001038 memcpy(&p, &t->parms, sizeof(p));
1039 if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p)))
1040 err = -EFAULT;
1041 break;
1042
1043 case SIOCADDTUNNEL:
1044 case SIOCCHGTUNNEL:
1045 err = -EPERM;
1046 if (!capable(CAP_NET_ADMIN))
1047 goto done;
1048
1049 err = -EFAULT;
1050 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
1051 goto done;
1052
1053 err = -EINVAL;
1054 if (p.iph.version != 4 || p.iph.protocol != IPPROTO_GRE ||
1055 p.iph.ihl != 5 || (p.iph.frag_off&htons(~IP_DF)) ||
1056 ((p.i_flags|p.o_flags)&(GRE_VERSION|GRE_ROUTING)))
1057 goto done;
1058 if (p.iph.ttl)
1059 p.iph.frag_off |= htons(IP_DF);
1060
1061 if (!(p.i_flags&GRE_KEY))
1062 p.i_key = 0;
1063 if (!(p.o_flags&GRE_KEY))
1064 p.o_key = 0;
1065
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -07001066 t = ipgre_tunnel_locate(net, &p, cmd == SIOCADDTUNNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001067
Pavel Emelyanov7daa0002008-04-16 01:10:05 -07001068 if (dev != ign->fb_tunnel_dev && cmd == SIOCCHGTUNNEL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001069 if (t != NULL) {
1070 if (t->dev != dev) {
1071 err = -EEXIST;
1072 break;
1073 }
1074 } else {
Eric Dumazet15078502010-09-15 11:07:53 +00001075 unsigned int nflags = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001076
Patrick McHardy2941a482006-01-08 22:05:26 -08001077 t = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001078
Joe Perchesf97c1e02007-12-16 13:45:43 -08001079 if (ipv4_is_multicast(p.iph.daddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001080 nflags = IFF_BROADCAST;
1081 else if (p.iph.daddr)
1082 nflags = IFF_POINTOPOINT;
1083
1084 if ((dev->flags^nflags)&(IFF_POINTOPOINT|IFF_BROADCAST)) {
1085 err = -EINVAL;
1086 break;
1087 }
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -07001088 ipgre_tunnel_unlink(ign, t);
Pavel Emelyanov74b0b852010-10-27 05:43:53 +00001089 synchronize_net();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001090 t->parms.iph.saddr = p.iph.saddr;
1091 t->parms.iph.daddr = p.iph.daddr;
1092 t->parms.i_key = p.i_key;
1093 t->parms.o_key = p.o_key;
1094 memcpy(dev->dev_addr, &p.iph.saddr, 4);
1095 memcpy(dev->broadcast, &p.iph.daddr, 4);
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -07001096 ipgre_tunnel_link(ign, t);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001097 netdev_state_change(dev);
1098 }
1099 }
1100
1101 if (t) {
1102 err = 0;
1103 if (cmd == SIOCCHGTUNNEL) {
1104 t->parms.iph.ttl = p.iph.ttl;
1105 t->parms.iph.tos = p.iph.tos;
1106 t->parms.iph.frag_off = p.iph.frag_off;
Michal Schmidtee34c1e2007-12-13 09:46:32 -08001107 if (t->parms.link != p.link) {
1108 t->parms.link = p.link;
Herbert Xu42aa9162008-10-09 11:59:32 -07001109 dev->mtu = ipgre_tunnel_bind_dev(dev);
Michal Schmidtee34c1e2007-12-13 09:46:32 -08001110 netdev_state_change(dev);
1111 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001112 }
1113 if (copy_to_user(ifr->ifr_ifru.ifru_data, &t->parms, sizeof(p)))
1114 err = -EFAULT;
1115 } else
1116 err = (cmd == SIOCADDTUNNEL ? -ENOBUFS : -ENOENT);
1117 break;
1118
1119 case SIOCDELTUNNEL:
1120 err = -EPERM;
1121 if (!capable(CAP_NET_ADMIN))
1122 goto done;
1123
Pavel Emelyanov7daa0002008-04-16 01:10:05 -07001124 if (dev == ign->fb_tunnel_dev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001125 err = -EFAULT;
1126 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
1127 goto done;
1128 err = -ENOENT;
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -07001129 if ((t = ipgre_tunnel_locate(net, &p, 0)) == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130 goto done;
1131 err = -EPERM;
Pavel Emelyanov7daa0002008-04-16 01:10:05 -07001132 if (t == netdev_priv(ign->fb_tunnel_dev))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001133 goto done;
1134 dev = t->dev;
1135 }
Stephen Hemminger22f8cde2007-02-07 00:09:58 -08001136 unregister_netdevice(dev);
1137 err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001138 break;
1139
1140 default:
1141 err = -EINVAL;
1142 }
1143
1144done:
1145 return err;
1146}
1147
Linus Torvalds1da177e2005-04-16 15:20:36 -07001148static int ipgre_tunnel_change_mtu(struct net_device *dev, int new_mtu)
1149{
Patrick McHardy2941a482006-01-08 22:05:26 -08001150 struct ip_tunnel *tunnel = netdev_priv(dev);
Herbert Xuc95b8192008-10-09 11:58:54 -07001151 if (new_mtu < 68 ||
1152 new_mtu > 0xFFF8 - dev->hard_header_len - tunnel->hlen)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001153 return -EINVAL;
1154 dev->mtu = new_mtu;
1155 return 0;
1156}
1157
Linus Torvalds1da177e2005-04-16 15:20:36 -07001158/* Nice toy. Unfortunately, useless in real life :-)
1159 It allows to construct virtual multiprotocol broadcast "LAN"
1160 over the Internet, provided multicast routing is tuned.
1161
1162
1163 I have no idea was this bicycle invented before me,
1164 so that I had to set ARPHRD_IPGRE to a random value.
1165 I have an impression, that Cisco could make something similar,
1166 but this feature is apparently missing in IOS<=11.2(8).
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001167
Linus Torvalds1da177e2005-04-16 15:20:36 -07001168 I set up 10.66.66/24 and fec0:6666:6666::0/96 as virtual networks
1169 with broadcast 224.66.66.66. If you have access to mbone, play with me :-)
1170
1171 ping -t 255 224.66.66.66
1172
1173 If nobody answers, mbone does not work.
1174
1175 ip tunnel add Universe mode gre remote 224.66.66.66 local <Your_real_addr> ttl 255
1176 ip addr add 10.66.66.<somewhat>/24 dev Universe
1177 ifconfig Universe up
1178 ifconfig Universe add fe80::<Your_real_addr>/10
1179 ifconfig Universe add fec0:6666:6666::<Your_real_addr>/96
1180 ftp 10.66.66.66
1181 ...
1182 ftp fec0:6666:6666::193.233.7.65
1183 ...
1184
1185 */
1186
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -07001187static int ipgre_header(struct sk_buff *skb, struct net_device *dev,
1188 unsigned short type,
Eric Dumazet15078502010-09-15 11:07:53 +00001189 const void *daddr, const void *saddr, unsigned int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001190{
Patrick McHardy2941a482006-01-08 22:05:26 -08001191 struct ip_tunnel *t = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001192 struct iphdr *iph = (struct iphdr *)skb_push(skb, t->hlen);
Daniel Baluta5e73ea12012-04-15 01:34:41 +00001193 __be16 *p = (__be16 *)(iph+1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001194
1195 memcpy(iph, &t->parms.iph, sizeof(struct iphdr));
1196 p[0] = t->parms.o_flags;
1197 p[1] = htons(type);
1198
1199 /*
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001200 * Set the source hardware address.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001201 */
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001202
Linus Torvalds1da177e2005-04-16 15:20:36 -07001203 if (saddr)
1204 memcpy(&iph->saddr, saddr, 4);
Timo Teräs6d55cb92010-03-03 04:01:13 +00001205 if (daddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001206 memcpy(&iph->daddr, daddr, 4);
Timo Teräs6d55cb92010-03-03 04:01:13 +00001207 if (iph->daddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001208 return t->hlen;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001209
Linus Torvalds1da177e2005-04-16 15:20:36 -07001210 return -t->hlen;
1211}
1212
Timo Teras6a5f44d2007-10-23 20:31:53 -07001213static int ipgre_header_parse(const struct sk_buff *skb, unsigned char *haddr)
1214{
Eric Dumazetb71d1d42011-04-22 04:53:02 +00001215 const struct iphdr *iph = (const struct iphdr *) skb_mac_header(skb);
Timo Teras6a5f44d2007-10-23 20:31:53 -07001216 memcpy(haddr, &iph->saddr, 4);
1217 return 4;
1218}
1219
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -07001220static const struct header_ops ipgre_header_ops = {
1221 .create = ipgre_header,
Timo Teras6a5f44d2007-10-23 20:31:53 -07001222 .parse = ipgre_header_parse,
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -07001223};
1224
Timo Teras6a5f44d2007-10-23 20:31:53 -07001225#ifdef CONFIG_NET_IPGRE_BROADCAST
Linus Torvalds1da177e2005-04-16 15:20:36 -07001226static int ipgre_open(struct net_device *dev)
1227{
Patrick McHardy2941a482006-01-08 22:05:26 -08001228 struct ip_tunnel *t = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001229
Joe Perchesf97c1e02007-12-16 13:45:43 -08001230 if (ipv4_is_multicast(t->parms.iph.daddr)) {
David S. Millercbb1e852011-05-04 12:33:34 -07001231 struct flowi4 fl4;
1232 struct rtable *rt;
Eric Dumazete985aad2010-09-27 03:57:11 +00001233
David S. Millercbb1e852011-05-04 12:33:34 -07001234 rt = ip_route_output_gre(dev_net(dev), &fl4,
1235 t->parms.iph.daddr,
1236 t->parms.iph.saddr,
1237 t->parms.o_key,
1238 RT_TOS(t->parms.iph.tos),
1239 t->parms.link);
David S. Millerb23dd4f2011-03-02 14:31:35 -08001240 if (IS_ERR(rt))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001241 return -EADDRNOTAVAIL;
Changli Gaod8d1f302010-06-10 23:31:35 -07001242 dev = rt->dst.dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001243 ip_rt_put(rt);
Herbert Xue5ed6392005-10-03 14:35:55 -07001244 if (__in_dev_get_rtnl(dev) == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001245 return -EADDRNOTAVAIL;
1246 t->mlink = dev->ifindex;
Herbert Xue5ed6392005-10-03 14:35:55 -07001247 ip_mc_inc_group(__in_dev_get_rtnl(dev), t->parms.iph.daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001248 }
1249 return 0;
1250}
1251
1252static int ipgre_close(struct net_device *dev)
1253{
Patrick McHardy2941a482006-01-08 22:05:26 -08001254 struct ip_tunnel *t = netdev_priv(dev);
Stephen Hemmingerb8c26a32008-11-20 20:34:29 -08001255
Joe Perchesf97c1e02007-12-16 13:45:43 -08001256 if (ipv4_is_multicast(t->parms.iph.daddr) && t->mlink) {
Denis V. Lunev7fee0ca2008-01-21 17:32:38 -08001257 struct in_device *in_dev;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001258 in_dev = inetdev_by_index(dev_net(dev), t->mlink);
Eric Dumazet8723e1b2010-10-19 00:39:26 +00001259 if (in_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001260 ip_mc_dec_group(in_dev, t->parms.iph.daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001261 }
1262 return 0;
1263}
1264
1265#endif
1266
Stephen Hemmingerb8c26a32008-11-20 20:34:29 -08001267static const struct net_device_ops ipgre_netdev_ops = {
1268 .ndo_init = ipgre_tunnel_init,
1269 .ndo_uninit = ipgre_tunnel_uninit,
1270#ifdef CONFIG_NET_IPGRE_BROADCAST
1271 .ndo_open = ipgre_open,
1272 .ndo_stop = ipgre_close,
1273#endif
1274 .ndo_start_xmit = ipgre_tunnel_xmit,
1275 .ndo_do_ioctl = ipgre_tunnel_ioctl,
1276 .ndo_change_mtu = ipgre_tunnel_change_mtu,
stephen hemminger87b6d212012-04-12 06:31:16 +00001277 .ndo_get_stats64 = ipgre_get_stats64,
Stephen Hemmingerb8c26a32008-11-20 20:34:29 -08001278};
1279
Eric Dumazete985aad2010-09-27 03:57:11 +00001280static void ipgre_dev_free(struct net_device *dev)
1281{
1282 free_percpu(dev->tstats);
1283 free_netdev(dev);
1284}
1285
Linus Torvalds1da177e2005-04-16 15:20:36 -07001286static void ipgre_tunnel_setup(struct net_device *dev)
1287{
Stephen Hemmingerb8c26a32008-11-20 20:34:29 -08001288 dev->netdev_ops = &ipgre_netdev_ops;
Eric Dumazete985aad2010-09-27 03:57:11 +00001289 dev->destructor = ipgre_dev_free;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001290
1291 dev->type = ARPHRD_IPGRE;
Herbert Xuc95b8192008-10-09 11:58:54 -07001292 dev->needed_headroom = LL_MAX_HEADER + sizeof(struct iphdr) + 4;
Kris Katterjohn46f25df2006-01-05 16:35:42 -08001293 dev->mtu = ETH_DATA_LEN - sizeof(struct iphdr) - 4;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001294 dev->flags = IFF_NOARP;
1295 dev->iflink = 0;
1296 dev->addr_len = 4;
Pavel Emelyanov0b67ece2008-04-16 01:11:13 -07001297 dev->features |= NETIF_F_NETNS_LOCAL;
Eric Dumazet108bfa82009-05-28 22:35:10 +00001298 dev->priv_flags &= ~IFF_XMIT_DST_RELEASE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001299}
1300
1301static int ipgre_tunnel_init(struct net_device *dev)
1302{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001303 struct ip_tunnel *tunnel;
1304 struct iphdr *iph;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001305
Patrick McHardy2941a482006-01-08 22:05:26 -08001306 tunnel = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001307 iph = &tunnel->parms.iph;
1308
1309 tunnel->dev = dev;
1310 strcpy(tunnel->parms.name, dev->name);
1311
1312 memcpy(dev->dev_addr, &tunnel->parms.iph.saddr, 4);
1313 memcpy(dev->broadcast, &tunnel->parms.iph.daddr, 4);
1314
Linus Torvalds1da177e2005-04-16 15:20:36 -07001315 if (iph->daddr) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001316#ifdef CONFIG_NET_IPGRE_BROADCAST
Joe Perchesf97c1e02007-12-16 13:45:43 -08001317 if (ipv4_is_multicast(iph->daddr)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001318 if (!iph->saddr)
1319 return -EINVAL;
1320 dev->flags = IFF_BROADCAST;
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -07001321 dev->header_ops = &ipgre_header_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001322 }
1323#endif
Michal Schmidtee34c1e2007-12-13 09:46:32 -08001324 } else
Timo Teras6a5f44d2007-10-23 20:31:53 -07001325 dev->header_ops = &ipgre_header_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001326
Eric Dumazete985aad2010-09-27 03:57:11 +00001327 dev->tstats = alloc_percpu(struct pcpu_tstats);
1328 if (!dev->tstats)
1329 return -ENOMEM;
1330
Linus Torvalds1da177e2005-04-16 15:20:36 -07001331 return 0;
1332}
1333
Stephen Hemmingerb8c26a32008-11-20 20:34:29 -08001334static void ipgre_fb_tunnel_init(struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001335{
Patrick McHardy2941a482006-01-08 22:05:26 -08001336 struct ip_tunnel *tunnel = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001337 struct iphdr *iph = &tunnel->parms.iph;
1338
1339 tunnel->dev = dev;
1340 strcpy(tunnel->parms.name, dev->name);
1341
1342 iph->version = 4;
1343 iph->protocol = IPPROTO_GRE;
1344 iph->ihl = 5;
1345 tunnel->hlen = sizeof(struct iphdr) + 4;
1346
1347 dev_hold(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001348}
1349
1350
Dmitry Kozlov00959ad2010-08-21 23:05:39 -07001351static const struct gre_protocol ipgre_protocol = {
1352 .handler = ipgre_rcv,
1353 .err_handler = ipgre_err,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001354};
1355
Eric Dumazeteef6dd62009-10-27 07:07:16 +00001356static void ipgre_destroy_tunnels(struct ipgre_net *ign, struct list_head *head)
Pavel Emelyanoveb8ce742008-04-16 01:10:26 -07001357{
1358 int prio;
1359
1360 for (prio = 0; prio < 4; prio++) {
1361 int h;
1362 for (h = 0; h < HASH_SIZE; h++) {
Eric Dumazet15078502010-09-15 11:07:53 +00001363 struct ip_tunnel *t;
1364
1365 t = rtnl_dereference(ign->tunnels[prio][h]);
Eric Dumazeteef6dd62009-10-27 07:07:16 +00001366
1367 while (t != NULL) {
1368 unregister_netdevice_queue(t->dev, head);
Eric Dumazet15078502010-09-15 11:07:53 +00001369 t = rtnl_dereference(t->next);
Eric Dumazeteef6dd62009-10-27 07:07:16 +00001370 }
Pavel Emelyanoveb8ce742008-04-16 01:10:26 -07001371 }
1372 }
1373}
1374
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00001375static int __net_init ipgre_init_net(struct net *net)
Pavel Emelyanov59a4c752008-04-16 01:08:53 -07001376{
Eric W. Biedermancfb8fbf2009-11-29 15:46:13 +00001377 struct ipgre_net *ign = net_generic(net, ipgre_net_id);
Pavel Emelyanov59a4c752008-04-16 01:08:53 -07001378 int err;
Pavel Emelyanov59a4c752008-04-16 01:08:53 -07001379
Pavel Emelyanov7daa0002008-04-16 01:10:05 -07001380 ign->fb_tunnel_dev = alloc_netdev(sizeof(struct ip_tunnel), "gre0",
1381 ipgre_tunnel_setup);
1382 if (!ign->fb_tunnel_dev) {
1383 err = -ENOMEM;
1384 goto err_alloc_dev;
1385 }
Alexey Dobriyanbe77e592008-11-23 17:26:26 -08001386 dev_net_set(ign->fb_tunnel_dev, net);
Pavel Emelyanov7daa0002008-04-16 01:10:05 -07001387
Stephen Hemmingerb8c26a32008-11-20 20:34:29 -08001388 ipgre_fb_tunnel_init(ign->fb_tunnel_dev);
Herbert Xuc19e6542008-10-09 11:59:55 -07001389 ign->fb_tunnel_dev->rtnl_link_ops = &ipgre_link_ops;
Pavel Emelyanov7daa0002008-04-16 01:10:05 -07001390
1391 if ((err = register_netdev(ign->fb_tunnel_dev)))
1392 goto err_reg_dev;
1393
Eric Dumazet3285ee32010-10-30 16:21:28 -07001394 rcu_assign_pointer(ign->tunnels_wc[0],
1395 netdev_priv(ign->fb_tunnel_dev));
Pavel Emelyanov59a4c752008-04-16 01:08:53 -07001396 return 0;
1397
Pavel Emelyanov7daa0002008-04-16 01:10:05 -07001398err_reg_dev:
Eric Dumazet3285ee32010-10-30 16:21:28 -07001399 ipgre_dev_free(ign->fb_tunnel_dev);
Pavel Emelyanov7daa0002008-04-16 01:10:05 -07001400err_alloc_dev:
Pavel Emelyanov59a4c752008-04-16 01:08:53 -07001401 return err;
1402}
1403
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00001404static void __net_exit ipgre_exit_net(struct net *net)
Pavel Emelyanov59a4c752008-04-16 01:08:53 -07001405{
1406 struct ipgre_net *ign;
Eric Dumazeteef6dd62009-10-27 07:07:16 +00001407 LIST_HEAD(list);
Pavel Emelyanov59a4c752008-04-16 01:08:53 -07001408
1409 ign = net_generic(net, ipgre_net_id);
Pavel Emelyanov7daa0002008-04-16 01:10:05 -07001410 rtnl_lock();
Eric Dumazeteef6dd62009-10-27 07:07:16 +00001411 ipgre_destroy_tunnels(ign, &list);
1412 unregister_netdevice_many(&list);
Pavel Emelyanov7daa0002008-04-16 01:10:05 -07001413 rtnl_unlock();
Pavel Emelyanov59a4c752008-04-16 01:08:53 -07001414}
1415
1416static struct pernet_operations ipgre_net_ops = {
1417 .init = ipgre_init_net,
1418 .exit = ipgre_exit_net,
Eric W. Biedermancfb8fbf2009-11-29 15:46:13 +00001419 .id = &ipgre_net_id,
1420 .size = sizeof(struct ipgre_net),
Pavel Emelyanov59a4c752008-04-16 01:08:53 -07001421};
Linus Torvalds1da177e2005-04-16 15:20:36 -07001422
Herbert Xuc19e6542008-10-09 11:59:55 -07001423static int ipgre_tunnel_validate(struct nlattr *tb[], struct nlattr *data[])
1424{
1425 __be16 flags;
1426
1427 if (!data)
1428 return 0;
1429
1430 flags = 0;
1431 if (data[IFLA_GRE_IFLAGS])
1432 flags |= nla_get_be16(data[IFLA_GRE_IFLAGS]);
1433 if (data[IFLA_GRE_OFLAGS])
1434 flags |= nla_get_be16(data[IFLA_GRE_OFLAGS]);
1435 if (flags & (GRE_VERSION|GRE_ROUTING))
1436 return -EINVAL;
1437
1438 return 0;
1439}
1440
Herbert Xue1a80002008-10-09 12:00:17 -07001441static int ipgre_tap_validate(struct nlattr *tb[], struct nlattr *data[])
1442{
1443 __be32 daddr;
1444
1445 if (tb[IFLA_ADDRESS]) {
1446 if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
1447 return -EINVAL;
1448 if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
1449 return -EADDRNOTAVAIL;
1450 }
1451
1452 if (!data)
1453 goto out;
1454
1455 if (data[IFLA_GRE_REMOTE]) {
1456 memcpy(&daddr, nla_data(data[IFLA_GRE_REMOTE]), 4);
1457 if (!daddr)
1458 return -EINVAL;
1459 }
1460
1461out:
1462 return ipgre_tunnel_validate(tb, data);
1463}
1464
Herbert Xuc19e6542008-10-09 11:59:55 -07001465static void ipgre_netlink_parms(struct nlattr *data[],
1466 struct ip_tunnel_parm *parms)
1467{
Herbert Xu7bb82d92008-10-11 12:20:15 -07001468 memset(parms, 0, sizeof(*parms));
Herbert Xuc19e6542008-10-09 11:59:55 -07001469
1470 parms->iph.protocol = IPPROTO_GRE;
1471
1472 if (!data)
1473 return;
1474
1475 if (data[IFLA_GRE_LINK])
1476 parms->link = nla_get_u32(data[IFLA_GRE_LINK]);
1477
1478 if (data[IFLA_GRE_IFLAGS])
1479 parms->i_flags = nla_get_be16(data[IFLA_GRE_IFLAGS]);
1480
1481 if (data[IFLA_GRE_OFLAGS])
1482 parms->o_flags = nla_get_be16(data[IFLA_GRE_OFLAGS]);
1483
1484 if (data[IFLA_GRE_IKEY])
1485 parms->i_key = nla_get_be32(data[IFLA_GRE_IKEY]);
1486
1487 if (data[IFLA_GRE_OKEY])
1488 parms->o_key = nla_get_be32(data[IFLA_GRE_OKEY]);
1489
1490 if (data[IFLA_GRE_LOCAL])
Patrick McHardy4d74f8b2008-10-10 12:11:06 -07001491 parms->iph.saddr = nla_get_be32(data[IFLA_GRE_LOCAL]);
Herbert Xuc19e6542008-10-09 11:59:55 -07001492
1493 if (data[IFLA_GRE_REMOTE])
Patrick McHardy4d74f8b2008-10-10 12:11:06 -07001494 parms->iph.daddr = nla_get_be32(data[IFLA_GRE_REMOTE]);
Herbert Xuc19e6542008-10-09 11:59:55 -07001495
1496 if (data[IFLA_GRE_TTL])
1497 parms->iph.ttl = nla_get_u8(data[IFLA_GRE_TTL]);
1498
1499 if (data[IFLA_GRE_TOS])
1500 parms->iph.tos = nla_get_u8(data[IFLA_GRE_TOS]);
1501
1502 if (!data[IFLA_GRE_PMTUDISC] || nla_get_u8(data[IFLA_GRE_PMTUDISC]))
1503 parms->iph.frag_off = htons(IP_DF);
1504}
1505
Herbert Xue1a80002008-10-09 12:00:17 -07001506static int ipgre_tap_init(struct net_device *dev)
1507{
1508 struct ip_tunnel *tunnel;
1509
1510 tunnel = netdev_priv(dev);
1511
1512 tunnel->dev = dev;
1513 strcpy(tunnel->parms.name, dev->name);
1514
1515 ipgre_tunnel_bind_dev(dev);
1516
Eric Dumazete985aad2010-09-27 03:57:11 +00001517 dev->tstats = alloc_percpu(struct pcpu_tstats);
1518 if (!dev->tstats)
1519 return -ENOMEM;
1520
Herbert Xue1a80002008-10-09 12:00:17 -07001521 return 0;
1522}
1523
Stephen Hemmingerb8c26a32008-11-20 20:34:29 -08001524static const struct net_device_ops ipgre_tap_netdev_ops = {
1525 .ndo_init = ipgre_tap_init,
1526 .ndo_uninit = ipgre_tunnel_uninit,
1527 .ndo_start_xmit = ipgre_tunnel_xmit,
1528 .ndo_set_mac_address = eth_mac_addr,
1529 .ndo_validate_addr = eth_validate_addr,
1530 .ndo_change_mtu = ipgre_tunnel_change_mtu,
stephen hemminger87b6d212012-04-12 06:31:16 +00001531 .ndo_get_stats64 = ipgre_get_stats64,
Stephen Hemmingerb8c26a32008-11-20 20:34:29 -08001532};
1533
Herbert Xue1a80002008-10-09 12:00:17 -07001534static void ipgre_tap_setup(struct net_device *dev)
1535{
1536
1537 ether_setup(dev);
1538
Herbert Xu2e9526b2009-10-30 05:51:48 +00001539 dev->netdev_ops = &ipgre_tap_netdev_ops;
Eric Dumazete985aad2010-09-27 03:57:11 +00001540 dev->destructor = ipgre_dev_free;
Herbert Xue1a80002008-10-09 12:00:17 -07001541
1542 dev->iflink = 0;
1543 dev->features |= NETIF_F_NETNS_LOCAL;
1544}
1545
Eric W. Biederman81adee42009-11-08 00:53:51 -08001546static int ipgre_newlink(struct net *src_net, struct net_device *dev, struct nlattr *tb[],
Herbert Xuc19e6542008-10-09 11:59:55 -07001547 struct nlattr *data[])
1548{
1549 struct ip_tunnel *nt;
1550 struct net *net = dev_net(dev);
1551 struct ipgre_net *ign = net_generic(net, ipgre_net_id);
1552 int mtu;
1553 int err;
1554
1555 nt = netdev_priv(dev);
1556 ipgre_netlink_parms(data, &nt->parms);
1557
Herbert Xue1a80002008-10-09 12:00:17 -07001558 if (ipgre_tunnel_find(net, &nt->parms, dev->type))
Herbert Xuc19e6542008-10-09 11:59:55 -07001559 return -EEXIST;
1560
Herbert Xue1a80002008-10-09 12:00:17 -07001561 if (dev->type == ARPHRD_ETHER && !tb[IFLA_ADDRESS])
Danny Kukawkaf2cedb62012-02-15 06:45:39 +00001562 eth_hw_addr_random(dev);
Herbert Xue1a80002008-10-09 12:00:17 -07001563
Herbert Xuc19e6542008-10-09 11:59:55 -07001564 mtu = ipgre_tunnel_bind_dev(dev);
1565 if (!tb[IFLA_MTU])
1566 dev->mtu = mtu;
1567
Eric Dumazetb790e012010-09-27 23:05:47 +00001568 /* Can use a lockless transmit, unless we generate output sequences */
1569 if (!(nt->parms.o_flags & GRE_SEQ))
1570 dev->features |= NETIF_F_LLTX;
1571
Herbert Xuc19e6542008-10-09 11:59:55 -07001572 err = register_netdevice(dev);
1573 if (err)
1574 goto out;
1575
1576 dev_hold(dev);
1577 ipgre_tunnel_link(ign, nt);
1578
1579out:
1580 return err;
1581}
1582
1583static int ipgre_changelink(struct net_device *dev, struct nlattr *tb[],
1584 struct nlattr *data[])
1585{
1586 struct ip_tunnel *t, *nt;
1587 struct net *net = dev_net(dev);
1588 struct ipgre_net *ign = net_generic(net, ipgre_net_id);
1589 struct ip_tunnel_parm p;
1590 int mtu;
1591
1592 if (dev == ign->fb_tunnel_dev)
1593 return -EINVAL;
1594
1595 nt = netdev_priv(dev);
1596 ipgre_netlink_parms(data, &p);
1597
1598 t = ipgre_tunnel_locate(net, &p, 0);
1599
1600 if (t) {
1601 if (t->dev != dev)
1602 return -EEXIST;
1603 } else {
Herbert Xuc19e6542008-10-09 11:59:55 -07001604 t = nt;
1605
Herbert Xu2e9526b2009-10-30 05:51:48 +00001606 if (dev->type != ARPHRD_ETHER) {
Eric Dumazet15078502010-09-15 11:07:53 +00001607 unsigned int nflags = 0;
Herbert Xuc19e6542008-10-09 11:59:55 -07001608
Herbert Xu2e9526b2009-10-30 05:51:48 +00001609 if (ipv4_is_multicast(p.iph.daddr))
1610 nflags = IFF_BROADCAST;
1611 else if (p.iph.daddr)
1612 nflags = IFF_POINTOPOINT;
1613
1614 if ((dev->flags ^ nflags) &
1615 (IFF_POINTOPOINT | IFF_BROADCAST))
1616 return -EINVAL;
1617 }
Herbert Xuc19e6542008-10-09 11:59:55 -07001618
1619 ipgre_tunnel_unlink(ign, t);
1620 t->parms.iph.saddr = p.iph.saddr;
1621 t->parms.iph.daddr = p.iph.daddr;
1622 t->parms.i_key = p.i_key;
Herbert Xu2e9526b2009-10-30 05:51:48 +00001623 if (dev->type != ARPHRD_ETHER) {
1624 memcpy(dev->dev_addr, &p.iph.saddr, 4);
1625 memcpy(dev->broadcast, &p.iph.daddr, 4);
1626 }
Herbert Xuc19e6542008-10-09 11:59:55 -07001627 ipgre_tunnel_link(ign, t);
1628 netdev_state_change(dev);
1629 }
1630
1631 t->parms.o_key = p.o_key;
1632 t->parms.iph.ttl = p.iph.ttl;
1633 t->parms.iph.tos = p.iph.tos;
1634 t->parms.iph.frag_off = p.iph.frag_off;
1635
1636 if (t->parms.link != p.link) {
1637 t->parms.link = p.link;
1638 mtu = ipgre_tunnel_bind_dev(dev);
1639 if (!tb[IFLA_MTU])
1640 dev->mtu = mtu;
1641 netdev_state_change(dev);
1642 }
1643
1644 return 0;
1645}
1646
1647static size_t ipgre_get_size(const struct net_device *dev)
1648{
1649 return
1650 /* IFLA_GRE_LINK */
1651 nla_total_size(4) +
1652 /* IFLA_GRE_IFLAGS */
1653 nla_total_size(2) +
1654 /* IFLA_GRE_OFLAGS */
1655 nla_total_size(2) +
1656 /* IFLA_GRE_IKEY */
1657 nla_total_size(4) +
1658 /* IFLA_GRE_OKEY */
1659 nla_total_size(4) +
1660 /* IFLA_GRE_LOCAL */
1661 nla_total_size(4) +
1662 /* IFLA_GRE_REMOTE */
1663 nla_total_size(4) +
1664 /* IFLA_GRE_TTL */
1665 nla_total_size(1) +
1666 /* IFLA_GRE_TOS */
1667 nla_total_size(1) +
1668 /* IFLA_GRE_PMTUDISC */
1669 nla_total_size(1) +
1670 0;
1671}
1672
1673static int ipgre_fill_info(struct sk_buff *skb, const struct net_device *dev)
1674{
1675 struct ip_tunnel *t = netdev_priv(dev);
1676 struct ip_tunnel_parm *p = &t->parms;
1677
David S. Millerf3756b72012-04-01 20:39:02 -04001678 if (nla_put_u32(skb, IFLA_GRE_LINK, p->link) ||
1679 nla_put_be16(skb, IFLA_GRE_IFLAGS, p->i_flags) ||
1680 nla_put_be16(skb, IFLA_GRE_OFLAGS, p->o_flags) ||
1681 nla_put_be32(skb, IFLA_GRE_IKEY, p->i_key) ||
1682 nla_put_be32(skb, IFLA_GRE_OKEY, p->o_key) ||
1683 nla_put_be32(skb, IFLA_GRE_LOCAL, p->iph.saddr) ||
1684 nla_put_be32(skb, IFLA_GRE_REMOTE, p->iph.daddr) ||
1685 nla_put_u8(skb, IFLA_GRE_TTL, p->iph.ttl) ||
1686 nla_put_u8(skb, IFLA_GRE_TOS, p->iph.tos) ||
1687 nla_put_u8(skb, IFLA_GRE_PMTUDISC,
1688 !!(p->iph.frag_off & htons(IP_DF))))
1689 goto nla_put_failure;
Herbert Xuc19e6542008-10-09 11:59:55 -07001690 return 0;
1691
1692nla_put_failure:
1693 return -EMSGSIZE;
1694}
1695
1696static const struct nla_policy ipgre_policy[IFLA_GRE_MAX + 1] = {
1697 [IFLA_GRE_LINK] = { .type = NLA_U32 },
1698 [IFLA_GRE_IFLAGS] = { .type = NLA_U16 },
1699 [IFLA_GRE_OFLAGS] = { .type = NLA_U16 },
1700 [IFLA_GRE_IKEY] = { .type = NLA_U32 },
1701 [IFLA_GRE_OKEY] = { .type = NLA_U32 },
Patrick McHardy4d74f8b2008-10-10 12:11:06 -07001702 [IFLA_GRE_LOCAL] = { .len = FIELD_SIZEOF(struct iphdr, saddr) },
1703 [IFLA_GRE_REMOTE] = { .len = FIELD_SIZEOF(struct iphdr, daddr) },
Herbert Xuc19e6542008-10-09 11:59:55 -07001704 [IFLA_GRE_TTL] = { .type = NLA_U8 },
1705 [IFLA_GRE_TOS] = { .type = NLA_U8 },
1706 [IFLA_GRE_PMTUDISC] = { .type = NLA_U8 },
1707};
1708
1709static struct rtnl_link_ops ipgre_link_ops __read_mostly = {
1710 .kind = "gre",
1711 .maxtype = IFLA_GRE_MAX,
1712 .policy = ipgre_policy,
1713 .priv_size = sizeof(struct ip_tunnel),
1714 .setup = ipgre_tunnel_setup,
1715 .validate = ipgre_tunnel_validate,
1716 .newlink = ipgre_newlink,
1717 .changelink = ipgre_changelink,
1718 .get_size = ipgre_get_size,
1719 .fill_info = ipgre_fill_info,
1720};
1721
Herbert Xue1a80002008-10-09 12:00:17 -07001722static struct rtnl_link_ops ipgre_tap_ops __read_mostly = {
1723 .kind = "gretap",
1724 .maxtype = IFLA_GRE_MAX,
1725 .policy = ipgre_policy,
1726 .priv_size = sizeof(struct ip_tunnel),
1727 .setup = ipgre_tap_setup,
1728 .validate = ipgre_tap_validate,
1729 .newlink = ipgre_newlink,
1730 .changelink = ipgre_changelink,
1731 .get_size = ipgre_get_size,
1732 .fill_info = ipgre_fill_info,
1733};
1734
Linus Torvalds1da177e2005-04-16 15:20:36 -07001735/*
1736 * And now the modules code and kernel interface.
1737 */
1738
1739static int __init ipgre_init(void)
1740{
1741 int err;
1742
Joe Perches058bd4d2012-03-11 18:36:11 +00001743 pr_info("GRE over IPv4 tunneling driver\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001744
Eric W. Biedermancfb8fbf2009-11-29 15:46:13 +00001745 err = register_pernet_device(&ipgre_net_ops);
Pavel Emelyanov59a4c752008-04-16 01:08:53 -07001746 if (err < 0)
Alexey Dobriyanc2892f02010-02-16 07:57:44 +00001747 return err;
1748
Dmitry Kozlov00959ad2010-08-21 23:05:39 -07001749 err = gre_add_protocol(&ipgre_protocol, GREPROTO_CISCO);
Alexey Dobriyanc2892f02010-02-16 07:57:44 +00001750 if (err < 0) {
Joe Perches058bd4d2012-03-11 18:36:11 +00001751 pr_info("%s: can't add protocol\n", __func__);
Alexey Dobriyanc2892f02010-02-16 07:57:44 +00001752 goto add_proto_failed;
1753 }
Pavel Emelyanov7daa0002008-04-16 01:10:05 -07001754
Herbert Xuc19e6542008-10-09 11:59:55 -07001755 err = rtnl_link_register(&ipgre_link_ops);
1756 if (err < 0)
1757 goto rtnl_link_failed;
1758
Herbert Xue1a80002008-10-09 12:00:17 -07001759 err = rtnl_link_register(&ipgre_tap_ops);
1760 if (err < 0)
1761 goto tap_ops_failed;
1762
Herbert Xuc19e6542008-10-09 11:59:55 -07001763out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001764 return err;
Herbert Xuc19e6542008-10-09 11:59:55 -07001765
Herbert Xue1a80002008-10-09 12:00:17 -07001766tap_ops_failed:
1767 rtnl_link_unregister(&ipgre_link_ops);
Herbert Xuc19e6542008-10-09 11:59:55 -07001768rtnl_link_failed:
Dmitry Kozlov00959ad2010-08-21 23:05:39 -07001769 gre_del_protocol(&ipgre_protocol, GREPROTO_CISCO);
Alexey Dobriyanc2892f02010-02-16 07:57:44 +00001770add_proto_failed:
1771 unregister_pernet_device(&ipgre_net_ops);
Herbert Xuc19e6542008-10-09 11:59:55 -07001772 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001773}
1774
Alexey Kuznetsovdb445752005-07-30 17:46:44 -07001775static void __exit ipgre_fini(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001776{
Herbert Xue1a80002008-10-09 12:00:17 -07001777 rtnl_link_unregister(&ipgre_tap_ops);
Herbert Xuc19e6542008-10-09 11:59:55 -07001778 rtnl_link_unregister(&ipgre_link_ops);
Dmitry Kozlov00959ad2010-08-21 23:05:39 -07001779 if (gre_del_protocol(&ipgre_protocol, GREPROTO_CISCO) < 0)
Joe Perches058bd4d2012-03-11 18:36:11 +00001780 pr_info("%s: can't remove protocol\n", __func__);
Alexey Dobriyanc2892f02010-02-16 07:57:44 +00001781 unregister_pernet_device(&ipgre_net_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001782}
1783
1784module_init(ipgre_init);
1785module_exit(ipgre_fini);
1786MODULE_LICENSE("GPL");
Patrick McHardy4d74f8b2008-10-10 12:11:06 -07001787MODULE_ALIAS_RTNL_LINK("gre");
1788MODULE_ALIAS_RTNL_LINK("gretap");
Vasiliy Kulikov8909c9a2011-03-02 00:33:13 +03001789MODULE_ALIAS_NETDEV("gre0");