projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branch 'for-linus' into for-next
[deliverable/linux.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 402 if (tunnel->collect_md) {
c29a70d2
PS		 403 __be16 flags;
404 __be64 tun_id;
2e15ea39 405
c29a70d2
PS		 406 flags = tpi->flags & (TUNNEL_CSUM | TUNNEL_KEY);
407 tun_id = key_to_tunnel_id(tpi->key);
408 tun_dst = ip_tun_rx_dst(skb, flags, tun_id, 0);
2e15ea39
PS		 409 if (!tun_dst)
410 return PACKET_REJECT;
2e15ea39
PS		 411 }
412
413 ip_tunnel_rcv(tunnel, skb, tpi, tun_dst, log_ecn_error);
bda7bb46 414 return PACKET_RCVD;
1da177e4 415 }
bda7bb46 416 return PACKET_REJECT;
1da177e4
LT		 417}
418
9f57c67c
PS		 419static int gre_rcv(struct sk_buff *skb)
420{
421 struct tnl_ptk_info tpi;
422 bool csum_err = false;
423
424#ifdef CONFIG_NET_IPGRE_BROADCAST
425 if (ipv4_is_multicast(ip_hdr(skb)->daddr)) {
426 /* Looped back packet, drop it! */
427 if (rt_is_output_route(skb_rtable(skb)))
428 goto drop;
429 }
430#endif
431
432 if (parse_gre_header(skb, &tpi, &csum_err) < 0)
433 goto drop;
434
435 if (ipgre_rcv(skb, &tpi) == PACKET_RCVD)
436 return 0;
437
438 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, 0);
439drop:
440 kfree_skb(skb);
441 return 0;
442}
443
2e15ea39
PS		 444static void build_header(struct sk_buff *skb, int hdr_len, __be16 flags,
445 __be16 proto, __be32 key, __be32 seq)
446{
447 struct gre_base_hdr *greh;
448
449 skb_push(skb, hdr_len);
450
451 skb_reset_transport_header(skb);
452 greh = (struct gre_base_hdr *)skb->data;
453 greh->flags = tnl_flags_to_gre_flags(flags);
454 greh->protocol = proto;
455
456 if (flags & (TUNNEL_KEY | TUNNEL_CSUM | TUNNEL_SEQ)) {
457 __be32 *ptr = (__be32 *)(((u8 *)greh) + hdr_len - 4);
458
459 if (flags & TUNNEL_SEQ) {
460 *ptr = seq;
461 ptr--;
462 }
463 if (flags & TUNNEL_KEY) {
464 *ptr = key;
465 ptr--;
466 }
467 if (flags & TUNNEL_CSUM &&
468 !(skb_shinfo(skb)->gso_type &
469 (SKB_GSO_GRE | SKB_GSO_GRE_CSUM))) {
470 *ptr = 0;
471 *(__sum16 *)ptr = csum_fold(skb_checksum(skb, 0,
472 skb->len, 0));
473 }
474 }
475}
476
c5441932
PS		 477static void __gre_xmit(struct sk_buff *skb, struct net_device *dev,
478 const struct iphdr *tnl_params,
479 __be16 proto)
480{
481 struct ip_tunnel *tunnel = netdev_priv(dev);
1da177e4 482
c5441932
PS		 483 if (tunnel->parms.o_flags & TUNNEL_SEQ)
484 tunnel->o_seqno++;
1da177e4 485
c5441932 486 /* Push GRE header. */
2e15ea39
PS		 487 build_header(skb, tunnel->tun_hlen, tunnel->parms.o_flags,
488 proto, tunnel->parms.o_key, htonl(tunnel->o_seqno));
54bc9bac 489
2e15ea39 490 skb_set_inner_protocol(skb, proto);
bf3d6a8f 491 ip_tunnel_xmit(skb, dev, tnl_params, tnl_params->protocol);
c5441932 492}
1da177e4 493
b2acd1dc
PS		 494static struct sk_buff *gre_handle_offloads(struct sk_buff *skb,
495 bool csum)
496{
497 return iptunnel_handle_offloads(skb, csum,
498 csum ? SKB_GSO_GRE_CSUM : SKB_GSO_GRE);
499}
500
2e15ea39
PS		 501static void gre_fb_xmit(struct sk_buff *skb, struct net_device *dev)
502{
503 struct ip_tunnel_info *tun_info;
504 struct net *net = dev_net(dev);
505 const struct ip_tunnel_key *key;
506 struct flowi4 fl;
507 struct rtable *rt;
508 int min_headroom;
509 int tunnel_hlen;
510 __be16 df, flags;
511 int err;
512
61adedf3 513 tun_info = skb_tunnel_info(skb);
7f9562a1
JB		 514 if (unlikely(!tun_info || !(tun_info->mode & IP_TUNNEL_INFO_TX) ||
515 ip_tunnel_info_af(tun_info) != AF_INET))
2e15ea39
PS		 516 goto err_free_skb;
517
518 key = &tun_info->key;
519 memset(&fl, 0, sizeof(fl));
c1ea5d67
JB		 520 fl.daddr = key->u.ipv4.dst;
521 fl.saddr = key->u.ipv4.src;
7c383fb2 522 fl.flowi4_tos = RT_TOS(key->tos);
2e15ea39
PS		 523 fl.flowi4_mark = skb->mark;
524 fl.flowi4_proto = IPPROTO_GRE;
525
526 rt = ip_route_output_key(net, &fl);
527 if (IS_ERR(rt))
528 goto err_free_skb;
529
530 tunnel_hlen = ip_gre_calc_hlen(key->tun_flags);
531
532 min_headroom = LL_RESERVED_SPACE(rt->dst.dev) + rt->dst.header_len
533 + tunnel_hlen + sizeof(struct iphdr);
534 if (skb_headroom(skb) < min_headroom || skb_header_cloned(skb)) {
535 int head_delta = SKB_DATA_ALIGN(min_headroom -
536 skb_headroom(skb) +
537 16);
538 err = pskb_expand_head(skb, max_t(int, head_delta, 0),
539 0, GFP_ATOMIC);
540 if (unlikely(err))
541 goto err_free_rt;
542 }
543
544 /* Push Tunnel header. */
545 skb = gre_handle_offloads(skb, !!(tun_info->key.tun_flags & TUNNEL_CSUM));
546 if (IS_ERR(skb)) {
547 skb = NULL;
548 goto err_free_rt;
549 }
550
551 flags = tun_info->key.tun_flags & (TUNNEL_CSUM | TUNNEL_KEY);
552 build_header(skb, tunnel_hlen, flags, htons(ETH_P_TEB),
553 tunnel_id_to_key(tun_info->key.tun_id), 0);
554
555 df = key->tun_flags & TUNNEL_DONT_FRAGMENT ? htons(IP_DF) : 0;
556 err = iptunnel_xmit(skb->sk, rt, skb, fl.saddr,
c1ea5d67 557 key->u.ipv4.dst, IPPROTO_GRE,
7c383fb2 558 key->tos, key->ttl, df, false);
2e15ea39
PS		 559 iptunnel_xmit_stats(err, &dev->stats, dev->tstats);
560 return;
561
562err_free_rt:
563 ip_rt_put(rt);
564err_free_skb:
565 kfree_skb(skb);
566 dev->stats.tx_dropped++;
567}
568
c5441932
PS		 569static netdev_tx_t ipgre_xmit(struct sk_buff *skb,
570 struct net_device *dev)
571{
572 struct ip_tunnel *tunnel = netdev_priv(dev);
573 const struct iphdr *tnl_params;
1da177e4 574
2e15ea39
PS		 575 if (tunnel->collect_md) {
576 gre_fb_xmit(skb, dev);
577 return NETDEV_TX_OK;
578 }
579
c5441932
PS		 580 if (dev->header_ops) {
581 /* Need space for new headers */
582 if (skb_cow_head(skb, dev->needed_headroom -
2bac7cb3 583 (tunnel->hlen + sizeof(struct iphdr))))
c5441932 584 goto free_skb;
1da177e4 585
c5441932 586 tnl_params = (const struct iphdr *)skb->data;
1da177e4 587
c5441932
PS		 588 /* Pull skb since ip_tunnel_xmit() needs skb->data pointing
589 * to gre header.
590 */
591 skb_pull(skb, tunnel->hlen + sizeof(struct iphdr));
8a0033a9 592 skb_reset_mac_header(skb);
c5441932
PS		 593 } else {
594 if (skb_cow_head(skb, dev->needed_headroom))
595 goto free_skb;
1da177e4 596
c5441932 597 tnl_params = &tunnel->parms.iph;
1da177e4
LT		 598 }
599
8a0033a9
TT		 600 skb = gre_handle_offloads(skb, !!(tunnel->parms.o_flags&TUNNEL_CSUM));
601 if (IS_ERR(skb))
602 goto out;
603
c5441932 604 __gre_xmit(skb, dev, tnl_params, skb->protocol);
6ed10654 605 return NETDEV_TX_OK;
1da177e4 606
c5441932 607free_skb:
3acfa1e7 608 kfree_skb(skb);
c5441932
PS		 609out:
610 dev->stats.tx_dropped++;
6ed10654 611 return NETDEV_TX_OK;
1da177e4
LT		 612}
613
c5441932
PS		 614static netdev_tx_t gre_tap_xmit(struct sk_buff *skb,
615 struct net_device *dev)
ee34c1eb 616{
c5441932 617 struct ip_tunnel *tunnel = netdev_priv(dev);
ee34c1eb 618
2e15ea39
PS		 619 if (tunnel->collect_md) {
620 gre_fb_xmit(skb, dev);
621 return NETDEV_TX_OK;
622 }
623
45f2e997 624 skb = gre_handle_offloads(skb, !!(tunnel->parms.o_flags&TUNNEL_CSUM));
c5441932
PS		 625 if (IS_ERR(skb))
626 goto out;
ee34c1eb 627
c5441932
PS		 628 if (skb_cow_head(skb, dev->needed_headroom))
629 goto free_skb;
42aa9162 630
c5441932 631 __gre_xmit(skb, dev, &tunnel->parms.iph, htons(ETH_P_TEB));
c5441932 632 return NETDEV_TX_OK;
ee34c1eb 633
c5441932 634free_skb:
3acfa1e7 635 kfree_skb(skb);
c5441932
PS		 636out:
637 dev->stats.tx_dropped++;
638 return NETDEV_TX_OK;
ee34c1eb
MS		 639}
640
c5441932
PS		 641static int ipgre_tunnel_ioctl(struct net_device *dev,
642 struct ifreq *ifr, int cmd)
1da177e4 643{
4565e991 644 int err;
1da177e4 645 struct ip_tunnel_parm p;
1da177e4 646
c5441932
PS		 647 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
648 return -EFAULT;
6c734fb8
CW		 649 if (cmd == SIOCADDTUNNEL || cmd == SIOCCHGTUNNEL) {
650 if (p.iph.version != 4 || p.iph.protocol != IPPROTO_GRE ||
651 p.iph.ihl != 5 || (p.iph.frag_off&htons(~IP_DF)) ||
652 ((p.i_flags|p.o_flags)&(GRE_VERSION|GRE_ROUTING)))
653 return -EINVAL;
1da177e4 654 }
c5441932
PS		 655 p.i_flags = gre_flags_to_tnl_flags(p.i_flags);
656 p.o_flags = gre_flags_to_tnl_flags(p.o_flags);
1da177e4 657
c5441932
PS		 658 err = ip_tunnel_ioctl(dev, &p, cmd);
659 if (err)
660 return err;
1da177e4 661
c5441932
PS		 662 p.i_flags = tnl_flags_to_gre_flags(p.i_flags);
663 p.o_flags = tnl_flags_to_gre_flags(p.o_flags);
664
665 if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p)))
666 return -EFAULT;
1da177e4
LT		 667 return 0;
668}
669
1da177e4
LT		 670/* Nice toy. Unfortunately, useless in real life :-)
671 It allows to construct virtual multiprotocol broadcast "LAN"
672 over the Internet, provided multicast routing is tuned.
673
674
675 I have no idea was this bicycle invented before me,
676 so that I had to set ARPHRD_IPGRE to a random value.
677 I have an impression, that Cisco could make something similar,
678 but this feature is apparently missing in IOS<=11.2(8).
e905a9ed 679
1da177e4
LT		 680 I set up 10.66.66/24 and fec0:6666:6666::0/96 as virtual networks
681 with broadcast 224.66.66.66. If you have access to mbone, play with me :-)
682
683 ping -t 255 224.66.66.66
684
685 If nobody answers, mbone does not work.
686
687 ip tunnel add Universe mode gre remote 224.66.66.66 local <Your_real_addr> ttl 255
688 ip addr add 10.66.66.<somewhat>/24 dev Universe
689 ifconfig Universe up
690 ifconfig Universe add fe80::<Your_real_addr>/10
691 ifconfig Universe add fec0:6666:6666::<Your_real_addr>/96
692 ftp 10.66.66.66
693 ...
694 ftp fec0:6666:6666::193.233.7.65
695 ...
1da177e4 696 */
3b04ddde
SH		 697static int ipgre_header(struct sk_buff *skb, struct net_device *dev,
698 unsigned short type,
1507850b 699 const void *daddr, const void *saddr, unsigned int len)
1da177e4 700{
2941a486 701 struct ip_tunnel *t = netdev_priv(dev);
c5441932
PS		 702 struct iphdr *iph;
703 struct gre_base_hdr *greh;
1da177e4 704
c5441932
PS		 705 iph = (struct iphdr *)skb_push(skb, t->hlen + sizeof(*iph));
706 greh = (struct gre_base_hdr *)(iph+1);
707 greh->flags = tnl_flags_to_gre_flags(t->parms.o_flags);
708 greh->protocol = htons(type);
1da177e4 709
c5441932 710 memcpy(iph, &t->parms.iph, sizeof(struct iphdr));
e905a9ed 711
c5441932 712 /* Set the source hardware address. */
1da177e4
LT		 713 if (saddr)
714 memcpy(&iph->saddr, saddr, 4);
6d55cb91 715 if (daddr)
1da177e4 716 memcpy(&iph->daddr, daddr, 4);
6d55cb91 717 if (iph->daddr)
77a482bd 718 return t->hlen + sizeof(*iph);
e905a9ed 719
c5441932 720 return -(t->hlen + sizeof(*iph));
1da177e4
LT		 721}
722
6a5f44d7
TT		 723static int ipgre_header_parse(const struct sk_buff *skb, unsigned char *haddr)
724{
b71d1d42 725 const struct iphdr *iph = (const struct iphdr *) skb_mac_header(skb);
6a5f44d7
TT		 726 memcpy(haddr, &iph->saddr, 4);
727 return 4;
728}
729
3b04ddde
SH		 730static const struct header_ops ipgre_header_ops = {
731 .create = ipgre_header,
6a5f44d7 732 .parse = ipgre_header_parse,
3b04ddde
SH		 733};
734
6a5f44d7 735#ifdef CONFIG_NET_IPGRE_BROADCAST
1da177e4
LT		 736static int ipgre_open(struct net_device *dev)
737{
2941a486 738 struct ip_tunnel *t = netdev_priv(dev);
1da177e4 739
f97c1e0c 740 if (ipv4_is_multicast(t->parms.iph.daddr)) {
cbb1e85f
DM		 741 struct flowi4 fl4;
742 struct rtable *rt;
743
b57708ad 744 rt = ip_route_output_gre(t->net, &fl4,
cbb1e85f
DM		 745 t->parms.iph.daddr,
746 t->parms.iph.saddr,
747 t->parms.o_key,
748 RT_TOS(t->parms.iph.tos),
749 t->parms.link);
b23dd4fe 750 if (IS_ERR(rt))
1da177e4 751 return -EADDRNOTAVAIL;
d8d1f30b 752 dev = rt->dst.dev;
1da177e4 753 ip_rt_put(rt);
51456b29 754 if (!__in_dev_get_rtnl(dev))
1da177e4
LT		 755 return -EADDRNOTAVAIL;
756 t->mlink = dev->ifindex;
e5ed6399 757 ip_mc_inc_group(__in_dev_get_rtnl(dev), t->parms.iph.daddr);
1da177e4
LT		 758 }
759 return 0;
760}
761
762static int ipgre_close(struct net_device *dev)
763{
2941a486 764 struct ip_tunnel *t = netdev_priv(dev);
b8c26a33 765
f97c1e0c 766 if (ipv4_is_multicast(t->parms.iph.daddr) && t->mlink) {
7fee0ca2 767 struct in_device *in_dev;
b57708ad 768 in_dev = inetdev_by_index(t->net, t->mlink);
8723e1b4 769 if (in_dev)
1da177e4 770 ip_mc_dec_group(in_dev, t->parms.iph.daddr);
1da177e4
LT		 771 }
772 return 0;
773}
1da177e4
LT		 774#endif
775
b8c26a33
SH		 776static const struct net_device_ops ipgre_netdev_ops = {
777 .ndo_init = ipgre_tunnel_init,
c5441932 778 .ndo_uninit = ip_tunnel_uninit,
b8c26a33
SH		 779#ifdef CONFIG_NET_IPGRE_BROADCAST
780 .ndo_open = ipgre_open,
781 .ndo_stop = ipgre_close,
782#endif
c5441932 783 .ndo_start_xmit = ipgre_xmit,
b8c26a33 784 .ndo_do_ioctl = ipgre_tunnel_ioctl,
c5441932
PS		 785 .ndo_change_mtu = ip_tunnel_change_mtu,
786 .ndo_get_stats64 = ip_tunnel_get_stats64,
1e99584b 787 .ndo_get_iflink = ip_tunnel_get_iflink,
b8c26a33
SH		 788};
789
6b78f16e
ED		 790#define GRE_FEATURES (NETIF_F_SG | \
791 NETIF_F_FRAGLIST | \
792 NETIF_F_HIGHDMA | \
793 NETIF_F_HW_CSUM)
794
1da177e4
LT		 795static void ipgre_tunnel_setup(struct net_device *dev)
796{
b8c26a33 797 dev->netdev_ops = &ipgre_netdev_ops;
5a455275 798 dev->type = ARPHRD_IPGRE;
c5441932
PS		 799 ip_tunnel_setup(dev, ipgre_net_id);
800}
1da177e4 801
c5441932
PS		 802static void __gre_tunnel_init(struct net_device *dev)
803{
804 struct ip_tunnel *tunnel;
4565e991 805 int t_hlen;
c5441932
PS		 806
807 tunnel = netdev_priv(dev);
4565e991 808 tunnel->tun_hlen = ip_gre_calc_hlen(tunnel->parms.o_flags);
c5441932
PS		 809 tunnel->parms.iph.protocol = IPPROTO_GRE;
810
4565e991
TH		 811 tunnel->hlen = tunnel->tun_hlen + tunnel->encap_hlen;
812
813 t_hlen = tunnel->hlen + sizeof(struct iphdr);
814
815 dev->needed_headroom = LL_MAX_HEADER + t_hlen + 4;
816 dev->mtu = ETH_DATA_LEN - t_hlen - 4;
6b78f16e 817
b57708ad 818 dev->features |= GRE_FEATURES;
6b78f16e 819 dev->hw_features |= GRE_FEATURES;
c5441932
PS		 820
821 if (!(tunnel->parms.o_flags & TUNNEL_SEQ)) {
822 /* TCP offload with GRE SEQ is not supported. */
823 dev->features |= NETIF_F_GSO_SOFTWARE;
824 dev->hw_features |= NETIF_F_GSO_SOFTWARE;
825 /* Can use a lockless transmit, unless we generate
826 * output sequences
827 */
828 dev->features |= NETIF_F_LLTX;
829 }
1da177e4
LT		 830}
831
832static int ipgre_tunnel_init(struct net_device *dev)
833{
c5441932
PS		 834 struct ip_tunnel *tunnel = netdev_priv(dev);
835 struct iphdr *iph = &tunnel->parms.iph;
1da177e4 836
c5441932 837 __gre_tunnel_init(dev);
1da177e4 838
c5441932
PS		 839 memcpy(dev->dev_addr, &iph->saddr, 4);
840 memcpy(dev->broadcast, &iph->daddr, 4);
1da177e4 841
c5441932 842 dev->flags = IFF_NOARP;
02875878 843 netif_keep_dst(dev);
c5441932 844 dev->addr_len = 4;
1da177e4 845
1da177e4 846 if (iph->daddr) {
1da177e4 847#ifdef CONFIG_NET_IPGRE_BROADCAST
f97c1e0c 848 if (ipv4_is_multicast(iph->daddr)) {
1da177e4
LT		 849 if (!iph->saddr)
850 return -EINVAL;
851 dev->flags = IFF_BROADCAST;
3b04ddde 852 dev->header_ops = &ipgre_header_ops;
1da177e4
LT		 853 }
854#endif
ee34c1eb 855 } else
6a5f44d7 856 dev->header_ops = &ipgre_header_ops;
1da177e4 857
c5441932 858 return ip_tunnel_init(dev);
1da177e4
LT		 859}
860
9f57c67c
PS		 861static const struct gre_protocol ipgre_protocol = {
862 .handler = gre_rcv,
863 .err_handler = gre_err,
1da177e4
LT		 864};
865
2c8c1e72 866static int __net_init ipgre_init_net(struct net *net)
59a4c759 867{
c5441932 868 return ip_tunnel_init_net(net, ipgre_net_id, &ipgre_link_ops, NULL);
59a4c759
PE		 869}
870
2c8c1e72 871static void __net_exit ipgre_exit_net(struct net *net)
59a4c759 872{
c5441932 873 struct ip_tunnel_net *itn = net_generic(net, ipgre_net_id);
6c742e71 874 ip_tunnel_delete_net(itn, &ipgre_link_ops);
59a4c759
PE		 875}
876
877static struct pernet_operations ipgre_net_ops = {
878 .init = ipgre_init_net,
879 .exit = ipgre_exit_net,
cfb8fbf2 880 .id = &ipgre_net_id,
c5441932 881 .size = sizeof(struct ip_tunnel_net),
59a4c759 882};
1da177e4 883
c19e654d
HX		 884static int ipgre_tunnel_validate(struct nlattr *tb[], struct nlattr *data[])
885{
886 __be16 flags;
887
888 if (!data)
889 return 0;
890
891 flags = 0;
892 if (data[IFLA_GRE_IFLAGS])
893 flags |= nla_get_be16(data[IFLA_GRE_IFLAGS]);
894 if (data[IFLA_GRE_OFLAGS])
895 flags |= nla_get_be16(data[IFLA_GRE_OFLAGS]);
896 if (flags & (GRE_VERSION|GRE_ROUTING))
897 return -EINVAL;
898
899 return 0;
900}
901
e1a80002
HX		 902static int ipgre_tap_validate(struct nlattr *tb[], struct nlattr *data[])
903{
904 __be32 daddr;
905
906 if (tb[IFLA_ADDRESS]) {
907 if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
908 return -EINVAL;
909 if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
910 return -EADDRNOTAVAIL;
911 }
912
913 if (!data)
914 goto out;
915
916 if (data[IFLA_GRE_REMOTE]) {
917 memcpy(&daddr, nla_data(data[IFLA_GRE_REMOTE]), 4);
918 if (!daddr)
919 return -EINVAL;
920 }
921
922out:
923 return ipgre_tunnel_validate(tb, data);
924}
925
2e15ea39
PS		 926static void ipgre_netlink_parms(struct net_device *dev,
927 struct nlattr *data[],
928 struct nlattr *tb[],
929 struct ip_tunnel_parm *parms)
c19e654d 930{
7bb82d92 931 memset(parms, 0, sizeof(*parms));
c19e654d
HX		 932
933 parms->iph.protocol = IPPROTO_GRE;
934
935 if (!data)
936 return;
937
938 if (data[IFLA_GRE_LINK])
939 parms->link = nla_get_u32(data[IFLA_GRE_LINK]);
940
941 if (data[IFLA_GRE_IFLAGS])
c5441932 942 parms->i_flags = gre_flags_to_tnl_flags(nla_get_be16(data[IFLA_GRE_IFLAGS]));
c19e654d
HX		 943
944 if (data[IFLA_GRE_OFLAGS])
c5441932 945 parms->o_flags = gre_flags_to_tnl_flags(nla_get_be16(data[IFLA_GRE_OFLAGS]));
c19e654d
HX		 946
947 if (data[IFLA_GRE_IKEY])
948 parms->i_key = nla_get_be32(data[IFLA_GRE_IKEY]);
949
950 if (data[IFLA_GRE_OKEY])
951 parms->o_key = nla_get_be32(data[IFLA_GRE_OKEY]);
952
953 if (data[IFLA_GRE_LOCAL])
67b61f6c 954 parms->iph.saddr = nla_get_in_addr(data[IFLA_GRE_LOCAL]);
c19e654d
HX		 955
956 if (data[IFLA_GRE_REMOTE])
67b61f6c 957 parms->iph.daddr = nla_get_in_addr(data[IFLA_GRE_REMOTE]);
c19e654d
HX		 958
959 if (data[IFLA_GRE_TTL])
960 parms->iph.ttl = nla_get_u8(data[IFLA_GRE_TTL]);
961
962 if (data[IFLA_GRE_TOS])
963 parms->iph.tos = nla_get_u8(data[IFLA_GRE_TOS]);
964
965 if (!data[IFLA_GRE_PMTUDISC] || nla_get_u8(data[IFLA_GRE_PMTUDISC]))
966 parms->iph.frag_off = htons(IP_DF);
2e15ea39
PS		 967
968 if (data[IFLA_GRE_COLLECT_METADATA]) {
969 struct ip_tunnel *t = netdev_priv(dev);
970
971 t->collect_md = true;
972 }
c19e654d
HX		 973}
974
4565e991
TH		 975/* This function returns true when ENCAP attributes are present in the nl msg */
976static bool ipgre_netlink_encap_parms(struct nlattr *data[],
977 struct ip_tunnel_encap *ipencap)
978{
979 bool ret = false;
980
981 memset(ipencap, 0, sizeof(*ipencap));
982
983 if (!data)
984 return ret;
985
986 if (data[IFLA_GRE_ENCAP_TYPE]) {
987 ret = true;
988 ipencap->type = nla_get_u16(data[IFLA_GRE_ENCAP_TYPE]);
989 }
990
991 if (data[IFLA_GRE_ENCAP_FLAGS]) {
992 ret = true;
993 ipencap->flags = nla_get_u16(data[IFLA_GRE_ENCAP_FLAGS]);
994 }
995
996 if (data[IFLA_GRE_ENCAP_SPORT]) {
997 ret = true;
3e97fa70 998 ipencap->sport = nla_get_be16(data[IFLA_GRE_ENCAP_SPORT]);
4565e991
TH		 999 }
1000
1001 if (data[IFLA_GRE_ENCAP_DPORT]) {
1002 ret = true;
3e97fa70 1003 ipencap->dport = nla_get_be16(data[IFLA_GRE_ENCAP_DPORT]);
4565e991
TH		 1004 }
1005
1006 return ret;
1007}
1008
c5441932 1009static int gre_tap_init(struct net_device *dev)
e1a80002 1010{
c5441932 1011 __gre_tunnel_init(dev);
bec94d43 1012 dev->priv_flags |= IFF_LIVE_ADDR_CHANGE;
e1a80002 1013
c5441932 1014 return ip_tunnel_init(dev);
e1a80002
HX		 1015}
1016
c5441932
PS		 1017static const struct net_device_ops gre_tap_netdev_ops = {
1018 .ndo_init = gre_tap_init,
1019 .ndo_uninit = ip_tunnel_uninit,
1020 .ndo_start_xmit = gre_tap_xmit,
b8c26a33
SH		 1021 .ndo_set_mac_address = eth_mac_addr,
1022 .ndo_validate_addr = eth_validate_addr,
c5441932
PS		 1023 .ndo_change_mtu = ip_tunnel_change_mtu,
1024 .ndo_get_stats64 = ip_tunnel_get_stats64,
1e99584b 1025 .ndo_get_iflink = ip_tunnel_get_iflink,
b8c26a33
SH		 1026};
1027
e1a80002
HX		 1028static void ipgre_tap_setup(struct net_device *dev)
1029{
e1a80002 1030 ether_setup(dev);
c5441932 1031 dev->netdev_ops = &gre_tap_netdev_ops;
f8c1b7ce 1032 dev->priv_flags |= IFF_LIVE_ADDR_CHANGE;
c5441932 1033 ip_tunnel_setup(dev, gre_tap_net_id);
e1a80002
HX		 1034}
1035
c5441932
PS		 1036static int ipgre_newlink(struct net *src_net, struct net_device *dev,
1037 struct nlattr *tb[], struct nlattr *data[])
c19e654d 1038{
c5441932 1039 struct ip_tunnel_parm p;
4565e991
TH		 1040 struct ip_tunnel_encap ipencap;
1041
1042 if (ipgre_netlink_encap_parms(data, &ipencap)) {
1043 struct ip_tunnel *t = netdev_priv(dev);
1044 int err = ip_tunnel_encap_setup(t, &ipencap);
1045
1046 if (err < 0)
1047 return err;
1048 }
c19e654d 1049
2e15ea39 1050 ipgre_netlink_parms(dev, data, tb, &p);
c5441932 1051 return ip_tunnel_newlink(dev, tb, &p);
c19e654d
HX		 1052}
1053
1054static int ipgre_changelink(struct net_device *dev, struct nlattr *tb[],
1055 struct nlattr *data[])
1056{
c19e654d 1057 struct ip_tunnel_parm p;
4565e991
TH		 1058 struct ip_tunnel_encap ipencap;
1059
1060 if (ipgre_netlink_encap_parms(data, &ipencap)) {
1061 struct ip_tunnel *t = netdev_priv(dev);
1062 int err = ip_tunnel_encap_setup(t, &ipencap);
1063
1064 if (err < 0)
1065 return err;
1066 }
c19e654d 1067
2e15ea39 1068 ipgre_netlink_parms(dev, data, tb, &p);
c5441932 1069 return ip_tunnel_changelink(dev, tb, &p);
c19e654d
HX		 1070}
1071
1072static size_t ipgre_get_size(const struct net_device *dev)
1073{
1074 return
1075 /* IFLA_GRE_LINK */
1076 nla_total_size(4) +
1077 /* IFLA_GRE_IFLAGS */
1078 nla_total_size(2) +
1079 /* IFLA_GRE_OFLAGS */
1080 nla_total_size(2) +
1081 /* IFLA_GRE_IKEY */
1082 nla_total_size(4) +
1083 /* IFLA_GRE_OKEY */
1084 nla_total_size(4) +
1085 /* IFLA_GRE_LOCAL */
1086 nla_total_size(4) +
1087 /* IFLA_GRE_REMOTE */
1088 nla_total_size(4) +
1089 /* IFLA_GRE_TTL */
1090 nla_total_size(1) +
1091 /* IFLA_GRE_TOS */
1092 nla_total_size(1) +
1093 /* IFLA_GRE_PMTUDISC */
1094 nla_total_size(1) +
4565e991
TH		 1095 /* IFLA_GRE_ENCAP_TYPE */
1096 nla_total_size(2) +
1097 /* IFLA_GRE_ENCAP_FLAGS */
1098 nla_total_size(2) +
1099 /* IFLA_GRE_ENCAP_SPORT */
1100 nla_total_size(2) +
1101 /* IFLA_GRE_ENCAP_DPORT */
1102 nla_total_size(2) +
2e15ea39
PS		 1103 /* IFLA_GRE_COLLECT_METADATA */
1104 nla_total_size(0) +
c19e654d
HX		 1105 0;
1106}
1107
1108static int ipgre_fill_info(struct sk_buff *skb, const struct net_device *dev)
1109{
1110 struct ip_tunnel *t = netdev_priv(dev);
1111 struct ip_tunnel_parm *p = &t->parms;
1112
f3756b79 1113 if (nla_put_u32(skb, IFLA_GRE_LINK, p->link) ||
c5441932
PS		 1114 nla_put_be16(skb, IFLA_GRE_IFLAGS, tnl_flags_to_gre_flags(p->i_flags)) ||
1115 nla_put_be16(skb, IFLA_GRE_OFLAGS, tnl_flags_to_gre_flags(p->o_flags)) ||
f3756b79
DM		 1116 nla_put_be32(skb, IFLA_GRE_IKEY, p->i_key) ||
1117 nla_put_be32(skb, IFLA_GRE_OKEY, p->o_key) ||
930345ea
JB		 1118 nla_put_in_addr(skb, IFLA_GRE_LOCAL, p->iph.saddr) ||
1119 nla_put_in_addr(skb, IFLA_GRE_REMOTE, p->iph.daddr) ||
f3756b79
DM		 1120 nla_put_u8(skb, IFLA_GRE_TTL, p->iph.ttl) ||
1121 nla_put_u8(skb, IFLA_GRE_TOS, p->iph.tos) ||
1122 nla_put_u8(skb, IFLA_GRE_PMTUDISC,
1123 !!(p->iph.frag_off & htons(IP_DF))))
1124 goto nla_put_failure;
4565e991
TH		 1125
1126 if (nla_put_u16(skb, IFLA_GRE_ENCAP_TYPE,
1127 t->encap.type) ||
3e97fa70
SD		 1128 nla_put_be16(skb, IFLA_GRE_ENCAP_SPORT,
1129 t->encap.sport) ||
1130 nla_put_be16(skb, IFLA_GRE_ENCAP_DPORT,
1131 t->encap.dport) ||
4565e991 1132 nla_put_u16(skb, IFLA_GRE_ENCAP_FLAGS,
e1b2cb65 1133 t->encap.flags))
4565e991
TH		 1134 goto nla_put_failure;
1135
2e15ea39
PS		 1136 if (t->collect_md) {
1137 if (nla_put_flag(skb, IFLA_GRE_COLLECT_METADATA))
1138 goto nla_put_failure;
1139 }
1140
c19e654d
HX		 1141 return 0;
1142
1143nla_put_failure:
1144 return -EMSGSIZE;
1145}
1146
1147static const struct nla_policy ipgre_policy[IFLA_GRE_MAX + 1] = {
1148 [IFLA_GRE_LINK] = { .type = NLA_U32 },
1149 [IFLA_GRE_IFLAGS] = { .type = NLA_U16 },
1150 [IFLA_GRE_OFLAGS] = { .type = NLA_U16 },
1151 [IFLA_GRE_IKEY] = { .type = NLA_U32 },
1152 [IFLA_GRE_OKEY] = { .type = NLA_U32 },
4d74f8ba
PM		 1153 [IFLA_GRE_LOCAL] = { .len = FIELD_SIZEOF(struct iphdr, saddr) },
1154 [IFLA_GRE_REMOTE] = { .len = FIELD_SIZEOF(struct iphdr, daddr) },
c19e654d
HX		 1155 [IFLA_GRE_TTL] = { .type = NLA_U8 },
1156 [IFLA_GRE_TOS] = { .type = NLA_U8 },
1157 [IFLA_GRE_PMTUDISC] = { .type = NLA_U8 },
4565e991
TH		 1158 [IFLA_GRE_ENCAP_TYPE] = { .type = NLA_U16 },
1159 [IFLA_GRE_ENCAP_FLAGS] = { .type = NLA_U16 },
1160 [IFLA_GRE_ENCAP_SPORT] = { .type = NLA_U16 },
1161 [IFLA_GRE_ENCAP_DPORT] = { .type = NLA_U16 },
2e15ea39 1162 [IFLA_GRE_COLLECT_METADATA] = { .type = NLA_FLAG },
c19e654d
HX		 1163};
1164
1165static struct rtnl_link_ops ipgre_link_ops __read_mostly = {
1166 .kind = "gre",
1167 .maxtype = IFLA_GRE_MAX,
1168 .policy = ipgre_policy,
1169 .priv_size = sizeof(struct ip_tunnel),
1170 .setup = ipgre_tunnel_setup,
1171 .validate = ipgre_tunnel_validate,
1172 .newlink = ipgre_newlink,
1173 .changelink = ipgre_changelink,
c5441932 1174 .dellink = ip_tunnel_dellink,
c19e654d
HX		 1175 .get_size = ipgre_get_size,
1176 .fill_info = ipgre_fill_info,
1728d4fa 1177 .get_link_net = ip_tunnel_get_link_net,
c19e654d
HX		 1178};
1179
e1a80002
HX		 1180static struct rtnl_link_ops ipgre_tap_ops __read_mostly = {
1181 .kind = "gretap",
1182 .maxtype = IFLA_GRE_MAX,
1183 .policy = ipgre_policy,
1184 .priv_size = sizeof(struct ip_tunnel),
1185 .setup = ipgre_tap_setup,
1186 .validate = ipgre_tap_validate,
1187 .newlink = ipgre_newlink,
1188 .changelink = ipgre_changelink,
c5441932 1189 .dellink = ip_tunnel_dellink,
e1a80002
HX		 1190 .get_size = ipgre_get_size,
1191 .fill_info = ipgre_fill_info,
1728d4fa 1192 .get_link_net = ip_tunnel_get_link_net,
e1a80002
HX		 1193};
1194
b2acd1dc
PS		 1195struct net_device *gretap_fb_dev_create(struct net *net, const char *name,
1196 u8 name_assign_type)
1197{
1198 struct nlattr *tb[IFLA_MAX + 1];
1199 struct net_device *dev;
1200 struct ip_tunnel *t;
1201 int err;
1202
1203 memset(&tb, 0, sizeof(tb));
1204
1205 dev = rtnl_create_link(net, name, name_assign_type,
1206 &ipgre_tap_ops, tb);
1207 if (IS_ERR(dev))
1208 return dev;
1209
1210 /* Configure flow based GRE device. */
1211 t = netdev_priv(dev);
1212 t->collect_md = true;
1213
1214 err = ipgre_newlink(net, dev, tb, NULL);
1215 if (err < 0)
1216 goto out;
1217 return dev;
1218out:
1219 free_netdev(dev);
1220 return ERR_PTR(err);
1221}
1222EXPORT_SYMBOL_GPL(gretap_fb_dev_create);
1223
c5441932
PS		 1224static int __net_init ipgre_tap_init_net(struct net *net)
1225{
2e15ea39 1226 return ip_tunnel_init_net(net, gre_tap_net_id, &ipgre_tap_ops, "gretap0");
c5441932
PS		 1227}
1228
1229static void __net_exit ipgre_tap_exit_net(struct net *net)
1230{
1231 struct ip_tunnel_net *itn = net_generic(net, gre_tap_net_id);
6c742e71 1232 ip_tunnel_delete_net(itn, &ipgre_tap_ops);
c5441932
PS		 1233}
1234
1235static struct pernet_operations ipgre_tap_net_ops = {
1236 .init = ipgre_tap_init_net,
1237 .exit = ipgre_tap_exit_net,
1238 .id = &gre_tap_net_id,
1239 .size = sizeof(struct ip_tunnel_net),
1240};
1da177e4
LT		 1241
1242static int __init ipgre_init(void)
1243{
1244 int err;
1245
058bd4d2 1246 pr_info("GRE over IPv4 tunneling driver\n");
1da177e4 1247
cfb8fbf2 1248 err = register_pernet_device(&ipgre_net_ops);
59a4c759 1249 if (err < 0)
c2892f02
AD		 1250 return err;
1251
c5441932
PS		 1252 err = register_pernet_device(&ipgre_tap_net_ops);
1253 if (err < 0)
1254 goto pnet_tap_faied;
1255
9f57c67c 1256 err = gre_add_protocol(&ipgre_protocol, GREPROTO_CISCO);
c2892f02 1257 if (err < 0) {
058bd4d2 1258 pr_info("%s: can't add protocol\n", __func__);
c2892f02
AD		 1259 goto add_proto_failed;
1260 }
7daa0004 1261
c19e654d
HX		 1262 err = rtnl_link_register(&ipgre_link_ops);
1263 if (err < 0)
1264 goto rtnl_link_failed;
1265
e1a80002
HX		 1266 err = rtnl_link_register(&ipgre_tap_ops);
1267 if (err < 0)
1268 goto tap_ops_failed;
1269
c5441932 1270 return 0;
c19e654d 1271
e1a80002
HX		 1272tap_ops_failed:
1273 rtnl_link_unregister(&ipgre_link_ops);
c19e654d 1274rtnl_link_failed:
9f57c67c 1275 gre_del_protocol(&ipgre_protocol, GREPROTO_CISCO);
c2892f02 1276add_proto_failed:
c5441932
PS		 1277 unregister_pernet_device(&ipgre_tap_net_ops);
1278pnet_tap_faied:
c2892f02 1279 unregister_pernet_device(&ipgre_net_ops);
c5441932 1280 return err;
1da177e4
LT		 1281}
1282
db44575f 1283static void __exit ipgre_fini(void)
1da177e4 1284{
e1a80002 1285 rtnl_link_unregister(&ipgre_tap_ops);
c19e654d 1286 rtnl_link_unregister(&ipgre_link_ops);
9f57c67c 1287 gre_del_protocol(&ipgre_protocol, GREPROTO_CISCO);
c5441932 1288 unregister_pernet_device(&ipgre_tap_net_ops);
c2892f02 1289 unregister_pernet_device(&ipgre_net_ops);
1da177e4
LT		 1290}
1291
1292module_init(ipgre_init);
1293module_exit(ipgre_fini);
1294MODULE_LICENSE("GPL");
4d74f8ba
PM		 1295MODULE_ALIAS_RTNL_LINK("gre");
1296MODULE_ALIAS_RTNL_LINK("gretap");
8909c9ad 1297MODULE_ALIAS_NETDEV("gre0");
c5441932 1298MODULE_ALIAS_NETDEV("gretap0");
Linux kernel - Deliverables
This page took 1.508485 seconds and 5 git commands to generate.