[linux.git] / include / net / gre.h

/* SPDX-License-Identifier: GPL-2.0 */
#ifndef __LINUX_GRE_H
#define __LINUX_GRE_H

#include <linux/skbuff.h>
#include <net/ip_tunnels.h>

struct gre_base_hdr {
	__be16 flags;
	__be16 protocol;
} __packed;

struct gre_full_hdr {
	struct gre_base_hdr fixed_header;
	__be16 csum;
	__be16 reserved1;
	__be32 key;
	__be32 seq;
} __packed;
#define GRE_HEADER_SECTION 4

#define GREPROTO_CISCO		0
#define GREPROTO_PPTP		1
#define GREPROTO_MAX		2
#define GRE_IP_PROTO_MAX	2

struct gre_protocol {
	int  (*handler)(struct sk_buff *skb);
	void (*err_handler)(struct sk_buff *skb, u32 info);
};

int gre_add_protocol(const struct gre_protocol *proto, u8 version);
int gre_del_protocol(const struct gre_protocol *proto, u8 version);

struct net_device *gretap_fb_dev_create(struct net *net, const char *name,
				       u8 name_assign_type);
int gre_parse_header(struct sk_buff *skb, struct tnl_ptk_info *tpi,
		     bool *csum_err, __be16 proto, int nhs);

static inline bool netif_is_gretap(const struct net_device *dev)
{
	return dev->rtnl_link_ops &&
	       !strcmp(dev->rtnl_link_ops->kind, "gretap");
}

static inline bool netif_is_ip6gretap(const struct net_device *dev)
{
	return dev->rtnl_link_ops &&
	       !strcmp(dev->rtnl_link_ops->kind, "ip6gretap");
}

static inline int gre_calc_hlen(__be16 o_flags)
{
	int addend = 4;

	if (o_flags & TUNNEL_CSUM)
		addend += 4;
	if (o_flags & TUNNEL_KEY)
		addend += 4;
	if (o_flags & TUNNEL_SEQ)
		addend += 4;
	return addend;
}

static inline __be16 gre_flags_to_tnl_flags(__be16 flags)
{
	__be16 tflags = 0;

	if (flags & GRE_CSUM)
		tflags |= TUNNEL_CSUM;
	if (flags & GRE_ROUTING)
		tflags |= TUNNEL_ROUTING;
	if (flags & GRE_KEY)
		tflags |= TUNNEL_KEY;
	if (flags & GRE_SEQ)
		tflags |= TUNNEL_SEQ;
	if (flags & GRE_STRICT)
		tflags |= TUNNEL_STRICT;
	if (flags & GRE_REC)
		tflags |= TUNNEL_REC;
	if (flags & GRE_VERSION)
		tflags |= TUNNEL_VERSION;

	return tflags;
}

static inline __be16 gre_tnl_flags_to_gre_flags(__be16 tflags)
{
	__be16 flags = 0;

	if (tflags & TUNNEL_CSUM)
		flags |= GRE_CSUM;
	if (tflags & TUNNEL_ROUTING)
		flags |= GRE_ROUTING;
	if (tflags & TUNNEL_KEY)
		flags |= GRE_KEY;
	if (tflags & TUNNEL_SEQ)
		flags |= GRE_SEQ;
	if (tflags & TUNNEL_STRICT)
		flags |= GRE_STRICT;
	if (tflags & TUNNEL_REC)
		flags |= GRE_REC;
	if (tflags & TUNNEL_VERSION)
		flags |= GRE_VERSION;

	return flags;
}

static inline void gre_build_header(struct sk_buff *skb, int hdr_len,
				    __be16 flags, __be16 proto,
				    __be32 key, __be32 seq)
{
	struct gre_base_hdr *greh;

	skb_push(skb, hdr_len);

	skb_set_inner_protocol(skb, proto);
	skb_reset_transport_header(skb);
	greh = (struct gre_base_hdr *)skb->data;
	greh->flags = gre_tnl_flags_to_gre_flags(flags);
	greh->protocol = proto;

	if (flags & (TUNNEL_KEY | TUNNEL_CSUM | TUNNEL_SEQ)) {
		__be32 *ptr = (__be32 *)(((u8 *)greh) + hdr_len - 4);

		if (flags & TUNNEL_SEQ) {
			*ptr = seq;
			ptr--;
		}
		if (flags & TUNNEL_KEY) {
			*ptr = key;
			ptr--;
		}
		if (flags & TUNNEL_CSUM &&
		    !(skb_shinfo(skb)->gso_type &
		      (SKB_GSO_GRE | SKB_GSO_GRE_CSUM))) {
			*ptr = 0;
			if (skb->ip_summed == CHECKSUM_PARTIAL) {
				*(__sum16 *)ptr = csum_fold(lco_csum(skb));
			} else {
				skb->ip_summed = CHECKSUM_PARTIAL;
				skb->csum_start = skb_transport_header(skb) - skb->head;
				skb->csum_offset = sizeof(*greh);
			}
		}
	}
}

#endif
Commit	Line	Data
b2441318	1	/* SPDX-License-Identifier: GPL-2.0 */
00959ade DK	2	#ifndef __LINUX_GRE_H
	3	#define __LINUX_GRE_H
	4
	5	#include <linux/skbuff.h>
c5441932	6	#include <net/ip_tunnels.h>
00959ade	7
9f57c67c PS	8	struct gre_base_hdr {
	9	__be16 flags;
	10	__be16 protocol;
ab10dccb GF	11	} __packed;
	12
	13	struct gre_full_hdr {
	14	struct gre_base_hdr fixed_header;
	15	__be16 csum;
	16	__be16 reserved1;
	17	__be32 key;
	18	__be32 seq;
	19	} __packed;
