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