1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  *	Linux NET3:	GRE over IP protocol decoder.
4  *
5  *	Authors: Alexey Kuznetsov (kuznet@ms2.inr.ac.ru)
6  */
7 
8 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
9 
10 #include <linux/capability.h>
11 #include <linux/module.h>
12 #include <linux/types.h>
13 #include <linux/kernel.h>
14 #include <linux/slab.h>
15 #include <linux/uaccess.h>
16 #include <linux/skbuff.h>
17 #include <linux/netdevice.h>
18 #include <linux/in.h>
19 #include <linux/tcp.h>
20 #include <linux/udp.h>
21 #include <linux/if_arp.h>
22 #include <linux/if_vlan.h>
23 #include <linux/init.h>
24 #include <linux/in6.h>
25 #include <linux/inetdevice.h>
26 #include <linux/igmp.h>
27 #include <linux/netfilter_ipv4.h>
28 #include <linux/etherdevice.h>
29 #include <linux/if_ether.h>
30 
31 #include <net/sock.h>
32 #include <net/ip.h>
33 #include <net/icmp.h>
34 #include <net/protocol.h>
35 #include <net/ip_tunnels.h>
36 #include <net/arp.h>
37 #include <net/checksum.h>
38 #include <net/dsfield.h>
39 #include <net/inet_ecn.h>
40 #include <net/xfrm.h>
41 #include <net/net_namespace.h>
42 #include <net/netns/generic.h>
43 #include <net/rtnetlink.h>
44 #include <net/gre.h>
45 #include <net/dst_metadata.h>
46 #include <net/erspan.h>
47 
48 /*
49    Problems & solutions
50    --------------------
51 
52    1. The most important issue is detecting local dead loops.
53    They would cause complete host lockup in transmit, which
54    would be "resolved" by stack overflow or, if queueing is enabled,
55    with infinite looping in net_bh.
56 
57    We cannot track such dead loops during route installation,
58    it is infeasible task. The most general solutions would be
59    to keep skb->encapsulation counter (sort of local ttl),
60    and silently drop packet when it expires. It is a good
61    solution, but it supposes maintaining new variable in ALL
62    skb, even if no tunneling is used.
63 
64    Current solution: xmit_recursion breaks dead loops. This is a percpu
65    counter, since when we enter the first ndo_xmit(), cpu migration is
66    forbidden. We force an exit if this counter reaches RECURSION_LIMIT
67 
68    2. Networking dead loops would not kill routers, but would really
69    kill network. IP hop limit plays role of "t->recursion" in this case,
70    if we copy it from packet being encapsulated to upper header.
71    It is very good solution, but it introduces two problems:
72 
73    - Routing protocols, using packets with ttl=1 (OSPF, RIP2),
74      do not work over tunnels.
75    - traceroute does not work. I planned to relay ICMP from tunnel,
76      so that this problem would be solved and traceroute output
77      would even more informative. This idea appeared to be wrong:
78      only Linux complies to rfc1812 now (yes, guys, Linux is the only
79      true router now :-)), all routers (at least, in neighbourhood of mine)
80      return only 8 bytes of payload. It is the end.
81 
82    Hence, if we want that OSPF worked or traceroute said something reasonable,
83    we should search for another solution.
84 
85    One of them is to parse packet trying to detect inner encapsulation
86    made by our node. It is difficult or even impossible, especially,
87    taking into account fragmentation. TO be short, ttl is not solution at all.
88 
89    Current solution: The solution was UNEXPECTEDLY SIMPLE.
90    We force DF flag on tunnels with preconfigured hop limit,
91    that is ALL. :-) Well, it does not remove the problem completely,
92    but exponential growth of network traffic is changed to linear
93    (branches, that exceed pmtu are pruned) and tunnel mtu
94    rapidly degrades to value <68, where looping stops.
95    Yes, it is not good if there exists a router in the loop,
96    which does not force DF, even when encapsulating packets have DF set.
97    But it is not our problem! Nobody could accuse us, we made
98    all that we could make. Even if it is your gated who injected
99    fatal route to network, even if it were you who configured
100    fatal static route: you are innocent. :-)
101 
102    Alexey Kuznetsov.
103  */
104 
105 static bool log_ecn_error = true;
106 module_param(log_ecn_error, bool, 0644);
107 MODULE_PARM_DESC(log_ecn_error, "Log packets received with corrupted ECN");
108 
109 static struct rtnl_link_ops ipgre_link_ops __read_mostly;
110 static const struct header_ops ipgre_header_ops;
111 
112 static int ipgre_tunnel_init(struct net_device *dev);
113 static void erspan_build_header(struct sk_buff *skb,
114 				u32 id, u32 index,
115 				bool truncate, bool is_ipv4);
116 
117 static unsigned int ipgre_net_id __read_mostly;
118 static unsigned int gre_tap_net_id __read_mostly;
119 static unsigned int erspan_net_id __read_mostly;
120 
ipgre_err(struct sk_buff * skb,u32 info,const struct tnl_ptk_info * tpi)121 static int ipgre_err(struct sk_buff *skb, u32 info,
122 		     const struct tnl_ptk_info *tpi)
123 {
124 
125 	/* All the routers (except for Linux) return only
126 	   8 bytes of packet payload. It means, that precise relaying of
127 	   ICMP in the real Internet is absolutely infeasible.
128 
129 	   Moreover, Cisco "wise men" put GRE key to the third word
130 	   in GRE header. It makes impossible maintaining even soft
131 	   state for keyed GRE tunnels with enabled checksum. Tell
132 	   them "thank you".
133 
134 	   Well, I wonder, rfc1812 was written by Cisco employee,
135 	   what the hell these idiots break standards established
136 	   by themselves???
137 	   */
138 	struct net *net = dev_net(skb->dev);
139 	struct ip_tunnel_net *itn;
140 	const struct iphdr *iph;
141 	const int type = icmp_hdr(skb)->type;
142 	const int code = icmp_hdr(skb)->code;
143 	unsigned int data_len = 0;
144 	struct ip_tunnel *t;
145 
146 	if (tpi->proto == htons(ETH_P_TEB))
147 		itn = net_generic(net, gre_tap_net_id);
148 	else if (tpi->proto == htons(ETH_P_ERSPAN) ||
149 		 tpi->proto == htons(ETH_P_ERSPAN2))
150 		itn = net_generic(net, erspan_net_id);
151 	else
152 		itn = net_generic(net, ipgre_net_id);
153 
154 	iph = (const struct iphdr *)(icmp_hdr(skb) + 1);
155 	t = ip_tunnel_lookup(itn, skb->dev->ifindex, tpi->flags,
156 			     iph->daddr, iph->saddr, tpi->key);
157 
158 	if (!t)
159 		return -ENOENT;
160 
161 	switch (type) {
162 	default:
163 	case ICMP_PARAMETERPROB:
164 		return 0;
165 
166 	case ICMP_DEST_UNREACH:
167 		switch (code) {
168 		case ICMP_SR_FAILED:
169 		case ICMP_PORT_UNREACH:
170 			/* Impossible event. */
171 			return 0;
172 		default:
173 			/* All others are translated to HOST_UNREACH.
174 			   rfc2003 contains "deep thoughts" about NET_UNREACH,
175 			   I believe they are just ether pollution. --ANK
176 			 */
177 			break;
178 		}
179 		break;
180 
181 	case ICMP_TIME_EXCEEDED:
182 		if (code != ICMP_EXC_TTL)
183 			return 0;
184 		data_len = icmp_hdr(skb)->un.reserved[1] * 4; /* RFC 4884 4.1 */
185 		break;
186 
187 	case ICMP_REDIRECT:
188 		break;
189 	}
190 
191 #if IS_ENABLED(CONFIG_IPV6)
192        if (tpi->proto == htons(ETH_P_IPV6) &&
193            !ip6_err_gen_icmpv6_unreach(skb, iph->ihl * 4 + tpi->hdr_len,
194 				       type, data_len))
195                return 0;
196 #endif
197 
198 	if (t->parms.iph.daddr == 0 ||
199 	    ipv4_is_multicast(t->parms.iph.daddr))
200 		return 0;
201 
202 	if (t->parms.iph.ttl == 0 && type == ICMP_TIME_EXCEEDED)
203 		return 0;
204 
205 	if (time_before(jiffies, t->err_time + IPTUNNEL_ERR_TIMEO))
206 		t->err_count++;
207 	else
208 		t->err_count = 1;
209 	t->err_time = jiffies;
210 
211 	return 0;
212 }
213 
gre_err(struct sk_buff * skb,u32 info)214 static void gre_err(struct sk_buff *skb, u32 info)
215 {
216 	/* All the routers (except for Linux) return only
217 	 * 8 bytes of packet payload. It means, that precise relaying of
218 	 * ICMP in the real Internet is absolutely infeasible.
219 	 *
220 	 * Moreover, Cisco "wise men" put GRE key to the third word
221 	 * in GRE header. It makes impossible maintaining even soft
222 	 * state for keyed
223 	 * GRE tunnels with enabled checksum. Tell them "thank you".
224 	 *
225 	 * Well, I wonder, rfc1812 was written by Cisco employee,
226 	 * what the hell these idiots break standards established
227 	 * by themselves???
228 	 */
229 
230 	const struct iphdr *iph = (struct iphdr *)skb->data;
231 	const int type = icmp_hdr(skb)->type;
232 	const int code = icmp_hdr(skb)->code;
233 	struct tnl_ptk_info tpi;
234 
235 	if (gre_parse_header(skb, &tpi, NULL, htons(ETH_P_IP),
236 			     iph->ihl * 4) < 0)
237 		return;
238 
239 	if (type == ICMP_DEST_UNREACH && code == ICMP_FRAG_NEEDED) {
240 		ipv4_update_pmtu(skb, dev_net(skb->dev), info,
241 				 skb->dev->ifindex, IPPROTO_GRE);
242 		return;
243 	}
244 	if (type == ICMP_REDIRECT) {
245 		ipv4_redirect(skb, dev_net(skb->dev), skb->dev->ifindex,
246 			      IPPROTO_GRE);
247 		return;
248 	}
249 
250 	ipgre_err(skb, info, &tpi);
251 }
252 
is_erspan_type1(int gre_hdr_len)253 static bool is_erspan_type1(int gre_hdr_len)
254 {
255 	/* Both ERSPAN type I (version 0) and type II (version 1) use
256 	 * protocol 0x88BE, but the type I has only 4-byte GRE header,
257 	 * while type II has 8-byte.
258 	 */
259 	return gre_hdr_len == 4;
260 }
261 
erspan_rcv(struct sk_buff * skb,struct tnl_ptk_info * tpi,int gre_hdr_len)262 static int erspan_rcv(struct sk_buff *skb, struct tnl_ptk_info *tpi,
263 		      int gre_hdr_len)
264 {
265 	struct net *net = dev_net(skb->dev);
266 	struct metadata_dst *tun_dst = NULL;
267 	struct erspan_base_hdr *ershdr;
268 	struct ip_tunnel_net *itn;
269 	struct ip_tunnel *tunnel;
270 	const struct iphdr *iph;
271 	struct erspan_md2 *md2;
272 	int ver;
273 	int len;
274 
275 	itn = net_generic(net, erspan_net_id);
276 	iph = ip_hdr(skb);
277 	if (is_erspan_type1(gre_hdr_len)) {
278 		ver = 0;
279 		tunnel = ip_tunnel_lookup(itn, skb->dev->ifindex,
280 					  tpi->flags | TUNNEL_NO_KEY,
281 					  iph->saddr, iph->daddr, 0);
282 	} else {
283 		ershdr = (struct erspan_base_hdr *)(skb->data + gre_hdr_len);
284 		ver = ershdr->ver;
285 		tunnel = ip_tunnel_lookup(itn, skb->dev->ifindex,
286 					  tpi->flags | TUNNEL_KEY,
287 					  iph->saddr, iph->daddr, tpi->key);
288 	}
289 
290 	if (tunnel) {
291 		if (is_erspan_type1(gre_hdr_len))
292 			len = gre_hdr_len;
293 		else
294 			len = gre_hdr_len + erspan_hdr_len(ver);
295 
296 		if (unlikely(!pskb_may_pull(skb, len)))
297 			return PACKET_REJECT;
298 
299 		if (__iptunnel_pull_header(skb,
300 					   len,
301 					   htons(ETH_P_TEB),
302 					   false, false) < 0)
303 			goto drop;
304 
305 		if (tunnel->collect_md) {
306 			struct erspan_metadata *pkt_md, *md;
307 			struct ip_tunnel_info *info;
308 			unsigned char *gh;
309 			__be64 tun_id;
310 			__be16 flags;
311 
312 			tpi->flags |= TUNNEL_KEY;
313 			flags = tpi->flags;
314 			tun_id = key32_to_tunnel_id(tpi->key);
315 
316 			tun_dst = ip_tun_rx_dst(skb, flags,
317 						tun_id, sizeof(*md));
318 			if (!tun_dst)
319 				return PACKET_REJECT;
320 
321 			/* skb can be uncloned in __iptunnel_pull_header, so
322 			 * old pkt_md is no longer valid and we need to reset
323 			 * it
324 			 */
325 			gh = skb_network_header(skb) +
326 			     skb_network_header_len(skb);
327 			pkt_md = (struct erspan_metadata *)(gh + gre_hdr_len +
328 							    sizeof(*ershdr));
329 			md = ip_tunnel_info_opts(&tun_dst->u.tun_info);
330 			md->version = ver;
331 			md2 = &md->u.md2;
332 			memcpy(md2, pkt_md, ver == 1 ? ERSPAN_V1_MDSIZE :
333 						       ERSPAN_V2_MDSIZE);
334 
335 			info = &tun_dst->u.tun_info;
336 			info->key.tun_flags |= TUNNEL_ERSPAN_OPT;
337 			info->options_len = sizeof(*md);
338 		}
339 
340 		skb_reset_mac_header(skb);
341 		ip_tunnel_rcv(tunnel, skb, tpi, tun_dst, log_ecn_error);
342 		return PACKET_RCVD;
343 	}
344 	return PACKET_REJECT;
345 
346 drop:
347 	kfree_skb(skb);
348 	return PACKET_RCVD;
349 }
350 
__ipgre_rcv(struct sk_buff * skb,const struct tnl_ptk_info * tpi,struct ip_tunnel_net * itn,int hdr_len,bool raw_proto)351 static int __ipgre_rcv(struct sk_buff *skb, const struct tnl_ptk_info *tpi,
352 		       struct ip_tunnel_net *itn, int hdr_len, bool raw_proto)
353 {
354 	struct metadata_dst *tun_dst = NULL;
355 	const struct iphdr *iph;
356 	struct ip_tunnel *tunnel;
357 
358 	iph = ip_hdr(skb);
359 	tunnel = ip_tunnel_lookup(itn, skb->dev->ifindex, tpi->flags,
360 				  iph->saddr, iph->daddr, tpi->key);
361 
362 	if (tunnel) {
363 		const struct iphdr *tnl_params;
364 
365 		if (__iptunnel_pull_header(skb, hdr_len, tpi->proto,
366 					   raw_proto, false) < 0)
367 			goto drop;
368 
369 		/* Special case for ipgre_header_parse(), which expects the
370 		 * mac_header to point to the outer IP header.
371 		 */
372 		if (tunnel->dev->header_ops == &ipgre_header_ops)
373 			skb_pop_mac_header(skb);
374 		else
375 			skb_reset_mac_header(skb);
376 
377 		tnl_params = &tunnel->parms.iph;
378 		if (tunnel->collect_md || tnl_params->daddr == 0) {
379 			__be16 flags;
380 			__be64 tun_id;
381 
382 			flags = tpi->flags & (TUNNEL_CSUM | TUNNEL_KEY);
383 			tun_id = key32_to_tunnel_id(tpi->key);
384 			tun_dst = ip_tun_rx_dst(skb, flags, tun_id, 0);
385 			if (!tun_dst)
386 				return PACKET_REJECT;
387 		}
388 
389 		ip_tunnel_rcv(tunnel, skb, tpi, tun_dst, log_ecn_error);
390 		return PACKET_RCVD;
391 	}
392 	return PACKET_NEXT;
393 
394 drop:
395 	kfree_skb(skb);
396 	return PACKET_RCVD;
397 }
398 
ipgre_rcv(struct sk_buff * skb,const struct tnl_ptk_info * tpi,int hdr_len)399 static int ipgre_rcv(struct sk_buff *skb, const struct tnl_ptk_info *tpi,
400 		     int hdr_len)
401 {
402 	struct net *net = dev_net(skb->dev);
403 	struct ip_tunnel_net *itn;
404 	int res;
405 
406 	if (tpi->proto == htons(ETH_P_TEB))
407 		itn = net_generic(net, gre_tap_net_id);
408 	else
409 		itn = net_generic(net, ipgre_net_id);
410 
411 	res = __ipgre_rcv(skb, tpi, itn, hdr_len, false);
412 	if (res == PACKET_NEXT && tpi->proto == htons(ETH_P_TEB)) {
413 		/* ipgre tunnels in collect metadata mode should receive
414 		 * also ETH_P_TEB traffic.
415 		 */
416 		itn = net_generic(net, ipgre_net_id);
417 		res = __ipgre_rcv(skb, tpi, itn, hdr_len, true);
418 	}
419 	return res;
420 }
421 
gre_rcv(struct sk_buff * skb)422 static int gre_rcv(struct sk_buff *skb)
423 {
424 	struct tnl_ptk_info tpi;
425 	bool csum_err = false;
426 	int hdr_len;
427 
428 #ifdef CONFIG_NET_IPGRE_BROADCAST
429 	if (ipv4_is_multicast(ip_hdr(skb)->daddr)) {
430 		/* Looped back packet, drop it! */
431 		if (rt_is_output_route(skb_rtable(skb)))
432 			goto drop;
433 	}
434 #endif
435 
436 	hdr_len = gre_parse_header(skb, &tpi, &csum_err, htons(ETH_P_IP), 0);
437 	if (hdr_len < 0)
438 		goto drop;
439 
440 	if (unlikely(tpi.proto == htons(ETH_P_ERSPAN) ||
441 		     tpi.proto == htons(ETH_P_ERSPAN2))) {
442 		if (erspan_rcv(skb, &tpi, hdr_len) == PACKET_RCVD)
443 			return 0;
444 		goto out;
445 	}
446 
447 	if (ipgre_rcv(skb, &tpi, hdr_len) == PACKET_RCVD)
448 		return 0;
449 
450 out:
451 	icmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, 0);
452 drop:
453 	kfree_skb(skb);
454 	return 0;
455 }
456 
__gre_xmit(struct sk_buff * skb,struct net_device * dev,const struct iphdr * tnl_params,__be16 proto)457 static void __gre_xmit(struct sk_buff *skb, struct net_device *dev,
458 		       const struct iphdr *tnl_params,
459 		       __be16 proto)
460 {
461 	struct ip_tunnel *tunnel = netdev_priv(dev);
462 	__be16 flags = tunnel->parms.o_flags;
463 
464 	/* Push GRE header. */
465 	gre_build_header(skb, tunnel->tun_hlen,
466 			 flags, proto, tunnel->parms.o_key,
467 			 (flags & TUNNEL_SEQ) ? htonl(atomic_fetch_inc(&tunnel->o_seqno)) : 0);
468 
469 	ip_tunnel_xmit(skb, dev, tnl_params, tnl_params->protocol);
470 }
471 
gre_handle_offloads(struct sk_buff * skb,bool csum)472 static int gre_handle_offloads(struct sk_buff *skb, bool csum)
473 {
474 	return iptunnel_handle_offloads(skb, csum ? SKB_GSO_GRE_CSUM : SKB_GSO_GRE);
475 }
476 
gre_fb_xmit(struct sk_buff * skb,struct net_device * dev,__be16 proto)477 static void gre_fb_xmit(struct sk_buff *skb, struct net_device *dev,
478 			__be16 proto)
479 {
480 	struct ip_tunnel *tunnel = netdev_priv(dev);
481 	struct ip_tunnel_info *tun_info;
482 	const struct ip_tunnel_key *key;
483 	int tunnel_hlen;
484 	__be16 flags;
485 
486 	tun_info = skb_tunnel_info(skb);
487 	if (unlikely(!tun_info || !(tun_info->mode & IP_TUNNEL_INFO_TX) ||
488 		     ip_tunnel_info_af(tun_info) != AF_INET))
489 		goto err_free_skb;
490 
491 	key = &tun_info->key;
492 	tunnel_hlen = gre_calc_hlen(key->tun_flags);
493 
494 	if (skb_cow_head(skb, dev->needed_headroom))
495 		goto err_free_skb;
496 
497 	/* Push Tunnel header. */
498 	if (gre_handle_offloads(skb, !!(tun_info->key.tun_flags & TUNNEL_CSUM)))
499 		goto err_free_skb;
500 
501 	flags = tun_info->key.tun_flags &
502 		(TUNNEL_CSUM | TUNNEL_KEY | TUNNEL_SEQ);
503 	gre_build_header(skb, tunnel_hlen, flags, proto,
504 			 tunnel_id_to_key32(tun_info->key.tun_id),
505 			 (flags & TUNNEL_SEQ) ? htonl(atomic_fetch_inc(&tunnel->o_seqno)) : 0);
506 
507 	ip_md_tunnel_xmit(skb, dev, IPPROTO_GRE, tunnel_hlen);
508 
509 	return;
510 
511 err_free_skb:
512 	kfree_skb(skb);
513 	dev->stats.tx_dropped++;
514 }
515 
erspan_fb_xmit(struct sk_buff * skb,struct net_device * dev)516 static void erspan_fb_xmit(struct sk_buff *skb, struct net_device *dev)
517 {
518 	struct ip_tunnel *tunnel = netdev_priv(dev);
519 	struct ip_tunnel_info *tun_info;
520 	const struct ip_tunnel_key *key;
521 	struct erspan_metadata *md;
522 	bool truncate = false;
523 	__be16 proto;
524 	int tunnel_hlen;
525 	int version;
526 	int nhoff;
527 
528 	tun_info = skb_tunnel_info(skb);
529 	if (unlikely(!tun_info || !(tun_info->mode & IP_TUNNEL_INFO_TX) ||
530 		     ip_tunnel_info_af(tun_info) != AF_INET))
531 		goto err_free_skb;
532 
533 	key = &tun_info->key;
534 	if (!(tun_info->key.tun_flags & TUNNEL_ERSPAN_OPT))
535 		goto err_free_skb;
536 	if (tun_info->options_len < sizeof(*md))
537 		goto err_free_skb;
538 	md = ip_tunnel_info_opts(tun_info);
539 
540 	/* ERSPAN has fixed 8 byte GRE header */
541 	version = md->version;
542 	tunnel_hlen = 8 + erspan_hdr_len(version);
543 
544 	if (skb_cow_head(skb, dev->needed_headroom))
545 		goto err_free_skb;
546 
547 	if (gre_handle_offloads(skb, false))
548 		goto err_free_skb;
549 
550 	if (skb->len > dev->mtu + dev->hard_header_len) {
551 		pskb_trim(skb, dev->mtu + dev->hard_header_len);
552 		truncate = true;
553 	}
554 
555 	nhoff = skb_network_header(skb) - skb_mac_header(skb);
556 	if (skb->protocol == htons(ETH_P_IP) &&
557 	    (ntohs(ip_hdr(skb)->tot_len) > skb->len - nhoff))
558 		truncate = true;
559 
560 	if (skb->protocol == htons(ETH_P_IPV6)) {
561 		int thoff;
562 
563 		if (skb_transport_header_was_set(skb))
564 			thoff = skb_transport_header(skb) - skb_mac_header(skb);
565 		else
566 			thoff = nhoff + sizeof(struct ipv6hdr);
567 		if (ntohs(ipv6_hdr(skb)->payload_len) > skb->len - thoff)
568 			truncate = true;
569 	}
570 
571 	if (version == 1) {
572 		erspan_build_header(skb, ntohl(tunnel_id_to_key32(key->tun_id)),
573 				    ntohl(md->u.index), truncate, true);
574 		proto = htons(ETH_P_ERSPAN);
575 	} else if (version == 2) {
576 		erspan_build_header_v2(skb,
577 				       ntohl(tunnel_id_to_key32(key->tun_id)),
578 				       md->u.md2.dir,
579 				       get_hwid(&md->u.md2),
580 				       truncate, true);
581 		proto = htons(ETH_P_ERSPAN2);
582 	} else {
583 		goto err_free_skb;
584 	}
585 
586 	gre_build_header(skb, 8, TUNNEL_SEQ,
587 			 proto, 0, htonl(atomic_fetch_inc(&tunnel->o_seqno)));
588 
589 	ip_md_tunnel_xmit(skb, dev, IPPROTO_GRE, tunnel_hlen);
590 
591 	return;
592 
593 err_free_skb:
594 	kfree_skb(skb);
595 	dev->stats.tx_dropped++;
596 }
597 
gre_fill_metadata_dst(struct net_device * dev,struct sk_buff * skb)598 static int gre_fill_metadata_dst(struct net_device *dev, struct sk_buff *skb)
599 {
600 	struct ip_tunnel_info *info = skb_tunnel_info(skb);
601 	const struct ip_tunnel_key *key;
602 	struct rtable *rt;
603 	struct flowi4 fl4;
604 
605 	if (ip_tunnel_info_af(info) != AF_INET)
606 		return -EINVAL;
607 
608 	key = &info->key;
609 	ip_tunnel_init_flow(&fl4, IPPROTO_GRE, key->u.ipv4.dst, key->u.ipv4.src,
610 			    tunnel_id_to_key32(key->tun_id),
611 			    key->tos & ~INET_ECN_MASK, dev_net(dev), 0,
612 			    skb->mark, skb_get_hash(skb), key->flow_flags);
613 	rt = ip_route_output_key(dev_net(dev), &fl4);
614 	if (IS_ERR(rt))
615 		return PTR_ERR(rt);
616 
617 	ip_rt_put(rt);
618 	info->key.u.ipv4.src = fl4.saddr;
619 	return 0;
620 }
621 
ipgre_xmit(struct sk_buff * skb,struct net_device * dev)622 static netdev_tx_t ipgre_xmit(struct sk_buff *skb,
623 			      struct net_device *dev)
624 {
625 	struct ip_tunnel *tunnel = netdev_priv(dev);
626 	const struct iphdr *tnl_params;
627 
628 	if (!pskb_inet_may_pull(skb))
629 		goto free_skb;
630 
631 	if (tunnel->collect_md) {
632 		gre_fb_xmit(skb, dev, skb->protocol);
633 		return NETDEV_TX_OK;
634 	}
635 
636 	if (dev->header_ops) {
637 		if (skb_cow_head(skb, 0))
638 			goto free_skb;
639 
640 		tnl_params = (const struct iphdr *)skb->data;
641 
642 		/* Pull skb since ip_tunnel_xmit() needs skb->data pointing
643 		 * to gre header.
644 		 */
645 		skb_pull(skb, tunnel->hlen + sizeof(struct iphdr));
646 		skb_reset_mac_header(skb);
647 
648 		if (skb->ip_summed == CHECKSUM_PARTIAL &&
649 		    skb_checksum_start(skb) < skb->data)
650 			goto free_skb;
651 	} else {
652 		if (skb_cow_head(skb, dev->needed_headroom))
653 			goto free_skb;
654 
655 		tnl_params = &tunnel->parms.iph;
656 	}
657 
658 	if (gre_handle_offloads(skb, !!(tunnel->parms.o_flags & TUNNEL_CSUM)))
659 		goto free_skb;
660 
661 	__gre_xmit(skb, dev, tnl_params, skb->protocol);
662 	return NETDEV_TX_OK;
663 
664 free_skb:
665 	kfree_skb(skb);
666 	dev->stats.tx_dropped++;
667 	return NETDEV_TX_OK;
668 }
669 
erspan_xmit(struct sk_buff * skb,struct net_device * dev)670 static netdev_tx_t erspan_xmit(struct sk_buff *skb,
671 			       struct net_device *dev)
672 {
673 	struct ip_tunnel *tunnel = netdev_priv(dev);
674 	bool truncate = false;
675 	__be16 proto;
676 
677 	if (!pskb_inet_may_pull(skb))
678 		goto free_skb;
679 
680 	if (tunnel->collect_md) {
681 		erspan_fb_xmit(skb, dev);
682 		return NETDEV_TX_OK;
683 	}
684 
685 	if (gre_handle_offloads(skb, false))
686 		goto free_skb;
687 
688 	if (skb_cow_head(skb, dev->needed_headroom))
689 		goto free_skb;
690 
691 	if (skb->len > dev->mtu + dev->hard_header_len) {
692 		pskb_trim(skb, dev->mtu + dev->hard_header_len);
693 		truncate = true;
694 	}
695 
696 	/* Push ERSPAN header */
697 	if (tunnel->erspan_ver == 0) {
698 		proto = htons(ETH_P_ERSPAN);
699 		tunnel->parms.o_flags &= ~TUNNEL_SEQ;
700 	} else if (tunnel->erspan_ver == 1) {
701 		erspan_build_header(skb, ntohl(tunnel->parms.o_key),
702 				    tunnel->index,
703 				    truncate, true);
704 		proto = htons(ETH_P_ERSPAN);
705 	} else if (tunnel->erspan_ver == 2) {
706 		erspan_build_header_v2(skb, ntohl(tunnel->parms.o_key),
707 				       tunnel->dir, tunnel->hwid,
708 				       truncate, true);
709 		proto = htons(ETH_P_ERSPAN2);
710 	} else {
711 		goto free_skb;
712 	}
713 
714 	tunnel->parms.o_flags &= ~TUNNEL_KEY;
715 	__gre_xmit(skb, dev, &tunnel->parms.iph, proto);
716 	return NETDEV_TX_OK;
717 
718 free_skb:
719 	kfree_skb(skb);
720 	dev->stats.tx_dropped++;
721 	return NETDEV_TX_OK;
722 }
723 
gre_tap_xmit(struct sk_buff * skb,struct net_device * dev)724 static netdev_tx_t gre_tap_xmit(struct sk_buff *skb,
725 				struct net_device *dev)
726 {
727 	struct ip_tunnel *tunnel = netdev_priv(dev);
728 
729 	if (!pskb_inet_may_pull(skb))
730 		goto free_skb;
731 
732 	if (tunnel->collect_md) {
733 		gre_fb_xmit(skb, dev, htons(ETH_P_TEB));
734 		return NETDEV_TX_OK;
735 	}
736 
737 	if (gre_handle_offloads(skb, !!(tunnel->parms.o_flags & TUNNEL_CSUM)))
738 		goto free_skb;
739 
740 	if (skb_cow_head(skb, dev->needed_headroom))
741 		goto free_skb;
742 
743 	__gre_xmit(skb, dev, &tunnel->parms.iph, htons(ETH_P_TEB));
744 	return NETDEV_TX_OK;
745 
746 free_skb:
747 	kfree_skb(skb);
748 	dev->stats.tx_dropped++;
749 	return NETDEV_TX_OK;
750 }
751 
ipgre_link_update(struct net_device * dev,bool set_mtu)752 static void ipgre_link_update(struct net_device *dev, bool set_mtu)
753 {
754 	struct ip_tunnel *tunnel = netdev_priv(dev);
755 	__be16 flags;
756 	int len;
757 
758 	len = tunnel->tun_hlen;
759 	tunnel->tun_hlen = gre_calc_hlen(tunnel->parms.o_flags);
760 	len = tunnel->tun_hlen - len;
761 	tunnel->hlen = tunnel->hlen + len;
762 
763 	if (dev->header_ops)
764 		dev->hard_header_len += len;
765 	else
766 		dev->needed_headroom += len;
767 
768 	if (set_mtu)
769 		dev->mtu = max_t(int, dev->mtu - len, 68);
770 
771 	flags = tunnel->parms.o_flags;
772 
773 	if (flags & TUNNEL_SEQ ||
774 	    (flags & TUNNEL_CSUM && tunnel->encap.type != TUNNEL_ENCAP_NONE)) {
775 		dev->features &= ~NETIF_F_GSO_SOFTWARE;
776 		dev->hw_features &= ~NETIF_F_GSO_SOFTWARE;
777 	} else {
778 		dev->features |= NETIF_F_GSO_SOFTWARE;
779 		dev->hw_features |= NETIF_F_GSO_SOFTWARE;
780 	}
781 }
782 
ipgre_tunnel_ctl(struct net_device * dev,struct ip_tunnel_parm * p,int cmd)783 static int ipgre_tunnel_ctl(struct net_device *dev, struct ip_tunnel_parm *p,
784 			    int cmd)
785 {
786 	int err;
787 
788 	if (cmd == SIOCADDTUNNEL || cmd == SIOCCHGTUNNEL) {
789 		if (p->iph.version != 4 || p->iph.protocol != IPPROTO_GRE ||
790 		    p->iph.ihl != 5 || (p->iph.frag_off & htons(~IP_DF)) ||
791 		    ((p->i_flags | p->o_flags) & (GRE_VERSION | GRE_ROUTING)))
792 			return -EINVAL;
793 	}
794 
795 	p->i_flags = gre_flags_to_tnl_flags(p->i_flags);
796 	p->o_flags = gre_flags_to_tnl_flags(p->o_flags);
797 
798 	err = ip_tunnel_ctl(dev, p, cmd);
799 	if (err)
800 		return err;
801 
802 	if (cmd == SIOCCHGTUNNEL) {
803 		struct ip_tunnel *t = netdev_priv(dev);
804 
805 		t->parms.i_flags = p->i_flags;
806 		t->parms.o_flags = p->o_flags;
807 
808 		if (strcmp(dev->rtnl_link_ops->kind, "erspan"))
809 			ipgre_link_update(dev, true);
810 	}
811 
812 	p->i_flags = gre_tnl_flags_to_gre_flags(p->i_flags);
813 	p->o_flags = gre_tnl_flags_to_gre_flags(p->o_flags);
814 	return 0;
815 }
816 
817 /* Nice toy. Unfortunately, useless in real life :-)
818    It allows to construct virtual multiprotocol broadcast "LAN"
819    over the Internet, provided multicast routing is tuned.
820 
821 
822    I have no idea was this bicycle invented before me,
823    so that I had to set ARPHRD_IPGRE to a random value.
824    I have an impression, that Cisco could make something similar,
825    but this feature is apparently missing in IOS<=11.2(8).
826 
827    I set up 10.66.66/24 and fec0:6666:6666::0/96 as virtual networks
828    with broadcast 224.66.66.66. If you have access to mbone, play with me :-)
829 
830    ping -t 255 224.66.66.66
831 
832    If nobody answers, mbone does not work.
833 
834    ip tunnel add Universe mode gre remote 224.66.66.66 local <Your_real_addr> ttl 255
835    ip addr add 10.66.66.<somewhat>/24 dev Universe
836    ifconfig Universe up
837    ifconfig Universe add fe80::<Your_real_addr>/10
838    ifconfig Universe add fec0:6666:6666::<Your_real_addr>/96
839    ftp 10.66.66.66
840    ...
841    ftp fec0:6666:6666::193.233.7.65
842    ...
843  */
ipgre_header(struct sk_buff * skb,struct net_device * dev,unsigned short type,const void * daddr,const void * saddr,unsigned int len)844 static int ipgre_header(struct sk_buff *skb, struct net_device *dev,
845 			unsigned short type,
846 			const void *daddr, const void *saddr, unsigned int len)
847 {
848 	struct ip_tunnel *t = netdev_priv(dev);
849 	struct iphdr *iph;
850 	struct gre_base_hdr *greh;
851 
852 	iph = skb_push(skb, t->hlen + sizeof(*iph));
853 	greh = (struct gre_base_hdr *)(iph+1);
854 	greh->flags = gre_tnl_flags_to_gre_flags(t->parms.o_flags);
855 	greh->protocol = htons(type);
856 
857 	memcpy(iph, &t->parms.iph, sizeof(struct iphdr));
858 
859 	/* Set the source hardware address. */
860 	if (saddr)
861 		memcpy(&iph->saddr, saddr, 4);
862 	if (daddr)
863 		memcpy(&iph->daddr, daddr, 4);
864 	if (iph->daddr)
865 		return t->hlen + sizeof(*iph);
866 
867 	return -(t->hlen + sizeof(*iph));
868 }
869 
ipgre_header_parse(const struct sk_buff * skb,unsigned char * haddr)870 static int ipgre_header_parse(const struct sk_buff *skb, unsigned char *haddr)
871 {
872 	const struct iphdr *iph = (const struct iphdr *) skb_mac_header(skb);
873 	memcpy(haddr, &iph->saddr, 4);
874 	return 4;
875 }
876 
877 static const struct header_ops ipgre_header_ops = {
878 	.create	= ipgre_header,
879 	.parse	= ipgre_header_parse,
880 };
881 
882 #ifdef CONFIG_NET_IPGRE_BROADCAST
ipgre_open(struct net_device * dev)883 static int ipgre_open(struct net_device *dev)
884 {
885 	struct ip_tunnel *t = netdev_priv(dev);
886 
887 	if (ipv4_is_multicast(t->parms.iph.daddr)) {
888 		struct flowi4 fl4;
889 		struct rtable *rt;
890 
891 		rt = ip_route_output_gre(t->net, &fl4,
892 					 t->parms.iph.daddr,
893 					 t->parms.iph.saddr,
894 					 t->parms.o_key,
895 					 RT_TOS(t->parms.iph.tos),
896 					 t->parms.link);
897 		if (IS_ERR(rt))
898 			return -EADDRNOTAVAIL;
899 		dev = rt->dst.dev;
900 		ip_rt_put(rt);
901 		if (!__in_dev_get_rtnl(dev))
902 			return -EADDRNOTAVAIL;
903 		t->mlink = dev->ifindex;
904 		ip_mc_inc_group(__in_dev_get_rtnl(dev), t->parms.iph.daddr);
905 	}
906 	return 0;
907 }
908 
ipgre_close(struct net_device * dev)909 static int ipgre_close(struct net_device *dev)
910 {
911 	struct ip_tunnel *t = netdev_priv(dev);
912 
913 	if (ipv4_is_multicast(t->parms.iph.daddr) && t->mlink) {
914 		struct in_device *in_dev;
915 		in_dev = inetdev_by_index(t->net, t->mlink);
916 		if (in_dev)
917 			ip_mc_dec_group(in_dev, t->parms.iph.daddr);
918 	}
919 	return 0;
920 }
921 #endif
922 
923 static const struct net_device_ops ipgre_netdev_ops = {
924 	.ndo_init		= ipgre_tunnel_init,
925 	.ndo_uninit		= ip_tunnel_uninit,
926 #ifdef CONFIG_NET_IPGRE_BROADCAST
927 	.ndo_open		= ipgre_open,
928 	.ndo_stop		= ipgre_close,
929 #endif
930 	.ndo_start_xmit		= ipgre_xmit,
931 	.ndo_siocdevprivate	= ip_tunnel_siocdevprivate,
932 	.ndo_change_mtu		= ip_tunnel_change_mtu,
933 	.ndo_get_stats64	= dev_get_tstats64,
934 	.ndo_get_iflink		= ip_tunnel_get_iflink,
935 	.ndo_tunnel_ctl		= ipgre_tunnel_ctl,
936 };
937 
938 #define GRE_FEATURES (NETIF_F_SG |		\
939 		      NETIF_F_FRAGLIST |	\
940 		      NETIF_F_HIGHDMA |		\
941 		      NETIF_F_HW_CSUM)
942 
ipgre_tunnel_setup(struct net_device * dev)943 static void ipgre_tunnel_setup(struct net_device *dev)
944 {
945 	dev->netdev_ops		= &ipgre_netdev_ops;
946 	dev->type		= ARPHRD_IPGRE;
947 	ip_tunnel_setup(dev, ipgre_net_id);
948 }
949 
__gre_tunnel_init(struct net_device * dev)950 static void __gre_tunnel_init(struct net_device *dev)
951 {
952 	struct ip_tunnel *tunnel;
953 	__be16 flags;
954 
955 	tunnel = netdev_priv(dev);
956 	tunnel->tun_hlen = gre_calc_hlen(tunnel->parms.o_flags);
957 	tunnel->parms.iph.protocol = IPPROTO_GRE;
958 
959 	tunnel->hlen = tunnel->tun_hlen + tunnel->encap_hlen;
960 	dev->needed_headroom = tunnel->hlen + sizeof(tunnel->parms.iph);
961 
962 	dev->features		|= GRE_FEATURES | NETIF_F_LLTX;
963 	dev->hw_features	|= GRE_FEATURES;
964 
965 	flags = tunnel->parms.o_flags;
966 
967 	/* TCP offload with GRE SEQ is not supported, nor can we support 2
968 	 * levels of outer headers requiring an update.
969 	 */
970 	if (flags & TUNNEL_SEQ)
971 		return;
972 	if (flags & TUNNEL_CSUM && tunnel->encap.type != TUNNEL_ENCAP_NONE)
973 		return;
974 
975 	dev->features |= NETIF_F_GSO_SOFTWARE;
976 	dev->hw_features |= NETIF_F_GSO_SOFTWARE;
977 }
978 
ipgre_tunnel_init(struct net_device * dev)979 static int ipgre_tunnel_init(struct net_device *dev)
980 {
981 	struct ip_tunnel *tunnel = netdev_priv(dev);
982 	struct iphdr *iph = &tunnel->parms.iph;
983 
984 	__gre_tunnel_init(dev);
985 
986 	__dev_addr_set(dev, &iph->saddr, 4);
987 	memcpy(dev->broadcast, &iph->daddr, 4);
988 
989 	dev->flags		= IFF_NOARP;
990 	netif_keep_dst(dev);
991 	dev->addr_len		= 4;
992 
993 	if (iph->daddr && !tunnel->collect_md) {
994 #ifdef CONFIG_NET_IPGRE_BROADCAST
995 		if (ipv4_is_multicast(iph->daddr)) {
996 			if (!iph->saddr)
997 				return -EINVAL;
998 			dev->flags = IFF_BROADCAST;
999 			dev->header_ops = &ipgre_header_ops;
1000 			dev->hard_header_len = tunnel->hlen + sizeof(*iph);
1001 			dev->needed_headroom = 0;
1002 		}
1003 #endif
1004 	} else if (!tunnel->collect_md) {
1005 		dev->header_ops = &ipgre_header_ops;
1006 		dev->hard_header_len = tunnel->hlen + sizeof(*iph);
1007 		dev->needed_headroom = 0;
1008 	}
1009 
1010 	return ip_tunnel_init(dev);
1011 }
1012 
1013 static const struct gre_protocol ipgre_protocol = {
1014 	.handler     = gre_rcv,
1015 	.err_handler = gre_err,
1016 };
1017 
ipgre_init_net(struct net * net)1018 static int __net_init ipgre_init_net(struct net *net)
1019 {
1020 	return ip_tunnel_init_net(net, ipgre_net_id, &ipgre_link_ops, NULL);
1021 }
1022 
ipgre_exit_batch_net(struct list_head * list_net)1023 static void __net_exit ipgre_exit_batch_net(struct list_head *list_net)
1024 {
1025 	ip_tunnel_delete_nets(list_net, ipgre_net_id, &ipgre_link_ops);
1026 }
1027 
1028 static struct pernet_operations ipgre_net_ops = {
1029 	.init = ipgre_init_net,
1030 	.exit_batch = ipgre_exit_batch_net,
1031 	.id   = &ipgre_net_id,
1032 	.size = sizeof(struct ip_tunnel_net),
1033 };
1034 
ipgre_tunnel_validate(struct nlattr * tb[],struct nlattr * data[],struct netlink_ext_ack * extack)1035 static int ipgre_tunnel_validate(struct nlattr *tb[], struct nlattr *data[],
1036 				 struct netlink_ext_ack *extack)
1037 {
1038 	__be16 flags;
1039 
1040 	if (!data)
1041 		return 0;
1042 
1043 	flags = 0;
1044 	if (data[IFLA_GRE_IFLAGS])
1045 		flags |= nla_get_be16(data[IFLA_GRE_IFLAGS]);
1046 	if (data[IFLA_GRE_OFLAGS])
1047 		flags |= nla_get_be16(data[IFLA_GRE_OFLAGS]);
1048 	if (flags & (GRE_VERSION|GRE_ROUTING))
1049 		return -EINVAL;
1050 
1051 	if (data[IFLA_GRE_COLLECT_METADATA] &&
1052 	    data[IFLA_GRE_ENCAP_TYPE] &&
1053 	    nla_get_u16(data[IFLA_GRE_ENCAP_TYPE]) != TUNNEL_ENCAP_NONE)
1054 		return -EINVAL;
1055 
1056 	return 0;
1057 }
1058 
ipgre_tap_validate(struct nlattr * tb[],struct nlattr * data[],struct netlink_ext_ack * extack)1059 static int ipgre_tap_validate(struct nlattr *tb[], struct nlattr *data[],
1060 			      struct netlink_ext_ack *extack)
1061 {
1062 	__be32 daddr;
1063 
1064 	if (tb[IFLA_ADDRESS]) {
1065 		if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
1066 			return -EINVAL;
1067 		if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
1068 			return -EADDRNOTAVAIL;
1069 	}
1070 
1071 	if (!data)
1072 		goto out;
1073 
1074 	if (data[IFLA_GRE_REMOTE]) {
1075 		memcpy(&daddr, nla_data(data[IFLA_GRE_REMOTE]), 4);
1076 		if (!daddr)
1077 			return -EINVAL;
1078 	}
1079 
1080 out:
1081 	return ipgre_tunnel_validate(tb, data, extack);
1082 }
1083 
erspan_validate(struct nlattr * tb[],struct nlattr * data[],struct netlink_ext_ack * extack)1084 static int erspan_validate(struct nlattr *tb[], struct nlattr *data[],
1085 			   struct netlink_ext_ack *extack)
1086 {
1087 	__be16 flags = 0;
1088 	int ret;
1089 
1090 	if (!data)
1091 		return 0;
1092 
1093 	ret = ipgre_tap_validate(tb, data, extack);
1094 	if (ret)
1095 		return ret;
1096 
1097 	if (data[IFLA_GRE_ERSPAN_VER] &&
1098 	    nla_get_u8(data[IFLA_GRE_ERSPAN_VER]) == 0)
1099 		return 0;
1100 
1101 	/* ERSPAN type II/III should only have GRE sequence and key flag */
1102 	if (data[IFLA_GRE_OFLAGS])
1103 		flags |= nla_get_be16(data[IFLA_GRE_OFLAGS]);
1104 	if (data[IFLA_GRE_IFLAGS])
1105 		flags |= nla_get_be16(data[IFLA_GRE_IFLAGS]);
1106 	if (!data[IFLA_GRE_COLLECT_METADATA] &&
1107 	    flags != (GRE_SEQ | GRE_KEY))
1108 		return -EINVAL;
1109 
1110 	/* ERSPAN Session ID only has 10-bit. Since we reuse
1111 	 * 32-bit key field as ID, check it's range.
1112 	 */
1113 	if (data[IFLA_GRE_IKEY] &&
1114 	    (ntohl(nla_get_be32(data[IFLA_GRE_IKEY])) & ~ID_MASK))
1115 		return -EINVAL;
1116 
1117 	if (data[IFLA_GRE_OKEY] &&
1118 	    (ntohl(nla_get_be32(data[IFLA_GRE_OKEY])) & ~ID_MASK))
1119 		return -EINVAL;
1120 
1121 	return 0;
1122 }
1123 
ipgre_netlink_parms(struct net_device * dev,struct nlattr * data[],struct nlattr * tb[],struct ip_tunnel_parm * parms,__u32 * fwmark)1124 static int ipgre_netlink_parms(struct net_device *dev,
1125 				struct nlattr *data[],
1126 				struct nlattr *tb[],
1127 				struct ip_tunnel_parm *parms,
1128 				__u32 *fwmark)
1129 {
1130 	struct ip_tunnel *t = netdev_priv(dev);
1131 
1132 	memset(parms, 0, sizeof(*parms));
1133 
1134 	parms->iph.protocol = IPPROTO_GRE;
1135 
1136 	if (!data)
1137 		return 0;
1138 
1139 	if (data[IFLA_GRE_LINK])
1140 		parms->link = nla_get_u32(data[IFLA_GRE_LINK]);
1141 
1142 	if (data[IFLA_GRE_IFLAGS])
1143 		parms->i_flags = gre_flags_to_tnl_flags(nla_get_be16(data[IFLA_GRE_IFLAGS]));
1144 
1145 	if (data[IFLA_GRE_OFLAGS])
1146 		parms->o_flags = gre_flags_to_tnl_flags(nla_get_be16(data[IFLA_GRE_OFLAGS]));
1147 
1148 	if (data[IFLA_GRE_IKEY])
1149 		parms->i_key = nla_get_be32(data[IFLA_GRE_IKEY]);
1150 
1151 	if (data[IFLA_GRE_OKEY])
1152 		parms->o_key = nla_get_be32(data[IFLA_GRE_OKEY]);
1153 
1154 	if (data[IFLA_GRE_LOCAL])
1155 		parms->iph.saddr = nla_get_in_addr(data[IFLA_GRE_LOCAL]);
1156 
1157 	if (data[IFLA_GRE_REMOTE])
1158 		parms->iph.daddr = nla_get_in_addr(data[IFLA_GRE_REMOTE]);
1159 
1160 	if (data[IFLA_GRE_TTL])
1161 		parms->iph.ttl = nla_get_u8(data[IFLA_GRE_TTL]);
1162 
1163 	if (data[IFLA_GRE_TOS])
1164 		parms->iph.tos = nla_get_u8(data[IFLA_GRE_TOS]);
1165 
1166 	if (!data[IFLA_GRE_PMTUDISC] || nla_get_u8(data[IFLA_GRE_PMTUDISC])) {
1167 		if (t->ignore_df)
1168 			return -EINVAL;
1169 		parms->iph.frag_off = htons(IP_DF);
1170 	}
1171 
1172 	if (data[IFLA_GRE_COLLECT_METADATA]) {
1173 		t->collect_md = true;
1174 		if (dev->type == ARPHRD_IPGRE)
1175 			dev->type = ARPHRD_NONE;
1176 	}
1177 
1178 	if (data[IFLA_GRE_IGNORE_DF]) {
1179 		if (nla_get_u8(data[IFLA_GRE_IGNORE_DF])
1180 		  && (parms->iph.frag_off & htons(IP_DF)))
1181 			return -EINVAL;
1182 		t->ignore_df = !!nla_get_u8(data[IFLA_GRE_IGNORE_DF]);
1183 	}
1184 
1185 	if (data[IFLA_GRE_FWMARK])
1186 		*fwmark = nla_get_u32(data[IFLA_GRE_FWMARK]);
1187 
1188 	return 0;
1189 }
1190 
erspan_netlink_parms(struct net_device * dev,struct nlattr * data[],struct nlattr * tb[],struct ip_tunnel_parm * parms,__u32 * fwmark)1191 static int erspan_netlink_parms(struct net_device *dev,
1192 				struct nlattr *data[],
1193 				struct nlattr *tb[],
1194 				struct ip_tunnel_parm *parms,
1195 				__u32 *fwmark)
1196 {
1197 	struct ip_tunnel *t = netdev_priv(dev);
1198 	int err;
1199 
1200 	err = ipgre_netlink_parms(dev, data, tb, parms, fwmark);
1201 	if (err)
1202 		return err;
1203 	if (!data)
1204 		return 0;
1205 
1206 	if (data[IFLA_GRE_ERSPAN_VER]) {
1207 		t->erspan_ver = nla_get_u8(data[IFLA_GRE_ERSPAN_VER]);
1208 
1209 		if (t->erspan_ver > 2)
1210 			return -EINVAL;
1211 	}
1212 
1213 	if (t->erspan_ver == 1) {
1214 		if (data[IFLA_GRE_ERSPAN_INDEX]) {
1215 			t->index = nla_get_u32(data[IFLA_GRE_ERSPAN_INDEX]);
1216 			if (t->index & ~INDEX_MASK)
1217 				return -EINVAL;
1218 		}
1219 	} else if (t->erspan_ver == 2) {
1220 		if (data[IFLA_GRE_ERSPAN_DIR]) {
1221 			t->dir = nla_get_u8(data[IFLA_GRE_ERSPAN_DIR]);
1222 			if (t->dir & ~(DIR_MASK >> DIR_OFFSET))
1223 				return -EINVAL;
1224 		}
1225 		if (data[IFLA_GRE_ERSPAN_HWID]) {
1226 			t->hwid = nla_get_u16(data[IFLA_GRE_ERSPAN_HWID]);
1227 			if (t->hwid & ~(HWID_MASK >> HWID_OFFSET))
1228 				return -EINVAL;
1229 		}
1230 	}
1231 
1232 	return 0;
1233 }
1234 
1235 /* This function returns true when ENCAP attributes are present in the nl msg */
ipgre_netlink_encap_parms(struct nlattr * data[],struct ip_tunnel_encap * ipencap)1236 static bool ipgre_netlink_encap_parms(struct nlattr *data[],
1237 				      struct ip_tunnel_encap *ipencap)
1238 {
1239 	bool ret = false;
1240 
1241 	memset(ipencap, 0, sizeof(*ipencap));
1242 
1243 	if (!data)
1244 		return ret;
1245 
1246 	if (data[IFLA_GRE_ENCAP_TYPE]) {
1247 		ret = true;
1248 		ipencap->type = nla_get_u16(data[IFLA_GRE_ENCAP_TYPE]);
1249 	}
1250 
1251 	if (data[IFLA_GRE_ENCAP_FLAGS]) {
1252 		ret = true;
1253 		ipencap->flags = nla_get_u16(data[IFLA_GRE_ENCAP_FLAGS]);
1254 	}
1255 
1256 	if (data[IFLA_GRE_ENCAP_SPORT]) {
1257 		ret = true;
1258 		ipencap->sport = nla_get_be16(data[IFLA_GRE_ENCAP_SPORT]);
1259 	}
1260 
1261 	if (data[IFLA_GRE_ENCAP_DPORT]) {
1262 		ret = true;
1263 		ipencap->dport = nla_get_be16(data[IFLA_GRE_ENCAP_DPORT]);
1264 	}
1265 
1266 	return ret;
1267 }
1268 
gre_tap_init(struct net_device * dev)1269 static int gre_tap_init(struct net_device *dev)
1270 {
1271 	__gre_tunnel_init(dev);
1272 	dev->priv_flags |= IFF_LIVE_ADDR_CHANGE;
1273 	netif_keep_dst(dev);
1274 
1275 	return ip_tunnel_init(dev);
1276 }
1277 
1278 static const struct net_device_ops gre_tap_netdev_ops = {
1279 	.ndo_init		= gre_tap_init,
1280 	.ndo_uninit		= ip_tunnel_uninit,
1281 	.ndo_start_xmit		= gre_tap_xmit,
1282 	.ndo_set_mac_address 	= eth_mac_addr,
1283 	.ndo_validate_addr	= eth_validate_addr,
1284 	.ndo_change_mtu		= ip_tunnel_change_mtu,
1285 	.ndo_get_stats64	= dev_get_tstats64,
1286 	.ndo_get_iflink		= ip_tunnel_get_iflink,
1287 	.ndo_fill_metadata_dst	= gre_fill_metadata_dst,
1288 };
1289 
erspan_tunnel_init(struct net_device * dev)1290 static int erspan_tunnel_init(struct net_device *dev)
1291 {
1292 	struct ip_tunnel *tunnel = netdev_priv(dev);
1293 
1294 	if (tunnel->erspan_ver == 0)
1295 		tunnel->tun_hlen = 4; /* 4-byte GRE hdr. */
1296 	else
1297 		tunnel->tun_hlen = 8; /* 8-byte GRE hdr. */
1298 
1299 	tunnel->parms.iph.protocol = IPPROTO_GRE;
1300 	tunnel->hlen = tunnel->tun_hlen + tunnel->encap_hlen +
1301 		       erspan_hdr_len(tunnel->erspan_ver);
1302 
1303 	dev->features		|= GRE_FEATURES;
1304 	dev->hw_features	|= GRE_FEATURES;
1305 	dev->priv_flags		|= IFF_LIVE_ADDR_CHANGE;
1306 	netif_keep_dst(dev);
1307 
1308 	return ip_tunnel_init(dev);
1309 }
1310 
1311 static const struct net_device_ops erspan_netdev_ops = {
1312 	.ndo_init		= erspan_tunnel_init,
1313 	.ndo_uninit		= ip_tunnel_uninit,
1314 	.ndo_start_xmit		= erspan_xmit,
1315 	.ndo_set_mac_address	= eth_mac_addr,
1316 	.ndo_validate_addr	= eth_validate_addr,
1317 	.ndo_change_mtu		= ip_tunnel_change_mtu,
1318 	.ndo_get_stats64	= dev_get_tstats64,
1319 	.ndo_get_iflink		= ip_tunnel_get_iflink,
1320 	.ndo_fill_metadata_dst	= gre_fill_metadata_dst,
1321 };
1322 
ipgre_tap_setup(struct net_device * dev)1323 static void ipgre_tap_setup(struct net_device *dev)
1324 {
1325 	ether_setup(dev);
1326 	dev->max_mtu = 0;
1327 	dev->netdev_ops	= &gre_tap_netdev_ops;
1328 	dev->priv_flags &= ~IFF_TX_SKB_SHARING;
1329 	dev->priv_flags	|= IFF_LIVE_ADDR_CHANGE;
1330 	ip_tunnel_setup(dev, gre_tap_net_id);
1331 }
1332 
1333 static int
ipgre_newlink_encap_setup(struct net_device * dev,struct nlattr * data[])1334 ipgre_newlink_encap_setup(struct net_device *dev, struct nlattr *data[])
1335 {
1336 	struct ip_tunnel_encap ipencap;
1337 
1338 	if (ipgre_netlink_encap_parms(data, &ipencap)) {
1339 		struct ip_tunnel *t = netdev_priv(dev);
1340 		int err = ip_tunnel_encap_setup(t, &ipencap);
1341 
1342 		if (err < 0)
1343 			return err;
1344 	}
1345 
1346 	return 0;
1347 }
1348 
ipgre_newlink(struct net * src_net,struct net_device * dev,struct nlattr * tb[],struct nlattr * data[],struct netlink_ext_ack * extack)1349 static int ipgre_newlink(struct net *src_net, struct net_device *dev,
1350 			 struct nlattr *tb[], struct nlattr *data[],
1351 			 struct netlink_ext_ack *extack)
1352 {
1353 	struct ip_tunnel_parm p;
1354 	__u32 fwmark = 0;
1355 	int err;
1356 
1357 	err = ipgre_newlink_encap_setup(dev, data);
1358 	if (err)
1359 		return err;
1360 
1361 	err = ipgre_netlink_parms(dev, data, tb, &p, &fwmark);
1362 	if (err < 0)
1363 		return err;
1364 	return ip_tunnel_newlink(dev, tb, &p, fwmark);
1365 }
1366 
erspan_newlink(struct net * src_net,struct net_device * dev,struct nlattr * tb[],struct nlattr * data[],struct netlink_ext_ack * extack)1367 static int erspan_newlink(struct net *src_net, struct net_device *dev,
1368 			  struct nlattr *tb[], struct nlattr *data[],
1369 			  struct netlink_ext_ack *extack)
1370 {
1371 	struct ip_tunnel_parm p;
1372 	__u32 fwmark = 0;
1373 	int err;
1374 
1375 	err = ipgre_newlink_encap_setup(dev, data);
1376 	if (err)
1377 		return err;
1378 
1379 	err = erspan_netlink_parms(dev, data, tb, &p, &fwmark);
1380 	if (err)
1381 		return err;
1382 	return ip_tunnel_newlink(dev, tb, &p, fwmark);
1383 }
1384 
ipgre_changelink(struct net_device * dev,struct nlattr * tb[],struct nlattr * data[],struct netlink_ext_ack * extack)1385 static int ipgre_changelink(struct net_device *dev, struct nlattr *tb[],
1386 			    struct nlattr *data[],
1387 			    struct netlink_ext_ack *extack)
1388 {
1389 	struct ip_tunnel *t = netdev_priv(dev);
1390 	__u32 fwmark = t->fwmark;
1391 	struct ip_tunnel_parm p;
1392 	int err;
1393 
1394 	err = ipgre_newlink_encap_setup(dev, data);
1395 	if (err)
1396 		return err;
1397 
1398 	err = ipgre_netlink_parms(dev, data, tb, &p, &fwmark);
1399 	if (err < 0)
1400 		return err;
1401 
1402 	err = ip_tunnel_changelink(dev, tb, &p, fwmark);
1403 	if (err < 0)
1404 		return err;
1405 
1406 	t->parms.i_flags = p.i_flags;
1407 	t->parms.o_flags = p.o_flags;
1408 
1409 	ipgre_link_update(dev, !tb[IFLA_MTU]);
1410 
1411 	return 0;
1412 }
1413 
erspan_changelink(struct net_device * dev,struct nlattr * tb[],struct nlattr * data[],struct netlink_ext_ack * extack)1414 static int erspan_changelink(struct net_device *dev, struct nlattr *tb[],
1415 			     struct nlattr *data[],
1416 			     struct netlink_ext_ack *extack)
1417 {
1418 	struct ip_tunnel *t = netdev_priv(dev);
1419 	__u32 fwmark = t->fwmark;
1420 	struct ip_tunnel_parm p;
1421 	int err;
1422 
1423 	err = ipgre_newlink_encap_setup(dev, data);
1424 	if (err)
1425 		return err;
1426 
1427 	err = erspan_netlink_parms(dev, data, tb, &p, &fwmark);
1428 	if (err < 0)
1429 		return err;
1430 
1431 	err = ip_tunnel_changelink(dev, tb, &p, fwmark);
1432 	if (err < 0)
1433 		return err;
1434 
1435 	t->parms.i_flags = p.i_flags;
1436 	t->parms.o_flags = p.o_flags;
1437 
1438 	return 0;
1439 }
1440 
ipgre_get_size(const struct net_device * dev)1441 static size_t ipgre_get_size(const struct net_device *dev)
1442 {
1443 	return
1444 		/* IFLA_GRE_LINK */
1445 		nla_total_size(4) +
1446 		/* IFLA_GRE_IFLAGS */
1447 		nla_total_size(2) +
1448 		/* IFLA_GRE_OFLAGS */
1449 		nla_total_size(2) +
1450 		/* IFLA_GRE_IKEY */
1451 		nla_total_size(4) +
1452 		/* IFLA_GRE_OKEY */
1453 		nla_total_size(4) +
1454 		/* IFLA_GRE_LOCAL */
1455 		nla_total_size(4) +
1456 		/* IFLA_GRE_REMOTE */
1457 		nla_total_size(4) +
1458 		/* IFLA_GRE_TTL */
1459 		nla_total_size(1) +
1460 		/* IFLA_GRE_TOS */
1461 		nla_total_size(1) +
1462 		/* IFLA_GRE_PMTUDISC */
1463 		nla_total_size(1) +
1464 		/* IFLA_GRE_ENCAP_TYPE */
1465 		nla_total_size(2) +
1466 		/* IFLA_GRE_ENCAP_FLAGS */
1467 		nla_total_size(2) +
1468 		/* IFLA_GRE_ENCAP_SPORT */
1469 		nla_total_size(2) +
1470 		/* IFLA_GRE_ENCAP_DPORT */
1471 		nla_total_size(2) +
1472 		/* IFLA_GRE_COLLECT_METADATA */
1473 		nla_total_size(0) +
1474 		/* IFLA_GRE_IGNORE_DF */
1475 		nla_total_size(1) +
1476 		/* IFLA_GRE_FWMARK */
1477 		nla_total_size(4) +
1478 		/* IFLA_GRE_ERSPAN_INDEX */
1479 		nla_total_size(4) +
1480 		/* IFLA_GRE_ERSPAN_VER */
1481 		nla_total_size(1) +
1482 		/* IFLA_GRE_ERSPAN_DIR */
1483 		nla_total_size(1) +
1484 		/* IFLA_GRE_ERSPAN_HWID */
1485 		nla_total_size(2) +
1486 		0;
1487 }
1488 
ipgre_fill_info(struct sk_buff * skb,const struct net_device * dev)1489 static int ipgre_fill_info(struct sk_buff *skb, const struct net_device *dev)
1490 {
1491 	struct ip_tunnel *t = netdev_priv(dev);
1492 	struct ip_tunnel_parm *p = &t->parms;
1493 	__be16 o_flags = p->o_flags;
1494 
1495 	if (nla_put_u32(skb, IFLA_GRE_LINK, p->link) ||
1496 	    nla_put_be16(skb, IFLA_GRE_IFLAGS,
1497 			 gre_tnl_flags_to_gre_flags(p->i_flags)) ||
1498 	    nla_put_be16(skb, IFLA_GRE_OFLAGS,
1499 			 gre_tnl_flags_to_gre_flags(o_flags)) ||
1500 	    nla_put_be32(skb, IFLA_GRE_IKEY, p->i_key) ||
1501 	    nla_put_be32(skb, IFLA_GRE_OKEY, p->o_key) ||
1502 	    nla_put_in_addr(skb, IFLA_GRE_LOCAL, p->iph.saddr) ||
1503 	    nla_put_in_addr(skb, IFLA_GRE_REMOTE, p->iph.daddr) ||
1504 	    nla_put_u8(skb, IFLA_GRE_TTL, p->iph.ttl) ||
1505 	    nla_put_u8(skb, IFLA_GRE_TOS, p->iph.tos) ||
1506 	    nla_put_u8(skb, IFLA_GRE_PMTUDISC,
1507 		       !!(p->iph.frag_off & htons(IP_DF))) ||
1508 	    nla_put_u32(skb, IFLA_GRE_FWMARK, t->fwmark))
1509 		goto nla_put_failure;
1510 
1511 	if (nla_put_u16(skb, IFLA_GRE_ENCAP_TYPE,
1512 			t->encap.type) ||
1513 	    nla_put_be16(skb, IFLA_GRE_ENCAP_SPORT,
1514 			 t->encap.sport) ||
1515 	    nla_put_be16(skb, IFLA_GRE_ENCAP_DPORT,
1516 			 t->encap.dport) ||
1517 	    nla_put_u16(skb, IFLA_GRE_ENCAP_FLAGS,
1518 			t->encap.flags))
1519 		goto nla_put_failure;
1520 
1521 	if (nla_put_u8(skb, IFLA_GRE_IGNORE_DF, t->ignore_df))
1522 		goto nla_put_failure;
1523 
1524 	if (t->collect_md) {
1525 		if (nla_put_flag(skb, IFLA_GRE_COLLECT_METADATA))
1526 			goto nla_put_failure;
1527 	}
1528 
1529 	return 0;
1530 
1531 nla_put_failure:
1532 	return -EMSGSIZE;
1533 }
1534 
erspan_fill_info(struct sk_buff * skb,const struct net_device * dev)1535 static int erspan_fill_info(struct sk_buff *skb, const struct net_device *dev)
1536 {
1537 	struct ip_tunnel *t = netdev_priv(dev);
1538 
1539 	if (t->erspan_ver <= 2) {
1540 		if (t->erspan_ver != 0 && !t->collect_md)
1541 			t->parms.o_flags |= TUNNEL_KEY;
1542 
1543 		if (nla_put_u8(skb, IFLA_GRE_ERSPAN_VER, t->erspan_ver))
1544 			goto nla_put_failure;
1545 
1546 		if (t->erspan_ver == 1) {
1547 			if (nla_put_u32(skb, IFLA_GRE_ERSPAN_INDEX, t->index))
1548 				goto nla_put_failure;
1549 		} else if (t->erspan_ver == 2) {
1550 			if (nla_put_u8(skb, IFLA_GRE_ERSPAN_DIR, t->dir))
1551 				goto nla_put_failure;
1552 			if (nla_put_u16(skb, IFLA_GRE_ERSPAN_HWID, t->hwid))
1553 				goto nla_put_failure;
1554 		}
1555 	}
1556 
1557 	return ipgre_fill_info(skb, dev);
1558 
1559 nla_put_failure:
1560 	return -EMSGSIZE;
1561 }
1562 
erspan_setup(struct net_device * dev)1563 static void erspan_setup(struct net_device *dev)
1564 {
1565 	struct ip_tunnel *t = netdev_priv(dev);
1566 
1567 	ether_setup(dev);
1568 	dev->max_mtu = 0;
1569 	dev->netdev_ops = &erspan_netdev_ops;
1570 	dev->priv_flags &= ~IFF_TX_SKB_SHARING;
1571 	dev->priv_flags |= IFF_LIVE_ADDR_CHANGE;
1572 	ip_tunnel_setup(dev, erspan_net_id);
1573 	t->erspan_ver = 1;
1574 }
1575 
1576 static const struct nla_policy ipgre_policy[IFLA_GRE_MAX + 1] = {
1577 	[IFLA_GRE_LINK]		= { .type = NLA_U32 },
1578 	[IFLA_GRE_IFLAGS]	= { .type = NLA_U16 },
1579 	[IFLA_GRE_OFLAGS]	= { .type = NLA_U16 },
1580 	[IFLA_GRE_IKEY]		= { .type = NLA_U32 },
1581 	[IFLA_GRE_OKEY]		= { .type = NLA_U32 },
1582 	[IFLA_GRE_LOCAL]	= { .len = sizeof_field(struct iphdr, saddr) },
1583 	[IFLA_GRE_REMOTE]	= { .len = sizeof_field(struct iphdr, daddr) },
1584 	[IFLA_GRE_TTL]		= { .type = NLA_U8 },
1585 	[IFLA_GRE_TOS]		= { .type = NLA_U8 },
1586 	[IFLA_GRE_PMTUDISC]	= { .type = NLA_U8 },
1587 	[IFLA_GRE_ENCAP_TYPE]	= { .type = NLA_U16 },
1588 	[IFLA_GRE_ENCAP_FLAGS]	= { .type = NLA_U16 },
1589 	[IFLA_GRE_ENCAP_SPORT]	= { .type = NLA_U16 },
1590 	[IFLA_GRE_ENCAP_DPORT]	= { .type = NLA_U16 },
1591 	[IFLA_GRE_COLLECT_METADATA]	= { .type = NLA_FLAG },
1592 	[IFLA_GRE_IGNORE_DF]	= { .type = NLA_U8 },
1593 	[IFLA_GRE_FWMARK]	= { .type = NLA_U32 },
1594 	[IFLA_GRE_ERSPAN_INDEX]	= { .type = NLA_U32 },
1595 	[IFLA_GRE_ERSPAN_VER]	= { .type = NLA_U8 },
1596 	[IFLA_GRE_ERSPAN_DIR]	= { .type = NLA_U8 },
1597 	[IFLA_GRE_ERSPAN_HWID]	= { .type = NLA_U16 },
1598 };
1599 
1600 static struct rtnl_link_ops ipgre_link_ops __read_mostly = {
1601 	.kind		= "gre",
1602 	.maxtype	= IFLA_GRE_MAX,
1603 	.policy		= ipgre_policy,
1604 	.priv_size	= sizeof(struct ip_tunnel),
1605 	.setup		= ipgre_tunnel_setup,
1606 	.validate	= ipgre_tunnel_validate,
1607 	.newlink	= ipgre_newlink,
1608 	.changelink	= ipgre_changelink,
1609 	.dellink	= ip_tunnel_dellink,
1610 	.get_size	= ipgre_get_size,
1611 	.fill_info	= ipgre_fill_info,
1612 	.get_link_net	= ip_tunnel_get_link_net,
1613 };
1614 
1615 static struct rtnl_link_ops ipgre_tap_ops __read_mostly = {
1616 	.kind		= "gretap",
1617 	.maxtype	= IFLA_GRE_MAX,
1618 	.policy		= ipgre_policy,
1619 	.priv_size	= sizeof(struct ip_tunnel),
1620 	.setup		= ipgre_tap_setup,
1621 	.validate	= ipgre_tap_validate,
1622 	.newlink	= ipgre_newlink,
1623 	.changelink	= ipgre_changelink,
1624 	.dellink	= ip_tunnel_dellink,
1625 	.get_size	= ipgre_get_size,
1626 	.fill_info	= ipgre_fill_info,
1627 	.get_link_net	= ip_tunnel_get_link_net,
1628 };
1629 
1630 static struct rtnl_link_ops erspan_link_ops __read_mostly = {
1631 	.kind		= "erspan",
1632 	.maxtype	= IFLA_GRE_MAX,
1633 	.policy		= ipgre_policy,
1634 	.priv_size	= sizeof(struct ip_tunnel),
1635 	.setup		= erspan_setup,
1636 	.validate	= erspan_validate,
1637 	.newlink	= erspan_newlink,
1638 	.changelink	= erspan_changelink,
1639 	.dellink	= ip_tunnel_dellink,
1640 	.get_size	= ipgre_get_size,
1641 	.fill_info	= erspan_fill_info,
1642 	.get_link_net	= ip_tunnel_get_link_net,
1643 };
1644 
gretap_fb_dev_create(struct net * net,const char * name,u8 name_assign_type)1645 struct net_device *gretap_fb_dev_create(struct net *net, const char *name,
1646 					u8 name_assign_type)
1647 {
1648 	struct nlattr *tb[IFLA_MAX + 1];
1649 	struct net_device *dev;
1650 	LIST_HEAD(list_kill);
1651 	struct ip_tunnel *t;
1652 	int err;
1653 
1654 	memset(&tb, 0, sizeof(tb));
1655 
1656 	dev = rtnl_create_link(net, name, name_assign_type,
1657 			       &ipgre_tap_ops, tb, NULL);
1658 	if (IS_ERR(dev))
1659 		return dev;
1660 
1661 	/* Configure flow based GRE device. */
1662 	t = netdev_priv(dev);
1663 	t->collect_md = true;
1664 
1665 	err = ipgre_newlink(net, dev, tb, NULL, NULL);
1666 	if (err < 0) {
1667 		free_netdev(dev);
1668 		return ERR_PTR(err);
1669 	}
1670 
1671 	/* openvswitch users expect packet sizes to be unrestricted,
1672 	 * so set the largest MTU we can.
1673 	 */
1674 	err = __ip_tunnel_change_mtu(dev, IP_MAX_MTU, false);
1675 	if (err)
1676 		goto out;
1677 
1678 	err = rtnl_configure_link(dev, NULL);
1679 	if (err < 0)
1680 		goto out;
1681 
1682 	return dev;
1683 out:
1684 	ip_tunnel_dellink(dev, &list_kill);
1685 	unregister_netdevice_many(&list_kill);
1686 	return ERR_PTR(err);
1687 }
1688 EXPORT_SYMBOL_GPL(gretap_fb_dev_create);
1689 
ipgre_tap_init_net(struct net * net)1690 static int __net_init ipgre_tap_init_net(struct net *net)
1691 {
1692 	return ip_tunnel_init_net(net, gre_tap_net_id, &ipgre_tap_ops, "gretap0");
1693 }
1694 
ipgre_tap_exit_batch_net(struct list_head * list_net)1695 static void __net_exit ipgre_tap_exit_batch_net(struct list_head *list_net)
1696 {
1697 	ip_tunnel_delete_nets(list_net, gre_tap_net_id, &ipgre_tap_ops);
1698 }
1699 
1700 static struct pernet_operations ipgre_tap_net_ops = {
1701 	.init = ipgre_tap_init_net,
1702 	.exit_batch = ipgre_tap_exit_batch_net,
1703 	.id   = &gre_tap_net_id,
1704 	.size = sizeof(struct ip_tunnel_net),
1705 };
1706 
erspan_init_net(struct net * net)1707 static int __net_init erspan_init_net(struct net *net)
1708 {
1709 	return ip_tunnel_init_net(net, erspan_net_id,
1710 				  &erspan_link_ops, "erspan0");
1711 }
1712 
erspan_exit_batch_net(struct list_head * net_list)1713 static void __net_exit erspan_exit_batch_net(struct list_head *net_list)
1714 {
1715 	ip_tunnel_delete_nets(net_list, erspan_net_id, &erspan_link_ops);
1716 }
1717 
1718 static struct pernet_operations erspan_net_ops = {
1719 	.init = erspan_init_net,
1720 	.exit_batch = erspan_exit_batch_net,
1721 	.id   = &erspan_net_id,
1722 	.size = sizeof(struct ip_tunnel_net),
1723 };
1724 
ipgre_init(void)1725 static int __init ipgre_init(void)
1726 {
1727 	int err;
1728 
1729 	pr_info("GRE over IPv4 tunneling driver\n");
1730 
1731 	err = register_pernet_device(&ipgre_net_ops);
1732 	if (err < 0)
1733 		return err;
1734 
1735 	err = register_pernet_device(&ipgre_tap_net_ops);
1736 	if (err < 0)
1737 		goto pnet_tap_failed;
1738 
1739 	err = register_pernet_device(&erspan_net_ops);
1740 	if (err < 0)
1741 		goto pnet_erspan_failed;
1742 
1743 	err = gre_add_protocol(&ipgre_protocol, GREPROTO_CISCO);
1744 	if (err < 0) {
1745 		pr_info("%s: can't add protocol\n", __func__);
1746 		goto add_proto_failed;
1747 	}
1748 
1749 	err = rtnl_link_register(&ipgre_link_ops);
1750 	if (err < 0)
1751 		goto rtnl_link_failed;
1752 
1753 	err = rtnl_link_register(&ipgre_tap_ops);
1754 	if (err < 0)
1755 		goto tap_ops_failed;
1756 
1757 	err = rtnl_link_register(&erspan_link_ops);
1758 	if (err < 0)
1759 		goto erspan_link_failed;
1760 
1761 	return 0;
1762 
1763 erspan_link_failed:
1764 	rtnl_link_unregister(&ipgre_tap_ops);
1765 tap_ops_failed:
1766 	rtnl_link_unregister(&ipgre_link_ops);
1767 rtnl_link_failed:
1768 	gre_del_protocol(&ipgre_protocol, GREPROTO_CISCO);
1769 add_proto_failed:
1770 	unregister_pernet_device(&erspan_net_ops);
1771 pnet_erspan_failed:
1772 	unregister_pernet_device(&ipgre_tap_net_ops);
1773 pnet_tap_failed:
1774 	unregister_pernet_device(&ipgre_net_ops);
1775 	return err;
1776 }
1777 
ipgre_fini(void)1778 static void __exit ipgre_fini(void)
1779 {
1780 	rtnl_link_unregister(&ipgre_tap_ops);
1781 	rtnl_link_unregister(&ipgre_link_ops);
1782 	rtnl_link_unregister(&erspan_link_ops);
1783 	gre_del_protocol(&ipgre_protocol, GREPROTO_CISCO);
1784 	unregister_pernet_device(&ipgre_tap_net_ops);
1785 	unregister_pernet_device(&ipgre_net_ops);
1786 	unregister_pernet_device(&erspan_net_ops);
1787 }
1788 
1789 module_init(ipgre_init);
1790 module_exit(ipgre_fini);
1791 MODULE_LICENSE("GPL");
1792 MODULE_ALIAS_RTNL_LINK("gre");
1793 MODULE_ALIAS_RTNL_LINK("gretap");
1794 MODULE_ALIAS_RTNL_LINK("erspan");
1795 MODULE_ALIAS_NETDEV("gre0");
1796 MODULE_ALIAS_NETDEV("gretap0");
1797 MODULE_ALIAS_NETDEV("erspan0");
1798