blob: 2a83591492dd6f3e8b7470c3e9b897dad7625a49 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09002 * Linux NET3: GRE over IP protocol decoder.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003 *
4 * Authors: Alexey Kuznetsov (kuznet@ms2.inr.ac.ru)
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 *
11 */
12
Joe Perchesafd465032012-03-12 07:03:32 +000013#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
14
Randy Dunlap4fc268d2006-01-11 12:17:47 -080015#include <linux/capability.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070016#include <linux/module.h>
17#include <linux/types.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#include <linux/kernel.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090019#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#include <asm/uaccess.h>
21#include <linux/skbuff.h>
22#include <linux/netdevice.h>
23#include <linux/in.h>
24#include <linux/tcp.h>
25#include <linux/udp.h>
26#include <linux/if_arp.h>
27#include <linux/mroute.h>
28#include <linux/init.h>
29#include <linux/in6.h>
30#include <linux/inetdevice.h>
31#include <linux/igmp.h>
32#include <linux/netfilter_ipv4.h>
Herbert Xue1a80002008-10-09 12:00:17 -070033#include <linux/etherdevice.h>
Kris Katterjohn46f25df2006-01-05 16:35:42 -080034#include <linux/if_ether.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070035
36#include <net/sock.h>
37#include <net/ip.h>
38#include <net/icmp.h>
39#include <net/protocol.h>
Pravin B Shelarc5441932013-03-25 14:49:35 +000040#include <net/ip_tunnels.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070041#include <net/arp.h>
42#include <net/checksum.h>
43#include <net/dsfield.h>
44#include <net/inet_ecn.h>
45#include <net/xfrm.h>
Pavel Emelyanov59a4c752008-04-16 01:08:53 -070046#include <net/net_namespace.h>
47#include <net/netns/generic.h>
Herbert Xuc19e6542008-10-09 11:59:55 -070048#include <net/rtnetlink.h>
Dmitry Kozlov00959ad2010-08-21 23:05:39 -070049#include <net/gre.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070050
Eric Dumazetdfd56b82011-12-10 09:48:31 +000051#if IS_ENABLED(CONFIG_IPV6)
Linus Torvalds1da177e2005-04-16 15:20:36 -070052#include <net/ipv6.h>
53#include <net/ip6_fib.h>
54#include <net/ip6_route.h>
55#endif
56
57/*
58 Problems & solutions
59 --------------------
60
61 1. The most important issue is detecting local dead loops.
62 They would cause complete host lockup in transmit, which
63 would be "resolved" by stack overflow or, if queueing is enabled,
64 with infinite looping in net_bh.
65
66 We cannot track such dead loops during route installation,
67 it is infeasible task. The most general solutions would be
68 to keep skb->encapsulation counter (sort of local ttl),
Eric Dumazet6d0722a2010-09-29 23:35:10 -070069 and silently drop packet when it expires. It is a good
stephen hemmingerbff52852012-02-24 08:08:20 +000070 solution, but it supposes maintaining new variable in ALL
Linus Torvalds1da177e2005-04-16 15:20:36 -070071 skb, even if no tunneling is used.
72
Eric Dumazet6d0722a2010-09-29 23:35:10 -070073 Current solution: xmit_recursion breaks dead loops. This is a percpu
74 counter, since when we enter the first ndo_xmit(), cpu migration is
75 forbidden. We force an exit if this counter reaches RECURSION_LIMIT
Linus Torvalds1da177e2005-04-16 15:20:36 -070076
77 2. Networking dead loops would not kill routers, but would really
78 kill network. IP hop limit plays role of "t->recursion" in this case,
79 if we copy it from packet being encapsulated to upper header.
80 It is very good solution, but it introduces two problems:
81
82 - Routing protocols, using packets with ttl=1 (OSPF, RIP2),
83 do not work over tunnels.
84 - traceroute does not work. I planned to relay ICMP from tunnel,
85 so that this problem would be solved and traceroute output
86 would even more informative. This idea appeared to be wrong:
87 only Linux complies to rfc1812 now (yes, guys, Linux is the only
88 true router now :-)), all routers (at least, in neighbourhood of mine)
89 return only 8 bytes of payload. It is the end.
90
91 Hence, if we want that OSPF worked or traceroute said something reasonable,
92 we should search for another solution.
93
94 One of them is to parse packet trying to detect inner encapsulation
95 made by our node. It is difficult or even impossible, especially,
stephen hemmingerbff52852012-02-24 08:08:20 +000096 taking into account fragmentation. TO be short, ttl is not solution at all.
Linus Torvalds1da177e2005-04-16 15:20:36 -070097
98 Current solution: The solution was UNEXPECTEDLY SIMPLE.
99 We force DF flag on tunnels with preconfigured hop limit,
100 that is ALL. :-) Well, it does not remove the problem completely,
101 but exponential growth of network traffic is changed to linear
102 (branches, that exceed pmtu are pruned) and tunnel mtu
stephen hemmingerbff52852012-02-24 08:08:20 +0000103 rapidly degrades to value <68, where looping stops.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104 Yes, it is not good if there exists a router in the loop,
105 which does not force DF, even when encapsulating packets have DF set.
106 But it is not our problem! Nobody could accuse us, we made
107 all that we could make. Even if it is your gated who injected
108 fatal route to network, even if it were you who configured
109 fatal static route: you are innocent. :-)
110
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111 Alexey Kuznetsov.
112 */
113
stephen hemmingereccc1bb2012-09-25 11:02:48 +0000114static bool log_ecn_error = true;
115module_param(log_ecn_error, bool, 0644);
116MODULE_PARM_DESC(log_ecn_error, "Log packets received with corrupted ECN");
117
Herbert Xuc19e6542008-10-09 11:59:55 -0700118static struct rtnl_link_ops ipgre_link_ops __read_mostly;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119static int ipgre_tunnel_init(struct net_device *dev);
Pavel Emelyanoveb8ce742008-04-16 01:10:26 -0700120
Eric Dumazetf99189b2009-11-17 10:42:49 +0000121static int ipgre_net_id __read_mostly;
Pravin B Shelarc5441932013-03-25 14:49:35 +0000122static int gre_tap_net_id __read_mostly;
Pavel Emelyanoveb8ce742008-04-16 01:10:26 -0700123
Pravin B Shelarc5441932013-03-25 14:49:35 +0000124static __sum16 check_checksum(struct sk_buff *skb)
Eric Dumazete985aad2010-09-27 03:57:11 +0000125{
Pravin B Shelarc5441932013-03-25 14:49:35 +0000126 __sum16 csum = 0;
Eric Dumazete985aad2010-09-27 03:57:11 +0000127
Pravin B Shelarc5441932013-03-25 14:49:35 +0000128 switch (skb->ip_summed) {
129 case CHECKSUM_COMPLETE:
130 csum = csum_fold(skb->csum);
Eric Dumazete985aad2010-09-27 03:57:11 +0000131
Pravin B Shelarc5441932013-03-25 14:49:35 +0000132 if (!csum)
133 break;
134 /* Fall through. */
stephen hemminger87b6d212012-04-12 06:31:16 +0000135
Pravin B Shelarc5441932013-03-25 14:49:35 +0000136 case CHECKSUM_NONE:
137 skb->csum = 0;
138 csum = __skb_checksum_complete(skb);
139 skb->ip_summed = CHECKSUM_COMPLETE;
140 break;
Eric Dumazete985aad2010-09-27 03:57:11 +0000141 }
stephen hemminger87b6d212012-04-12 06:31:16 +0000142
Pravin B Shelarc5441932013-03-25 14:49:35 +0000143 return csum;
Eric Dumazete985aad2010-09-27 03:57:11 +0000144}
145
Pravin B Shelarc5441932013-03-25 14:49:35 +0000146static int ip_gre_calc_hlen(__be16 o_flags)
stephen hemmingerd2083282012-09-24 18:12:23 +0000147{
Pravin B Shelarc5441932013-03-25 14:49:35 +0000148 int addend = 4;
149
150 if (o_flags&TUNNEL_CSUM)
151 addend += 4;
152 if (o_flags&TUNNEL_KEY)
153 addend += 4;
154 if (o_flags&TUNNEL_SEQ)
155 addend += 4;
156 return addend;
157}
158
159static int parse_gre_header(struct sk_buff *skb, struct tnl_ptk_info *tpi,
160 bool *csum_err, int *hdr_len)
161{
Eric Dumazet22251c72013-04-04 15:41:27 +0000162 unsigned int ip_hlen = ip_hdrlen(skb);
163 const struct gre_base_hdr *greh;
Pravin B Shelarc5441932013-03-25 14:49:35 +0000164 __be32 *options;
165
166 if (unlikely(!pskb_may_pull(skb, sizeof(struct gre_base_hdr))))
167 return -EINVAL;
168
Eric Dumazet22251c72013-04-04 15:41:27 +0000169 greh = (struct gre_base_hdr *)(skb_network_header(skb) + ip_hlen);
Pravin B Shelarc5441932013-03-25 14:49:35 +0000170 if (unlikely(greh->flags & (GRE_VERSION | GRE_ROUTING)))
171 return -EINVAL;
172
173 tpi->flags = gre_flags_to_tnl_flags(greh->flags);
174 *hdr_len = ip_gre_calc_hlen(tpi->flags);
175
176 if (!pskb_may_pull(skb, *hdr_len))
177 return -EINVAL;
178
Eric Dumazet22251c72013-04-04 15:41:27 +0000179 greh = (struct gre_base_hdr *)(skb_network_header(skb) + ip_hlen);
180
Pravin B Shelarc5441932013-03-25 14:49:35 +0000181 tpi->proto = greh->protocol;
182
183 options = (__be32 *)(greh + 1);
184 if (greh->flags & GRE_CSUM) {
185 if (check_checksum(skb)) {
186 *csum_err = true;
187 return -EINVAL;
188 }
189 options++;
190 }
191
192 if (greh->flags & GRE_KEY) {
193 tpi->key = *options;
194 options++;
stephen hemmingerd2083282012-09-24 18:12:23 +0000195 } else
Pravin B Shelarc5441932013-03-25 14:49:35 +0000196 tpi->key = 0;
stephen hemmingerd2083282012-09-24 18:12:23 +0000197
Pravin B Shelarc5441932013-03-25 14:49:35 +0000198 if (unlikely(greh->flags & GRE_SEQ)) {
199 tpi->seq = *options;
200 options++;
201 } else
202 tpi->seq = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203
Pravin B Shelarc5441932013-03-25 14:49:35 +0000204 /* WCCP version 1 and 2 protocol decoding.
205 * - Change protocol to IP
206 * - When dealing with WCCPv2, Skip extra 4 bytes in GRE header
207 */
208 if (greh->flags == 0 && tpi->proto == htons(ETH_P_WCCP)) {
209 tpi->proto = htons(ETH_P_IP);
210 if ((*(u8 *)options & 0xF0) != 0x40) {
211 *hdr_len += 4;
212 if (!pskb_may_pull(skb, *hdr_len))
213 return -EINVAL;
Timo Terasafcf1242009-01-26 20:56:10 -0800214 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215 }
Herbert Xue1a80002008-10-09 12:00:17 -0700216
Pravin B Shelarc5441932013-03-25 14:49:35 +0000217 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218}
219
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220static void ipgre_err(struct sk_buff *skb, u32 info)
221{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222
Pravin B Shelarc5441932013-03-25 14:49:35 +0000223 /* All the routers (except for Linux) return only
224 8 bytes of packet payload. It means, that precise relaying of
225 ICMP in the real Internet is absolutely infeasible.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226
Pravin B Shelarc5441932013-03-25 14:49:35 +0000227 Moreover, Cisco "wise men" put GRE key to the third word
228 in GRE header. It makes impossible maintaining even soft
229 state for keyed GRE tunnels with enabled checksum. Tell
230 them "thank you".
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231
Pravin B Shelarc5441932013-03-25 14:49:35 +0000232 Well, I wonder, rfc1812 was written by Cisco employee,
233 what the hell these idiots break standards established
234 by themselves???
235 */
236 struct net *net = dev_net(skb->dev);
237 struct ip_tunnel_net *itn;
Eric Dumazet96f5a842013-05-18 08:36:03 +0000238 const struct iphdr *iph;
Arnaldo Carvalho de Melo88c76642007-03-13 14:43:18 -0300239 const int type = icmp_hdr(skb)->type;
240 const int code = icmp_hdr(skb)->code;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241 struct ip_tunnel *t;
Pravin B Shelarc5441932013-03-25 14:49:35 +0000242 struct tnl_ptk_info tpi;
243 int hdr_len;
244 bool csum_err = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245
Pravin B Shelarc5441932013-03-25 14:49:35 +0000246 if (parse_gre_header(skb, &tpi, &csum_err, &hdr_len)) {
247 if (!csum_err) /* ignore csum errors. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249 }
250
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251 switch (type) {
252 default:
253 case ICMP_PARAMETERPROB:
254 return;
255
256 case ICMP_DEST_UNREACH:
257 switch (code) {
258 case ICMP_SR_FAILED:
259 case ICMP_PORT_UNREACH:
260 /* Impossible event. */
261 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262 default:
263 /* All others are translated to HOST_UNREACH.
264 rfc2003 contains "deep thoughts" about NET_UNREACH,
265 I believe they are just ether pollution. --ANK
266 */
267 break;
268 }
269 break;
270 case ICMP_TIME_EXCEEDED:
271 if (code != ICMP_EXC_TTL)
272 return;
273 break;
David S. Miller55be7a92012-07-11 21:27:49 -0700274
275 case ICMP_REDIRECT:
276 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277 }
278
Pravin B Shelarc5441932013-03-25 14:49:35 +0000279 if (tpi.proto == htons(ETH_P_TEB))
280 itn = net_generic(net, gre_tap_net_id);
281 else
282 itn = net_generic(net, ipgre_net_id);
283
Eric Dumazet96f5a842013-05-18 08:36:03 +0000284 iph = (const struct iphdr *)skb->data;
Pravin B Shelarc5441932013-03-25 14:49:35 +0000285 t = ip_tunnel_lookup(itn, skb->dev->ifindex, tpi.flags,
286 iph->daddr, iph->saddr, tpi.key);
stephen hemmingerd2083282012-09-24 18:12:23 +0000287
David S. Miller36393392012-06-14 22:21:46 -0700288 if (t == NULL)
stephen hemminger0c5794a2012-09-24 18:12:24 +0000289 return;
David S. Miller36393392012-06-14 22:21:46 -0700290
291 if (type == ICMP_DEST_UNREACH && code == ICMP_FRAG_NEEDED) {
292 ipv4_update_pmtu(skb, dev_net(skb->dev), info,
293 t->parms.link, 0, IPPROTO_GRE, 0);
stephen hemminger0c5794a2012-09-24 18:12:24 +0000294 return;
David S. Miller36393392012-06-14 22:21:46 -0700295 }
David S. Miller55be7a92012-07-11 21:27:49 -0700296 if (type == ICMP_REDIRECT) {
297 ipv4_redirect(skb, dev_net(skb->dev), t->parms.link, 0,
298 IPPROTO_GRE, 0);
stephen hemminger0c5794a2012-09-24 18:12:24 +0000299 return;
David S. Miller55be7a92012-07-11 21:27:49 -0700300 }
David S. Miller36393392012-06-14 22:21:46 -0700301 if (t->parms.iph.daddr == 0 ||
Joe Perchesf97c1e02007-12-16 13:45:43 -0800302 ipv4_is_multicast(t->parms.iph.daddr))
stephen hemminger0c5794a2012-09-24 18:12:24 +0000303 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304
305 if (t->parms.iph.ttl == 0 && type == ICMP_TIME_EXCEEDED)
stephen hemminger0c5794a2012-09-24 18:12:24 +0000306 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307
Wei Yongjunda6185d82009-02-24 23:34:48 -0800308 if (time_before(jiffies, t->err_time + IPTUNNEL_ERR_TIMEO))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309 t->err_count++;
310 else
311 t->err_count = 1;
312 t->err_time = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313}
314
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315static int ipgre_rcv(struct sk_buff *skb)
316{
Pravin B Shelarc5441932013-03-25 14:49:35 +0000317 struct net *net = dev_net(skb->dev);
318 struct ip_tunnel_net *itn;
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000319 const struct iphdr *iph;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320 struct ip_tunnel *tunnel;
Pravin B Shelarc5441932013-03-25 14:49:35 +0000321 struct tnl_ptk_info tpi;
322 int hdr_len;
323 bool csum_err = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324
Pravin B Shelarc5441932013-03-25 14:49:35 +0000325 if (parse_gre_header(skb, &tpi, &csum_err, &hdr_len) < 0)
stephen hemminger0c5794a2012-09-24 18:12:24 +0000326 goto drop;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327
Pravin B Shelarc5441932013-03-25 14:49:35 +0000328 if (tpi.proto == htons(ETH_P_TEB))
329 itn = net_generic(net, gre_tap_net_id);
330 else
331 itn = net_generic(net, ipgre_net_id);
332
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700333 iph = ip_hdr(skb);
Pravin B Shelarc5441932013-03-25 14:49:35 +0000334 tunnel = ip_tunnel_lookup(itn, skb->dev->ifindex, tpi.flags,
335 iph->saddr, iph->daddr, tpi.key);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336
stephen hemmingerd2083282012-09-24 18:12:23 +0000337 if (tunnel) {
Pravin B Shelarc5441932013-03-25 14:49:35 +0000338 ip_tunnel_rcv(tunnel, skb, &tpi, log_ecn_error);
Eric Dumazet8990f462010-09-20 00:12:11 +0000339 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340 }
Herbert Xu45af08b2006-04-05 22:31:19 -0700341 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342drop:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343 kfree_skb(skb);
Eric Dumazeta02cec22010-09-22 20:43:57 +0000344 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345}
346
Pravin B Shelar8f100982013-02-24 20:05:05 +0000347static struct sk_buff *handle_offloads(struct ip_tunnel *tunnel, struct sk_buff *skb)
Pravin B Shelar68c33162013-02-14 14:02:41 +0000348{
349 int err;
350
351 if (skb_is_gso(skb)) {
352 err = skb_unclone(skb, GFP_ATOMIC);
353 if (unlikely(err))
354 goto error;
355 skb_shinfo(skb)->gso_type |= SKB_GSO_GRE;
356 return skb;
Pravin B Shelar8f100982013-02-24 20:05:05 +0000357 } else if (skb->ip_summed == CHECKSUM_PARTIAL &&
Pravin B Shelarc5441932013-03-25 14:49:35 +0000358 tunnel->parms.o_flags&TUNNEL_CSUM) {
Pravin B Shelar8f100982013-02-24 20:05:05 +0000359 err = skb_checksum_help(skb);
360 if (unlikely(err))
361 goto error;
362 } else if (skb->ip_summed != CHECKSUM_PARTIAL)
Dmitry Kravkovaa0e51c2013-02-18 09:50:52 +0000363 skb->ip_summed = CHECKSUM_NONE;
Pravin B Shelar68c33162013-02-14 14:02:41 +0000364
365 return skb;
366
367error:
368 kfree_skb(skb);
369 return ERR_PTR(err);
370}
371
Pravin B Shelarc5441932013-03-25 14:49:35 +0000372static struct sk_buff *gre_build_header(struct sk_buff *skb,
373 const struct tnl_ptk_info *tpi,
374 int hdr_len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375{
Pravin B Shelarc5441932013-03-25 14:49:35 +0000376 struct gre_base_hdr *greh;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377
Pravin B Shelarc5441932013-03-25 14:49:35 +0000378 skb_push(skb, hdr_len);
379
380 greh = (struct gre_base_hdr *)skb->data;
381 greh->flags = tnl_flags_to_gre_flags(tpi->flags);
382 greh->protocol = tpi->proto;
383
384 if (tpi->flags&(TUNNEL_KEY|TUNNEL_CSUM|TUNNEL_SEQ)) {
385 __be32 *ptr = (__be32 *)(((u8 *)greh) + hdr_len - 4);
386
387 if (tpi->flags&TUNNEL_SEQ) {
388 *ptr = tpi->seq;
389 ptr--;
390 }
391 if (tpi->flags&TUNNEL_KEY) {
392 *ptr = tpi->key;
393 ptr--;
394 }
395 if (tpi->flags&TUNNEL_CSUM &&
396 !(skb_shinfo(skb)->gso_type & SKB_GSO_GRE)) {
397 *(__sum16 *)ptr = 0;
398 *(__sum16 *)ptr = csum_fold(skb_checksum(skb, 0,
399 skb->len, 0));
400 }
Pravin B Shelar68c33162013-02-14 14:02:41 +0000401 }
402
Pravin B Shelarc5441932013-03-25 14:49:35 +0000403 return skb;
404}
405
406static void __gre_xmit(struct sk_buff *skb, struct net_device *dev,
407 const struct iphdr *tnl_params,
408 __be16 proto)
409{
410 struct ip_tunnel *tunnel = netdev_priv(dev);
411 struct tnl_ptk_info tpi;
412
413 if (likely(!skb->encapsulation)) {
Pravin B Shelar68c33162013-02-14 14:02:41 +0000414 skb_reset_inner_headers(skb);
415 skb->encapsulation = 1;
416 }
Eric Dumazet6b78f162012-09-13 21:25:33 +0000417
Pravin B Shelarc5441932013-03-25 14:49:35 +0000418 tpi.flags = tunnel->parms.o_flags;
419 tpi.proto = proto;
420 tpi.key = tunnel->parms.o_key;
421 if (tunnel->parms.o_flags & TUNNEL_SEQ)
422 tunnel->o_seqno++;
423 tpi.seq = htonl(tunnel->o_seqno);
Eric Dumazetcef401d2013-01-25 20:34:37 +0000424
Pravin B Shelarc5441932013-03-25 14:49:35 +0000425 /* Push GRE header. */
426 skb = gre_build_header(skb, &tpi, tunnel->hlen);
427 if (unlikely(!skb)) {
428 dev->stats.tx_dropped++;
429 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430 }
431
Pravin B Shelarc5441932013-03-25 14:49:35 +0000432 ip_tunnel_xmit(skb, dev, tnl_params);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433}
434
Pravin B Shelarc5441932013-03-25 14:49:35 +0000435static netdev_tx_t ipgre_xmit(struct sk_buff *skb,
436 struct net_device *dev)
Michal Schmidtee34c1e2007-12-13 09:46:32 -0800437{
Pravin B Shelarc5441932013-03-25 14:49:35 +0000438 struct ip_tunnel *tunnel = netdev_priv(dev);
439 const struct iphdr *tnl_params;
Michal Schmidtee34c1e2007-12-13 09:46:32 -0800440
Pravin B Shelarc5441932013-03-25 14:49:35 +0000441 skb = handle_offloads(tunnel, skb);
442 if (IS_ERR(skb))
443 goto out;
Michal Schmidtee34c1e2007-12-13 09:46:32 -0800444
Pravin B Shelarc5441932013-03-25 14:49:35 +0000445 if (dev->header_ops) {
446 /* Need space for new headers */
447 if (skb_cow_head(skb, dev->needed_headroom -
Chen Gang2bac7cb2013-04-22 20:45:42 +0000448 (tunnel->hlen + sizeof(struct iphdr))))
Pravin B Shelarc5441932013-03-25 14:49:35 +0000449 goto free_skb;
Michal Schmidtee34c1e2007-12-13 09:46:32 -0800450
Pravin B Shelarc5441932013-03-25 14:49:35 +0000451 tnl_params = (const struct iphdr *)skb->data;
Eric Dumazete985aad2010-09-27 03:57:11 +0000452
Pravin B Shelarc5441932013-03-25 14:49:35 +0000453 /* Pull skb since ip_tunnel_xmit() needs skb->data pointing
454 * to gre header.
455 */
456 skb_pull(skb, tunnel->hlen + sizeof(struct iphdr));
457 } else {
458 if (skb_cow_head(skb, dev->needed_headroom))
459 goto free_skb;
Herbert Xue1a80002008-10-09 12:00:17 -0700460
Pravin B Shelarc5441932013-03-25 14:49:35 +0000461 tnl_params = &tunnel->parms.iph;
Michal Schmidtee34c1e2007-12-13 09:46:32 -0800462 }
463
Pravin B Shelarc5441932013-03-25 14:49:35 +0000464 __gre_xmit(skb, dev, tnl_params, skb->protocol);
Michal Schmidtee34c1e2007-12-13 09:46:32 -0800465
Pravin B Shelarc5441932013-03-25 14:49:35 +0000466 return NETDEV_TX_OK;
Michal Schmidtee34c1e2007-12-13 09:46:32 -0800467
Pravin B Shelarc5441932013-03-25 14:49:35 +0000468free_skb:
469 dev_kfree_skb(skb);
470out:
471 dev->stats.tx_dropped++;
472 return NETDEV_TX_OK;
Michal Schmidtee34c1e2007-12-13 09:46:32 -0800473}
474
Pravin B Shelarc5441932013-03-25 14:49:35 +0000475static netdev_tx_t gre_tap_xmit(struct sk_buff *skb,
476 struct net_device *dev)
477{
478 struct ip_tunnel *tunnel = netdev_priv(dev);
479
480 skb = handle_offloads(tunnel, skb);
481 if (IS_ERR(skb))
482 goto out;
483
484 if (skb_cow_head(skb, dev->needed_headroom))
485 goto free_skb;
486
487 __gre_xmit(skb, dev, &tunnel->parms.iph, htons(ETH_P_TEB));
488
489 return NETDEV_TX_OK;
490
491free_skb:
492 dev_kfree_skb(skb);
493out:
494 dev->stats.tx_dropped++;
495 return NETDEV_TX_OK;
496}
497
498static int ipgre_tunnel_ioctl(struct net_device *dev,
499 struct ifreq *ifr, int cmd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500{
501 int err = 0;
502 struct ip_tunnel_parm p;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503
Pravin B Shelarc5441932013-03-25 14:49:35 +0000504 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
505 return -EFAULT;
506 if (p.iph.version != 4 || p.iph.protocol != IPPROTO_GRE ||
507 p.iph.ihl != 5 || (p.iph.frag_off&htons(~IP_DF)) ||
508 ((p.i_flags|p.o_flags)&(GRE_VERSION|GRE_ROUTING))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509 return -EINVAL;
Pravin B Shelarc5441932013-03-25 14:49:35 +0000510 }
511 p.i_flags = gre_flags_to_tnl_flags(p.i_flags);
512 p.o_flags = gre_flags_to_tnl_flags(p.o_flags);
513
514 err = ip_tunnel_ioctl(dev, &p, cmd);
515 if (err)
516 return err;
517
518 p.i_flags = tnl_flags_to_gre_flags(p.i_flags);
519 p.o_flags = tnl_flags_to_gre_flags(p.o_flags);
520
521 if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p)))
522 return -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523 return 0;
524}
525
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526/* Nice toy. Unfortunately, useless in real life :-)
527 It allows to construct virtual multiprotocol broadcast "LAN"
528 over the Internet, provided multicast routing is tuned.
529
530
531 I have no idea was this bicycle invented before me,
532 so that I had to set ARPHRD_IPGRE to a random value.
533 I have an impression, that Cisco could make something similar,
534 but this feature is apparently missing in IOS<=11.2(8).
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900535
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536 I set up 10.66.66/24 and fec0:6666:6666::0/96 as virtual networks
537 with broadcast 224.66.66.66. If you have access to mbone, play with me :-)
538
539 ping -t 255 224.66.66.66
540
541 If nobody answers, mbone does not work.
542
543 ip tunnel add Universe mode gre remote 224.66.66.66 local <Your_real_addr> ttl 255
544 ip addr add 10.66.66.<somewhat>/24 dev Universe
545 ifconfig Universe up
546 ifconfig Universe add fe80::<Your_real_addr>/10
547 ifconfig Universe add fec0:6666:6666::<Your_real_addr>/96
548 ftp 10.66.66.66
549 ...
550 ftp fec0:6666:6666::193.233.7.65
551 ...
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552 */
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700553static int ipgre_header(struct sk_buff *skb, struct net_device *dev,
554 unsigned short type,
Eric Dumazet15078502010-09-15 11:07:53 +0000555 const void *daddr, const void *saddr, unsigned int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556{
Patrick McHardy2941a482006-01-08 22:05:26 -0800557 struct ip_tunnel *t = netdev_priv(dev);
Pravin B Shelarc5441932013-03-25 14:49:35 +0000558 struct iphdr *iph;
559 struct gre_base_hdr *greh;
560
561 iph = (struct iphdr *)skb_push(skb, t->hlen + sizeof(*iph));
562 greh = (struct gre_base_hdr *)(iph+1);
563 greh->flags = tnl_flags_to_gre_flags(t->parms.o_flags);
564 greh->protocol = htons(type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565
566 memcpy(iph, &t->parms.iph, sizeof(struct iphdr));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567
Pravin B Shelarc5441932013-03-25 14:49:35 +0000568 /* Set the source hardware address. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569 if (saddr)
570 memcpy(&iph->saddr, saddr, 4);
Timo Teräs6d55cb92010-03-03 04:01:13 +0000571 if (daddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572 memcpy(&iph->daddr, daddr, 4);
Timo Teräs6d55cb92010-03-03 04:01:13 +0000573 if (iph->daddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574 return t->hlen;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900575
Pravin B Shelarc5441932013-03-25 14:49:35 +0000576 return -(t->hlen + sizeof(*iph));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577}
578
Timo Teras6a5f44d2007-10-23 20:31:53 -0700579static int ipgre_header_parse(const struct sk_buff *skb, unsigned char *haddr)
580{
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000581 const struct iphdr *iph = (const struct iphdr *) skb_mac_header(skb);
Timo Teras6a5f44d2007-10-23 20:31:53 -0700582 memcpy(haddr, &iph->saddr, 4);
583 return 4;
584}
585
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700586static const struct header_ops ipgre_header_ops = {
587 .create = ipgre_header,
Timo Teras6a5f44d2007-10-23 20:31:53 -0700588 .parse = ipgre_header_parse,
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700589};
590
Timo Teras6a5f44d2007-10-23 20:31:53 -0700591#ifdef CONFIG_NET_IPGRE_BROADCAST
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592static int ipgre_open(struct net_device *dev)
593{
Patrick McHardy2941a482006-01-08 22:05:26 -0800594 struct ip_tunnel *t = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595
Joe Perchesf97c1e02007-12-16 13:45:43 -0800596 if (ipv4_is_multicast(t->parms.iph.daddr)) {
David S. Millercbb1e852011-05-04 12:33:34 -0700597 struct flowi4 fl4;
598 struct rtable *rt;
Eric Dumazete985aad2010-09-27 03:57:11 +0000599
David S. Millercbb1e852011-05-04 12:33:34 -0700600 rt = ip_route_output_gre(dev_net(dev), &fl4,
601 t->parms.iph.daddr,
602 t->parms.iph.saddr,
603 t->parms.o_key,
604 RT_TOS(t->parms.iph.tos),
605 t->parms.link);
David S. Millerb23dd4f2011-03-02 14:31:35 -0800606 if (IS_ERR(rt))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607 return -EADDRNOTAVAIL;
Changli Gaod8d1f302010-06-10 23:31:35 -0700608 dev = rt->dst.dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609 ip_rt_put(rt);
Herbert Xue5ed6392005-10-03 14:35:55 -0700610 if (__in_dev_get_rtnl(dev) == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611 return -EADDRNOTAVAIL;
612 t->mlink = dev->ifindex;
Herbert Xue5ed6392005-10-03 14:35:55 -0700613 ip_mc_inc_group(__in_dev_get_rtnl(dev), t->parms.iph.daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614 }
615 return 0;
616}
617
618static int ipgre_close(struct net_device *dev)
619{
Patrick McHardy2941a482006-01-08 22:05:26 -0800620 struct ip_tunnel *t = netdev_priv(dev);
Stephen Hemmingerb8c26a32008-11-20 20:34:29 -0800621
Joe Perchesf97c1e02007-12-16 13:45:43 -0800622 if (ipv4_is_multicast(t->parms.iph.daddr) && t->mlink) {
Denis V. Lunev7fee0ca2008-01-21 17:32:38 -0800623 struct in_device *in_dev;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900624 in_dev = inetdev_by_index(dev_net(dev), t->mlink);
Eric Dumazet8723e1b2010-10-19 00:39:26 +0000625 if (in_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626 ip_mc_dec_group(in_dev, t->parms.iph.daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627 }
628 return 0;
629}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630#endif
631
Stephen Hemmingerb8c26a32008-11-20 20:34:29 -0800632static const struct net_device_ops ipgre_netdev_ops = {
633 .ndo_init = ipgre_tunnel_init,
Pravin B Shelarc5441932013-03-25 14:49:35 +0000634 .ndo_uninit = ip_tunnel_uninit,
Stephen Hemmingerb8c26a32008-11-20 20:34:29 -0800635#ifdef CONFIG_NET_IPGRE_BROADCAST
636 .ndo_open = ipgre_open,
637 .ndo_stop = ipgre_close,
638#endif
Pravin B Shelarc5441932013-03-25 14:49:35 +0000639 .ndo_start_xmit = ipgre_xmit,
Stephen Hemmingerb8c26a32008-11-20 20:34:29 -0800640 .ndo_do_ioctl = ipgre_tunnel_ioctl,
Pravin B Shelarc5441932013-03-25 14:49:35 +0000641 .ndo_change_mtu = ip_tunnel_change_mtu,
642 .ndo_get_stats64 = ip_tunnel_get_stats64,
Stephen Hemmingerb8c26a32008-11-20 20:34:29 -0800643};
644
Eric Dumazet6b78f162012-09-13 21:25:33 +0000645#define GRE_FEATURES (NETIF_F_SG | \
646 NETIF_F_FRAGLIST | \
647 NETIF_F_HIGHDMA | \
648 NETIF_F_HW_CSUM)
649
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650static void ipgre_tunnel_setup(struct net_device *dev)
651{
Stephen Hemmingerb8c26a32008-11-20 20:34:29 -0800652 dev->netdev_ops = &ipgre_netdev_ops;
Pravin B Shelarc5441932013-03-25 14:49:35 +0000653 ip_tunnel_setup(dev, ipgre_net_id);
654}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700655
Pravin B Shelarc5441932013-03-25 14:49:35 +0000656static void __gre_tunnel_init(struct net_device *dev)
657{
658 struct ip_tunnel *tunnel;
659
660 tunnel = netdev_priv(dev);
661 tunnel->hlen = ip_gre_calc_hlen(tunnel->parms.o_flags);
662 tunnel->parms.iph.protocol = IPPROTO_GRE;
663
664 dev->needed_headroom = LL_MAX_HEADER + sizeof(struct iphdr) + 4;
Kris Katterjohn46f25df2006-01-05 16:35:42 -0800665 dev->mtu = ETH_DATA_LEN - sizeof(struct iphdr) - 4;
Eric Dumazet6b78f162012-09-13 21:25:33 +0000666
Pravin B Shelarc5441932013-03-25 14:49:35 +0000667 dev->features |= NETIF_F_NETNS_LOCAL | GRE_FEATURES;
Eric Dumazet6b78f162012-09-13 21:25:33 +0000668 dev->hw_features |= GRE_FEATURES;
Pravin B Shelarc5441932013-03-25 14:49:35 +0000669
670 if (!(tunnel->parms.o_flags & TUNNEL_SEQ)) {
671 /* TCP offload with GRE SEQ is not supported. */
672 dev->features |= NETIF_F_GSO_SOFTWARE;
673 dev->hw_features |= NETIF_F_GSO_SOFTWARE;
674 /* Can use a lockless transmit, unless we generate
675 * output sequences
676 */
677 dev->features |= NETIF_F_LLTX;
678 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679}
680
681static int ipgre_tunnel_init(struct net_device *dev)
682{
Pravin B Shelarc5441932013-03-25 14:49:35 +0000683 struct ip_tunnel *tunnel = netdev_priv(dev);
684 struct iphdr *iph = &tunnel->parms.iph;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685
Pravin B Shelarc5441932013-03-25 14:49:35 +0000686 __gre_tunnel_init(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687
Pravin B Shelarc5441932013-03-25 14:49:35 +0000688 memcpy(dev->dev_addr, &iph->saddr, 4);
689 memcpy(dev->broadcast, &iph->daddr, 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690
Pravin B Shelarc5441932013-03-25 14:49:35 +0000691 dev->type = ARPHRD_IPGRE;
692 dev->flags = IFF_NOARP;
693 dev->priv_flags &= ~IFF_XMIT_DST_RELEASE;
694 dev->addr_len = 4;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696 if (iph->daddr) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697#ifdef CONFIG_NET_IPGRE_BROADCAST
Joe Perchesf97c1e02007-12-16 13:45:43 -0800698 if (ipv4_is_multicast(iph->daddr)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699 if (!iph->saddr)
700 return -EINVAL;
701 dev->flags = IFF_BROADCAST;
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700702 dev->header_ops = &ipgre_header_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703 }
704#endif
Michal Schmidtee34c1e2007-12-13 09:46:32 -0800705 } else
Timo Teras6a5f44d2007-10-23 20:31:53 -0700706 dev->header_ops = &ipgre_header_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707
Pravin B Shelarc5441932013-03-25 14:49:35 +0000708 return ip_tunnel_init(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709}
710
Dmitry Kozlov00959ad2010-08-21 23:05:39 -0700711static const struct gre_protocol ipgre_protocol = {
712 .handler = ipgre_rcv,
713 .err_handler = ipgre_err,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714};
715
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +0000716static int __net_init ipgre_init_net(struct net *net)
Pavel Emelyanov59a4c752008-04-16 01:08:53 -0700717{
Pravin B Shelarc5441932013-03-25 14:49:35 +0000718 return ip_tunnel_init_net(net, ipgre_net_id, &ipgre_link_ops, NULL);
Pavel Emelyanov59a4c752008-04-16 01:08:53 -0700719}
720
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +0000721static void __net_exit ipgre_exit_net(struct net *net)
Pavel Emelyanov59a4c752008-04-16 01:08:53 -0700722{
Pravin B Shelarc5441932013-03-25 14:49:35 +0000723 struct ip_tunnel_net *itn = net_generic(net, ipgre_net_id);
724 ip_tunnel_delete_net(itn);
Pavel Emelyanov59a4c752008-04-16 01:08:53 -0700725}
726
727static struct pernet_operations ipgre_net_ops = {
728 .init = ipgre_init_net,
729 .exit = ipgre_exit_net,
Eric W. Biedermancfb8fbf2009-11-29 15:46:13 +0000730 .id = &ipgre_net_id,
Pravin B Shelarc5441932013-03-25 14:49:35 +0000731 .size = sizeof(struct ip_tunnel_net),
Pavel Emelyanov59a4c752008-04-16 01:08:53 -0700732};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733
Herbert Xuc19e6542008-10-09 11:59:55 -0700734static int ipgre_tunnel_validate(struct nlattr *tb[], struct nlattr *data[])
735{
736 __be16 flags;
737
738 if (!data)
739 return 0;
740
741 flags = 0;
742 if (data[IFLA_GRE_IFLAGS])
743 flags |= nla_get_be16(data[IFLA_GRE_IFLAGS]);
744 if (data[IFLA_GRE_OFLAGS])
745 flags |= nla_get_be16(data[IFLA_GRE_OFLAGS]);
746 if (flags & (GRE_VERSION|GRE_ROUTING))
747 return -EINVAL;
748
749 return 0;
750}
751
Herbert Xue1a80002008-10-09 12:00:17 -0700752static int ipgre_tap_validate(struct nlattr *tb[], struct nlattr *data[])
753{
754 __be32 daddr;
755
756 if (tb[IFLA_ADDRESS]) {
757 if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
758 return -EINVAL;
759 if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
760 return -EADDRNOTAVAIL;
761 }
762
763 if (!data)
764 goto out;
765
766 if (data[IFLA_GRE_REMOTE]) {
767 memcpy(&daddr, nla_data(data[IFLA_GRE_REMOTE]), 4);
768 if (!daddr)
769 return -EINVAL;
770 }
771
772out:
773 return ipgre_tunnel_validate(tb, data);
774}
775
Pravin B Shelarc5441932013-03-25 14:49:35 +0000776static void ipgre_netlink_parms(struct nlattr *data[], struct nlattr *tb[],
777 struct ip_tunnel_parm *parms)
Herbert Xuc19e6542008-10-09 11:59:55 -0700778{
Herbert Xu7bb82d92008-10-11 12:20:15 -0700779 memset(parms, 0, sizeof(*parms));
Herbert Xuc19e6542008-10-09 11:59:55 -0700780
781 parms->iph.protocol = IPPROTO_GRE;
782
783 if (!data)
784 return;
785
786 if (data[IFLA_GRE_LINK])
787 parms->link = nla_get_u32(data[IFLA_GRE_LINK]);
788
789 if (data[IFLA_GRE_IFLAGS])
Pravin B Shelarc5441932013-03-25 14:49:35 +0000790 parms->i_flags = gre_flags_to_tnl_flags(nla_get_be16(data[IFLA_GRE_IFLAGS]));
Herbert Xuc19e6542008-10-09 11:59:55 -0700791
792 if (data[IFLA_GRE_OFLAGS])
Pravin B Shelarc5441932013-03-25 14:49:35 +0000793 parms->o_flags = gre_flags_to_tnl_flags(nla_get_be16(data[IFLA_GRE_OFLAGS]));
Herbert Xuc19e6542008-10-09 11:59:55 -0700794
795 if (data[IFLA_GRE_IKEY])
796 parms->i_key = nla_get_be32(data[IFLA_GRE_IKEY]);
797
798 if (data[IFLA_GRE_OKEY])
799 parms->o_key = nla_get_be32(data[IFLA_GRE_OKEY]);
800
801 if (data[IFLA_GRE_LOCAL])
Patrick McHardy4d74f8b2008-10-10 12:11:06 -0700802 parms->iph.saddr = nla_get_be32(data[IFLA_GRE_LOCAL]);
Herbert Xuc19e6542008-10-09 11:59:55 -0700803
804 if (data[IFLA_GRE_REMOTE])
Patrick McHardy4d74f8b2008-10-10 12:11:06 -0700805 parms->iph.daddr = nla_get_be32(data[IFLA_GRE_REMOTE]);
Herbert Xuc19e6542008-10-09 11:59:55 -0700806
807 if (data[IFLA_GRE_TTL])
808 parms->iph.ttl = nla_get_u8(data[IFLA_GRE_TTL]);
809
810 if (data[IFLA_GRE_TOS])
811 parms->iph.tos = nla_get_u8(data[IFLA_GRE_TOS]);
812
813 if (!data[IFLA_GRE_PMTUDISC] || nla_get_u8(data[IFLA_GRE_PMTUDISC]))
814 parms->iph.frag_off = htons(IP_DF);
815}
816
Pravin B Shelarc5441932013-03-25 14:49:35 +0000817static int gre_tap_init(struct net_device *dev)
Herbert Xue1a80002008-10-09 12:00:17 -0700818{
Pravin B Shelarc5441932013-03-25 14:49:35 +0000819 __gre_tunnel_init(dev);
Herbert Xue1a80002008-10-09 12:00:17 -0700820
Pravin B Shelarc5441932013-03-25 14:49:35 +0000821 return ip_tunnel_init(dev);
Herbert Xue1a80002008-10-09 12:00:17 -0700822}
823
Pravin B Shelarc5441932013-03-25 14:49:35 +0000824static const struct net_device_ops gre_tap_netdev_ops = {
825 .ndo_init = gre_tap_init,
826 .ndo_uninit = ip_tunnel_uninit,
827 .ndo_start_xmit = gre_tap_xmit,
Stephen Hemmingerb8c26a32008-11-20 20:34:29 -0800828 .ndo_set_mac_address = eth_mac_addr,
829 .ndo_validate_addr = eth_validate_addr,
Pravin B Shelarc5441932013-03-25 14:49:35 +0000830 .ndo_change_mtu = ip_tunnel_change_mtu,
831 .ndo_get_stats64 = ip_tunnel_get_stats64,
Stephen Hemmingerb8c26a32008-11-20 20:34:29 -0800832};
833
Herbert Xue1a80002008-10-09 12:00:17 -0700834static void ipgre_tap_setup(struct net_device *dev)
835{
Herbert Xue1a80002008-10-09 12:00:17 -0700836 ether_setup(dev);
Pravin B Shelarc5441932013-03-25 14:49:35 +0000837 dev->netdev_ops = &gre_tap_netdev_ops;
838 ip_tunnel_setup(dev, gre_tap_net_id);
Herbert Xue1a80002008-10-09 12:00:17 -0700839}
840
Pravin B Shelarc5441932013-03-25 14:49:35 +0000841static int ipgre_newlink(struct net *src_net, struct net_device *dev,
842 struct nlattr *tb[], struct nlattr *data[])
Herbert Xuc19e6542008-10-09 11:59:55 -0700843{
Pravin B Shelarc5441932013-03-25 14:49:35 +0000844 struct ip_tunnel_parm p;
Herbert Xuc19e6542008-10-09 11:59:55 -0700845
Pravin B Shelarc5441932013-03-25 14:49:35 +0000846 ipgre_netlink_parms(data, tb, &p);
847 return ip_tunnel_newlink(dev, tb, &p);
Herbert Xuc19e6542008-10-09 11:59:55 -0700848}
849
850static int ipgre_changelink(struct net_device *dev, struct nlattr *tb[],
851 struct nlattr *data[])
852{
Herbert Xuc19e6542008-10-09 11:59:55 -0700853 struct ip_tunnel_parm p;
Herbert Xuc19e6542008-10-09 11:59:55 -0700854
Pravin B Shelarc5441932013-03-25 14:49:35 +0000855 ipgre_netlink_parms(data, tb, &p);
856 return ip_tunnel_changelink(dev, tb, &p);
Herbert Xuc19e6542008-10-09 11:59:55 -0700857}
858
859static size_t ipgre_get_size(const struct net_device *dev)
860{
861 return
862 /* IFLA_GRE_LINK */
863 nla_total_size(4) +
864 /* IFLA_GRE_IFLAGS */
865 nla_total_size(2) +
866 /* IFLA_GRE_OFLAGS */
867 nla_total_size(2) +
868 /* IFLA_GRE_IKEY */
869 nla_total_size(4) +
870 /* IFLA_GRE_OKEY */
871 nla_total_size(4) +
872 /* IFLA_GRE_LOCAL */
873 nla_total_size(4) +
874 /* IFLA_GRE_REMOTE */
875 nla_total_size(4) +
876 /* IFLA_GRE_TTL */
877 nla_total_size(1) +
878 /* IFLA_GRE_TOS */
879 nla_total_size(1) +
880 /* IFLA_GRE_PMTUDISC */
881 nla_total_size(1) +
882 0;
883}
884
885static int ipgre_fill_info(struct sk_buff *skb, const struct net_device *dev)
886{
887 struct ip_tunnel *t = netdev_priv(dev);
888 struct ip_tunnel_parm *p = &t->parms;
889
David S. Millerf3756b72012-04-01 20:39:02 -0400890 if (nla_put_u32(skb, IFLA_GRE_LINK, p->link) ||
Pravin B Shelarc5441932013-03-25 14:49:35 +0000891 nla_put_be16(skb, IFLA_GRE_IFLAGS, tnl_flags_to_gre_flags(p->i_flags)) ||
892 nla_put_be16(skb, IFLA_GRE_OFLAGS, tnl_flags_to_gre_flags(p->o_flags)) ||
David S. Millerf3756b72012-04-01 20:39:02 -0400893 nla_put_be32(skb, IFLA_GRE_IKEY, p->i_key) ||
894 nla_put_be32(skb, IFLA_GRE_OKEY, p->o_key) ||
895 nla_put_be32(skb, IFLA_GRE_LOCAL, p->iph.saddr) ||
896 nla_put_be32(skb, IFLA_GRE_REMOTE, p->iph.daddr) ||
897 nla_put_u8(skb, IFLA_GRE_TTL, p->iph.ttl) ||
898 nla_put_u8(skb, IFLA_GRE_TOS, p->iph.tos) ||
899 nla_put_u8(skb, IFLA_GRE_PMTUDISC,
900 !!(p->iph.frag_off & htons(IP_DF))))
901 goto nla_put_failure;
Herbert Xuc19e6542008-10-09 11:59:55 -0700902 return 0;
903
904nla_put_failure:
905 return -EMSGSIZE;
906}
907
908static const struct nla_policy ipgre_policy[IFLA_GRE_MAX + 1] = {
909 [IFLA_GRE_LINK] = { .type = NLA_U32 },
910 [IFLA_GRE_IFLAGS] = { .type = NLA_U16 },
911 [IFLA_GRE_OFLAGS] = { .type = NLA_U16 },
912 [IFLA_GRE_IKEY] = { .type = NLA_U32 },
913 [IFLA_GRE_OKEY] = { .type = NLA_U32 },
Patrick McHardy4d74f8b2008-10-10 12:11:06 -0700914 [IFLA_GRE_LOCAL] = { .len = FIELD_SIZEOF(struct iphdr, saddr) },
915 [IFLA_GRE_REMOTE] = { .len = FIELD_SIZEOF(struct iphdr, daddr) },
Herbert Xuc19e6542008-10-09 11:59:55 -0700916 [IFLA_GRE_TTL] = { .type = NLA_U8 },
917 [IFLA_GRE_TOS] = { .type = NLA_U8 },
918 [IFLA_GRE_PMTUDISC] = { .type = NLA_U8 },
919};
920
921static struct rtnl_link_ops ipgre_link_ops __read_mostly = {
922 .kind = "gre",
923 .maxtype = IFLA_GRE_MAX,
924 .policy = ipgre_policy,
925 .priv_size = sizeof(struct ip_tunnel),
926 .setup = ipgre_tunnel_setup,
927 .validate = ipgre_tunnel_validate,
928 .newlink = ipgre_newlink,
929 .changelink = ipgre_changelink,
Pravin B Shelarc5441932013-03-25 14:49:35 +0000930 .dellink = ip_tunnel_dellink,
Herbert Xuc19e6542008-10-09 11:59:55 -0700931 .get_size = ipgre_get_size,
932 .fill_info = ipgre_fill_info,
933};
934
Herbert Xue1a80002008-10-09 12:00:17 -0700935static struct rtnl_link_ops ipgre_tap_ops __read_mostly = {
936 .kind = "gretap",
937 .maxtype = IFLA_GRE_MAX,
938 .policy = ipgre_policy,
939 .priv_size = sizeof(struct ip_tunnel),
940 .setup = ipgre_tap_setup,
941 .validate = ipgre_tap_validate,
942 .newlink = ipgre_newlink,
943 .changelink = ipgre_changelink,
Pravin B Shelarc5441932013-03-25 14:49:35 +0000944 .dellink = ip_tunnel_dellink,
Herbert Xue1a80002008-10-09 12:00:17 -0700945 .get_size = ipgre_get_size,
946 .fill_info = ipgre_fill_info,
947};
948
Pravin B Shelarc5441932013-03-25 14:49:35 +0000949static int __net_init ipgre_tap_init_net(struct net *net)
950{
951 return ip_tunnel_init_net(net, gre_tap_net_id, &ipgre_tap_ops, NULL);
952}
953
954static void __net_exit ipgre_tap_exit_net(struct net *net)
955{
956 struct ip_tunnel_net *itn = net_generic(net, gre_tap_net_id);
957 ip_tunnel_delete_net(itn);
958}
959
960static struct pernet_operations ipgre_tap_net_ops = {
961 .init = ipgre_tap_init_net,
962 .exit = ipgre_tap_exit_net,
963 .id = &gre_tap_net_id,
964 .size = sizeof(struct ip_tunnel_net),
965};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700966
967static int __init ipgre_init(void)
968{
969 int err;
970
Joe Perches058bd4d2012-03-11 18:36:11 +0000971 pr_info("GRE over IPv4 tunneling driver\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700972
Eric W. Biedermancfb8fbf2009-11-29 15:46:13 +0000973 err = register_pernet_device(&ipgre_net_ops);
Pavel Emelyanov59a4c752008-04-16 01:08:53 -0700974 if (err < 0)
Alexey Dobriyanc2892f02010-02-16 07:57:44 +0000975 return err;
976
Pravin B Shelarc5441932013-03-25 14:49:35 +0000977 err = register_pernet_device(&ipgre_tap_net_ops);
978 if (err < 0)
979 goto pnet_tap_faied;
980
Dmitry Kozlov00959ad2010-08-21 23:05:39 -0700981 err = gre_add_protocol(&ipgre_protocol, GREPROTO_CISCO);
Alexey Dobriyanc2892f02010-02-16 07:57:44 +0000982 if (err < 0) {
Joe Perches058bd4d2012-03-11 18:36:11 +0000983 pr_info("%s: can't add protocol\n", __func__);
Alexey Dobriyanc2892f02010-02-16 07:57:44 +0000984 goto add_proto_failed;
985 }
Pavel Emelyanov7daa0002008-04-16 01:10:05 -0700986
Herbert Xuc19e6542008-10-09 11:59:55 -0700987 err = rtnl_link_register(&ipgre_link_ops);
988 if (err < 0)
989 goto rtnl_link_failed;
990
Herbert Xue1a80002008-10-09 12:00:17 -0700991 err = rtnl_link_register(&ipgre_tap_ops);
992 if (err < 0)
993 goto tap_ops_failed;
994
Pravin B Shelarc5441932013-03-25 14:49:35 +0000995 return 0;
Herbert Xuc19e6542008-10-09 11:59:55 -0700996
Herbert Xue1a80002008-10-09 12:00:17 -0700997tap_ops_failed:
998 rtnl_link_unregister(&ipgre_link_ops);
Herbert Xuc19e6542008-10-09 11:59:55 -0700999rtnl_link_failed:
Dmitry Kozlov00959ad2010-08-21 23:05:39 -07001000 gre_del_protocol(&ipgre_protocol, GREPROTO_CISCO);
Alexey Dobriyanc2892f02010-02-16 07:57:44 +00001001add_proto_failed:
Pravin B Shelarc5441932013-03-25 14:49:35 +00001002 unregister_pernet_device(&ipgre_tap_net_ops);
1003pnet_tap_faied:
Alexey Dobriyanc2892f02010-02-16 07:57:44 +00001004 unregister_pernet_device(&ipgre_net_ops);
Pravin B Shelarc5441932013-03-25 14:49:35 +00001005 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001006}
1007
Alexey Kuznetsovdb445752005-07-30 17:46:44 -07001008static void __exit ipgre_fini(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001009{
Herbert Xue1a80002008-10-09 12:00:17 -07001010 rtnl_link_unregister(&ipgre_tap_ops);
Herbert Xuc19e6542008-10-09 11:59:55 -07001011 rtnl_link_unregister(&ipgre_link_ops);
Dmitry Kozlov00959ad2010-08-21 23:05:39 -07001012 if (gre_del_protocol(&ipgre_protocol, GREPROTO_CISCO) < 0)
Joe Perches058bd4d2012-03-11 18:36:11 +00001013 pr_info("%s: can't remove protocol\n", __func__);
Pravin B Shelarc5441932013-03-25 14:49:35 +00001014 unregister_pernet_device(&ipgre_tap_net_ops);
Alexey Dobriyanc2892f02010-02-16 07:57:44 +00001015 unregister_pernet_device(&ipgre_net_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001016}
1017
1018module_init(ipgre_init);
1019module_exit(ipgre_fini);
1020MODULE_LICENSE("GPL");
Patrick McHardy4d74f8b2008-10-10 12:11:06 -07001021MODULE_ALIAS_RTNL_LINK("gre");
1022MODULE_ALIAS_RTNL_LINK("gretap");
Vasiliy Kulikov8909c9a2011-03-02 00:33:13 +03001023MODULE_ALIAS_NETDEV("gre0");
Pravin B Shelarc5441932013-03-25 14:49:35 +00001024MODULE_ALIAS_NETDEV("gretap0");