2012-08-10 00:51:50 +00:00
|
|
|
/*
|
|
|
|
* GRE over IPv6 protocol decoder.
|
|
|
|
*
|
|
|
|
* Authors: Dmitry Kozlov (xeb@mail.ru)
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License
|
|
|
|
* as published by the Free Software Foundation; either version
|
|
|
|
* 2 of the License, or (at your option) any later version.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
|
|
|
|
|
|
|
#include <linux/capability.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/uaccess.h>
|
|
|
|
#include <linux/skbuff.h>
|
|
|
|
#include <linux/netdevice.h>
|
|
|
|
#include <linux/in.h>
|
|
|
|
#include <linux/tcp.h>
|
|
|
|
#include <linux/udp.h>
|
|
|
|
#include <linux/if_arp.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/in6.h>
|
|
|
|
#include <linux/inetdevice.h>
|
|
|
|
#include <linux/igmp.h>
|
|
|
|
#include <linux/netfilter_ipv4.h>
|
|
|
|
#include <linux/etherdevice.h>
|
|
|
|
#include <linux/if_ether.h>
|
|
|
|
#include <linux/hash.h>
|
|
|
|
#include <linux/if_tunnel.h>
|
|
|
|
#include <linux/ip6_tunnel.h>
|
|
|
|
|
|
|
|
#include <net/sock.h>
|
|
|
|
#include <net/ip.h>
|
2013-03-25 14:49:35 +00:00
|
|
|
#include <net/ip_tunnels.h>
|
2012-08-10 00:51:50 +00:00
|
|
|
#include <net/icmp.h>
|
|
|
|
#include <net/protocol.h>
|
|
|
|
#include <net/addrconf.h>
|
|
|
|
#include <net/arp.h>
|
|
|
|
#include <net/checksum.h>
|
|
|
|
#include <net/dsfield.h>
|
|
|
|
#include <net/inet_ecn.h>
|
|
|
|
#include <net/xfrm.h>
|
|
|
|
#include <net/net_namespace.h>
|
|
|
|
#include <net/netns/generic.h>
|
|
|
|
#include <net/rtnetlink.h>
|
|
|
|
|
|
|
|
#include <net/ipv6.h>
|
|
|
|
#include <net/ip6_fib.h>
|
|
|
|
#include <net/ip6_route.h>
|
|
|
|
#include <net/ip6_tunnel.h>
|
2016-04-30 00:12:17 +00:00
|
|
|
#include <net/gre.h>
|
2012-08-10 00:51:50 +00:00
|
|
|
|
|
|
|
|
2012-09-25 11:02:48 +00:00
|
|
|
static bool log_ecn_error = true;
|
|
|
|
module_param(log_ecn_error, bool, 0644);
|
|
|
|
MODULE_PARM_DESC(log_ecn_error, "Log packets received with corrupted ECN");
|
|
|
|
|
2016-08-10 09:03:35 +00:00
|
|
|
#define IP6_GRE_HASH_SIZE_SHIFT 5
|
|
|
|
#define IP6_GRE_HASH_SIZE (1 << IP6_GRE_HASH_SIZE_SHIFT)
|
2012-08-10 00:51:50 +00:00
|
|
|
|
netns: make struct pernet_operations::id unsigned int
Make struct pernet_operations::id unsigned.
There are 2 reasons to do so:
1)
This field is really an index into an zero based array and
thus is unsigned entity. Using negative value is out-of-bound
access by definition.
2)
On x86_64 unsigned 32-bit data which are mixed with pointers
via array indexing or offsets added or subtracted to pointers
are preffered to signed 32-bit data.
"int" being used as an array index needs to be sign-extended
to 64-bit before being used.
void f(long *p, int i)
{
g(p[i]);
}
roughly translates to
movsx rsi, esi
mov rdi, [rsi+...]
call g
MOVSX is 3 byte instruction which isn't necessary if the variable is
unsigned because x86_64 is zero extending by default.
Now, there is net_generic() function which, you guessed it right, uses
"int" as an array index:
static inline void *net_generic(const struct net *net, int id)
{
...
ptr = ng->ptr[id - 1];
...
}
And this function is used a lot, so those sign extensions add up.
Patch snipes ~1730 bytes on allyesconfig kernel (without all junk
messing with code generation):
add/remove: 0/0 grow/shrink: 70/598 up/down: 396/-2126 (-1730)
Unfortunately some functions actually grow bigger.
This is a semmingly random artefact of code generation with register
allocator being used differently. gcc decides that some variable
needs to live in new r8+ registers and every access now requires REX
prefix. Or it is shifted into r12, so [r12+0] addressing mode has to be
used which is longer than [r8]
However, overall balance is in negative direction:
add/remove: 0/0 grow/shrink: 70/598 up/down: 396/-2126 (-1730)
function old new delta
nfsd4_lock 3886 3959 +73
tipc_link_build_proto_msg 1096 1140 +44
mac80211_hwsim_new_radio 2776 2808 +32
tipc_mon_rcv 1032 1058 +26
svcauth_gss_legacy_init 1413 1429 +16
tipc_bcbase_select_primary 379 392 +13
nfsd4_exchange_id 1247 1260 +13
nfsd4_setclientid_confirm 782 793 +11
...
put_client_renew_locked 494 480 -14
ip_set_sockfn_get 730 716 -14
geneve_sock_add 829 813 -16
nfsd4_sequence_done 721 703 -18
nlmclnt_lookup_host 708 686 -22
nfsd4_lockt 1085 1063 -22
nfs_get_client 1077 1050 -27
tcf_bpf_init 1106 1076 -30
nfsd4_encode_fattr 5997 5930 -67
Total: Before=154856051, After=154854321, chg -0.00%
Signed-off-by: Alexey Dobriyan <adobriyan@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2016-11-17 01:58:21 +00:00
|
|
|
static unsigned int ip6gre_net_id __read_mostly;
|
2012-08-10 00:51:50 +00:00
|
|
|
struct ip6gre_net {
|
2016-08-10 09:03:35 +00:00
|
|
|
struct ip6_tnl __rcu *tunnels[4][IP6_GRE_HASH_SIZE];
|
2012-08-10 00:51:50 +00:00
|
|
|
|
|
|
|
struct net_device *fb_tunnel_dev;
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct rtnl_link_ops ip6gre_link_ops __read_mostly;
|
2014-04-22 08:15:24 +00:00
|
|
|
static struct rtnl_link_ops ip6gre_tap_ops __read_mostly;
|
2012-08-10 00:51:50 +00:00
|
|
|
static int ip6gre_tunnel_init(struct net_device *dev);
|
|
|
|
static void ip6gre_tunnel_setup(struct net_device *dev);
|
|
|
|
static void ip6gre_tunnel_link(struct ip6gre_net *ign, struct ip6_tnl *t);
|
|
|
|
static void ip6gre_tnl_link_config(struct ip6_tnl *t, int set_mtu);
|
|
|
|
|
|
|
|
/* Tunnel hash table */
|
|
|
|
|
|
|
|
/*
|
|
|
|
4 hash tables:
|
|
|
|
|
|
|
|
3: (remote,local)
|
|
|
|
2: (remote,*)
|
|
|
|
1: (*,local)
|
|
|
|
0: (*,*)
|
|
|
|
|
|
|
|
We require exact key match i.e. if a key is present in packet
|
|
|
|
it will match only tunnel with the same key; if it is not present,
|
|
|
|
it will match only keyless tunnel.
|
|
|
|
|
|
|
|
All keysless packets, if not matched configured keyless tunnels
|
|
|
|
will match fallback tunnel.
|
|
|
|
*/
|
|
|
|
|
2016-08-10 09:03:35 +00:00
|
|
|
#define HASH_KEY(key) (((__force u32)key^((__force u32)key>>4))&(IP6_GRE_HASH_SIZE - 1))
|
2012-08-10 00:51:50 +00:00
|
|
|
static u32 HASH_ADDR(const struct in6_addr *addr)
|
|
|
|
{
|
|
|
|
u32 hash = ipv6_addr_hash(addr);
|
|
|
|
|
2016-08-10 09:03:35 +00:00
|
|
|
return hash_32(hash, IP6_GRE_HASH_SIZE_SHIFT);
|
2012-08-10 00:51:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#define tunnels_r_l tunnels[3]
|
|
|
|
#define tunnels_r tunnels[2]
|
|
|
|
#define tunnels_l tunnels[1]
|
|
|
|
#define tunnels_wc tunnels[0]
|
|
|
|
|
|
|
|
/* Given src, dst and key, find appropriate for input tunnel. */
|
|
|
|
|
|
|
|
static struct ip6_tnl *ip6gre_tunnel_lookup(struct net_device *dev,
|
|
|
|
const struct in6_addr *remote, const struct in6_addr *local,
|
|
|
|
__be32 key, __be16 gre_proto)
|
|
|
|
{
|
|
|
|
struct net *net = dev_net(dev);
|
|
|
|
int link = dev->ifindex;
|
|
|
|
unsigned int h0 = HASH_ADDR(remote);
|
|
|
|
unsigned int h1 = HASH_KEY(key);
|
|
|
|
struct ip6_tnl *t, *cand = NULL;
|
|
|
|
struct ip6gre_net *ign = net_generic(net, ip6gre_net_id);
|
|
|
|
int dev_type = (gre_proto == htons(ETH_P_TEB)) ?
|
|
|
|
ARPHRD_ETHER : ARPHRD_IP6GRE;
|
|
|
|
int score, cand_score = 4;
|
|
|
|
|
2012-11-11 21:52:34 +00:00
|
|
|
for_each_ip_tunnel_rcu(t, ign->tunnels_r_l[h0 ^ h1]) {
|
2012-08-10 00:51:50 +00:00
|
|
|
if (!ipv6_addr_equal(local, &t->parms.laddr) ||
|
|
|
|
!ipv6_addr_equal(remote, &t->parms.raddr) ||
|
|
|
|
key != t->parms.i_key ||
|
|
|
|
!(t->dev->flags & IFF_UP))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (t->dev->type != ARPHRD_IP6GRE &&
|
|
|
|
t->dev->type != dev_type)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
score = 0;
|
|
|
|
if (t->parms.link != link)
|
|
|
|
score |= 1;
|
|
|
|
if (t->dev->type != dev_type)
|
|
|
|
score |= 2;
|
|
|
|
if (score == 0)
|
|
|
|
return t;
|
|
|
|
|
|
|
|
if (score < cand_score) {
|
|
|
|
cand = t;
|
|
|
|
cand_score = score;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-11-11 21:52:34 +00:00
|
|
|
for_each_ip_tunnel_rcu(t, ign->tunnels_r[h0 ^ h1]) {
|
2012-08-10 00:51:50 +00:00
|
|
|
if (!ipv6_addr_equal(remote, &t->parms.raddr) ||
|
|
|
|
key != t->parms.i_key ||
|
|
|
|
!(t->dev->flags & IFF_UP))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (t->dev->type != ARPHRD_IP6GRE &&
|
|
|
|
t->dev->type != dev_type)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
score = 0;
|
|
|
|
if (t->parms.link != link)
|
|
|
|
score |= 1;
|
|
|
|
if (t->dev->type != dev_type)
|
|
|
|
score |= 2;
|
|
|
|
if (score == 0)
|
|
|
|
return t;
|
|
|
|
|
|
|
|
if (score < cand_score) {
|
|
|
|
cand = t;
|
|
|
|
cand_score = score;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-11-11 21:52:34 +00:00
|
|
|
for_each_ip_tunnel_rcu(t, ign->tunnels_l[h1]) {
|
2012-08-10 00:51:50 +00:00
|
|
|
if ((!ipv6_addr_equal(local, &t->parms.laddr) &&
|
|
|
|
(!ipv6_addr_equal(local, &t->parms.raddr) ||
|
|
|
|
!ipv6_addr_is_multicast(local))) ||
|
|
|
|
key != t->parms.i_key ||
|
|
|
|
!(t->dev->flags & IFF_UP))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (t->dev->type != ARPHRD_IP6GRE &&
|
|
|
|
t->dev->type != dev_type)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
score = 0;
|
|
|
|
if (t->parms.link != link)
|
|
|
|
score |= 1;
|
|
|
|
if (t->dev->type != dev_type)
|
|
|
|
score |= 2;
|
|
|
|
if (score == 0)
|
|
|
|
return t;
|
|
|
|
|
|
|
|
if (score < cand_score) {
|
|
|
|
cand = t;
|
|
|
|
cand_score = score;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-11-11 21:52:34 +00:00
|
|
|
for_each_ip_tunnel_rcu(t, ign->tunnels_wc[h1]) {
|
2012-08-10 00:51:50 +00:00
|
|
|
if (t->parms.i_key != key ||
|
|
|
|
!(t->dev->flags & IFF_UP))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (t->dev->type != ARPHRD_IP6GRE &&
|
|
|
|
t->dev->type != dev_type)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
score = 0;
|
|
|
|
if (t->parms.link != link)
|
|
|
|
score |= 1;
|
|
|
|
if (t->dev->type != dev_type)
|
|
|
|
score |= 2;
|
|
|
|
if (score == 0)
|
|
|
|
return t;
|
|
|
|
|
|
|
|
if (score < cand_score) {
|
|
|
|
cand = t;
|
|
|
|
cand_score = score;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-03-29 13:00:05 +00:00
|
|
|
if (cand)
|
2012-08-10 00:51:50 +00:00
|
|
|
return cand;
|
|
|
|
|
|
|
|
dev = ign->fb_tunnel_dev;
|
|
|
|
if (dev->flags & IFF_UP)
|
|
|
|
return netdev_priv(dev);
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct ip6_tnl __rcu **__ip6gre_bucket(struct ip6gre_net *ign,
|
|
|
|
const struct __ip6_tnl_parm *p)
|
|
|
|
{
|
|
|
|
const struct in6_addr *remote = &p->raddr;
|
|
|
|
const struct in6_addr *local = &p->laddr;
|
|
|
|
unsigned int h = HASH_KEY(p->i_key);
|
|
|
|
int prio = 0;
|
|
|
|
|
|
|
|
if (!ipv6_addr_any(local))
|
|
|
|
prio |= 1;
|
|
|
|
if (!ipv6_addr_any(remote) && !ipv6_addr_is_multicast(remote)) {
|
|
|
|
prio |= 2;
|
|
|
|
h ^= HASH_ADDR(remote);
|
|
|
|
}
|
|
|
|
|
|
|
|
return &ign->tunnels[prio][h];
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline struct ip6_tnl __rcu **ip6gre_bucket(struct ip6gre_net *ign,
|
|
|
|
const struct ip6_tnl *t)
|
|
|
|
{
|
|
|
|
return __ip6gre_bucket(ign, &t->parms);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ip6gre_tunnel_link(struct ip6gre_net *ign, struct ip6_tnl *t)
|
|
|
|
{
|
|
|
|
struct ip6_tnl __rcu **tp = ip6gre_bucket(ign, t);
|
|
|
|
|
|
|
|
rcu_assign_pointer(t->next, rtnl_dereference(*tp));
|
|
|
|
rcu_assign_pointer(*tp, t);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ip6gre_tunnel_unlink(struct ip6gre_net *ign, struct ip6_tnl *t)
|
|
|
|
{
|
|
|
|
struct ip6_tnl __rcu **tp;
|
|
|
|
struct ip6_tnl *iter;
|
|
|
|
|
|
|
|
for (tp = ip6gre_bucket(ign, t);
|
|
|
|
(iter = rtnl_dereference(*tp)) != NULL;
|
|
|
|
tp = &iter->next) {
|
|
|
|
if (t == iter) {
|
|
|
|
rcu_assign_pointer(*tp, t->next);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct ip6_tnl *ip6gre_tunnel_find(struct net *net,
|
|
|
|
const struct __ip6_tnl_parm *parms,
|
|
|
|
int type)
|
|
|
|
{
|
|
|
|
const struct in6_addr *remote = &parms->raddr;
|
|
|
|
const struct in6_addr *local = &parms->laddr;
|
|
|
|
__be32 key = parms->i_key;
|
|
|
|
int link = parms->link;
|
|
|
|
struct ip6_tnl *t;
|
|
|
|
struct ip6_tnl __rcu **tp;
|
|
|
|
struct ip6gre_net *ign = net_generic(net, ip6gre_net_id);
|
|
|
|
|
|
|
|
for (tp = __ip6gre_bucket(ign, parms);
|
|
|
|
(t = rtnl_dereference(*tp)) != NULL;
|
|
|
|
tp = &t->next)
|
|
|
|
if (ipv6_addr_equal(local, &t->parms.laddr) &&
|
|
|
|
ipv6_addr_equal(remote, &t->parms.raddr) &&
|
|
|
|
key == t->parms.i_key &&
|
|
|
|
link == t->parms.link &&
|
|
|
|
type == t->dev->type)
|
|
|
|
break;
|
|
|
|
|
|
|
|
return t;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct ip6_tnl *ip6gre_tunnel_locate(struct net *net,
|
|
|
|
const struct __ip6_tnl_parm *parms, int create)
|
|
|
|
{
|
|
|
|
struct ip6_tnl *t, *nt;
|
|
|
|
struct net_device *dev;
|
|
|
|
char name[IFNAMSIZ];
|
|
|
|
struct ip6gre_net *ign = net_generic(net, ip6gre_net_id);
|
|
|
|
|
|
|
|
t = ip6gre_tunnel_find(net, parms, ARPHRD_IP6GRE);
|
2014-09-22 08:07:26 +00:00
|
|
|
if (t && create)
|
|
|
|
return NULL;
|
2012-08-10 00:51:50 +00:00
|
|
|
if (t || !create)
|
|
|
|
return t;
|
|
|
|
|
|
|
|
if (parms->name[0])
|
|
|
|
strlcpy(name, parms->name, IFNAMSIZ);
|
|
|
|
else
|
|
|
|
strcpy(name, "ip6gre%d");
|
|
|
|
|
net: set name_assign_type in alloc_netdev()
Extend alloc_netdev{,_mq{,s}}() to take name_assign_type as argument, and convert
all users to pass NET_NAME_UNKNOWN.
Coccinelle patch:
@@
expression sizeof_priv, name, setup, txqs, rxqs, count;
@@
(
-alloc_netdev_mqs(sizeof_priv, name, setup, txqs, rxqs)
+alloc_netdev_mqs(sizeof_priv, name, NET_NAME_UNKNOWN, setup, txqs, rxqs)
|
-alloc_netdev_mq(sizeof_priv, name, setup, count)
+alloc_netdev_mq(sizeof_priv, name, NET_NAME_UNKNOWN, setup, count)
|
-alloc_netdev(sizeof_priv, name, setup)
+alloc_netdev(sizeof_priv, name, NET_NAME_UNKNOWN, setup)
)
v9: move comments here from the wrong commit
Signed-off-by: Tom Gundersen <teg@jklm.no>
Reviewed-by: David Herrmann <dh.herrmann@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2014-07-14 14:37:24 +00:00
|
|
|
dev = alloc_netdev(sizeof(*t), name, NET_NAME_UNKNOWN,
|
|
|
|
ip6gre_tunnel_setup);
|
2012-08-10 00:51:50 +00:00
|
|
|
if (!dev)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
dev_net_set(dev, net);
|
|
|
|
|
|
|
|
nt = netdev_priv(dev);
|
|
|
|
nt->parms = *parms;
|
|
|
|
dev->rtnl_link_ops = &ip6gre_link_ops;
|
|
|
|
|
|
|
|
nt->dev = dev;
|
2013-08-13 15:51:12 +00:00
|
|
|
nt->net = dev_net(dev);
|
2012-08-10 00:51:50 +00:00
|
|
|
ip6gre_tnl_link_config(nt, 1);
|
|
|
|
|
|
|
|
if (register_netdevice(dev) < 0)
|
|
|
|
goto failed_free;
|
|
|
|
|
|
|
|
/* Can use a lockless transmit, unless we generate output sequences */
|
2016-05-10 00:12:12 +00:00
|
|
|
if (!(nt->parms.o_flags & TUNNEL_SEQ))
|
2012-08-10 00:51:50 +00:00
|
|
|
dev->features |= NETIF_F_LLTX;
|
|
|
|
|
|
|
|
dev_hold(dev);
|
|
|
|
ip6gre_tunnel_link(ign, nt);
|
|
|
|
return nt;
|
|
|
|
|
|
|
|
failed_free:
|
|
|
|
free_netdev(dev);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ip6gre_tunnel_uninit(struct net_device *dev)
|
|
|
|
{
|
2014-04-22 08:15:24 +00:00
|
|
|
struct ip6_tnl *t = netdev_priv(dev);
|
|
|
|
struct ip6gre_net *ign = net_generic(t->net, ip6gre_net_id);
|
2012-08-10 00:51:50 +00:00
|
|
|
|
2014-04-22 08:15:24 +00:00
|
|
|
ip6gre_tunnel_unlink(ign, t);
|
2016-02-12 14:43:54 +00:00
|
|
|
dst_cache_reset(&t->dst_cache);
|
2012-08-10 00:51:50 +00:00
|
|
|
dev_put(dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void ip6gre_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
|
2017-02-05 07:18:55 +00:00
|
|
|
u8 type, u8 code, int offset, __be32 info)
|
2012-08-10 00:51:50 +00:00
|
|
|
{
|
2017-02-05 07:18:55 +00:00
|
|
|
const struct gre_base_hdr *greh;
|
|
|
|
const struct ipv6hdr *ipv6h;
|
|
|
|
int grehlen = sizeof(*greh);
|
2012-08-10 00:51:50 +00:00
|
|
|
struct ip6_tnl *t;
|
2017-02-05 07:18:55 +00:00
|
|
|
int key_off = 0;
|
2012-08-10 00:51:50 +00:00
|
|
|
__be16 flags;
|
2017-02-05 07:18:55 +00:00
|
|
|
__be32 key;
|
2012-08-10 00:51:50 +00:00
|
|
|
|
2017-02-05 07:18:55 +00:00
|
|
|
if (!pskb_may_pull(skb, offset + grehlen))
|
|
|
|
return;
|
|
|
|
greh = (const struct gre_base_hdr *)(skb->data + offset);
|
|
|
|
flags = greh->flags;
|
|
|
|
if (flags & (GRE_VERSION | GRE_ROUTING))
|
|
|
|
return;
|
|
|
|
if (flags & GRE_CSUM)
|
|
|
|
grehlen += 4;
|
|
|
|
if (flags & GRE_KEY) {
|
|
|
|
key_off = grehlen + offset;
|
|
|
|
grehlen += 4;
|
2012-08-10 00:51:50 +00:00
|
|
|
}
|
|
|
|
|
2017-02-05 07:18:55 +00:00
|
|
|
if (!pskb_may_pull(skb, offset + grehlen))
|
2012-08-10 00:51:50 +00:00
|
|
|
return;
|
2012-08-19 03:47:30 +00:00
|
|
|
ipv6h = (const struct ipv6hdr *)skb->data;
|
2017-02-05 07:18:55 +00:00
|
|
|
greh = (const struct gre_base_hdr *)(skb->data + offset);
|
|
|
|
key = key_off ? *(__be32 *)(skb->data + key_off) : 0;
|
2012-08-10 00:51:50 +00:00
|
|
|
|
|
|
|
t = ip6gre_tunnel_lookup(skb->dev, &ipv6h->daddr, &ipv6h->saddr,
|
2017-02-05 07:18:55 +00:00
|
|
|
key, greh->protocol);
|
2015-03-29 13:00:04 +00:00
|
|
|
if (!t)
|
2012-09-24 18:12:24 +00:00
|
|
|
return;
|
2012-08-10 00:51:50 +00:00
|
|
|
|
|
|
|
switch (type) {
|
|
|
|
__u32 teli;
|
|
|
|
struct ipv6_tlv_tnl_enc_lim *tel;
|
|
|
|
__u32 mtu;
|
|
|
|
case ICMPV6_DEST_UNREACH:
|
2015-09-23 04:58:31 +00:00
|
|
|
net_dbg_ratelimited("%s: Path to destination invalid or inactive!\n",
|
|
|
|
t->parms.name);
|
2017-10-26 11:23:27 +00:00
|
|
|
if (code != ICMPV6_PORT_UNREACH)
|
|
|
|
break;
|
|
|
|
return;
|
2012-08-10 00:51:50 +00:00
|
|
|
case ICMPV6_TIME_EXCEED:
|
|
|
|
if (code == ICMPV6_EXC_HOPLIMIT) {
|
2015-09-23 04:58:31 +00:00
|
|
|
net_dbg_ratelimited("%s: Too small hop limit or routing loop in tunnel!\n",
|
|
|
|
t->parms.name);
|
2017-10-26 11:23:27 +00:00
|
|
|
break;
|
2012-08-10 00:51:50 +00:00
|
|
|
}
|
2017-10-26 11:23:27 +00:00
|
|
|
return;
|
2012-08-10 00:51:50 +00:00
|
|
|
case ICMPV6_PARAMPROB:
|
|
|
|
teli = 0;
|
|
|
|
if (code == ICMPV6_HDR_FIELD)
|
|
|
|
teli = ip6_tnl_parse_tlv_enc_lim(skb, skb->data);
|
|
|
|
|
2015-02-04 14:25:09 +00:00
|
|
|
if (teli && teli == be32_to_cpu(info) - 2) {
|
2012-08-10 00:51:50 +00:00
|
|
|
tel = (struct ipv6_tlv_tnl_enc_lim *) &skb->data[teli];
|
|
|
|
if (tel->encap_limit == 0) {
|
2015-09-23 04:58:31 +00:00
|
|
|
net_dbg_ratelimited("%s: Too small encapsulation limit or routing loop in tunnel!\n",
|
|
|
|
t->parms.name);
|
2012-08-10 00:51:50 +00:00
|
|
|
}
|
|
|
|
} else {
|
2015-09-23 04:58:31 +00:00
|
|
|
net_dbg_ratelimited("%s: Recipient unable to parse tunneled packet!\n",
|
|
|
|
t->parms.name);
|
2012-08-10 00:51:50 +00:00
|
|
|
}
|
2017-10-26 11:23:27 +00:00
|
|
|
return;
|
2012-08-10 00:51:50 +00:00
|
|
|
case ICMPV6_PKT_TOOBIG:
|
2017-09-05 09:26:33 +00:00
|
|
|
mtu = be32_to_cpu(info) - offset - t->tun_hlen;
|
|
|
|
if (t->dev->type == ARPHRD_ETHER)
|
|
|
|
mtu -= ETH_HLEN;
|
2012-08-10 00:51:50 +00:00
|
|
|
if (mtu < IPV6_MIN_MTU)
|
|
|
|
mtu = IPV6_MIN_MTU;
|
|
|
|
t->dev->mtu = mtu;
|
2017-10-26 11:23:27 +00:00
|
|
|
return;
|
2012-08-10 00:51:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (time_before(jiffies, t->err_time + IP6TUNNEL_ERR_TIMEO))
|
|
|
|
t->err_count++;
|
|
|
|
else
|
|
|
|
t->err_count = 1;
|
|
|
|
t->err_time = jiffies;
|
|
|
|
}
|
|
|
|
|
2016-04-30 00:12:17 +00:00
|
|
|
static int ip6gre_rcv(struct sk_buff *skb, const struct tnl_ptk_info *tpi)
|
2012-08-10 00:51:50 +00:00
|
|
|
{
|
|
|
|
const struct ipv6hdr *ipv6h;
|
|
|
|
struct ip6_tnl *tunnel;
|
|
|
|
|
|
|
|
ipv6h = ipv6_hdr(skb);
|
|
|
|
tunnel = ip6gre_tunnel_lookup(skb->dev,
|
2016-04-30 00:12:17 +00:00
|
|
|
&ipv6h->saddr, &ipv6h->daddr, tpi->key,
|
|
|
|
tpi->proto);
|
2012-08-10 00:51:50 +00:00
|
|
|
if (tunnel) {
|
2017-11-17 16:16:17 +00:00
|
|
|
ip6_tnl_rcv(tunnel, skb, tpi, NULL, log_ecn_error);
|
2012-08-10 00:51:50 +00:00
|
|
|
|
2016-04-30 00:12:17 +00:00
|
|
|
return PACKET_RCVD;
|
|
|
|
}
|
2012-09-25 11:02:48 +00:00
|
|
|
|
2016-04-30 00:12:17 +00:00
|
|
|
return PACKET_REJECT;
|
|
|
|
}
|
2012-09-25 11:02:48 +00:00
|
|
|
|
2016-04-30 00:12:17 +00:00
|
|
|
static int gre_rcv(struct sk_buff *skb)
|
|
|
|
{
|
|
|
|
struct tnl_ptk_info tpi;
|
|
|
|
bool csum_err = false;
|
|
|
|
int hdr_len;
|
2012-09-25 11:02:48 +00:00
|
|
|
|
2016-06-15 13:24:00 +00:00
|
|
|
hdr_len = gre_parse_header(skb, &tpi, &csum_err, htons(ETH_P_IPV6), 0);
|
2016-05-03 13:00:21 +00:00
|
|
|
if (hdr_len < 0)
|
2016-04-30 00:12:17 +00:00
|
|
|
goto drop;
|
2012-08-10 00:51:50 +00:00
|
|
|
|
2016-04-30 00:12:17 +00:00
|
|
|
if (iptunnel_pull_header(skb, hdr_len, tpi.proto, false))
|
|
|
|
goto drop;
|
2012-08-10 00:51:50 +00:00
|
|
|
|
2016-04-30 00:12:17 +00:00
|
|
|
if (ip6gre_rcv(skb, &tpi) == PACKET_RCVD)
|
2012-08-10 00:51:50 +00:00
|
|
|
return 0;
|
|
|
|
|
2016-04-30 00:12:17 +00:00
|
|
|
icmpv6_send(skb, ICMPV6_DEST_UNREACH, ICMPV6_PORT_UNREACH, 0);
|
2012-08-10 00:51:50 +00:00
|
|
|
drop:
|
|
|
|
kfree_skb(skb);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-04-30 00:12:21 +00:00
|
|
|
static int gre_handle_offloads(struct sk_buff *skb, bool csum)
|
2012-08-10 00:51:50 +00:00
|
|
|
{
|
2016-04-30 00:12:21 +00:00
|
|
|
return iptunnel_handle_offloads(skb,
|
|
|
|
csum ? SKB_GSO_GRE_CSUM : SKB_GSO_GRE);
|
2012-08-10 00:51:50 +00:00
|
|
|
}
|
|
|
|
|
2016-04-30 00:12:21 +00:00
|
|
|
static netdev_tx_t __gre6_xmit(struct sk_buff *skb,
|
|
|
|
struct net_device *dev, __u8 dsfield,
|
|
|
|
struct flowi6 *fl6, int encap_limit,
|
|
|
|
__u32 *pmtu, __be16 proto)
|
2012-08-10 00:51:50 +00:00
|
|
|
{
|
|
|
|
struct ip6_tnl *tunnel = netdev_priv(dev);
|
2017-10-26 11:27:17 +00:00
|
|
|
struct dst_entry *dst = skb_dst(skb);
|
|
|
|
__be16 protocol;
|
2012-08-10 00:51:50 +00:00
|
|
|
|
|
|
|
if (dev->type == ARPHRD_ETHER)
|
|
|
|
IPCB(skb)->flags = 0;
|
|
|
|
|
2016-04-30 00:12:21 +00:00
|
|
|
if (dev->header_ops && dev->type == ARPHRD_IP6GRE)
|
|
|
|
fl6->daddr = ((struct ipv6hdr *)skb->data)->daddr;
|
|
|
|
else
|
2012-08-10 00:51:50 +00:00
|
|
|
fl6->daddr = tunnel->parms.raddr;
|
|
|
|
|
2016-04-30 00:12:21 +00:00
|
|
|
if (tunnel->parms.o_flags & TUNNEL_SEQ)
|
|
|
|
tunnel->o_seqno++;
|
2012-08-10 00:51:50 +00:00
|
|
|
|
2016-04-30 00:12:21 +00:00
|
|
|
/* Push GRE header. */
|
2017-10-26 11:27:17 +00:00
|
|
|
protocol = (dev->type == ARPHRD_ETHER) ? htons(ETH_P_TEB) : proto;
|
2016-04-30 00:12:21 +00:00
|
|
|
gre_build_header(skb, tunnel->tun_hlen, tunnel->parms.o_flags,
|
|
|
|
protocol, tunnel->parms.o_key, htonl(tunnel->o_seqno));
|
2012-08-10 00:51:50 +00:00
|
|
|
|
2017-10-26 11:27:17 +00:00
|
|
|
/* TooBig packet may have updated dst->dev's mtu */
|
|
|
|
if (dst && dst_mtu(dst) > dst->dev->mtu)
|
|
|
|
dst->ops->update_pmtu(dst, NULL, skb, dst->dev->mtu);
|
|
|
|
|
2016-04-30 00:12:21 +00:00
|
|
|
return ip6_tnl_xmit(skb, dev, dsfield, fl6, encap_limit, pmtu,
|
|
|
|
NEXTHDR_GRE);
|
2012-08-10 00:51:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline int ip6gre_xmit_ipv4(struct sk_buff *skb, struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct ip6_tnl *t = netdev_priv(dev);
|
|
|
|
const struct iphdr *iph = ip_hdr(skb);
|
|
|
|
int encap_limit = -1;
|
|
|
|
struct flowi6 fl6;
|
|
|
|
__u8 dsfield;
|
|
|
|
__u32 mtu;
|
|
|
|
int err;
|
|
|
|
|
2016-02-21 23:58:05 +00:00
|
|
|
memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
|
|
|
|
|
2012-08-10 00:51:50 +00:00
|
|
|
if (!(t->parms.flags & IP6_TNL_F_IGN_ENCAP_LIMIT))
|
|
|
|
encap_limit = t->parms.encap_limit;
|
|
|
|
|
|
|
|
memcpy(&fl6, &t->fl.u.ip6, sizeof(fl6));
|
|
|
|
|
|
|
|
if (t->parms.flags & IP6_TNL_F_USE_ORIG_TCLASS)
|
2017-05-25 20:35:18 +00:00
|
|
|
dsfield = ipv4_get_dsfield(iph);
|
|
|
|
else
|
|
|
|
dsfield = ip6_tclass(t->parms.flowinfo);
|
2012-08-10 00:51:50 +00:00
|
|
|
if (t->parms.flags & IP6_TNL_F_USE_ORIG_FWMARK)
|
|
|
|
fl6.flowi6_mark = skb->mark;
|
2017-04-19 16:30:53 +00:00
|
|
|
else
|
|
|
|
fl6.flowi6_mark = t->parms.fwmark;
|
2012-08-10 00:51:50 +00:00
|
|
|
|
2016-11-03 17:23:43 +00:00
|
|
|
fl6.flowi6_uid = sock_net_uid(dev_net(dev), NULL);
|
|
|
|
|
2016-04-30 00:12:21 +00:00
|
|
|
err = gre_handle_offloads(skb, !!(t->parms.o_flags & TUNNEL_CSUM));
|
|
|
|
if (err)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
err = __gre6_xmit(skb, dev, dsfield, &fl6, encap_limit, &mtu,
|
|
|
|
skb->protocol);
|
2012-08-10 00:51:50 +00:00
|
|
|
if (err != 0) {
|
|
|
|
/* XXX: send ICMP error even if DF is not set. */
|
|
|
|
if (err == -EMSGSIZE)
|
|
|
|
icmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED,
|
|
|
|
htonl(mtu));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int ip6gre_xmit_ipv6(struct sk_buff *skb, struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct ip6_tnl *t = netdev_priv(dev);
|
|
|
|
struct ipv6hdr *ipv6h = ipv6_hdr(skb);
|
|
|
|
int encap_limit = -1;
|
|
|
|
__u16 offset;
|
|
|
|
struct flowi6 fl6;
|
|
|
|
__u8 dsfield;
|
|
|
|
__u32 mtu;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
if (ipv6_addr_equal(&t->parms.raddr, &ipv6h->saddr))
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
offset = ip6_tnl_parse_tlv_enc_lim(skb, skb_network_header(skb));
|
2017-01-24 00:43:05 +00:00
|
|
|
/* ip6_tnl_parse_tlv_enc_lim() might have reallocated skb->head */
|
|
|
|
ipv6h = ipv6_hdr(skb);
|
|
|
|
|
2012-08-10 00:51:50 +00:00
|
|
|
if (offset > 0) {
|
|
|
|
struct ipv6_tlv_tnl_enc_lim *tel;
|
|
|
|
tel = (struct ipv6_tlv_tnl_enc_lim *)&skb_network_header(skb)[offset];
|
|
|
|
if (tel->encap_limit == 0) {
|
|
|
|
icmpv6_send(skb, ICMPV6_PARAMPROB,
|
|
|
|
ICMPV6_HDR_FIELD, offset + 2);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
encap_limit = tel->encap_limit - 1;
|
|
|
|
} else if (!(t->parms.flags & IP6_TNL_F_IGN_ENCAP_LIMIT))
|
|
|
|
encap_limit = t->parms.encap_limit;
|
|
|
|
|
|
|
|
memcpy(&fl6, &t->fl.u.ip6, sizeof(fl6));
|
|
|
|
|
|
|
|
if (t->parms.flags & IP6_TNL_F_USE_ORIG_TCLASS)
|
2017-05-25 20:35:18 +00:00
|
|
|
dsfield = ipv6_get_dsfield(ipv6h);
|
|
|
|
else
|
|
|
|
dsfield = ip6_tclass(t->parms.flowinfo);
|
|
|
|
|
2012-08-10 00:51:50 +00:00
|
|
|
if (t->parms.flags & IP6_TNL_F_USE_ORIG_FLOWLABEL)
|
2013-12-08 14:47:00 +00:00
|
|
|
fl6.flowlabel |= ip6_flowlabel(ipv6h);
|
2012-08-10 00:51:50 +00:00
|
|
|
if (t->parms.flags & IP6_TNL_F_USE_ORIG_FWMARK)
|
|
|
|
fl6.flowi6_mark = skb->mark;
|
2017-04-19 16:30:53 +00:00
|
|
|
else
|
|
|
|
fl6.flowi6_mark = t->parms.fwmark;
|
2012-08-10 00:51:50 +00:00
|
|
|
|
2016-11-03 17:23:43 +00:00
|
|
|
fl6.flowi6_uid = sock_net_uid(dev_net(dev), NULL);
|
|
|
|
|
2016-04-30 00:12:21 +00:00
|
|
|
if (gre_handle_offloads(skb, !!(t->parms.o_flags & TUNNEL_CSUM)))
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
err = __gre6_xmit(skb, dev, dsfield, &fl6, encap_limit,
|
|
|
|
&mtu, skb->protocol);
|
2012-08-10 00:51:50 +00:00
|
|
|
if (err != 0) {
|
|
|
|
if (err == -EMSGSIZE)
|
|
|
|
icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, mtu);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ip6_tnl_addr_conflict - compare packet addresses to tunnel's own
|
|
|
|
* @t: the outgoing tunnel device
|
|
|
|
* @hdr: IPv6 header from the incoming packet
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Avoid trivial tunneling loop by checking that tunnel exit-point
|
|
|
|
* doesn't match source of incoming packet.
|
|
|
|
*
|
|
|
|
* Return:
|
|
|
|
* 1 if conflict,
|
|
|
|
* 0 else
|
|
|
|
**/
|
|
|
|
|
|
|
|
static inline bool ip6gre_tnl_addr_conflict(const struct ip6_tnl *t,
|
|
|
|
const struct ipv6hdr *hdr)
|
|
|
|
{
|
|
|
|
return ipv6_addr_equal(&t->parms.raddr, &hdr->saddr);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ip6gre_xmit_other(struct sk_buff *skb, struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct ip6_tnl *t = netdev_priv(dev);
|
|
|
|
int encap_limit = -1;
|
|
|
|
struct flowi6 fl6;
|
|
|
|
__u32 mtu;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
if (!(t->parms.flags & IP6_TNL_F_IGN_ENCAP_LIMIT))
|
|
|
|
encap_limit = t->parms.encap_limit;
|
|
|
|
|
|
|
|
memcpy(&fl6, &t->fl.u.ip6, sizeof(fl6));
|
|
|
|
|
2016-04-30 00:12:21 +00:00
|
|
|
err = gre_handle_offloads(skb, !!(t->parms.o_flags & TUNNEL_CSUM));
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
err = __gre6_xmit(skb, dev, 0, &fl6, encap_limit, &mtu, skb->protocol);
|
2012-08-10 00:51:50 +00:00
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static netdev_tx_t ip6gre_tunnel_xmit(struct sk_buff *skb,
|
|
|
|
struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct ip6_tnl *t = netdev_priv(dev);
|
|
|
|
struct net_device_stats *stats = &t->dev->stats;
|
|
|
|
int ret;
|
|
|
|
|
2014-11-05 07:02:48 +00:00
|
|
|
if (!ip6_tnl_xmit_ctl(t, &t->parms.laddr, &t->parms.raddr))
|
2013-02-06 03:24:02 +00:00
|
|
|
goto tx_err;
|
2012-08-10 00:51:50 +00:00
|
|
|
|
|
|
|
switch (skb->protocol) {
|
|
|
|
case htons(ETH_P_IP):
|
|
|
|
ret = ip6gre_xmit_ipv4(skb, dev);
|
|
|
|
break;
|
|
|
|
case htons(ETH_P_IPV6):
|
|
|
|
ret = ip6gre_xmit_ipv6(skb, dev);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
ret = ip6gre_xmit_other(skb, dev);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ret < 0)
|
|
|
|
goto tx_err;
|
|
|
|
|
|
|
|
return NETDEV_TX_OK;
|
|
|
|
|
|
|
|
tx_err:
|
|
|
|
stats->tx_errors++;
|
|
|
|
stats->tx_dropped++;
|
|
|
|
kfree_skb(skb);
|
|
|
|
return NETDEV_TX_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ip6gre_tnl_link_config(struct ip6_tnl *t, int set_mtu)
|
|
|
|
{
|
|
|
|
struct net_device *dev = t->dev;
|
|
|
|
struct __ip6_tnl_parm *p = &t->parms;
|
|
|
|
struct flowi6 *fl6 = &t->fl.u.ip6;
|
2016-05-10 00:12:08 +00:00
|
|
|
int t_hlen;
|
2012-08-10 00:51:50 +00:00
|
|
|
|
|
|
|
if (dev->type != ARPHRD_ETHER) {
|
|
|
|
memcpy(dev->dev_addr, &p->laddr, sizeof(struct in6_addr));
|
|
|
|
memcpy(dev->broadcast, &p->raddr, sizeof(struct in6_addr));
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Set up flowi template */
|
|
|
|
fl6->saddr = p->laddr;
|
|
|
|
fl6->daddr = p->raddr;
|
|
|
|
fl6->flowi6_oif = p->link;
|
|
|
|
fl6->flowlabel = 0;
|
2016-05-21 10:17:35 +00:00
|
|
|
fl6->flowi6_proto = IPPROTO_GRE;
|
2012-08-10 00:51:50 +00:00
|
|
|
|
|
|
|
if (!(p->flags&IP6_TNL_F_USE_ORIG_TCLASS))
|
|
|
|
fl6->flowlabel |= IPV6_TCLASS_MASK & p->flowinfo;
|
|
|
|
if (!(p->flags&IP6_TNL_F_USE_ORIG_FLOWLABEL))
|
|
|
|
fl6->flowlabel |= IPV6_FLOWLABEL_MASK & p->flowinfo;
|
|
|
|
|
|
|
|
p->flags &= ~(IP6_TNL_F_CAP_XMIT|IP6_TNL_F_CAP_RCV|IP6_TNL_F_CAP_PER_PACKET);
|
|
|
|
p->flags |= ip6_tnl_get_cap(t, &p->laddr, &p->raddr);
|
|
|
|
|
|
|
|
if (p->flags&IP6_TNL_F_CAP_XMIT &&
|
|
|
|
p->flags&IP6_TNL_F_CAP_RCV && dev->type != ARPHRD_ETHER)
|
|
|
|
dev->flags |= IFF_POINTOPOINT;
|
|
|
|
else
|
|
|
|
dev->flags &= ~IFF_POINTOPOINT;
|
|
|
|
|
2016-05-10 00:12:08 +00:00
|
|
|
t->tun_hlen = gre_calc_hlen(t->parms.o_flags);
|
|
|
|
|
2016-05-18 16:06:19 +00:00
|
|
|
t->hlen = t->encap_hlen + t->tun_hlen;
|
2016-05-10 00:12:08 +00:00
|
|
|
|
|
|
|
t_hlen = t->hlen + sizeof(struct ipv6hdr);
|
2012-08-10 00:51:50 +00:00
|
|
|
|
|
|
|
if (p->flags & IP6_TNL_F_CAP_XMIT) {
|
|
|
|
int strict = (ipv6_addr_type(&p->raddr) &
|
|
|
|
(IPV6_ADDR_MULTICAST|IPV6_ADDR_LINKLOCAL));
|
|
|
|
|
2014-04-22 08:15:24 +00:00
|
|
|
struct rt6_info *rt = rt6_lookup(t->net,
|
2012-08-10 00:51:50 +00:00
|
|
|
&p->raddr, &p->laddr,
|
|
|
|
p->link, strict);
|
|
|
|
|
2015-03-29 13:00:04 +00:00
|
|
|
if (!rt)
|
2012-08-10 00:51:50 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
if (rt->dst.dev) {
|
2016-05-10 00:12:08 +00:00
|
|
|
dev->hard_header_len = rt->dst.dev->hard_header_len +
|
|
|
|
t_hlen;
|
2012-08-10 00:51:50 +00:00
|
|
|
|
|
|
|
if (set_mtu) {
|
2016-05-10 00:12:08 +00:00
|
|
|
dev->mtu = rt->dst.dev->mtu - t_hlen;
|
2012-08-10 00:51:50 +00:00
|
|
|
if (!(t->parms.flags & IP6_TNL_F_IGN_ENCAP_LIMIT))
|
|
|
|
dev->mtu -= 8;
|
2016-04-14 19:33:45 +00:00
|
|
|
if (dev->type == ARPHRD_ETHER)
|
|
|
|
dev->mtu -= ETH_HLEN;
|
2012-08-10 00:51:50 +00:00
|
|
|
|
|
|
|
if (dev->mtu < IPV6_MIN_MTU)
|
|
|
|
dev->mtu = IPV6_MIN_MTU;
|
|
|
|
}
|
|
|
|
}
|
2012-10-29 00:13:19 +00:00
|
|
|
ip6_rt_put(rt);
|
2012-08-10 00:51:50 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ip6gre_tnl_change(struct ip6_tnl *t,
|
|
|
|
const struct __ip6_tnl_parm *p, int set_mtu)
|
|
|
|
{
|
|
|
|
t->parms.laddr = p->laddr;
|
|
|
|
t->parms.raddr = p->raddr;
|
|
|
|
t->parms.flags = p->flags;
|
|
|
|
t->parms.hop_limit = p->hop_limit;
|
|
|
|
t->parms.encap_limit = p->encap_limit;
|
|
|
|
t->parms.flowinfo = p->flowinfo;
|
|
|
|
t->parms.link = p->link;
|
|
|
|
t->parms.proto = p->proto;
|
|
|
|
t->parms.i_key = p->i_key;
|
|
|
|
t->parms.o_key = p->o_key;
|
|
|
|
t->parms.i_flags = p->i_flags;
|
|
|
|
t->parms.o_flags = p->o_flags;
|
2017-04-19 16:30:53 +00:00
|
|
|
t->parms.fwmark = p->fwmark;
|
2016-02-12 14:43:54 +00:00
|
|
|
dst_cache_reset(&t->dst_cache);
|
2012-08-10 00:51:50 +00:00
|
|
|
ip6gre_tnl_link_config(t, set_mtu);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ip6gre_tnl_parm_from_user(struct __ip6_tnl_parm *p,
|
|
|
|
const struct ip6_tnl_parm2 *u)
|
|
|
|
{
|
|
|
|
p->laddr = u->laddr;
|
|
|
|
p->raddr = u->raddr;
|
|
|
|
p->flags = u->flags;
|
|
|
|
p->hop_limit = u->hop_limit;
|
|
|
|
p->encap_limit = u->encap_limit;
|
|
|
|
p->flowinfo = u->flowinfo;
|
|
|
|
p->link = u->link;
|
|
|
|
p->i_key = u->i_key;
|
|
|
|
p->o_key = u->o_key;
|
2016-05-10 00:12:09 +00:00
|
|
|
p->i_flags = gre_flags_to_tnl_flags(u->i_flags);
|
|
|
|
p->o_flags = gre_flags_to_tnl_flags(u->o_flags);
|
2012-08-10 00:51:50 +00:00
|
|
|
memcpy(p->name, u->name, sizeof(u->name));
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ip6gre_tnl_parm_to_user(struct ip6_tnl_parm2 *u,
|
|
|
|
const struct __ip6_tnl_parm *p)
|
|
|
|
{
|
|
|
|
u->proto = IPPROTO_GRE;
|
|
|
|
u->laddr = p->laddr;
|
|
|
|
u->raddr = p->raddr;
|
|
|
|
u->flags = p->flags;
|
|
|
|
u->hop_limit = p->hop_limit;
|
|
|
|
u->encap_limit = p->encap_limit;
|
|
|
|
u->flowinfo = p->flowinfo;
|
|
|
|
u->link = p->link;
|
|
|
|
u->i_key = p->i_key;
|
|
|
|
u->o_key = p->o_key;
|
2016-05-10 00:12:09 +00:00
|
|
|
u->i_flags = gre_tnl_flags_to_gre_flags(p->i_flags);
|
|
|
|
u->o_flags = gre_tnl_flags_to_gre_flags(p->o_flags);
|
2012-08-10 00:51:50 +00:00
|
|
|
memcpy(u->name, p->name, sizeof(u->name));
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ip6gre_tunnel_ioctl(struct net_device *dev,
|
|
|
|
struct ifreq *ifr, int cmd)
|
|
|
|
{
|
|
|
|
int err = 0;
|
|
|
|
struct ip6_tnl_parm2 p;
|
|
|
|
struct __ip6_tnl_parm p1;
|
2014-04-22 08:15:24 +00:00
|
|
|
struct ip6_tnl *t = netdev_priv(dev);
|
|
|
|
struct net *net = t->net;
|
2012-08-10 00:51:50 +00:00
|
|
|
struct ip6gre_net *ign = net_generic(net, ip6gre_net_id);
|
|
|
|
|
2016-04-30 00:12:17 +00:00
|
|
|
memset(&p1, 0, sizeof(p1));
|
|
|
|
|
2012-08-10 00:51:50 +00:00
|
|
|
switch (cmd) {
|
|
|
|
case SIOCGETTUNNEL:
|
|
|
|
if (dev == ign->fb_tunnel_dev) {
|
|
|
|
if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p))) {
|
|
|
|
err = -EFAULT;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
ip6gre_tnl_parm_from_user(&p1, &p);
|
|
|
|
t = ip6gre_tunnel_locate(net, &p1, 0);
|
2015-03-29 13:00:04 +00:00
|
|
|
if (!t)
|
2014-04-22 08:15:24 +00:00
|
|
|
t = netdev_priv(dev);
|
2012-08-10 00:51:50 +00:00
|
|
|
}
|
2013-05-09 21:56:37 +00:00
|
|
|
memset(&p, 0, sizeof(p));
|
2012-08-10 00:51:50 +00:00
|
|
|
ip6gre_tnl_parm_to_user(&p, &t->parms);
|
|
|
|
if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p)))
|
|
|
|
err = -EFAULT;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SIOCADDTUNNEL:
|
|
|
|
case SIOCCHGTUNNEL:
|
|
|
|
err = -EPERM;
|
net: Allow userns root to control ipv6
Allow an unpriviled user who has created a user namespace, and then
created a network namespace to effectively use the new network
namespace, by reducing capable(CAP_NET_ADMIN) and
capable(CAP_NET_RAW) calls to be ns_capable(net->user_ns,
CAP_NET_ADMIN), or capable(net->user_ns, CAP_NET_RAW) calls.
Settings that merely control a single network device are allowed.
Either the network device is a logical network device where
restrictions make no difference or the network device is hardware NIC
that has been explicity moved from the initial network namespace.
In general policy and network stack state changes are allowed while
resource control is left unchanged.
Allow the SIOCSIFADDR ioctl to add ipv6 addresses.
Allow the SIOCDIFADDR ioctl to delete ipv6 addresses.
Allow the SIOCADDRT ioctl to add ipv6 routes.
Allow the SIOCDELRT ioctl to delete ipv6 routes.
Allow creation of ipv6 raw sockets.
Allow setting the IPV6_JOIN_ANYCAST socket option.
Allow setting the IPV6_FL_A_RENEW parameter of the IPV6_FLOWLABEL_MGR
socket option.
Allow setting the IPV6_TRANSPARENT socket option.
Allow setting the IPV6_HOPOPTS socket option.
Allow setting the IPV6_RTHDRDSTOPTS socket option.
Allow setting the IPV6_DSTOPTS socket option.
Allow setting the IPV6_IPSEC_POLICY socket option.
Allow setting the IPV6_XFRM_POLICY socket option.
Allow sending packets with the IPV6_2292HOPOPTS control message.
Allow sending packets with the IPV6_2292DSTOPTS control message.
Allow sending packets with the IPV6_RTHDRDSTOPTS control message.
Allow setting the multicast routing socket options on non multicast
routing sockets.
Allow the SIOCADDTUNNEL, SIOCCHGTUNNEL, and SIOCDELTUNNEL ioctls for
setting up, changing and deleting tunnels over ipv6.
Allow the SIOCADDTUNNEL, SIOCCHGTUNNEL, SIOCDELTUNNEL ioctls for
setting up, changing and deleting ipv6 over ipv4 tunnels.
Allow the SIOCADDPRL, SIOCDELPRL, SIOCCHGPRL ioctls for adding,
deleting, and changing the potential router list for ISATAP tunnels.
Signed-off-by: "Eric W. Biederman" <ebiederm@xmission.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2012-11-16 03:03:06 +00:00
|
|
|
if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
|
2012-08-10 00:51:50 +00:00
|
|
|
goto done;
|
|
|
|
|
|
|
|
err = -EFAULT;
|
|
|
|
if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
|
|
|
|
goto done;
|
|
|
|
|
|
|
|
err = -EINVAL;
|
|
|
|
if ((p.i_flags|p.o_flags)&(GRE_VERSION|GRE_ROUTING))
|
|
|
|
goto done;
|
|
|
|
|
|
|
|
if (!(p.i_flags&GRE_KEY))
|
|
|
|
p.i_key = 0;
|
|
|
|
if (!(p.o_flags&GRE_KEY))
|
|
|
|
p.o_key = 0;
|
|
|
|
|
|
|
|
ip6gre_tnl_parm_from_user(&p1, &p);
|
|
|
|
t = ip6gre_tunnel_locate(net, &p1, cmd == SIOCADDTUNNEL);
|
|
|
|
|
|
|
|
if (dev != ign->fb_tunnel_dev && cmd == SIOCCHGTUNNEL) {
|
2015-03-29 13:00:05 +00:00
|
|
|
if (t) {
|
2012-08-10 00:51:50 +00:00
|
|
|
if (t->dev != dev) {
|
|
|
|
err = -EEXIST;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
t = netdev_priv(dev);
|
|
|
|
|
|
|
|
ip6gre_tunnel_unlink(ign, t);
|
|
|
|
synchronize_net();
|
|
|
|
ip6gre_tnl_change(t, &p1, 1);
|
|
|
|
ip6gre_tunnel_link(ign, t);
|
|
|
|
netdev_state_change(dev);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (t) {
|
|
|
|
err = 0;
|
|
|
|
|
2013-05-09 21:56:37 +00:00
|
|
|
memset(&p, 0, sizeof(p));
|
2012-08-10 00:51:50 +00:00
|
|
|
ip6gre_tnl_parm_to_user(&p, &t->parms);
|
|
|
|
if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p)))
|
|
|
|
err = -EFAULT;
|
|
|
|
} else
|
|
|
|
err = (cmd == SIOCADDTUNNEL ? -ENOBUFS : -ENOENT);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SIOCDELTUNNEL:
|
|
|
|
err = -EPERM;
|
net: Allow userns root to control ipv6
Allow an unpriviled user who has created a user namespace, and then
created a network namespace to effectively use the new network
namespace, by reducing capable(CAP_NET_ADMIN) and
capable(CAP_NET_RAW) calls to be ns_capable(net->user_ns,
CAP_NET_ADMIN), or capable(net->user_ns, CAP_NET_RAW) calls.
Settings that merely control a single network device are allowed.
Either the network device is a logical network device where
restrictions make no difference or the network device is hardware NIC
that has been explicity moved from the initial network namespace.
In general policy and network stack state changes are allowed while
resource control is left unchanged.
Allow the SIOCSIFADDR ioctl to add ipv6 addresses.
Allow the SIOCDIFADDR ioctl to delete ipv6 addresses.
Allow the SIOCADDRT ioctl to add ipv6 routes.
Allow the SIOCDELRT ioctl to delete ipv6 routes.
Allow creation of ipv6 raw sockets.
Allow setting the IPV6_JOIN_ANYCAST socket option.
Allow setting the IPV6_FL_A_RENEW parameter of the IPV6_FLOWLABEL_MGR
socket option.
Allow setting the IPV6_TRANSPARENT socket option.
Allow setting the IPV6_HOPOPTS socket option.
Allow setting the IPV6_RTHDRDSTOPTS socket option.
Allow setting the IPV6_DSTOPTS socket option.
Allow setting the IPV6_IPSEC_POLICY socket option.
Allow setting the IPV6_XFRM_POLICY socket option.
Allow sending packets with the IPV6_2292HOPOPTS control message.
Allow sending packets with the IPV6_2292DSTOPTS control message.
Allow sending packets with the IPV6_RTHDRDSTOPTS control message.
Allow setting the multicast routing socket options on non multicast
routing sockets.
Allow the SIOCADDTUNNEL, SIOCCHGTUNNEL, and SIOCDELTUNNEL ioctls for
setting up, changing and deleting tunnels over ipv6.
Allow the SIOCADDTUNNEL, SIOCCHGTUNNEL, SIOCDELTUNNEL ioctls for
setting up, changing and deleting ipv6 over ipv4 tunnels.
Allow the SIOCADDPRL, SIOCDELPRL, SIOCCHGPRL ioctls for adding,
deleting, and changing the potential router list for ISATAP tunnels.
Signed-off-by: "Eric W. Biederman" <ebiederm@xmission.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2012-11-16 03:03:06 +00:00
|
|
|
if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
|
2012-08-10 00:51:50 +00:00
|
|
|
goto done;
|
|
|
|
|
|
|
|
if (dev == ign->fb_tunnel_dev) {
|
|
|
|
err = -EFAULT;
|
|
|
|
if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
|
|
|
|
goto done;
|
|
|
|
err = -ENOENT;
|
|
|
|
ip6gre_tnl_parm_from_user(&p1, &p);
|
|
|
|
t = ip6gre_tunnel_locate(net, &p1, 0);
|
2015-03-29 13:00:04 +00:00
|
|
|
if (!t)
|
2012-08-10 00:51:50 +00:00
|
|
|
goto done;
|
|
|
|
err = -EPERM;
|
|
|
|
if (t == netdev_priv(ign->fb_tunnel_dev))
|
|
|
|
goto done;
|
|
|
|
dev = t->dev;
|
|
|
|
}
|
|
|
|
unregister_netdevice(dev);
|
|
|
|
err = 0;
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
err = -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
done:
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ip6gre_header(struct sk_buff *skb, struct net_device *dev,
|
2017-09-15 04:00:07 +00:00
|
|
|
unsigned short type, const void *daddr,
|
|
|
|
const void *saddr, unsigned int len)
|
2012-08-10 00:51:50 +00:00
|
|
|
{
|
|
|
|
struct ip6_tnl *t = netdev_priv(dev);
|
2017-09-15 04:00:07 +00:00
|
|
|
struct ipv6hdr *ipv6h;
|
|
|
|
__be16 *p;
|
2012-08-10 00:51:50 +00:00
|
|
|
|
2017-09-15 04:00:07 +00:00
|
|
|
ipv6h = skb_push(skb, t->hlen + sizeof(*ipv6h));
|
|
|
|
ip6_flow_hdr(ipv6h, 0, ip6_make_flowlabel(dev_net(dev), skb,
|
|
|
|
t->fl.u.ip6.flowlabel,
|
|
|
|
true, &t->fl.u.ip6));
|
2012-08-10 00:51:50 +00:00
|
|
|
ipv6h->hop_limit = t->parms.hop_limit;
|
|
|
|
ipv6h->nexthdr = NEXTHDR_GRE;
|
|
|
|
ipv6h->saddr = t->parms.laddr;
|
|
|
|
ipv6h->daddr = t->parms.raddr;
|
|
|
|
|
2017-09-15 04:00:07 +00:00
|
|
|
p = (__be16 *)(ipv6h + 1);
|
|
|
|
p[0] = t->parms.o_flags;
|
|
|
|
p[1] = htons(type);
|
2012-08-10 00:51:50 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Set the source hardware address.
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (saddr)
|
|
|
|
memcpy(&ipv6h->saddr, saddr, sizeof(struct in6_addr));
|
|
|
|
if (daddr)
|
|
|
|
memcpy(&ipv6h->daddr, daddr, sizeof(struct in6_addr));
|
|
|
|
if (!ipv6_addr_any(&ipv6h->daddr))
|
|
|
|
return t->hlen;
|
|
|
|
|
|
|
|
return -t->hlen;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct header_ops ip6gre_header_ops = {
|
|
|
|
.create = ip6gre_header,
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct net_device_ops ip6gre_netdev_ops = {
|
|
|
|
.ndo_init = ip6gre_tunnel_init,
|
|
|
|
.ndo_uninit = ip6gre_tunnel_uninit,
|
|
|
|
.ndo_start_xmit = ip6gre_tunnel_xmit,
|
|
|
|
.ndo_do_ioctl = ip6gre_tunnel_ioctl,
|
2016-04-30 00:12:21 +00:00
|
|
|
.ndo_change_mtu = ip6_tnl_change_mtu,
|
2013-03-25 14:50:00 +00:00
|
|
|
.ndo_get_stats64 = ip_tunnel_get_stats64,
|
2015-04-02 15:07:01 +00:00
|
|
|
.ndo_get_iflink = ip6_tnl_get_iflink,
|
2012-08-10 00:51:50 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static void ip6gre_dev_free(struct net_device *dev)
|
|
|
|
{
|
2015-09-15 21:30:07 +00:00
|
|
|
struct ip6_tnl *t = netdev_priv(dev);
|
|
|
|
|
2016-02-12 14:43:54 +00:00
|
|
|
dst_cache_destroy(&t->dst_cache);
|
2012-08-10 00:51:50 +00:00
|
|
|
free_percpu(dev->tstats);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ip6gre_tunnel_setup(struct net_device *dev)
|
|
|
|
{
|
|
|
|
dev->netdev_ops = &ip6gre_netdev_ops;
|
net: Fix inconsistent teardown and release of private netdev state.
Network devices can allocate reasources and private memory using
netdev_ops->ndo_init(). However, the release of these resources
can occur in one of two different places.
Either netdev_ops->ndo_uninit() or netdev->destructor().
The decision of which operation frees the resources depends upon
whether it is necessary for all netdev refs to be released before it
is safe to perform the freeing.
netdev_ops->ndo_uninit() presumably can occur right after the
NETDEV_UNREGISTER notifier completes and the unicast and multicast
address lists are flushed.
netdev->destructor(), on the other hand, does not run until the
netdev references all go away.
Further complicating the situation is that netdev->destructor()
almost universally does also a free_netdev().
This creates a problem for the logic in register_netdevice().
Because all callers of register_netdevice() manage the freeing
of the netdev, and invoke free_netdev(dev) if register_netdevice()
fails.
If netdev_ops->ndo_init() succeeds, but something else fails inside
of register_netdevice(), it does call ndo_ops->ndo_uninit(). But
it is not able to invoke netdev->destructor().
This is because netdev->destructor() will do a free_netdev() and
then the caller of register_netdevice() will do the same.
However, this means that the resources that would normally be released
by netdev->destructor() will not be.
Over the years drivers have added local hacks to deal with this, by
invoking their destructor parts by hand when register_netdevice()
fails.
Many drivers do not try to deal with this, and instead we have leaks.
Let's close this hole by formalizing the distinction between what
private things need to be freed up by netdev->destructor() and whether
the driver needs unregister_netdevice() to perform the free_netdev().
netdev->priv_destructor() performs all actions to free up the private
resources that used to be freed by netdev->destructor(), except for
free_netdev().
netdev->needs_free_netdev is a boolean that indicates whether
free_netdev() should be done at the end of unregister_netdevice().
Now, register_netdevice() can sanely release all resources after
ndo_ops->ndo_init() succeeds, by invoking both ndo_ops->ndo_uninit()
and netdev->priv_destructor().
And at the end of unregister_netdevice(), we invoke
netdev->priv_destructor() and optionally call free_netdev().
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-05-08 16:52:56 +00:00
|
|
|
dev->needs_free_netdev = true;
|
|
|
|
dev->priv_destructor = ip6gre_dev_free;
|
2012-08-10 00:51:50 +00:00
|
|
|
|
|
|
|
dev->type = ARPHRD_IP6GRE;
|
2016-04-30 00:12:21 +00:00
|
|
|
|
2012-08-10 00:51:50 +00:00
|
|
|
dev->flags |= IFF_NOARP;
|
|
|
|
dev->addr_len = sizeof(struct in6_addr);
|
2014-10-06 01:38:35 +00:00
|
|
|
netif_keep_dst(dev);
|
2017-01-26 03:59:18 +00:00
|
|
|
/* This perm addr will be used as interface identifier by IPv6 */
|
|
|
|
dev->addr_assign_type = NET_ADDR_RANDOM;
|
|
|
|
eth_random_addr(dev->perm_addr);
|
2012-08-10 00:51:50 +00:00
|
|
|
}
|
|
|
|
|
2017-12-20 16:36:03 +00:00
|
|
|
#define GRE6_FEATURES (NETIF_F_SG | \
|
|
|
|
NETIF_F_FRAGLIST | \
|
|
|
|
NETIF_F_HIGHDMA | \
|
|
|
|
NETIF_F_HW_CSUM)
|
|
|
|
|
|
|
|
static void ip6gre_tnl_init_features(struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct ip6_tnl *nt = netdev_priv(dev);
|
|
|
|
|
|
|
|
dev->features |= GRE6_FEATURES;
|
|
|
|
dev->hw_features |= GRE6_FEATURES;
|
|
|
|
|
|
|
|
if (!(nt->parms.o_flags & TUNNEL_SEQ)) {
|
|
|
|
/* TCP offload with GRE SEQ is not supported, nor
|
|
|
|
* can we support 2 levels of outer headers requiring
|
|
|
|
* an update.
|
|
|
|
*/
|
|
|
|
if (!(nt->parms.o_flags & TUNNEL_CSUM) ||
|
|
|
|
nt->encap.type == TUNNEL_ENCAP_NONE) {
|
|
|
|
dev->features |= NETIF_F_GSO_SOFTWARE;
|
|
|
|
dev->hw_features |= NETIF_F_GSO_SOFTWARE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Can use a lockless transmit, unless we generate
|
|
|
|
* output sequences
|
|
|
|
*/
|
|
|
|
dev->features |= NETIF_F_LLTX;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-09-15 21:30:05 +00:00
|
|
|
static int ip6gre_tunnel_init_common(struct net_device *dev)
|
2012-08-10 00:51:50 +00:00
|
|
|
{
|
|
|
|
struct ip6_tnl *tunnel;
|
2015-09-15 21:30:07 +00:00
|
|
|
int ret;
|
2016-04-30 00:12:21 +00:00
|
|
|
int t_hlen;
|
2012-08-10 00:51:50 +00:00
|
|
|
|
|
|
|
tunnel = netdev_priv(dev);
|
|
|
|
|
|
|
|
tunnel->dev = dev;
|
2013-08-13 15:51:12 +00:00
|
|
|
tunnel->net = dev_net(dev);
|
2012-08-10 00:51:50 +00:00
|
|
|
strcpy(tunnel->parms.name, dev->name);
|
|
|
|
|
2015-09-15 21:30:05 +00:00
|
|
|
dev->tstats = netdev_alloc_pcpu_stats(struct pcpu_sw_netstats);
|
|
|
|
if (!dev->tstats)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2016-02-12 14:43:54 +00:00
|
|
|
ret = dst_cache_init(&tunnel->dst_cache, GFP_KERNEL);
|
2015-09-15 21:30:07 +00:00
|
|
|
if (ret) {
|
|
|
|
free_percpu(dev->tstats);
|
|
|
|
dev->tstats = NULL;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2016-04-30 00:12:21 +00:00
|
|
|
tunnel->tun_hlen = gre_calc_hlen(tunnel->parms.o_flags);
|
2016-05-18 16:06:19 +00:00
|
|
|
tunnel->hlen = tunnel->tun_hlen + tunnel->encap_hlen;
|
2016-05-10 00:12:08 +00:00
|
|
|
t_hlen = tunnel->hlen + sizeof(struct ipv6hdr);
|
2016-04-30 00:12:21 +00:00
|
|
|
|
2016-05-10 00:12:08 +00:00
|
|
|
dev->hard_header_len = LL_MAX_HEADER + t_hlen;
|
|
|
|
dev->mtu = ETH_DATA_LEN - t_hlen;
|
2016-05-21 10:17:34 +00:00
|
|
|
if (dev->type == ARPHRD_ETHER)
|
|
|
|
dev->mtu -= ETH_HLEN;
|
2016-04-30 00:12:21 +00:00
|
|
|
if (!(tunnel->parms.flags & IP6_TNL_F_IGN_ENCAP_LIMIT))
|
|
|
|
dev->mtu -= 8;
|
|
|
|
|
2017-12-20 16:36:03 +00:00
|
|
|
ip6gre_tnl_init_features(dev);
|
|
|
|
|
2015-09-15 21:30:05 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ip6gre_tunnel_init(struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct ip6_tnl *tunnel;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = ip6gre_tunnel_init_common(dev);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
tunnel = netdev_priv(dev);
|
|
|
|
|
2012-08-10 00:51:50 +00:00
|
|
|
memcpy(dev->dev_addr, &tunnel->parms.laddr, sizeof(struct in6_addr));
|
|
|
|
memcpy(dev->broadcast, &tunnel->parms.raddr, sizeof(struct in6_addr));
|
|
|
|
|
|
|
|
if (ipv6_addr_any(&tunnel->parms.raddr))
|
|
|
|
dev->header_ops = &ip6gre_header_ops;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ip6gre_fb_tunnel_init(struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct ip6_tnl *tunnel = netdev_priv(dev);
|
|
|
|
|
|
|
|
tunnel->dev = dev;
|
2013-08-13 15:51:12 +00:00
|
|
|
tunnel->net = dev_net(dev);
|
2012-08-10 00:51:50 +00:00
|
|
|
strcpy(tunnel->parms.name, dev->name);
|
|
|
|
|
|
|
|
tunnel->hlen = sizeof(struct ipv6hdr) + 4;
|
|
|
|
|
|
|
|
dev_hold(dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static struct inet6_protocol ip6gre_protocol __read_mostly = {
|
2016-04-30 00:12:17 +00:00
|
|
|
.handler = gre_rcv,
|
2012-08-10 00:51:50 +00:00
|
|
|
.err_handler = ip6gre_err,
|
|
|
|
.flags = INET6_PROTO_NOPOLICY|INET6_PROTO_FINAL,
|
|
|
|
};
|
|
|
|
|
2014-04-22 08:15:24 +00:00
|
|
|
static void ip6gre_destroy_tunnels(struct net *net, struct list_head *head)
|
2012-08-10 00:51:50 +00:00
|
|
|
{
|
2014-04-22 08:15:24 +00:00
|
|
|
struct ip6gre_net *ign = net_generic(net, ip6gre_net_id);
|
|
|
|
struct net_device *dev, *aux;
|
2012-08-10 00:51:50 +00:00
|
|
|
int prio;
|
|
|
|
|
2014-04-22 08:15:24 +00:00
|
|
|
for_each_netdev_safe(net, dev, aux)
|
|
|
|
if (dev->rtnl_link_ops == &ip6gre_link_ops ||
|
|
|
|
dev->rtnl_link_ops == &ip6gre_tap_ops)
|
|
|
|
unregister_netdevice_queue(dev, head);
|
|
|
|
|
2012-08-10 00:51:50 +00:00
|
|
|
for (prio = 0; prio < 4; prio++) {
|
|
|
|
int h;
|
2016-08-10 09:03:35 +00:00
|
|
|
for (h = 0; h < IP6_GRE_HASH_SIZE; h++) {
|
2012-08-10 00:51:50 +00:00
|
|
|
struct ip6_tnl *t;
|
|
|
|
|
|
|
|
t = rtnl_dereference(ign->tunnels[prio][h]);
|
|
|
|
|
2015-03-29 13:00:05 +00:00
|
|
|
while (t) {
|
2014-04-22 08:15:24 +00:00
|
|
|
/* If dev is in the same netns, it has already
|
|
|
|
* been added to the list by the previous loop.
|
|
|
|
*/
|
|
|
|
if (!net_eq(dev_net(t->dev), net))
|
|
|
|
unregister_netdevice_queue(t->dev,
|
|
|
|
head);
|
2012-08-10 00:51:50 +00:00
|
|
|
t = rtnl_dereference(t->next);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __net_init ip6gre_init_net(struct net *net)
|
|
|
|
{
|
|
|
|
struct ip6gre_net *ign = net_generic(net, ip6gre_net_id);
|
|
|
|
int err;
|
|
|
|
|
|
|
|
ign->fb_tunnel_dev = alloc_netdev(sizeof(struct ip6_tnl), "ip6gre0",
|
net: set name_assign_type in alloc_netdev()
Extend alloc_netdev{,_mq{,s}}() to take name_assign_type as argument, and convert
all users to pass NET_NAME_UNKNOWN.
Coccinelle patch:
@@
expression sizeof_priv, name, setup, txqs, rxqs, count;
@@
(
-alloc_netdev_mqs(sizeof_priv, name, setup, txqs, rxqs)
+alloc_netdev_mqs(sizeof_priv, name, NET_NAME_UNKNOWN, setup, txqs, rxqs)
|
-alloc_netdev_mq(sizeof_priv, name, setup, count)
+alloc_netdev_mq(sizeof_priv, name, NET_NAME_UNKNOWN, setup, count)
|
-alloc_netdev(sizeof_priv, name, setup)
+alloc_netdev(sizeof_priv, name, NET_NAME_UNKNOWN, setup)
)
v9: move comments here from the wrong commit
Signed-off-by: Tom Gundersen <teg@jklm.no>
Reviewed-by: David Herrmann <dh.herrmann@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2014-07-14 14:37:24 +00:00
|
|
|
NET_NAME_UNKNOWN,
|
|
|
|
ip6gre_tunnel_setup);
|
2012-08-10 00:51:50 +00:00
|
|
|
if (!ign->fb_tunnel_dev) {
|
|
|
|
err = -ENOMEM;
|
|
|
|
goto err_alloc_dev;
|
|
|
|
}
|
|
|
|
dev_net_set(ign->fb_tunnel_dev, net);
|
2014-04-22 08:15:24 +00:00
|
|
|
/* FB netdevice is special: we have one, and only one per netns.
|
|
|
|
* Allowing to move it to another netns is clearly unsafe.
|
|
|
|
*/
|
|
|
|
ign->fb_tunnel_dev->features |= NETIF_F_NETNS_LOCAL;
|
|
|
|
|
2012-08-10 00:51:50 +00:00
|
|
|
|
|
|
|
ip6gre_fb_tunnel_init(ign->fb_tunnel_dev);
|
|
|
|
ign->fb_tunnel_dev->rtnl_link_ops = &ip6gre_link_ops;
|
|
|
|
|
|
|
|
err = register_netdev(ign->fb_tunnel_dev);
|
|
|
|
if (err)
|
|
|
|
goto err_reg_dev;
|
|
|
|
|
|
|
|
rcu_assign_pointer(ign->tunnels_wc[0],
|
|
|
|
netdev_priv(ign->fb_tunnel_dev));
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err_reg_dev:
|
net: Fix inconsistent teardown and release of private netdev state.
Network devices can allocate reasources and private memory using
netdev_ops->ndo_init(). However, the release of these resources
can occur in one of two different places.
Either netdev_ops->ndo_uninit() or netdev->destructor().
The decision of which operation frees the resources depends upon
whether it is necessary for all netdev refs to be released before it
is safe to perform the freeing.
netdev_ops->ndo_uninit() presumably can occur right after the
NETDEV_UNREGISTER notifier completes and the unicast and multicast
address lists are flushed.
netdev->destructor(), on the other hand, does not run until the
netdev references all go away.
Further complicating the situation is that netdev->destructor()
almost universally does also a free_netdev().
This creates a problem for the logic in register_netdevice().
Because all callers of register_netdevice() manage the freeing
of the netdev, and invoke free_netdev(dev) if register_netdevice()
fails.
If netdev_ops->ndo_init() succeeds, but something else fails inside
of register_netdevice(), it does call ndo_ops->ndo_uninit(). But
it is not able to invoke netdev->destructor().
This is because netdev->destructor() will do a free_netdev() and
then the caller of register_netdevice() will do the same.
However, this means that the resources that would normally be released
by netdev->destructor() will not be.
Over the years drivers have added local hacks to deal with this, by
invoking their destructor parts by hand when register_netdevice()
fails.
Many drivers do not try to deal with this, and instead we have leaks.
Let's close this hole by formalizing the distinction between what
private things need to be freed up by netdev->destructor() and whether
the driver needs unregister_netdevice() to perform the free_netdev().
netdev->priv_destructor() performs all actions to free up the private
resources that used to be freed by netdev->destructor(), except for
free_netdev().
netdev->needs_free_netdev is a boolean that indicates whether
free_netdev() should be done at the end of unregister_netdevice().
Now, register_netdevice() can sanely release all resources after
ndo_ops->ndo_init() succeeds, by invoking both ndo_ops->ndo_uninit()
and netdev->priv_destructor().
And at the end of unregister_netdevice(), we invoke
netdev->priv_destructor() and optionally call free_netdev().
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-05-08 16:52:56 +00:00
|
|
|
free_netdev(ign->fb_tunnel_dev);
|
2012-08-10 00:51:50 +00:00
|
|
|
err_alloc_dev:
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __net_exit ip6gre_exit_net(struct net *net)
|
|
|
|
{
|
|
|
|
LIST_HEAD(list);
|
|
|
|
|
|
|
|
rtnl_lock();
|
2014-04-22 08:15:24 +00:00
|
|
|
ip6gre_destroy_tunnels(net, &list);
|
2012-08-10 00:51:50 +00:00
|
|
|
unregister_netdevice_many(&list);
|
|
|
|
rtnl_unlock();
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct pernet_operations ip6gre_net_ops = {
|
|
|
|
.init = ip6gre_init_net,
|
|
|
|
.exit = ip6gre_exit_net,
|
|
|
|
.id = &ip6gre_net_id,
|
|
|
|
.size = sizeof(struct ip6gre_net),
|
|
|
|
};
|
|
|
|
|
2017-06-25 21:56:01 +00:00
|
|
|
static int ip6gre_tunnel_validate(struct nlattr *tb[], struct nlattr *data[],
|
|
|
|
struct netlink_ext_ack *extack)
|
2012-08-10 00:51:50 +00:00
|
|
|
{
|
|
|
|
__be16 flags;
|
|
|
|
|
|
|
|
if (!data)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
flags = 0;
|
|
|
|
if (data[IFLA_GRE_IFLAGS])
|
|
|
|
flags |= nla_get_be16(data[IFLA_GRE_IFLAGS]);
|
|
|
|
if (data[IFLA_GRE_OFLAGS])
|
|
|
|
flags |= nla_get_be16(data[IFLA_GRE_OFLAGS]);
|
|
|
|
if (flags & (GRE_VERSION|GRE_ROUTING))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-06-25 21:56:01 +00:00
|
|
|
static int ip6gre_tap_validate(struct nlattr *tb[], struct nlattr *data[],
|
|
|
|
struct netlink_ext_ack *extack)
|
2012-08-10 00:51:50 +00:00
|
|
|
{
|
|
|
|
struct in6_addr daddr;
|
|
|
|
|
|
|
|
if (tb[IFLA_ADDRESS]) {
|
|
|
|
if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
|
|
|
|
return -EINVAL;
|
|
|
|
if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
|
|
|
|
return -EADDRNOTAVAIL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!data)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
if (data[IFLA_GRE_REMOTE]) {
|
2015-03-29 14:59:26 +00:00
|
|
|
daddr = nla_get_in6_addr(data[IFLA_GRE_REMOTE]);
|
2012-08-10 00:51:50 +00:00
|
|
|
if (ipv6_addr_any(&daddr))
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
2017-06-25 21:56:01 +00:00
|
|
|
return ip6gre_tunnel_validate(tb, data, extack);
|
2012-08-10 00:51:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void ip6gre_netlink_parms(struct nlattr *data[],
|
|
|
|
struct __ip6_tnl_parm *parms)
|
|
|
|
{
|
|
|
|
memset(parms, 0, sizeof(*parms));
|
|
|
|
|
|
|
|
if (!data)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (data[IFLA_GRE_LINK])
|
|
|
|
parms->link = nla_get_u32(data[IFLA_GRE_LINK]);
|
|
|
|
|
|
|
|
if (data[IFLA_GRE_IFLAGS])
|
2016-05-10 00:12:09 +00:00
|
|
|
parms->i_flags = gre_flags_to_tnl_flags(
|
|
|
|
nla_get_be16(data[IFLA_GRE_IFLAGS]));
|
2012-08-10 00:51:50 +00:00
|
|
|
|
|
|
|
if (data[IFLA_GRE_OFLAGS])
|
2016-05-10 00:12:09 +00:00
|
|
|
parms->o_flags = gre_flags_to_tnl_flags(
|
|
|
|
nla_get_be16(data[IFLA_GRE_OFLAGS]));
|
2012-08-10 00:51:50 +00:00
|
|
|
|
|
|
|
if (data[IFLA_GRE_IKEY])
|
|
|
|
parms->i_key = nla_get_be32(data[IFLA_GRE_IKEY]);
|
|
|
|
|
|
|
|
if (data[IFLA_GRE_OKEY])
|
|
|
|
parms->o_key = nla_get_be32(data[IFLA_GRE_OKEY]);
|
|
|
|
|
|
|
|
if (data[IFLA_GRE_LOCAL])
|
2015-03-29 14:59:26 +00:00
|
|
|
parms->laddr = nla_get_in6_addr(data[IFLA_GRE_LOCAL]);
|
2012-08-10 00:51:50 +00:00
|
|
|
|
|
|
|
if (data[IFLA_GRE_REMOTE])
|
2015-03-29 14:59:26 +00:00
|
|
|
parms->raddr = nla_get_in6_addr(data[IFLA_GRE_REMOTE]);
|
2012-08-10 00:51:50 +00:00
|
|
|
|
|
|
|
if (data[IFLA_GRE_TTL])
|
|
|
|
parms->hop_limit = nla_get_u8(data[IFLA_GRE_TTL]);
|
|
|
|
|
|
|
|
if (data[IFLA_GRE_ENCAP_LIMIT])
|
|
|
|
parms->encap_limit = nla_get_u8(data[IFLA_GRE_ENCAP_LIMIT]);
|
|
|
|
|
|
|
|
if (data[IFLA_GRE_FLOWINFO])
|
2016-09-24 18:01:04 +00:00
|
|
|
parms->flowinfo = nla_get_be32(data[IFLA_GRE_FLOWINFO]);
|
2012-08-10 00:51:50 +00:00
|
|
|
|
|
|
|
if (data[IFLA_GRE_FLAGS])
|
|
|
|
parms->flags = nla_get_u32(data[IFLA_GRE_FLAGS]);
|
2017-04-19 16:30:53 +00:00
|
|
|
|
|
|
|
if (data[IFLA_GRE_FWMARK])
|
|
|
|
parms->fwmark = nla_get_u32(data[IFLA_GRE_FWMARK]);
|
2012-08-10 00:51:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int ip6gre_tap_init(struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct ip6_tnl *tunnel;
|
2015-09-15 21:30:05 +00:00
|
|
|
int ret;
|
2012-08-10 00:51:50 +00:00
|
|
|
|
2015-09-15 21:30:05 +00:00
|
|
|
ret = ip6gre_tunnel_init_common(dev);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2012-08-10 00:51:50 +00:00
|
|
|
|
2016-06-08 19:15:43 +00:00
|
|
|
dev->priv_flags |= IFF_LIVE_ADDR_CHANGE;
|
|
|
|
|
2015-09-15 21:30:05 +00:00
|
|
|
tunnel = netdev_priv(dev);
|
2012-08-10 00:51:50 +00:00
|
|
|
|
|
|
|
ip6gre_tnl_link_config(tunnel, 1);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct net_device_ops ip6gre_tap_netdev_ops = {
|
|
|
|
.ndo_init = ip6gre_tap_init,
|
|
|
|
.ndo_uninit = ip6gre_tunnel_uninit,
|
|
|
|
.ndo_start_xmit = ip6gre_tunnel_xmit,
|
|
|
|
.ndo_set_mac_address = eth_mac_addr,
|
|
|
|
.ndo_validate_addr = eth_validate_addr,
|
2016-04-30 00:12:21 +00:00
|
|
|
.ndo_change_mtu = ip6_tnl_change_mtu,
|
2013-03-25 14:50:00 +00:00
|
|
|
.ndo_get_stats64 = ip_tunnel_get_stats64,
|
2015-04-02 15:07:01 +00:00
|
|
|
.ndo_get_iflink = ip6_tnl_get_iflink,
|
2012-08-10 00:51:50 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static void ip6gre_tap_setup(struct net_device *dev)
|
|
|
|
{
|
|
|
|
|
|
|
|
ether_setup(dev);
|
|
|
|
|
|
|
|
dev->netdev_ops = &ip6gre_tap_netdev_ops;
|
net: Fix inconsistent teardown and release of private netdev state.
Network devices can allocate reasources and private memory using
netdev_ops->ndo_init(). However, the release of these resources
can occur in one of two different places.
Either netdev_ops->ndo_uninit() or netdev->destructor().
The decision of which operation frees the resources depends upon
whether it is necessary for all netdev refs to be released before it
is safe to perform the freeing.
netdev_ops->ndo_uninit() presumably can occur right after the
NETDEV_UNREGISTER notifier completes and the unicast and multicast
address lists are flushed.
netdev->destructor(), on the other hand, does not run until the
netdev references all go away.
Further complicating the situation is that netdev->destructor()
almost universally does also a free_netdev().
This creates a problem for the logic in register_netdevice().
Because all callers of register_netdevice() manage the freeing
of the netdev, and invoke free_netdev(dev) if register_netdevice()
fails.
If netdev_ops->ndo_init() succeeds, but something else fails inside
of register_netdevice(), it does call ndo_ops->ndo_uninit(). But
it is not able to invoke netdev->destructor().
This is because netdev->destructor() will do a free_netdev() and
then the caller of register_netdevice() will do the same.
However, this means that the resources that would normally be released
by netdev->destructor() will not be.
Over the years drivers have added local hacks to deal with this, by
invoking their destructor parts by hand when register_netdevice()
fails.
Many drivers do not try to deal with this, and instead we have leaks.
Let's close this hole by formalizing the distinction between what
private things need to be freed up by netdev->destructor() and whether
the driver needs unregister_netdevice() to perform the free_netdev().
netdev->priv_destructor() performs all actions to free up the private
resources that used to be freed by netdev->destructor(), except for
free_netdev().
netdev->needs_free_netdev is a boolean that indicates whether
free_netdev() should be done at the end of unregister_netdevice().
Now, register_netdevice() can sanely release all resources after
ndo_ops->ndo_init() succeeds, by invoking both ndo_ops->ndo_uninit()
and netdev->priv_destructor().
And at the end of unregister_netdevice(), we invoke
netdev->priv_destructor() and optionally call free_netdev().
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-05-08 16:52:56 +00:00
|
|
|
dev->needs_free_netdev = true;
|
|
|
|
dev->priv_destructor = ip6gre_dev_free;
|
2012-08-10 00:51:50 +00:00
|
|
|
|
|
|
|
dev->features |= NETIF_F_NETNS_LOCAL;
|
2016-02-17 14:32:53 +00:00
|
|
|
dev->priv_flags &= ~IFF_TX_SKB_SHARING;
|
2016-06-08 19:15:43 +00:00
|
|
|
dev->priv_flags |= IFF_LIVE_ADDR_CHANGE;
|
2017-09-28 05:23:50 +00:00
|
|
|
netif_keep_dst(dev);
|
2012-08-10 00:51:50 +00:00
|
|
|
}
|
|
|
|
|
2016-05-18 16:06:19 +00:00
|
|
|
static bool ip6gre_netlink_encap_parms(struct nlattr *data[],
|
|
|
|
struct ip_tunnel_encap *ipencap)
|
|
|
|
{
|
|
|
|
bool ret = false;
|
|
|
|
|
|
|
|
memset(ipencap, 0, sizeof(*ipencap));
|
|
|
|
|
|
|
|
if (!data)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
if (data[IFLA_GRE_ENCAP_TYPE]) {
|
|
|
|
ret = true;
|
|
|
|
ipencap->type = nla_get_u16(data[IFLA_GRE_ENCAP_TYPE]);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (data[IFLA_GRE_ENCAP_FLAGS]) {
|
|
|
|
ret = true;
|
|
|
|
ipencap->flags = nla_get_u16(data[IFLA_GRE_ENCAP_FLAGS]);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (data[IFLA_GRE_ENCAP_SPORT]) {
|
|
|
|
ret = true;
|
|
|
|
ipencap->sport = nla_get_be16(data[IFLA_GRE_ENCAP_SPORT]);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (data[IFLA_GRE_ENCAP_DPORT]) {
|
|
|
|
ret = true;
|
|
|
|
ipencap->dport = nla_get_be16(data[IFLA_GRE_ENCAP_DPORT]);
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-08-10 00:51:50 +00:00
|
|
|
static int ip6gre_newlink(struct net *src_net, struct net_device *dev,
|
2017-06-25 21:55:59 +00:00
|
|
|
struct nlattr *tb[], struct nlattr *data[],
|
|
|
|
struct netlink_ext_ack *extack)
|
2012-08-10 00:51:50 +00:00
|
|
|
{
|
|
|
|
struct ip6_tnl *nt;
|
|
|
|
struct net *net = dev_net(dev);
|
|
|
|
struct ip6gre_net *ign = net_generic(net, ip6gre_net_id);
|
2016-05-18 16:06:19 +00:00
|
|
|
struct ip_tunnel_encap ipencap;
|
2012-08-10 00:51:50 +00:00
|
|
|
int err;
|
|
|
|
|
|
|
|
nt = netdev_priv(dev);
|
2016-05-18 16:06:19 +00:00
|
|
|
|
|
|
|
if (ip6gre_netlink_encap_parms(data, &ipencap)) {
|
|
|
|
int err = ip6_tnl_encap_setup(nt, &ipencap);
|
|
|
|
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2012-08-10 00:51:50 +00:00
|
|
|
ip6gre_netlink_parms(data, &nt->parms);
|
|
|
|
|
|
|
|
if (ip6gre_tunnel_find(net, &nt->parms, dev->type))
|
|
|
|
return -EEXIST;
|
|
|
|
|
|
|
|
if (dev->type == ARPHRD_ETHER && !tb[IFLA_ADDRESS])
|
|
|
|
eth_hw_addr_random(dev);
|
|
|
|
|
|
|
|
nt->dev = dev;
|
2013-08-13 15:51:12 +00:00
|
|
|
nt->net = dev_net(dev);
|
2012-08-10 00:51:50 +00:00
|
|
|
ip6gre_tnl_link_config(nt, !tb[IFLA_MTU]);
|
|
|
|
|
|
|
|
err = register_netdevice(dev);
|
|
|
|
if (err)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
dev_hold(dev);
|
|
|
|
ip6gre_tunnel_link(ign, nt);
|
|
|
|
|
|
|
|
out:
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ip6gre_changelink(struct net_device *dev, struct nlattr *tb[],
|
2017-06-25 21:56:00 +00:00
|
|
|
struct nlattr *data[],
|
|
|
|
struct netlink_ext_ack *extack)
|
2012-08-10 00:51:50 +00:00
|
|
|
{
|
2014-04-22 08:15:24 +00:00
|
|
|
struct ip6_tnl *t, *nt = netdev_priv(dev);
|
|
|
|
struct net *net = nt->net;
|
2012-08-10 00:51:50 +00:00
|
|
|
struct ip6gre_net *ign = net_generic(net, ip6gre_net_id);
|
|
|
|
struct __ip6_tnl_parm p;
|
2016-05-18 16:06:19 +00:00
|
|
|
struct ip_tunnel_encap ipencap;
|
2012-08-10 00:51:50 +00:00
|
|
|
|
|
|
|
if (dev == ign->fb_tunnel_dev)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2016-05-18 16:06:19 +00:00
|
|
|
if (ip6gre_netlink_encap_parms(data, &ipencap)) {
|
|
|
|
int err = ip6_tnl_encap_setup(nt, &ipencap);
|
|
|
|
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2012-08-10 00:51:50 +00:00
|
|
|
ip6gre_netlink_parms(data, &p);
|
|
|
|
|
|
|
|
t = ip6gre_tunnel_locate(net, &p, 0);
|
|
|
|
|
|
|
|
if (t) {
|
|
|
|
if (t->dev != dev)
|
|
|
|
return -EEXIST;
|
|
|
|
} else {
|
|
|
|
t = nt;
|
|
|
|
}
|
|
|
|
|
2015-12-03 16:21:50 +00:00
|
|
|
ip6gre_tunnel_unlink(ign, t);
|
|
|
|
ip6gre_tnl_change(t, &p, !tb[IFLA_MTU]);
|
|
|
|
ip6gre_tunnel_link(ign, t);
|
2012-08-10 00:51:50 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-04-14 15:11:38 +00:00
|
|
|
static void ip6gre_dellink(struct net_device *dev, struct list_head *head)
|
|
|
|
{
|
|
|
|
struct net *net = dev_net(dev);
|
|
|
|
struct ip6gre_net *ign = net_generic(net, ip6gre_net_id);
|
|
|
|
|
|
|
|
if (dev != ign->fb_tunnel_dev)
|
|
|
|
unregister_netdevice_queue(dev, head);
|
|
|
|
}
|
|
|
|
|
2012-08-10 00:51:50 +00:00
|
|
|
static size_t ip6gre_get_size(const struct net_device *dev)
|
|
|
|
{
|
|
|
|
return
|
|
|
|
/* IFLA_GRE_LINK */
|
|
|
|
nla_total_size(4) +
|
|
|
|
/* IFLA_GRE_IFLAGS */
|
|
|
|
nla_total_size(2) +
|
|
|
|
/* IFLA_GRE_OFLAGS */
|
|
|
|
nla_total_size(2) +
|
|
|
|
/* IFLA_GRE_IKEY */
|
|
|
|
nla_total_size(4) +
|
|
|
|
/* IFLA_GRE_OKEY */
|
|
|
|
nla_total_size(4) +
|
|
|
|
/* IFLA_GRE_LOCAL */
|
2012-11-09 05:34:56 +00:00
|
|
|
nla_total_size(sizeof(struct in6_addr)) +
|
2012-08-10 00:51:50 +00:00
|
|
|
/* IFLA_GRE_REMOTE */
|
2012-11-09 05:34:56 +00:00
|
|
|
nla_total_size(sizeof(struct in6_addr)) +
|
2012-08-10 00:51:50 +00:00
|
|
|
/* IFLA_GRE_TTL */
|
|
|
|
nla_total_size(1) +
|
|
|
|
/* IFLA_GRE_ENCAP_LIMIT */
|
|
|
|
nla_total_size(1) +
|
|
|
|
/* IFLA_GRE_FLOWINFO */
|
|
|
|
nla_total_size(4) +
|
|
|
|
/* IFLA_GRE_FLAGS */
|
|
|
|
nla_total_size(4) +
|
2016-05-18 16:06:19 +00:00
|
|
|
/* IFLA_GRE_ENCAP_TYPE */
|
|
|
|
nla_total_size(2) +
|
|
|
|
/* IFLA_GRE_ENCAP_FLAGS */
|
|
|
|
nla_total_size(2) +
|
|
|
|
/* IFLA_GRE_ENCAP_SPORT */
|
|
|
|
nla_total_size(2) +
|
|
|
|
/* IFLA_GRE_ENCAP_DPORT */
|
|
|
|
nla_total_size(2) +
|
2017-04-19 16:30:53 +00:00
|
|
|
/* IFLA_GRE_FWMARK */
|
|
|
|
nla_total_size(4) +
|
2012-08-10 00:51:50 +00:00
|
|
|
0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ip6gre_fill_info(struct sk_buff *skb, const struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct ip6_tnl *t = netdev_priv(dev);
|
|
|
|
struct __ip6_tnl_parm *p = &t->parms;
|
|
|
|
|
|
|
|
if (nla_put_u32(skb, IFLA_GRE_LINK, p->link) ||
|
2016-05-10 00:12:09 +00:00
|
|
|
nla_put_be16(skb, IFLA_GRE_IFLAGS,
|
|
|
|
gre_tnl_flags_to_gre_flags(p->i_flags)) ||
|
|
|
|
nla_put_be16(skb, IFLA_GRE_OFLAGS,
|
|
|
|
gre_tnl_flags_to_gre_flags(p->o_flags)) ||
|
2012-08-10 00:51:50 +00:00
|
|
|
nla_put_be32(skb, IFLA_GRE_IKEY, p->i_key) ||
|
|
|
|
nla_put_be32(skb, IFLA_GRE_OKEY, p->o_key) ||
|
2015-03-29 14:59:25 +00:00
|
|
|
nla_put_in6_addr(skb, IFLA_GRE_LOCAL, &p->laddr) ||
|
|
|
|
nla_put_in6_addr(skb, IFLA_GRE_REMOTE, &p->raddr) ||
|
2012-08-10 00:51:50 +00:00
|
|
|
nla_put_u8(skb, IFLA_GRE_TTL, p->hop_limit) ||
|
|
|
|
nla_put_u8(skb, IFLA_GRE_ENCAP_LIMIT, p->encap_limit) ||
|
|
|
|
nla_put_be32(skb, IFLA_GRE_FLOWINFO, p->flowinfo) ||
|
2017-04-19 16:30:53 +00:00
|
|
|
nla_put_u32(skb, IFLA_GRE_FLAGS, p->flags) ||
|
|
|
|
nla_put_u32(skb, IFLA_GRE_FWMARK, p->fwmark))
|
2012-08-10 00:51:50 +00:00
|
|
|
goto nla_put_failure;
|
2016-05-18 16:06:19 +00:00
|
|
|
|
|
|
|
if (nla_put_u16(skb, IFLA_GRE_ENCAP_TYPE,
|
|
|
|
t->encap.type) ||
|
|
|
|
nla_put_be16(skb, IFLA_GRE_ENCAP_SPORT,
|
|
|
|
t->encap.sport) ||
|
|
|
|
nla_put_be16(skb, IFLA_GRE_ENCAP_DPORT,
|
|
|
|
t->encap.dport) ||
|
|
|
|
nla_put_u16(skb, IFLA_GRE_ENCAP_FLAGS,
|
|
|
|
t->encap.flags))
|
|
|
|
goto nla_put_failure;
|
|
|
|
|
2012-08-10 00:51:50 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
nla_put_failure:
|
|
|
|
return -EMSGSIZE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct nla_policy ip6gre_policy[IFLA_GRE_MAX + 1] = {
|
|
|
|
[IFLA_GRE_LINK] = { .type = NLA_U32 },
|
|
|
|
[IFLA_GRE_IFLAGS] = { .type = NLA_U16 },
|
|
|
|
[IFLA_GRE_OFLAGS] = { .type = NLA_U16 },
|
|
|
|
[IFLA_GRE_IKEY] = { .type = NLA_U32 },
|
|
|
|
[IFLA_GRE_OKEY] = { .type = NLA_U32 },
|
|
|
|
[IFLA_GRE_LOCAL] = { .len = FIELD_SIZEOF(struct ipv6hdr, saddr) },
|
|
|
|
[IFLA_GRE_REMOTE] = { .len = FIELD_SIZEOF(struct ipv6hdr, daddr) },
|
|
|
|
[IFLA_GRE_TTL] = { .type = NLA_U8 },
|
|
|
|
[IFLA_GRE_ENCAP_LIMIT] = { .type = NLA_U8 },
|
|
|
|
[IFLA_GRE_FLOWINFO] = { .type = NLA_U32 },
|
|
|
|
[IFLA_GRE_FLAGS] = { .type = NLA_U32 },
|
2016-05-18 16:06:19 +00:00
|
|
|
[IFLA_GRE_ENCAP_TYPE] = { .type = NLA_U16 },
|
|
|
|
[IFLA_GRE_ENCAP_FLAGS] = { .type = NLA_U16 },
|
|
|
|
[IFLA_GRE_ENCAP_SPORT] = { .type = NLA_U16 },
|
|
|
|
[IFLA_GRE_ENCAP_DPORT] = { .type = NLA_U16 },
|
2017-04-19 16:30:53 +00:00
|
|
|
[IFLA_GRE_FWMARK] = { .type = NLA_U32 },
|
2012-08-10 00:51:50 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static struct rtnl_link_ops ip6gre_link_ops __read_mostly = {
|
|
|
|
.kind = "ip6gre",
|
|
|
|
.maxtype = IFLA_GRE_MAX,
|
|
|
|
.policy = ip6gre_policy,
|
|
|
|
.priv_size = sizeof(struct ip6_tnl),
|
|
|
|
.setup = ip6gre_tunnel_setup,
|
|
|
|
.validate = ip6gre_tunnel_validate,
|
|
|
|
.newlink = ip6gre_newlink,
|
|
|
|
.changelink = ip6gre_changelink,
|
2014-04-14 15:11:38 +00:00
|
|
|
.dellink = ip6gre_dellink,
|
2012-08-10 00:51:50 +00:00
|
|
|
.get_size = ip6gre_get_size,
|
|
|
|
.fill_info = ip6gre_fill_info,
|
2015-01-15 14:11:17 +00:00
|
|
|
.get_link_net = ip6_tnl_get_link_net,
|
2012-08-10 00:51:50 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static struct rtnl_link_ops ip6gre_tap_ops __read_mostly = {
|
|
|
|
.kind = "ip6gretap",
|
|
|
|
.maxtype = IFLA_GRE_MAX,
|
|
|
|
.policy = ip6gre_policy,
|
|
|
|
.priv_size = sizeof(struct ip6_tnl),
|
|
|
|
.setup = ip6gre_tap_setup,
|
|
|
|
.validate = ip6gre_tap_validate,
|
|
|
|
.newlink = ip6gre_newlink,
|
|
|
|
.changelink = ip6gre_changelink,
|
|
|
|
.get_size = ip6gre_get_size,
|
|
|
|
.fill_info = ip6gre_fill_info,
|
2015-01-20 14:15:43 +00:00
|
|
|
.get_link_net = ip6_tnl_get_link_net,
|
2012-08-10 00:51:50 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* And now the modules code and kernel interface.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int __init ip6gre_init(void)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
|
|
|
pr_info("GRE over IPv6 tunneling driver\n");
|
|
|
|
|
|
|
|
err = register_pernet_device(&ip6gre_net_ops);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
err = inet6_add_protocol(&ip6gre_protocol, IPPROTO_GRE);
|
|
|
|
if (err < 0) {
|
|
|
|
pr_info("%s: can't add protocol\n", __func__);
|
|
|
|
goto add_proto_failed;
|
|
|
|
}
|
|
|
|
|
|
|
|
err = rtnl_link_register(&ip6gre_link_ops);
|
|
|
|
if (err < 0)
|
|
|
|
goto rtnl_link_failed;
|
|
|
|
|
|
|
|
err = rtnl_link_register(&ip6gre_tap_ops);
|
|
|
|
if (err < 0)
|
|
|
|
goto tap_ops_failed;
|
|
|
|
|
|
|
|
out:
|
|
|
|
return err;
|
|
|
|
|
|
|
|
tap_ops_failed:
|
|
|
|
rtnl_link_unregister(&ip6gre_link_ops);
|
|
|
|
rtnl_link_failed:
|
|
|
|
inet6_del_protocol(&ip6gre_protocol, IPPROTO_GRE);
|
|
|
|
add_proto_failed:
|
|
|
|
unregister_pernet_device(&ip6gre_net_ops);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __exit ip6gre_fini(void)
|
|
|
|
{
|
|
|
|
rtnl_link_unregister(&ip6gre_tap_ops);
|
|
|
|
rtnl_link_unregister(&ip6gre_link_ops);
|
|
|
|
inet6_del_protocol(&ip6gre_protocol, IPPROTO_GRE);
|
|
|
|
unregister_pernet_device(&ip6gre_net_ops);
|
|
|
|
}
|
|
|
|
|
|
|
|
module_init(ip6gre_init);
|
|
|
|
module_exit(ip6gre_fini);
|
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
MODULE_AUTHOR("D. Kozlov (xeb@mail.ru)");
|
|
|
|
MODULE_DESCRIPTION("GRE over IPv6 tunneling device");
|
|
|
|
MODULE_ALIAS_RTNL_LINK("ip6gre");
|
2014-09-24 09:03:00 +00:00
|
|
|
MODULE_ALIAS_RTNL_LINK("ip6gretap");
|
2012-08-10 00:51:50 +00:00
|
|
|
MODULE_ALIAS_NETDEV("ip6gre0");
|