[mirror_ubuntu-bionic-kernel.git] / net / ipv6 / fou6.c

#include <linux/module.h>
#include <linux/errno.h>
#include <linux/socket.h>
#include <linux/skbuff.h>
#include <linux/ip.h>
#include <linux/udp.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <net/fou.h>
#include <net/ip.h>
#include <net/ip6_tunnel.h>
#include <net/ip6_checksum.h>
#include <net/protocol.h>
#include <net/udp.h>
#include <net/udp_tunnel.h>

static void fou6_build_udp(struct sk_buff *skb, struct ip_tunnel_encap *e,
			   struct flowi6 *fl6, u8 *protocol, __be16 sport)
{
	struct udphdr *uh;

	skb_push(skb, sizeof(struct udphdr));
	skb_reset_transport_header(skb);

	uh = udp_hdr(skb);

	uh->dest = e->dport;
	uh->source = sport;
	uh->len = htons(skb->len);
	udp6_set_csum(!(e->flags & TUNNEL_ENCAP_FLAG_CSUM6), skb,
		      &fl6->saddr, &fl6->daddr, skb->len);

	*protocol = IPPROTO_UDP;
}

int fou6_build_header(struct sk_buff *skb, struct ip_tunnel_encap *e,
		      u8 *protocol, struct flowi6 *fl6)
{
	__be16 sport;
	int err;
	int type = e->flags & TUNNEL_ENCAP_FLAG_CSUM6 ?
		SKB_GSO_UDP_TUNNEL_CSUM : SKB_GSO_UDP_TUNNEL;

	err = __fou_build_header(skb, e, protocol, &sport, type);
	if (err)
		return err;

	fou6_build_udp(skb, e, fl6, protocol, sport);

	return 0;
}
EXPORT_SYMBOL(fou6_build_header);

int gue6_build_header(struct sk_buff *skb, struct ip_tunnel_encap *e,
		      u8 *protocol, struct flowi6 *fl6)
{
	__be16 sport;
	int err;
	int type = e->flags & TUNNEL_ENCAP_FLAG_CSUM6 ?
		SKB_GSO_UDP_TUNNEL_CSUM : SKB_GSO_UDP_TUNNEL;

	err = __gue_build_header(skb, e, protocol, &sport, type);
	if (err)
		return err;

	fou6_build_udp(skb, e, fl6, protocol, sport);

	return 0;
}
EXPORT_SYMBOL(gue6_build_header);

#if IS_ENABLED(CONFIG_IPV6_FOU_TUNNEL)

static const struct ip6_tnl_encap_ops fou_ip6tun_ops = {
	.encap_hlen = fou_encap_hlen,
	.build_header = fou6_build_header,
};

static const struct ip6_tnl_encap_ops gue_ip6tun_ops = {
	.encap_hlen = gue_encap_hlen,
	.build_header = gue6_build_header,
};

static int ip6_tnl_encap_add_fou_ops(void)
{
	int ret;

	ret = ip6_tnl_encap_add_ops(&fou_ip6tun_ops, TUNNEL_ENCAP_FOU);
	if (ret < 0) {
		pr_err("can't add fou6 ops\n");
		return ret;
	}

	ret = ip6_tnl_encap_add_ops(&gue_ip6tun_ops, TUNNEL_ENCAP_GUE);
	if (ret < 0) {
		pr_err("can't add gue6 ops\n");
		ip6_tnl_encap_del_ops(&fou_ip6tun_ops, TUNNEL_ENCAP_FOU);
		return ret;
	}

	return 0;
}

static void ip6_tnl_encap_del_fou_ops(void)
{
	ip6_tnl_encap_del_ops(&fou_ip6tun_ops, TUNNEL_ENCAP_FOU);
	ip6_tnl_encap_del_ops(&gue_ip6tun_ops, TUNNEL_ENCAP_GUE);
}

#else

static int ip6_tnl_encap_add_fou_ops(void)
{
	return 0;
}

static void ip6_tnl_encap_del_fou_ops(void)
{
}

#endif

static int __init fou6_init(void)
{
	int ret;

	ret = ip6_tnl_encap_add_fou_ops();

	return ret;
}

static void __exit fou6_fini(void)
{
	ip6_tnl_encap_del_fou_ops();
}

