blob: fd192d676955fde161200bc37c4bc07650292a00 [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>
17#include <asm/uaccess.h>
18#include <linux/skbuff.h>
19#include <linux/netdevice.h>
20#include <linux/in.h>
21#include <linux/tcp.h>
22#include <linux/udp.h>
23#include <linux/if_arp.h>
24#include <linux/mroute.h>
25#include <linux/init.h>
26#include <linux/in6.h>
27#include <linux/inetdevice.h>
28#include <linux/igmp.h>
29#include <linux/netfilter_ipv4.h>
Kris Katterjohn46f25df2006-01-05 16:35:42 -080030#include <linux/if_ether.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070031
32#include <net/sock.h>
33#include <net/ip.h>
34#include <net/icmp.h>
35#include <net/protocol.h>
36#include <net/ipip.h>
37#include <net/arp.h>
38#include <net/checksum.h>
39#include <net/dsfield.h>
40#include <net/inet_ecn.h>
41#include <net/xfrm.h>
Pavel Emelyanov59a4c752008-04-16 01:08:53 -070042#include <net/net_namespace.h>
43#include <net/netns/generic.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070044
45#ifdef CONFIG_IPV6
46#include <net/ipv6.h>
47#include <net/ip6_fib.h>
48#include <net/ip6_route.h>
49#endif
50
51/*
52 Problems & solutions
53 --------------------
54
55 1. The most important issue is detecting local dead loops.
56 They would cause complete host lockup in transmit, which
57 would be "resolved" by stack overflow or, if queueing is enabled,
58 with infinite looping in net_bh.
59
60 We cannot track such dead loops during route installation,
61 it is infeasible task. The most general solutions would be
62 to keep skb->encapsulation counter (sort of local ttl),
63 and silently drop packet when it expires. It is the best
64 solution, but it supposes maintaing new variable in ALL
65 skb, even if no tunneling is used.
66
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +090067 Current solution: t->recursion lock breaks dead loops. It looks
Linus Torvalds1da177e2005-04-16 15:20:36 -070068 like dev->tbusy flag, but I preferred new variable, because
69 the semantics is different. One day, when hard_start_xmit
70 will be multithreaded we will have to use skb->encapsulation.
71
72
73
74 2. Networking dead loops would not kill routers, but would really
75 kill network. IP hop limit plays role of "t->recursion" in this case,
76 if we copy it from packet being encapsulated to upper header.
77 It is very good solution, but it introduces two problems:
78
79 - Routing protocols, using packets with ttl=1 (OSPF, RIP2),
80 do not work over tunnels.
81 - traceroute does not work. I planned to relay ICMP from tunnel,
82 so that this problem would be solved and traceroute output
83 would even more informative. This idea appeared to be wrong:
84 only Linux complies to rfc1812 now (yes, guys, Linux is the only
85 true router now :-)), all routers (at least, in neighbourhood of mine)
86 return only 8 bytes of payload. It is the end.
87
88 Hence, if we want that OSPF worked or traceroute said something reasonable,
89 we should search for another solution.
90
91 One of them is to parse packet trying to detect inner encapsulation
92 made by our node. It is difficult or even impossible, especially,
93 taking into account fragmentation. TO be short, tt is not solution at all.
94
95 Current solution: The solution was UNEXPECTEDLY SIMPLE.
96 We force DF flag on tunnels with preconfigured hop limit,
97 that is ALL. :-) Well, it does not remove the problem completely,
98 but exponential growth of network traffic is changed to linear
99 (branches, that exceed pmtu are pruned) and tunnel mtu
100 fastly degrades to value <68, where looping stops.
101 Yes, it is not good if there exists a router in the loop,
102 which does not force DF, even when encapsulating packets have DF set.
103 But it is not our problem! Nobody could accuse us, we made
104 all that we could make. Even if it is your gated who injected
105 fatal route to network, even if it were you who configured
106 fatal static route: you are innocent. :-)
107
108
109
110 3. Really, ipv4/ipip.c, ipv4/ip_gre.c and ipv6/sit.c contain
111 practically identical code. It would be good to glue them
112 together, but it is not very evident, how to make them modular.
113 sit is integral part of IPv6, ipip and gre are naturally modular.
114 We could extract common parts (hash table, ioctl etc)
115 to a separate module (ip_tunnel.c).
116
117 Alexey Kuznetsov.
118 */
119
120static int ipgre_tunnel_init(struct net_device *dev);
121static void ipgre_tunnel_setup(struct net_device *dev);
122
123/* Fallback tunnel: no source, no destination, no key, no options */
124
125static int ipgre_fb_tunnel_init(struct net_device *dev);
126
Pavel Emelyanoveb8ce742008-04-16 01:10:26 -0700127#define HASH_SIZE 16
128
Pavel Emelyanov59a4c752008-04-16 01:08:53 -0700129static int ipgre_net_id;
130struct ipgre_net {
Pavel Emelyanoveb8ce742008-04-16 01:10:26 -0700131 struct ip_tunnel *tunnels[4][HASH_SIZE];
132
Pavel Emelyanov7daa0002008-04-16 01:10:05 -0700133 struct net_device *fb_tunnel_dev;
Pavel Emelyanov59a4c752008-04-16 01:08:53 -0700134};
135
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136/* Tunnel hash table */
137
138/*
139 4 hash tables:
140
141 3: (remote,local)
142 2: (remote,*)
143 1: (*,local)
144 0: (*,*)
145
146 We require exact key match i.e. if a key is present in packet
147 it will match only tunnel with the same key; if it is not present,
148 it will match only keyless tunnel.
149
150 All keysless packets, if not matched configured keyless tunnels
151 will match fallback tunnel.
152 */
153
Al Virod5a0a1e2006-11-08 00:23:14 -0800154#define HASH(addr) (((__force u32)addr^((__force u32)addr>>4))&0xF)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155
Pavel Emelyanoveb8ce742008-04-16 01:10:26 -0700156#define tunnels_r_l tunnels[3]
157#define tunnels_r tunnels[2]
158#define tunnels_l tunnels[1]
159#define tunnels_wc tunnels[0]
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160
161static DEFINE_RWLOCK(ipgre_lock);
162
163/* Given src, dst and key, find appropriate for input tunnel. */
164
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -0700165static struct ip_tunnel * ipgre_tunnel_lookup(struct net *net,
166 __be32 remote, __be32 local, __be32 key)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167{
168 unsigned h0 = HASH(remote);
169 unsigned h1 = HASH(key);
170 struct ip_tunnel *t;
Pavel Emelyanov7daa0002008-04-16 01:10:05 -0700171 struct ipgre_net *ign = net_generic(net, ipgre_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172
Pavel Emelyanoveb8ce742008-04-16 01:10:26 -0700173 for (t = ign->tunnels_r_l[h0^h1]; t; t = t->next) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174 if (local == t->parms.iph.saddr && remote == t->parms.iph.daddr) {
175 if (t->parms.i_key == key && (t->dev->flags&IFF_UP))
176 return t;
177 }
178 }
Pavel Emelyanoveb8ce742008-04-16 01:10:26 -0700179 for (t = ign->tunnels_r[h0^h1]; t; t = t->next) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180 if (remote == t->parms.iph.daddr) {
181 if (t->parms.i_key == key && (t->dev->flags&IFF_UP))
182 return t;
183 }
184 }
Pavel Emelyanoveb8ce742008-04-16 01:10:26 -0700185 for (t = ign->tunnels_l[h1]; t; t = t->next) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186 if (local == t->parms.iph.saddr ||
Joe Perchesf97c1e02007-12-16 13:45:43 -0800187 (local == t->parms.iph.daddr &&
188 ipv4_is_multicast(local))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189 if (t->parms.i_key == key && (t->dev->flags&IFF_UP))
190 return t;
191 }
192 }
Pavel Emelyanoveb8ce742008-04-16 01:10:26 -0700193 for (t = ign->tunnels_wc[h1]; t; t = t->next) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194 if (t->parms.i_key == key && (t->dev->flags&IFF_UP))
195 return t;
196 }
197
Pavel Emelyanov7daa0002008-04-16 01:10:05 -0700198 if (ign->fb_tunnel_dev->flags&IFF_UP)
199 return netdev_priv(ign->fb_tunnel_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200 return NULL;
201}
202
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -0700203static struct ip_tunnel **__ipgre_bucket(struct ipgre_net *ign,
204 struct ip_tunnel_parm *parms)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205{
YOSHIFUJI Hideaki5056a1e2007-04-24 20:44:48 +0900206 __be32 remote = parms->iph.daddr;
207 __be32 local = parms->iph.saddr;
208 __be32 key = parms->i_key;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209 unsigned h = HASH(key);
210 int prio = 0;
211
212 if (local)
213 prio |= 1;
Joe Perchesf97c1e02007-12-16 13:45:43 -0800214 if (remote && !ipv4_is_multicast(remote)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215 prio |= 2;
216 h ^= HASH(remote);
217 }
218
Pavel Emelyanoveb8ce742008-04-16 01:10:26 -0700219 return &ign->tunnels[prio][h];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220}
221
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -0700222static inline struct ip_tunnel **ipgre_bucket(struct ipgre_net *ign,
223 struct ip_tunnel *t)
YOSHIFUJI Hideaki5056a1e2007-04-24 20:44:48 +0900224{
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -0700225 return __ipgre_bucket(ign, &t->parms);
YOSHIFUJI Hideaki5056a1e2007-04-24 20:44:48 +0900226}
227
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -0700228static void ipgre_tunnel_link(struct ipgre_net *ign, struct ip_tunnel *t)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229{
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -0700230 struct ip_tunnel **tp = ipgre_bucket(ign, t);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231
232 t->next = *tp;
233 write_lock_bh(&ipgre_lock);
234 *tp = t;
235 write_unlock_bh(&ipgre_lock);
236}
237
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -0700238static void ipgre_tunnel_unlink(struct ipgre_net *ign, struct ip_tunnel *t)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239{
240 struct ip_tunnel **tp;
241
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -0700242 for (tp = ipgre_bucket(ign, t); *tp; tp = &(*tp)->next) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243 if (t == *tp) {
244 write_lock_bh(&ipgre_lock);
245 *tp = t->next;
246 write_unlock_bh(&ipgre_lock);
247 break;
248 }
249 }
250}
251
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -0700252static struct ip_tunnel * ipgre_tunnel_locate(struct net *net,
253 struct ip_tunnel_parm *parms, int create)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254{
Al Virod5a0a1e2006-11-08 00:23:14 -0800255 __be32 remote = parms->iph.daddr;
256 __be32 local = parms->iph.saddr;
257 __be32 key = parms->i_key;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258 struct ip_tunnel *t, **tp, *nt;
259 struct net_device *dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260 char name[IFNAMSIZ];
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -0700261 struct ipgre_net *ign = net_generic(net, ipgre_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -0700263 for (tp = __ipgre_bucket(ign, parms); (t = *tp) != NULL; tp = &t->next) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264 if (local == t->parms.iph.saddr && remote == t->parms.iph.daddr) {
265 if (key == t->parms.i_key)
266 return t;
267 }
268 }
269 if (!create)
270 return NULL;
271
272 if (parms->name[0])
273 strlcpy(name, parms->name, IFNAMSIZ);
Pavel Emelyanov34cc7ba2008-02-23 20:19:20 -0800274 else
275 sprintf(name, "gre%%d");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276
277 dev = alloc_netdev(sizeof(*t), name, ipgre_tunnel_setup);
278 if (!dev)
279 return NULL;
280
Pavel Emelyanov0b67ece2008-04-16 01:11:13 -0700281 dev_net_set(dev, net);
282
Pavel Emelyanovb37d4282008-02-26 23:51:04 -0800283 if (strchr(name, '%')) {
284 if (dev_alloc_name(dev, name) < 0)
285 goto failed_free;
286 }
287
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288 dev->init = ipgre_tunnel_init;
Patrick McHardy2941a482006-01-08 22:05:26 -0800289 nt = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290 nt->parms = *parms;
291
Pavel Emelyanovb37d4282008-02-26 23:51:04 -0800292 if (register_netdevice(dev) < 0)
293 goto failed_free;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295 dev_hold(dev);
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -0700296 ipgre_tunnel_link(ign, nt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297 return nt;
298
Pavel Emelyanovb37d4282008-02-26 23:51:04 -0800299failed_free:
300 free_netdev(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301 return NULL;
302}
303
304static void ipgre_tunnel_uninit(struct net_device *dev)
305{
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -0700306 struct net *net = dev_net(dev);
307 struct ipgre_net *ign = net_generic(net, ipgre_net_id);
308
309 ipgre_tunnel_unlink(ign, netdev_priv(dev));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310 dev_put(dev);
311}
312
313
314static void ipgre_err(struct sk_buff *skb, u32 info)
315{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316
Rami Rosen071f92d2008-05-21 17:47:54 -0700317/* All the routers (except for Linux) return only
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318 8 bytes of packet payload. It means, that precise relaying of
319 ICMP in the real Internet is absolutely infeasible.
320
321 Moreover, Cisco "wise men" put GRE key to the third word
322 in GRE header. It makes impossible maintaining even soft state for keyed
323 GRE tunnels with enabled checksum. Tell them "thank you".
324
325 Well, I wonder, rfc1812 was written by Cisco employee,
326 what the hell these idiots break standrads established
327 by themself???
328 */
329
330 struct iphdr *iph = (struct iphdr*)skb->data;
Al Virod5a0a1e2006-11-08 00:23:14 -0800331 __be16 *p = (__be16*)(skb->data+(iph->ihl<<2));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332 int grehlen = (iph->ihl<<2) + 4;
Arnaldo Carvalho de Melo88c76642007-03-13 14:43:18 -0300333 const int type = icmp_hdr(skb)->type;
334 const int code = icmp_hdr(skb)->code;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335 struct ip_tunnel *t;
Al Virod5a0a1e2006-11-08 00:23:14 -0800336 __be16 flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337
338 flags = p[0];
339 if (flags&(GRE_CSUM|GRE_KEY|GRE_SEQ|GRE_ROUTING|GRE_VERSION)) {
340 if (flags&(GRE_VERSION|GRE_ROUTING))
341 return;
342 if (flags&GRE_KEY) {
343 grehlen += 4;
344 if (flags&GRE_CSUM)
345 grehlen += 4;
346 }
347 }
348
349 /* If only 8 bytes returned, keyed message will be dropped here */
350 if (skb_headlen(skb) < grehlen)
351 return;
352
353 switch (type) {
354 default:
355 case ICMP_PARAMETERPROB:
356 return;
357
358 case ICMP_DEST_UNREACH:
359 switch (code) {
360 case ICMP_SR_FAILED:
361 case ICMP_PORT_UNREACH:
362 /* Impossible event. */
363 return;
364 case ICMP_FRAG_NEEDED:
365 /* Soft state for pmtu is maintained by IP core. */
366 return;
367 default:
368 /* All others are translated to HOST_UNREACH.
369 rfc2003 contains "deep thoughts" about NET_UNREACH,
370 I believe they are just ether pollution. --ANK
371 */
372 break;
373 }
374 break;
375 case ICMP_TIME_EXCEEDED:
376 if (code != ICMP_EXC_TTL)
377 return;
378 break;
379 }
380
381 read_lock(&ipgre_lock);
Pavel Emelyanov3b4667f2008-04-16 01:09:44 -0700382 t = ipgre_tunnel_lookup(dev_net(skb->dev), iph->daddr, iph->saddr,
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -0700383 (flags&GRE_KEY) ?
384 *(((__be32*)p) + (grehlen>>2) - 1) : 0);
Joe Perchesf97c1e02007-12-16 13:45:43 -0800385 if (t == NULL || t->parms.iph.daddr == 0 ||
386 ipv4_is_multicast(t->parms.iph.daddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387 goto out;
388
389 if (t->parms.iph.ttl == 0 && type == ICMP_TIME_EXCEEDED)
390 goto out;
391
392 if (jiffies - t->err_time < IPTUNNEL_ERR_TIMEO)
393 t->err_count++;
394 else
395 t->err_count = 1;
396 t->err_time = jiffies;
397out:
398 read_unlock(&ipgre_lock);
399 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400}
401
402static inline void ipgre_ecn_decapsulate(struct iphdr *iph, struct sk_buff *skb)
403{
404 if (INET_ECN_is_ce(iph->tos)) {
405 if (skb->protocol == htons(ETH_P_IP)) {
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700406 IP_ECN_set_ce(ip_hdr(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407 } else if (skb->protocol == htons(ETH_P_IPV6)) {
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700408 IP6_ECN_set_ce(ipv6_hdr(skb));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409 }
410 }
411}
412
413static inline u8
414ipgre_ecn_encapsulate(u8 tos, struct iphdr *old_iph, struct sk_buff *skb)
415{
416 u8 inner = 0;
417 if (skb->protocol == htons(ETH_P_IP))
418 inner = old_iph->tos;
419 else if (skb->protocol == htons(ETH_P_IPV6))
420 inner = ipv6_get_dsfield((struct ipv6hdr *)old_iph);
421 return INET_ECN_encapsulate(tos, inner);
422}
423
424static int ipgre_rcv(struct sk_buff *skb)
425{
426 struct iphdr *iph;
427 u8 *h;
Al Virod5a0a1e2006-11-08 00:23:14 -0800428 __be16 flags;
Al Virod3bc23e2006-11-14 21:24:49 -0800429 __sum16 csum = 0;
Al Virod5a0a1e2006-11-08 00:23:14 -0800430 __be32 key = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431 u32 seqno = 0;
432 struct ip_tunnel *tunnel;
433 int offset = 4;
434
435 if (!pskb_may_pull(skb, 16))
436 goto drop_nolock;
437
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700438 iph = ip_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439 h = skb->data;
Al Virod5a0a1e2006-11-08 00:23:14 -0800440 flags = *(__be16*)h;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441
442 if (flags&(GRE_CSUM|GRE_KEY|GRE_ROUTING|GRE_SEQ|GRE_VERSION)) {
443 /* - Version must be 0.
444 - We do not support routing headers.
445 */
446 if (flags&(GRE_VERSION|GRE_ROUTING))
447 goto drop_nolock;
448
449 if (flags&GRE_CSUM) {
Herbert Xufb286bb2005-11-10 13:01:24 -0800450 switch (skb->ip_summed) {
Patrick McHardy84fa7932006-08-29 16:44:56 -0700451 case CHECKSUM_COMPLETE:
Al Virod3bc23e2006-11-14 21:24:49 -0800452 csum = csum_fold(skb->csum);
Herbert Xufb286bb2005-11-10 13:01:24 -0800453 if (!csum)
454 break;
455 /* fall through */
456 case CHECKSUM_NONE:
457 skb->csum = 0;
458 csum = __skb_checksum_complete(skb);
Patrick McHardy84fa7932006-08-29 16:44:56 -0700459 skb->ip_summed = CHECKSUM_COMPLETE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460 }
461 offset += 4;
462 }
463 if (flags&GRE_KEY) {
Al Virod5a0a1e2006-11-08 00:23:14 -0800464 key = *(__be32*)(h + offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465 offset += 4;
466 }
467 if (flags&GRE_SEQ) {
Al Virod5a0a1e2006-11-08 00:23:14 -0800468 seqno = ntohl(*(__be32*)(h + offset));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469 offset += 4;
470 }
471 }
472
473 read_lock(&ipgre_lock);
Pavel Emelyanov3b4667f2008-04-16 01:09:44 -0700474 if ((tunnel = ipgre_tunnel_lookup(dev_net(skb->dev),
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -0700475 iph->saddr, iph->daddr, key)) != NULL) {
Pavel Emelyanovaddd68e2008-05-21 14:14:22 -0700476 struct net_device_stats *stats = &tunnel->dev->stats;
477
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478 secpath_reset(skb);
479
Al Virod5a0a1e2006-11-08 00:23:14 -0800480 skb->protocol = *(__be16*)(h + 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481 /* WCCP version 1 and 2 protocol decoding.
482 * - Change protocol to IP
483 * - When dealing with WCCPv2, Skip extra 4 bytes in GRE header
484 */
485 if (flags == 0 &&
YOSHIFUJI Hideaki496c98d2006-10-10 19:41:21 -0700486 skb->protocol == htons(ETH_P_WCCP)) {
487 skb->protocol = htons(ETH_P_IP);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900488 if ((*(h + offset) & 0xF0) != 0x40)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489 offset += 4;
490 }
491
Timo Teras1d069162007-12-20 00:10:33 -0800492 skb->mac_header = skb->network_header;
Arnaldo Carvalho de Melo4209fb62007-03-10 18:42:03 -0300493 __pskb_pull(skb, offset);
494 skb_reset_network_header(skb);
Arnaldo Carvalho de Melo9c702202007-04-25 18:04:18 -0700495 skb_postpull_rcsum(skb, skb_transport_header(skb), offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496 skb->pkt_type = PACKET_HOST;
497#ifdef CONFIG_NET_IPGRE_BROADCAST
Joe Perchesf97c1e02007-12-16 13:45:43 -0800498 if (ipv4_is_multicast(iph->daddr)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499 /* Looped back packet, drop it! */
Eric Dumazetee6b9672008-03-05 18:30:47 -0800500 if (skb->rtable->fl.iif == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501 goto drop;
Pavel Emelyanovaddd68e2008-05-21 14:14:22 -0700502 stats->multicast++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503 skb->pkt_type = PACKET_BROADCAST;
504 }
505#endif
506
507 if (((flags&GRE_CSUM) && csum) ||
508 (!(flags&GRE_CSUM) && tunnel->parms.i_flags&GRE_CSUM)) {
Pavel Emelyanovaddd68e2008-05-21 14:14:22 -0700509 stats->rx_crc_errors++;
510 stats->rx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511 goto drop;
512 }
513 if (tunnel->parms.i_flags&GRE_SEQ) {
514 if (!(flags&GRE_SEQ) ||
515 (tunnel->i_seqno && (s32)(seqno - tunnel->i_seqno) < 0)) {
Pavel Emelyanovaddd68e2008-05-21 14:14:22 -0700516 stats->rx_fifo_errors++;
517 stats->rx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518 goto drop;
519 }
520 tunnel->i_seqno = seqno + 1;
521 }
Pavel Emelyanovaddd68e2008-05-21 14:14:22 -0700522 stats->rx_packets++;
523 stats->rx_bytes += skb->len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524 skb->dev = tunnel->dev;
525 dst_release(skb->dst);
526 skb->dst = NULL;
527 nf_reset(skb);
528 ipgre_ecn_decapsulate(iph, skb);
529 netif_rx(skb);
530 read_unlock(&ipgre_lock);
531 return(0);
532 }
Herbert Xu45af08b2006-04-05 22:31:19 -0700533 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534
535drop:
536 read_unlock(&ipgre_lock);
537drop_nolock:
538 kfree_skb(skb);
539 return(0);
540}
541
542static int ipgre_tunnel_xmit(struct sk_buff *skb, struct net_device *dev)
543{
Patrick McHardy2941a482006-01-08 22:05:26 -0800544 struct ip_tunnel *tunnel = netdev_priv(dev);
Pavel Emelyanovaddd68e2008-05-21 14:14:22 -0700545 struct net_device_stats *stats = &tunnel->dev->stats;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700546 struct iphdr *old_iph = ip_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547 struct iphdr *tiph;
548 u8 tos;
Al Virod5a0a1e2006-11-08 00:23:14 -0800549 __be16 df;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550 struct rtable *rt; /* Route to the other host */
551 struct net_device *tdev; /* Device to other host */
552 struct iphdr *iph; /* Our new IP header */
Chuck Leverc2636b42007-10-23 21:07:32 -0700553 unsigned int max_headroom; /* The extra header space needed */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554 int gre_hlen;
Al Virod5a0a1e2006-11-08 00:23:14 -0800555 __be32 dst;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556 int mtu;
557
558 if (tunnel->recursion++) {
Pavel Emelyanovaddd68e2008-05-21 14:14:22 -0700559 stats->collisions++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560 goto tx_error;
561 }
562
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700563 if (dev->header_ops) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564 gre_hlen = 0;
565 tiph = (struct iphdr*)skb->data;
566 } else {
567 gre_hlen = tunnel->hlen;
568 tiph = &tunnel->parms.iph;
569 }
570
571 if ((dst = tiph->daddr) == 0) {
572 /* NBMA tunnel */
573
574 if (skb->dst == NULL) {
Pavel Emelyanovaddd68e2008-05-21 14:14:22 -0700575 stats->tx_fifo_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576 goto tx_error;
577 }
578
579 if (skb->protocol == htons(ETH_P_IP)) {
Eric Dumazetee6b9672008-03-05 18:30:47 -0800580 rt = skb->rtable;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581 if ((dst = rt->rt_gateway) == 0)
582 goto tx_error_icmp;
583 }
584#ifdef CONFIG_IPV6
585 else if (skb->protocol == htons(ETH_P_IPV6)) {
586 struct in6_addr *addr6;
587 int addr_type;
588 struct neighbour *neigh = skb->dst->neighbour;
589
590 if (neigh == NULL)
591 goto tx_error;
592
593 addr6 = (struct in6_addr*)&neigh->primary_key;
594 addr_type = ipv6_addr_type(addr6);
595
596 if (addr_type == IPV6_ADDR_ANY) {
Arnaldo Carvalho de Melo0660e032007-04-25 17:54:47 -0700597 addr6 = &ipv6_hdr(skb)->daddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598 addr_type = ipv6_addr_type(addr6);
599 }
600
601 if ((addr_type & IPV6_ADDR_COMPATv4) == 0)
602 goto tx_error_icmp;
603
604 dst = addr6->s6_addr32[3];
605 }
606#endif
607 else
608 goto tx_error;
609 }
610
611 tos = tiph->tos;
612 if (tos&1) {
613 if (skb->protocol == htons(ETH_P_IP))
614 tos = old_iph->tos;
615 tos &= ~1;
616 }
617
618 {
619 struct flowi fl = { .oif = tunnel->parms.link,
620 .nl_u = { .ip4_u =
621 { .daddr = dst,
622 .saddr = tiph->saddr,
623 .tos = RT_TOS(tos) } },
624 .proto = IPPROTO_GRE };
Pavel Emelyanov96635522008-04-16 01:10:44 -0700625 if (ip_route_output_key(dev_net(dev), &rt, &fl)) {
Pavel Emelyanovaddd68e2008-05-21 14:14:22 -0700626 stats->tx_carrier_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627 goto tx_error;
628 }
629 }
630 tdev = rt->u.dst.dev;
631
632 if (tdev == dev) {
633 ip_rt_put(rt);
Pavel Emelyanovaddd68e2008-05-21 14:14:22 -0700634 stats->collisions++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635 goto tx_error;
636 }
637
638 df = tiph->frag_off;
639 if (df)
Herbert Xuc95b8192008-10-09 11:58:54 -0700640 mtu = dst_mtu(&rt->u.dst) - dev->hard_header_len - tunnel->hlen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641 else
642 mtu = skb->dst ? dst_mtu(skb->dst) : dev->mtu;
643
644 if (skb->dst)
645 skb->dst->ops->update_pmtu(skb->dst, mtu);
646
647 if (skb->protocol == htons(ETH_P_IP)) {
648 df |= (old_iph->frag_off&htons(IP_DF));
649
650 if ((old_iph->frag_off&htons(IP_DF)) &&
651 mtu < ntohs(old_iph->tot_len)) {
652 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED, htonl(mtu));
653 ip_rt_put(rt);
654 goto tx_error;
655 }
656 }
657#ifdef CONFIG_IPV6
658 else if (skb->protocol == htons(ETH_P_IPV6)) {
659 struct rt6_info *rt6 = (struct rt6_info*)skb->dst;
660
661 if (rt6 && mtu < dst_mtu(skb->dst) && mtu >= IPV6_MIN_MTU) {
Joe Perchesf97c1e02007-12-16 13:45:43 -0800662 if ((tunnel->parms.iph.daddr &&
663 !ipv4_is_multicast(tunnel->parms.iph.daddr)) ||
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664 rt6->rt6i_dst.plen == 128) {
665 rt6->rt6i_flags |= RTF_MODIFIED;
666 skb->dst->metrics[RTAX_MTU-1] = mtu;
667 }
668 }
669
670 if (mtu >= IPV6_MIN_MTU && mtu < skb->len - tunnel->hlen + gre_hlen) {
671 icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, mtu, dev);
672 ip_rt_put(rt);
673 goto tx_error;
674 }
675 }
676#endif
677
678 if (tunnel->err_count > 0) {
679 if (jiffies - tunnel->err_time < IPTUNNEL_ERR_TIMEO) {
680 tunnel->err_count--;
681
682 dst_link_failure(skb);
683 } else
684 tunnel->err_count = 0;
685 }
686
687 max_headroom = LL_RESERVED_SPACE(tdev) + gre_hlen;
688
Patrick McHardycfbba492007-07-09 15:33:40 -0700689 if (skb_headroom(skb) < max_headroom || skb_shared(skb)||
690 (skb_cloned(skb) && !skb_clone_writable(skb, 0))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691 struct sk_buff *new_skb = skb_realloc_headroom(skb, max_headroom);
692 if (!new_skb) {
693 ip_rt_put(rt);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900694 stats->tx_dropped++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695 dev_kfree_skb(skb);
696 tunnel->recursion--;
697 return 0;
698 }
699 if (skb->sk)
700 skb_set_owner_w(new_skb, skb->sk);
701 dev_kfree_skb(skb);
702 skb = new_skb;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700703 old_iph = ip_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704 }
705
Arnaldo Carvalho de Melob0e380b2007-04-10 21:21:55 -0700706 skb->transport_header = skb->network_header;
Arnaldo Carvalho de Meloe2d1bca2007-04-10 20:46:21 -0700707 skb_push(skb, gre_hlen);
708 skb_reset_network_header(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709 memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
Patrick McHardy48d5cad2006-02-15 15:10:22 -0800710 IPCB(skb)->flags &= ~(IPSKB_XFRM_TUNNEL_SIZE | IPSKB_XFRM_TRANSFORMED |
711 IPSKB_REROUTED);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712 dst_release(skb->dst);
713 skb->dst = &rt->u.dst;
714
715 /*
716 * Push down and install the IPIP header.
717 */
718
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700719 iph = ip_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720 iph->version = 4;
721 iph->ihl = sizeof(struct iphdr) >> 2;
722 iph->frag_off = df;
723 iph->protocol = IPPROTO_GRE;
724 iph->tos = ipgre_ecn_encapsulate(tos, old_iph, skb);
725 iph->daddr = rt->rt_dst;
726 iph->saddr = rt->rt_src;
727
728 if ((iph->ttl = tiph->ttl) == 0) {
729 if (skb->protocol == htons(ETH_P_IP))
730 iph->ttl = old_iph->ttl;
731#ifdef CONFIG_IPV6
732 else if (skb->protocol == htons(ETH_P_IPV6))
733 iph->ttl = ((struct ipv6hdr*)old_iph)->hop_limit;
734#endif
735 else
736 iph->ttl = dst_metric(&rt->u.dst, RTAX_HOPLIMIT);
737 }
738
Al Virod5a0a1e2006-11-08 00:23:14 -0800739 ((__be16*)(iph+1))[0] = tunnel->parms.o_flags;
740 ((__be16*)(iph+1))[1] = skb->protocol;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741
742 if (tunnel->parms.o_flags&(GRE_KEY|GRE_CSUM|GRE_SEQ)) {
Al Virod5a0a1e2006-11-08 00:23:14 -0800743 __be32 *ptr = (__be32*)(((u8*)iph) + tunnel->hlen - 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700744
745 if (tunnel->parms.o_flags&GRE_SEQ) {
746 ++tunnel->o_seqno;
747 *ptr = htonl(tunnel->o_seqno);
748 ptr--;
749 }
750 if (tunnel->parms.o_flags&GRE_KEY) {
751 *ptr = tunnel->parms.o_key;
752 ptr--;
753 }
754 if (tunnel->parms.o_flags&GRE_CSUM) {
755 *ptr = 0;
Al Viro5f92a732006-11-14 21:36:54 -0800756 *(__sum16*)ptr = ip_compute_csum((void*)(iph+1), skb->len - sizeof(struct iphdr));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757 }
758 }
759
760 nf_reset(skb);
761
762 IPTUNNEL_XMIT();
763 tunnel->recursion--;
764 return 0;
765
766tx_error_icmp:
767 dst_link_failure(skb);
768
769tx_error:
770 stats->tx_errors++;
771 dev_kfree_skb(skb);
772 tunnel->recursion--;
773 return 0;
774}
775
Michal Schmidtee34c1e2007-12-13 09:46:32 -0800776static void ipgre_tunnel_bind_dev(struct net_device *dev)
777{
778 struct net_device *tdev = NULL;
779 struct ip_tunnel *tunnel;
780 struct iphdr *iph;
781 int hlen = LL_MAX_HEADER;
782 int mtu = ETH_DATA_LEN;
783 int addend = sizeof(struct iphdr) + 4;
784
785 tunnel = netdev_priv(dev);
786 iph = &tunnel->parms.iph;
787
Herbert Xuc95b8192008-10-09 11:58:54 -0700788 /* Guess output device to choose reasonable mtu and needed_headroom */
Michal Schmidtee34c1e2007-12-13 09:46:32 -0800789
790 if (iph->daddr) {
791 struct flowi fl = { .oif = tunnel->parms.link,
792 .nl_u = { .ip4_u =
793 { .daddr = iph->daddr,
794 .saddr = iph->saddr,
795 .tos = RT_TOS(iph->tos) } },
796 .proto = IPPROTO_GRE };
797 struct rtable *rt;
Pavel Emelyanov96635522008-04-16 01:10:44 -0700798 if (!ip_route_output_key(dev_net(dev), &rt, &fl)) {
Michal Schmidtee34c1e2007-12-13 09:46:32 -0800799 tdev = rt->u.dst.dev;
800 ip_rt_put(rt);
801 }
802 dev->flags |= IFF_POINTOPOINT;
803 }
804
805 if (!tdev && tunnel->parms.link)
Pavel Emelyanov96635522008-04-16 01:10:44 -0700806 tdev = __dev_get_by_index(dev_net(dev), tunnel->parms.link);
Michal Schmidtee34c1e2007-12-13 09:46:32 -0800807
808 if (tdev) {
Herbert Xuc95b8192008-10-09 11:58:54 -0700809 hlen = tdev->hard_header_len + tdev->needed_headroom;
Michal Schmidtee34c1e2007-12-13 09:46:32 -0800810 mtu = tdev->mtu;
811 }
812 dev->iflink = tunnel->parms.link;
813
814 /* Precalculate GRE options length */
815 if (tunnel->parms.o_flags&(GRE_CSUM|GRE_KEY|GRE_SEQ)) {
816 if (tunnel->parms.o_flags&GRE_CSUM)
817 addend += 4;
818 if (tunnel->parms.o_flags&GRE_KEY)
819 addend += 4;
820 if (tunnel->parms.o_flags&GRE_SEQ)
821 addend += 4;
822 }
Herbert Xuc95b8192008-10-09 11:58:54 -0700823 dev->needed_headroom = addend + hlen;
824 dev->mtu = mtu - dev->hard_header_len - addend;
Michal Schmidtee34c1e2007-12-13 09:46:32 -0800825 tunnel->hlen = addend;
826
827}
828
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829static int
830ipgre_tunnel_ioctl (struct net_device *dev, struct ifreq *ifr, int cmd)
831{
832 int err = 0;
833 struct ip_tunnel_parm p;
834 struct ip_tunnel *t;
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -0700835 struct net *net = dev_net(dev);
836 struct ipgre_net *ign = net_generic(net, ipgre_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837
838 switch (cmd) {
839 case SIOCGETTUNNEL:
840 t = NULL;
Pavel Emelyanov7daa0002008-04-16 01:10:05 -0700841 if (dev == ign->fb_tunnel_dev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p))) {
843 err = -EFAULT;
844 break;
845 }
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -0700846 t = ipgre_tunnel_locate(net, &p, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700847 }
848 if (t == NULL)
Patrick McHardy2941a482006-01-08 22:05:26 -0800849 t = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850 memcpy(&p, &t->parms, sizeof(p));
851 if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p)))
852 err = -EFAULT;
853 break;
854
855 case SIOCADDTUNNEL:
856 case SIOCCHGTUNNEL:
857 err = -EPERM;
858 if (!capable(CAP_NET_ADMIN))
859 goto done;
860
861 err = -EFAULT;
862 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
863 goto done;
864
865 err = -EINVAL;
866 if (p.iph.version != 4 || p.iph.protocol != IPPROTO_GRE ||
867 p.iph.ihl != 5 || (p.iph.frag_off&htons(~IP_DF)) ||
868 ((p.i_flags|p.o_flags)&(GRE_VERSION|GRE_ROUTING)))
869 goto done;
870 if (p.iph.ttl)
871 p.iph.frag_off |= htons(IP_DF);
872
873 if (!(p.i_flags&GRE_KEY))
874 p.i_key = 0;
875 if (!(p.o_flags&GRE_KEY))
876 p.o_key = 0;
877
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -0700878 t = ipgre_tunnel_locate(net, &p, cmd == SIOCADDTUNNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700879
Pavel Emelyanov7daa0002008-04-16 01:10:05 -0700880 if (dev != ign->fb_tunnel_dev && cmd == SIOCCHGTUNNEL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881 if (t != NULL) {
882 if (t->dev != dev) {
883 err = -EEXIST;
884 break;
885 }
886 } else {
887 unsigned nflags=0;
888
Patrick McHardy2941a482006-01-08 22:05:26 -0800889 t = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700890
Joe Perchesf97c1e02007-12-16 13:45:43 -0800891 if (ipv4_is_multicast(p.iph.daddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700892 nflags = IFF_BROADCAST;
893 else if (p.iph.daddr)
894 nflags = IFF_POINTOPOINT;
895
896 if ((dev->flags^nflags)&(IFF_POINTOPOINT|IFF_BROADCAST)) {
897 err = -EINVAL;
898 break;
899 }
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -0700900 ipgre_tunnel_unlink(ign, t);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700901 t->parms.iph.saddr = p.iph.saddr;
902 t->parms.iph.daddr = p.iph.daddr;
903 t->parms.i_key = p.i_key;
904 t->parms.o_key = p.o_key;
905 memcpy(dev->dev_addr, &p.iph.saddr, 4);
906 memcpy(dev->broadcast, &p.iph.daddr, 4);
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -0700907 ipgre_tunnel_link(ign, t);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700908 netdev_state_change(dev);
909 }
910 }
911
912 if (t) {
913 err = 0;
914 if (cmd == SIOCCHGTUNNEL) {
915 t->parms.iph.ttl = p.iph.ttl;
916 t->parms.iph.tos = p.iph.tos;
917 t->parms.iph.frag_off = p.iph.frag_off;
Michal Schmidtee34c1e2007-12-13 09:46:32 -0800918 if (t->parms.link != p.link) {
919 t->parms.link = p.link;
920 ipgre_tunnel_bind_dev(dev);
921 netdev_state_change(dev);
922 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700923 }
924 if (copy_to_user(ifr->ifr_ifru.ifru_data, &t->parms, sizeof(p)))
925 err = -EFAULT;
926 } else
927 err = (cmd == SIOCADDTUNNEL ? -ENOBUFS : -ENOENT);
928 break;
929
930 case SIOCDELTUNNEL:
931 err = -EPERM;
932 if (!capable(CAP_NET_ADMIN))
933 goto done;
934
Pavel Emelyanov7daa0002008-04-16 01:10:05 -0700935 if (dev == ign->fb_tunnel_dev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700936 err = -EFAULT;
937 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
938 goto done;
939 err = -ENOENT;
Pavel Emelyanovf57e7d52008-04-16 01:09:22 -0700940 if ((t = ipgre_tunnel_locate(net, &p, 0)) == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700941 goto done;
942 err = -EPERM;
Pavel Emelyanov7daa0002008-04-16 01:10:05 -0700943 if (t == netdev_priv(ign->fb_tunnel_dev))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700944 goto done;
945 dev = t->dev;
946 }
Stephen Hemminger22f8cde2007-02-07 00:09:58 -0800947 unregister_netdevice(dev);
948 err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700949 break;
950
951 default:
952 err = -EINVAL;
953 }
954
955done:
956 return err;
957}
958
Linus Torvalds1da177e2005-04-16 15:20:36 -0700959static int ipgre_tunnel_change_mtu(struct net_device *dev, int new_mtu)
960{
Patrick McHardy2941a482006-01-08 22:05:26 -0800961 struct ip_tunnel *tunnel = netdev_priv(dev);
Herbert Xuc95b8192008-10-09 11:58:54 -0700962 if (new_mtu < 68 ||
963 new_mtu > 0xFFF8 - dev->hard_header_len - tunnel->hlen)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700964 return -EINVAL;
965 dev->mtu = new_mtu;
966 return 0;
967}
968
Linus Torvalds1da177e2005-04-16 15:20:36 -0700969/* Nice toy. Unfortunately, useless in real life :-)
970 It allows to construct virtual multiprotocol broadcast "LAN"
971 over the Internet, provided multicast routing is tuned.
972
973
974 I have no idea was this bicycle invented before me,
975 so that I had to set ARPHRD_IPGRE to a random value.
976 I have an impression, that Cisco could make something similar,
977 but this feature is apparently missing in IOS<=11.2(8).
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900978
Linus Torvalds1da177e2005-04-16 15:20:36 -0700979 I set up 10.66.66/24 and fec0:6666:6666::0/96 as virtual networks
980 with broadcast 224.66.66.66. If you have access to mbone, play with me :-)
981
982 ping -t 255 224.66.66.66
983
984 If nobody answers, mbone does not work.
985
986 ip tunnel add Universe mode gre remote 224.66.66.66 local <Your_real_addr> ttl 255
987 ip addr add 10.66.66.<somewhat>/24 dev Universe
988 ifconfig Universe up
989 ifconfig Universe add fe80::<Your_real_addr>/10
990 ifconfig Universe add fec0:6666:6666::<Your_real_addr>/96
991 ftp 10.66.66.66
992 ...
993 ftp fec0:6666:6666::193.233.7.65
994 ...
995
996 */
997
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700998static int ipgre_header(struct sk_buff *skb, struct net_device *dev,
999 unsigned short type,
1000 const void *daddr, const void *saddr, unsigned len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001001{
Patrick McHardy2941a482006-01-08 22:05:26 -08001002 struct ip_tunnel *t = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001003 struct iphdr *iph = (struct iphdr *)skb_push(skb, t->hlen);
Al Virod5a0a1e2006-11-08 00:23:14 -08001004 __be16 *p = (__be16*)(iph+1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001005
1006 memcpy(iph, &t->parms.iph, sizeof(struct iphdr));
1007 p[0] = t->parms.o_flags;
1008 p[1] = htons(type);
1009
1010 /*
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001011 * Set the source hardware address.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001012 */
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001013
Linus Torvalds1da177e2005-04-16 15:20:36 -07001014 if (saddr)
1015 memcpy(&iph->saddr, saddr, 4);
1016
1017 if (daddr) {
1018 memcpy(&iph->daddr, daddr, 4);
1019 return t->hlen;
1020 }
Joe Perchesf97c1e02007-12-16 13:45:43 -08001021 if (iph->daddr && !ipv4_is_multicast(iph->daddr))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001022 return t->hlen;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09001023
Linus Torvalds1da177e2005-04-16 15:20:36 -07001024 return -t->hlen;
1025}
1026
Timo Teras6a5f44d2007-10-23 20:31:53 -07001027static int ipgre_header_parse(const struct sk_buff *skb, unsigned char *haddr)
1028{
1029 struct iphdr *iph = (struct iphdr*) skb_mac_header(skb);
1030 memcpy(haddr, &iph->saddr, 4);
1031 return 4;
1032}
1033
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -07001034static const struct header_ops ipgre_header_ops = {
1035 .create = ipgre_header,
Timo Teras6a5f44d2007-10-23 20:31:53 -07001036 .parse = ipgre_header_parse,
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -07001037};
1038
Timo Teras6a5f44d2007-10-23 20:31:53 -07001039#ifdef CONFIG_NET_IPGRE_BROADCAST
Linus Torvalds1da177e2005-04-16 15:20:36 -07001040static int ipgre_open(struct net_device *dev)
1041{
Patrick McHardy2941a482006-01-08 22:05:26 -08001042 struct ip_tunnel *t = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001043
Joe Perchesf97c1e02007-12-16 13:45:43 -08001044 if (ipv4_is_multicast(t->parms.iph.daddr)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001045 struct flowi fl = { .oif = t->parms.link,
1046 .nl_u = { .ip4_u =
1047 { .daddr = t->parms.iph.daddr,
1048 .saddr = t->parms.iph.saddr,
1049 .tos = RT_TOS(t->parms.iph.tos) } },
1050 .proto = IPPROTO_GRE };
1051 struct rtable *rt;
Pavel Emelyanov96635522008-04-16 01:10:44 -07001052 if (ip_route_output_key(dev_net(dev), &rt, &fl))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001053 return -EADDRNOTAVAIL;
1054 dev = rt->u.dst.dev;
1055 ip_rt_put(rt);
Herbert Xue5ed6392005-10-03 14:35:55 -07001056 if (__in_dev_get_rtnl(dev) == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001057 return -EADDRNOTAVAIL;
1058 t->mlink = dev->ifindex;
Herbert Xue5ed6392005-10-03 14:35:55 -07001059 ip_mc_inc_group(__in_dev_get_rtnl(dev), t->parms.iph.daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001060 }
1061 return 0;
1062}
1063
1064static int ipgre_close(struct net_device *dev)
1065{
Patrick McHardy2941a482006-01-08 22:05:26 -08001066 struct ip_tunnel *t = netdev_priv(dev);
Joe Perchesf97c1e02007-12-16 13:45:43 -08001067 if (ipv4_is_multicast(t->parms.iph.daddr) && t->mlink) {
Denis V. Lunev7fee0ca2008-01-21 17:32:38 -08001068 struct in_device *in_dev;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +09001069 in_dev = inetdev_by_index(dev_net(dev), t->mlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001070 if (in_dev) {
1071 ip_mc_dec_group(in_dev, t->parms.iph.daddr);
1072 in_dev_put(in_dev);
1073 }
1074 }
1075 return 0;
1076}
1077
1078#endif
1079
1080static void ipgre_tunnel_setup(struct net_device *dev)
1081{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001082 dev->uninit = ipgre_tunnel_uninit;
1083 dev->destructor = free_netdev;
1084 dev->hard_start_xmit = ipgre_tunnel_xmit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001085 dev->do_ioctl = ipgre_tunnel_ioctl;
1086 dev->change_mtu = ipgre_tunnel_change_mtu;
1087
1088 dev->type = ARPHRD_IPGRE;
Herbert Xuc95b8192008-10-09 11:58:54 -07001089 dev->needed_headroom = LL_MAX_HEADER + sizeof(struct iphdr) + 4;
Kris Katterjohn46f25df2006-01-05 16:35:42 -08001090 dev->mtu = ETH_DATA_LEN - sizeof(struct iphdr) - 4;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001091 dev->flags = IFF_NOARP;
1092 dev->iflink = 0;
1093 dev->addr_len = 4;
Pavel Emelyanov0b67ece2008-04-16 01:11:13 -07001094 dev->features |= NETIF_F_NETNS_LOCAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001095}
1096
1097static int ipgre_tunnel_init(struct net_device *dev)
1098{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001099 struct ip_tunnel *tunnel;
1100 struct iphdr *iph;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001101
Patrick McHardy2941a482006-01-08 22:05:26 -08001102 tunnel = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001103 iph = &tunnel->parms.iph;
1104
1105 tunnel->dev = dev;
1106 strcpy(tunnel->parms.name, dev->name);
1107
1108 memcpy(dev->dev_addr, &tunnel->parms.iph.saddr, 4);
1109 memcpy(dev->broadcast, &tunnel->parms.iph.daddr, 4);
1110
Michal Schmidtee34c1e2007-12-13 09:46:32 -08001111 ipgre_tunnel_bind_dev(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001112
1113 if (iph->daddr) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001114#ifdef CONFIG_NET_IPGRE_BROADCAST
Joe Perchesf97c1e02007-12-16 13:45:43 -08001115 if (ipv4_is_multicast(iph->daddr)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001116 if (!iph->saddr)
1117 return -EINVAL;
1118 dev->flags = IFF_BROADCAST;
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -07001119 dev->header_ops = &ipgre_header_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001120 dev->open = ipgre_open;
1121 dev->stop = ipgre_close;
1122 }
1123#endif
Michal Schmidtee34c1e2007-12-13 09:46:32 -08001124 } else
Timo Teras6a5f44d2007-10-23 20:31:53 -07001125 dev->header_ops = &ipgre_header_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001126
Linus Torvalds1da177e2005-04-16 15:20:36 -07001127 return 0;
1128}
1129
Pavel Emelyanov7daa0002008-04-16 01:10:05 -07001130static int ipgre_fb_tunnel_init(struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001131{
Patrick McHardy2941a482006-01-08 22:05:26 -08001132 struct ip_tunnel *tunnel = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001133 struct iphdr *iph = &tunnel->parms.iph;
Pavel Emelyanoveb8ce742008-04-16 01:10:26 -07001134 struct ipgre_net *ign = net_generic(dev_net(dev), ipgre_net_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001135
1136 tunnel->dev = dev;
1137 strcpy(tunnel->parms.name, dev->name);
1138
1139 iph->version = 4;
1140 iph->protocol = IPPROTO_GRE;
1141 iph->ihl = 5;
1142 tunnel->hlen = sizeof(struct iphdr) + 4;
1143
1144 dev_hold(dev);
Pavel Emelyanoveb8ce742008-04-16 01:10:26 -07001145 ign->tunnels_wc[0] = tunnel;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001146 return 0;
1147}
1148
1149
1150static struct net_protocol ipgre_protocol = {
1151 .handler = ipgre_rcv,
1152 .err_handler = ipgre_err,
Pavel Emelyanovf96c1482008-04-16 01:11:36 -07001153 .netns_ok = 1,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001154};
1155
Pavel Emelyanoveb8ce742008-04-16 01:10:26 -07001156static void ipgre_destroy_tunnels(struct ipgre_net *ign)
1157{
1158 int prio;
1159
1160 for (prio = 0; prio < 4; prio++) {
1161 int h;
1162 for (h = 0; h < HASH_SIZE; h++) {
1163 struct ip_tunnel *t;
1164 while ((t = ign->tunnels[prio][h]) != NULL)
1165 unregister_netdevice(t->dev);
1166 }
1167 }
1168}
1169
Pavel Emelyanov59a4c752008-04-16 01:08:53 -07001170static int ipgre_init_net(struct net *net)
1171{
1172 int err;
1173 struct ipgre_net *ign;
1174
1175 err = -ENOMEM;
Pavel Emelyanoveb8ce742008-04-16 01:10:26 -07001176 ign = kzalloc(sizeof(struct ipgre_net), GFP_KERNEL);
Pavel Emelyanov59a4c752008-04-16 01:08:53 -07001177 if (ign == NULL)
1178 goto err_alloc;
1179
1180 err = net_assign_generic(net, ipgre_net_id, ign);
1181 if (err < 0)
1182 goto err_assign;
1183
Pavel Emelyanov7daa0002008-04-16 01:10:05 -07001184 ign->fb_tunnel_dev = alloc_netdev(sizeof(struct ip_tunnel), "gre0",
1185 ipgre_tunnel_setup);
1186 if (!ign->fb_tunnel_dev) {
1187 err = -ENOMEM;
1188 goto err_alloc_dev;
1189 }
1190
1191 ign->fb_tunnel_dev->init = ipgre_fb_tunnel_init;
1192 dev_net_set(ign->fb_tunnel_dev, net);
1193
1194 if ((err = register_netdev(ign->fb_tunnel_dev)))
1195 goto err_reg_dev;
1196
Pavel Emelyanov59a4c752008-04-16 01:08:53 -07001197 return 0;
1198
Pavel Emelyanov7daa0002008-04-16 01:10:05 -07001199err_reg_dev:
1200 free_netdev(ign->fb_tunnel_dev);
1201err_alloc_dev:
1202 /* nothing */
Pavel Emelyanov59a4c752008-04-16 01:08:53 -07001203err_assign:
1204 kfree(ign);
1205err_alloc:
1206 return err;
1207}
1208
1209static void ipgre_exit_net(struct net *net)
1210{
1211 struct ipgre_net *ign;
1212
1213 ign = net_generic(net, ipgre_net_id);
Pavel Emelyanov7daa0002008-04-16 01:10:05 -07001214 rtnl_lock();
Pavel Emelyanoveb8ce742008-04-16 01:10:26 -07001215 ipgre_destroy_tunnels(ign);
Pavel Emelyanov7daa0002008-04-16 01:10:05 -07001216 rtnl_unlock();
Pavel Emelyanov59a4c752008-04-16 01:08:53 -07001217 kfree(ign);
1218}
1219
1220static struct pernet_operations ipgre_net_ops = {
1221 .init = ipgre_init_net,
1222 .exit = ipgre_exit_net,
1223};
Linus Torvalds1da177e2005-04-16 15:20:36 -07001224
1225/*
1226 * And now the modules code and kernel interface.
1227 */
1228
1229static int __init ipgre_init(void)
1230{
1231 int err;
1232
1233 printk(KERN_INFO "GRE over IPv4 tunneling driver\n");
1234
1235 if (inet_add_protocol(&ipgre_protocol, IPPROTO_GRE) < 0) {
1236 printk(KERN_INFO "ipgre init: can't add protocol\n");
1237 return -EAGAIN;
1238 }
1239
Pavel Emelyanov59a4c752008-04-16 01:08:53 -07001240 err = register_pernet_gen_device(&ipgre_net_id, &ipgre_net_ops);
1241 if (err < 0)
Pavel Emelyanov7daa0002008-04-16 01:10:05 -07001242 inet_del_protocol(&ipgre_protocol, IPPROTO_GRE);
1243
Linus Torvalds1da177e2005-04-16 15:20:36 -07001244 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001245}
1246
Alexey Kuznetsovdb445752005-07-30 17:46:44 -07001247static void __exit ipgre_fini(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001248{
1249 if (inet_del_protocol(&ipgre_protocol, IPPROTO_GRE) < 0)
1250 printk(KERN_INFO "ipgre close: can't remove protocol\n");
1251
Pavel Emelyanov59a4c752008-04-16 01:08:53 -07001252 unregister_pernet_gen_device(ipgre_net_id, &ipgre_net_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001253}
1254
1255module_init(ipgre_init);
1256module_exit(ipgre_fini);
1257MODULE_LICENSE("GPL");