Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 058214a4 authored by Tom Herbert's avatar Tom Herbert Committed by David S. Miller
Browse files

ip6_tun: Add infrastructure for doing encapsulation 



Add encap_hlen and ip_tunnel_encap structure to ip6_tnl. Add functions
for getting encap hlen, setting up encap on a tunnel, performing
encapsulation operation.

Signed-off-by: default avatarTom Herbert <tom@herbertland.com>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent 5f914b68

include/net/ip6_tunnel.h

+58 −0
Original line number Diff line number Diff line
@@ -52,10 +52,68 @@ struct ip6_tnl { 
	__u32 o_seqno;	/* The last output seqno */

	int hlen;       /* tun_hlen + encap_hlen */

	int tun_hlen;	/* Precalculated header length */

	int encap_hlen; /* Encap header length (FOU,GUE) */

	struct ip_tunnel_encap encap;

	int mlink;

};



struct ip6_tnl_encap_ops {

	size_t (*encap_hlen)(struct ip_tunnel_encap *e);

	int (*build_header)(struct sk_buff *skb, struct ip_tunnel_encap *e,

			    u8 *protocol, struct flowi6 *fl6);

};



extern const struct ip6_tnl_encap_ops __rcu *

		ip6tun_encaps[MAX_IPTUN_ENCAP_OPS];



int ip6_tnl_encap_add_ops(const struct ip6_tnl_encap_ops *ops,

			  unsigned int num);

int ip6_tnl_encap_del_ops(const struct ip6_tnl_encap_ops *ops,

			  unsigned int num);

int ip6_tnl_encap_setup(struct ip6_tnl *t,

			struct ip_tunnel_encap *ipencap);



static inline int ip6_encap_hlen(struct ip_tunnel_encap *e)

{

	const struct ip6_tnl_encap_ops *ops;

	int hlen = -EINVAL;



	if (e->type == TUNNEL_ENCAP_NONE)

		return 0;



	if (e->type >= MAX_IPTUN_ENCAP_OPS)

		return -EINVAL;



	rcu_read_lock();

	ops = rcu_dereference(ip6tun_encaps[e->type]);

	if (likely(ops && ops->encap_hlen))

		hlen = ops->encap_hlen(e);

	rcu_read_unlock();



	return hlen;

}



static inline int ip6_tnl_encap(struct sk_buff *skb, struct ip6_tnl *t,

				u8 *protocol, struct flowi6 *fl6)

{

	const struct ip6_tnl_encap_ops *ops;

	int ret = -EINVAL;



	if (t->encap.type == TUNNEL_ENCAP_NONE)

		return 0;



	if (t->encap.type >= MAX_IPTUN_ENCAP_OPS)

		return -EINVAL;



	rcu_read_lock();

	ops = rcu_dereference(ip6tun_encaps[t->encap.type]);

	if (likely(ops && ops->build_header))

		ret = ops->build_header(skb, &t->encap, protocol, fl6);

	rcu_read_unlock();



	return ret;

}



/* Tunnel encapsulation limit destination sub-option */



struct ipv6_tlv_tnl_enc_lim {

net/ipv4/ip_tunnel_core.c

+5 −0
Original line number Diff line number Diff line
@@ -37,6 +37,7 @@ 
#include <net/icmp.h>

#include <net/protocol.h>

#include <net/ip_tunnels.h>

#include <net/ip6_tunnel.h>

#include <net/arp.h>

#include <net/checksum.h>

#include <net/dsfield.h>
@@ -51,6 +52,10 @@ const struct ip_tunnel_encap_ops __rcu * 
		iptun_encaps[MAX_IPTUN_ENCAP_OPS] __read_mostly;

EXPORT_SYMBOL(iptun_encaps);



const struct ip6_tnl_encap_ops __rcu *

