blob: 6207275fc749fc52f00e63d6cae212148a791f1b [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 Shelarbda7bb42013-06-17 17:49:38 -0700124static int ipgre_err(struct sk_buff *skb, u32 info,
125 const struct tnl_ptk_info *tpi)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127
Pravin B Shelarc5441932013-03-25 14:49:35 +0000128 /* All the routers (except for Linux) return only
129 8 bytes of packet payload. It means, that precise relaying of
130 ICMP in the real Internet is absolutely infeasible.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131
Pravin B Shelarc5441932013-03-25 14:49:35 +0000132 Moreover, Cisco "wise men" put GRE key to the third word
133 in GRE header. It makes impossible maintaining even soft
134 state for keyed GRE tunnels with enabled checksum. Tell
135 them "thank you".
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136
Pravin B Shelarc5441932013-03-25 14:49:35 +0000137 Well, I wonder, rfc1812 was written by Cisco employee,
138 what the hell these idiots break standards established
139 by themselves???
140 */
141 struct net *net = dev_net(skb->dev);
142 struct ip_tunnel_net *itn;
Eric Dumazet96f5a842013-05-18 08:36:03 +0000143 const struct iphdr *iph;
Arnaldo Carvalho de Melo88c76642007-03-13 14:43:18 -0300144 const int type = icmp_hdr(skb)->type;
145 const int code = icmp_hdr(skb)->code;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146 struct ip_tunnel *t;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148 switch (type) {
149 default:
150 case ICMP_PARAMETERPROB:
Pravin B Shelarbda7bb42013-06-17 17:49:38 -0700151 return PACKET_RCVD;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152
153 case ICMP_DEST_UNREACH:
154 switch (code) {
155 case ICMP_SR_FAILED:
156 case ICMP_PORT_UNREACH:
157 /* Impossible event. */
Pravin B Shelarbda7bb42013-06-17 17:49:38 -0700158 return PACKET_RCVD;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159 default:
160 /* All others are translated to HOST_UNREACH.
161 rfc2003 contains "deep thoughts" about NET_UNREACH,
162 I believe they are just ether pollution. --ANK
163 */
164 break;
165 }
166 break;
167 case ICMP_TIME_EXCEEDED:
168 if (code != ICMP_EXC_TTL)
Pravin B Shelarbda7bb42013-06-17 17:49:38 -0700169 return PACKET_RCVD;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170 break;
David S. Miller55be7a92012-07-11 21:27:49 -0700171
172 case ICMP_REDIRECT:
173 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174 }
175
Pravin B Shelarbda7bb42013-06-17 17:49:38 -0700176 if (tpi->proto == htons(ETH_P_TEB))
Pravin B Shelarc5441932013-03-25 14:49:35 +0000177 itn = net_generic(net, gre_tap_net_id);
178 else
179 itn = net_generic(net, ipgre_net_id);
180
Duan Jiongc0c0c502014-01-28 11:49:43 +0800181 iph = (const struct iphdr *)(icmp_hdr(skb) + 1);
Pravin B Shelarbda7bb42013-06-17 17:49:38 -0700182 t = ip_tunnel_lookup(itn, skb->dev->ifindex, tpi->flags,
183 iph->daddr, iph->saddr, tpi->key);
stephen hemmingerd2083282012-09-24 18:12:23 +0000184
David S. Miller36393392012-06-14 22:21:46 -0700185 if (t == NULL)
Pravin B Shelarbda7bb42013-06-17 17:49:38 -0700186 return PACKET_REJECT;
David S. Miller36393392012-06-14 22:21:46 -0700187
David S. Miller36393392012-06-14 22:21:46 -0700188 if (t->parms.iph.daddr == 0 ||
Joe Perchesf97c1e02007-12-16 13:45:43 -0800189 ipv4_is_multicast(t->parms.iph.daddr))
Pravin B Shelarbda7bb42013-06-17 17:49:38 -0700190 return PACKET_RCVD;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191
192 if (t->parms.iph.ttl == 0 && type == ICMP_TIME_EXCEEDED)
Pravin B Shelarbda7bb42013-06-17 17:49:38 -0700193 return PACKET_RCVD;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194
Wei Yongjunda6185d82009-02-24 23:34:48 -0800195 if (time_before(jiffies, t->err_time + IPTUNNEL_ERR_TIMEO))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196 t->err_count++;
197 else
198 t->err_count = 1;
199 t->err_time = jiffies;
Pravin B Shelarbda7bb42013-06-17 17:49:38 -0700200 return PACKET_RCVD;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201}
202
Pravin B Shelarbda7bb42013-06-17 17:49:38 -0700203static int ipgre_rcv(struct sk_buff *skb, const struct tnl_ptk_info *tpi)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204{
Pravin B Shelarc5441932013-03-25 14:49:35 +0000205 struct net *net = dev_net(skb->dev);
206 struct ip_tunnel_net *itn;
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000207 const struct iphdr *iph;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208 struct ip_tunnel *tunnel;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209
Pravin B Shelarbda7bb42013-06-17 17:49:38 -0700210 if (tpi->proto == htons(ETH_P_TEB))
Pravin B Shelarc5441932013-03-25 14:49:35 +0000211 itn = net_generic(net, gre_tap_net_id);
212 else
213 itn = net_generic(net, ipgre_net_id);
214
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700215 iph = ip_hdr(skb);
Pravin B Shelarbda7bb42013-06-17 17:49:38 -0700216 tunnel = ip_tunnel_lookup(itn, skb->dev->ifindex, tpi->flags,
217 iph->saddr, iph->daddr, tpi->key);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218
stephen hemmingerd2083282012-09-24 18:12:23 +0000219 if (tunnel) {
Timo Teräs0e3da5b2013-12-16 11:02:09 +0200220 skb_pop_mac_header(skb);
Pravin B Shelarbda7bb42013-06-17 17:49:38 -0700221 ip_tunnel_rcv(tunnel, skb, tpi, log_ecn_error);
222 return PACKET_RCVD;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223 }
Pravin B Shelarbda7bb42013-06-17 17:49:38 -0700224 return PACKET_REJECT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225}
226
Pravin B Shelarc5441932013-03-25 14:49:35 +0000227static void __gre_xmit(struct sk_buff *skb, struct net_device *dev,
228 const struct iphdr *tnl_params,
229 __be16 proto)
230{
231 struct ip_tunnel *tunnel = netdev_priv(dev);
232 struct tnl_ptk_info tpi;
233
Pravin B Shelarc5441932013-03-25 14:49:35 +0000234 tpi.flags = tunnel->parms.o_flags;
235 tpi.proto = proto;
236 tpi.key = tunnel->parms.o_key;
237 if (tunnel->parms.o_flags & TUNNEL_SEQ)
238 tunnel->o_seqno++;
239 tpi.seq = htonl(tunnel->o_seqno);
Eric Dumazetcef401d2013-01-25 20:34:37 +0000240
Pravin B Shelarc5441932013-03-25 14:49:35 +0000241 /* Push GRE header. */
Tom Herbert4565e992014-09-17 12:26:01 -0700242 gre_build_header(skb, &tpi, tunnel->tun_hlen);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243
Tom Herbert54bc9ba2014-09-29 20:22:32 -0700244 skb_set_inner_protocol(skb, tpi.proto);
245
Nicolas Dichtelbf3d6a82013-05-27 23:48:15 +0000246 ip_tunnel_xmit(skb, dev, tnl_params, tnl_params->protocol);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247}
248
Pravin B Shelarc5441932013-03-25 14:49:35 +0000249static netdev_tx_t ipgre_xmit(struct sk_buff *skb,
250 struct net_device *dev)
Michal Schmidtee34c1e2007-12-13 09:46:32 -0800251{
Pravin B Shelarc5441932013-03-25 14:49:35 +0000252 struct ip_tunnel *tunnel = netdev_priv(dev);
253 const struct iphdr *tnl_params;
Michal Schmidtee34c1e2007-12-13 09:46:32 -0800254
Pravin B Shelarc5441932013-03-25 14:49:35 +0000255 if (dev->header_ops) {
256 /* Need space for new headers */
257 if (skb_cow_head(skb, dev->needed_headroom -
Chen Gang2bac7cb2013-04-22 20:45:42 +0000258 (tunnel->hlen + sizeof(struct iphdr))))
Pravin B Shelarc5441932013-03-25 14:49:35 +0000259 goto free_skb;
Michal Schmidtee34c1e2007-12-13 09:46:32 -0800260
Pravin B Shelarc5441932013-03-25 14:49:35 +0000261 tnl_params = (const struct iphdr *)skb->data;
Eric Dumazete985aad2010-09-27 03:57:11 +0000262
Pravin B Shelarc5441932013-03-25 14:49:35 +0000263 /* Pull skb since ip_tunnel_xmit() needs skb->data pointing
264 * to gre header.
265 */
266 skb_pull(skb, tunnel->hlen + sizeof(struct iphdr));
Timo Teräs8a0033a2014-12-15 09:24:13 +0200267 skb_reset_mac_header(skb);
Pravin B Shelarc5441932013-03-25 14:49:35 +0000268 } else {
269 if (skb_cow_head(skb, dev->needed_headroom))
270 goto free_skb;
Herbert Xue1a80002008-10-09 12:00:17 -0700271
Pravin B Shelarc5441932013-03-25 14:49:35 +0000272 tnl_params = &tunnel->parms.iph;
Michal Schmidtee34c1e2007-12-13 09:46:32 -0800273 }
274
Timo Teräs8a0033a2014-12-15 09:24:13 +0200275 skb = gre_handle_offloads(skb, !!(tunnel->parms.o_flags&TUNNEL_CSUM));
276 if (IS_ERR(skb))
277 goto out;
278
Pravin B Shelarc5441932013-03-25 14:49:35 +0000279 __gre_xmit(skb, dev, tnl_params, skb->protocol);
Michal Schmidtee34c1e2007-12-13 09:46:32 -0800280
Pravin B Shelarc5441932013-03-25 14:49:35 +0000281 return NETDEV_TX_OK;
Michal Schmidtee34c1e2007-12-13 09:46:32 -0800282
Pravin B Shelarc5441932013-03-25 14:49:35 +0000283free_skb:
Eric Dumazet3acfa1e2014-01-18 18:27:49 -0800284 kfree_skb(skb);
Pravin B Shelarc5441932013-03-25 14:49:35 +0000285out:
286 dev->stats.tx_dropped++;
287 return NETDEV_TX_OK;
Michal Schmidtee34c1e2007-12-13 09:46:32 -0800288}
289
Pravin B Shelarc5441932013-03-25 14:49:35 +0000290static netdev_tx_t gre_tap_xmit(struct sk_buff *skb,
291 struct net_device *dev)
292{
293 struct ip_tunnel *tunnel = netdev_priv(dev);
294
Pravin B Shelar45f2e992013-06-17 17:49:51 -0700295 skb = gre_handle_offloads(skb, !!(tunnel->parms.o_flags&TUNNEL_CSUM));
Pravin B Shelarc5441932013-03-25 14:49:35 +0000296 if (IS_ERR(skb))
297 goto out;
298
299 if (skb_cow_head(skb, dev->needed_headroom))
300 goto free_skb;
301
302 __gre_xmit(skb, dev, &tunnel->parms.iph, htons(ETH_P_TEB));
303
304 return NETDEV_TX_OK;
305
306free_skb:
Eric Dumazet3acfa1e2014-01-18 18:27:49 -0800307 kfree_skb(skb);
Pravin B Shelarc5441932013-03-25 14:49:35 +0000308out:
309 dev->stats.tx_dropped++;
310 return NETDEV_TX_OK;
311}
312
313static int ipgre_tunnel_ioctl(struct net_device *dev,
314 struct ifreq *ifr, int cmd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315{
Tom Herbert4565e992014-09-17 12:26:01 -0700316 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317 struct ip_tunnel_parm p;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318
Pravin B Shelarc5441932013-03-25 14:49:35 +0000319 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
320 return -EFAULT;
Cong Wang6c734fb2013-06-29 12:02:59 +0800321 if (cmd == SIOCADDTUNNEL || cmd == SIOCCHGTUNNEL) {
322 if (p.iph.version != 4 || p.iph.protocol != IPPROTO_GRE ||
323 p.iph.ihl != 5 || (p.iph.frag_off&htons(~IP_DF)) ||
324 ((p.i_flags|p.o_flags)&(GRE_VERSION|GRE_ROUTING)))
325 return -EINVAL;
Pravin B Shelarc5441932013-03-25 14:49:35 +0000326 }
327 p.i_flags = gre_flags_to_tnl_flags(p.i_flags);
328 p.o_flags = gre_flags_to_tnl_flags(p.o_flags);
329
330 err = ip_tunnel_ioctl(dev, &p, cmd);
331 if (err)
332 return err;
333
334 p.i_flags = tnl_flags_to_gre_flags(p.i_flags);
335 p.o_flags = tnl_flags_to_gre_flags(p.o_flags);
336
337 if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p)))
338 return -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339 return 0;
340}
341
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342/* Nice toy. Unfortunately, useless in real life :-)
343 It allows to construct virtual multiprotocol broadcast "LAN"
344 over the Internet, provided multicast routing is tuned.
345
346
347 I have no idea was this bicycle invented before me,
348 so that I had to set ARPHRD_IPGRE to a random value.
349 I have an impression, that Cisco could make something similar,
350 but this feature is apparently missing in IOS<=11.2(8).
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900351
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352 I set up 10.66.66/24 and fec0:6666:6666::0/96 as virtual networks
353 with broadcast 224.66.66.66. If you have access to mbone, play with me :-)
354
355 ping -t 255 224.66.66.66
356
357 If nobody answers, mbone does not work.
358
359 ip tunnel add Universe mode gre remote 224.66.66.66 local <Your_real_addr> ttl 255
360 ip addr add 10.66.66.<somewhat>/24 dev Universe
361 ifconfig Universe up
362 ifconfig Universe add fe80::<Your_real_addr>/10
363 ifconfig Universe add fec0:6666:6666::<Your_real_addr>/96
364 ftp 10.66.66.66
365 ...
366 ftp fec0:6666:6666::193.233.7.65
367 ...
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368 */
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700369static int ipgre_header(struct sk_buff *skb, struct net_device *dev,
370 unsigned short type,
Eric Dumazet15078502010-09-15 11:07:53 +0000371 const void *daddr, const void *saddr, unsigned int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372{
Patrick McHardy2941a482006-01-08 22:05:26 -0800373 struct ip_tunnel *t = netdev_priv(dev);
Pravin B Shelarc5441932013-03-25 14:49:35 +0000374 struct iphdr *iph;
375 struct gre_base_hdr *greh;
376
377 iph = (struct iphdr *)skb_push(skb, t->hlen + sizeof(*iph));
378 greh = (struct gre_base_hdr *)(iph+1);
379 greh->flags = tnl_flags_to_gre_flags(t->parms.o_flags);
380 greh->protocol = htons(type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381
382 memcpy(iph, &t->parms.iph, sizeof(struct iphdr));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383
Pravin B Shelarc5441932013-03-25 14:49:35 +0000384 /* Set the source hardware address. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385 if (saddr)
386 memcpy(&iph->saddr, saddr, 4);
Timo Teräs6d55cb92010-03-03 04:01:13 +0000387 if (daddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388 memcpy(&iph->daddr, daddr, 4);
Timo Teräs6d55cb92010-03-03 04:01:13 +0000389 if (iph->daddr)
Timo Teräs77a482b2013-08-06 13:45:43 +0300390 return t->hlen + sizeof(*iph);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900391
Pravin B Shelarc5441932013-03-25 14:49:35 +0000392 return -(t->hlen + sizeof(*iph));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393}
394
Timo Teras6a5f44d2007-10-23 20:31:53 -0700395static int ipgre_header_parse(const struct sk_buff *skb, unsigned char *haddr)
396{
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000397 const struct iphdr *iph = (const struct iphdr *) skb_mac_header(skb);
Timo Teras6a5f44d2007-10-23 20:31:53 -0700398 memcpy(haddr, &iph->saddr, 4);
399 return 4;
400}
401
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700402static const struct header_ops ipgre_header_ops = {
403 .create = ipgre_header,
Timo Teras6a5f44d2007-10-23 20:31:53 -0700404 .parse = ipgre_header_parse,
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700405};
406
Timo Teras6a5f44d2007-10-23 20:31:53 -0700407#ifdef CONFIG_NET_IPGRE_BROADCAST
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408static int ipgre_open(struct net_device *dev)
409{
Patrick McHardy2941a482006-01-08 22:05:26 -0800410 struct ip_tunnel *t = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411
Joe Perchesf97c1e02007-12-16 13:45:43 -0800412 if (ipv4_is_multicast(t->parms.iph.daddr)) {
David S. Millercbb1e852011-05-04 12:33:34 -0700413 struct flowi4 fl4;
414 struct rtable *rt;
Eric Dumazete985aad2010-09-27 03:57:11 +0000415
Nicolas Dichtelb57708a2014-04-22 10:15:23 +0200416 rt = ip_route_output_gre(t->net, &fl4,
David S. Millercbb1e852011-05-04 12:33:34 -0700417 t->parms.iph.daddr,
418 t->parms.iph.saddr,
419 t->parms.o_key,
420 RT_TOS(t->parms.iph.tos),
421 t->parms.link);
David S. Millerb23dd4f2011-03-02 14:31:35 -0800422 if (IS_ERR(rt))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423 return -EADDRNOTAVAIL;
Changli Gaod8d1f302010-06-10 23:31:35 -0700424 dev = rt->dst.dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425 ip_rt_put(rt);
Herbert Xue5ed6392005-10-03 14:35:55 -0700426 if (__in_dev_get_rtnl(dev) == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427 return -EADDRNOTAVAIL;
428 t->mlink = dev->ifindex;
Herbert Xue5ed6392005-10-03 14:35:55 -0700429 ip_mc_inc_group(__in_dev_get_rtnl(dev), t->parms.iph.daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430 }
431 return 0;
432}
433
434static int ipgre_close(struct net_device *dev)
435{
Patrick McHardy2941a482006-01-08 22:05:26 -0800436 struct ip_tunnel *t = netdev_priv(dev);
Stephen Hemmingerb8c26a32008-11-20 20:34:29 -0800437
Joe Perchesf97c1e02007-12-16 13:45:43 -0800438 if (ipv4_is_multicast(t->parms.iph.daddr) && t->mlink) {
Denis V. Lunev7fee0ca2008-01-21 17:32:38 -0800439 struct in_device *in_dev;
Nicolas Dichtelb57708a2014-04-22 10:15:23 +0200440 in_dev = inetdev_by_index(t->net, t->mlink);
Eric Dumazet8723e1b2010-10-19 00:39:26 +0000441 if (in_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442 ip_mc_dec_group(in_dev, t->parms.iph.daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443 }
444 return 0;
445}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446#endif
447
Stephen Hemmingerb8c26a32008-11-20 20:34:29 -0800448static const struct net_device_ops ipgre_netdev_ops = {
449 .ndo_init = ipgre_tunnel_init,
Pravin B Shelarc5441932013-03-25 14:49:35 +0000450 .ndo_uninit = ip_tunnel_uninit,
Stephen Hemmingerb8c26a32008-11-20 20:34:29 -0800451#ifdef CONFIG_NET_IPGRE_BROADCAST
452 .ndo_open = ipgre_open,
453 .ndo_stop = ipgre_close,
454#endif
Pravin B Shelarc5441932013-03-25 14:49:35 +0000455 .ndo_start_xmit = ipgre_xmit,
Stephen Hemmingerb8c26a32008-11-20 20:34:29 -0800456 .ndo_do_ioctl = ipgre_tunnel_ioctl,
Pravin B Shelarc5441932013-03-25 14:49:35 +0000457 .ndo_change_mtu = ip_tunnel_change_mtu,
458 .ndo_get_stats64 = ip_tunnel_get_stats64,
Stephen Hemmingerb8c26a32008-11-20 20:34:29 -0800459};
460
Eric Dumazet6b78f162012-09-13 21:25:33 +0000461#define GRE_FEATURES (NETIF_F_SG | \
462 NETIF_F_FRAGLIST | \
463 NETIF_F_HIGHDMA | \
464 NETIF_F_HW_CSUM)
465
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466static void ipgre_tunnel_setup(struct net_device *dev)
467{
Stephen Hemmingerb8c26a32008-11-20 20:34:29 -0800468 dev->netdev_ops = &ipgre_netdev_ops;
Nicolas Dichtel5a455272014-04-11 15:51:18 +0200469 dev->type = ARPHRD_IPGRE;
Pravin B Shelarc5441932013-03-25 14:49:35 +0000470 ip_tunnel_setup(dev, ipgre_net_id);
471}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472
Pravin B Shelarc5441932013-03-25 14:49:35 +0000473static void __gre_tunnel_init(struct net_device *dev)
474{
475 struct ip_tunnel *tunnel;
Tom Herbert4565e992014-09-17 12:26:01 -0700476 int t_hlen;
Pravin B Shelarc5441932013-03-25 14:49:35 +0000477
478 tunnel = netdev_priv(dev);
Tom Herbert4565e992014-09-17 12:26:01 -0700479 tunnel->tun_hlen = ip_gre_calc_hlen(tunnel->parms.o_flags);
Pravin B Shelarc5441932013-03-25 14:49:35 +0000480 tunnel->parms.iph.protocol = IPPROTO_GRE;
481
Tom Herbert4565e992014-09-17 12:26:01 -0700482 tunnel->hlen = tunnel->tun_hlen + tunnel->encap_hlen;
483
484 t_hlen = tunnel->hlen + sizeof(struct iphdr);
485
486 dev->needed_headroom = LL_MAX_HEADER + t_hlen + 4;
487 dev->mtu = ETH_DATA_LEN - t_hlen - 4;
Eric Dumazet6b78f162012-09-13 21:25:33 +0000488
Nicolas Dichtelb57708a2014-04-22 10:15:23 +0200489 dev->features |= GRE_FEATURES;
Eric Dumazet6b78f162012-09-13 21:25:33 +0000490 dev->hw_features |= GRE_FEATURES;
Pravin B Shelarc5441932013-03-25 14:49:35 +0000491
492 if (!(tunnel->parms.o_flags & TUNNEL_SEQ)) {
493 /* TCP offload with GRE SEQ is not supported. */
494 dev->features |= NETIF_F_GSO_SOFTWARE;
495 dev->hw_features |= NETIF_F_GSO_SOFTWARE;
496 /* Can use a lockless transmit, unless we generate
497 * output sequences
498 */
499 dev->features |= NETIF_F_LLTX;
500 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501}
502
503static int ipgre_tunnel_init(struct net_device *dev)
504{
Pravin B Shelarc5441932013-03-25 14:49:35 +0000505 struct ip_tunnel *tunnel = netdev_priv(dev);
506 struct iphdr *iph = &tunnel->parms.iph;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507
Pravin B Shelarc5441932013-03-25 14:49:35 +0000508 __gre_tunnel_init(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509
Pravin B Shelarc5441932013-03-25 14:49:35 +0000510 memcpy(dev->dev_addr, &iph->saddr, 4);
511 memcpy(dev->broadcast, &iph->daddr, 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512
Pravin B Shelarc5441932013-03-25 14:49:35 +0000513 dev->flags = IFF_NOARP;
Eric Dumazet02875872014-10-05 18:38:35 -0700514 netif_keep_dst(dev);
Pravin B Shelarc5441932013-03-25 14:49:35 +0000515 dev->addr_len = 4;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517 if (iph->daddr) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518#ifdef CONFIG_NET_IPGRE_BROADCAST
Joe Perchesf97c1e02007-12-16 13:45:43 -0800519 if (ipv4_is_multicast(iph->daddr)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520 if (!iph->saddr)
521 return -EINVAL;
522 dev->flags = IFF_BROADCAST;
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700523 dev->header_ops = &ipgre_header_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524 }
525#endif
Michal Schmidtee34c1e2007-12-13 09:46:32 -0800526 } else
Timo Teras6a5f44d2007-10-23 20:31:53 -0700527 dev->header_ops = &ipgre_header_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528
Pravin B Shelarc5441932013-03-25 14:49:35 +0000529 return ip_tunnel_init(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530}
531
Pravin B Shelarbda7bb42013-06-17 17:49:38 -0700532static struct gre_cisco_protocol ipgre_protocol = {
533 .handler = ipgre_rcv,
534 .err_handler = ipgre_err,
535 .priority = 0,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536};
537
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +0000538static int __net_init ipgre_init_net(struct net *net)
Pavel Emelyanov59a4c752008-04-16 01:08:53 -0700539{
Pravin B Shelarc5441932013-03-25 14:49:35 +0000540 return ip_tunnel_init_net(net, ipgre_net_id, &ipgre_link_ops, NULL);
Pavel Emelyanov59a4c752008-04-16 01:08:53 -0700541}
542
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +0000543static void __net_exit ipgre_exit_net(struct net *net)
Pavel Emelyanov59a4c752008-04-16 01:08:53 -0700544{
Pravin B Shelarc5441932013-03-25 14:49:35 +0000545 struct ip_tunnel_net *itn = net_generic(net, ipgre_net_id);
Nicolas Dichtel6c742e72013-08-13 17:51:11 +0200546 ip_tunnel_delete_net(itn, &ipgre_link_ops);
Pavel Emelyanov59a4c752008-04-16 01:08:53 -0700547}
548
549static struct pernet_operations ipgre_net_ops = {
550 .init = ipgre_init_net,
551 .exit = ipgre_exit_net,
Eric W. Biedermancfb8fbf2009-11-29 15:46:13 +0000552 .id = &ipgre_net_id,
Pravin B Shelarc5441932013-03-25 14:49:35 +0000553 .size = sizeof(struct ip_tunnel_net),
Pavel Emelyanov59a4c752008-04-16 01:08:53 -0700554};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555
Herbert Xuc19e6542008-10-09 11:59:55 -0700556static int ipgre_tunnel_validate(struct nlattr *tb[], struct nlattr *data[])
557{
558 __be16 flags;
559
560 if (!data)
561 return 0;
562
563 flags = 0;
564 if (data[IFLA_GRE_IFLAGS])
565 flags |= nla_get_be16(data[IFLA_GRE_IFLAGS]);
566 if (data[IFLA_GRE_OFLAGS])
567 flags |= nla_get_be16(data[IFLA_GRE_OFLAGS]);
568 if (flags & (GRE_VERSION|GRE_ROUTING))
569 return -EINVAL;
570
571 return 0;
572}
573
Herbert Xue1a80002008-10-09 12:00:17 -0700574static int ipgre_tap_validate(struct nlattr *tb[], struct nlattr *data[])
575{
576 __be32 daddr;
577
578 if (tb[IFLA_ADDRESS]) {
579 if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
580 return -EINVAL;
581 if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
582 return -EADDRNOTAVAIL;
583 }
584
585 if (!data)
586 goto out;
587
588 if (data[IFLA_GRE_REMOTE]) {
589 memcpy(&daddr, nla_data(data[IFLA_GRE_REMOTE]), 4);
590 if (!daddr)
591 return -EINVAL;
592 }
593
594out:
595 return ipgre_tunnel_validate(tb, data);
596}
597
Pravin B Shelarc5441932013-03-25 14:49:35 +0000598static void ipgre_netlink_parms(struct nlattr *data[], struct nlattr *tb[],
599 struct ip_tunnel_parm *parms)
Herbert Xuc19e6542008-10-09 11:59:55 -0700600{
Herbert Xu7bb82d92008-10-11 12:20:15 -0700601 memset(parms, 0, sizeof(*parms));
Herbert Xuc19e6542008-10-09 11:59:55 -0700602
603 parms->iph.protocol = IPPROTO_GRE;
604
605 if (!data)
606 return;
607
608 if (data[IFLA_GRE_LINK])
609 parms->link = nla_get_u32(data[IFLA_GRE_LINK]);
610
611 if (data[IFLA_GRE_IFLAGS])
Pravin B Shelarc5441932013-03-25 14:49:35 +0000612 parms->i_flags = gre_flags_to_tnl_flags(nla_get_be16(data[IFLA_GRE_IFLAGS]));
Herbert Xuc19e6542008-10-09 11:59:55 -0700613
614 if (data[IFLA_GRE_OFLAGS])
Pravin B Shelarc5441932013-03-25 14:49:35 +0000615 parms->o_flags = gre_flags_to_tnl_flags(nla_get_be16(data[IFLA_GRE_OFLAGS]));
Herbert Xuc19e6542008-10-09 11:59:55 -0700616
617 if (data[IFLA_GRE_IKEY])
618 parms->i_key = nla_get_be32(data[IFLA_GRE_IKEY]);
619
620 if (data[IFLA_GRE_OKEY])
621 parms->o_key = nla_get_be32(data[IFLA_GRE_OKEY]);
622
623 if (data[IFLA_GRE_LOCAL])
Patrick McHardy4d74f8b2008-10-10 12:11:06 -0700624 parms->iph.saddr = nla_get_be32(data[IFLA_GRE_LOCAL]);
Herbert Xuc19e6542008-10-09 11:59:55 -0700625
626 if (data[IFLA_GRE_REMOTE])
Patrick McHardy4d74f8b2008-10-10 12:11:06 -0700627 parms->iph.daddr = nla_get_be32(data[IFLA_GRE_REMOTE]);
Herbert Xuc19e6542008-10-09 11:59:55 -0700628
629 if (data[IFLA_GRE_TTL])
630 parms->iph.ttl = nla_get_u8(data[IFLA_GRE_TTL]);
631
632 if (data[IFLA_GRE_TOS])
633 parms->iph.tos = nla_get_u8(data[IFLA_GRE_TOS]);
634
635 if (!data[IFLA_GRE_PMTUDISC] || nla_get_u8(data[IFLA_GRE_PMTUDISC]))
636 parms->iph.frag_off = htons(IP_DF);
637}
638
Tom Herbert4565e992014-09-17 12:26:01 -0700639/* This function returns true when ENCAP attributes are present in the nl msg */
640static bool ipgre_netlink_encap_parms(struct nlattr *data[],
641 struct ip_tunnel_encap *ipencap)
642{
643 bool ret = false;
644
645 memset(ipencap, 0, sizeof(*ipencap));
646
647 if (!data)
648 return ret;
649
650 if (data[IFLA_GRE_ENCAP_TYPE]) {
651 ret = true;
652 ipencap->type = nla_get_u16(data[IFLA_GRE_ENCAP_TYPE]);
653 }
654
655 if (data[IFLA_GRE_ENCAP_FLAGS]) {
656 ret = true;
657 ipencap->flags = nla_get_u16(data[IFLA_GRE_ENCAP_FLAGS]);
658 }
659
660 if (data[IFLA_GRE_ENCAP_SPORT]) {
661 ret = true;
Sabrina Dubroca3e97fa72015-02-06 17:22:22 +0100662 ipencap->sport = nla_get_be16(data[IFLA_GRE_ENCAP_SPORT]);
Tom Herbert4565e992014-09-17 12:26:01 -0700663 }
664
665 if (data[IFLA_GRE_ENCAP_DPORT]) {
666 ret = true;
Sabrina Dubroca3e97fa72015-02-06 17:22:22 +0100667 ipencap->dport = nla_get_be16(data[IFLA_GRE_ENCAP_DPORT]);
Tom Herbert4565e992014-09-17 12:26:01 -0700668 }
669
670 return ret;
671}
672
Pravin B Shelarc5441932013-03-25 14:49:35 +0000673static int gre_tap_init(struct net_device *dev)
Herbert Xue1a80002008-10-09 12:00:17 -0700674{
Pravin B Shelarc5441932013-03-25 14:49:35 +0000675 __gre_tunnel_init(dev);
stephen hemmingerbec94d4302014-12-27 10:01:42 -0800676 dev->priv_flags |= IFF_LIVE_ADDR_CHANGE;
Herbert Xue1a80002008-10-09 12:00:17 -0700677
Pravin B Shelarc5441932013-03-25 14:49:35 +0000678 return ip_tunnel_init(dev);
Herbert Xue1a80002008-10-09 12:00:17 -0700679}
680
Pravin B Shelarc5441932013-03-25 14:49:35 +0000681static const struct net_device_ops gre_tap_netdev_ops = {
682 .ndo_init = gre_tap_init,
683 .ndo_uninit = ip_tunnel_uninit,
684 .ndo_start_xmit = gre_tap_xmit,
Stephen Hemmingerb8c26a32008-11-20 20:34:29 -0800685 .ndo_set_mac_address = eth_mac_addr,
686 .ndo_validate_addr = eth_validate_addr,
Pravin B Shelarc5441932013-03-25 14:49:35 +0000687 .ndo_change_mtu = ip_tunnel_change_mtu,
688 .ndo_get_stats64 = ip_tunnel_get_stats64,
Stephen Hemmingerb8c26a32008-11-20 20:34:29 -0800689};
690
Herbert Xue1a80002008-10-09 12:00:17 -0700691static void ipgre_tap_setup(struct net_device *dev)
692{
Herbert Xue1a80002008-10-09 12:00:17 -0700693 ether_setup(dev);
Pravin B Shelarc5441932013-03-25 14:49:35 +0000694 dev->netdev_ops = &gre_tap_netdev_ops;
stephen hemmingerf8c1b7c2014-06-06 08:10:00 -0700695 dev->priv_flags |= IFF_LIVE_ADDR_CHANGE;
Pravin B Shelarc5441932013-03-25 14:49:35 +0000696 ip_tunnel_setup(dev, gre_tap_net_id);
Herbert Xue1a80002008-10-09 12:00:17 -0700697}
698
Pravin B Shelarc5441932013-03-25 14:49:35 +0000699static int ipgre_newlink(struct net *src_net, struct net_device *dev,
700 struct nlattr *tb[], struct nlattr *data[])
Herbert Xuc19e6542008-10-09 11:59:55 -0700701{
Pravin B Shelarc5441932013-03-25 14:49:35 +0000702 struct ip_tunnel_parm p;
Tom Herbert4565e992014-09-17 12:26:01 -0700703 struct ip_tunnel_encap ipencap;
704
705 if (ipgre_netlink_encap_parms(data, &ipencap)) {
706 struct ip_tunnel *t = netdev_priv(dev);
707 int err = ip_tunnel_encap_setup(t, &ipencap);
708
709 if (err < 0)
710 return err;
711 }
Herbert Xuc19e6542008-10-09 11:59:55 -0700712
Pravin B Shelarc5441932013-03-25 14:49:35 +0000713 ipgre_netlink_parms(data, tb, &p);
714 return ip_tunnel_newlink(dev, tb, &p);
Herbert Xuc19e6542008-10-09 11:59:55 -0700715}
716
717static int ipgre_changelink(struct net_device *dev, struct nlattr *tb[],
718 struct nlattr *data[])
719{
Herbert Xuc19e6542008-10-09 11:59:55 -0700720 struct ip_tunnel_parm p;
Tom Herbert4565e992014-09-17 12:26:01 -0700721 struct ip_tunnel_encap ipencap;
722
723 if (ipgre_netlink_encap_parms(data, &ipencap)) {
724 struct ip_tunnel *t = netdev_priv(dev);
725 int err = ip_tunnel_encap_setup(t, &ipencap);
726
727 if (err < 0)
728 return err;
729 }
Herbert Xuc19e6542008-10-09 11:59:55 -0700730
Pravin B Shelarc5441932013-03-25 14:49:35 +0000731 ipgre_netlink_parms(data, tb, &p);
732 return ip_tunnel_changelink(dev, tb, &p);
Herbert Xuc19e6542008-10-09 11:59:55 -0700733}
734
735static size_t ipgre_get_size(const struct net_device *dev)
736{
737 return
738 /* IFLA_GRE_LINK */
739 nla_total_size(4) +
740 /* IFLA_GRE_IFLAGS */
741 nla_total_size(2) +
742 /* IFLA_GRE_OFLAGS */
743 nla_total_size(2) +
744 /* IFLA_GRE_IKEY */
745 nla_total_size(4) +
746 /* IFLA_GRE_OKEY */
747 nla_total_size(4) +
748 /* IFLA_GRE_LOCAL */
749 nla_total_size(4) +
750 /* IFLA_GRE_REMOTE */
751 nla_total_size(4) +
752 /* IFLA_GRE_TTL */
753 nla_total_size(1) +
754 /* IFLA_GRE_TOS */
755 nla_total_size(1) +
756 /* IFLA_GRE_PMTUDISC */
757 nla_total_size(1) +
Tom Herbert4565e992014-09-17 12:26:01 -0700758 /* IFLA_GRE_ENCAP_TYPE */
759 nla_total_size(2) +
760 /* IFLA_GRE_ENCAP_FLAGS */
761 nla_total_size(2) +
762 /* IFLA_GRE_ENCAP_SPORT */
763 nla_total_size(2) +
764 /* IFLA_GRE_ENCAP_DPORT */
765 nla_total_size(2) +
Herbert Xuc19e6542008-10-09 11:59:55 -0700766 0;
767}
768
769static int ipgre_fill_info(struct sk_buff *skb, const struct net_device *dev)
770{
771 struct ip_tunnel *t = netdev_priv(dev);
772 struct ip_tunnel_parm *p = &t->parms;
773
David S. Millerf3756b72012-04-01 20:39:02 -0400774 if (nla_put_u32(skb, IFLA_GRE_LINK, p->link) ||
Pravin B Shelarc5441932013-03-25 14:49:35 +0000775 nla_put_be16(skb, IFLA_GRE_IFLAGS, tnl_flags_to_gre_flags(p->i_flags)) ||
776 nla_put_be16(skb, IFLA_GRE_OFLAGS, tnl_flags_to_gre_flags(p->o_flags)) ||
David S. Millerf3756b72012-04-01 20:39:02 -0400777 nla_put_be32(skb, IFLA_GRE_IKEY, p->i_key) ||
778 nla_put_be32(skb, IFLA_GRE_OKEY, p->o_key) ||
779 nla_put_be32(skb, IFLA_GRE_LOCAL, p->iph.saddr) ||
780 nla_put_be32(skb, IFLA_GRE_REMOTE, p->iph.daddr) ||
781 nla_put_u8(skb, IFLA_GRE_TTL, p->iph.ttl) ||
782 nla_put_u8(skb, IFLA_GRE_TOS, p->iph.tos) ||
783 nla_put_u8(skb, IFLA_GRE_PMTUDISC,
784 !!(p->iph.frag_off & htons(IP_DF))))
785 goto nla_put_failure;
Tom Herbert4565e992014-09-17 12:26:01 -0700786
787 if (nla_put_u16(skb, IFLA_GRE_ENCAP_TYPE,
788 t->encap.type) ||
Sabrina Dubroca3e97fa72015-02-06 17:22:22 +0100789 nla_put_be16(skb, IFLA_GRE_ENCAP_SPORT,
790 t->encap.sport) ||
791 nla_put_be16(skb, IFLA_GRE_ENCAP_DPORT,
792 t->encap.dport) ||
Tom Herbert4565e992014-09-17 12:26:01 -0700793 nla_put_u16(skb, IFLA_GRE_ENCAP_FLAGS,
Tom Herberte1b2cb62014-11-05 16:49:38 -0800794 t->encap.flags))
Tom Herbert4565e992014-09-17 12:26:01 -0700795 goto nla_put_failure;
796
Herbert Xuc19e6542008-10-09 11:59:55 -0700797 return 0;
798
799nla_put_failure:
800 return -EMSGSIZE;
801}
802
803static const struct nla_policy ipgre_policy[IFLA_GRE_MAX + 1] = {
804 [IFLA_GRE_LINK] = { .type = NLA_U32 },
805 [IFLA_GRE_IFLAGS] = { .type = NLA_U16 },
806 [IFLA_GRE_OFLAGS] = { .type = NLA_U16 },
807 [IFLA_GRE_IKEY] = { .type = NLA_U32 },
808 [IFLA_GRE_OKEY] = { .type = NLA_U32 },
Patrick McHardy4d74f8b2008-10-10 12:11:06 -0700809 [IFLA_GRE_LOCAL] = { .len = FIELD_SIZEOF(struct iphdr, saddr) },
810 [IFLA_GRE_REMOTE] = { .len = FIELD_SIZEOF(struct iphdr, daddr) },
Herbert Xuc19e6542008-10-09 11:59:55 -0700811 [IFLA_GRE_TTL] = { .type = NLA_U8 },
812 [IFLA_GRE_TOS] = { .type = NLA_U8 },
813 [IFLA_GRE_PMTUDISC] = { .type = NLA_U8 },
Tom Herbert4565e992014-09-17 12:26:01 -0700814 [IFLA_GRE_ENCAP_TYPE] = { .type = NLA_U16 },
815 [IFLA_GRE_ENCAP_FLAGS] = { .type = NLA_U16 },
816 [IFLA_GRE_ENCAP_SPORT] = { .type = NLA_U16 },
817 [IFLA_GRE_ENCAP_DPORT] = { .type = NLA_U16 },
Herbert Xuc19e6542008-10-09 11:59:55 -0700818};
819
820static struct rtnl_link_ops ipgre_link_ops __read_mostly = {
821 .kind = "gre",
822 .maxtype = IFLA_GRE_MAX,
823 .policy = ipgre_policy,
824 .priv_size = sizeof(struct ip_tunnel),
825 .setup = ipgre_tunnel_setup,
826 .validate = ipgre_tunnel_validate,
827 .newlink = ipgre_newlink,
828 .changelink = ipgre_changelink,
Pravin B Shelarc5441932013-03-25 14:49:35 +0000829 .dellink = ip_tunnel_dellink,
Herbert Xuc19e6542008-10-09 11:59:55 -0700830 .get_size = ipgre_get_size,
831 .fill_info = ipgre_fill_info,
Nicolas Dichtel1728d4f2015-01-15 15:11:17 +0100832 .get_link_net = ip_tunnel_get_link_net,
Herbert Xuc19e6542008-10-09 11:59:55 -0700833};
834
Herbert Xue1a80002008-10-09 12:00:17 -0700835static struct rtnl_link_ops ipgre_tap_ops __read_mostly = {
836 .kind = "gretap",
837 .maxtype = IFLA_GRE_MAX,
838 .policy = ipgre_policy,
839 .priv_size = sizeof(struct ip_tunnel),
840 .setup = ipgre_tap_setup,
841 .validate = ipgre_tap_validate,
842 .newlink = ipgre_newlink,
843 .changelink = ipgre_changelink,
Pravin B Shelarc5441932013-03-25 14:49:35 +0000844 .dellink = ip_tunnel_dellink,
Herbert Xue1a80002008-10-09 12:00:17 -0700845 .get_size = ipgre_get_size,
846 .fill_info = ipgre_fill_info,
Nicolas Dichtel1728d4f2015-01-15 15:11:17 +0100847 .get_link_net = ip_tunnel_get_link_net,
Herbert Xue1a80002008-10-09 12:00:17 -0700848};
849
Pravin B Shelarc5441932013-03-25 14:49:35 +0000850static int __net_init ipgre_tap_init_net(struct net *net)
851{
852 return ip_tunnel_init_net(net, gre_tap_net_id, &ipgre_tap_ops, NULL);
853}
854
855static void __net_exit ipgre_tap_exit_net(struct net *net)
856{
857 struct ip_tunnel_net *itn = net_generic(net, gre_tap_net_id);
Nicolas Dichtel6c742e72013-08-13 17:51:11 +0200858 ip_tunnel_delete_net(itn, &ipgre_tap_ops);
Pravin B Shelarc5441932013-03-25 14:49:35 +0000859}
860
861static struct pernet_operations ipgre_tap_net_ops = {
862 .init = ipgre_tap_init_net,
863 .exit = ipgre_tap_exit_net,
864 .id = &gre_tap_net_id,
865 .size = sizeof(struct ip_tunnel_net),
866};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867
868static int __init ipgre_init(void)
869{
870 int err;
871
Joe Perches058bd4d2012-03-11 18:36:11 +0000872 pr_info("GRE over IPv4 tunneling driver\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700873
Eric W. Biedermancfb8fbf2009-11-29 15:46:13 +0000874 err = register_pernet_device(&ipgre_net_ops);
Pavel Emelyanov59a4c752008-04-16 01:08:53 -0700875 if (err < 0)
Alexey Dobriyanc2892f02010-02-16 07:57:44 +0000876 return err;
877
Pravin B Shelarc5441932013-03-25 14:49:35 +0000878 err = register_pernet_device(&ipgre_tap_net_ops);
879 if (err < 0)
880 goto pnet_tap_faied;
881
Pravin B Shelarbda7bb42013-06-17 17:49:38 -0700882 err = gre_cisco_register(&ipgre_protocol);
Alexey Dobriyanc2892f02010-02-16 07:57:44 +0000883 if (err < 0) {
Joe Perches058bd4d2012-03-11 18:36:11 +0000884 pr_info("%s: can't add protocol\n", __func__);
Alexey Dobriyanc2892f02010-02-16 07:57:44 +0000885 goto add_proto_failed;
886 }
Pavel Emelyanov7daa0002008-04-16 01:10:05 -0700887
Herbert Xuc19e6542008-10-09 11:59:55 -0700888 err = rtnl_link_register(&ipgre_link_ops);
889 if (err < 0)
890 goto rtnl_link_failed;
891
Herbert Xue1a80002008-10-09 12:00:17 -0700892 err = rtnl_link_register(&ipgre_tap_ops);
893 if (err < 0)
894 goto tap_ops_failed;
895
Pravin B Shelarc5441932013-03-25 14:49:35 +0000896 return 0;
Herbert Xuc19e6542008-10-09 11:59:55 -0700897
Herbert Xue1a80002008-10-09 12:00:17 -0700898tap_ops_failed:
899 rtnl_link_unregister(&ipgre_link_ops);
Herbert Xuc19e6542008-10-09 11:59:55 -0700900rtnl_link_failed:
Pravin B Shelarbda7bb42013-06-17 17:49:38 -0700901 gre_cisco_unregister(&ipgre_protocol);
Alexey Dobriyanc2892f02010-02-16 07:57:44 +0000902add_proto_failed:
Pravin B Shelarc5441932013-03-25 14:49:35 +0000903 unregister_pernet_device(&ipgre_tap_net_ops);
904pnet_tap_faied:
Alexey Dobriyanc2892f02010-02-16 07:57:44 +0000905 unregister_pernet_device(&ipgre_net_ops);
Pravin B Shelarc5441932013-03-25 14:49:35 +0000906 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700907}
908
Alexey Kuznetsovdb445752005-07-30 17:46:44 -0700909static void __exit ipgre_fini(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700910{
Herbert Xue1a80002008-10-09 12:00:17 -0700911 rtnl_link_unregister(&ipgre_tap_ops);
Herbert Xuc19e6542008-10-09 11:59:55 -0700912 rtnl_link_unregister(&ipgre_link_ops);
Pravin B Shelarbda7bb42013-06-17 17:49:38 -0700913 gre_cisco_unregister(&ipgre_protocol);
Pravin B Shelarc5441932013-03-25 14:49:35 +0000914 unregister_pernet_device(&ipgre_tap_net_ops);
Alexey Dobriyanc2892f02010-02-16 07:57:44 +0000915 unregister_pernet_device(&ipgre_net_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700916}
917
918module_init(ipgre_init);
919module_exit(ipgre_fini);
920MODULE_LICENSE("GPL");
Patrick McHardy4d74f8b2008-10-10 12:11:06 -0700921MODULE_ALIAS_RTNL_LINK("gre");
922MODULE_ALIAS_RTNL_LINK("gretap");
Vasiliy Kulikov8909c9a2011-03-02 00:33:13 +0300923MODULE_ALIAS_NETDEV("gre0");
Pravin B Shelarc5441932013-03-25 14:49:35 +0000924MODULE_ALIAS_NETDEV("gretap0");