qca-nss-ecm/ecm_types.h - manifest_repos/sdk - Git at Google

 /*
  **************************************************************************
  * Copyright (c) 2014-2015, 2019-2021 The Linux Foundation. All rights reserved.
  * Copyright (c) 2022, Qualcomm Innovation Center, Inc. All rights reserved.
  *
  * Permission to use, copy, modify, and/or distribute this software for
  * any purpose with or without fee is hereby granted, provided that the
  * above copyright notice and this permission notice appear in all copies.
  *
  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
  * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  **************************************************************************
  */
 #ifndef ECM_TYPES_H_
 #define ECM_TYPES_H_

 #include <linux/printk.h>

 /*
  * Common ECM macro to handle the kernel macro name change from kernel version 4.9 and above.
  * GRE_VERSION_1701 and GRE_VERSION_PPTP macros in kernel version <  4.9 needs to be converted
  * to big endian since GRE_VERSION with which it compares is in big endian
  */
 #if (LINUX_VERSION_CODE < KERNEL_VERSION(4, 9, 0))
 #define ECM_GRE_VERSION_0   __cpu_to_be16(GRE_VERSION_1701)
 #define ECM_GRE_VERSION_1   __cpu_to_be16(GRE_VERSION_PPTP)
 typedef struct gre_hdr_pptp ecm_gre_hdr_pptp;
 #else
 #define ECM_GRE_VERSION_0   GRE_VERSION_0
 #define ECM_GRE_VERSION_1   GRE_VERSION_1
 typedef struct pptp_gre_header ecm_gre_hdr_pptp;
 #endif

 /*
  * Flow/Return direction types.
  */
 enum ecm_conn_dir {
 	ECM_CONN_DIR_FLOW,
 	ECM_CONN_DIR_RETURN,
 	ECM_CONN_DIR_MAX
 };

 /*
  * Rule update types.
  */
 enum ecm_rule_update_type {
 	ECM_RULE_UPDATE_TYPE_CONNMARK,
 	ECM_RULE_UPDATE_TYPE_MAX
 };

 /*
  * The ECM IP address is an array of 4 32 bit numbers.
  * This is enough to record both an IPv6 address aswell as an IPv4 address.
  * IPv4 addresses are stored encoded in an IPv6 as the usual ::FFFF:x:y/96
  * We store IP addresses in host order format and NOT network order which is different to Linux network internals.
  */
 typedef uint32_t ip_addr_t[4];

 /*
  * 32/64 bits pointer type
  */
 #ifdef __LP64__
 typedef uint64_t ecm_ptr_t;
 #else
 typedef uint32_t ecm_ptr_t;
 #endif

 #define ECM_IP_ADDR_OCTAL_FMT "%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x"
 #define ECM_IP_ADDR_DOT_FMT "%u.%u.%u.%u"

 #define ECM_IP_ADDR_TO_OCTAL(ipaddrt) ((uint16_t *)ipaddrt)[7], ((uint16_t *)ipaddrt)[6], ((uint16_t *)ipaddrt)[5], ((uint16_t *)ipaddrt)[4], ((uint16_t *)ipaddrt)[3], ((uint16_t *)ipaddrt)[2], ((uint16_t *)ipaddrt)[1], ((uint16_t *)ipaddrt)[0]

 #define ECM_IP_ADDR_TO_DOT(ipaddrt) ((uint8_t *)ipaddrt)[3], ((uint8_t *)ipaddrt)[2], ((uint8_t *)ipaddrt)[1], ((uint8_t *)ipaddrt)[0]

 #define ECM_IP_ADDR_MATCH(a, b) \
 	((a[0] == b[0]) && (a[1] == b[1]) && (a[2] == b[2]) && (a[3] == b[3]))

 #define ECM_IP_ADDR_MASK_MATCH(addr, mask) \
 	(((addr[0] & mask[0]) == mask[0]) && ((addr[1] & mask[1]) == mask[1]) && \
 	((addr[2] & mask[2]) == mask[2]) && ((addr[3] & mask[3]) == mask[3]))

 #define ECM_PORT_MASK_MATCH(port, mask)  ((port & mask) == mask)
 #define ECM_PROTO_MASK_MATCH(proto, mask)  ((proto & mask) == mask)

 #define ECM_MAC_ADDR_MATCH(a, b) \
 	((((uint16_t *)a)[0] == (((uint16_t *)b)[0])) && \
 	(((uint16_t *)a)[1] == (((uint16_t *)b)[1])) && \
 	(((uint16_t *)a)[2] == (((uint16_t *)b)[2])))

 #define ECM_IP_ADDR_IS_V4(a) \
 	((a[1] == 0x0000ffff) && !a[2] && !a[3])

 #define ECM_IP_ADDR_IS_NULL(a) \
 	((a[0] | a[1] | a[2] | a[3]) == 0)

 #define ECM_IP_ADDR_NULL {0, 0, 0, 0}

 #define ECM_MAC_ADDR_STR_BUFF_SIZE		18	/* This is the size of a string in the format of aa:bb:cc:dd:ee:ff */
 #define ECM_IP_ADDR_STR_BUFF_SIZE		40	/* This is the size of a string in the format of aaaa:bbbb:cccc:0000:1111:dddd:eeee:ffff */
 #define ECM_IP_ADDR_DOT_FMT_STR_BUFF_SIZE	16	/* This is the size of a string in the format of 192.168.100.200 */

 /*
  * Type checking functions for various forms of IP address
  * Placing these in a macro, enables the compiler to check
  * that the caller is doing the right thing.
  */
 static inline void ecm_type_check_ecm_ip_addr(ip_addr_t ipaddr){}
 static inline void ecm_type_check_linux_ipv4(__be32 ipaddr){}
 static inline void ecm_type_check_ae_ipv4(uint32_t addr){}
 static inline void ecm_type_check_linux_ipv6(struct in6_addr in6){}
 static inline void ecm_type_check_ae_ipv6(uint32_t ip6[4]){}

 /*
  * This macro copies ip_addr_t's
  * It's usually quicker than a memcpy().
  */
 #define __ECM_IP_ADDR_COPY_NO_CHECK(d, s) \
 	{ \
 		d[0] = s[0]; \
 		d[1] = s[1]; \
 		d[2] = s[2]; \
 		d[3] = s[3]; \
 	}

 #define ECM_IP_ADDR_COPY(d,s) \
 	{ \
 		ecm_type_check_ecm_ip_addr(d); \
 		ecm_type_check_ecm_ip_addr(s); \
 		__ECM_IP_ADDR_COPY_NO_CHECK(d,s); \
 	}

 #define ECM_IP_ADDR_HASH(h, a) \
 	{ \
 		ecm_type_check_ecm_ip_addr(a); \
 		h = a[0] ^ a[1] ^ a[2] ^ a[3]; \
 	}

 /*
  * This macro converts from Linux IPv4 address (network order) to ECM ip_addr_t
  */
 #define ECM_NIN4_ADDR_TO_IP_ADDR(ipaddrt, nin4) \
 	{ \
 		ecm_type_check_ecm_ip_addr(ipaddrt); \
 		ecm_type_check_linux_ipv4(nin4); \
 		ipaddrt[0] = ntohl(nin4); \
 		ipaddrt[1] = 0x0000ffff; \
 		ipaddrt[2] = 0x00000000; \
 		ipaddrt[3] = 0x00000000; \
 	}

 /*
  * This macro converts from ECM ip_addr_t to Linux network IPv4 address
  */
 #define ECM_IP_ADDR_TO_NIN4_ADDR(nin4, ipaddrt) \
 	{ \
 		nin4 = 0; \
 		ecm_type_check_linux_ipv4(nin4); \
 		ecm_type_check_ecm_ip_addr(ipaddrt); \
 		DEBUG_ASSERT(!ipaddrt[3] && !ipaddrt[2] && (ipaddrt[1] == 0x0000ffff), "Not IPv4 address: " ECM_IP_ADDR_OCTAL_FMT "\n", ECM_IP_ADDR_TO_OCTAL(ipaddrt)); \
 		nin4 = htonl(ipaddrt[0]); \
 	}

 /*
  * This macro converts from Linux IPv4 address (host order) to ECM ip_addr_t
  */
 #define ECM_HIN4_ADDR_TO_IP_ADDR(ipaddrt, hin4) \
 	{ \
 		ecm_type_check_linux_ipv4(hin4); \
 		ecm_type_check_ecm_ip_addr(ipaddrt); \
 		ipaddrt[0] = hin4; \
 		ipaddrt[1] = 0x0000ffff; \
 		ipaddrt[2] = 0x00000000; \
 		ipaddrt[3] = 0x00000000; \
 	}

 /*
  * This macro converts from ECM ip_addr_t to Linux Host IPv4 address
  */
 #define ECM_IP_ADDR_TO_HIN4_ADDR(hin4, ipaddrt) \
 	{ \
 		ecm_type_check_linux_ipv4(hin4); \
 		ecm_type_check_ecm_ip_addr(ipaddrt); \
 		DEBUG_ASSERT(!ipaddrt[3] && !ipaddrt[2] && (ipaddrt[1] == 0x0000ffff), "Not IPv4 address: " ECM_IP_ADDR_OCTAL_FMT "\n", ECM_IP_ADDR_TO_OCTAL(ipaddrt)); \
 		hin4 = ipaddrt[0]; \
 	}

 #define ECM_LINUX6_TO_IP_ADDR(d,s) \
 	{ \
 		ecm_type_check_ecm_ip_addr(d); \
 		ecm_type_check_ae_ipv6(s); \
 		__ECM_IP_ADDR_COPY_NO_CHECK(d,s); \
 	}

 #define ECM_IP_ADDR_TO_LINUX6(d,s) \
 	{ \
 		ecm_type_check_ae_ipv6(d); \
 		ecm_type_check_ecm_ip_addr(s); \
 		__ECM_IP_ADDR_COPY_NO_CHECK(d,s); \
 	}

 /*
  * This macro converts from Linux IPv6 address (network order) to ECM ip_addr_t
  */
 #define ECM_NIN6_ADDR_TO_IP_ADDR(ipaddrt, nin6) \
 	{ \
 		ecm_type_check_ecm_ip_addr(ipaddrt); \
 		ecm_type_check_linux_ipv6(nin6); \
 		ipaddrt[0] = ntohl(nin6.in6_u.u6_addr32[3]); \
 		ipaddrt[1] = ntohl(nin6.in6_u.u6_addr32[2]); \
 		ipaddrt[2] = ntohl(nin6.in6_u.u6_addr32[1]); \
 		ipaddrt[3] = ntohl(nin6.in6_u.u6_addr32[0]); \
 	}

 /*
  * This macro converts from ECM ip_addr_t to Linux IPv6 address (network order)
  */
 #define ECM_IP_ADDR_TO_NIN6_ADDR(nin6, ipaddrt) \
 	{ \
 		ecm_type_check_linux_ipv6(nin6); \
 		ecm_type_check_ecm_ip_addr(ipaddrt); \
 		nin6.in6_u.u6_addr32[3] = htonl(ipaddrt[0]); \
 		nin6.in6_u.u6_addr32[2] = htonl(ipaddrt[1]); \
 		nin6.in6_u.u6_addr32[1] = htonl(ipaddrt[2]); \
 		nin6.in6_u.u6_addr32[0] = htonl(ipaddrt[3]); \
 	}

 /*
  * This macro converts from Linux IPv6 address (host order) to ECM ip_addr_t
  */
 #define ECM_HIN6_ADDR_TO_IP_ADDR(ipaddrt, hin6) \
 	{ \
 		ecm_type_check_ecm_ip_addr(ipaddrt); \
 		ecm_type_check_linux_ipv6(hin6); \
 		ipaddrt[0] = hin6.in6_u.u6_addr32[3]; \
 		ipaddrt[1] = hin6.in6_u.u6_addr32[2]; \
 		ipaddrt[2] = hin6.in6_u.u6_addr32[1]; \
 		ipaddrt[3] = hin6.in6_u.u6_addr32[0]; \
 	}

 /*
  * This macro converts from ECM ip_addr_t to Linux IPv6 address (host order)
  */
 #define ECM_IP_ADDR_TO_HIN6_ADDR(hin6, ipaddrt) \
 	{ \
 		ecm_type_check_linux_ipv6(hin6); \
 		ecm_type_check_ecm_ip_addr(ipaddrt); \
 		hin6.in6_u.u6_addr32[0] = ipaddrt[3]; \
 		hin6.in6_u.u6_addr32[1] = ipaddrt[2]; \
 		hin6.in6_u.u6_addr32[2] = ipaddrt[1]; \
 		hin6.in6_u.u6_addr32[3] = ipaddrt[0]; \
 	}

 /*
  * ecm_mac_addr_equal()
  *	Compares two MAC addresses.
  */
 static inline bool ecm_mac_addr_equal(const u8 *addr1, const u8 *addr2)
 {
 	return !ether_addr_equal(addr1, addr2);
 }

 /*
  * ecm_ip_addr_is_non_unicast()
  *	Returns true if the IP address is not unicast
  */
 static inline bool ecm_ip_addr_is_non_unicast(ip_addr_t addr)
 {
 	uint32_t v4_addr = addr[0];

 #ifdef ECM_IPV6_ENABLE
 	if (!ECM_IP_ADDR_IS_V4(addr)) {
 		/*
 		 * IPv6
 		 * ff00::0/8 are multicast
 		 */
 		if (ECM_IP_ADDR_IS_NULL(addr) || ((addr[3] & 0xff000000) == 0xff000000)) {
 			return true;
 		}
 		return false;
 	}
 #endif

 	if (ECM_IP_ADDR_IS_NULL(addr) || ((v4_addr & 0xe0000000) == 0xe0000000)) {
 		return true;
 	}
 	return false;
 }

 /*
  * ecm_ip_addr_is_multicast()
  *	Returns true if the IP address is multicast
  */
 static inline bool ecm_ip_addr_is_multicast(ip_addr_t addr)
 {
 	uint32_t v4_addr = addr[0];

 #ifdef ECM_IPV6_ENABLE
 	if (!ECM_IP_ADDR_IS_V4(addr)) {
 		/*
 		 * IPv6
 		 * ff00::0/8 are multicast
 		 */
 		if (((addr[3] & 0xff000000) == 0xff000000)) {
 			return true;
 		}
 		return false;
 	}
 #endif

 	if (((v4_addr & 0xf0000000) == 0xe0000000)) {
 		return true;
 	}
 	return false;
 }

 #ifdef ECM_MULTICAST_ENABLE
 /*
  * ecm_translate_multicast_mac()
  * 	Create the multicast MAC address given a multicast IP address
  */
 static inline void ecm_translate_multicast_mac(ip_addr_t addr, unsigned char multicast_mac[])
 {
 	uint32_t ip_addr = addr[0];

 	if (ECM_IP_ADDR_IS_V4(addr)) {
 		multicast_mac[0] = 0x01;
 		multicast_mac[1] = 0x00;
 		multicast_mac[2] = 0x5e;
 		multicast_mac[3] = (ip_addr & 0x7f0000) >> 16;
 		multicast_mac[4] = (ip_addr & 0xff00) >> 8;
 		multicast_mac[5] = (ip_addr & 0xff);
 		return;
 	}

 	multicast_mac[0] = 0x33;
 	multicast_mac[1] = 0x33;
 	multicast_mac[2] = (ip_addr & 0xff000000) >> 24;
 	multicast_mac[3] = (ip_addr & 0xff0000) >> 16;
 	multicast_mac[4] = (ip_addr & 0xff00) >> 8;
 	multicast_mac[5] = (ip_addr & 0xff);
 }
 #endif

 /*
  * ecm_ip_addr_in_range()
  *	Tests if a is >= s && <= e
  */
 static inline bool ecm_ip_addr_in_range(ip_addr_t a, ip_addr_t s, ip_addr_t e)
 {
 	if (a[3] > s[3]) goto test_end;
 	if (a[3] < s[3]) return false;
 	/* a[3] == s[3] */
 	if (a[2] > s[2]) goto test_end;
 	if (a[2] < s[2]) return false;
 	/* a[2] == s[2] */
 	if (a[1] > s[1]) goto test_end;
 	if (a[1] < s[1]) return false;
 	/* a[1] == s[1] */
 	if (a[0] > s[0]) goto test_end;
 	if (a[0] < s[0]) return false;
 	/* a[0] == s[0] */

 test_end:
 	;
 	if (a[3] > e[3]) return false;
 	if (a[3] < e[3]) return true;
 	/* a[3] == e[3] */
 	if (a[2] > e[2]) return false;
 	if (a[2] < e[2]) return true;
 	/* a[2] == e[2] */
 	if (a[1] > e[1]) return false;
 	if (a[1] < e[1]) return true;
 	/* a[1] == e[1] */
 	if (a[0] > e[0]) return false;
 	/* a[0] <= e[0] */
 	return true;
 }

 /*
  * ecm_ip_addr_to_string()
  *	Converts the given address to a string either as octal or dotted format
  *
  * Supplied buffer should be at least 40 bytes long.
  */
 static inline void ecm_ip_addr_to_string(char *str, ip_addr_t a)
 {
 #ifdef ECM_IPV6_ENABLE
 	if (!ECM_IP_ADDR_IS_V4(a)) {
 		snprintf(str, ECM_IP_ADDR_STR_BUFF_SIZE, ECM_IP_ADDR_OCTAL_FMT, ECM_IP_ADDR_TO_OCTAL(a));
 		return;
 	}
 #endif

 	snprintf(str, ECM_IP_ADDR_DOT_FMT_STR_BUFF_SIZE, ECM_IP_ADDR_DOT_FMT, ECM_IP_ADDR_TO_DOT(a));
 }

 /*
  * ecm_string_to_ip_addr()
  *	Convert a string IP address to its ECM ip_addr_t representation
  */
 static inline bool ecm_string_to_ip_addr(ip_addr_t addr, char *ip_str)
 {
 	struct in6_addr dbuf;
 	uint8_t *dptr = dbuf.s6_addr;
 	if (in4_pton(ip_str, -1, dptr, '\0', NULL) > 0) {
 		/*
 		 * IPv4
 		 */
 		ECM_NIN4_ADDR_TO_IP_ADDR(addr, dbuf.s6_addr[0]);
 		return true;
 	}
 #ifdef ECM_IPV6_ENABLE
 	if (in6_pton(ip_str, -1, dptr, '\0', NULL) > 0) {
 		/*
 		 * IPv6
 		 */
 		ECM_NIN6_ADDR_TO_IP_ADDR(addr, dbuf);
 		return true;
 	}
 #endif
 	return false;
 }

 /*
  * The following are debug macros used throughout the ECM.
  * Each file that #includes this file MUST have a:
  *
  * #define DEBUG_LEVEL X
  *
  * before the inclusion of this file.
  * X is:
  * 0 = OFF
  * 1 = ASSERTS / ERRORS
  * 2 = 1 + WARN
  * 3 = 2 + INFO
  * 4 = 3 + TRACE
  * NOTE: But X is usually provided by a -D preprocessor defined in the Makefile
  */
 #if (DEBUG_LEVEL < 1)
 #define DEBUG_ASSERT(s, ...)
 #define DEBUG_ERROR(s, ...)
 #define DEBUG_ERROR_RATELIMITED(s, ...)
 #define DEBUG_CHECK_MAGIC(i, m, s, ...)
 #define DEBUG_SET_MAGIC(i, m)
 #define DEBUG_CLEAR_MAGIC(i)
 #define DEBUG_ECM_IP_ADDR_TO_STRING(addr_str, addr)
 #else
 #define DEBUG_ASSERT(c, s, ...) if (!(c)) { pr_emerg("ASSERT: %s:%d:" s, __FUNCTION__, __LINE__, ##__VA_ARGS__); BUG(); }
 #define DEBUG_ERROR(s, ...) pr_err("%s:%d:" s, __FUNCTION__, __LINE__, ##__VA_ARGS__)
 #define DEBUG_ERROR_RATELIMITED(s, ...) pr_err_ratelimited("%s:%d:" s, __FUNCTION__, __LINE__, ##__VA_ARGS__)
 #define DEBUG_CHECK_MAGIC(i, m, s, ...) if (i->magic != m) { DEBUG_ASSERT(false, s, ##__VA_ARGS__); }
 #define DEBUG_SET_MAGIC(i, m) i->magic = m
 #define DEBUG_CLEAR_MAGIC(i) i->magic = 0
 #define DEBUG_ECM_IP_ADDR_TO_STRING(addr_str, addr) ecm_ip_addr_to_string(addr_str, addr);
 #endif

 #if defined(CONFIG_DYNAMIC_DEBUG)
 /*
  * Compile messages for dynamic enable/disable
  */
 #define DEBUG_WARN(s, ...) pr_debug("%s[%d]:" s, __FUNCTION__, __LINE__, ##__VA_ARGS__)
 #define DEBUG_INFO(s, ...) pr_debug("%s[%d]:" s, __FUNCTION__, __LINE__, ##__VA_ARGS__)
 #define DEBUG_TRACE(s, ...) pr_debug("%s[%d]:" s, __FUNCTION__, __LINE__, ##__VA_ARGS__)
 #else

 /*
  * Statically compile messages at different levels
  */
 #if (DEBUG_LEVEL < 2)
 #define DEBUG_WARN(s, ...)
 #else
 #define DEBUG_WARN(s, ...) pr_warn("%s[%d]:" s, __FUNCTION__, __LINE__, ##__VA_ARGS__)
 #endif

 #if (DEBUG_LEVEL < 3)
 #define DEBUG_INFO(s, ...)
 #else
 #define DEBUG_INFO(s, ...) pr_notice("%s[%d]:" s, __FUNCTION__, __LINE__, ##__VA_ARGS__)
 #endif

 #if (DEBUG_LEVEL < 4)
 #define DEBUG_TRACE(s, ...)
 #else
 #define DEBUG_TRACE(s, ...) pr_info("%s[%d]:" s, __FUNCTION__, __LINE__, ##__VA_ARGS__)
 #endif
 #endif
 #endif
	/*
	**************************************************************************
	* Copyright (c) 2014-2015, 2019-2021 The Linux Foundation. All rights reserved.
	* Copyright (c) 2022, Qualcomm Innovation Center, Inc. All rights reserved.
	*
	* Permission to use, copy, modify, and/or distribute this software for
	* any purpose with or without fee is hereby granted, provided that the
	* above copyright notice and this permission notice appear in all copies.
	*
	* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
	* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
	* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
	* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
	* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
	* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
	* OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
	**************************************************************************
	*/
	#ifndef ECM_TYPES_H_
	#define ECM_TYPES_H_

	#include <linux/printk.h>

	/*
	* Common ECM macro to handle the kernel macro name change from kernel version 4.9 and above.
	* GRE_VERSION_1701 and GRE_VERSION_PPTP macros in kernel version < 4.9 needs to be converted
	* to big endian since GRE_VERSION with which it compares is in big endian
	*/
	#if (LINUX_VERSION_CODE < KERNEL_VERSION(4, 9, 0))
	#define ECM_GRE_VERSION_0 __cpu_to_be16(GRE_VERSION_1701)
	#define ECM_GRE_VERSION_1 __cpu_to_be16(GRE_VERSION_PPTP)
	typedef struct gre_hdr_pptp ecm_gre_hdr_pptp;
	#else
	#define ECM_GRE_VERSION_0 GRE_VERSION_0
	#define ECM_GRE_VERSION_1 GRE_VERSION_1
	typedef struct pptp_gre_header ecm_gre_hdr_pptp;
	#endif

	/*
	* Flow/Return direction types.
	*/
	enum ecm_conn_dir {
	ECM_CONN_DIR_FLOW,
	ECM_CONN_DIR_RETURN,
	ECM_CONN_DIR_MAX
	};

	/*
	* Rule update types.
	*/
	enum ecm_rule_update_type {
	ECM_RULE_UPDATE_TYPE_CONNMARK,
	ECM_RULE_UPDATE_TYPE_MAX
	};

	/*
	* The ECM IP address is an array of 4 32 bit numbers.
	* This is enough to record both an IPv6 address aswell as an IPv4 address.
	* IPv4 addresses are stored encoded in an IPv6 as the usual ::FFFF:x:y/96
	* We store IP addresses in host order format and NOT network order which is different to Linux network internals.
	*/
	typedef uint32_t ip_addr_t[4];

	/*
	* 32/64 bits pointer type
	*/
	#ifdef __LP64__
	typedef uint64_t ecm_ptr_t;
	#else
	typedef uint32_t ecm_ptr_t;
	#endif

	#define ECM_IP_ADDR_OCTAL_FMT "%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x"
	#define ECM_IP_ADDR_DOT_FMT "%u.%u.%u.%u"

	#define ECM_IP_ADDR_TO_OCTAL(ipaddrt) ((uint16_t )ipaddrt)[7], ((uint16_t )ipaddrt)[6], ((uint16_t )ipaddrt)[5], ((uint16_t )ipaddrt)[4], ((uint16_t )ipaddrt)[3], ((uint16_t )ipaddrt)[2], ((uint16_t )ipaddrt)[1], ((uint16_t )ipaddrt)[0]

	#define ECM_IP_ADDR_TO_DOT(ipaddrt) ((uint8_t )ipaddrt)[3], ((uint8_t )ipaddrt)[2], ((uint8_t )ipaddrt)[1], ((uint8_t )ipaddrt)[0]

	#define ECM_IP_ADDR_MATCH(a, b) \
	((a[0] == b[0]) && (a[1] == b[1]) && (a[2] == b[2]) && (a[3] == b[3]))

	#define ECM_IP_ADDR_MASK_MATCH(addr, mask) \
	(((addr[0] & mask[0]) == mask[0]) && ((addr[1] & mask[1]) == mask[1]) && \
	((addr[2] & mask[2]) == mask[2]) && ((addr[3] & mask[3]) == mask[3]))

	#define ECM_PORT_MASK_MATCH(port, mask) ((port & mask) == mask)
	#define ECM_PROTO_MASK_MATCH(proto, mask) ((proto & mask) == mask)

	#define ECM_MAC_ADDR_MATCH(a, b) \
	((((uint16_t )a)[0] == (((uint16_t )b)[0])) && \
	(((uint16_t )a)[1] == (((uint16_t )b)[1])) && \
	(((uint16_t )a)[2] == (((uint16_t )b)[2])))

	#define ECM_IP_ADDR_IS_V4(a) \
	((a[1] == 0x0000ffff) && !a[2] && !a[3])

	#define ECM_IP_ADDR_IS_NULL(a) \
	((a[0] \| a[1] \| a[2] \| a[3]) == 0)

	#define ECM_IP_ADDR_NULL {0, 0, 0, 0}

	#define ECM_MAC_ADDR_STR_BUFF_SIZE 18 /* This is the size of a string in the format of aa:bb:cc:dd:ee:ff */
	#define ECM_IP_ADDR_STR_BUFF_SIZE 40 /* This is the size of a string in the format of aaaa:bbbb:cccc:0000:1111:dddd:eeee:ffff */
	#define ECM_IP_ADDR_DOT_FMT_STR_BUFF_SIZE 16 /* This is the size of a string in the format of 192.168.100.200 */

	/*
	* Type checking functions for various forms of IP address
	* Placing these in a macro, enables the compiler to check
	* that the caller is doing the right thing.
	*/
	static inline void ecm_type_check_ecm_ip_addr(ip_addr_t ipaddr){}
	static inline void ecm_type_check_linux_ipv4(__be32 ipaddr){}
	static inline void ecm_type_check_ae_ipv4(uint32_t addr){}
	static inline void ecm_type_check_linux_ipv6(struct in6_addr in6){}
	static inline void ecm_type_check_ae_ipv6(uint32_t ip6[4]){}

	/*
	* This macro copies ip_addr_t's
	* It's usually quicker than a memcpy().
	*/
	#define __ECM_IP_ADDR_COPY_NO_CHECK(d, s) \
	{ \
	d[0] = s[0]; \
	d[1] = s[1]; \
	d[2] = s[2]; \
	d[3] = s[3]; \
	}

	#define ECM_IP_ADDR_COPY(d,s) \
	{ \
	ecm_type_check_ecm_ip_addr(d); \
	ecm_type_check_ecm_ip_addr(s); \
	__ECM_IP_ADDR_COPY_NO_CHECK(d,s); \
	}

	#define ECM_IP_ADDR_HASH(h, a) \
	{ \
	ecm_type_check_ecm_ip_addr(a); \
	h = a[0] ^ a[1] ^ a[2] ^ a[3]; \
	}

	/*
	* This macro converts from Linux IPv4 address (network order) to ECM ip_addr_t
	*/
	#define ECM_NIN4_ADDR_TO_IP_ADDR(ipaddrt, nin4) \
	{ \
	ecm_type_check_ecm_ip_addr(ipaddrt); \
	ecm_type_check_linux_ipv4(nin4); \
	ipaddrt[0] = ntohl(nin4); \
	ipaddrt[1] = 0x0000ffff; \
	ipaddrt[2] = 0x00000000; \
	ipaddrt[3] = 0x00000000; \
	}

	/*
	* This macro converts from ECM ip_addr_t to Linux network IPv4 address
	*/
	#define ECM_IP_ADDR_TO_NIN4_ADDR(nin4, ipaddrt) \
	{ \
	nin4 = 0; \
	ecm_type_check_linux_ipv4(nin4); \
	ecm_type_check_ecm_ip_addr(ipaddrt); \
	DEBUG_ASSERT(!ipaddrt[3] && !ipaddrt[2] && (ipaddrt[1] == 0x0000ffff), "Not IPv4 address: " ECM_IP_ADDR_OCTAL_FMT "\n", ECM_IP_ADDR_TO_OCTAL(ipaddrt)); \
	nin4 = htonl(ipaddrt[0]); \
	}

	/*
	* This macro converts from Linux IPv4 address (host order) to ECM ip_addr_t
	*/
	#define ECM_HIN4_ADDR_TO_IP_ADDR(ipaddrt, hin4) \
	{ \
	ecm_type_check_linux_ipv4(hin4); \
	ecm_type_check_ecm_ip_addr(ipaddrt); \
	ipaddrt[0] = hin4; \
	ipaddrt[1] = 0x0000ffff; \
	ipaddrt[2] = 0x00000000; \
	ipaddrt[3] = 0x00000000; \
	}

	/*
	* This macro converts from ECM ip_addr_t to Linux Host IPv4 address
	*/
	#define ECM_IP_ADDR_TO_HIN4_ADDR(hin4, ipaddrt) \
	{ \
	ecm_type_check_linux_ipv4(hin4); \
	ecm_type_check_ecm_ip_addr(ipaddrt); \
	DEBUG_ASSERT(!ipaddrt[3] && !ipaddrt[2] && (ipaddrt[1] == 0x0000ffff), "Not IPv4 address: " ECM_IP_ADDR_OCTAL_FMT "\n", ECM_IP_ADDR_TO_OCTAL(ipaddrt)); \
	hin4 = ipaddrt[0]; \
	}

	#define ECM_LINUX6_TO_IP_ADDR(d,s) \
	{ \
	ecm_type_check_ecm_ip_addr(d); \
	ecm_type_check_ae_ipv6(s); \
	__ECM_IP_ADDR_COPY_NO_CHECK(d,s); \
	}

	#define ECM_IP_ADDR_TO_LINUX6(d,s) \
	{ \
	ecm_type_check_ae_ipv6(d); \
	ecm_type_check_ecm_ip_addr(s); \
	__ECM_IP_ADDR_COPY_NO_CHECK(d,s); \
	}

	/*
	* This macro converts from Linux IPv6 address (network order) to ECM ip_addr_t
	*/
	#define ECM_NIN6_ADDR_TO_IP_ADDR(ipaddrt, nin6) \
	{ \
	ecm_type_check_ecm_ip_addr(ipaddrt); \
	ecm_type_check_linux_ipv6(nin6); \
	ipaddrt[0] = ntohl(nin6.in6_u.u6_addr32[3]); \
	ipaddrt[1] = ntohl(nin6.in6_u.u6_addr32[2]); \
	ipaddrt[2] = ntohl(nin6.in6_u.u6_addr32[1]); \
	ipaddrt[3] = ntohl(nin6.in6_u.u6_addr32[0]); \
	}

	/*
	* This macro converts from ECM ip_addr_t to Linux IPv6 address (network order)
	*/
	#define ECM_IP_ADDR_TO_NIN6_ADDR(nin6, ipaddrt) \
	{ \
	ecm_type_check_linux_ipv6(nin6); \
	ecm_type_check_ecm_ip_addr(ipaddrt); \
	nin6.in6_u.u6_addr32[3] = htonl(ipaddrt[0]); \
	nin6.in6_u.u6_addr32[2] = htonl(ipaddrt[1]); \
	nin6.in6_u.u6_addr32[1] = htonl(ipaddrt[2]); \
	nin6.in6_u.u6_addr32[0] = htonl(ipaddrt[3]); \
	}

	/*
	* This macro converts from Linux IPv6 address (host order) to ECM ip_addr_t
	*/
	#define ECM_HIN6_ADDR_TO_IP_ADDR(ipaddrt, hin6) \
	{ \
	ecm_type_check_ecm_ip_addr(ipaddrt); \
	ecm_type_check_linux_ipv6(hin6); \
	ipaddrt[0] = hin6.in6_u.u6_addr32[3]; \
	ipaddrt[1] = hin6.in6_u.u6_addr32[2]; \
	ipaddrt[2] = hin6.in6_u.u6_addr32[1]; \
	ipaddrt[3] = hin6.in6_u.u6_addr32[0]; \
	}

	/*
	* This macro converts from ECM ip_addr_t to Linux IPv6 address (host order)
	*/
	#define ECM_IP_ADDR_TO_HIN6_ADDR(hin6, ipaddrt) \
	{ \
	ecm_type_check_linux_ipv6(hin6); \
	ecm_type_check_ecm_ip_addr(ipaddrt); \
	hin6.in6_u.u6_addr32[0] = ipaddrt[3]; \
	hin6.in6_u.u6_addr32[1] = ipaddrt[2]; \
	hin6.in6_u.u6_addr32[2] = ipaddrt[1]; \
	hin6.in6_u.u6_addr32[3] = ipaddrt[0]; \
	}

	/*
	* ecm_mac_addr_equal()
	* Compares two MAC addresses.
	*/
	static inline bool ecm_mac_addr_equal(const u8 addr1, const u8 addr2)
	{
	return !ether_addr_equal(addr1, addr2);
	}

	/*
	* ecm_ip_addr_is_non_unicast()
	* Returns true if the IP address is not unicast
	*/
	static inline bool ecm_ip_addr_is_non_unicast(ip_addr_t addr)
	{
	uint32_t v4_addr = addr[0];

	#ifdef ECM_IPV6_ENABLE
	if (!ECM_IP_ADDR_IS_V4(addr)) {
	/*
	* IPv6
	* ff00::0/8 are multicast
	*/
	if (ECM_IP_ADDR_IS_NULL(addr) \|\| ((addr[3] & 0xff000000) == 0xff000000)) {
	return true;
	}
	return false;
	}
	#endif

	if (ECM_IP_ADDR_IS_NULL(addr) \|\| ((v4_addr & 0xe0000000) == 0xe0000000)) {
	return true;
	}
	return false;
	}

	/*
	* ecm_ip_addr_is_multicast()
	* Returns true if the IP address is multicast
	*/
	static inline bool ecm_ip_addr_is_multicast(ip_addr_t addr)
	{
	uint32_t v4_addr = addr[0];

	#ifdef ECM_IPV6_ENABLE
	if (!ECM_IP_ADDR_IS_V4(addr)) {
	/*
	* IPv6
	* ff00::0/8 are multicast
	*/
	if (((addr[3] & 0xff000000) == 0xff000000)) {
	return true;
	}
	return false;
	}
	#endif

	if (((v4_addr & 0xf0000000) == 0xe0000000)) {
	return true;
	}
	return false;
	}

	#ifdef ECM_MULTICAST_ENABLE
	/*
	* ecm_translate_multicast_mac()
	* Create the multicast MAC address given a multicast IP address
	*/
	static inline void ecm_translate_multicast_mac(ip_addr_t addr, unsigned char multicast_mac[])
	{
	uint32_t ip_addr = addr[0];

	if (ECM_IP_ADDR_IS_V4(addr)) {
	multicast_mac[0] = 0x01;
	multicast_mac[1] = 0x00;
	multicast_mac[2] = 0x5e;
	multicast_mac[3] = (ip_addr & 0x7f0000) >> 16;
	multicast_mac[4] = (ip_addr & 0xff00) >> 8;
	multicast_mac[5] = (ip_addr & 0xff);
	return;
	}

	multicast_mac[0] = 0x33;
	multicast_mac[1] = 0x33;
	multicast_mac[2] = (ip_addr & 0xff000000) >> 24;
	multicast_mac[3] = (ip_addr & 0xff0000) >> 16;
	multicast_mac[4] = (ip_addr & 0xff00) >> 8;
	multicast_mac[5] = (ip_addr & 0xff);
	}
	#endif

	/*
	* ecm_ip_addr_in_range()
	* Tests if a is >= s && <= e
	*/
	static inline bool ecm_ip_addr_in_range(ip_addr_t a, ip_addr_t s, ip_addr_t e)
	{
	if (a[3] > s[3]) goto test_end;
	if (a[3] < s[3]) return false;
	/* a[3] == s[3] */
	if (a[2] > s[2]) goto test_end;
	if (a[2] < s[2]) return false;
	/* a[2] == s[2] */
	if (a[1] > s[1]) goto test_end;
	if (a[1] < s[1]) return false;
	/* a[1] == s[1] */
	if (a[0] > s[0]) goto test_end;
	if (a[0] < s[0]) return false;
	/* a[0] == s[0] */

	test_end:
	;
	if (a[3] > e[3]) return false;
	if (a[3] < e[3]) return true;
	/* a[3] == e[3] */
	if (a[2] > e[2]) return false;
	if (a[2] < e[2]) return true;
	/* a[2] == e[2] */
	if (a[1] > e[1]) return false;
	if (a[1] < e[1]) return true;
	/* a[1] == e[1] */
	if (a[0] > e[0]) return false;
	/* a[0] <= e[0] */
	return true;
	}

	/*
	* ecm_ip_addr_to_string()
	* Converts the given address to a string either as octal or dotted format
	*
	* Supplied buffer should be at least 40 bytes long.
	*/
	static inline void ecm_ip_addr_to_string(char *str, ip_addr_t a)
	{
	#ifdef ECM_IPV6_ENABLE
	if (!ECM_IP_ADDR_IS_V4(a)) {
	snprintf(str, ECM_IP_ADDR_STR_BUFF_SIZE, ECM_IP_ADDR_OCTAL_FMT, ECM_IP_ADDR_TO_OCTAL(a));
	return;
	}
	#endif

	snprintf(str, ECM_IP_ADDR_DOT_FMT_STR_BUFF_SIZE, ECM_IP_ADDR_DOT_FMT, ECM_IP_ADDR_TO_DOT(a));
	}

	/*
	* ecm_string_to_ip_addr()
	* Convert a string IP address to its ECM ip_addr_t representation
	*/
	static inline bool ecm_string_to_ip_addr(ip_addr_t addr, char *ip_str)
	{
	struct in6_addr dbuf;
	uint8_t *dptr = dbuf.s6_addr;
	if (in4_pton(ip_str, -1, dptr, '\0', NULL) > 0) {
	/*
	* IPv4
	*/
	ECM_NIN4_ADDR_TO_IP_ADDR(addr, dbuf.s6_addr[0]);
	return true;
	}
	#ifdef ECM_IPV6_ENABLE
	if (in6_pton(ip_str, -1, dptr, '\0', NULL) > 0) {
	/*
	* IPv6
	*/
	ECM_NIN6_ADDR_TO_IP_ADDR(addr, dbuf);
	return true;
	}
	#endif
	return false;
	}

	/*
	* The following are debug macros used throughout the ECM.
	* Each file that #includes this file MUST have a:
	*
	* #define DEBUG_LEVEL X
	*
	* before the inclusion of this file.
	* X is:
	* 0 = OFF
	* 1 = ASSERTS / ERRORS
	* 2 = 1 + WARN
	* 3 = 2 + INFO
	* 4 = 3 + TRACE
	* NOTE: But X is usually provided by a -D preprocessor defined in the Makefile
	*/
	#if (DEBUG_LEVEL < 1)
	#define DEBUG_ASSERT(s, ...)
	#define DEBUG_ERROR(s, ...)
	#define DEBUG_ERROR_RATELIMITED(s, ...)
	#define DEBUG_CHECK_MAGIC(i, m, s, ...)
	#define DEBUG_SET_MAGIC(i, m)
	#define DEBUG_CLEAR_MAGIC(i)
	#define DEBUG_ECM_IP_ADDR_TO_STRING(addr_str, addr)
	#else
	#define DEBUG_ASSERT(c, s, ...) if (!(c)) { pr_emerg("ASSERT: %s:%d:" s, __FUNCTION__, __LINE__, ##__VA_ARGS__); BUG(); }
	#define DEBUG_ERROR(s, ...) pr_err("%s:%d:" s, __FUNCTION__, __LINE__, ##__VA_ARGS__)
	#define DEBUG_ERROR_RATELIMITED(s, ...) pr_err_ratelimited("%s:%d:" s, __FUNCTION__, __LINE__, ##__VA_ARGS__)
	#define DEBUG_CHECK_MAGIC(i, m, s, ...) if (i->magic != m) { DEBUG_ASSERT(false, s, ##__VA_ARGS__); }
	#define DEBUG_SET_MAGIC(i, m) i->magic = m
	#define DEBUG_CLEAR_MAGIC(i) i->magic = 0
	#define DEBUG_ECM_IP_ADDR_TO_STRING(addr_str, addr) ecm_ip_addr_to_string(addr_str, addr);
	#endif

	#if defined(CONFIG_DYNAMIC_DEBUG)
	/*
	* Compile messages for dynamic enable/disable
	*/
	#define DEBUG_WARN(s, ...) pr_debug("%s[%d]:" s, __FUNCTION__, __LINE__, ##__VA_ARGS__)
	#define DEBUG_INFO(s, ...) pr_debug("%s[%d]:" s, __FUNCTION__, __LINE__, ##__VA_ARGS__)
	#define DEBUG_TRACE(s, ...) pr_debug("%s[%d]:" s, __FUNCTION__, __LINE__, ##__VA_ARGS__)
	#else

	/*
	* Statically compile messages at different levels
	*/
	#if (DEBUG_LEVEL < 2)
	#define DEBUG_WARN(s, ...)
	#else
	#define DEBUG_WARN(s, ...) pr_warn("%s[%d]:" s, __FUNCTION__, __LINE__, ##__VA_ARGS__)
	#endif

	#if (DEBUG_LEVEL < 3)
	#define DEBUG_INFO(s, ...)
	#else
	#define DEBUG_INFO(s, ...) pr_notice("%s[%d]:" s, __FUNCTION__, __LINE__, ##__VA_ARGS__)
	#endif

	#if (DEBUG_LEVEL < 4)
	#define DEBUG_TRACE(s, ...)
	#else
	#define DEBUG_TRACE(s, ...) pr_info("%s[%d]:" s, __FUNCTION__, __LINE__, ##__VA_ARGS__)
	#endif
	#endif
	#endif