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