blob: f9af98dd756126188819e7c2c0f95d3f41ea2cbc [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
Randy Dunlap4fc268d2006-01-11 12:17:47 -080013#include <linux/capability.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070014#include <linux/module.h>
15#include <linux/types.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070016#include <linux/kernel.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090017#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#include <asm/uaccess.h>
19#include <linux/skbuff.h>
20#include <linux/netdevice.h>
21#include <linux/in.h>
22#include <linux/tcp.h>
23#include <linux/udp.h>
24#include <linux/if_arp.h>
25#include <linux/mroute.h>
26#include <linux/init.h>
27#include <linux/in6.h>
28#include <linux/inetdevice.h>
29#include <linux/igmp.h>
30#include <linux/netfilter_ipv4.h>
Herbert Xue1a80002008-10-09 12:00:17 -070031#include <linux/etherdevice.h>
Kris Katterjohn46f25df2006-01-05 16:35:42 -080032#include <linux/if_ether.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070033
34#include <net/sock.h>
35#include <net/ip.h>
36#include <net/icmp.h>
37#include <net/protocol.h>
38#include <net/ipip.h>
39#include <net/arp.h>
40#include <net/checksum.h>
41#include <net/dsfield.h>
42#include <net/inet_ecn.h>
43#include <net/xfrm.h>
Pavel Emelyanov59a4c752008-04-16 01:08:53 -070044#include <net/net_namespace.h>
45#include <net/netns/generic.h>
Herbert Xuc19e6542008-10-09 11:59:55 -070046#include <net/rtnetlink.h>
Dmitry Kozlov00959ad2010-08-21 23:05:39 -070047#include <net/gre.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070048
Eric Dumazet842c74b2010-09-20 10:06:12 -070049#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
Linus Torvalds1da177e2005-04-16 15:20:36 -070050#include <net/ipv6.h>
51#include <net/ip6_fib.h>
52#include <net/ip6_route.h>
53#endif
54
55/*
56 Problems & solutions
57 --------------------
58
59 1. The most important issue is detecting local dead loops.
60 They would cause complete host lockup in transmit, which
61 would be "resolved" by stack overflow or, if queueing is enabled,
62 with infinite looping in net_bh.
63
64 We cannot track such dead loops during route installation,
65 it is infeasible task. The most general solutions would be
66 to keep skb->encapsulation counter (sort of local ttl),
Eric Dumazet6d0722a2010-09-29 23:35:10 -070067 and silently drop packet when it expires. It is a good
Linus Torvalds1da177e2005-04-16 15:20:36 -070068 solution, but it supposes maintaing new variable in ALL
69 skb, even if no tunneling is used.
70
Eric Dumazet6d0722a2010-09-29 23:35:10 -070071 Current solution: xmit_recursion breaks dead loops. This is a percpu
72 counter, since when we enter the first ndo_xmit(), cpu migration is
73 forbidden. We force an exit if this counter reaches RECURSION_LIMIT
Linus Torvalds1da177e2005-04-16 15:20:36 -070074
75 2. Networking dead loops would not kill routers, but would really
76 kill network. IP hop limit plays role of "t->recursion" in this case,
77 if we copy it from packet being encapsulated to upper header.
78 It is very good solution, but it introduces two problems:
79
80 - Routing protocols, using packets with ttl=1 (OSPF, RIP2),
81 do not work over tunnels.
82 - traceroute does not work. I planned to relay ICMP from tunnel,
83 so that this problem would be solved and traceroute output
84 would even more informative. This idea appeared to be wrong:
85 only Linux complies to rfc1812 now (yes, guys, Linux is the only
86 true router now :-)), all routers (at least, in neighbourhood of mine)
87 return only 8 bytes of payload. It is the end.
88
89 Hence, if we want that OSPF worked or traceroute said something reasonable,
90 we should search for another solution.
91
92 One of them is to parse packet trying to detect inner encapsulation
93 made by our node. It is difficult or even impossible, especially,
94 taking into account fragmentation. TO be short, tt is not solution at all.
95
96 Current solution: The solution was UNEXPECTEDLY SIMPLE.
97 We force DF flag on tunnels with preconfigured hop limit,
98 that is ALL. :-) Well, it does not remove the problem completely,
99 but exponential growth of network traffic is changed to linear
100 (branches, that exceed pmtu are pruned) and tunnel mtu
101 fastly degrades to value <68, where looping stops.
102 Yes, it is not good if there exists a router in the loop,
103 which does not force DF, even when encapsulating packets have DF set.
104 But it is not our problem! Nobody could accuse us, we made
105 all that we could make. Even if it is your gated who injected
106 fatal route to network, even if it were you who configured
107 fatal static route: you are innocent. :-)
108
109
110
111 3. Really, ipv4/ipip.c, ipv4/ip_gre.c and ipv6/sit.c contain
112 practically identical code. It would be good to glue them
113 together, but it is not very evident, how to make them modular.
114 sit is integral part of IPv6, ipip and gre are naturally modular.
115 We could extract common parts (hash table, ioctl etc)
116 to a separate module (ip_tunnel.c).
117
118 Alexey Kuznetsov.
119 */
120
Herbert Xuc19e6542008-10-09 11:59:55 -0700121static struct rtnl_link_ops ipgre_link_ops __read_mostly;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122static int ipgre_tunnel_init(struct net_device *dev);
123static void ipgre_tunnel_setup(struct net_device *dev);
Herbert Xu42aa9162008-10-09 11:59:32 -0700124static int ipgre_tunnel_bind_dev(struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125
126/* Fallback tunnel: no source, no destination, no key, no options */
127
Pavel Emelyanoveb8ce742008-04-16 01:10:26 -0700128#define HASH_SIZE 16
129
Eric Dumazetf99189b2009-11-17 10:42:49 +0000130static int ipgre_net_id __read_mostly;
Pavel Emelyanov59a4c752008-04-16 01:08:53 -0700131struct ipgre_net {
Eric Dumazet15078502010-09-15 11:07:53 +0000132 struct ip_tunnel __rcu *tunnels[4][HASH_SIZE];
Pavel Emelyanoveb8ce742008-04-16 01:10:26 -0700133
Pavel Emelyanov7daa0002008-04-16 01:10:05 -0700134 struct net_device *fb_tunnel_dev;
Pavel Emelyanov59a4c752008-04-16 01:08:53 -0700135};
136
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137/* Tunnel hash table */
138
139/*
140 4 hash tables:
141
142 3: (remote,local)
143 2: (remote,*)
144 1: (*,local)
145 0: (*,*)
146
147 We require exact key match i.e. if a key is present in packet
148 it will match only tunnel with the same key; if it is not present,
149 it will match only keyless tunnel.
150
151 All keysless packets, if not matched configured keyless tunnels
152 will match fallback tunnel.
153 */
154
Al Virod5a0a1e2006-11-08 00:23:14 -0800155#define HASH(addr) (((__force u32)addr^((__force u32)addr>>4))&0xF)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156
Pavel Emelyanoveb8ce742008-04-16 01:10:26 -0700157#define tunnels_r_l tunnels[3]
158#define tunnels_r tunnels[2]
159#define tunnels_l tunnels[1]
160#define tunnels_wc tunnels[0]
Eric Dumazet8d5b2c02009-10-23 06:14:38 +0000161/*
Eric Dumazet15078502010-09-15 11:07:53 +0000162 * Locking : hash tables are protected by RCU and RTNL
Eric Dumazet8d5b2c02009-10-23 06:14:38 +0000163 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164
Eric Dumazet8d5b2c02009-10-23 06:14:38 +0000165#define for_each_ip_tunnel_rcu(start) \
166 for (t = rcu_dereference(start); t; t = rcu_dereference(t->next))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167
Eric Dumazete985aad2010-09-27 03:57:11 +0000168/* often modified stats are per cpu, other are shared (netdev->stats) */
169struct pcpu_tstats {
170 unsigned long rx_packets;
171 unsigned long rx_bytes;
172 unsigned long tx_packets;
173 unsigned long tx_bytes;
174};
175
176static struct net_device_stats *ipgre_get_stats(struct net_device *dev)
177{
178 struct pcpu_tstats sum = { 0 };
179 int i;
180
181 for_each_possible_cpu(i) {
182 const struct pcpu_tstats *tstats = per_cpu_ptr(dev->tstats, i);
183
184 sum.rx_packets += tstats->rx_packets;
185 sum.rx_bytes += tstats->rx_bytes;
186 sum.tx_packets += tstats->tx_packets;
187 sum.tx_bytes += tstats->tx_bytes;
188 }
189 dev->stats.rx_packets = sum.rx_packets;
190 dev->stats.rx_bytes = sum.rx_bytes;
191 dev->stats.tx_packets = sum.tx_packets;
192 dev->stats.tx_bytes = sum.tx_bytes;
193 return &dev->stats;
194}
195
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196/* Given src, dst and key, find appropriate for input tunnel. */
197
Timo Teras749c10f2009-01-19 17:22:12 -0800198static struct ip_tunnel * ipgre_tunnel_lookup(struct net_device *dev,
Herbert Xue1a80002008-10-09 12:00:17 -0700199 __be32 remote, __be32 local,
200 __be32 key, __be16 gre_proto)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201{
Timo Teras749c10f2009-01-19 17:22:12 -0800202 struct net *net = dev_net(dev);
203 int link = dev->ifindex;
Eric Dumazet15078502010-09-15 11:07:53 +0000204 unsigned int h0 = HASH(remote);
205 unsigned int h1 = HASH(key);
Timo Terasafcf1242009-01-26 20:56:10 -0800206 struct ip_tunnel *t, *cand = NULL;
Pavel Emelyanov7daa0002008-04-16 01:10:05 -0700207 struct ipgre_net *ign = net_generic(net, ipgre_net_id);
Herbert Xue1a80002008-10-09 12:00:17 -0700208 int dev_type = (gre_proto == htons(ETH_P_TEB)) ?
209 ARPHRD_ETHER : ARPHRD_IPGRE;
Timo Terasafcf1242009-01-26 20:56:10 -0800210 int score, cand_score = 4;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211
Eric Dumazet8d5b2c02009-10-23 06:14:38 +0000212 for_each_ip_tunnel_rcu(ign->tunnels_r_l[h0 ^ h1]) {
Timo Teras749c10f2009-01-19 17:22:12 -0800213 if (local != t->parms.iph.saddr ||
214 remote != t->parms.iph.daddr ||
215 key != t->parms.i_key ||
216 !(t->dev->flags & IFF_UP))
217 continue;
218
219 if (t->dev->type != ARPHRD_IPGRE &&
220 t->dev->type != dev_type)
221 continue;
222
Timo Terasafcf1242009-01-26 20:56:10 -0800223 score = 0;
Timo Teras749c10f2009-01-19 17:22:12 -0800224 if (t->parms.link != link)
Timo Terasafcf1242009-01-26 20:56:10 -0800225 score |= 1;
Timo Teras749c10f2009-01-19 17:22:12 -0800226 if (t->dev->type != dev_type)
Timo Terasafcf1242009-01-26 20:56:10 -0800227 score |= 2;
228 if (score == 0)
Timo Teras749c10f2009-01-19 17:22:12 -0800229 return t;
Timo Terasafcf1242009-01-26 20:56:10 -0800230
231 if (score < cand_score) {
232 cand = t;
233 cand_score = score;
234 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235 }
Herbert Xue1a80002008-10-09 12:00:17 -0700236
Eric Dumazet8d5b2c02009-10-23 06:14:38 +0000237 for_each_ip_tunnel_rcu(ign->tunnels_r[h0 ^ h1]) {
Timo Teras749c10f2009-01-19 17:22:12 -0800238 if (remote != t->parms.iph.daddr ||
239 key != t->parms.i_key ||
240 !(t->dev->flags & IFF_UP))
241 continue;
242
243 if (t->dev->type != ARPHRD_IPGRE &&
244 t->dev->type != dev_type)
245 continue;
246
Timo Terasafcf1242009-01-26 20:56:10 -0800247 score = 0;
Timo Teras749c10f2009-01-19 17:22:12 -0800248 if (t->parms.link != link)
Timo Terasafcf1242009-01-26 20:56:10 -0800249 score |= 1;
Timo Teras749c10f2009-01-19 17:22:12 -0800250 if (t->dev->type != dev_type)
Timo Terasafcf1242009-01-26 20:56:10 -0800251 score |= 2;
252 if (score == 0)
Timo Teras749c10f2009-01-19 17:22:12 -0800253 return t;
Timo Terasafcf1242009-01-26 20:56:10 -0800254
255 if (score < cand_score) {
256 cand = t;
257 cand_score = score;
258 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259 }
Herbert Xue1a80002008-10-09 12:00:17 -0700260
Eric Dumazet8d5b2c02009-10-23 06:14:38 +0000261 for_each_ip_tunnel_rcu(ign->tunnels_l[h1]) {
Timo Teras749c10f2009-01-19 17:22:12 -0800262 if ((local != t->parms.iph.saddr &&
263 (local != t->parms.iph.daddr ||
264 !ipv4_is_multicast(local))) ||
265 key != t->parms.i_key ||
266 !(t->dev->flags & IFF_UP))
267 continue;
268
269 if (t->dev->type != ARPHRD_IPGRE &&
270 t->dev->type != dev_type)
271 continue;
272
Timo Terasafcf1242009-01-26 20:56:10 -0800273 score = 0;
Timo Teras749c10f2009-01-19 17:22:12 -0800274 if (t->parms.link != link)
Timo Terasafcf1242009-01-26 20:56:10 -0800275 score |= 1;
Timo Teras749c10f2009-01-19 17:22:12 -0800276 if (t->dev->type != dev_type)
Timo Terasafcf1242009-01-26 20:56:10 -0800277 score |= 2;
278 if (score == 0)
Timo Teras749c10f2009-01-19 17:22:12 -0800279 return t;
Timo Terasafcf1242009-01-26 20:56:10 -0800280
281 if (score < cand_score) {
282 cand = t;
283 cand_score = score;
284 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285 }
Herbert Xue1a80002008-10-09 12:00:17 -0700286
Eric Dumazet8d5b2c02009-10-23 06:14:38 +0000287 for_each_ip_tunnel_rcu(ign->tunnels_wc[h1]) {
Timo Teras749c10f2009-01-19 17:22:12 -0800288 if (t->parms.i_key != key ||
289 !(t->dev->flags & IFF_UP))
290 continue;
291
292 if (t->dev->type != ARPHRD_IPGRE &&
293 t->dev->type != dev_type)
294 continue;
295
Timo Terasafcf1242009-01-26 20:56:10 -0800296 score = 0;
Timo Teras749c10f2009-01-19 17:22:12 -0800297 if (t->parms.link != link)
Timo Terasafcf1242009-01-26 20:56:10 -0800298 score |= 1;
Timo Teras749c10f2009-01-19 17:22:12 -0800299 if (t->dev->type != dev_type)
Timo Terasafcf1242009-01-26 20:56:10 -0800300 score |= 2;
301 if (score == 0)
Timo Teras749c10f2009-01-19 17:22:12 -0800302 return t;
Timo Terasafcf1242009-01-26 20:56:10 -0800303
304 if (score < cand_score) {
305 cand = t;
306 cand_score = score;
307 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308 }
309
Timo Terasafcf1242009-01-26 20:56:10 -0800310 if (cand != NULL)
311 return cand;
Herbert Xue1a80002008-10-09 12:00:17 -0700312
Eric Dumazet8d5b2c02009-10-23 06:14:38 +0000313 dev = ign->fb_tunnel_dev;
314 if (dev->flags & IFF_UP)
315 return netdev_priv(dev);
Timo Teras749c10f2009-01-19 17:22:12 -0800316
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317 return NULL;
318}
319
Eric Dumazet15078502010-09-15 11:07:53 +0000320static struct ip_tunnel __rcu **__ipgre_bucket(struct ipgre_net *ign,
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -0700321 struct ip_tunnel_parm *parms)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322{
YOSHIFUJI Hideaki5056a1e2007-04-24 20:44:48 +0900323 __be32 remote = parms->iph.daddr;
324 __be32 local = parms->iph.saddr;
325 __be32 key = parms->i_key;
Eric Dumazet15078502010-09-15 11:07:53 +0000326 unsigned int h = HASH(key);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327 int prio = 0;
328
329 if (local)
330 prio |= 1;
Joe Perchesf97c1e02007-12-16 13:45:43 -0800331 if (remote && !ipv4_is_multicast(remote)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332 prio |= 2;
333 h ^= HASH(remote);
334 }
335
Pavel Emelyanoveb8ce742008-04-16 01:10:26 -0700336 return &ign->tunnels[prio][h];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337}
338
Eric Dumazet15078502010-09-15 11:07:53 +0000339static inline struct ip_tunnel __rcu **ipgre_bucket(struct ipgre_net *ign,
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -0700340 struct ip_tunnel *t)
YOSHIFUJI Hideaki5056a1e2007-04-24 20:44:48 +0900341{
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -0700342 return __ipgre_bucket(ign, &t->parms);
YOSHIFUJI Hideaki5056a1e2007-04-24 20:44:48 +0900343}
344
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -0700345static void ipgre_tunnel_link(struct ipgre_net *ign, struct ip_tunnel *t)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346{
Eric Dumazet15078502010-09-15 11:07:53 +0000347 struct ip_tunnel __rcu **tp = ipgre_bucket(ign, t);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348
Eric Dumazet15078502010-09-15 11:07:53 +0000349 rcu_assign_pointer(t->next, rtnl_dereference(*tp));
Eric Dumazet8d5b2c02009-10-23 06:14:38 +0000350 rcu_assign_pointer(*tp, t);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351}
352
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -0700353static void ipgre_tunnel_unlink(struct ipgre_net *ign, struct ip_tunnel *t)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354{
Eric Dumazet15078502010-09-15 11:07:53 +0000355 struct ip_tunnel __rcu **tp;
356 struct ip_tunnel *iter;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357
Eric Dumazet15078502010-09-15 11:07:53 +0000358 for (tp = ipgre_bucket(ign, t);
359 (iter = rtnl_dereference(*tp)) != NULL;
360 tp = &iter->next) {
361 if (t == iter) {
362 rcu_assign_pointer(*tp, t->next);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363 break;
364 }
365 }
366}
367
Herbert Xue1a80002008-10-09 12:00:17 -0700368static struct ip_tunnel *ipgre_tunnel_find(struct net *net,
369 struct ip_tunnel_parm *parms,
370 int type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371{
Al Virod5a0a1e2006-11-08 00:23:14 -0800372 __be32 remote = parms->iph.daddr;
373 __be32 local = parms->iph.saddr;
374 __be32 key = parms->i_key;
Timo Teras749c10f2009-01-19 17:22:12 -0800375 int link = parms->link;
Eric Dumazet15078502010-09-15 11:07:53 +0000376 struct ip_tunnel *t;
377 struct ip_tunnel __rcu **tp;
Herbert Xue1a80002008-10-09 12:00:17 -0700378 struct ipgre_net *ign = net_generic(net, ipgre_net_id);
379
Eric Dumazet15078502010-09-15 11:07:53 +0000380 for (tp = __ipgre_bucket(ign, parms);
381 (t = rtnl_dereference(*tp)) != NULL;
382 tp = &t->next)
Herbert Xue1a80002008-10-09 12:00:17 -0700383 if (local == t->parms.iph.saddr &&
384 remote == t->parms.iph.daddr &&
385 key == t->parms.i_key &&
Timo Teras749c10f2009-01-19 17:22:12 -0800386 link == t->parms.link &&
Herbert Xue1a80002008-10-09 12:00:17 -0700387 type == t->dev->type)
388 break;
389
390 return t;
391}
392
Eric Dumazet15078502010-09-15 11:07:53 +0000393static struct ip_tunnel *ipgre_tunnel_locate(struct net *net,
Herbert Xue1a80002008-10-09 12:00:17 -0700394 struct ip_tunnel_parm *parms, int create)
395{
396 struct ip_tunnel *t, *nt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397 struct net_device *dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398 char name[IFNAMSIZ];
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -0700399 struct ipgre_net *ign = net_generic(net, ipgre_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400
Herbert Xue1a80002008-10-09 12:00:17 -0700401 t = ipgre_tunnel_find(net, parms, ARPHRD_IPGRE);
402 if (t || !create)
403 return t;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404
405 if (parms->name[0])
406 strlcpy(name, parms->name, IFNAMSIZ);
Pavel Emelyanov34cc7ba2008-02-23 20:19:20 -0800407 else
stephen hemminger407d6fc2010-11-29 09:47:47 +0000408 strcpy(name, "gre%d");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409
410 dev = alloc_netdev(sizeof(*t), name, ipgre_tunnel_setup);
411 if (!dev)
stephen hemminger407d6fc2010-11-29 09:47:47 +0000412 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413
Pavel Emelyanov0b67ece2008-04-16 01:11:13 -0700414 dev_net_set(dev, net);
415
Pavel Emelyanovb37d428b2008-02-26 23:51:04 -0800416 if (strchr(name, '%')) {
417 if (dev_alloc_name(dev, name) < 0)
418 goto failed_free;
419 }
420
Patrick McHardy2941a482006-01-08 22:05:26 -0800421 nt = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422 nt->parms = *parms;
Herbert Xuc19e6542008-10-09 11:59:55 -0700423 dev->rtnl_link_ops = &ipgre_link_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424
Herbert Xu42aa9162008-10-09 11:59:32 -0700425 dev->mtu = ipgre_tunnel_bind_dev(dev);
426
Pavel Emelyanovb37d428b2008-02-26 23:51:04 -0800427 if (register_netdevice(dev) < 0)
428 goto failed_free;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430 dev_hold(dev);
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -0700431 ipgre_tunnel_link(ign, nt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432 return nt;
433
Pavel Emelyanovb37d428b2008-02-26 23:51:04 -0800434failed_free:
435 free_netdev(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436 return NULL;
437}
438
439static void ipgre_tunnel_uninit(struct net_device *dev)
440{
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -0700441 struct net *net = dev_net(dev);
442 struct ipgre_net *ign = net_generic(net, ipgre_net_id);
443
444 ipgre_tunnel_unlink(ign, netdev_priv(dev));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445 dev_put(dev);
446}
447
448
449static void ipgre_err(struct sk_buff *skb, u32 info)
450{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451
Rami Rosen071f92d2008-05-21 17:47:54 -0700452/* All the routers (except for Linux) return only
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453 8 bytes of packet payload. It means, that precise relaying of
454 ICMP in the real Internet is absolutely infeasible.
455
456 Moreover, Cisco "wise men" put GRE key to the third word
457 in GRE header. It makes impossible maintaining even soft state for keyed
458 GRE tunnels with enabled checksum. Tell them "thank you".
459
460 Well, I wonder, rfc1812 was written by Cisco employee,
461 what the hell these idiots break standrads established
462 by themself???
463 */
464
Jianjun Kong6ed25332008-11-03 00:25:16 -0800465 struct iphdr *iph = (struct iphdr *)skb->data;
Al Virod5a0a1e2006-11-08 00:23:14 -0800466 __be16 *p = (__be16*)(skb->data+(iph->ihl<<2));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467 int grehlen = (iph->ihl<<2) + 4;
Arnaldo Carvalho de Melo88c76642007-03-13 14:43:18 -0300468 const int type = icmp_hdr(skb)->type;
469 const int code = icmp_hdr(skb)->code;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470 struct ip_tunnel *t;
Al Virod5a0a1e2006-11-08 00:23:14 -0800471 __be16 flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472
473 flags = p[0];
474 if (flags&(GRE_CSUM|GRE_KEY|GRE_SEQ|GRE_ROUTING|GRE_VERSION)) {
475 if (flags&(GRE_VERSION|GRE_ROUTING))
476 return;
477 if (flags&GRE_KEY) {
478 grehlen += 4;
479 if (flags&GRE_CSUM)
480 grehlen += 4;
481 }
482 }
483
484 /* If only 8 bytes returned, keyed message will be dropped here */
485 if (skb_headlen(skb) < grehlen)
486 return;
487
488 switch (type) {
489 default:
490 case ICMP_PARAMETERPROB:
491 return;
492
493 case ICMP_DEST_UNREACH:
494 switch (code) {
495 case ICMP_SR_FAILED:
496 case ICMP_PORT_UNREACH:
497 /* Impossible event. */
498 return;
499 case ICMP_FRAG_NEEDED:
500 /* Soft state for pmtu is maintained by IP core. */
501 return;
502 default:
503 /* All others are translated to HOST_UNREACH.
504 rfc2003 contains "deep thoughts" about NET_UNREACH,
505 I believe they are just ether pollution. --ANK
506 */
507 break;
508 }
509 break;
510 case ICMP_TIME_EXCEEDED:
511 if (code != ICMP_EXC_TTL)
512 return;
513 break;
514 }
515
Eric Dumazet8d5b2c02009-10-23 06:14:38 +0000516 rcu_read_lock();
Timo Teras749c10f2009-01-19 17:22:12 -0800517 t = ipgre_tunnel_lookup(skb->dev, iph->daddr, iph->saddr,
Herbert Xue1a80002008-10-09 12:00:17 -0700518 flags & GRE_KEY ?
519 *(((__be32 *)p) + (grehlen / 4) - 1) : 0,
520 p[1]);
Joe Perchesf97c1e02007-12-16 13:45:43 -0800521 if (t == NULL || t->parms.iph.daddr == 0 ||
522 ipv4_is_multicast(t->parms.iph.daddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523 goto out;
524
525 if (t->parms.iph.ttl == 0 && type == ICMP_TIME_EXCEEDED)
526 goto out;
527
Wei Yongjunda6185d82009-02-24 23:34:48 -0800528 if (time_before(jiffies, t->err_time + IPTUNNEL_ERR_TIMEO))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529 t->err_count++;
530 else
531 t->err_count = 1;
532 t->err_time = jiffies;
533out:
Eric Dumazet8d5b2c02009-10-23 06:14:38 +0000534 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535}
536
537static inline void ipgre_ecn_decapsulate(struct iphdr *iph, struct sk_buff *skb)
538{
539 if (INET_ECN_is_ce(iph->tos)) {
540 if (skb->protocol == htons(ETH_P_IP)) {
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700541 IP_ECN_set_ce(ip_hdr(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542 } else if (skb->protocol == htons(ETH_P_IPV6)) {
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700543 IP6_ECN_set_ce(ipv6_hdr(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544 }
545 }
546}
547
548static inline u8
549ipgre_ecn_encapsulate(u8 tos, struct iphdr *old_iph, struct sk_buff *skb)
550{
551 u8 inner = 0;
552 if (skb->protocol == htons(ETH_P_IP))
553 inner = old_iph->tos;
554 else if (skb->protocol == htons(ETH_P_IPV6))
555 inner = ipv6_get_dsfield((struct ipv6hdr *)old_iph);
556 return INET_ECN_encapsulate(tos, inner);
557}
558
559static int ipgre_rcv(struct sk_buff *skb)
560{
561 struct iphdr *iph;
562 u8 *h;
Al Virod5a0a1e2006-11-08 00:23:14 -0800563 __be16 flags;
Al Virod3bc23e2006-11-14 21:24:49 -0800564 __sum16 csum = 0;
Al Virod5a0a1e2006-11-08 00:23:14 -0800565 __be32 key = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566 u32 seqno = 0;
567 struct ip_tunnel *tunnel;
568 int offset = 4;
Herbert Xue1a80002008-10-09 12:00:17 -0700569 __be16 gre_proto;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570
571 if (!pskb_may_pull(skb, 16))
572 goto drop_nolock;
573
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700574 iph = ip_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575 h = skb->data;
Al Virod5a0a1e2006-11-08 00:23:14 -0800576 flags = *(__be16*)h;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577
578 if (flags&(GRE_CSUM|GRE_KEY|GRE_ROUTING|GRE_SEQ|GRE_VERSION)) {
579 /* - Version must be 0.
580 - We do not support routing headers.
581 */
582 if (flags&(GRE_VERSION|GRE_ROUTING))
583 goto drop_nolock;
584
585 if (flags&GRE_CSUM) {
Herbert Xufb286bb2005-11-10 13:01:24 -0800586 switch (skb->ip_summed) {
Patrick McHardy84fa7932006-08-29 16:44:56 -0700587 case CHECKSUM_COMPLETE:
Al Virod3bc23e2006-11-14 21:24:49 -0800588 csum = csum_fold(skb->csum);
Herbert Xufb286bb2005-11-10 13:01:24 -0800589 if (!csum)
590 break;
591 /* fall through */
592 case CHECKSUM_NONE:
593 skb->csum = 0;
594 csum = __skb_checksum_complete(skb);
Patrick McHardy84fa7932006-08-29 16:44:56 -0700595 skb->ip_summed = CHECKSUM_COMPLETE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596 }
597 offset += 4;
598 }
599 if (flags&GRE_KEY) {
Al Virod5a0a1e2006-11-08 00:23:14 -0800600 key = *(__be32*)(h + offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601 offset += 4;
602 }
603 if (flags&GRE_SEQ) {
Al Virod5a0a1e2006-11-08 00:23:14 -0800604 seqno = ntohl(*(__be32*)(h + offset));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605 offset += 4;
606 }
607 }
608
Herbert Xue1a80002008-10-09 12:00:17 -0700609 gre_proto = *(__be16 *)(h + 2);
610
Eric Dumazet8d5b2c02009-10-23 06:14:38 +0000611 rcu_read_lock();
Timo Teras749c10f2009-01-19 17:22:12 -0800612 if ((tunnel = ipgre_tunnel_lookup(skb->dev,
Herbert Xue1a80002008-10-09 12:00:17 -0700613 iph->saddr, iph->daddr, key,
614 gre_proto))) {
Eric Dumazete985aad2010-09-27 03:57:11 +0000615 struct pcpu_tstats *tstats;
Pavel Emelyanovaddd68e2008-05-21 14:14:22 -0700616
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617 secpath_reset(skb);
618
Herbert Xue1a80002008-10-09 12:00:17 -0700619 skb->protocol = gre_proto;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620 /* WCCP version 1 and 2 protocol decoding.
621 * - Change protocol to IP
622 * - When dealing with WCCPv2, Skip extra 4 bytes in GRE header
623 */
Herbert Xue1a80002008-10-09 12:00:17 -0700624 if (flags == 0 && gre_proto == htons(ETH_P_WCCP)) {
YOSHIFUJI Hideaki496c98d2006-10-10 19:41:21 -0700625 skb->protocol = htons(ETH_P_IP);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900626 if ((*(h + offset) & 0xF0) != 0x40)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627 offset += 4;
628 }
629
Timo Teras1d069162007-12-20 00:10:33 -0800630 skb->mac_header = skb->network_header;
Arnaldo Carvalho de Melo4209fb62007-03-10 18:42:03 -0300631 __pskb_pull(skb, offset);
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -0700632 skb_postpull_rcsum(skb, skb_transport_header(skb), offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633 skb->pkt_type = PACKET_HOST;
634#ifdef CONFIG_NET_IPGRE_BROADCAST
Joe Perchesf97c1e02007-12-16 13:45:43 -0800635 if (ipv4_is_multicast(iph->daddr)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700636 /* Looped back packet, drop it! */
David S. Millerc7537962010-11-11 17:07:48 -0800637 if (rt_is_output_route(skb_rtable(skb)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638 goto drop;
Eric Dumazete985aad2010-09-27 03:57:11 +0000639 tunnel->dev->stats.multicast++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640 skb->pkt_type = PACKET_BROADCAST;
641 }
642#endif
643
644 if (((flags&GRE_CSUM) && csum) ||
645 (!(flags&GRE_CSUM) && tunnel->parms.i_flags&GRE_CSUM)) {
Eric Dumazete985aad2010-09-27 03:57:11 +0000646 tunnel->dev->stats.rx_crc_errors++;
647 tunnel->dev->stats.rx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700648 goto drop;
649 }
650 if (tunnel->parms.i_flags&GRE_SEQ) {
651 if (!(flags&GRE_SEQ) ||
652 (tunnel->i_seqno && (s32)(seqno - tunnel->i_seqno) < 0)) {
Eric Dumazete985aad2010-09-27 03:57:11 +0000653 tunnel->dev->stats.rx_fifo_errors++;
654 tunnel->dev->stats.rx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700655 goto drop;
656 }
657 tunnel->i_seqno = seqno + 1;
658 }
Herbert Xue1a80002008-10-09 12:00:17 -0700659
660 /* Warning: All skb pointers will be invalidated! */
661 if (tunnel->dev->type == ARPHRD_ETHER) {
662 if (!pskb_may_pull(skb, ETH_HLEN)) {
Eric Dumazete985aad2010-09-27 03:57:11 +0000663 tunnel->dev->stats.rx_length_errors++;
664 tunnel->dev->stats.rx_errors++;
Herbert Xue1a80002008-10-09 12:00:17 -0700665 goto drop;
666 }
667
668 iph = ip_hdr(skb);
669 skb->protocol = eth_type_trans(skb, tunnel->dev);
670 skb_postpull_rcsum(skb, eth_hdr(skb), ETH_HLEN);
671 }
672
Eric Dumazete985aad2010-09-27 03:57:11 +0000673 tstats = this_cpu_ptr(tunnel->dev->tstats);
674 tstats->rx_packets++;
675 tstats->rx_bytes += skb->len;
676
677 __skb_tunnel_rx(skb, tunnel->dev);
Herbert Xue1a80002008-10-09 12:00:17 -0700678
679 skb_reset_network_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680 ipgre_ecn_decapsulate(iph, skb);
Herbert Xue1a80002008-10-09 12:00:17 -0700681
Eric Dumazetcaf586e2010-09-30 21:06:55 +0000682 netif_rx(skb);
Eric Dumazet8990f462010-09-20 00:12:11 +0000683
Eric Dumazet8d5b2c02009-10-23 06:14:38 +0000684 rcu_read_unlock();
Eric Dumazet8990f462010-09-20 00:12:11 +0000685 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686 }
Herbert Xu45af08b2006-04-05 22:31:19 -0700687 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700688
689drop:
Eric Dumazet8d5b2c02009-10-23 06:14:38 +0000690 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691drop_nolock:
692 kfree_skb(skb);
Eric Dumazeta02cec22010-09-22 20:43:57 +0000693 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694}
695
Stephen Hemminger6fef4c02009-08-31 19:50:41 +0000696static netdev_tx_t ipgre_tunnel_xmit(struct sk_buff *skb, struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697{
Patrick McHardy2941a482006-01-08 22:05:26 -0800698 struct ip_tunnel *tunnel = netdev_priv(dev);
Eric Dumazete985aad2010-09-27 03:57:11 +0000699 struct pcpu_tstats *tstats;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700700 struct iphdr *old_iph = ip_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701 struct iphdr *tiph;
702 u8 tos;
Al Virod5a0a1e2006-11-08 00:23:14 -0800703 __be16 df;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704 struct rtable *rt; /* Route to the other host */
Eric Dumazet15078502010-09-15 11:07:53 +0000705 struct net_device *tdev; /* Device to other host */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706 struct iphdr *iph; /* Our new IP header */
Chuck Leverc2636b42007-10-23 21:07:32 -0700707 unsigned int max_headroom; /* The extra header space needed */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708 int gre_hlen;
Al Virod5a0a1e2006-11-08 00:23:14 -0800709 __be32 dst;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710 int mtu;
711
Herbert Xue1a80002008-10-09 12:00:17 -0700712 if (dev->type == ARPHRD_ETHER)
713 IPCB(skb)->flags = 0;
714
715 if (dev->header_ops && dev->type == ARPHRD_IPGRE) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716 gre_hlen = 0;
Jianjun Kong6ed25332008-11-03 00:25:16 -0800717 tiph = (struct iphdr *)skb->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718 } else {
719 gre_hlen = tunnel->hlen;
720 tiph = &tunnel->parms.iph;
721 }
722
723 if ((dst = tiph->daddr) == 0) {
724 /* NBMA tunnel */
725
Eric Dumazetadf30902009-06-02 05:19:30 +0000726 if (skb_dst(skb) == NULL) {
Eric Dumazete985aad2010-09-27 03:57:11 +0000727 dev->stats.tx_fifo_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728 goto tx_error;
729 }
730
731 if (skb->protocol == htons(ETH_P_IP)) {
Eric Dumazet511c3f92009-06-02 05:14:27 +0000732 rt = skb_rtable(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733 if ((dst = rt->rt_gateway) == 0)
734 goto tx_error_icmp;
735 }
Eric Dumazet842c74b2010-09-20 10:06:12 -0700736#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737 else if (skb->protocol == htons(ETH_P_IPV6)) {
738 struct in6_addr *addr6;
739 int addr_type;
Eric Dumazetadf30902009-06-02 05:19:30 +0000740 struct neighbour *neigh = skb_dst(skb)->neighbour;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741
742 if (neigh == NULL)
743 goto tx_error;
744
Jianjun Kong6ed25332008-11-03 00:25:16 -0800745 addr6 = (struct in6_addr *)&neigh->primary_key;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746 addr_type = ipv6_addr_type(addr6);
747
748 if (addr_type == IPV6_ADDR_ANY) {
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700749 addr6 = &ipv6_hdr(skb)->daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750 addr_type = ipv6_addr_type(addr6);
751 }
752
753 if ((addr_type & IPV6_ADDR_COMPATv4) == 0)
754 goto tx_error_icmp;
755
756 dst = addr6->s6_addr32[3];
757 }
758#endif
759 else
760 goto tx_error;
761 }
762
763 tos = tiph->tos;
Andreas Jaggiee686ca2009-07-14 09:35:59 -0700764 if (tos == 1) {
765 tos = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766 if (skb->protocol == htons(ETH_P_IP))
767 tos = old_iph->tos;
Stephen Hemmingerdd4ba832010-07-08 21:35:58 -0700768 else if (skb->protocol == htons(ETH_P_IPV6))
769 tos = ipv6_get_dsfield((struct ipv6hdr *)old_iph);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770 }
771
772 {
Eric Dumazete985aad2010-09-27 03:57:11 +0000773 struct flowi fl = {
774 .oif = tunnel->parms.link,
Changli Gao58116622010-11-12 18:43:55 +0000775 .fl4_dst = dst,
776 .fl4_src = tiph->saddr,
777 .fl4_tos = RT_TOS(tos),
Steffen Klassert946bf5e2011-02-11 11:21:57 -0800778 .proto = IPPROTO_GRE,
Timo Teräscc9ff192010-11-03 04:41:38 +0000779 .fl_gre_key = tunnel->parms.o_key
780 };
David S. Millerb23dd4f2011-03-02 14:31:35 -0800781 rt = ip_route_output_key(dev_net(dev), &fl);
782 if (IS_ERR(rt)) {
Eric Dumazete985aad2010-09-27 03:57:11 +0000783 dev->stats.tx_carrier_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784 goto tx_error;
785 }
786 }
Changli Gaod8d1f302010-06-10 23:31:35 -0700787 tdev = rt->dst.dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700788
789 if (tdev == dev) {
790 ip_rt_put(rt);
Eric Dumazete985aad2010-09-27 03:57:11 +0000791 dev->stats.collisions++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792 goto tx_error;
793 }
794
795 df = tiph->frag_off;
796 if (df)
Changli Gaod8d1f302010-06-10 23:31:35 -0700797 mtu = dst_mtu(&rt->dst) - dev->hard_header_len - tunnel->hlen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798 else
Eric Dumazetadf30902009-06-02 05:19:30 +0000799 mtu = skb_dst(skb) ? dst_mtu(skb_dst(skb)) : dev->mtu;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700800
Eric Dumazetadf30902009-06-02 05:19:30 +0000801 if (skb_dst(skb))
802 skb_dst(skb)->ops->update_pmtu(skb_dst(skb), mtu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803
804 if (skb->protocol == htons(ETH_P_IP)) {
805 df |= (old_iph->frag_off&htons(IP_DF));
806
807 if ((old_iph->frag_off&htons(IP_DF)) &&
808 mtu < ntohs(old_iph->tot_len)) {
809 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED, htonl(mtu));
810 ip_rt_put(rt);
811 goto tx_error;
812 }
813 }
Eric Dumazet842c74b2010-09-20 10:06:12 -0700814#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815 else if (skb->protocol == htons(ETH_P_IPV6)) {
Eric Dumazetadf30902009-06-02 05:19:30 +0000816 struct rt6_info *rt6 = (struct rt6_info *)skb_dst(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817
Eric Dumazetadf30902009-06-02 05:19:30 +0000818 if (rt6 && mtu < dst_mtu(skb_dst(skb)) && mtu >= IPV6_MIN_MTU) {
Joe Perchesf97c1e02007-12-16 13:45:43 -0800819 if ((tunnel->parms.iph.daddr &&
820 !ipv4_is_multicast(tunnel->parms.iph.daddr)) ||
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821 rt6->rt6i_dst.plen == 128) {
822 rt6->rt6i_flags |= RTF_MODIFIED;
David S. Millerdefb3512010-12-08 21:16:57 -0800823 dst_metric_set(skb_dst(skb), RTAX_MTU, mtu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824 }
825 }
826
827 if (mtu >= IPV6_MIN_MTU && mtu < skb->len - tunnel->hlen + gre_hlen) {
Alexey Dobriyan3ffe5332010-02-18 08:25:24 +0000828 icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, mtu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829 ip_rt_put(rt);
830 goto tx_error;
831 }
832 }
833#endif
834
835 if (tunnel->err_count > 0) {
Wei Yongjunda6185d82009-02-24 23:34:48 -0800836 if (time_before(jiffies,
837 tunnel->err_time + IPTUNNEL_ERR_TIMEO)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838 tunnel->err_count--;
839
840 dst_link_failure(skb);
841 } else
842 tunnel->err_count = 0;
843 }
844
Changli Gaod8d1f302010-06-10 23:31:35 -0700845 max_headroom = LL_RESERVED_SPACE(tdev) + gre_hlen + rt->dst.header_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700846
Patrick McHardycfbba492007-07-09 15:33:40 -0700847 if (skb_headroom(skb) < max_headroom || skb_shared(skb)||
848 (skb_cloned(skb) && !skb_clone_writable(skb, 0))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700849 struct sk_buff *new_skb = skb_realloc_headroom(skb, max_headroom);
Timo Teräs243aad82010-03-20 02:27:58 +0000850 if (max_headroom > dev->needed_headroom)
851 dev->needed_headroom = max_headroom;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852 if (!new_skb) {
853 ip_rt_put(rt);
Eric Dumazete985aad2010-09-27 03:57:11 +0000854 dev->stats.tx_dropped++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855 dev_kfree_skb(skb);
Patrick McHardy6ed10652009-06-23 06:03:08 +0000856 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700857 }
858 if (skb->sk)
859 skb_set_owner_w(new_skb, skb->sk);
860 dev_kfree_skb(skb);
861 skb = new_skb;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700862 old_iph = ip_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863 }
864
Herbert Xu64194c32008-10-09 12:03:17 -0700865 skb_reset_transport_header(skb);
Arnaldo Carvalho de Meloe2d1bca2007-04-10 20:46:21 -0700866 skb_push(skb, gre_hlen);
867 skb_reset_network_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868 memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
Patrick McHardy48d5cad2006-02-15 15:10:22 -0800869 IPCB(skb)->flags &= ~(IPSKB_XFRM_TUNNEL_SIZE | IPSKB_XFRM_TRANSFORMED |
870 IPSKB_REROUTED);
Eric Dumazetadf30902009-06-02 05:19:30 +0000871 skb_dst_drop(skb);
Changli Gaod8d1f302010-06-10 23:31:35 -0700872 skb_dst_set(skb, &rt->dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700873
874 /*
875 * Push down and install the IPIP header.
876 */
877
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700878 iph = ip_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700879 iph->version = 4;
880 iph->ihl = sizeof(struct iphdr) >> 2;
881 iph->frag_off = df;
882 iph->protocol = IPPROTO_GRE;
883 iph->tos = ipgre_ecn_encapsulate(tos, old_iph, skb);
884 iph->daddr = rt->rt_dst;
885 iph->saddr = rt->rt_src;
886
887 if ((iph->ttl = tiph->ttl) == 0) {
888 if (skb->protocol == htons(ETH_P_IP))
889 iph->ttl = old_iph->ttl;
Eric Dumazet842c74b2010-09-20 10:06:12 -0700890#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700891 else if (skb->protocol == htons(ETH_P_IPV6))
Jianjun Kong6ed25332008-11-03 00:25:16 -0800892 iph->ttl = ((struct ipv6hdr *)old_iph)->hop_limit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700893#endif
894 else
David S. Miller323e1262010-12-12 21:55:08 -0800895 iph->ttl = ip4_dst_hoplimit(&rt->dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896 }
897
Herbert Xue1a80002008-10-09 12:00:17 -0700898 ((__be16 *)(iph + 1))[0] = tunnel->parms.o_flags;
899 ((__be16 *)(iph + 1))[1] = (dev->type == ARPHRD_ETHER) ?
900 htons(ETH_P_TEB) : skb->protocol;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700901
902 if (tunnel->parms.o_flags&(GRE_KEY|GRE_CSUM|GRE_SEQ)) {
Al Virod5a0a1e2006-11-08 00:23:14 -0800903 __be32 *ptr = (__be32*)(((u8*)iph) + tunnel->hlen - 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700904
905 if (tunnel->parms.o_flags&GRE_SEQ) {
906 ++tunnel->o_seqno;
907 *ptr = htonl(tunnel->o_seqno);
908 ptr--;
909 }
910 if (tunnel->parms.o_flags&GRE_KEY) {
911 *ptr = tunnel->parms.o_key;
912 ptr--;
913 }
914 if (tunnel->parms.o_flags&GRE_CSUM) {
915 *ptr = 0;
Al Viro5f92a732006-11-14 21:36:54 -0800916 *(__sum16*)ptr = ip_compute_csum((void*)(iph+1), skb->len - sizeof(struct iphdr));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700917 }
918 }
919
920 nf_reset(skb);
Eric Dumazete985aad2010-09-27 03:57:11 +0000921 tstats = this_cpu_ptr(dev->tstats);
922 __IPTUNNEL_XMIT(tstats, &dev->stats);
Patrick McHardy6ed10652009-06-23 06:03:08 +0000923 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700924
925tx_error_icmp:
926 dst_link_failure(skb);
927
928tx_error:
Eric Dumazete985aad2010-09-27 03:57:11 +0000929 dev->stats.tx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700930 dev_kfree_skb(skb);
Patrick McHardy6ed10652009-06-23 06:03:08 +0000931 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700932}
933
Herbert Xu42aa9162008-10-09 11:59:32 -0700934static int ipgre_tunnel_bind_dev(struct net_device *dev)
Michal Schmidtee34c1e2007-12-13 09:46:32 -0800935{
936 struct net_device *tdev = NULL;
937 struct ip_tunnel *tunnel;
938 struct iphdr *iph;
939 int hlen = LL_MAX_HEADER;
940 int mtu = ETH_DATA_LEN;
941 int addend = sizeof(struct iphdr) + 4;
942
943 tunnel = netdev_priv(dev);
944 iph = &tunnel->parms.iph;
945
Herbert Xuc95b8192008-10-09 11:58:54 -0700946 /* Guess output device to choose reasonable mtu and needed_headroom */
Michal Schmidtee34c1e2007-12-13 09:46:32 -0800947
948 if (iph->daddr) {
Eric Dumazete985aad2010-09-27 03:57:11 +0000949 struct flowi fl = {
950 .oif = tunnel->parms.link,
Changli Gao58116622010-11-12 18:43:55 +0000951 .fl4_dst = iph->daddr,
952 .fl4_src = iph->saddr,
953 .fl4_tos = RT_TOS(iph->tos),
Timo Teräscc9ff192010-11-03 04:41:38 +0000954 .proto = IPPROTO_GRE,
955 .fl_gre_key = tunnel->parms.o_key
Eric Dumazete985aad2010-09-27 03:57:11 +0000956 };
David S. Millerb23dd4f2011-03-02 14:31:35 -0800957 struct rtable *rt = ip_route_output_key(dev_net(dev), &fl);
Eric Dumazete985aad2010-09-27 03:57:11 +0000958
David S. Millerb23dd4f2011-03-02 14:31:35 -0800959 if (!IS_ERR(rt)) {
Changli Gaod8d1f302010-06-10 23:31:35 -0700960 tdev = rt->dst.dev;
Michal Schmidtee34c1e2007-12-13 09:46:32 -0800961 ip_rt_put(rt);
962 }
Herbert Xue1a80002008-10-09 12:00:17 -0700963
964 if (dev->type != ARPHRD_ETHER)
965 dev->flags |= IFF_POINTOPOINT;
Michal Schmidtee34c1e2007-12-13 09:46:32 -0800966 }
967
968 if (!tdev && tunnel->parms.link)
Pavel Emelyanov96635522008-04-16 01:10:44 -0700969 tdev = __dev_get_by_index(dev_net(dev), tunnel->parms.link);
Michal Schmidtee34c1e2007-12-13 09:46:32 -0800970
971 if (tdev) {
Herbert Xuc95b8192008-10-09 11:58:54 -0700972 hlen = tdev->hard_header_len + tdev->needed_headroom;
Michal Schmidtee34c1e2007-12-13 09:46:32 -0800973 mtu = tdev->mtu;
974 }
975 dev->iflink = tunnel->parms.link;
976
977 /* Precalculate GRE options length */
978 if (tunnel->parms.o_flags&(GRE_CSUM|GRE_KEY|GRE_SEQ)) {
979 if (tunnel->parms.o_flags&GRE_CSUM)
980 addend += 4;
981 if (tunnel->parms.o_flags&GRE_KEY)
982 addend += 4;
983 if (tunnel->parms.o_flags&GRE_SEQ)
984 addend += 4;
985 }
Herbert Xuc95b8192008-10-09 11:58:54 -0700986 dev->needed_headroom = addend + hlen;
Tom Goff8cdb0452009-08-14 16:33:56 -0700987 mtu -= dev->hard_header_len + addend;
Herbert Xu42aa9162008-10-09 11:59:32 -0700988
989 if (mtu < 68)
990 mtu = 68;
991
Michal Schmidtee34c1e2007-12-13 09:46:32 -0800992 tunnel->hlen = addend;
993
Herbert Xu42aa9162008-10-09 11:59:32 -0700994 return mtu;
Michal Schmidtee34c1e2007-12-13 09:46:32 -0800995}
996
Linus Torvalds1da177e2005-04-16 15:20:36 -0700997static int
998ipgre_tunnel_ioctl (struct net_device *dev, struct ifreq *ifr, int cmd)
999{
1000 int err = 0;
1001 struct ip_tunnel_parm p;
1002 struct ip_tunnel *t;
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -07001003 struct net *net = dev_net(dev);
1004 struct ipgre_net *ign = net_generic(net, ipgre_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001005
1006 switch (cmd) {
1007 case SIOCGETTUNNEL:
1008 t = NULL;
Pavel Emelyanov7daa0002008-04-16 01:10:05 -07001009 if (dev == ign->fb_tunnel_dev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001010 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p))) {
1011 err = -EFAULT;
1012 break;
1013 }
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -07001014 t = ipgre_tunnel_locate(net, &p, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001015 }
1016 if (t == NULL)
Patrick McHardy2941a482006-01-08 22:05:26 -08001017 t = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001018 memcpy(&p, &t->parms, sizeof(p));
1019 if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p)))
1020 err = -EFAULT;
1021 break;
1022
1023 case SIOCADDTUNNEL:
1024 case SIOCCHGTUNNEL:
1025 err = -EPERM;
1026 if (!capable(CAP_NET_ADMIN))
1027 goto done;
1028
1029 err = -EFAULT;
1030 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
1031 goto done;
1032
1033 err = -EINVAL;
1034 if (p.iph.version != 4 || p.iph.protocol != IPPROTO_GRE ||
1035 p.iph.ihl != 5 || (p.iph.frag_off&htons(~IP_DF)) ||
1036 ((p.i_flags|p.o_flags)&(GRE_VERSION|GRE_ROUTING)))
1037 goto done;
1038 if (p.iph.ttl)
1039 p.iph.frag_off |= htons(IP_DF);
1040
1041 if (!(p.i_flags&GRE_KEY))
1042 p.i_key = 0;
1043 if (!(p.o_flags&GRE_KEY))
1044 p.o_key = 0;
1045
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -07001046 t = ipgre_tunnel_locate(net, &p, cmd == SIOCADDTUNNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001047
Pavel Emelyanov7daa0002008-04-16 01:10:05 -07001048 if (dev != ign->fb_tunnel_dev && cmd == SIOCCHGTUNNEL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001049 if (t != NULL) {
1050 if (t->dev != dev) {
1051 err = -EEXIST;
1052 break;
1053 }
1054 } else {
Eric Dumazet15078502010-09-15 11:07:53 +00001055 unsigned int nflags = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001056
Patrick McHardy2941a482006-01-08 22:05:26 -08001057 t = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001058
Joe Perchesf97c1e02007-12-16 13:45:43 -08001059 if (ipv4_is_multicast(p.iph.daddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001060 nflags = IFF_BROADCAST;
1061 else if (p.iph.daddr)
1062 nflags = IFF_POINTOPOINT;
1063
1064 if ((dev->flags^nflags)&(IFF_POINTOPOINT|IFF_BROADCAST)) {
1065 err = -EINVAL;
1066 break;
1067 }
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -07001068 ipgre_tunnel_unlink(ign, t);
Pavel Emelyanov74b0b852010-10-27 05:43:53 +00001069 synchronize_net();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001070 t->parms.iph.saddr = p.iph.saddr;
1071 t->parms.iph.daddr = p.iph.daddr;
1072 t->parms.i_key = p.i_key;
1073 t->parms.o_key = p.o_key;
1074 memcpy(dev->dev_addr, &p.iph.saddr, 4);
1075 memcpy(dev->broadcast, &p.iph.daddr, 4);
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -07001076 ipgre_tunnel_link(ign, t);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001077 netdev_state_change(dev);
1078 }
1079 }
1080
1081 if (t) {
1082 err = 0;
1083 if (cmd == SIOCCHGTUNNEL) {
1084 t->parms.iph.ttl = p.iph.ttl;
1085 t->parms.iph.tos = p.iph.tos;
1086 t->parms.iph.frag_off = p.iph.frag_off;
Michal Schmidtee34c1e2007-12-13 09:46:32 -08001087 if (t->parms.link != p.link) {
1088 t->parms.link = p.link;
Herbert Xu42aa9162008-10-09 11:59:32 -07001089 dev->mtu = ipgre_tunnel_bind_dev(dev);
Michal Schmidtee34c1e2007-12-13 09:46:32 -08001090 netdev_state_change(dev);
1091 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001092 }
1093 if (copy_to_user(ifr->ifr_ifru.ifru_data, &t->parms, sizeof(p)))
1094 err = -EFAULT;
1095 } else
1096 err = (cmd == SIOCADDTUNNEL ? -ENOBUFS : -ENOENT);
1097 break;
1098
1099 case SIOCDELTUNNEL:
1100 err = -EPERM;
1101 if (!capable(CAP_NET_ADMIN))
1102 goto done;
1103
Pavel Emelyanov7daa0002008-04-16 01:10:05 -07001104 if (dev == ign->fb_tunnel_dev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001105 err = -EFAULT;
1106 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
1107 goto done;
1108 err = -ENOENT;
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -07001109 if ((t = ipgre_tunnel_locate(net, &p, 0)) == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001110 goto done;
1111 err = -EPERM;
Pavel Emelyanov7daa0002008-04-16 01:10:05 -07001112 if (t == netdev_priv(ign->fb_tunnel_dev))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001113 goto done;
1114 dev = t->dev;
1115 }
Stephen Hemminger22f8cde2007-02-07 00:09:58 -08001116 unregister_netdevice(dev);
1117 err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001118 break;
1119
1120 default:
1121 err = -EINVAL;
1122 }
1123
1124done:
1125 return err;
1126}
1127
Linus Torvalds1da177e2005-04-16 15:20:36 -07001128static int ipgre_tunnel_change_mtu(struct net_device *dev, int new_mtu)
1129{
Patrick McHardy2941a482006-01-08 22:05:26 -08001130 struct ip_tunnel *tunnel = netdev_priv(dev);
Herbert Xuc95b8192008-10-09 11:58:54 -07001131 if (new_mtu < 68 ||
1132 new_mtu > 0xFFF8 - dev->hard_header_len - tunnel->hlen)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001133 return -EINVAL;
1134 dev->mtu = new_mtu;
1135 return 0;
1136}
1137
Linus Torvalds1da177e2005-04-16 15:20:36 -07001138/* Nice toy. Unfortunately, useless in real life :-)
1139 It allows to construct virtual multiprotocol broadcast "LAN"
1140 over the Internet, provided multicast routing is tuned.
1141
1142
1143 I have no idea was this bicycle invented before me,
1144 so that I had to set ARPHRD_IPGRE to a random value.
1145 I have an impression, that Cisco could make something similar,
1146 but this feature is apparently missing in IOS<=11.2(8).
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001147
Linus Torvalds1da177e2005-04-16 15:20:36 -07001148 I set up 10.66.66/24 and fec0:6666:6666::0/96 as virtual networks
1149 with broadcast 224.66.66.66. If you have access to mbone, play with me :-)
1150
1151 ping -t 255 224.66.66.66
1152
1153 If nobody answers, mbone does not work.
1154
1155 ip tunnel add Universe mode gre remote 224.66.66.66 local <Your_real_addr> ttl 255
1156 ip addr add 10.66.66.<somewhat>/24 dev Universe
1157 ifconfig Universe up
1158 ifconfig Universe add fe80::<Your_real_addr>/10
1159 ifconfig Universe add fec0:6666:6666::<Your_real_addr>/96
1160 ftp 10.66.66.66
1161 ...
1162 ftp fec0:6666:6666::193.233.7.65
1163 ...
1164
1165 */
1166
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -07001167static int ipgre_header(struct sk_buff *skb, struct net_device *dev,
1168 unsigned short type,
Eric Dumazet15078502010-09-15 11:07:53 +00001169 const void *daddr, const void *saddr, unsigned int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001170{
Patrick McHardy2941a482006-01-08 22:05:26 -08001171 struct ip_tunnel *t = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001172 struct iphdr *iph = (struct iphdr *)skb_push(skb, t->hlen);
Al Virod5a0a1e2006-11-08 00:23:14 -08001173 __be16 *p = (__be16*)(iph+1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001174
1175 memcpy(iph, &t->parms.iph, sizeof(struct iphdr));
1176 p[0] = t->parms.o_flags;
1177 p[1] = htons(type);
1178
1179 /*
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001180 * Set the source hardware address.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001181 */
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001182
Linus Torvalds1da177e2005-04-16 15:20:36 -07001183 if (saddr)
1184 memcpy(&iph->saddr, saddr, 4);
Timo Teräs6d55cb92010-03-03 04:01:13 +00001185 if (daddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001186 memcpy(&iph->daddr, daddr, 4);
Timo Teräs6d55cb92010-03-03 04:01:13 +00001187 if (iph->daddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001188 return t->hlen;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001189
Linus Torvalds1da177e2005-04-16 15:20:36 -07001190 return -t->hlen;
1191}
1192
Timo Teras6a5f44d2007-10-23 20:31:53 -07001193static int ipgre_header_parse(const struct sk_buff *skb, unsigned char *haddr)
1194{
Jianjun Kong6ed25332008-11-03 00:25:16 -08001195 struct iphdr *iph = (struct iphdr *) skb_mac_header(skb);
Timo Teras6a5f44d2007-10-23 20:31:53 -07001196 memcpy(haddr, &iph->saddr, 4);
1197 return 4;
1198}
1199
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -07001200static const struct header_ops ipgre_header_ops = {
1201 .create = ipgre_header,
Timo Teras6a5f44d2007-10-23 20:31:53 -07001202 .parse = ipgre_header_parse,
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -07001203};
1204
Timo Teras6a5f44d2007-10-23 20:31:53 -07001205#ifdef CONFIG_NET_IPGRE_BROADCAST
Linus Torvalds1da177e2005-04-16 15:20:36 -07001206static int ipgre_open(struct net_device *dev)
1207{
Patrick McHardy2941a482006-01-08 22:05:26 -08001208 struct ip_tunnel *t = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001209
Joe Perchesf97c1e02007-12-16 13:45:43 -08001210 if (ipv4_is_multicast(t->parms.iph.daddr)) {
Eric Dumazete985aad2010-09-27 03:57:11 +00001211 struct flowi fl = {
1212 .oif = t->parms.link,
Changli Gao58116622010-11-12 18:43:55 +00001213 .fl4_dst = t->parms.iph.daddr,
1214 .fl4_src = t->parms.iph.saddr,
1215 .fl4_tos = RT_TOS(t->parms.iph.tos),
Timo Teräscc9ff192010-11-03 04:41:38 +00001216 .proto = IPPROTO_GRE,
1217 .fl_gre_key = t->parms.o_key
Eric Dumazete985aad2010-09-27 03:57:11 +00001218 };
David S. Millerb23dd4f2011-03-02 14:31:35 -08001219 struct rtable *rt = ip_route_output_key(dev_net(dev), &fl);
Eric Dumazete985aad2010-09-27 03:57:11 +00001220
David S. Millerb23dd4f2011-03-02 14:31:35 -08001221 if (IS_ERR(rt))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001222 return -EADDRNOTAVAIL;
Changli Gaod8d1f302010-06-10 23:31:35 -07001223 dev = rt->dst.dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001224 ip_rt_put(rt);
Herbert Xue5ed6392005-10-03 14:35:55 -07001225 if (__in_dev_get_rtnl(dev) == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001226 return -EADDRNOTAVAIL;
1227 t->mlink = dev->ifindex;
Herbert Xue5ed6392005-10-03 14:35:55 -07001228 ip_mc_inc_group(__in_dev_get_rtnl(dev), t->parms.iph.daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001229 }
1230 return 0;
1231}
1232
1233static int ipgre_close(struct net_device *dev)
1234{
Patrick McHardy2941a482006-01-08 22:05:26 -08001235 struct ip_tunnel *t = netdev_priv(dev);
Stephen Hemmingerb8c26a32008-11-20 20:34:29 -08001236
Joe Perchesf97c1e02007-12-16 13:45:43 -08001237 if (ipv4_is_multicast(t->parms.iph.daddr) && t->mlink) {
Denis V. Lunev7fee0ca2008-01-21 17:32:38 -08001238 struct in_device *in_dev;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001239 in_dev = inetdev_by_index(dev_net(dev), t->mlink);
Eric Dumazet8723e1b2010-10-19 00:39:26 +00001240 if (in_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001241 ip_mc_dec_group(in_dev, t->parms.iph.daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001242 }
1243 return 0;
1244}
1245
1246#endif
1247
Stephen Hemmingerb8c26a32008-11-20 20:34:29 -08001248static const struct net_device_ops ipgre_netdev_ops = {
1249 .ndo_init = ipgre_tunnel_init,
1250 .ndo_uninit = ipgre_tunnel_uninit,
1251#ifdef CONFIG_NET_IPGRE_BROADCAST
1252 .ndo_open = ipgre_open,
1253 .ndo_stop = ipgre_close,
1254#endif
1255 .ndo_start_xmit = ipgre_tunnel_xmit,
1256 .ndo_do_ioctl = ipgre_tunnel_ioctl,
1257 .ndo_change_mtu = ipgre_tunnel_change_mtu,
Eric Dumazete985aad2010-09-27 03:57:11 +00001258 .ndo_get_stats = ipgre_get_stats,
Stephen Hemmingerb8c26a32008-11-20 20:34:29 -08001259};
1260
Eric Dumazete985aad2010-09-27 03:57:11 +00001261static void ipgre_dev_free(struct net_device *dev)
1262{
1263 free_percpu(dev->tstats);
1264 free_netdev(dev);
1265}
1266
Linus Torvalds1da177e2005-04-16 15:20:36 -07001267static void ipgre_tunnel_setup(struct net_device *dev)
1268{
Stephen Hemmingerb8c26a32008-11-20 20:34:29 -08001269 dev->netdev_ops = &ipgre_netdev_ops;
Eric Dumazete985aad2010-09-27 03:57:11 +00001270 dev->destructor = ipgre_dev_free;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001271
1272 dev->type = ARPHRD_IPGRE;
Herbert Xuc95b8192008-10-09 11:58:54 -07001273 dev->needed_headroom = LL_MAX_HEADER + sizeof(struct iphdr) + 4;
Kris Katterjohn46f25df2006-01-05 16:35:42 -08001274 dev->mtu = ETH_DATA_LEN - sizeof(struct iphdr) - 4;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001275 dev->flags = IFF_NOARP;
1276 dev->iflink = 0;
1277 dev->addr_len = 4;
Pavel Emelyanov0b67ece2008-04-16 01:11:13 -07001278 dev->features |= NETIF_F_NETNS_LOCAL;
Eric Dumazet108bfa82009-05-28 22:35:10 +00001279 dev->priv_flags &= ~IFF_XMIT_DST_RELEASE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001280}
1281
1282static int ipgre_tunnel_init(struct net_device *dev)
1283{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001284 struct ip_tunnel *tunnel;
1285 struct iphdr *iph;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001286
Patrick McHardy2941a482006-01-08 22:05:26 -08001287 tunnel = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001288 iph = &tunnel->parms.iph;
1289
1290 tunnel->dev = dev;
1291 strcpy(tunnel->parms.name, dev->name);
1292
1293 memcpy(dev->dev_addr, &tunnel->parms.iph.saddr, 4);
1294 memcpy(dev->broadcast, &tunnel->parms.iph.daddr, 4);
1295
Linus Torvalds1da177e2005-04-16 15:20:36 -07001296 if (iph->daddr) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001297#ifdef CONFIG_NET_IPGRE_BROADCAST
Joe Perchesf97c1e02007-12-16 13:45:43 -08001298 if (ipv4_is_multicast(iph->daddr)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001299 if (!iph->saddr)
1300 return -EINVAL;
1301 dev->flags = IFF_BROADCAST;
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -07001302 dev->header_ops = &ipgre_header_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001303 }
1304#endif
Michal Schmidtee34c1e2007-12-13 09:46:32 -08001305 } else
Timo Teras6a5f44d2007-10-23 20:31:53 -07001306 dev->header_ops = &ipgre_header_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001307
Eric Dumazete985aad2010-09-27 03:57:11 +00001308 dev->tstats = alloc_percpu(struct pcpu_tstats);
1309 if (!dev->tstats)
1310 return -ENOMEM;
1311
Linus Torvalds1da177e2005-04-16 15:20:36 -07001312 return 0;
1313}
1314
Stephen Hemmingerb8c26a32008-11-20 20:34:29 -08001315static void ipgre_fb_tunnel_init(struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001316{
Patrick McHardy2941a482006-01-08 22:05:26 -08001317 struct ip_tunnel *tunnel = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001318 struct iphdr *iph = &tunnel->parms.iph;
1319
1320 tunnel->dev = dev;
1321 strcpy(tunnel->parms.name, dev->name);
1322
1323 iph->version = 4;
1324 iph->protocol = IPPROTO_GRE;
1325 iph->ihl = 5;
1326 tunnel->hlen = sizeof(struct iphdr) + 4;
1327
1328 dev_hold(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001329}
1330
1331
Dmitry Kozlov00959ad2010-08-21 23:05:39 -07001332static const struct gre_protocol ipgre_protocol = {
1333 .handler = ipgre_rcv,
1334 .err_handler = ipgre_err,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001335};
1336
Eric Dumazeteef6dd62009-10-27 07:07:16 +00001337static void ipgre_destroy_tunnels(struct ipgre_net *ign, struct list_head *head)
Pavel Emelyanoveb8ce742008-04-16 01:10:26 -07001338{
1339 int prio;
1340
1341 for (prio = 0; prio < 4; prio++) {
1342 int h;
1343 for (h = 0; h < HASH_SIZE; h++) {
Eric Dumazet15078502010-09-15 11:07:53 +00001344 struct ip_tunnel *t;
1345
1346 t = rtnl_dereference(ign->tunnels[prio][h]);
Eric Dumazeteef6dd62009-10-27 07:07:16 +00001347
1348 while (t != NULL) {
1349 unregister_netdevice_queue(t->dev, head);
Eric Dumazet15078502010-09-15 11:07:53 +00001350 t = rtnl_dereference(t->next);
Eric Dumazeteef6dd62009-10-27 07:07:16 +00001351 }
Pavel Emelyanoveb8ce742008-04-16 01:10:26 -07001352 }
1353 }
1354}
1355
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00001356static int __net_init ipgre_init_net(struct net *net)
Pavel Emelyanov59a4c752008-04-16 01:08:53 -07001357{
Eric W. Biedermancfb8fbf2009-11-29 15:46:13 +00001358 struct ipgre_net *ign = net_generic(net, ipgre_net_id);
Pavel Emelyanov59a4c752008-04-16 01:08:53 -07001359 int err;
Pavel Emelyanov59a4c752008-04-16 01:08:53 -07001360
Pavel Emelyanov7daa0002008-04-16 01:10:05 -07001361 ign->fb_tunnel_dev = alloc_netdev(sizeof(struct ip_tunnel), "gre0",
1362 ipgre_tunnel_setup);
1363 if (!ign->fb_tunnel_dev) {
1364 err = -ENOMEM;
1365 goto err_alloc_dev;
1366 }
Alexey Dobriyanbe77e592008-11-23 17:26:26 -08001367 dev_net_set(ign->fb_tunnel_dev, net);
Pavel Emelyanov7daa0002008-04-16 01:10:05 -07001368
Stephen Hemmingerb8c26a32008-11-20 20:34:29 -08001369 ipgre_fb_tunnel_init(ign->fb_tunnel_dev);
Herbert Xuc19e6542008-10-09 11:59:55 -07001370 ign->fb_tunnel_dev->rtnl_link_ops = &ipgre_link_ops;
Pavel Emelyanov7daa0002008-04-16 01:10:05 -07001371
1372 if ((err = register_netdev(ign->fb_tunnel_dev)))
1373 goto err_reg_dev;
1374
Eric Dumazet3285ee32010-10-30 16:21:28 -07001375 rcu_assign_pointer(ign->tunnels_wc[0],
1376 netdev_priv(ign->fb_tunnel_dev));
Pavel Emelyanov59a4c752008-04-16 01:08:53 -07001377 return 0;
1378
Pavel Emelyanov7daa0002008-04-16 01:10:05 -07001379err_reg_dev:
Eric Dumazet3285ee32010-10-30 16:21:28 -07001380 ipgre_dev_free(ign->fb_tunnel_dev);
Pavel Emelyanov7daa0002008-04-16 01:10:05 -07001381err_alloc_dev:
Pavel Emelyanov59a4c752008-04-16 01:08:53 -07001382 return err;
1383}
1384
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +00001385static void __net_exit ipgre_exit_net(struct net *net)
Pavel Emelyanov59a4c752008-04-16 01:08:53 -07001386{
1387 struct ipgre_net *ign;
Eric Dumazeteef6dd62009-10-27 07:07:16 +00001388 LIST_HEAD(list);
Pavel Emelyanov59a4c752008-04-16 01:08:53 -07001389
1390 ign = net_generic(net, ipgre_net_id);
Pavel Emelyanov7daa0002008-04-16 01:10:05 -07001391 rtnl_lock();
Eric Dumazeteef6dd62009-10-27 07:07:16 +00001392 ipgre_destroy_tunnels(ign, &list);
1393 unregister_netdevice_many(&list);
Pavel Emelyanov7daa0002008-04-16 01:10:05 -07001394 rtnl_unlock();
Pavel Emelyanov59a4c752008-04-16 01:08:53 -07001395}
1396
1397static struct pernet_operations ipgre_net_ops = {
1398 .init = ipgre_init_net,
1399 .exit = ipgre_exit_net,
Eric W. Biedermancfb8fbf2009-11-29 15:46:13 +00001400 .id = &ipgre_net_id,
1401 .size = sizeof(struct ipgre_net),
Pavel Emelyanov59a4c752008-04-16 01:08:53 -07001402};
Linus Torvalds1da177e2005-04-16 15:20:36 -07001403
Herbert Xuc19e6542008-10-09 11:59:55 -07001404static int ipgre_tunnel_validate(struct nlattr *tb[], struct nlattr *data[])
1405{
1406 __be16 flags;
1407
1408 if (!data)
1409 return 0;
1410
1411 flags = 0;
1412 if (data[IFLA_GRE_IFLAGS])
1413 flags |= nla_get_be16(data[IFLA_GRE_IFLAGS]);
1414 if (data[IFLA_GRE_OFLAGS])
1415 flags |= nla_get_be16(data[IFLA_GRE_OFLAGS]);
1416 if (flags & (GRE_VERSION|GRE_ROUTING))
1417 return -EINVAL;
1418
1419 return 0;
1420}
1421
Herbert Xue1a80002008-10-09 12:00:17 -07001422static int ipgre_tap_validate(struct nlattr *tb[], struct nlattr *data[])
1423{
1424 __be32 daddr;
1425
1426 if (tb[IFLA_ADDRESS]) {
1427 if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
1428 return -EINVAL;
1429 if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
1430 return -EADDRNOTAVAIL;
1431 }
1432
1433 if (!data)
1434 goto out;
1435
1436 if (data[IFLA_GRE_REMOTE]) {
1437 memcpy(&daddr, nla_data(data[IFLA_GRE_REMOTE]), 4);
1438 if (!daddr)
1439 return -EINVAL;
1440 }
1441
1442out:
1443 return ipgre_tunnel_validate(tb, data);
1444}
1445
Herbert Xuc19e6542008-10-09 11:59:55 -07001446static void ipgre_netlink_parms(struct nlattr *data[],
1447 struct ip_tunnel_parm *parms)
1448{
Herbert Xu7bb82d92008-10-11 12:20:15 -07001449 memset(parms, 0, sizeof(*parms));
Herbert Xuc19e6542008-10-09 11:59:55 -07001450
1451 parms->iph.protocol = IPPROTO_GRE;
1452
1453 if (!data)
1454 return;
1455
1456 if (data[IFLA_GRE_LINK])
1457 parms->link = nla_get_u32(data[IFLA_GRE_LINK]);
1458
1459 if (data[IFLA_GRE_IFLAGS])
1460 parms->i_flags = nla_get_be16(data[IFLA_GRE_IFLAGS]);
1461
1462 if (data[IFLA_GRE_OFLAGS])
1463 parms->o_flags = nla_get_be16(data[IFLA_GRE_OFLAGS]);
1464
1465 if (data[IFLA_GRE_IKEY])
1466 parms->i_key = nla_get_be32(data[IFLA_GRE_IKEY]);
1467
1468 if (data[IFLA_GRE_OKEY])
1469 parms->o_key = nla_get_be32(data[IFLA_GRE_OKEY]);
1470
1471 if (data[IFLA_GRE_LOCAL])
Patrick McHardy4d74f8b2008-10-10 12:11:06 -07001472 parms->iph.saddr = nla_get_be32(data[IFLA_GRE_LOCAL]);
Herbert Xuc19e6542008-10-09 11:59:55 -07001473
1474 if (data[IFLA_GRE_REMOTE])
Patrick McHardy4d74f8b2008-10-10 12:11:06 -07001475 parms->iph.daddr = nla_get_be32(data[IFLA_GRE_REMOTE]);
Herbert Xuc19e6542008-10-09 11:59:55 -07001476
1477 if (data[IFLA_GRE_TTL])
1478 parms->iph.ttl = nla_get_u8(data[IFLA_GRE_TTL]);
1479
1480 if (data[IFLA_GRE_TOS])
1481 parms->iph.tos = nla_get_u8(data[IFLA_GRE_TOS]);
1482
1483 if (!data[IFLA_GRE_PMTUDISC] || nla_get_u8(data[IFLA_GRE_PMTUDISC]))
1484 parms->iph.frag_off = htons(IP_DF);
1485}
1486
Herbert Xue1a80002008-10-09 12:00:17 -07001487static int ipgre_tap_init(struct net_device *dev)
1488{
1489 struct ip_tunnel *tunnel;
1490
1491 tunnel = netdev_priv(dev);
1492
1493 tunnel->dev = dev;
1494 strcpy(tunnel->parms.name, dev->name);
1495
1496 ipgre_tunnel_bind_dev(dev);
1497
Eric Dumazete985aad2010-09-27 03:57:11 +00001498 dev->tstats = alloc_percpu(struct pcpu_tstats);
1499 if (!dev->tstats)
1500 return -ENOMEM;
1501
Herbert Xue1a80002008-10-09 12:00:17 -07001502 return 0;
1503}
1504
Stephen Hemmingerb8c26a32008-11-20 20:34:29 -08001505static const struct net_device_ops ipgre_tap_netdev_ops = {
1506 .ndo_init = ipgre_tap_init,
1507 .ndo_uninit = ipgre_tunnel_uninit,
1508 .ndo_start_xmit = ipgre_tunnel_xmit,
1509 .ndo_set_mac_address = eth_mac_addr,
1510 .ndo_validate_addr = eth_validate_addr,
1511 .ndo_change_mtu = ipgre_tunnel_change_mtu,
Eric Dumazete985aad2010-09-27 03:57:11 +00001512 .ndo_get_stats = ipgre_get_stats,
Stephen Hemmingerb8c26a32008-11-20 20:34:29 -08001513};
1514
Herbert Xue1a80002008-10-09 12:00:17 -07001515static void ipgre_tap_setup(struct net_device *dev)
1516{
1517
1518 ether_setup(dev);
1519
Herbert Xu2e9526b2009-10-30 05:51:48 +00001520 dev->netdev_ops = &ipgre_tap_netdev_ops;
Eric Dumazete985aad2010-09-27 03:57:11 +00001521 dev->destructor = ipgre_dev_free;
Herbert Xue1a80002008-10-09 12:00:17 -07001522
1523 dev->iflink = 0;
1524 dev->features |= NETIF_F_NETNS_LOCAL;
1525}
1526
Eric W. Biederman81adee42009-11-08 00:53:51 -08001527static int ipgre_newlink(struct net *src_net, struct net_device *dev, struct nlattr *tb[],
Herbert Xuc19e6542008-10-09 11:59:55 -07001528 struct nlattr *data[])
1529{
1530 struct ip_tunnel *nt;
1531 struct net *net = dev_net(dev);
1532 struct ipgre_net *ign = net_generic(net, ipgre_net_id);
1533 int mtu;
1534 int err;
1535
1536 nt = netdev_priv(dev);
1537 ipgre_netlink_parms(data, &nt->parms);
1538
Herbert Xue1a80002008-10-09 12:00:17 -07001539 if (ipgre_tunnel_find(net, &nt->parms, dev->type))
Herbert Xuc19e6542008-10-09 11:59:55 -07001540 return -EEXIST;
1541
Herbert Xue1a80002008-10-09 12:00:17 -07001542 if (dev->type == ARPHRD_ETHER && !tb[IFLA_ADDRESS])
1543 random_ether_addr(dev->dev_addr);
1544
Herbert Xuc19e6542008-10-09 11:59:55 -07001545 mtu = ipgre_tunnel_bind_dev(dev);
1546 if (!tb[IFLA_MTU])
1547 dev->mtu = mtu;
1548
Eric Dumazetb790e012010-09-27 23:05:47 +00001549 /* Can use a lockless transmit, unless we generate output sequences */
1550 if (!(nt->parms.o_flags & GRE_SEQ))
1551 dev->features |= NETIF_F_LLTX;
1552
Herbert Xuc19e6542008-10-09 11:59:55 -07001553 err = register_netdevice(dev);
1554 if (err)
1555 goto out;
1556
1557 dev_hold(dev);
1558 ipgre_tunnel_link(ign, nt);
1559
1560out:
1561 return err;
1562}
1563
1564static int ipgre_changelink(struct net_device *dev, struct nlattr *tb[],
1565 struct nlattr *data[])
1566{
1567 struct ip_tunnel *t, *nt;
1568 struct net *net = dev_net(dev);
1569 struct ipgre_net *ign = net_generic(net, ipgre_net_id);
1570 struct ip_tunnel_parm p;
1571 int mtu;
1572
1573 if (dev == ign->fb_tunnel_dev)
1574 return -EINVAL;
1575
1576 nt = netdev_priv(dev);
1577 ipgre_netlink_parms(data, &p);
1578
1579 t = ipgre_tunnel_locate(net, &p, 0);
1580
1581 if (t) {
1582 if (t->dev != dev)
1583 return -EEXIST;
1584 } else {
Herbert Xuc19e6542008-10-09 11:59:55 -07001585 t = nt;
1586
Herbert Xu2e9526b2009-10-30 05:51:48 +00001587 if (dev->type != ARPHRD_ETHER) {
Eric Dumazet15078502010-09-15 11:07:53 +00001588 unsigned int nflags = 0;
Herbert Xuc19e6542008-10-09 11:59:55 -07001589
Herbert Xu2e9526b2009-10-30 05:51:48 +00001590 if (ipv4_is_multicast(p.iph.daddr))
1591 nflags = IFF_BROADCAST;
1592 else if (p.iph.daddr)
1593 nflags = IFF_POINTOPOINT;
1594
1595 if ((dev->flags ^ nflags) &
1596 (IFF_POINTOPOINT | IFF_BROADCAST))
1597 return -EINVAL;
1598 }
Herbert Xuc19e6542008-10-09 11:59:55 -07001599
1600 ipgre_tunnel_unlink(ign, t);
1601 t->parms.iph.saddr = p.iph.saddr;
1602 t->parms.iph.daddr = p.iph.daddr;
1603 t->parms.i_key = p.i_key;
Herbert Xu2e9526b2009-10-30 05:51:48 +00001604 if (dev->type != ARPHRD_ETHER) {
1605 memcpy(dev->dev_addr, &p.iph.saddr, 4);
1606 memcpy(dev->broadcast, &p.iph.daddr, 4);
1607 }
Herbert Xuc19e6542008-10-09 11:59:55 -07001608 ipgre_tunnel_link(ign, t);
1609 netdev_state_change(dev);
1610 }
1611
1612 t->parms.o_key = p.o_key;
1613 t->parms.iph.ttl = p.iph.ttl;
1614 t->parms.iph.tos = p.iph.tos;
1615 t->parms.iph.frag_off = p.iph.frag_off;
1616
1617 if (t->parms.link != p.link) {
1618 t->parms.link = p.link;
1619 mtu = ipgre_tunnel_bind_dev(dev);
1620 if (!tb[IFLA_MTU])
1621 dev->mtu = mtu;
1622 netdev_state_change(dev);
1623 }
1624
1625 return 0;
1626}
1627
1628static size_t ipgre_get_size(const struct net_device *dev)
1629{
1630 return
1631 /* IFLA_GRE_LINK */
1632 nla_total_size(4) +
1633 /* IFLA_GRE_IFLAGS */
1634 nla_total_size(2) +
1635 /* IFLA_GRE_OFLAGS */
1636 nla_total_size(2) +
1637 /* IFLA_GRE_IKEY */
1638 nla_total_size(4) +
1639 /* IFLA_GRE_OKEY */
1640 nla_total_size(4) +
1641 /* IFLA_GRE_LOCAL */
1642 nla_total_size(4) +
1643 /* IFLA_GRE_REMOTE */
1644 nla_total_size(4) +
1645 /* IFLA_GRE_TTL */
1646 nla_total_size(1) +
1647 /* IFLA_GRE_TOS */
1648 nla_total_size(1) +
1649 /* IFLA_GRE_PMTUDISC */
1650 nla_total_size(1) +
1651 0;
1652}
1653
1654static int ipgre_fill_info(struct sk_buff *skb, const struct net_device *dev)
1655{
1656 struct ip_tunnel *t = netdev_priv(dev);
1657 struct ip_tunnel_parm *p = &t->parms;
1658
1659 NLA_PUT_U32(skb, IFLA_GRE_LINK, p->link);
1660 NLA_PUT_BE16(skb, IFLA_GRE_IFLAGS, p->i_flags);
1661 NLA_PUT_BE16(skb, IFLA_GRE_OFLAGS, p->o_flags);
Patrick McHardyba9e64b2008-10-10 12:10:30 -07001662 NLA_PUT_BE32(skb, IFLA_GRE_IKEY, p->i_key);
1663 NLA_PUT_BE32(skb, IFLA_GRE_OKEY, p->o_key);
Patrick McHardy4d74f8b2008-10-10 12:11:06 -07001664 NLA_PUT_BE32(skb, IFLA_GRE_LOCAL, p->iph.saddr);
1665 NLA_PUT_BE32(skb, IFLA_GRE_REMOTE, p->iph.daddr);
Herbert Xuc19e6542008-10-09 11:59:55 -07001666 NLA_PUT_U8(skb, IFLA_GRE_TTL, p->iph.ttl);
1667 NLA_PUT_U8(skb, IFLA_GRE_TOS, p->iph.tos);
1668 NLA_PUT_U8(skb, IFLA_GRE_PMTUDISC, !!(p->iph.frag_off & htons(IP_DF)));
1669
1670 return 0;
1671
1672nla_put_failure:
1673 return -EMSGSIZE;
1674}
1675
1676static const struct nla_policy ipgre_policy[IFLA_GRE_MAX + 1] = {
1677 [IFLA_GRE_LINK] = { .type = NLA_U32 },
1678 [IFLA_GRE_IFLAGS] = { .type = NLA_U16 },
1679 [IFLA_GRE_OFLAGS] = { .type = NLA_U16 },
1680 [IFLA_GRE_IKEY] = { .type = NLA_U32 },
1681 [IFLA_GRE_OKEY] = { .type = NLA_U32 },
Patrick McHardy4d74f8b2008-10-10 12:11:06 -07001682 [IFLA_GRE_LOCAL] = { .len = FIELD_SIZEOF(struct iphdr, saddr) },
1683 [IFLA_GRE_REMOTE] = { .len = FIELD_SIZEOF(struct iphdr, daddr) },
Herbert Xuc19e6542008-10-09 11:59:55 -07001684 [IFLA_GRE_TTL] = { .type = NLA_U8 },
1685 [IFLA_GRE_TOS] = { .type = NLA_U8 },
1686 [IFLA_GRE_PMTUDISC] = { .type = NLA_U8 },
1687};
1688
1689static struct rtnl_link_ops ipgre_link_ops __read_mostly = {
1690 .kind = "gre",
1691 .maxtype = IFLA_GRE_MAX,
1692 .policy = ipgre_policy,
1693 .priv_size = sizeof(struct ip_tunnel),
1694 .setup = ipgre_tunnel_setup,
1695 .validate = ipgre_tunnel_validate,
1696 .newlink = ipgre_newlink,
1697 .changelink = ipgre_changelink,
1698 .get_size = ipgre_get_size,
1699 .fill_info = ipgre_fill_info,
1700};
1701
Herbert Xue1a80002008-10-09 12:00:17 -07001702static struct rtnl_link_ops ipgre_tap_ops __read_mostly = {
1703 .kind = "gretap",
1704 .maxtype = IFLA_GRE_MAX,
1705 .policy = ipgre_policy,
1706 .priv_size = sizeof(struct ip_tunnel),
1707 .setup = ipgre_tap_setup,
1708 .validate = ipgre_tap_validate,
1709 .newlink = ipgre_newlink,
1710 .changelink = ipgre_changelink,
1711 .get_size = ipgre_get_size,
1712 .fill_info = ipgre_fill_info,
1713};
1714
Linus Torvalds1da177e2005-04-16 15:20:36 -07001715/*
1716 * And now the modules code and kernel interface.
1717 */
1718
1719static int __init ipgre_init(void)
1720{
1721 int err;
1722
1723 printk(KERN_INFO "GRE over IPv4 tunneling driver\n");
1724
Eric W. Biedermancfb8fbf2009-11-29 15:46:13 +00001725 err = register_pernet_device(&ipgre_net_ops);
Pavel Emelyanov59a4c752008-04-16 01:08:53 -07001726 if (err < 0)
Alexey Dobriyanc2892f02010-02-16 07:57:44 +00001727 return err;
1728
Dmitry Kozlov00959ad2010-08-21 23:05:39 -07001729 err = gre_add_protocol(&ipgre_protocol, GREPROTO_CISCO);
Alexey Dobriyanc2892f02010-02-16 07:57:44 +00001730 if (err < 0) {
1731 printk(KERN_INFO "ipgre init: can't add protocol\n");
1732 goto add_proto_failed;
1733 }
Pavel Emelyanov7daa0002008-04-16 01:10:05 -07001734
Herbert Xuc19e6542008-10-09 11:59:55 -07001735 err = rtnl_link_register(&ipgre_link_ops);
1736 if (err < 0)
1737 goto rtnl_link_failed;
1738
Herbert Xue1a80002008-10-09 12:00:17 -07001739 err = rtnl_link_register(&ipgre_tap_ops);
1740 if (err < 0)
1741 goto tap_ops_failed;
1742
Herbert Xuc19e6542008-10-09 11:59:55 -07001743out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001744 return err;
Herbert Xuc19e6542008-10-09 11:59:55 -07001745
Herbert Xue1a80002008-10-09 12:00:17 -07001746tap_ops_failed:
1747 rtnl_link_unregister(&ipgre_link_ops);
Herbert Xuc19e6542008-10-09 11:59:55 -07001748rtnl_link_failed:
Dmitry Kozlov00959ad2010-08-21 23:05:39 -07001749 gre_del_protocol(&ipgre_protocol, GREPROTO_CISCO);
Alexey Dobriyanc2892f02010-02-16 07:57:44 +00001750add_proto_failed:
1751 unregister_pernet_device(&ipgre_net_ops);
Herbert Xuc19e6542008-10-09 11:59:55 -07001752 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001753}
1754
Alexey Kuznetsovdb445752005-07-30 17:46:44 -07001755static void __exit ipgre_fini(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001756{
Herbert Xue1a80002008-10-09 12:00:17 -07001757 rtnl_link_unregister(&ipgre_tap_ops);
Herbert Xuc19e6542008-10-09 11:59:55 -07001758 rtnl_link_unregister(&ipgre_link_ops);
Dmitry Kozlov00959ad2010-08-21 23:05:39 -07001759 if (gre_del_protocol(&ipgre_protocol, GREPROTO_CISCO) < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001760 printk(KERN_INFO "ipgre close: can't remove protocol\n");
Alexey Dobriyanc2892f02010-02-16 07:57:44 +00001761 unregister_pernet_device(&ipgre_net_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001762}
1763
1764module_init(ipgre_init);
1765module_exit(ipgre_fini);
1766MODULE_LICENSE("GPL");
Patrick McHardy4d74f8b2008-10-10 12:11:06 -07001767MODULE_ALIAS_RTNL_LINK("gre");
1768MODULE_ALIAS_RTNL_LINK("gretap");
stephen hemminger4da6a732010-11-29 09:47:48 +00001769MODULE_ALIAS("gre0");