9f57c67c PS	20	#define GRE_HEADER_SECTION 4
9f57c67c PS	21
00959ade DK	22	#define GREPROTO_CISCO 0
	23	#define GREPROTO_PPTP 1
	24	#define GREPROTO_MAX 2
bda7bb46	25	#define GRE_IP_PROTO_MAX 2
00959ade DK	26
	27	struct gre_protocol {
	28	int (handler)(struct sk_buff skb);
	29	void (err_handler)(struct sk_buff skb, u32 info);
	30	};
	31
	32	int gre_add_protocol(const struct gre_protocol *proto, u8 version);
	33	int gre_del_protocol(const struct gre_protocol *proto, u8 version);
	34
b2acd1dc PS	35	struct net_device gretap_fb_dev_create(struct net net, const char *name,
b2acd1dc PS	36	u8 name_assign_type);
95f5c64c	37	int gre_parse_header(struct sk_buff skb, struct tnl_ptk_info tpi,
e582615a	38	bool *csum_err, __be16 proto, int nhs);
95f5c64c	39
0621e6fc OS	40	static inline bool netif_is_gretap(const struct net_device *dev)
	41	{
	42	return dev->rtnl_link_ops &&
	43	!strcmp(dev->rtnl_link_ops->kind, "gretap");
	44	}
	45
	46	static inline bool netif_is_ip6gretap(const struct net_device *dev)
	47	{
	48	return dev->rtnl_link_ops &&
	49	!strcmp(dev->rtnl_link_ops->kind, "ip6gretap");
	50	}
d1b2a6c4	51
95f5c64c TH	52	static inline int gre_calc_hlen(__be16 o_flags)
	53	{
	54	int addend = 4;
	55
	56	if (o_flags & TUNNEL_CSUM)
	57	addend += 4;
	58	if (o_flags & TUNNEL_KEY)
	59	addend += 4;
	60	if (o_flags & TUNNEL_SEQ)
	61	addend += 4;
	62	return addend;
	63	}
	64
	65	static inline __be16 gre_flags_to_tnl_flags(__be16 flags)
	66	{
	67	__be16 tflags = 0;
	68
	69	if (flags & GRE_CSUM)
	70	tflags \|= TUNNEL_CSUM;
	71	if (flags & GRE_ROUTING)
	72	tflags \|= TUNNEL_ROUTING;
	73	if (flags & GRE_KEY)
	74	tflags \|= TUNNEL_KEY;
	75	if (flags & GRE_SEQ)
	76	tflags \|= TUNNEL_SEQ;
	77	if (flags & GRE_STRICT)
	78	tflags \|= TUNNEL_STRICT;
	79	if (flags & GRE_REC)
	80	tflags \|= TUNNEL_REC;
	81	if (flags & GRE_VERSION)
	82	tflags \|= TUNNEL_VERSION;
	83
	84	return tflags;
	85	}
	86
	87	static inline __be16 gre_tnl_flags_to_gre_flags(__be16 tflags)
	88	{
	89	__be16 flags = 0;
	90
	91	if (tflags & TUNNEL_CSUM)
	92	flags \|= GRE_CSUM;
	93	if (tflags & TUNNEL_ROUTING)
	94	flags \|= GRE_ROUTING;
	95	if (tflags & TUNNEL_KEY)
	96	flags \|= GRE_KEY;
	97	if (tflags & TUNNEL_SEQ)
	98	flags \|= GRE_SEQ;
	99	if (tflags & TUNNEL_STRICT)
	100	flags \|= GRE_STRICT;
	101	if (tflags & TUNNEL_REC)
	102	flags \|= GRE_REC;
	103	if (tflags & TUNNEL_VERSION)
	104	flags \|= GRE_VERSION;
	105
	106	return flags;
	107	}
	108
182a352d TH	109	static inline void gre_build_header(struct sk_buff *skb, int hdr_len,
	110	__be16 flags, __be16 proto,
	111	__be32 key, __be32 seq)
	112	{
	113	struct gre_base_hdr *greh;
	114
	115	skb_push(skb, hdr_len);
	116
3d7b3320	117	skb_set_inner_protocol(skb, proto);
182a352d TH	118	skb_reset_transport_header(skb);
	119	greh = (struct gre_base_hdr *)skb->data;
	120	greh->flags = gre_tnl_flags_to_gre_flags(flags);
	121	greh->protocol = proto;
	122
	123	if (flags & (TUNNEL_KEY \| TUNNEL_CSUM \| TUNNEL_SEQ)) {
	124	__be32 ptr = (__be32 )(((u8 *)greh) + hdr_len - 4);
	125
	126	if (flags & TUNNEL_SEQ) {
	127	*ptr = seq;
	128	ptr--;
	129	}
	130	if (flags & TUNNEL_KEY) {
	131	*ptr = key;
	132	ptr--;
	133	}
	134	if (flags & TUNNEL_CSUM &&
	135	!(skb_shinfo(skb)->gso_type &
	136	(SKB_GSO_GRE \| SKB_GSO_GRE_CSUM))) {
	137	*ptr = 0;
efa1a65c XL	138	if (skb->ip_summed == CHECKSUM_PARTIAL) {
	139	(__sum16 )ptr = csum_fold(lco_csum(skb));
	140	} else {
	141	skb->ip_summed = CHECKSUM_PARTIAL;
	142	skb->csum_start = skb_transport_header(skb) - skb->head;
	143	skb->csum_offset = sizeof(*greh);
	144	}
182a352d TH	145	}
	146	}
	147	}
	148
00959ade	149	#endif