2 * Linux NET3: GRE over IP protocol decoder.
4 * Authors: Alexey Kuznetsov (kuznet@ms2.inr.ac.ru)
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.
13 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
15 #include <linux/capability.h>
16 #include <linux/module.h>
17 #include <linux/types.h>
18 #include <linux/kernel.h>
19 #include <linux/slab.h>
20 #include <asm/uaccess.h>
21 #include <linux/skbuff.h>
22 #include <linux/netdevice.h>
24 #include <linux/tcp.h>
25 #include <linux/udp.h>
26 #include <linux/if_arp.h>
27 #include <linux/mroute.h>
28 #include <linux/init.h>
29 #include <linux/in6.h>
30 #include <linux/inetdevice.h>
31 #include <linux/igmp.h>
32 #include <linux/netfilter_ipv4.h>
33 #include <linux/etherdevice.h>
34 #include <linux/if_ether.h>
39 #include <net/protocol.h>
40 #include <net/ip_tunnels.h>
42 #include <net/checksum.h>
43 #include <net/dsfield.h>
44 #include <net/inet_ecn.h>
46 #include <net/net_namespace.h>
47 #include <net/netns/generic.h>
48 #include <net/rtnetlink.h>
51 #if IS_ENABLED(CONFIG_IPV6)
53 #include <net/ip6_fib.h>
54 #include <net/ip6_route.h>
61 1. The most important issue is detecting local dead loops.
62 They would cause complete host lockup in transmit, which
63 would be "resolved" by stack overflow or, if queueing is enabled,
64 with infinite looping in net_bh.
66 We cannot track such dead loops during route installation,
67 it is infeasible task. The most general solutions would be
68 to keep skb->encapsulation counter (sort of local ttl),
69 and silently drop packet when it expires. It is a good
70 solution, but it supposes maintaining new variable in ALL
71 skb, even if no tunneling is used.
73 Current solution: xmit_recursion breaks dead loops. This is a percpu
74 counter, since when we enter the first ndo_xmit(), cpu migration is
75 forbidden. We force an exit if this counter reaches RECURSION_LIMIT
77 2. Networking dead loops would not kill routers, but would really
78 kill network. IP hop limit plays role of "t->recursion" in this case,
79 if we copy it from packet being encapsulated to upper header.
80 It is very good solution, but it introduces two problems:
82 - Routing protocols, using packets with ttl=1 (OSPF, RIP2),
83 do not work over tunnels.
84 - traceroute does not work. I planned to relay ICMP from tunnel,
85 so that this problem would be solved and traceroute output
86 would even more informative. This idea appeared to be wrong:
87 only Linux complies to rfc1812 now (yes, guys, Linux is the only
88 true router now :-)), all routers (at least, in neighbourhood of mine)
89 return only 8 bytes of payload. It is the end.
91 Hence, if we want that OSPF worked or traceroute said something reasonable,
92 we should search for another solution.
94 One of them is to parse packet trying to detect inner encapsulation
95 made by our node. It is difficult or even impossible, especially,
96 taking into account fragmentation. TO be short, ttl is not solution at all.
98 Current solution: The solution was UNEXPECTEDLY SIMPLE.
99 We force DF flag on tunnels with preconfigured hop limit,
100 that is ALL. :-) Well, it does not remove the problem completely,
101 but exponential growth of network traffic is changed to linear
102 (branches, that exceed pmtu are pruned) and tunnel mtu
103 rapidly degrades to value <68, where looping stops.
104 Yes, it is not good if there exists a router in the loop,
105 which does not force DF, even when encapsulating packets have DF set.
106 But it is not our problem! Nobody could accuse us, we made
107 all that we could make. Even if it is your gated who injected
108 fatal route to network, even if it were you who configured
109 fatal static route: you are innocent. :-)
114 static bool log_ecn_error
= true;
115 module_param(log_ecn_error
, bool, 0644);
116 MODULE_PARM_DESC(log_ecn_error
, "Log packets received with corrupted ECN");
118 static struct rtnl_link_ops ipgre_link_ops __read_mostly
;
119 static int ipgre_tunnel_init(struct net_device
*dev
);
121 static int ipgre_net_id __read_mostly
;
122 static int gre_tap_net_id __read_mostly
;
124 static int ipgre_err(struct sk_buff
*skb
, u32 info
,
125 const struct tnl_ptk_info
*tpi
)
128 /* All the routers (except for Linux) return only
129 8 bytes of packet payload. It means, that precise relaying of
130 ICMP in the real Internet is absolutely infeasible.
132 Moreover, Cisco "wise men" put GRE key to the third word
133 in GRE header. It makes impossible maintaining even soft
134 state for keyed GRE tunnels with enabled checksum. Tell
137 Well, I wonder, rfc1812 was written by Cisco employee,
138 what the hell these idiots break standards established
141 struct net
*net
= dev_net(skb
->dev
);
142 struct ip_tunnel_net
*itn
;
143 const struct iphdr
*iph
;
144 const int type
= icmp_hdr(skb
)->type
;
145 const int code
= icmp_hdr(skb
)->code
;
150 case ICMP_PARAMETERPROB
:
153 case ICMP_DEST_UNREACH
:
156 case ICMP_PORT_UNREACH
:
157 /* Impossible event. */
160 /* All others are translated to HOST_UNREACH.
161 rfc2003 contains "deep thoughts" about NET_UNREACH,
162 I believe they are just ether pollution. --ANK
167 case ICMP_TIME_EXCEEDED
:
168 if (code
!= ICMP_EXC_TTL
)
176 if (tpi
->proto
== htons(ETH_P_TEB
))
177 itn
= net_generic(net
, gre_tap_net_id
);
179 itn
= net_generic(net
, ipgre_net_id
);
181 iph
= (const struct iphdr
*)skb
->data
;
182 t
= ip_tunnel_lookup(itn
, skb
->dev
->ifindex
, tpi
->flags
,
183 iph
->daddr
, iph
->saddr
, tpi
->key
);
186 return PACKET_REJECT
;
188 if (t
->parms
.iph
.daddr
== 0 ||
189 ipv4_is_multicast(t
->parms
.iph
.daddr
))
192 if (t
->parms
.iph
.ttl
== 0 && type
== ICMP_TIME_EXCEEDED
)
195 if (time_before(jiffies
, t
->err_time
+ IPTUNNEL_ERR_TIMEO
))
199 t
->err_time
= jiffies
;
203 static int ipgre_rcv(struct sk_buff
*skb
, const struct tnl_ptk_info
*tpi
)
205 struct net
*net
= dev_net(skb
->dev
);
206 struct ip_tunnel_net
*itn
;
207 const struct iphdr
*iph
;
208 struct ip_tunnel
*tunnel
;
210 if (tpi
->proto
== htons(ETH_P_TEB
))
211 itn
= net_generic(net
, gre_tap_net_id
);
213 itn
= net_generic(net
, ipgre_net_id
);
216 tunnel
= ip_tunnel_lookup(itn
, skb
->dev
->ifindex
, tpi
->flags
,
217 iph
->saddr
, iph
->daddr
, tpi
->key
);
220 ip_tunnel_rcv(tunnel
, skb
, tpi
, log_ecn_error
);
223 return PACKET_REJECT
;
226 static void __gre_xmit(struct sk_buff
*skb
, struct net_device
*dev
,
227 const struct iphdr
*tnl_params
,
230 struct ip_tunnel
*tunnel
= netdev_priv(dev
);
231 struct tnl_ptk_info tpi
;
233 tpi
.flags
= tunnel
->parms
.o_flags
;
235 tpi
.key
= tunnel
->parms
.o_key
;
236 if (tunnel
->parms
.o_flags
& TUNNEL_SEQ
)
238 tpi
.seq
= htonl(tunnel
->o_seqno
);
240 /* Push GRE header. */
241 gre_build_header(skb
, &tpi
, tunnel
->hlen
);
243 ip_tunnel_xmit(skb
, dev
, tnl_params
, tnl_params
->protocol
);
246 static netdev_tx_t
ipgre_xmit(struct sk_buff
*skb
,
247 struct net_device
*dev
)
249 struct ip_tunnel
*tunnel
= netdev_priv(dev
);
250 const struct iphdr
*tnl_params
;
252 skb
= gre_handle_offloads(skb
, !!(tunnel
->parms
.o_flags
&TUNNEL_CSUM
));
256 if (dev
->header_ops
) {
257 /* Need space for new headers */
258 if (skb_cow_head(skb
, dev
->needed_headroom
-
259 (tunnel
->hlen
+ sizeof(struct iphdr
))))
262 tnl_params
= (const struct iphdr
*)skb
->data
;
264 /* Pull skb since ip_tunnel_xmit() needs skb->data pointing
267 skb_pull(skb
, tunnel
->hlen
+ sizeof(struct iphdr
));
269 if (skb_cow_head(skb
, dev
->needed_headroom
))
272 tnl_params
= &tunnel
->parms
.iph
;
275 __gre_xmit(skb
, dev
, tnl_params
, skb
->protocol
);
282 dev
->stats
.tx_dropped
++;
286 static netdev_tx_t
gre_tap_xmit(struct sk_buff
*skb
,
287 struct net_device
*dev
)
289 struct ip_tunnel
*tunnel
= netdev_priv(dev
);
291 skb
= gre_handle_offloads(skb
, !!(tunnel
->parms
.o_flags
&TUNNEL_CSUM
));
295 if (skb_cow_head(skb
, dev
->needed_headroom
))
298 __gre_xmit(skb
, dev
, &tunnel
->parms
.iph
, htons(ETH_P_TEB
));
305 dev
->stats
.tx_dropped
++;
309 static int ipgre_tunnel_ioctl(struct net_device
*dev
,
310 struct ifreq
*ifr
, int cmd
)
313 struct ip_tunnel_parm p
;
315 if (copy_from_user(&p
, ifr
->ifr_ifru
.ifru_data
, sizeof(p
)))
317 if (p
.iph
.version
!= 4 || p
.iph
.protocol
!= IPPROTO_GRE
||
318 p
.iph
.ihl
!= 5 || (p
.iph
.frag_off
&htons(~IP_DF
)) ||
319 ((p
.i_flags
|p
.o_flags
)&(GRE_VERSION
|GRE_ROUTING
))) {
322 p
.i_flags
= gre_flags_to_tnl_flags(p
.i_flags
);
323 p
.o_flags
= gre_flags_to_tnl_flags(p
.o_flags
);
325 err
= ip_tunnel_ioctl(dev
, &p
, cmd
);
329 p
.i_flags
= tnl_flags_to_gre_flags(p
.i_flags
);
330 p
.o_flags
= tnl_flags_to_gre_flags(p
.o_flags
);
332 if (copy_to_user(ifr
->ifr_ifru
.ifru_data
, &p
, sizeof(p
)))
337 /* Nice toy. Unfortunately, useless in real life :-)
338 It allows to construct virtual multiprotocol broadcast "LAN"
339 over the Internet, provided multicast routing is tuned.
342 I have no idea was this bicycle invented before me,
343 so that I had to set ARPHRD_IPGRE to a random value.
344 I have an impression, that Cisco could make something similar,
345 but this feature is apparently missing in IOS<=11.2(8).
347 I set up 10.66.66/24 and fec0:6666:6666::0/96 as virtual networks
348 with broadcast 224.66.66.66. If you have access to mbone, play with me :-)
350 ping -t 255 224.66.66.66
352 If nobody answers, mbone does not work.
354 ip tunnel add Universe mode gre remote 224.66.66.66 local <Your_real_addr> ttl 255
355 ip addr add 10.66.66.<somewhat>/24 dev Universe
357 ifconfig Universe add fe80::<Your_real_addr>/10
358 ifconfig Universe add fec0:6666:6666::<Your_real_addr>/96
361 ftp fec0:6666:6666::193.233.7.65
364 static int ipgre_header(struct sk_buff
*skb
, struct net_device
*dev
,
366 const void *daddr
, const void *saddr
, unsigned int len
)
368 struct ip_tunnel
*t
= netdev_priv(dev
);
370 struct gre_base_hdr
*greh
;
372 iph
= (struct iphdr
*)skb_push(skb
, t
->hlen
+ sizeof(*iph
));
373 greh
= (struct gre_base_hdr
*)(iph
+1);
374 greh
->flags
= tnl_flags_to_gre_flags(t
->parms
.o_flags
);
375 greh
->protocol
= htons(type
);
377 memcpy(iph
, &t
->parms
.iph
, sizeof(struct iphdr
));
379 /* Set the source hardware address. */
381 memcpy(&iph
->saddr
, saddr
, 4);
383 memcpy(&iph
->daddr
, daddr
, 4);
387 return -(t
->hlen
+ sizeof(*iph
));
390 static int ipgre_header_parse(const struct sk_buff
*skb
, unsigned char *haddr
)
392 const struct iphdr
*iph
= (const struct iphdr
*) skb_mac_header(skb
);
393 memcpy(haddr
, &iph
->saddr
, 4);
397 static const struct header_ops ipgre_header_ops
= {
398 .create
= ipgre_header
,
399 .parse
= ipgre_header_parse
,
402 #ifdef CONFIG_NET_IPGRE_BROADCAST
403 static int ipgre_open(struct net_device
*dev
)
405 struct ip_tunnel
*t
= netdev_priv(dev
);
407 if (ipv4_is_multicast(t
->parms
.iph
.daddr
)) {
411 rt
= ip_route_output_gre(dev_net(dev
), &fl4
,
415 RT_TOS(t
->parms
.iph
.tos
),
418 return -EADDRNOTAVAIL
;
421 if (__in_dev_get_rtnl(dev
) == NULL
)
422 return -EADDRNOTAVAIL
;
423 t
->mlink
= dev
->ifindex
;
424 ip_mc_inc_group(__in_dev_get_rtnl(dev
), t
->parms
.iph
.daddr
);
429 static int ipgre_close(struct net_device
*dev
)
431 struct ip_tunnel
*t
= netdev_priv(dev
);
433 if (ipv4_is_multicast(t
->parms
.iph
.daddr
) && t
->mlink
) {
434 struct in_device
*in_dev
;
435 in_dev
= inetdev_by_index(dev_net(dev
), t
->mlink
);
437 ip_mc_dec_group(in_dev
, t
->parms
.iph
.daddr
);
443 static const struct net_device_ops ipgre_netdev_ops
= {
444 .ndo_init
= ipgre_tunnel_init
,
445 .ndo_uninit
= ip_tunnel_uninit
,
446 #ifdef CONFIG_NET_IPGRE_BROADCAST
447 .ndo_open
= ipgre_open
,
448 .ndo_stop
= ipgre_close
,
450 .ndo_start_xmit
= ipgre_xmit
,
451 .ndo_do_ioctl
= ipgre_tunnel_ioctl
,
452 .ndo_change_mtu
= ip_tunnel_change_mtu
,
453 .ndo_get_stats64
= ip_tunnel_get_stats64
,
456 #define GRE_FEATURES (NETIF_F_SG | \
461 static void ipgre_tunnel_setup(struct net_device
*dev
)
463 dev
->netdev_ops
= &ipgre_netdev_ops
;
464 ip_tunnel_setup(dev
, ipgre_net_id
);
467 static void __gre_tunnel_init(struct net_device
*dev
)
469 struct ip_tunnel
*tunnel
;
471 tunnel
= netdev_priv(dev
);
472 tunnel
->hlen
= ip_gre_calc_hlen(tunnel
->parms
.o_flags
);
473 tunnel
->parms
.iph
.protocol
= IPPROTO_GRE
;
475 dev
->needed_headroom
= LL_MAX_HEADER
+ sizeof(struct iphdr
) + 4;
476 dev
->mtu
= ETH_DATA_LEN
- sizeof(struct iphdr
) - 4;
478 dev
->features
|= NETIF_F_NETNS_LOCAL
| GRE_FEATURES
;
479 dev
->hw_features
|= GRE_FEATURES
;
481 if (!(tunnel
->parms
.o_flags
& TUNNEL_SEQ
)) {
482 /* TCP offload with GRE SEQ is not supported. */
483 dev
->features
|= NETIF_F_GSO_SOFTWARE
;
484 dev
->hw_features
|= NETIF_F_GSO_SOFTWARE
;
485 /* Can use a lockless transmit, unless we generate
488 dev
->features
|= NETIF_F_LLTX
;
492 static int ipgre_tunnel_init(struct net_device
*dev
)
494 struct ip_tunnel
*tunnel
= netdev_priv(dev
);
495 struct iphdr
*iph
= &tunnel
->parms
.iph
;
497 __gre_tunnel_init(dev
);
499 memcpy(dev
->dev_addr
, &iph
->saddr
, 4);
500 memcpy(dev
->broadcast
, &iph
->daddr
, 4);
502 dev
->type
= ARPHRD_IPGRE
;
503 dev
->flags
= IFF_NOARP
;
504 dev
->priv_flags
&= ~IFF_XMIT_DST_RELEASE
;
508 #ifdef CONFIG_NET_IPGRE_BROADCAST
509 if (ipv4_is_multicast(iph
->daddr
)) {
512 dev
->flags
= IFF_BROADCAST
;
513 dev
->header_ops
= &ipgre_header_ops
;
517 dev
->header_ops
= &ipgre_header_ops
;
519 return ip_tunnel_init(dev
);
522 static struct gre_cisco_protocol ipgre_protocol
= {
523 .handler
= ipgre_rcv
,
524 .err_handler
= ipgre_err
,
528 static int __net_init
ipgre_init_net(struct net
*net
)
530 return ip_tunnel_init_net(net
, ipgre_net_id
, &ipgre_link_ops
, NULL
);
533 static void __net_exit
ipgre_exit_net(struct net
*net
)
535 struct ip_tunnel_net
*itn
= net_generic(net
, ipgre_net_id
);
536 ip_tunnel_delete_net(itn
);
539 static struct pernet_operations ipgre_net_ops
= {
540 .init
= ipgre_init_net
,
541 .exit
= ipgre_exit_net
,
543 .size
= sizeof(struct ip_tunnel_net
),
546 static int ipgre_tunnel_validate(struct nlattr
*tb
[], struct nlattr
*data
[])
554 if (data
[IFLA_GRE_IFLAGS
])
555 flags
|= nla_get_be16(data
[IFLA_GRE_IFLAGS
]);
556 if (data
[IFLA_GRE_OFLAGS
])
557 flags
|= nla_get_be16(data
[IFLA_GRE_OFLAGS
]);
558 if (flags
& (GRE_VERSION
|GRE_ROUTING
))
564 static int ipgre_tap_validate(struct nlattr
*tb
[], struct nlattr
*data
[])
568 if (tb
[IFLA_ADDRESS
]) {
569 if (nla_len(tb
[IFLA_ADDRESS
]) != ETH_ALEN
)
571 if (!is_valid_ether_addr(nla_data(tb
[IFLA_ADDRESS
])))
572 return -EADDRNOTAVAIL
;
578 if (data
[IFLA_GRE_REMOTE
]) {
579 memcpy(&daddr
, nla_data(data
[IFLA_GRE_REMOTE
]), 4);
585 return ipgre_tunnel_validate(tb
, data
);
588 static void ipgre_netlink_parms(struct nlattr
*data
[], struct nlattr
*tb
[],
589 struct ip_tunnel_parm
*parms
)
591 memset(parms
, 0, sizeof(*parms
));
593 parms
->iph
.protocol
= IPPROTO_GRE
;
598 if (data
[IFLA_GRE_LINK
])
599 parms
->link
= nla_get_u32(data
[IFLA_GRE_LINK
]);
601 if (data
[IFLA_GRE_IFLAGS
])
602 parms
->i_flags
= gre_flags_to_tnl_flags(nla_get_be16(data
[IFLA_GRE_IFLAGS
]));
604 if (data
[IFLA_GRE_OFLAGS
])
605 parms
->o_flags
= gre_flags_to_tnl_flags(nla_get_be16(data
[IFLA_GRE_OFLAGS
]));
607 if (data
[IFLA_GRE_IKEY
])
608 parms
->i_key
= nla_get_be32(data
[IFLA_GRE_IKEY
]);
610 if (data
[IFLA_GRE_OKEY
])
611 parms
->o_key
= nla_get_be32(data
[IFLA_GRE_OKEY
]);
613 if (data
[IFLA_GRE_LOCAL
])
614 parms
->iph
.saddr
= nla_get_be32(data
[IFLA_GRE_LOCAL
]);
616 if (data
[IFLA_GRE_REMOTE
])
617 parms
->iph
.daddr
= nla_get_be32(data
[IFLA_GRE_REMOTE
]);
619 if (data
[IFLA_GRE_TTL
])
620 parms
->iph
.ttl
= nla_get_u8(data
[IFLA_GRE_TTL
]);
622 if (data
[IFLA_GRE_TOS
])
623 parms
->iph
.tos
= nla_get_u8(data
[IFLA_GRE_TOS
]);
625 if (!data
[IFLA_GRE_PMTUDISC
] || nla_get_u8(data
[IFLA_GRE_PMTUDISC
]))
626 parms
->iph
.frag_off
= htons(IP_DF
);
629 static int gre_tap_init(struct net_device
*dev
)
631 __gre_tunnel_init(dev
);
633 return ip_tunnel_init(dev
);
636 static const struct net_device_ops gre_tap_netdev_ops
= {
637 .ndo_init
= gre_tap_init
,
638 .ndo_uninit
= ip_tunnel_uninit
,
639 .ndo_start_xmit
= gre_tap_xmit
,
640 .ndo_set_mac_address
= eth_mac_addr
,
641 .ndo_validate_addr
= eth_validate_addr
,
642 .ndo_change_mtu
= ip_tunnel_change_mtu
,
643 .ndo_get_stats64
= ip_tunnel_get_stats64
,
646 static void ipgre_tap_setup(struct net_device
*dev
)
649 dev
->netdev_ops
= &gre_tap_netdev_ops
;
650 ip_tunnel_setup(dev
, gre_tap_net_id
);
653 static int ipgre_newlink(struct net
*src_net
, struct net_device
*dev
,
654 struct nlattr
*tb
[], struct nlattr
*data
[])
656 struct ip_tunnel_parm p
;
658 ipgre_netlink_parms(data
, tb
, &p
);
659 return ip_tunnel_newlink(dev
, tb
, &p
);
662 static int ipgre_changelink(struct net_device
*dev
, struct nlattr
*tb
[],
663 struct nlattr
*data
[])
665 struct ip_tunnel_parm p
;
667 ipgre_netlink_parms(data
, tb
, &p
);
668 return ip_tunnel_changelink(dev
, tb
, &p
);
671 static size_t ipgre_get_size(const struct net_device
*dev
)
676 /* IFLA_GRE_IFLAGS */
678 /* IFLA_GRE_OFLAGS */
686 /* IFLA_GRE_REMOTE */
692 /* IFLA_GRE_PMTUDISC */
697 static int ipgre_fill_info(struct sk_buff
*skb
, const struct net_device
*dev
)
699 struct ip_tunnel
*t
= netdev_priv(dev
);
700 struct ip_tunnel_parm
*p
= &t
->parms
;
702 if (nla_put_u32(skb
, IFLA_GRE_LINK
, p
->link
) ||
703 nla_put_be16(skb
, IFLA_GRE_IFLAGS
, tnl_flags_to_gre_flags(p
->i_flags
)) ||
704 nla_put_be16(skb
, IFLA_GRE_OFLAGS
, tnl_flags_to_gre_flags(p
->o_flags
)) ||
705 nla_put_be32(skb
, IFLA_GRE_IKEY
, p
->i_key
) ||
706 nla_put_be32(skb
, IFLA_GRE_OKEY
, p
->o_key
) ||
707 nla_put_be32(skb
, IFLA_GRE_LOCAL
, p
->iph
.saddr
) ||
708 nla_put_be32(skb
, IFLA_GRE_REMOTE
, p
->iph
.daddr
) ||
709 nla_put_u8(skb
, IFLA_GRE_TTL
, p
->iph
.ttl
) ||
710 nla_put_u8(skb
, IFLA_GRE_TOS
, p
->iph
.tos
) ||
711 nla_put_u8(skb
, IFLA_GRE_PMTUDISC
,
712 !!(p
->iph
.frag_off
& htons(IP_DF
))))
713 goto nla_put_failure
;
720 static const struct nla_policy ipgre_policy
[IFLA_GRE_MAX
+ 1] = {
721 [IFLA_GRE_LINK
] = { .type
= NLA_U32
},
722 [IFLA_GRE_IFLAGS
] = { .type
= NLA_U16
},
723 [IFLA_GRE_OFLAGS
] = { .type
= NLA_U16
},
724 [IFLA_GRE_IKEY
] = { .type
= NLA_U32
},
725 [IFLA_GRE_OKEY
] = { .type
= NLA_U32
},
726 [IFLA_GRE_LOCAL
] = { .len
= FIELD_SIZEOF(struct iphdr
, saddr
) },
727 [IFLA_GRE_REMOTE
] = { .len
= FIELD_SIZEOF(struct iphdr
, daddr
) },
728 [IFLA_GRE_TTL
] = { .type
= NLA_U8
},
729 [IFLA_GRE_TOS
] = { .type
= NLA_U8
},
730 [IFLA_GRE_PMTUDISC
] = { .type
= NLA_U8
},
733 static struct rtnl_link_ops ipgre_link_ops __read_mostly
= {
735 .maxtype
= IFLA_GRE_MAX
,
736 .policy
= ipgre_policy
,
737 .priv_size
= sizeof(struct ip_tunnel
),
738 .setup
= ipgre_tunnel_setup
,
739 .validate
= ipgre_tunnel_validate
,
740 .newlink
= ipgre_newlink
,
741 .changelink
= ipgre_changelink
,
742 .dellink
= ip_tunnel_dellink
,
743 .get_size
= ipgre_get_size
,
744 .fill_info
= ipgre_fill_info
,
747 static struct rtnl_link_ops ipgre_tap_ops __read_mostly
= {
749 .maxtype
= IFLA_GRE_MAX
,
750 .policy
= ipgre_policy
,
751 .priv_size
= sizeof(struct ip_tunnel
),
752 .setup
= ipgre_tap_setup
,
753 .validate
= ipgre_tap_validate
,
754 .newlink
= ipgre_newlink
,
755 .changelink
= ipgre_changelink
,
756 .dellink
= ip_tunnel_dellink
,
757 .get_size
= ipgre_get_size
,
758 .fill_info
= ipgre_fill_info
,
761 static int __net_init
ipgre_tap_init_net(struct net
*net
)
763 return ip_tunnel_init_net(net
, gre_tap_net_id
, &ipgre_tap_ops
, NULL
);
766 static void __net_exit
ipgre_tap_exit_net(struct net
*net
)
768 struct ip_tunnel_net
*itn
= net_generic(net
, gre_tap_net_id
);
769 ip_tunnel_delete_net(itn
);
772 static struct pernet_operations ipgre_tap_net_ops
= {
773 .init
= ipgre_tap_init_net
,
774 .exit
= ipgre_tap_exit_net
,
775 .id
= &gre_tap_net_id
,
776 .size
= sizeof(struct ip_tunnel_net
),
779 static int __init
ipgre_init(void)
783 pr_info("GRE over IPv4 tunneling driver\n");
785 err
= register_pernet_device(&ipgre_net_ops
);
789 err
= register_pernet_device(&ipgre_tap_net_ops
);
793 err
= gre_cisco_register(&ipgre_protocol
);
795 pr_info("%s: can't add protocol\n", __func__
);
796 goto add_proto_failed
;
799 err
= rtnl_link_register(&ipgre_link_ops
);
801 goto rtnl_link_failed
;
803 err
= rtnl_link_register(&ipgre_tap_ops
);
810 rtnl_link_unregister(&ipgre_link_ops
);
812 gre_cisco_unregister(&ipgre_protocol
);
814 unregister_pernet_device(&ipgre_tap_net_ops
);
816 unregister_pernet_device(&ipgre_net_ops
);
820 static void __exit
ipgre_fini(void)
822 rtnl_link_unregister(&ipgre_tap_ops
);
823 rtnl_link_unregister(&ipgre_link_ops
);
824 gre_cisco_unregister(&ipgre_protocol
);
825 unregister_pernet_device(&ipgre_tap_net_ops
);
826 unregister_pernet_device(&ipgre_net_ops
);
829 module_init(ipgre_init
);
830 module_exit(ipgre_fini
);
831 MODULE_LICENSE("GPL");
832 MODULE_ALIAS_RTNL_LINK("gre");
833 MODULE_ALIAS_RTNL_LINK("gretap");
834 MODULE_ALIAS_NETDEV("gre0");
835 MODULE_ALIAS_NETDEV("gretap0");