blob: e7a92fdb36f61b779e04b1da45acf12312302c6b [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
Eric Dumazet96f5a842013-05-18 08:36:03 +0000181 iph = (const struct iphdr *)skb->data;
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. */
Pravin B Shelar752f36d2013-06-17 17:49:45 -0700242 gre_build_header(skb, &tpi, tunnel->hlen);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243
Nicolas Dichtelbf3d6a82013-05-27 23:48:15 +0000244 ip_tunnel_xmit(skb, dev, tnl_params, tnl_params->protocol);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245}
246
Pravin B Shelarc5441932013-03-25 14:49:35 +0000247static netdev_tx_t ipgre_xmit(struct sk_buff *skb,
248 struct net_device *dev)
Michal Schmidtee34c1e2007-12-13 09:46:32 -0800249{
Pravin B Shelarc5441932013-03-25 14:49:35 +0000250 struct ip_tunnel *tunnel = netdev_priv(dev);
251 const struct iphdr *tnl_params;
Michal Schmidtee34c1e2007-12-13 09:46:32 -0800252
Pravin B Shelar45f2e992013-06-17 17:49:51 -0700253 skb = gre_handle_offloads(skb, !!(tunnel->parms.o_flags&TUNNEL_CSUM));
Pravin B Shelarc5441932013-03-25 14:49:35 +0000254 if (IS_ERR(skb))
255 goto out;
Michal Schmidtee34c1e2007-12-13 09:46:32 -0800256
Pravin B Shelarc5441932013-03-25 14:49:35 +0000257 if (dev->header_ops) {
258 /* Need space for new headers */
259 if (skb_cow_head(skb, dev->needed_headroom -
Chen Gang2bac7cb2013-04-22 20:45:42 +0000260 (tunnel->hlen + sizeof(struct iphdr))))
Pravin B Shelarc5441932013-03-25 14:49:35 +0000261 goto free_skb;
Michal Schmidtee34c1e2007-12-13 09:46:32 -0800262
Pravin B Shelarc5441932013-03-25 14:49:35 +0000263 tnl_params = (const struct iphdr *)skb->data;
Eric Dumazete985aad2010-09-27 03:57:11 +0000264
Pravin B Shelarc5441932013-03-25 14:49:35 +0000265 /* Pull skb since ip_tunnel_xmit() needs skb->data pointing
266 * to gre header.
267 */
268 skb_pull(skb, tunnel->hlen + sizeof(struct iphdr));
269 } else {
270 if (skb_cow_head(skb, dev->needed_headroom))
271 goto free_skb;
Herbert Xue1a80002008-10-09 12:00:17 -0700272
Pravin B Shelarc5441932013-03-25 14:49:35 +0000273 tnl_params = &tunnel->parms.iph;
Michal Schmidtee34c1e2007-12-13 09:46:32 -0800274 }
275
Pravin B Shelarc5441932013-03-25 14:49:35 +0000276 __gre_xmit(skb, dev, tnl_params, skb->protocol);
Michal Schmidtee34c1e2007-12-13 09:46:32 -0800277
Pravin B Shelarc5441932013-03-25 14:49:35 +0000278 return NETDEV_TX_OK;
Michal Schmidtee34c1e2007-12-13 09:46:32 -0800279
Pravin B Shelarc5441932013-03-25 14:49:35 +0000280free_skb:
Eric Dumazet3acfa1e2014-01-18 18:27:49 -0800281 kfree_skb(skb);
Pravin B Shelarc5441932013-03-25 14:49:35 +0000282out:
283 dev->stats.tx_dropped++;
284 return NETDEV_TX_OK;
Michal Schmidtee34c1e2007-12-13 09:46:32 -0800285}
286
Pravin B Shelarc5441932013-03-25 14:49:35 +0000287static netdev_tx_t gre_tap_xmit(struct sk_buff *skb,
288 struct net_device *dev)
289{
290 struct ip_tunnel *tunnel = netdev_priv(dev);
291
Pravin B Shelar45f2e992013-06-17 17:49:51 -0700292 skb = gre_handle_offloads(skb, !!(tunnel->parms.o_flags&TUNNEL_CSUM));
Pravin B Shelarc5441932013-03-25 14:49:35 +0000293 if (IS_ERR(skb))
294 goto out;
295
296 if (skb_cow_head(skb, dev->needed_headroom))
297 goto free_skb;
298
299 __gre_xmit(skb, dev, &tunnel->parms.iph, htons(ETH_P_TEB));
300
301 return NETDEV_TX_OK;
302
303free_skb:
Eric Dumazet3acfa1e2014-01-18 18:27:49 -0800304 kfree_skb(skb);
Pravin B Shelarc5441932013-03-25 14:49:35 +0000305out:
306 dev->stats.tx_dropped++;
307 return NETDEV_TX_OK;
308}
309
310static int ipgre_tunnel_ioctl(struct net_device *dev,
311 struct ifreq *ifr, int cmd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312{
313 int err = 0;
314 struct ip_tunnel_parm p;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315
Pravin B Shelarc5441932013-03-25 14:49:35 +0000316 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
317 return -EFAULT;
Cong Wang6c734fb2013-06-29 12:02:59 +0800318 if (cmd == SIOCADDTUNNEL || cmd == SIOCCHGTUNNEL) {
319 if (p.iph.version != 4 || p.iph.protocol != IPPROTO_GRE ||
320 p.iph.ihl != 5 || (p.iph.frag_off&htons(~IP_DF)) ||
321 ((p.i_flags|p.o_flags)&(GRE_VERSION|GRE_ROUTING)))
322 return -EINVAL;
Pravin B Shelarc5441932013-03-25 14:49:35 +0000323 }
324 p.i_flags = gre_flags_to_tnl_flags(p.i_flags);
325 p.o_flags = gre_flags_to_tnl_flags(p.o_flags);
326
327 err = ip_tunnel_ioctl(dev, &p, cmd);
328 if (err)
329 return err;
330
331 p.i_flags = tnl_flags_to_gre_flags(p.i_flags);
332 p.o_flags = tnl_flags_to_gre_flags(p.o_flags);
333
334 if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p)))
335 return -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336 return 0;
337}
338
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339/* Nice toy. Unfortunately, useless in real life :-)
340 It allows to construct virtual multiprotocol broadcast "LAN"
341 over the Internet, provided multicast routing is tuned.
342
343
344 I have no idea was this bicycle invented before me,
345 so that I had to set ARPHRD_IPGRE to a random value.
346 I have an impression, that Cisco could make something similar,
347 but this feature is apparently missing in IOS<=11.2(8).
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900348
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349 I set up 10.66.66/24 and fec0:6666:6666::0/96 as virtual networks
350 with broadcast 224.66.66.66. If you have access to mbone, play with me :-)
351
352 ping -t 255 224.66.66.66
353
354 If nobody answers, mbone does not work.
355
356 ip tunnel add Universe mode gre remote 224.66.66.66 local <Your_real_addr> ttl 255
357 ip addr add 10.66.66.<somewhat>/24 dev Universe
358 ifconfig Universe up
359 ifconfig Universe add fe80::<Your_real_addr>/10
360 ifconfig Universe add fec0:6666:6666::<Your_real_addr>/96
361 ftp 10.66.66.66
362 ...
363 ftp fec0:6666:6666::193.233.7.65
364 ...
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365 */
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700366static int ipgre_header(struct sk_buff *skb, struct net_device *dev,
367 unsigned short type,
Eric Dumazet15078502010-09-15 11:07:53 +0000368 const void *daddr, const void *saddr, unsigned int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369{
Patrick McHardy2941a482006-01-08 22:05:26 -0800370 struct ip_tunnel *t = netdev_priv(dev);
Pravin B Shelarc5441932013-03-25 14:49:35 +0000371 struct iphdr *iph;
372 struct gre_base_hdr *greh;
373
374 iph = (struct iphdr *)skb_push(skb, t->hlen + sizeof(*iph));
375 greh = (struct gre_base_hdr *)(iph+1);
376 greh->flags = tnl_flags_to_gre_flags(t->parms.o_flags);
377 greh->protocol = htons(type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378
379 memcpy(iph, &t->parms.iph, sizeof(struct iphdr));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380
Pravin B Shelarc5441932013-03-25 14:49:35 +0000381 /* Set the source hardware address. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382 if (saddr)
383 memcpy(&iph->saddr, saddr, 4);
Timo Teräs6d55cb92010-03-03 04:01:13 +0000384 if (daddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385 memcpy(&iph->daddr, daddr, 4);
Timo Teräs6d55cb92010-03-03 04:01:13 +0000386 if (iph->daddr)
Timo Teräs77a482b2013-08-06 13:45:43 +0300387 return t->hlen + sizeof(*iph);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900388
Pravin B Shelarc5441932013-03-25 14:49:35 +0000389 return -(t->hlen + sizeof(*iph));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390}
391
Timo Teras6a5f44d2007-10-23 20:31:53 -0700392static int ipgre_header_parse(const struct sk_buff *skb, unsigned char *haddr)
393{
Eric Dumazetb71d1d42011-04-22 04:53:02 +0000394 const struct iphdr *iph = (const struct iphdr *) skb_mac_header(skb);
Timo Teras6a5f44d2007-10-23 20:31:53 -0700395 memcpy(haddr, &iph->saddr, 4);
396 return 4;
397}
398
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700399static const struct header_ops ipgre_header_ops = {
400 .create = ipgre_header,
Timo Teras6a5f44d2007-10-23 20:31:53 -0700401 .parse = ipgre_header_parse,
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700402};
403
Timo Teras6a5f44d2007-10-23 20:31:53 -0700404#ifdef CONFIG_NET_IPGRE_BROADCAST
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405static int ipgre_open(struct net_device *dev)
406{
Patrick McHardy2941a482006-01-08 22:05:26 -0800407 struct ip_tunnel *t = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408
Joe Perchesf97c1e02007-12-16 13:45:43 -0800409 if (ipv4_is_multicast(t->parms.iph.daddr)) {
David S. Millercbb1e852011-05-04 12:33:34 -0700410 struct flowi4 fl4;
411 struct rtable *rt;
Eric Dumazete985aad2010-09-27 03:57:11 +0000412
David S. Millercbb1e852011-05-04 12:33:34 -0700413 rt = ip_route_output_gre(dev_net(dev), &fl4,
414 t->parms.iph.daddr,
415 t->parms.iph.saddr,
416 t->parms.o_key,
417 RT_TOS(t->parms.iph.tos),
418 t->parms.link);
David S. Millerb23dd4f2011-03-02 14:31:35 -0800419 if (IS_ERR(rt))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420 return -EADDRNOTAVAIL;
Changli Gaod8d1f302010-06-10 23:31:35 -0700421 dev = rt->dst.dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422 ip_rt_put(rt);
Herbert Xue5ed6392005-10-03 14:35:55 -0700423 if (__in_dev_get_rtnl(dev) == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424 return -EADDRNOTAVAIL;
425 t->mlink = dev->ifindex;
Herbert Xue5ed6392005-10-03 14:35:55 -0700426 ip_mc_inc_group(__in_dev_get_rtnl(dev), t->parms.iph.daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427 }
428 return 0;
429}
430
431static int ipgre_close(struct net_device *dev)
432{
Patrick McHardy2941a482006-01-08 22:05:26 -0800433 struct ip_tunnel *t = netdev_priv(dev);
Stephen Hemmingerb8c26a32008-11-20 20:34:29 -0800434
Joe Perchesf97c1e02007-12-16 13:45:43 -0800435 if (ipv4_is_multicast(t->parms.iph.daddr) && t->mlink) {
Denis V. Lunev7fee0ca2008-01-21 17:32:38 -0800436 struct in_device *in_dev;
YOSHIFUJI Hideakic346dca2008-03-25 21:47:49 +0900437 in_dev = inetdev_by_index(dev_net(dev), t->mlink);
Eric Dumazet8723e1b2010-10-19 00:39:26 +0000438 if (in_dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439 ip_mc_dec_group(in_dev, t->parms.iph.daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440 }
441 return 0;
442}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443#endif
444
Stephen Hemmingerb8c26a32008-11-20 20:34:29 -0800445static const struct net_device_ops ipgre_netdev_ops = {
446 .ndo_init = ipgre_tunnel_init,
Pravin B Shelarc5441932013-03-25 14:49:35 +0000447 .ndo_uninit = ip_tunnel_uninit,
Stephen Hemmingerb8c26a32008-11-20 20:34:29 -0800448#ifdef CONFIG_NET_IPGRE_BROADCAST
449 .ndo_open = ipgre_open,
450 .ndo_stop = ipgre_close,
451#endif
Pravin B Shelarc5441932013-03-25 14:49:35 +0000452 .ndo_start_xmit = ipgre_xmit,
Stephen Hemmingerb8c26a32008-11-20 20:34:29 -0800453 .ndo_do_ioctl = ipgre_tunnel_ioctl,
Pravin B Shelarc5441932013-03-25 14:49:35 +0000454 .ndo_change_mtu = ip_tunnel_change_mtu,
455 .ndo_get_stats64 = ip_tunnel_get_stats64,
Stephen Hemmingerb8c26a32008-11-20 20:34:29 -0800456};
457
Eric Dumazet6b78f162012-09-13 21:25:33 +0000458#define GRE_FEATURES (NETIF_F_SG | \
459 NETIF_F_FRAGLIST | \
460 NETIF_F_HIGHDMA | \
461 NETIF_F_HW_CSUM)
462
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463static void ipgre_tunnel_setup(struct net_device *dev)
464{
Stephen Hemmingerb8c26a32008-11-20 20:34:29 -0800465 dev->netdev_ops = &ipgre_netdev_ops;
Pravin B Shelarc5441932013-03-25 14:49:35 +0000466 ip_tunnel_setup(dev, ipgre_net_id);
467}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468
Pravin B Shelarc5441932013-03-25 14:49:35 +0000469static void __gre_tunnel_init(struct net_device *dev)
470{
471 struct ip_tunnel *tunnel;
472
473 tunnel = netdev_priv(dev);
474 tunnel->hlen = ip_gre_calc_hlen(tunnel->parms.o_flags);
475 tunnel->parms.iph.protocol = IPPROTO_GRE;
476
477 dev->needed_headroom = LL_MAX_HEADER + sizeof(struct iphdr) + 4;
Kris Katterjohn46f25df2006-01-05 16:35:42 -0800478 dev->mtu = ETH_DATA_LEN - sizeof(struct iphdr) - 4;
Eric Dumazet6b78f162012-09-13 21:25:33 +0000479
Pravin B Shelarc5441932013-03-25 14:49:35 +0000480 dev->features |= NETIF_F_NETNS_LOCAL | GRE_FEATURES;
Eric Dumazet6b78f162012-09-13 21:25:33 +0000481 dev->hw_features |= GRE_FEATURES;
Pravin B Shelarc5441932013-03-25 14:49:35 +0000482
483 if (!(tunnel->parms.o_flags & TUNNEL_SEQ)) {
484 /* TCP offload with GRE SEQ is not supported. */
485 dev->features |= NETIF_F_GSO_SOFTWARE;
486 dev->hw_features |= NETIF_F_GSO_SOFTWARE;
487 /* Can use a lockless transmit, unless we generate
488 * output sequences
489 */
490 dev->features |= NETIF_F_LLTX;
491 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492}
493
494static int ipgre_tunnel_init(struct net_device *dev)
495{
Pravin B Shelarc5441932013-03-25 14:49:35 +0000496 struct ip_tunnel *tunnel = netdev_priv(dev);
497 struct iphdr *iph = &tunnel->parms.iph;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498
Pravin B Shelarc5441932013-03-25 14:49:35 +0000499 __gre_tunnel_init(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500
Pravin B Shelarc5441932013-03-25 14:49:35 +0000501 memcpy(dev->dev_addr, &iph->saddr, 4);
502 memcpy(dev->broadcast, &iph->daddr, 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503
Pravin B Shelarc5441932013-03-25 14:49:35 +0000504 dev->type = ARPHRD_IPGRE;
505 dev->flags = IFF_NOARP;
506 dev->priv_flags &= ~IFF_XMIT_DST_RELEASE;
507 dev->addr_len = 4;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509 if (iph->daddr) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510#ifdef CONFIG_NET_IPGRE_BROADCAST
Joe Perchesf97c1e02007-12-16 13:45:43 -0800511 if (ipv4_is_multicast(iph->daddr)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512 if (!iph->saddr)
513 return -EINVAL;
514 dev->flags = IFF_BROADCAST;
Stephen Hemminger3b04ddd2007-10-09 01:40:57 -0700515 dev->header_ops = &ipgre_header_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516 }
517#endif
Michal Schmidtee34c1e2007-12-13 09:46:32 -0800518 } else
Timo Teras6a5f44d2007-10-23 20:31:53 -0700519 dev->header_ops = &ipgre_header_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520
Pravin B Shelarc5441932013-03-25 14:49:35 +0000521 return ip_tunnel_init(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522}
523
Pravin B Shelarbda7bb42013-06-17 17:49:38 -0700524static struct gre_cisco_protocol ipgre_protocol = {
525 .handler = ipgre_rcv,
526 .err_handler = ipgre_err,
527 .priority = 0,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528};
529
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +0000530static int __net_init ipgre_init_net(struct net *net)
Pavel Emelyanov59a4c752008-04-16 01:08:53 -0700531{
Pravin B Shelarc5441932013-03-25 14:49:35 +0000532 return ip_tunnel_init_net(net, ipgre_net_id, &ipgre_link_ops, NULL);
Pavel Emelyanov59a4c752008-04-16 01:08:53 -0700533}
534
Alexey Dobriyan2c8c1e72010-01-17 03:35:32 +0000535static void __net_exit ipgre_exit_net(struct net *net)
Pavel Emelyanov59a4c752008-04-16 01:08:53 -0700536{
Pravin B Shelarc5441932013-03-25 14:49:35 +0000537 struct ip_tunnel_net *itn = net_generic(net, ipgre_net_id);
Nicolas Dichtel6c742e72013-08-13 17:51:11 +0200538 ip_tunnel_delete_net(itn, &ipgre_link_ops);
Pavel Emelyanov59a4c752008-04-16 01:08:53 -0700539}
540
541static struct pernet_operations ipgre_net_ops = {
542 .init = ipgre_init_net,
543 .exit = ipgre_exit_net,
Eric W. Biedermancfb8fbf2009-11-29 15:46:13 +0000544 .id = &ipgre_net_id,
Pravin B Shelarc5441932013-03-25 14:49:35 +0000545 .size = sizeof(struct ip_tunnel_net),
Pavel Emelyanov59a4c752008-04-16 01:08:53 -0700546};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547
Herbert Xuc19e6542008-10-09 11:59:55 -0700548static int ipgre_tunnel_validate(struct nlattr *tb[], struct nlattr *data[])
549{
550 __be16 flags;
551
552 if (!data)
553 return 0;
554
555 flags = 0;
556 if (data[IFLA_GRE_IFLAGS])
557 flags |= nla_get_be16(data[IFLA_GRE_IFLAGS]);
558 if (data[IFLA_GRE_OFLAGS])
559 flags |= nla_get_be16(data[IFLA_GRE_OFLAGS]);
560 if (flags & (GRE_VERSION|GRE_ROUTING))
561 return -EINVAL;
562
563 return 0;
564}
565
Herbert Xue1a80002008-10-09 12:00:17 -0700566static int ipgre_tap_validate(struct nlattr *tb[], struct nlattr *data[])
567{
568 __be32 daddr;
569
570 if (tb[IFLA_ADDRESS]) {
571 if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
572 return -EINVAL;
573 if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
574 return -EADDRNOTAVAIL;
575 }
576
577 if (!data)
578 goto out;
579
580 if (data[IFLA_GRE_REMOTE]) {
581 memcpy(&daddr, nla_data(data[IFLA_GRE_REMOTE]), 4);
582 if (!daddr)
583 return -EINVAL;
584 }
585
586out:
587 return ipgre_tunnel_validate(tb, data);
588}
589
Pravin B Shelarc5441932013-03-25 14:49:35 +0000590static void ipgre_netlink_parms(struct nlattr *data[], struct nlattr *tb[],
591 struct ip_tunnel_parm *parms)
Herbert Xuc19e6542008-10-09 11:59:55 -0700592{
Herbert Xu7bb82d92008-10-11 12:20:15 -0700593 memset(parms, 0, sizeof(*parms));
Herbert Xuc19e6542008-10-09 11:59:55 -0700594
595 parms->iph.protocol = IPPROTO_GRE;
596
597 if (!data)
598 return;
599
600 if (data[IFLA_GRE_LINK])
601 parms->link = nla_get_u32(data[IFLA_GRE_LINK]);
602
603 if (data[IFLA_GRE_IFLAGS])
Pravin B Shelarc5441932013-03-25 14:49:35 +0000604 parms->i_flags = gre_flags_to_tnl_flags(nla_get_be16(data[IFLA_GRE_IFLAGS]));
Herbert Xuc19e6542008-10-09 11:59:55 -0700605
606 if (data[IFLA_GRE_OFLAGS])
Pravin B Shelarc5441932013-03-25 14:49:35 +0000607 parms->o_flags = gre_flags_to_tnl_flags(nla_get_be16(data[IFLA_GRE_OFLAGS]));
Herbert Xuc19e6542008-10-09 11:59:55 -0700608
609 if (data[IFLA_GRE_IKEY])
610 parms->i_key = nla_get_be32(data[IFLA_GRE_IKEY]);
611
612 if (data[IFLA_GRE_OKEY])
613 parms->o_key = nla_get_be32(data[IFLA_GRE_OKEY]);
614
615 if (data[IFLA_GRE_LOCAL])
Patrick McHardy4d74f8b2008-10-10 12:11:06 -0700616 parms->iph.saddr = nla_get_be32(data[IFLA_GRE_LOCAL]);
Herbert Xuc19e6542008-10-09 11:59:55 -0700617
618 if (data[IFLA_GRE_REMOTE])
Patrick McHardy4d74f8b2008-10-10 12:11:06 -0700619 parms->iph.daddr = nla_get_be32(data[IFLA_GRE_REMOTE]);
Herbert Xuc19e6542008-10-09 11:59:55 -0700620
621 if (data[IFLA_GRE_TTL])
622 parms->iph.ttl = nla_get_u8(data[IFLA_GRE_TTL]);
623
624 if (data[IFLA_GRE_TOS])
625 parms->iph.tos = nla_get_u8(data[IFLA_GRE_TOS]);
626
627 if (!data[IFLA_GRE_PMTUDISC] || nla_get_u8(data[IFLA_GRE_PMTUDISC]))
628 parms->iph.frag_off = htons(IP_DF);
629}
630
Pravin B Shelarc5441932013-03-25 14:49:35 +0000631static int gre_tap_init(struct net_device *dev)
Herbert Xue1a80002008-10-09 12:00:17 -0700632{
Pravin B Shelarc5441932013-03-25 14:49:35 +0000633 __gre_tunnel_init(dev);
Herbert Xue1a80002008-10-09 12:00:17 -0700634
Pravin B Shelarc5441932013-03-25 14:49:35 +0000635 return ip_tunnel_init(dev);
Herbert Xue1a80002008-10-09 12:00:17 -0700636}
637
Pravin B Shelarc5441932013-03-25 14:49:35 +0000638static const struct net_device_ops gre_tap_netdev_ops = {
639 .ndo_init = gre_tap_init,
640 .ndo_uninit = ip_tunnel_uninit,
641 .ndo_start_xmit = gre_tap_xmit,
Stephen Hemmingerb8c26a32008-11-20 20:34:29 -0800642 .ndo_set_mac_address = eth_mac_addr,
643 .ndo_validate_addr = eth_validate_addr,
Pravin B Shelarc5441932013-03-25 14:49:35 +0000644 .ndo_change_mtu = ip_tunnel_change_mtu,
645 .ndo_get_stats64 = ip_tunnel_get_stats64,
Stephen Hemmingerb8c26a32008-11-20 20:34:29 -0800646};
647
Herbert Xue1a80002008-10-09 12:00:17 -0700648static void ipgre_tap_setup(struct net_device *dev)
649{
Herbert Xue1a80002008-10-09 12:00:17 -0700650 ether_setup(dev);
Pravin B Shelarc5441932013-03-25 14:49:35 +0000651 dev->netdev_ops = &gre_tap_netdev_ops;
652 ip_tunnel_setup(dev, gre_tap_net_id);
Herbert Xue1a80002008-10-09 12:00:17 -0700653}
654
Pravin B Shelarc5441932013-03-25 14:49:35 +0000655static int ipgre_newlink(struct net *src_net, struct net_device *dev,
656 struct nlattr *tb[], struct nlattr *data[])
Herbert Xuc19e6542008-10-09 11:59:55 -0700657{
Pravin B Shelarc5441932013-03-25 14:49:35 +0000658 struct ip_tunnel_parm p;
Herbert Xuc19e6542008-10-09 11:59:55 -0700659
Pravin B Shelarc5441932013-03-25 14:49:35 +0000660 ipgre_netlink_parms(data, tb, &p);
661 return ip_tunnel_newlink(dev, tb, &p);
Herbert Xuc19e6542008-10-09 11:59:55 -0700662}
663
664static int ipgre_changelink(struct net_device *dev, struct nlattr *tb[],
665 struct nlattr *data[])
666{
Herbert Xuc19e6542008-10-09 11:59:55 -0700667 struct ip_tunnel_parm p;
Herbert Xuc19e6542008-10-09 11:59:55 -0700668
Pravin B Shelarc5441932013-03-25 14:49:35 +0000669 ipgre_netlink_parms(data, tb, &p);
670 return ip_tunnel_changelink(dev, tb, &p);
Herbert Xuc19e6542008-10-09 11:59:55 -0700671}
672
673static size_t ipgre_get_size(const struct net_device *dev)
674{
675 return
676 /* IFLA_GRE_LINK */
677 nla_total_size(4) +
678 /* IFLA_GRE_IFLAGS */
679 nla_total_size(2) +
680 /* IFLA_GRE_OFLAGS */
681 nla_total_size(2) +
682 /* IFLA_GRE_IKEY */
683 nla_total_size(4) +
684 /* IFLA_GRE_OKEY */
685 nla_total_size(4) +
686 /* IFLA_GRE_LOCAL */
687 nla_total_size(4) +
688 /* IFLA_GRE_REMOTE */
689 nla_total_size(4) +
690 /* IFLA_GRE_TTL */
691 nla_total_size(1) +
692 /* IFLA_GRE_TOS */
693 nla_total_size(1) +
694 /* IFLA_GRE_PMTUDISC */
695 nla_total_size(1) +
696 0;
697}
698
699static int ipgre_fill_info(struct sk_buff *skb, const struct net_device *dev)
700{
701 struct ip_tunnel *t = netdev_priv(dev);
702 struct ip_tunnel_parm *p = &t->parms;
703
David S. Millerf3756b72012-04-01 20:39:02 -0400704 if (nla_put_u32(skb, IFLA_GRE_LINK, p->link) ||
Pravin B Shelarc5441932013-03-25 14:49:35 +0000705 nla_put_be16(skb, IFLA_GRE_IFLAGS, tnl_flags_to_gre_flags(p->i_flags)) ||
706 nla_put_be16(skb, IFLA_GRE_OFLAGS, tnl_flags_to_gre_flags(p->o_flags)) ||
David S. Millerf3756b72012-04-01 20:39:02 -0400707 nla_put_be32(skb, IFLA_GRE_IKEY, p->i_key) ||
708 nla_put_be32(skb, IFLA_GRE_OKEY, p->o_key) ||
709 nla_put_be32(skb, IFLA_GRE_LOCAL, p->iph.saddr) ||
710 nla_put_be32(skb, IFLA_GRE_REMOTE, p->iph.daddr) ||
711 nla_put_u8(skb, IFLA_GRE_TTL, p->iph.ttl) ||
712 nla_put_u8(skb, IFLA_GRE_TOS, p->iph.tos) ||
713 nla_put_u8(skb, IFLA_GRE_PMTUDISC,
714 !!(p->iph.frag_off & htons(IP_DF))))
715 goto nla_put_failure;
Herbert Xuc19e6542008-10-09 11:59:55 -0700716 return 0;
717
718nla_put_failure:
719 return -EMSGSIZE;
720}
721
722static const struct nla_policy ipgre_policy[IFLA_GRE_MAX + 1] = {
723 [IFLA_GRE_LINK] = { .type = NLA_U32 },
724 [IFLA_GRE_IFLAGS] = { .type = NLA_U16 },
725 [IFLA_GRE_OFLAGS] = { .type = NLA_U16 },
726 [IFLA_GRE_IKEY] = { .type = NLA_U32 },
727 [IFLA_GRE_OKEY] = { .type = NLA_U32 },
Patrick McHardy4d74f8b2008-10-10 12:11:06 -0700728 [IFLA_GRE_LOCAL] = { .len = FIELD_SIZEOF(struct iphdr, saddr) },
729 [IFLA_GRE_REMOTE] = { .len = FIELD_SIZEOF(struct iphdr, daddr) },
Herbert Xuc19e6542008-10-09 11:59:55 -0700730 [IFLA_GRE_TTL] = { .type = NLA_U8 },
731 [IFLA_GRE_TOS] = { .type = NLA_U8 },
732 [IFLA_GRE_PMTUDISC] = { .type = NLA_U8 },
733};
734
735static struct rtnl_link_ops ipgre_link_ops __read_mostly = {
736 .kind = "gre",
737 .maxtype = IFLA_GRE_MAX,
738 .policy = ipgre_policy,
739 .priv_size = sizeof(struct ip_tunnel),
740 .setup = ipgre_tunnel_setup,
741 .validate = ipgre_tunnel_validate,
742 .newlink = ipgre_newlink,
743 .changelink = ipgre_changelink,
Pravin B Shelarc5441932013-03-25 14:49:35 +0000744 .dellink = ip_tunnel_dellink,
Herbert Xuc19e6542008-10-09 11:59:55 -0700745 .get_size = ipgre_get_size,
746 .fill_info = ipgre_fill_info,
747};
748
Herbert Xue1a80002008-10-09 12:00:17 -0700749static struct rtnl_link_ops ipgre_tap_ops __read_mostly = {
750 .kind = "gretap",
751 .maxtype = IFLA_GRE_MAX,
752 .policy = ipgre_policy,
753 .priv_size = sizeof(struct ip_tunnel),
754 .setup = ipgre_tap_setup,
755 .validate = ipgre_tap_validate,
756 .newlink = ipgre_newlink,
757 .changelink = ipgre_changelink,
Pravin B Shelarc5441932013-03-25 14:49:35 +0000758 .dellink = ip_tunnel_dellink,
Herbert Xue1a80002008-10-09 12:00:17 -0700759 .get_size = ipgre_get_size,
760 .fill_info = ipgre_fill_info,
761};
762
Pravin B Shelarc5441932013-03-25 14:49:35 +0000763static int __net_init ipgre_tap_init_net(struct net *net)
764{
765 return ip_tunnel_init_net(net, gre_tap_net_id, &ipgre_tap_ops, NULL);
766}
767
768static void __net_exit ipgre_tap_exit_net(struct net *net)
769{
770 struct ip_tunnel_net *itn = net_generic(net, gre_tap_net_id);
Nicolas Dichtel6c742e72013-08-13 17:51:11 +0200771 ip_tunnel_delete_net(itn, &ipgre_tap_ops);
Pravin B Shelarc5441932013-03-25 14:49:35 +0000772}
773
774static struct pernet_operations ipgre_tap_net_ops = {
775 .init = ipgre_tap_init_net,
776 .exit = ipgre_tap_exit_net,
777 .id = &gre_tap_net_id,
778 .size = sizeof(struct ip_tunnel_net),
779};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700780
781static int __init ipgre_init(void)
782{
783 int err;
784
Joe Perches058bd4d2012-03-11 18:36:11 +0000785 pr_info("GRE over IPv4 tunneling driver\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700786
Eric W. Biedermancfb8fbf2009-11-29 15:46:13 +0000787 err = register_pernet_device(&ipgre_net_ops);
Pavel Emelyanov59a4c752008-04-16 01:08:53 -0700788 if (err < 0)
Alexey Dobriyanc2892f02010-02-16 07:57:44 +0000789 return err;
790
Pravin B Shelarc5441932013-03-25 14:49:35 +0000791 err = register_pernet_device(&ipgre_tap_net_ops);
792 if (err < 0)
793 goto pnet_tap_faied;
794
Pravin B Shelarbda7bb42013-06-17 17:49:38 -0700795 err = gre_cisco_register(&ipgre_protocol);
Alexey Dobriyanc2892f02010-02-16 07:57:44 +0000796 if (err < 0) {
Joe Perches058bd4d2012-03-11 18:36:11 +0000797 pr_info("%s: can't add protocol\n", __func__);
Alexey Dobriyanc2892f02010-02-16 07:57:44 +0000798 goto add_proto_failed;
799 }
Pavel Emelyanov7daa0002008-04-16 01:10:05 -0700800
Herbert Xuc19e6542008-10-09 11:59:55 -0700801 err = rtnl_link_register(&ipgre_link_ops);
802 if (err < 0)
803 goto rtnl_link_failed;
804
Herbert Xue1a80002008-10-09 12:00:17 -0700805 err = rtnl_link_register(&ipgre_tap_ops);
806 if (err < 0)
807 goto tap_ops_failed;
808
Pravin B Shelarc5441932013-03-25 14:49:35 +0000809 return 0;
Herbert Xuc19e6542008-10-09 11:59:55 -0700810
Herbert Xue1a80002008-10-09 12:00:17 -0700811tap_ops_failed:
812 rtnl_link_unregister(&ipgre_link_ops);
Herbert Xuc19e6542008-10-09 11:59:55 -0700813rtnl_link_failed:
Pravin B Shelarbda7bb42013-06-17 17:49:38 -0700814 gre_cisco_unregister(&ipgre_protocol);
Alexey Dobriyanc2892f02010-02-16 07:57:44 +0000815add_proto_failed:
Pravin B Shelarc5441932013-03-25 14:49:35 +0000816 unregister_pernet_device(&ipgre_tap_net_ops);
817pnet_tap_faied:
Alexey Dobriyanc2892f02010-02-16 07:57:44 +0000818 unregister_pernet_device(&ipgre_net_ops);
Pravin B Shelarc5441932013-03-25 14:49:35 +0000819 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700820}
821
Alexey Kuznetsovdb445752005-07-30 17:46:44 -0700822static void __exit ipgre_fini(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823{
Herbert Xue1a80002008-10-09 12:00:17 -0700824 rtnl_link_unregister(&ipgre_tap_ops);
Herbert Xuc19e6542008-10-09 11:59:55 -0700825 rtnl_link_unregister(&ipgre_link_ops);
Pravin B Shelarbda7bb42013-06-17 17:49:38 -0700826 gre_cisco_unregister(&ipgre_protocol);
Pravin B Shelarc5441932013-03-25 14:49:35 +0000827 unregister_pernet_device(&ipgre_tap_net_ops);
Alexey Dobriyanc2892f02010-02-16 07:57:44 +0000828 unregister_pernet_device(&ipgre_net_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829}
830
831module_init(ipgre_init);
832module_exit(ipgre_fini);
833MODULE_LICENSE("GPL");
Patrick McHardy4d74f8b2008-10-10 12:11:06 -0700834MODULE_ALIAS_RTNL_LINK("gre");
835MODULE_ALIAS_RTNL_LINK("gretap");
Vasiliy Kulikov8909c9a2011-03-02 00:33:13 +0300836MODULE_ALIAS_NETDEV("gre0");
Pravin B Shelarc5441932013-03-25 14:49:35 +0000837MODULE_ALIAS_NETDEV("gretap0");