		ip6tun_encaps[MAX_IPTUN_ENCAP_OPS] __read_mostly;

EXPORT_SYMBOL(ip6tun_encaps);



void iptunnel_xmit(struct sock *sk, struct rtable *rt, struct sk_buff *skb,

		   __be32 src, __be32 dst, __u8 proto,

		   __u8 tos, __u8 ttl, __be16 df, bool xnet)

net/ipv6/ip6_tunnel.c

+81 −13
Original line number Diff line number Diff line
@@ -1010,7 +1010,8 @@ int ip6_tnl_xmit(struct sk_buff *skb, struct net_device *dev, __u8 dsfield, 
	struct dst_entry *dst = NULL, *ndst = NULL;

	struct net_device *tdev;

	int mtu;

	unsigned int max_headroom = sizeof(struct ipv6hdr);

	unsigned int psh_hlen = sizeof(struct ipv6hdr) + t->encap_hlen;

	unsigned int max_headroom = psh_hlen;

	int err = -1;



	/* NBMA tunnel */
@@ -1063,7 +1064,7 @@ int ip6_tnl_xmit(struct sk_buff *skb, struct net_device *dev, __u8 dsfield, 
				     t->parms.name);

		goto tx_err_dst_release;

	}

	mtu = dst_mtu(dst) - sizeof(*ipv6h);

	mtu = dst_mtu(dst) - psh_hlen;

