projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ip_tunnels: use tos and ttl fields also for IPv6
[linux-2.6-block.git] / net / ipv4 / ip_gre.c
CommitLineData
1da177e4 1/*
e905a9ed 2 * Linux NET3: GRE over IP protocol decoder.
1da177e4
LT		 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
afd46503
JP		 13#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
14
4fc268d2 15#include <linux/capability.h>
1da177e4
LT		 16#include <linux/module.h>
17#include <linux/types.h>
1da177e4 18#include <linux/kernel.h>
5a0e3ad6 19#include <linux/slab.h>
1da177e4
LT		 20#include <asm/uaccess.h>
21#include <linux/skbuff.h>
22#include <linux/netdevice.h>
23#include <linux/in.h>
24#include <linux/tcp.h>
25#include <linux/udp.h>
26#include <linux/if_arp.h>
27#include <linux/mroute.h>
2e15ea39 28#include <linux/if_vlan.h>
1da177e4
LT		 29#include <linux/init.h>
30#include <linux/in6.h>
31#include <linux/inetdevice.h>
32#include <linux/igmp.h>
33#include <linux/netfilter_ipv4.h>
e1a80002 34#include <linux/etherdevice.h>
46f25dff 35#include <linux/if_ether.h>
1da177e4
LT		 36
37#include <net/sock.h>
38#include <net/ip.h>
39#include <net/icmp.h>
40#include <net/protocol.h>
c5441932 41#include <net/ip_tunnels.h>
1da177e4
LT		 42#include <net/arp.h>
43#include <net/checksum.h>
44#include <net/dsfield.h>
45#include <net/inet_ecn.h>
46#include <net/xfrm.h>
59a4c759
PE		 47#include <net/net_namespace.h>
48#include <net/netns/generic.h>
c19e654d 49#include <net/rtnetlink.h>
00959ade 50#include <net/gre.h>
2e15ea39 51#include <net/dst_metadata.h>
1da177e4 52
dfd56b8b 53#if IS_ENABLED(CONFIG_IPV6)
1da177e4
LT		 54#include <net/ipv6.h>
55#include <net/ip6_fib.h>
56#include <net/ip6_route.h>
57#endif
58
59/*
60 Problems & solutions
61 --------------------
62
63 1. The most important issue is detecting local dead loops.
64 They would cause complete host lockup in transmit, which
65 would be "resolved" by stack overflow or, if queueing is enabled,
66 with infinite looping in net_bh.
67
68 We cannot track such dead loops during route installation,
69 it is infeasible task. The most general solutions would be
70 to keep skb->encapsulation counter (sort of local ttl),
6d0722a2 71 and silently drop packet when it expires. It is a good
bff52857 72 solution, but it supposes maintaining new variable in ALL
1da177e4
LT		 73 skb, even if no tunneling is used.
74
6d0722a2
ED		 75 Current solution: xmit_recursion breaks dead loops. This is a percpu
76 counter, since when we enter the first ndo_xmit(), cpu migration is
77 forbidden. We force an exit if this counter reaches RECURSION_LIMIT
1da177e4
LT		 78
79 2. Networking dead loops would not kill routers, but would really
80 kill network. IP hop limit plays role of "t->recursion" in this case,
81 if we copy it from packet being encapsulated to upper header.
82 It is very good solution, but it introduces two problems:
83
84 - Routing protocols, using packets with ttl=1 (OSPF, RIP2),
85 do not work over tunnels.
86 - traceroute does not work. I planned to relay ICMP from tunnel,
87 so that this problem would be solved and traceroute output
88 would even more informative. This idea appeared to be wrong:
89 only Linux complies to rfc1812 now (yes, guys, Linux is the only
90 true router now :-)), all routers (at least, in neighbourhood of mine)
91 return only 8 bytes of payload. It is the end.
92
93 Hence, if we want that OSPF worked or traceroute said something reasonable,
94 we should search for another solution.
95
96 One of them is to parse packet trying to detect inner encapsulation
97 made by our node. It is difficult or even impossible, especially,
bff52857 98 taking into account fragmentation. TO be short, ttl is not solution at all.
1da177e4
LT		 99
100 Current solution: The solution was UNEXPECTEDLY SIMPLE.
101 We force DF flag on tunnels with preconfigured hop limit,
102 that is ALL. :-) Well, it does not remove the problem completely,
103 but exponential growth of network traffic is changed to linear
104 (branches, that exceed pmtu are pruned) and tunnel mtu
bff52857 105 rapidly degrades to value <68, where looping stops.
1da177e4
LT		 106 Yes, it is not good if there exists a router in the loop,
107 which does not force DF, even when encapsulating packets have DF set.
108 But it is not our problem! Nobody could accuse us, we made
109 all that we could make. Even if it is your gated who injected
110 fatal route to network, even if it were you who configured
111 fatal static route: you are innocent. :-)
112
1da177e4
LT		 113 Alexey Kuznetsov.
114 */
115
eccc1bb8 116static bool log_ecn_error = true;
117module_param(log_ecn_error, bool, 0644);
118MODULE_PARM_DESC(log_ecn_error, "Log packets received with corrupted ECN");
119
c19e654d 120static struct rtnl_link_ops ipgre_link_ops __read_mostly;
1da177e4 121static int ipgre_tunnel_init(struct net_device *dev);
eb8ce741 122
f99189b1 123static int ipgre_net_id __read_mostly;
c5441932 124static int gre_tap_net_id __read_mostly;
1da177e4 125
9f57c67c
PS		 126static int ip_gre_calc_hlen(__be16 o_flags)
127{
128 int addend = 4;
129
130 if (o_flags & TUNNEL_CSUM)
131 addend += 4;
132 if (o_flags & TUNNEL_KEY)
133 addend += 4;
134 if (o_flags & TUNNEL_SEQ)
135 addend += 4;
136 return addend;
137}
138
139static __be16 gre_flags_to_tnl_flags(__be16 flags)
140{
141 __be16 tflags = 0;
142
143 if (flags & GRE_CSUM)
144 tflags |= TUNNEL_CSUM;
145 if (flags & GRE_ROUTING)
146 tflags |= TUNNEL_ROUTING;
147 if (flags & GRE_KEY)
148 tflags |= TUNNEL_KEY;
149 if (flags & GRE_SEQ)
150 tflags |= TUNNEL_SEQ;
151 if (flags & GRE_STRICT)
152 tflags |= TUNNEL_STRICT;
153 if (flags & GRE_REC)
154 tflags |= TUNNEL_REC;
155 if (flags & GRE_VERSION)
156 tflags |= TUNNEL_VERSION;
157
158 return tflags;
159}
160
161static __be16 tnl_flags_to_gre_flags(__be16 tflags)
162{
163 __be16 flags = 0;
164
165 if (tflags & TUNNEL_CSUM)
166 flags |= GRE_CSUM;
167 if (tflags & TUNNEL_ROUTING)
168 flags |= GRE_ROUTING;
169 if (tflags & TUNNEL_KEY)
170 flags |= GRE_KEY;
171 if (tflags & TUNNEL_SEQ)
172 flags |= GRE_SEQ;
173 if (tflags & TUNNEL_STRICT)
174 flags |= GRE_STRICT;
175 if (tflags & TUNNEL_REC)
176 flags |= GRE_REC;
177 if (tflags & TUNNEL_VERSION)
178 flags |= GRE_VERSION;
179
180 return flags;
181}
182
183static int parse_gre_header(struct sk_buff *skb, struct tnl_ptk_info *tpi,
184 bool *csum_err)
185{
186 const struct gre_base_hdr *greh;
187 __be32 *options;
188 int hdr_len;
189
190 if (unlikely(!pskb_may_pull(skb, sizeof(struct gre_base_hdr))))
191 return -EINVAL;
192
193 greh = (struct gre_base_hdr *)skb_transport_header(skb);
194 if (unlikely(greh->flags & (GRE_VERSION | GRE_ROUTING)))
195 return -EINVAL;
196
197 tpi->flags = gre_flags_to_tnl_flags(greh->flags);
198 hdr_len = ip_gre_calc_hlen(tpi->flags);
199
200 if (!pskb_may_pull(skb, hdr_len))
201 return -EINVAL;
202
203 greh = (struct gre_base_hdr *)skb_transport_header(skb);
204 tpi->proto = greh->protocol;
205
206 options = (__be32 *)(greh + 1);
207 if (greh->flags & GRE_CSUM) {
208 if (skb_checksum_simple_validate(skb)) {
209 *csum_err = true;
210 return -EINVAL;
211 }
212
213 skb_checksum_try_convert(skb, IPPROTO_GRE, 0,
214 null_compute_pseudo);
215 options++;
216 }
217
218 if (greh->flags & GRE_KEY) {
219 tpi->key = *options;
220 options++;
221 } else {
222 tpi->key = 0;
223 }
224 if (unlikely(greh->flags & GRE_SEQ)) {
225 tpi->seq = *options;
226 options++;
227 } else {
228 tpi->seq = 0;
229 }
230 /* WCCP version 1 and 2 protocol decoding.
231 * - Change protocol to IP
232 * - When dealing with WCCPv2, Skip extra 4 bytes in GRE header
233 */
234 if (greh->flags == 0 && tpi->proto == htons(ETH_P_WCCP)) {
235 tpi->proto = htons(ETH_P_IP);
236 if ((*(u8 *)options & 0xF0) != 0x40) {
237 hdr_len += 4;
238 if (!pskb_may_pull(skb, hdr_len))
239 return -EINVAL;
240 }
241 }
242 return iptunnel_pull_header(skb, hdr_len, tpi->proto);
243}
244
245static void ipgre_err(struct sk_buff *skb, u32 info,
246 const struct tnl_ptk_info *tpi)
1da177e4 247{
1da177e4 248
c5441932
PS		 249 /* All the routers (except for Linux) return only
250 8 bytes of packet payload. It means, that precise relaying of
251 ICMP in the real Internet is absolutely infeasible.
1da177e4 252
c5441932
PS		 253 Moreover, Cisco "wise men" put GRE key to the third word
254 in GRE header. It makes impossible maintaining even soft
255 state for keyed GRE tunnels with enabled checksum. Tell
256 them "thank you".
1da177e4 257
c5441932
PS		 258 Well, I wonder, rfc1812 was written by Cisco employee,
259 what the hell these idiots break standards established
260 by themselves???
261 */
262 struct net *net = dev_net(skb->dev);
263 struct ip_tunnel_net *itn;
96f5a846 264 const struct iphdr *iph;
88c7664f
ACM		 265 const int type = icmp_hdr(skb)->type;
266 const int code = icmp_hdr(skb)->code;
1da177e4 267 struct ip_tunnel *t;
1da177e4 268
1da177e4
LT		 269 switch (type) {
270 default:
271 case ICMP_PARAMETERPROB:
9f57c67c 272 return;
1da177e4
LT		 273
274 case ICMP_DEST_UNREACH:
275 switch (code) {
276 case ICMP_SR_FAILED:
277 case ICMP_PORT_UNREACH:
278 /* Impossible event. */
9f57c67c 279 return;
1da177e4
LT		 280 default:
281 /* All others are translated to HOST_UNREACH.
282 rfc2003 contains "deep thoughts" about NET_UNREACH,
283 I believe they are just ether pollution. --ANK
284 */
285 break;
286 }
287 break;
9f57c67c 288
1da177e4
LT		 289 case ICMP_TIME_EXCEEDED:
290 if (code != ICMP_EXC_TTL)
9f57c67c 291 return;
1da177e4 292 break;
55be7a9c
DM		 293
294 case ICMP_REDIRECT:
295 break;
1da177e4
LT		 296 }
297
bda7bb46 298 if (tpi->proto == htons(ETH_P_TEB))
c5441932
PS		 299 itn = net_generic(net, gre_tap_net_id);
300 else
301 itn = net_generic(net, ipgre_net_id);
302
c0c0c50f 303 iph = (const struct iphdr *)(icmp_hdr(skb) + 1);
bda7bb46
PS		 304 t = ip_tunnel_lookup(itn, skb->dev->ifindex, tpi->flags,
305 iph->daddr, iph->saddr, tpi->key);
d2083287 306
51456b29 307 if (!t)
9f57c67c 308 return;
36393395 309
36393395 310 if (t->parms.iph.daddr == 0 ||
f97c1e0c 311 ipv4_is_multicast(t->parms.iph.daddr))
9f57c67c 312 return;
1da177e4
LT		 313
314 if (t->parms.iph.ttl == 0 && type == ICMP_TIME_EXCEEDED)
9f57c67c 315 return;
1da177e4 316
da6185d8 317 if (time_before(jiffies, t->err_time + IPTUNNEL_ERR_TIMEO))
1da177e4
LT		 318 t->err_count++;
319 else
320 t->err_count = 1;
321 t->err_time = jiffies;
9f57c67c
PS		 322}
323
324static void gre_err(struct sk_buff *skb, u32 info)
325{
326 /* All the routers (except for Linux) return only
327 * 8 bytes of packet payload. It means, that precise relaying of
328 * ICMP in the real Internet is absolutely infeasible.
329 *
330 * Moreover, Cisco "wise men" put GRE key to the third word
331 * in GRE header. It makes impossible maintaining even soft
332 * state for keyed
333 * GRE tunnels with enabled checksum. Tell them "thank you".
334 *
335 * Well, I wonder, rfc1812 was written by Cisco employee,
336 * what the hell these idiots break standards established
337 * by themselves???
338 */
339
340 const int type = icmp_hdr(skb)->type;
341 const int code = icmp_hdr(skb)->code;
342 struct tnl_ptk_info tpi;
343 bool csum_err = false;
344
345 if (parse_gre_header(skb, &tpi, &csum_err)) {
346 if (!csum_err) /* ignore csum errors. */
347 return;
348 }
349
350 if (type == ICMP_DEST_UNREACH && code == ICMP_FRAG_NEEDED) {
351 ipv4_update_pmtu(skb, dev_net(skb->dev), info,
352 skb->dev->ifindex, 0, IPPROTO_GRE, 0);
353 return;
354 }
355 if (type == ICMP_REDIRECT) {
356 ipv4_redirect(skb, dev_net(skb->dev), skb->dev->ifindex, 0,
357 IPPROTO_GRE, 0);
358 return;
359 }
360
361 ipgre_err(skb, info, &tpi);
1da177e4
LT		 362}
363
2e15ea39
PS		 364static __be64 key_to_tunnel_id(__be32 key)
365{
366#ifdef __BIG_ENDIAN
367 return (__force __be64)((__force u32)key);
368#else
369 return (__force __be64)((__force u64)key << 32);
370#endif
371}
372
373/* Returns the least-significant 32 bits of a __be64. */
374static __be32 tunnel_id_to_key(__be64 x)
375{
376#ifdef __BIG_ENDIAN
377 return (__force __be32)x;
378#else
379 return (__force __be32)((__force u64)x >> 32);
380#endif
381}
382
bda7bb46 383static int ipgre_rcv(struct sk_buff *skb, const struct tnl_ptk_info *tpi)
1da177e4 384{
c5441932 385 struct net *net = dev_net(skb->dev);
2e15ea39 386 struct metadata_dst *tun_dst = NULL;
c5441932 387 struct ip_tunnel_net *itn;
b71d1d42 388 const struct iphdr *iph;
1da177e4 389 struct ip_tunnel *tunnel;
1da177e4 390
bda7bb46 391 if (tpi->proto == htons(ETH_P_TEB))
c5441932
PS		 392 itn = net_generic(net, gre_tap_net_id);
393 else
394 itn = net_generic(net, ipgre_net_id);
1da177e4 395
c5441932 396 iph = ip_hdr(skb);
bda7bb46
PS		 397 tunnel = ip_tunnel_lookup(itn, skb->dev->ifindex, tpi->flags,
398 iph->saddr, iph->daddr, tpi->key);
e1a80002 399
d2083287 400 if (tunnel) {
0e3da5bb 401 skb_pop_mac_header(skb);
2e15ea39
PS		 402 if (tunnel->collect_md) {
403 struct ip_tunnel_info *info;
404
405 tun_dst = metadata_dst_alloc(0, GFP_ATOMIC);
406 if (!tun_dst)
407 return PACKET_REJECT;
408
409 info = &tun_dst->u.tun_info;
c1ea5d67
JB		 410 info->key.u.ipv4.src = iph->saddr;
411 info->key.u.ipv4.dst = iph->daddr;
7c383fb2
JB		 412 info->key.tos = iph->tos;
413 info->key.ttl = iph->ttl;
2e15ea39
PS		 414
415 info->mode = IP_TUNNEL_INFO_RX;
416 info->key.tun_flags = tpi->flags &
417 (TUNNEL_CSUM | TUNNEL_KEY);
418 info->key.tun_id = key_to_tunnel_id(tpi->key);
419
420 info->key.tp_src = 0;
421 info->key.tp_dst = 0;
422 }
423
424 ip_tunnel_rcv(tunnel, skb, tpi, tun_dst, log_ecn_error);
bda7bb46 425 return PACKET_RCVD;
1da177e4 426 }
bda7bb46 427 return PACKET_REJECT;
1da177e4
LT		 428}
429
9f57c67c
PS		 430static int gre_rcv(struct sk_buff *skb)
431{
432 struct tnl_ptk_info tpi;
433 bool csum_err = false;
434
435#ifdef CONFIG_NET_IPGRE_BROADCAST
436 if (ipv4_is_multicast(ip_hdr(skb)->daddr)) {
437 /* Looped back packet, drop it! */
438 if (rt_is_output_route(skb_rtable(skb)))
439 goto drop;
440 }
441#endif
442
443 if (parse_gre_header(skb, &tpi, &csum_err) < 0)
444 goto drop;
445
446 if (ipgre_rcv(skb, &tpi) == PACKET_RCVD)
447 return 0;
448
449 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, 0);
450drop:
451 kfree_skb(skb);
452 return 0;
453}
454
2e15ea39
PS		 455static void build_header(struct sk_buff *skb, int hdr_len, __be16 flags,
456 __be16 proto, __be32 key, __be32 seq)
457{
458 struct gre_base_hdr *greh;
459
460 skb_push(skb, hdr_len);
461
462 skb_reset_transport_header(skb);
463 greh = (struct gre_base_hdr *)skb->data;
464 greh->flags = tnl_flags_to_gre_flags(flags);
465 greh->protocol = proto;
466
467 if (flags & (TUNNEL_KEY | TUNNEL_CSUM | TUNNEL_SEQ)) {
468 __be32 *ptr = (__be32 *)(((u8 *)greh) + hdr_len - 4);
469
470 if (flags & TUNNEL_SEQ) {
471 *ptr = seq;
472 ptr--;
473 }
474 if (flags & TUNNEL_KEY) {
475 *ptr = key;
476 ptr--;
477 }
478 if (flags & TUNNEL_CSUM &&
479 !(skb_shinfo(skb)->gso_type &
480 (SKB_GSO_GRE | SKB_GSO_GRE_CSUM))) {
481 *ptr = 0;
482 *(__sum16 *)ptr = csum_fold(skb_checksum(skb, 0,
483 skb->len, 0));
484 }
485 }
486}
487
c5441932
PS		 488static void __gre_xmit(struct sk_buff *skb, struct net_device *dev,
489 const struct iphdr *tnl_params,
490 __be16 proto)
491{
492 struct ip_tunnel *tunnel = netdev_priv(dev);
1da177e4 493
c5441932
PS		 494 if (tunnel->parms.o_flags & TUNNEL_SEQ)
495 tunnel->o_seqno++;
1da177e4 496
c5441932 497 /* Push GRE header. */
2e15ea39
PS		 498 build_header(skb, tunnel->tun_hlen, tunnel->parms.o_flags,
499 proto, tunnel->parms.o_key, htonl(tunnel->o_seqno));
54bc9bac 500
2e15ea39 501 skb_set_inner_protocol(skb, proto);
bf3d6a8f 502 ip_tunnel_xmit(skb, dev, tnl_params, tnl_params->protocol);
c5441932 503}
1da177e4 504
b2acd1dc
PS		 505static struct sk_buff *gre_handle_offloads(struct sk_buff *skb,
506 bool csum)
507{
508 return iptunnel_handle_offloads(skb, csum,
509 csum ? SKB_GSO_GRE_CSUM : SKB_GSO_GRE);
510}
511
2e15ea39
PS		 512static void gre_fb_xmit(struct sk_buff *skb, struct net_device *dev)
513{
514 struct ip_tunnel_info *tun_info;
515 struct net *net = dev_net(dev);
516 const struct ip_tunnel_key *key;
517 struct flowi4 fl;
518 struct rtable *rt;
519 int min_headroom;
520 int tunnel_hlen;
521 __be16 df, flags;
522 int err;
523
524 tun_info = skb_tunnel_info(skb, AF_INET);
525 if (unlikely(!tun_info || tun_info->mode != IP_TUNNEL_INFO_TX))
526 goto err_free_skb;
527
528 key = &tun_info->key;
529 memset(&fl, 0, sizeof(fl));
c1ea5d67
JB		 530 fl.daddr = key->u.ipv4.dst;
531 fl.saddr = key->u.ipv4.src;
7c383fb2 532 fl.flowi4_tos = RT_TOS(key->tos);
2e15ea39
PS		 533 fl.flowi4_mark = skb->mark;
534 fl.flowi4_proto = IPPROTO_GRE;
535
536 rt = ip_route_output_key(net, &fl);
537 if (IS_ERR(rt))
538 goto err_free_skb;
539
540 tunnel_hlen = ip_gre_calc_hlen(key->tun_flags);
541
542 min_headroom = LL_RESERVED_SPACE(rt->dst.dev) + rt->dst.header_len
543 + tunnel_hlen + sizeof(struct iphdr);
544 if (skb_headroom(skb) < min_headroom || skb_header_cloned(skb)) {
545 int head_delta = SKB_DATA_ALIGN(min_headroom -
546 skb_headroom(skb) +
547 16);
548 err = pskb_expand_head(skb, max_t(int, head_delta, 0),
549 0, GFP_ATOMIC);
550 if (unlikely(err))
551 goto err_free_rt;
552 }
553
554 /* Push Tunnel header. */
555 skb = gre_handle_offloads(skb, !!(tun_info->key.tun_flags & TUNNEL_CSUM));
556 if (IS_ERR(skb)) {
557 skb = NULL;
558 goto err_free_rt;
559 }
560
561 flags = tun_info->key.tun_flags & (TUNNEL_CSUM | TUNNEL_KEY);
562 build_header(skb, tunnel_hlen, flags, htons(ETH_P_TEB),
563 tunnel_id_to_key(tun_info->key.tun_id), 0);
564
565 df = key->tun_flags & TUNNEL_DONT_FRAGMENT ? htons(IP_DF) : 0;
566 err = iptunnel_xmit(skb->sk, rt, skb, fl.saddr,
c1ea5d67 567 key->u.ipv4.dst, IPPROTO_GRE,
7c383fb2 568 key->tos, key->ttl, df, false);
2e15ea39
PS		 569 iptunnel_xmit_stats(err, &dev->stats, dev->tstats);
570 return;
571
572err_free_rt:
573 ip_rt_put(rt);
574err_free_skb:
575 kfree_skb(skb);
576 dev->stats.tx_dropped++;
577}
578
c5441932
PS		 579static netdev_tx_t ipgre_xmit(struct sk_buff *skb,
580 struct net_device *dev)
581{
582 struct ip_tunnel *tunnel = netdev_priv(dev);
583 const struct iphdr *tnl_params;
1da177e4 584
2e15ea39
PS		 585 if (tunnel->collect_md) {
586 gre_fb_xmit(skb, dev);
587 return NETDEV_TX_OK;
588 }
589
c5441932
PS		 590 if (dev->header_ops) {
591 /* Need space for new headers */
592 if (skb_cow_head(skb, dev->needed_headroom -
2bac7cb3 593 (tunnel->hlen + sizeof(struct iphdr))))
c5441932 594 goto free_skb;
1da177e4 595
c5441932 596 tnl_params = (const struct iphdr *)skb->data;
1da177e4 597
c5441932
PS		 598 /* Pull skb since ip_tunnel_xmit() needs skb->data pointing
599 * to gre header.
600 */
601 skb_pull(skb, tunnel->hlen + sizeof(struct iphdr));
8a0033a9 602 skb_reset_mac_header(skb);
c5441932
PS		 603 } else {
604 if (skb_cow_head(skb, dev->needed_headroom))
605 goto free_skb;
1da177e4 606
c5441932 607 tnl_params = &tunnel->parms.iph;
1da177e4
LT		 608 }
609
8a0033a9
TT		 610 skb = gre_handle_offloads(skb, !!(tunnel->parms.o_flags&TUNNEL_CSUM));
611 if (IS_ERR(skb))
612 goto out;
613
c5441932 614 __gre_xmit(skb, dev, tnl_params, skb->protocol);
6ed10654 615 return NETDEV_TX_OK;
1da177e4 616
c5441932 617free_skb:
3acfa1e7 618 kfree_skb(skb);
c5441932
PS		 619out:
620 dev->stats.tx_dropped++;
6ed10654 621 return NETDEV_TX_OK;
1da177e4
LT		 622}
623
c5441932
PS		 624static netdev_tx_t gre_tap_xmit(struct sk_buff *skb,
625 struct net_device *dev)
ee34c1eb 626{
c5441932 627 struct ip_tunnel *tunnel = netdev_priv(dev);
ee34c1eb 628
2e15ea39
PS		 629 if (tunnel->collect_md) {
630 gre_fb_xmit(skb, dev);
631 return NETDEV_TX_OK;
632 }
633
45f2e997 634 skb = gre_handle_offloads(skb, !!(tunnel->parms.o_flags&TUNNEL_CSUM));
c5441932
PS		 635 if (IS_ERR(skb))
636 goto out;
ee34c1eb 637
c5441932
PS		 638 if (skb_cow_head(skb, dev->needed_headroom))
639 goto free_skb;
42aa9162 640
c5441932 641 __gre_xmit(skb, dev, &tunnel->parms.iph, htons(ETH_P_TEB));
c5441932 642 return NETDEV_TX_OK;
ee34c1eb 643
c5441932 644free_skb:
3acfa1e7 645 kfree_skb(skb);
c5441932
PS		 646out:
647 dev->stats.tx_dropped++;
648 return NETDEV_TX_OK;
ee34c1eb
MS		 649}
650
c5441932
PS		 651static int ipgre_tunnel_ioctl(struct net_device *dev,
652 struct ifreq *ifr, int cmd)
1da177e4 653{
4565e991 654 int err;
1da177e4 655 struct ip_tunnel_parm p;
1da177e4 656
c5441932
PS		 657 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
658 return -EFAULT;
6c734fb8
CW		 659 if (cmd == SIOCADDTUNNEL || cmd == SIOCCHGTUNNEL) {
660 if (p.iph.version != 4 || p.iph.protocol != IPPROTO_GRE ||
661 p.iph.ihl != 5 || (p.iph.frag_off&htons(~IP_DF)) ||
662 ((p.i_flags|p.o_flags)&(GRE_VERSION|GRE_ROUTING)))
663 return -EINVAL;
1da177e4 664 }
c5441932
PS		 665 p.i_flags = gre_flags_to_tnl_flags(p.i_flags);
666 p.o_flags = gre_flags_to_tnl_flags(p.o_flags);
1da177e4 667
c5441932
PS		 668 err = ip_tunnel_ioctl(dev, &p, cmd);
669 if (err)
670 return err;
1da177e4 671
c5441932
PS		 672 p.i_flags = tnl_flags_to_gre_flags(p.i_flags);
673 p.o_flags = tnl_flags_to_gre_flags(p.o_flags);
674
675 if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p)))
676 return -EFAULT;
1da177e4
LT		 677 return 0;
678}
679
1da177e4
LT		 680/* Nice toy. Unfortunately, useless in real life :-)
681 It allows to construct virtual multiprotocol broadcast "LAN"
682 over the Internet, provided multicast routing is tuned.
683
684
685 I have no idea was this bicycle invented before me,
686 so that I had to set ARPHRD_IPGRE to a random value.
687 I have an impression, that Cisco could make something similar,
688 but this feature is apparently missing in IOS<=11.2(8).
e905a9ed 689
1da177e4
LT		 690 I set up 10.66.66/24 and fec0:6666:6666::0/96 as virtual networks
691 with broadcast 224.66.66.66. If you have access to mbone, play with me :-)
692
693 ping -t 255 224.66.66.66
694
695 If nobody answers, mbone does not work.
696
697 ip tunnel add Universe mode gre remote 224.66.66.66 local <Your_real_addr> ttl 255
698 ip addr add 10.66.66.<somewhat>/24 dev Universe
699 ifconfig Universe up
700 ifconfig Universe add fe80::<Your_real_addr>/10
701 ifconfig Universe add fec0:6666:6666::<Your_real_addr>/96
702 ftp 10.66.66.66
703 ...
704 ftp fec0:6666:6666::193.233.7.65
705 ...
1da177e4 706 */
3b04ddde
SH		 707static int ipgre_header(struct sk_buff *skb, struct net_device *dev,
708 unsigned short type,
1507850b 709 const void *daddr, const void *saddr, unsigned int len)
1da177e4 710{
2941a486 711 struct ip_tunnel *t = netdev_priv(dev);
c5441932
PS		 712 struct iphdr *iph;
713 struct gre_base_hdr *greh;
1da177e4 714
c5441932
PS		 715 iph = (struct iphdr *)skb_push(skb, t->hlen + sizeof(*iph));
716 greh = (struct gre_base_hdr *)(iph+1);
717 greh->flags = tnl_flags_to_gre_flags(t->parms.o_flags);
718 greh->protocol = htons(type);
1da177e4 719
c5441932 720 memcpy(iph, &t->parms.iph, sizeof(struct iphdr));
e905a9ed 721
c5441932 722 /* Set the source hardware address. */
1da177e4
LT		 723 if (saddr)
724 memcpy(&iph->saddr, saddr, 4);
6d55cb91 725 if (daddr)
1da177e4 726 memcpy(&iph->daddr, daddr, 4);
6d55cb91 727 if (iph->daddr)
77a482bd 728 return t->hlen + sizeof(*iph);
e905a9ed 729
c5441932 730 return -(t->hlen + sizeof(*iph));
1da177e4
LT		 731}
732
6a5f44d7
TT		 733static int ipgre_header_parse(const struct sk_buff *skb, unsigned char *haddr)
734{
b71d1d42 735 const struct iphdr *iph = (const struct iphdr *) skb_mac_header(skb);
6a5f44d7
TT		 736 memcpy(haddr, &iph->saddr, 4);
737 return 4;
738}
739
3b04ddde
SH		 740static const struct header_ops ipgre_header_ops = {
741 .create = ipgre_header,
6a5f44d7 742 .parse = ipgre_header_parse,
3b04ddde
SH		 743};
744
6a5f44d7 745#ifdef CONFIG_NET_IPGRE_BROADCAST
1da177e4
LT		 746static int ipgre_open(struct net_device *dev)
747{
2941a486 748 struct ip_tunnel *t = netdev_priv(dev);
1da177e4 749
f97c1e0c 750 if (ipv4_is_multicast(t->parms.iph.daddr)) {
cbb1e85f
DM		 751 struct flowi4 fl4;
752 struct rtable *rt;
753
b57708ad 754 rt = ip_route_output_gre(t->net, &fl4,
cbb1e85f
DM		 755 t->parms.iph.daddr,
756 t->parms.iph.saddr,
757 t->parms.o_key,
758 RT_TOS(t->parms.iph.tos),
759 t->parms.link);
b23dd4fe 760 if (IS_ERR(rt))
1da177e4 761 return -EADDRNOTAVAIL;
d8d1f30b 762 dev = rt->dst.dev;
1da177e4 763 ip_rt_put(rt);
51456b29 764 if (!__in_dev_get_rtnl(dev))
1da177e4
LT		 765 return -EADDRNOTAVAIL;
766 t->mlink = dev->ifindex;
e5ed6399 767 ip_mc_inc_group(__in_dev_get_rtnl(dev), t->parms.iph.daddr);
1da177e4
LT		 768 }
769 return 0;
770}
771
772static int ipgre_close(struct net_device *dev)
773{
2941a486 774 struct ip_tunnel *t = netdev_priv(dev);
b8c26a33 775
f97c1e0c 776 if (ipv4_is_multicast(t->parms.iph.daddr) && t->mlink) {
7fee0ca2 777 struct in_device *in_dev;
b57708ad 778 in_dev = inetdev_by_index(t->net, t->mlink);
8723e1b4 779 if (in_dev)
1da177e4 780 ip_mc_dec_group(in_dev, t->parms.iph.daddr);
1da177e4
LT		 781 }
782 return 0;
783}
1da177e4
LT		 784#endif
785
b8c26a33
SH		 786static const struct net_device_ops ipgre_netdev_ops = {
787 .ndo_init = ipgre_tunnel_init,
c5441932 788 .ndo_uninit = ip_tunnel_uninit,
b8c26a33
SH		 789#ifdef CONFIG_NET_IPGRE_BROADCAST
790 .ndo_open = ipgre_open,
791 .ndo_stop = ipgre_close,
792#endif
c5441932 793 .ndo_start_xmit = ipgre_xmit,
b8c26a33 794 .ndo_do_ioctl = ipgre_tunnel_ioctl,
c5441932
PS		 795 .ndo_change_mtu = ip_tunnel_change_mtu,
796 .ndo_get_stats64 = ip_tunnel_get_stats64,
1e99584b 797 .ndo_get_iflink = ip_tunnel_get_iflink,
b8c26a33
SH		 798};
799
6b78f16e
ED		 800#define GRE_FEATURES (NETIF_F_SG | \
801 NETIF_F_FRAGLIST | \
802 NETIF_F_HIGHDMA | \
803 NETIF_F_HW_CSUM)
804
1da177e4
LT		 805static void ipgre_tunnel_setup(struct net_device *dev)
806{
b8c26a33 807 dev->netdev_ops = &ipgre_netdev_ops;
5a455275 808 dev->type = ARPHRD_IPGRE;
c5441932
PS		 809 ip_tunnel_setup(dev, ipgre_net_id);
810}
1da177e4 811
c5441932
PS		 812static void __gre_tunnel_init(struct net_device *dev)
813{
814 struct ip_tunnel *tunnel;
4565e991 815 int t_hlen;
c5441932
PS		 816
817 tunnel = netdev_priv(dev);
4565e991 818 tunnel->tun_hlen = ip_gre_calc_hlen(tunnel->parms.o_flags);
c5441932
PS		 819 tunnel->parms.iph.protocol = IPPROTO_GRE;
820
4565e991
TH		 821 tunnel->hlen = tunnel->tun_hlen + tunnel->encap_hlen;
822
823 t_hlen = tunnel->hlen + sizeof(struct iphdr);
824
825 dev->needed_headroom = LL_MAX_HEADER + t_hlen + 4;
826 dev->mtu = ETH_DATA_LEN - t_hlen - 4;
6b78f16e 827
b57708ad 828 dev->features |= GRE_FEATURES;
6b78f16e 829 dev->hw_features |= GRE_FEATURES;
c5441932
PS		 830
831 if (!(tunnel->parms.o_flags & TUNNEL_SEQ)) {
832 /* TCP offload with GRE SEQ is not supported. */
833 dev->features |= NETIF_F_GSO_SOFTWARE;
834 dev->hw_features |= NETIF_F_GSO_SOFTWARE;
835 /* Can use a lockless transmit, unless we generate
836 * output sequences
837 */
838 dev->features |= NETIF_F_LLTX;
839 }
1da177e4
LT		 840}
841
842static int ipgre_tunnel_init(struct net_device *dev)
843{
c5441932
PS		 844 struct ip_tunnel *tunnel = netdev_priv(dev);
845 struct iphdr *iph = &tunnel->parms.iph;
1da177e4 846
c5441932 847 __gre_tunnel_init(dev);
1da177e4 848
c5441932
PS		 849 memcpy(dev->dev_addr, &iph->saddr, 4);
850 memcpy(dev->broadcast, &iph->daddr, 4);
1da177e4 851
c5441932 852 dev->flags = IFF_NOARP;
02875878 853 netif_keep_dst(dev);
c5441932 854 dev->addr_len = 4;
1da177e4 855
1da177e4 856 if (iph->daddr) {
1da177e4 857#ifdef CONFIG_NET_IPGRE_BROADCAST
f97c1e0c 858 if (ipv4_is_multicast(iph->daddr)) {
1da177e4
LT		 859 if (!iph->saddr)
860 return -EINVAL;
861 dev->flags = IFF_BROADCAST;
3b04ddde 862 dev->header_ops = &ipgre_header_ops;
1da177e4
LT		 863 }
864#endif
ee34c1eb 865 } else
6a5f44d7 866 dev->header_ops = &ipgre_header_ops;
1da177e4 867
c5441932 868 return ip_tunnel_init(dev);
1da177e4
LT		 869}
870
9f57c67c
PS		 871static const struct gre_protocol ipgre_protocol = {
872 .handler = gre_rcv,
873 .err_handler = gre_err,
1da177e4
LT		 874};
875
2c8c1e72 876static int __net_init ipgre_init_net(struct net *net)
59a4c759 877{
c5441932 878 return ip_tunnel_init_net(net, ipgre_net_id, &ipgre_link_ops, NULL);
59a4c759
PE		 879}
880
2c8c1e72 881static void __net_exit ipgre_exit_net(struct net *net)
59a4c759 882{
c5441932 883 struct ip_tunnel_net *itn = net_generic(net, ipgre_net_id);
6c742e71 884 ip_tunnel_delete_net(itn, &ipgre_link_ops);
59a4c759
PE		 885}
886
887static struct pernet_operations ipgre_net_ops = {
888 .init = ipgre_init_net,
889 .exit = ipgre_exit_net,
cfb8fbf2 890 .id = &ipgre_net_id,
c5441932 891 .size = sizeof(struct ip_tunnel_net),
59a4c759 892};
1da177e4 893
c19e654d
HX		 894static int ipgre_tunnel_validate(struct nlattr *tb[], struct nlattr *data[])
895{
896 __be16 flags;
897
898 if (!data)
899 return 0;
900
901 flags = 0;
902 if (data[IFLA_GRE_IFLAGS])
903 flags |= nla_get_be16(data[IFLA_GRE_IFLAGS]);
904 if (data[IFLA_GRE_OFLAGS])
905 flags |= nla_get_be16(data[IFLA_GRE_OFLAGS]);
906 if (flags & (GRE_VERSION|GRE_ROUTING))
907 return -EINVAL;
908
909 return 0;
910}
911
e1a80002
HX		 912static int ipgre_tap_validate(struct nlattr *tb[], struct nlattr *data[])
913{
914 __be32 daddr;
915
916 if (tb[IFLA_ADDRESS]) {
917 if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
918 return -EINVAL;
919 if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
920 return -EADDRNOTAVAIL;
921 }
922
923 if (!data)
924 goto out;
925
926 if (data[IFLA_GRE_REMOTE]) {
927 memcpy(&daddr, nla_data(data[IFLA_GRE_REMOTE]), 4);
928 if (!daddr)
929 return -EINVAL;
930 }
931
932out:
933 return ipgre_tunnel_validate(tb, data);
934}
935
2e15ea39
PS		 936static void ipgre_netlink_parms(struct net_device *dev,
937 struct nlattr *data[],
938 struct nlattr *tb[],
939 struct ip_tunnel_parm *parms)
c19e654d 940{
7bb82d92 941 memset(parms, 0, sizeof(*parms));
c19e654d
HX		 942
943 parms->iph.protocol = IPPROTO_GRE;
944
945 if (!data)
946 return;
947
948 if (data[IFLA_GRE_LINK])
949 parms->link = nla_get_u32(data[IFLA_GRE_LINK]);
950
951 if (data[IFLA_GRE_IFLAGS])
c5441932 952 parms->i_flags = gre_flags_to_tnl_flags(nla_get_be16(data[IFLA_GRE_IFLAGS]));
c19e654d
HX		 953
954 if (data[IFLA_GRE_OFLAGS])
c5441932 955 parms->o_flags = gre_flags_to_tnl_flags(nla_get_be16(data[IFLA_GRE_OFLAGS]));
c19e654d
HX		 956
957 if (data[IFLA_GRE_IKEY])
958 parms->i_key = nla_get_be32(data[IFLA_GRE_IKEY]);
959
960 if (data[IFLA_GRE_OKEY])
961 parms->o_key = nla_get_be32(data[IFLA_GRE_OKEY]);
962
963 if (data[IFLA_GRE_LOCAL])
67b61f6c 964 parms->iph.saddr = nla_get_in_addr(data[IFLA_GRE_LOCAL]);
c19e654d
HX		 965
966 if (data[IFLA_GRE_REMOTE])
67b61f6c 967 parms->iph.daddr = nla_get_in_addr(data[IFLA_GRE_REMOTE]);
c19e654d
HX		 968
969 if (data[IFLA_GRE_TTL])
970 parms->iph.ttl = nla_get_u8(data[IFLA_GRE_TTL]);
971
972 if (data[IFLA_GRE_TOS])
973 parms->iph.tos = nla_get_u8(data[IFLA_GRE_TOS]);
974
975 if (!data[IFLA_GRE_PMTUDISC] || nla_get_u8(data[IFLA_GRE_PMTUDISC]))
976 parms->iph.frag_off = htons(IP_DF);
2e15ea39
PS		 977
978 if (data[IFLA_GRE_COLLECT_METADATA]) {
979 struct ip_tunnel *t = netdev_priv(dev);
980
981 t->collect_md = true;
982 }
c19e654d
HX		 983}
984
4565e991
TH		 985/* This function returns true when ENCAP attributes are present in the nl msg */
986static bool ipgre_netlink_encap_parms(struct nlattr *data[],
987 struct ip_tunnel_encap *ipencap)
988{
989 bool ret = false;
990
991 memset(ipencap, 0, sizeof(*ipencap));
992
993 if (!data)
994 return ret;
995
996 if (data[IFLA_GRE_ENCAP_TYPE]) {
997 ret = true;
998 ipencap->type = nla_get_u16(data[IFLA_GRE_ENCAP_TYPE]);
999 }
1000
1001 if (data[IFLA_GRE_ENCAP_FLAGS]) {
1002 ret = true;
1003 ipencap->flags = nla_get_u16(data[IFLA_GRE_ENCAP_FLAGS]);
1004 }
1005
1006 if (data[IFLA_GRE_ENCAP_SPORT]) {
1007 ret = true;
3e97fa70 1008 ipencap->sport = nla_get_be16(data[IFLA_GRE_ENCAP_SPORT]);
4565e991
TH		 1009 }
1010
1011 if (data[IFLA_GRE_ENCAP_DPORT]) {
1012 ret = true;
3e97fa70 1013 ipencap->dport = nla_get_be16(data[IFLA_GRE_ENCAP_DPORT]);
4565e991
TH		 1014 }
1015
1016 return ret;
1017}
1018
c5441932 1019static int gre_tap_init(struct net_device *dev)
e1a80002 1020{
c5441932 1021 __gre_tunnel_init(dev);
bec94d43 1022 dev->priv_flags |= IFF_LIVE_ADDR_CHANGE;
e1a80002 1023
c5441932 1024 return ip_tunnel_init(dev);
e1a80002
HX		 1025}
1026
c5441932
PS		 1027static const struct net_device_ops gre_tap_netdev_ops = {
1028 .ndo_init = gre_tap_init,
1029 .ndo_uninit = ip_tunnel_uninit,
1030 .ndo_start_xmit = gre_tap_xmit,
b8c26a33
SH		 1031 .ndo_set_mac_address = eth_mac_addr,
1032 .ndo_validate_addr = eth_validate_addr,
c5441932
PS		 1033 .ndo_change_mtu = ip_tunnel_change_mtu,
1034 .ndo_get_stats64 = ip_tunnel_get_stats64,
1e99584b 1035 .ndo_get_iflink = ip_tunnel_get_iflink,
b8c26a33
SH		 1036};
1037
e1a80002
HX		 1038static void ipgre_tap_setup(struct net_device *dev)
1039{
e1a80002 1040 ether_setup(dev);
c5441932 1041 dev->netdev_ops = &gre_tap_netdev_ops;
f8c1b7ce 1042 dev->priv_flags |= IFF_LIVE_ADDR_CHANGE;
c5441932 1043 ip_tunnel_setup(dev, gre_tap_net_id);
e1a80002
HX		 1044}
1045
c5441932
PS		 1046static int ipgre_newlink(struct net *src_net, struct net_device *dev,
1047 struct nlattr *tb[], struct nlattr *data[])
c19e654d 1048{
c5441932 1049 struct ip_tunnel_parm p;
4565e991
TH		 1050 struct ip_tunnel_encap ipencap;
1051
1052 if (ipgre_netlink_encap_parms(data, &ipencap)) {
1053 struct ip_tunnel *t = netdev_priv(dev);
1054 int err = ip_tunnel_encap_setup(t, &ipencap);
1055
1056 if (err < 0)
1057 return err;
1058 }
c19e654d 1059
2e15ea39 1060 ipgre_netlink_parms(dev, data, tb, &p);
c5441932 1061 return ip_tunnel_newlink(dev, tb, &p);
c19e654d
HX		 1062}
1063
1064static int ipgre_changelink(struct net_device *dev, struct nlattr *tb[],
1065 struct nlattr *data[])
1066{
c19e654d 1067 struct ip_tunnel_parm p;
4565e991
TH		 1068 struct ip_tunnel_encap ipencap;
1069
1070 if (ipgre_netlink_encap_parms(data, &ipencap)) {
1071 struct ip_tunnel *t = netdev_priv(dev);
1072 int err = ip_tunnel_encap_setup(t, &ipencap);
1073
1074 if (err < 0)
1075 return err;
1076 }
c19e654d 1077
2e15ea39 1078 ipgre_netlink_parms(dev, data, tb, &p);
c5441932 1079 return ip_tunnel_changelink(dev, tb, &p);
c19e654d
HX		 1080}
1081
1082static size_t ipgre_get_size(const struct net_device *dev)
1083{
1084 return
1085 /* IFLA_GRE_LINK */
1086 nla_total_size(4) +
1087 /* IFLA_GRE_IFLAGS */
1088 nla_total_size(2) +
1089 /* IFLA_GRE_OFLAGS */
1090 nla_total_size(2) +
1091 /* IFLA_GRE_IKEY */
1092 nla_total_size(4) +
1093 /* IFLA_GRE_OKEY */
1094 nla_total_size(4) +
1095 /* IFLA_GRE_LOCAL */
1096 nla_total_size(4) +
1097 /* IFLA_GRE_REMOTE */
1098 nla_total_size(4) +
1099 /* IFLA_GRE_TTL */
1100 nla_total_size(1) +
1101 /* IFLA_GRE_TOS */
1102 nla_total_size(1) +
1103 /* IFLA_GRE_PMTUDISC */
1104 nla_total_size(1) +
4565e991
TH		 1105 /* IFLA_GRE_ENCAP_TYPE */
1106 nla_total_size(2) +
1107 /* IFLA_GRE_ENCAP_FLAGS */
1108 nla_total_size(2) +
1109 /* IFLA_GRE_ENCAP_SPORT */
1110 nla_total_size(2) +
1111 /* IFLA_GRE_ENCAP_DPORT */
1112 nla_total_size(2) +
2e15ea39
PS		 1113 /* IFLA_GRE_COLLECT_METADATA */
1114 nla_total_size(0) +
c19e654d
HX		 1115 0;
1116}
1117
1118static int ipgre_fill_info(struct sk_buff *skb, const struct net_device *dev)
1119{
1120 struct ip_tunnel *t = netdev_priv(dev);
1121 struct ip_tunnel_parm *p = &t->parms;
1122
f3756b79 1123 if (nla_put_u32(skb, IFLA_GRE_LINK, p->link) ||
c5441932
PS		 1124 nla_put_be16(skb, IFLA_GRE_IFLAGS, tnl_flags_to_gre_flags(p->i_flags)) ||
1125 nla_put_be16(skb, IFLA_GRE_OFLAGS, tnl_flags_to_gre_flags(p->o_flags)) ||
f3756b79
DM		 1126 nla_put_be32(skb, IFLA_GRE_IKEY, p->i_key) ||
1127 nla_put_be32(skb, IFLA_GRE_OKEY, p->o_key) ||
930345ea
JB		 1128 nla_put_in_addr(skb, IFLA_GRE_LOCAL, p->iph.saddr) ||
1129 nla_put_in_addr(skb, IFLA_GRE_REMOTE, p->iph.daddr) ||
f3756b79
DM		 1130 nla_put_u8(skb, IFLA_GRE_TTL, p->iph.ttl) ||
1131 nla_put_u8(skb, IFLA_GRE_TOS, p->iph.tos) ||
1132 nla_put_u8(skb, IFLA_GRE_PMTUDISC,
1133 !!(p->iph.frag_off & htons(IP_DF))))
1134 goto nla_put_failure;
4565e991
TH		 1135
1136 if (nla_put_u16(skb, IFLA_GRE_ENCAP_TYPE,
1137 t->encap.type) ||
3e97fa70
SD		 1138 nla_put_be16(skb, IFLA_GRE_ENCAP_SPORT,
1139 t->encap.sport) ||
1140 nla_put_be16(skb, IFLA_GRE_ENCAP_DPORT,
1141 t->encap.dport) ||
4565e991 1142 nla_put_u16(skb, IFLA_GRE_ENCAP_FLAGS,
e1b2cb65 1143 t->encap.flags))
4565e991
TH		 1144 goto nla_put_failure;
1145
2e15ea39
PS		 1146 if (t->collect_md) {
1147 if (nla_put_flag(skb, IFLA_GRE_COLLECT_METADATA))
1148 goto nla_put_failure;
1149 }
1150
c19e654d
HX		 1151 return 0;
1152
1153nla_put_failure:
1154 return -EMSGSIZE;
1155}
1156
1157static const struct nla_policy ipgre_policy[IFLA_GRE_MAX + 1] = {
1158 [IFLA_GRE_LINK] = { .type = NLA_U32 },
1159 [IFLA_GRE_IFLAGS] = { .type = NLA_U16 },
1160 [IFLA_GRE_OFLAGS] = { .type = NLA_U16 },
1161 [IFLA_GRE_IKEY] = { .type = NLA_U32 },
1162 [IFLA_GRE_OKEY] = { .type = NLA_U32 },
4d74f8ba
PM		 1163 [IFLA_GRE_LOCAL] = { .len = FIELD_SIZEOF(struct iphdr, saddr) },
1164 [IFLA_GRE_REMOTE] = { .len = FIELD_SIZEOF(struct iphdr, daddr) },
c19e654d
HX		 1165 [IFLA_GRE_TTL] = { .type = NLA_U8 },
1166 [IFLA_GRE_TOS] = { .type = NLA_U8 },
1167 [IFLA_GRE_PMTUDISC] = { .type = NLA_U8 },
4565e991
TH		 1168 [IFLA_GRE_ENCAP_TYPE] = { .type = NLA_U16 },
1169 [IFLA_GRE_ENCAP_FLAGS] = { .type = NLA_U16 },
1170 [IFLA_GRE_ENCAP_SPORT] = { .type = NLA_U16 },
1171 [IFLA_GRE_ENCAP_DPORT] = { .type = NLA_U16 },
2e15ea39 1172 [IFLA_GRE_COLLECT_METADATA] = { .type = NLA_FLAG },
c19e654d
HX		 1173};
1174
1175static struct rtnl_link_ops ipgre_link_ops __read_mostly = {
1176 .kind = "gre",
1177 .maxtype = IFLA_GRE_MAX,
1178 .policy = ipgre_policy,
1179 .priv_size = sizeof(struct ip_tunnel),
1180 .setup = ipgre_tunnel_setup,
1181 .validate = ipgre_tunnel_validate,
1182 .newlink = ipgre_newlink,
1183 .changelink = ipgre_changelink,
c5441932 1184 .dellink = ip_tunnel_dellink,
c19e654d
HX		 1185 .get_size = ipgre_get_size,
1186 .fill_info = ipgre_fill_info,
1728d4fa 1187 .get_link_net = ip_tunnel_get_link_net,
c19e654d
HX		 1188};
1189
e1a80002
HX		 1190static struct rtnl_link_ops ipgre_tap_ops __read_mostly = {
1191 .kind = "gretap",
1192 .maxtype = IFLA_GRE_MAX,
1193 .policy = ipgre_policy,
1194 .priv_size = sizeof(struct ip_tunnel),
1195 .setup = ipgre_tap_setup,
1196 .validate = ipgre_tap_validate,
1197 .newlink = ipgre_newlink,
1198 .changelink = ipgre_changelink,
c5441932 1199 .dellink = ip_tunnel_dellink,
e1a80002
HX		 1200 .get_size = ipgre_get_size,
1201 .fill_info = ipgre_fill_info,
1728d4fa 1202 .get_link_net = ip_tunnel_get_link_net,
e1a80002
HX		 1203};
1204
b2acd1dc
PS		 1205struct net_device *gretap_fb_dev_create(struct net *net, const char *name,
1206 u8 name_assign_type)
1207{
1208 struct nlattr *tb[IFLA_MAX + 1];
1209 struct net_device *dev;
1210 struct ip_tunnel *t;
1211 int err;
1212
1213 memset(&tb, 0, sizeof(tb));
1214
1215 dev = rtnl_create_link(net, name, name_assign_type,
1216 &ipgre_tap_ops, tb);
1217 if (IS_ERR(dev))
1218 return dev;
1219
1220 /* Configure flow based GRE device. */
1221 t = netdev_priv(dev);
1222 t->collect_md = true;
1223
1224 err = ipgre_newlink(net, dev, tb, NULL);
1225 if (err < 0)
1226 goto out;
1227 return dev;
1228out:
1229 free_netdev(dev);
1230 return ERR_PTR(err);
1231}
1232EXPORT_SYMBOL_GPL(gretap_fb_dev_create);
1233
c5441932
PS		 1234static int __net_init ipgre_tap_init_net(struct net *net)
1235{
2e15ea39 1236 return ip_tunnel_init_net(net, gre_tap_net_id, &ipgre_tap_ops, "gretap0");
c5441932
PS		 1237}
1238
1239static void __net_exit ipgre_tap_exit_net(struct net *net)
1240{
1241 struct ip_tunnel_net *itn = net_generic(net, gre_tap_net_id);
6c742e71 1242 ip_tunnel_delete_net(itn, &ipgre_tap_ops);
c5441932
PS		 1243}
1244
1245static struct pernet_operations ipgre_tap_net_ops = {
1246 .init = ipgre_tap_init_net,
1247 .exit = ipgre_tap_exit_net,
1248 .id = &gre_tap_net_id,
1249 .size = sizeof(struct ip_tunnel_net),
1250};
1da177e4
LT		 1251
1252static int __init ipgre_init(void)
1253{
1254 int err;
1255
058bd4d2 1256 pr_info("GRE over IPv4 tunneling driver\n");
1da177e4 1257
cfb8fbf2 1258 err = register_pernet_device(&ipgre_net_ops);
59a4c759 1259 if (err < 0)
c2892f02
AD		 1260 return err;
1261
c5441932
PS		 1262 err = register_pernet_device(&ipgre_tap_net_ops);
1263 if (err < 0)
1264 goto pnet_tap_faied;
1265
9f57c67c 1266 err = gre_add_protocol(&ipgre_protocol, GREPROTO_CISCO);
c2892f02 1267 if (err < 0) {
058bd4d2 1268 pr_info("%s: can't add protocol\n", __func__);
c2892f02
AD		 1269 goto add_proto_failed;
1270 }
7daa0004 1271
c19e654d
HX		 1272 err = rtnl_link_register(&ipgre_link_ops);
1273 if (err < 0)
1274 goto rtnl_link_failed;
1275
e1a80002
HX		 1276 err = rtnl_link_register(&ipgre_tap_ops);
1277 if (err < 0)
1278 goto tap_ops_failed;
1279
c5441932 1280 return 0;
c19e654d 1281
e1a80002
HX		 1282tap_ops_failed:
1283 rtnl_link_unregister(&ipgre_link_ops);
c19e654d 1284rtnl_link_failed:
9f57c67c 1285 gre_del_protocol(&ipgre_protocol, GREPROTO_CISCO);
c2892f02 1286add_proto_failed:
c5441932
PS		 1287 unregister_pernet_device(&ipgre_tap_net_ops);
1288pnet_tap_faied:
c2892f02 1289 unregister_pernet_device(&ipgre_net_ops);
c5441932 1290 return err;
1da177e4
LT		 1291}
1292
db44575f 1293static void __exit ipgre_fini(void)
1da177e4 1294{
e1a80002 1295 rtnl_link_unregister(&ipgre_tap_ops);
c19e654d 1296 rtnl_link_unregister(&ipgre_link_ops);
9f57c67c 1297 gre_del_protocol(&ipgre_protocol, GREPROTO_CISCO);
c5441932 1298 unregister_pernet_device(&ipgre_tap_net_ops);
c2892f02 1299 unregister_pernet_device(&ipgre_net_ops);
1da177e4
LT		 1300}
1301
1302module_init(ipgre_init);
1303module_exit(ipgre_fini);
1304MODULE_LICENSE("GPL");
4d74f8ba
PM		 1305MODULE_ALIAS_RTNL_LINK("gre");
1306MODULE_ALIAS_RTNL_LINK("gretap");
8909c9ad 1307MODULE_ALIAS_NETDEV("gre0");
c5441932 1308MODULE_ALIAS_NETDEV("gretap0");
Linux 6.x block layer and io_uring tree(s)