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