	if (encap_limit >= 0) {

		max_headroom += 8;

		mtu -= 8;
@@ -1124,11 +1125,18 @@ int ip6_tnl_xmit(struct sk_buff *skb, struct net_device *dev, __u8 dsfield, 
		skb->encapsulation = 1;

	}



	/* Calculate max headroom for all the headers and adjust

	 * needed_headroom if necessary.

	 */

	max_headroom = LL_RESERVED_SPACE(dst->dev) + sizeof(struct ipv6hdr)

			+ dst->header_len;

			+ dst->header_len + t->hlen;

	if (max_headroom > dev->needed_headroom)

		dev->needed_headroom = max_headroom;



	err = ip6_tnl_encap(skb, t, &proto, fl6);

	if (err)

		return err;



	skb_push(skb, sizeof(struct ipv6hdr));

	skb_reset_network_header(skb);

	ipv6h = ipv6_hdr(skb);
@@ -1280,6 +1288,7 @@ static void ip6_tnl_link_config(struct ip6_tnl *t) 
	struct net_device *dev = t->dev;

	struct __ip6_tnl_parm *p = &t->parms;

	struct flowi6 *fl6 = &t->fl.u.ip6;

	int t_hlen;



	memcpy(dev->dev_addr, &p->laddr, sizeof(struct in6_addr));

	memcpy(dev->broadcast, &p->raddr, sizeof(struct in6_addr));
@@ -1303,6 +1312,10 @@ static void ip6_tnl_link_config(struct ip6_tnl *t) 
	else

		dev->flags &= ~IFF_POINTOPOINT;



	t->tun_hlen = 0;

	t->hlen = t->encap_hlen + t->tun_hlen;

	t_hlen = t->hlen + sizeof(struct ipv6hdr);



	if (p->flags & IP6_TNL_F_CAP_XMIT) {

		int strict = (ipv6_addr_type(&p->raddr) &

			      (IPV6_ADDR_MULTICAST|IPV6_ADDR_LINKLOCAL));
@@ -1316,9 +1329,9 @@ static void ip6_tnl_link_config(struct ip6_tnl *t) 


		if (rt->dst.dev) {

			dev->hard_header_len = rt->dst.dev->hard_header_len +

				sizeof(struct ipv6hdr);

				t_hlen;



			dev->mtu = rt->dst.dev->mtu - sizeof(struct ipv6hdr);

			dev->mtu = rt->dst.dev->mtu - t_hlen;

			if (!(t->parms.flags & IP6_TNL_F_IGN_ENCAP_LIMIT))

				dev->mtu -= 8;
@@ -1564,6 +1577,59 @@ int ip6_tnl_get_iflink(const struct net_device *dev) 
}

EXPORT_SYMBOL(ip6_tnl_get_iflink);



int ip6_tnl_encap_add_ops(const struct ip6_tnl_encap_ops *ops,

			  unsigned int num)

{

	if (num >= MAX_IPTUN_ENCAP_OPS)

		return -ERANGE;



	return !cmpxchg((const struct ip6_tnl_encap_ops **)

			&ip6tun_encaps[num],

			NULL, ops) ? 0 : -1;

}

EXPORT_SYMBOL(ip6_tnl_encap_add_ops);



int ip6_tnl_encap_del_ops(const struct ip6_tnl_encap_ops *ops,

			  unsigned int num)

{

	int ret;



	if (num >= MAX_IPTUN_ENCAP_OPS)

		return -ERANGE;



	ret = (cmpxchg((const struct ip6_tnl_encap_ops **)

		       &ip6tun_encaps[num],

		       ops, NULL) == ops) ? 0 : -1;



	synchronize_net();



	return ret;

}

EXPORT_SYMBOL(ip6_tnl_encap_del_ops);



int ip6_tnl_encap_setup(struct ip6_tnl *t,

			struct ip_tunnel_encap *ipencap)

{

	int hlen;



	memset(&t->encap, 0, sizeof(t->encap));



	hlen = ip6_encap_hlen(ipencap);

	if (hlen < 0)

		return hlen;



	t->encap.type = ipencap->type;

	t->encap.sport = ipencap->sport;

	t->encap.dport = ipencap->dport;

	t->encap.flags = ipencap->flags;



	t->encap_hlen = hlen;

	t->hlen = t->encap_hlen + t->tun_hlen;



	return 0;

}

EXPORT_SYMBOL_GPL(ip6_tnl_encap_setup);



static const struct net_device_ops ip6_tnl_netdev_ops = {

	.ndo_init	= ip6_tnl_dev_init,

	.ndo_uninit	= ip6_tnl_dev_uninit,
@@ -1585,19 +1651,13 @@ static const struct net_device_ops ip6_tnl_netdev_ops = { 


static void ip6_tnl_dev_setup(struct net_device *dev)

{

	struct ip6_tnl *t;



	dev->netdev_ops = &ip6_tnl_netdev_ops;

	dev->destructor = ip6_dev_free;



	dev->type = ARPHRD_TUNNEL6;

	dev->hard_header_len = LL_MAX_HEADER + sizeof(struct ipv6hdr);

	dev->mtu = ETH_DATA_LEN - sizeof(struct ipv6hdr);

	t = netdev_priv(dev);

	if (!(t->parms.flags & IP6_TNL_F_IGN_ENCAP_LIMIT))

		dev->mtu -= 8;

	dev->flags |= IFF_NOARP;

	dev->addr_len = sizeof(struct in6_addr);

	dev->features |= NETIF_F_LLTX;

	netif_keep_dst(dev);

	/* This perm addr will be used as interface identifier by IPv6 */

	dev->addr_assign_type = NET_ADDR_RANDOM;
@@ -1615,6 +1675,7 @@ ip6_tnl_dev_init_gen(struct net_device *dev) 
{

	struct ip6_tnl *t = netdev_priv(dev);

	int ret;

	int t_hlen;



	t->dev = dev;

	t->net = dev_net(dev);
@@ -1630,8 +1691,15 @@ ip6_tnl_dev_init_gen(struct net_device *dev) 
	if (ret)

		goto destroy_dst;



	t->hlen = 0;

	t->tun_hlen = 0;

	t->hlen = t->encap_hlen + t->tun_hlen;

	t_hlen = t->hlen + sizeof(struct ipv6hdr);



	dev->type = ARPHRD_TUNNEL6;

	dev->hard_header_len = LL_MAX_HEADER + t_hlen;

	dev->mtu = ETH_DATA_LEN - t_hlen;

	if (!(t->parms.flags & IP6_TNL_F_IGN_ENCAP_LIMIT))

		dev->mtu -= 8;



	return 0;