module_init(fou6_init);
module_exit(fou6_fini);
MODULE_AUTHOR("Tom Herbert <therbert@google.com>");
MODULE_LICENSE("GPL");
Commit	Line	Data
aa3463d6 TH	1	#include <linux/module.h>
	2	#include <linux/errno.h>
	3	#include <linux/socket.h>
	4	#include <linux/skbuff.h>
	5	#include <linux/ip.h>
	6	#include <linux/udp.h>
	7	#include <linux/types.h>
	8	#include <linux/kernel.h>
	9	#include <net/fou.h>
	10	#include <net/ip.h>
	11	#include <net/ip6_tunnel.h>
	12	#include <net/ip6_checksum.h>
	13	#include <net/protocol.h>
	14	#include <net/udp.h>
	15	#include <net/udp_tunnel.h>
	16
	17	static void fou6_build_udp(struct sk_buff skb, struct ip_tunnel_encap e,
	18	struct flowi6 fl6, u8 protocol, __be16 sport)
	19	{
	20	struct udphdr *uh;
	21
	22	skb_push(skb, sizeof(struct udphdr));
	23	skb_reset_transport_header(skb);
	24
	25	uh = udp_hdr(skb);
	26
	27	uh->dest = e->dport;
	28	uh->source = sport;
	29	uh->len = htons(skb->len);
	30	udp6_set_csum(!(e->flags & TUNNEL_ENCAP_FLAG_CSUM6), skb,
	31	&fl6->saddr, &fl6->daddr, skb->len);
	32
	33	*protocol = IPPROTO_UDP;
	34	}
	35
	36	int fou6_build_header(struct sk_buff skb, struct ip_tunnel_encap e,
	37	u8 protocol, struct flowi6 fl6)
	38	{
	39	__be16 sport;
	40	int err;
	41	int type = e->flags & TUNNEL_ENCAP_FLAG_CSUM6 ?
	42	SKB_GSO_UDP_TUNNEL_CSUM : SKB_GSO_UDP_TUNNEL;
	43
	44	err = __fou_build_header(skb, e, protocol, &sport, type);
	45	if (err)
	46	return err;
	47
	48	fou6_build_udp(skb, e, fl6, protocol, sport);
	49
	50	return 0;
	51	}
	52	EXPORT_SYMBOL(fou6_build_header);
	53
	54	int gue6_build_header(struct sk_buff skb, struct ip_tunnel_encap e,
	55	u8 protocol, struct flowi6 fl6)
	56	{
	57	__be16 sport;
	58	int err;
	59	int type = e->flags & TUNNEL_ENCAP_FLAG_CSUM6 ?
	60	SKB_GSO_UDP_TUNNEL_CSUM : SKB_GSO_UDP_TUNNEL;
	61
	62	err = __gue_build_header(skb, e, protocol, &sport, type);
	63	if (err)
	64	return err;
65
66	fou6_build_udp(skb, e, fl6, protocol, sport);
67
68	return 0;
69	}
70	EXPORT_SYMBOL(gue6_build_header);
71
fabb13db	72	#if IS_ENABLED(CONFIG_IPV6_FOU_TUNNEL)
aa3463d6 TH	73
	74	static const struct ip6_tnl_encap_ops fou_ip6tun_ops = {
	75	.encap_hlen = fou_encap_hlen,
	76	.build_header = fou6_build_header,
	77	};
	78
	79	static const struct ip6_tnl_encap_ops gue_ip6tun_ops = {
	80	.encap_hlen = gue_encap_hlen,
	81	.build_header = gue6_build_header,
	82	};
	83
	84	static int ip6_tnl_encap_add_fou_ops(void)
	85	{
	86	int ret;
	87
	88	ret = ip6_tnl_encap_add_ops(&fou_ip6tun_ops, TUNNEL_ENCAP_FOU);
	89	if (ret < 0) {
	90	pr_err("can't add fou6 ops\n");
	91	return ret;
	92	}
	93
	94	ret = ip6_tnl_encap_add_ops(&gue_ip6tun_ops, TUNNEL_ENCAP_GUE);
	95	if (ret < 0) {
	96	pr_err("can't add gue6 ops\n");
	97	ip6_tnl_encap_del_ops(&fou_ip6tun_ops, TUNNEL_ENCAP_FOU);
	98	return ret;
	99	}
	100
	101	return 0;
	102	}
	103
	104	static void ip6_tnl_encap_del_fou_ops(void)
	105	{
	106	ip6_tnl_encap_del_ops(&fou_ip6tun_ops, TUNNEL_ENCAP_FOU);
	107	ip6_tnl_encap_del_ops(&gue_ip6tun_ops, TUNNEL_ENCAP_GUE);
	108	}
	109
	110	#else
	111
	112	static int ip6_tnl_encap_add_fou_ops(void)
	113	{
	114	return 0;
	115	}
	116
	117	static void ip6_tnl_encap_del_fou_ops(void)
	118	{
	119	}
	120
	121	#endif
	122
	123	static int __init fou6_init(void)
	124	{
	125	int ret;
	126
	127	ret = ip6_tnl_encap_add_fou_ops();
	128
	129	return ret;
	130	}
	131
	132	static void __exit fou6_fini(void)
	133	{
	134	ip6_tnl_encap_del_fou_ops();
	135	}
	136
137	module_init(fou6_init);
138	module_exit(fou6_fini);
139	MODULE_AUTHOR("Tom Herbert <therbert@google.com>");
140	MODULE_LICENSE("GPL");