proto.c File Reference

#include <stddef.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <net/if_arp.h>
#include <arpa/inet.h>
#include <linux/netfilter.h>
#include <expression.h>
#include <headers.h>
#include <proto.h>
#include <gmputil.h>
#include <utils.h>
#include <netinet/ip_icmp.h>
#include <netinet/udp.h>
#include <netinet/tcp.h>
#include <netinet/ip.h>
#include <netinet/icmp6.h>
#include <net/ethernet.h>

Include dependency graph for proto.c:

Macros
#define	HDR_TEMPLATE(__name, __dtype, __type, __member)
#define	HDR_FIELD(__name, __struct, __member)   HDR_TEMPLATE(__name, &integer_type, __struct, __member)
#define	HDR_BITFIELD(__name, __dtype,__offset, __len)
#define	HDR_TYPE(__name, __dtype, __struct, __member)   HDR_TEMPLATE(__name, __dtype, __struct, __member)
#define	INET_PROTOCOL(__name, __struct, __member)   HDR_TYPE(__name, &inet_protocol_type, __struct, __member)
#define	INET_SERVICE(__name, __struct, __member)   HDR_TYPE(__name, &inet_service_type, __struct, __member)
#define	AHHDR_FIELD(__name, __member)   HDR_FIELD(__name, struct ip_auth_hdr, __member)
#define	ESPHDR_FIELD(__name, __member)   HDR_FIELD(__name, struct ip_esp_hdr, __member)
#define	COMPHDR_FIELD(__name, __member)   HDR_FIELD(__name, struct ip_comp_hdr, __member)
#define	ICMPHDR_FIELD(__name, __member)   HDR_FIELD(__name, struct icmphdr, __member)
#define	ICMPHDR_TYPE(__name, __type, __member)   HDR_TYPE(__name, __type, struct icmphdr, __member)
#define	UDPHDR_FIELD(__name, __member)   HDR_FIELD(__name, struct udphdr, __member)
#define	TCPHDR_FIELD(__name, __member)   HDR_FIELD(__name, struct tcphdr, __member)
#define	DCCPHDR_FIELD(__name, __member)   HDR_FIELD(__name, struct dccp_hdr, __member)
#define	SCTPHDR_FIELD(__name, __member)   HDR_FIELD(__name, struct sctphdr, __member)
#define	IPHDR_FIELD(__name, __member)   HDR_FIELD(__name, struct iphdr, __member)
#define	IPHDR_ADDR(__name, __member)   HDR_TYPE(__name, &ipaddr_type, struct iphdr, __member)
#define	ICMP6HDR_FIELD(__name, __member)   HDR_FIELD(__name, struct icmp6_hdr, __member)
#define	ICMP6HDR_TYPE(__name, __type, __member)   HDR_TYPE(__name, __type, struct icmp6_hdr, __member)
#define	IP6HDR_FIELD(__name,__member)   HDR_FIELD(__name, struct ipv6hdr, __member)
#define	IP6HDR_ADDR(__name, __member)   HDR_TYPE(__name, &ip6addr_type, struct ipv6hdr, __member)
#define	IP6HDR_PROTOCOL(__name, __member)   HDR_TYPE(__name, &inet_service_type, struct ipv6hdr, __member)
#define	ARPHDR_TYPE(__name, __type, __member)   HDR_TYPE(__name, __type, struct arphdr, __member)
#define	ARPHDR_FIELD(__name, __member)   HDR_FIELD(__name, struct arphdr, __member)
#define	VLANHDR_BITFIELD(__name, __offset, __len)   HDR_BITFIELD(__name, &integer_type, __offset, __len)
#define	VLANHDR_TYPE(__name, __type, __member)   HDR_TYPE(__name, __type, struct vlan_hdr, __member)
#define	ETHHDR_TEMPLATE(__name, __dtype, __member)   HDR_TEMPLATE(__name, __dtype, struct ether_header, __member)
#define	ETHHDR_TYPE(__name, __member)   ETHHDR_TEMPLATE(__name, &ethertype_type, __member)
#define	ETHHDR_ADDR(__name, __member)

Functions
const struct proto_desc *	proto_find_upper (const struct proto_desc *base, unsigned int num)
	proto_find_upper - find higher layer protocol description by protocol value linking it to the lower layer protocol More...
int	proto_find_num (const struct proto_desc *base, const struct proto_desc *desc)
	proto_find_num - return protocol number linking two protocols together More...
int	proto_dev_type (const struct proto_desc *desc, uint16_t *res)
	proto_dev_type - return arphrd type linking a device and a protocol together More...
const struct proto_desc *	proto_dev_desc (uint16_t type)
	proto_dev_desc - return protocol description for an arphrd type More...
void	proto_ctx_init (struct proto_ctx *ctx, unsigned int family)
	proto_ctx_init - initialize protocol context for a given hook family More...
void	proto_ctx_update (struct proto_ctx *ctx, enum proto_bases base, const struct location *loc, const struct proto_desc *desc)
	proto_ctx_update: update protocol context for given protocol base More...

Variables
const char *	proto_base_names []
const char *	proto_base_tokens []
const struct proto_hdr_template	proto_unknown_template
const struct proto_desc	proto_unknown
const struct hook_proto_desc	hook_proto_desc []
const struct proto_desc	proto_ah
const struct proto_desc	proto_esp
const struct proto_desc	proto_comp
const struct proto_desc	proto_icmp
const struct proto_desc	proto_udp
const struct proto_desc	proto_udplite
const struct proto_desc	proto_tcp
const struct proto_desc	proto_dccp
const struct proto_desc	proto_sctp
const struct proto_desc	proto_ip
const struct proto_desc	proto_icmp6
const struct proto_desc	proto_ip6
const struct proto_desc	proto_inet
const struct proto_desc	proto_inet_service
const struct proto_desc	proto_arp
const struct proto_desc	proto_vlan
const struct datatype	etheraddr_type
const struct datatype	ethertype_type
const struct proto_desc	proto_eth

Macro Definition Documentation

#define AHHDR_FIELD	(		__name,
			__member
	)		HDR_FIELD(__name, struct ip_auth_hdr, __member)

#define ARPHDR_FIELD	(		__name,
			__member
	)		HDR_FIELD(__name, struct arphdr, __member)

#define ARPHDR_TYPE	(		__name,
			__type,
			__member
	)		HDR_TYPE(__name, __type, struct arphdr, __member)

#define COMPHDR_FIELD	(		__name,
			__member
	)		HDR_FIELD(__name, struct ip_comp_hdr, __member)

#define DCCPHDR_FIELD	(		__name,
			__member
	)		HDR_FIELD(__name, struct dccp_hdr, __member)

#define ESPHDR_FIELD	(		__name,
			__member
	)		HDR_FIELD(__name, struct ip_esp_hdr, __member)

#define ETHHDR_ADDR	(		__name,
			__member
	)

Value:

PROTO_HDR_TEMPLATE(__name, &etheraddr_type,     \
               BYTEORDER_HOST_ENDIAN,       \
               offsetof(struct ether_header, __member) * 8, \
               field_sizeof(struct ether_header, __member) * 8)

#define ETHHDR_TEMPLATE	(		__name,
			__dtype,
			__member
	)		HDR_TEMPLATE(__name, __dtype, struct ether_header, __member)

#define ETHHDR_TYPE	(		__name,
			__member
	)		ETHHDR_TEMPLATE(__name, &ethertype_type, __member)

#define HDR_BITFIELD	(		__name,
			__dtype,
			__offset,
			__len
	)

Value:

PROTO_HDR_TEMPLATE(__name, __dtype, BYTEORDER_BIG_ENDIAN,   \
               __offset, __len)

#define HDR_FIELD	(		__name,
			__struct,
			__member
	)		HDR_TEMPLATE(__name, &integer_type, __struct, __member)

#define HDR_TEMPLATE	(		__name,
			__dtype,
			__type,
			__member
	)

Value:

PROTO_HDR_TEMPLATE(__name, __dtype,             \
               BYTEORDER_BIG_ENDIAN,            \
               offsetof(__type, __member) * 8,      \
               field_sizeof(__type, __member) * 8)

#define HDR_TYPE	(		__name,
			__dtype,
			__struct,
			__member
	)		HDR_TEMPLATE(__name, __dtype, __struct, __member)

#define ICMP6HDR_FIELD	(		__name,
			__member
	)		HDR_FIELD(__name, struct icmp6_hdr, __member)

#define ICMP6HDR_TYPE	(		__name,
			__type,
			__member
	)		HDR_TYPE(__name, __type, struct icmp6_hdr, __member)

#define ICMPHDR_FIELD	(		__name,
			__member
	)		HDR_FIELD(__name, struct icmphdr, __member)

#define ICMPHDR_TYPE	(		__name,
			__type,
			__member
	)		HDR_TYPE(__name, __type, struct icmphdr, __member)

#define INET_PROTOCOL	(		__name,
			__struct,
			__member
	)		HDR_TYPE(__name, &inet_protocol_type, __struct, __member)

#define INET_SERVICE	(		__name,
			__struct,
			__member
	)		HDR_TYPE(__name, &inet_service_type, __struct, __member)

#define IP6HDR_ADDR	(		__name,
			__member
	)		HDR_TYPE(__name, &ip6addr_type, struct ipv6hdr, __member)

#define IP6HDR_FIELD	(		__name,
			__member
	)		HDR_FIELD(__name, struct ipv6hdr, __member)

#define IP6HDR_PROTOCOL	(		__name,
			__member
	)		HDR_TYPE(__name, &inet_service_type, struct ipv6hdr, __member)

#define IPHDR_ADDR	(		__name,
			__member
	)		HDR_TYPE(__name, &ipaddr_type, struct iphdr, __member)

#define IPHDR_FIELD	(		__name,
			__member
	)		HDR_FIELD(__name, struct iphdr, __member)

#define SCTPHDR_FIELD	(		__name,
			__member
	)		HDR_FIELD(__name, struct sctphdr, __member)

#define TCPHDR_FIELD	(		__name,
			__member
	)		HDR_FIELD(__name, struct tcphdr, __member)

#define UDPHDR_FIELD	(		__name,
			__member
	)		HDR_FIELD(__name, struct udphdr, __member)

#define VLANHDR_BITFIELD	(		__name,
			__offset,
			__len
	)		HDR_BITFIELD(__name, &integer_type, __offset, __len)

#define VLANHDR_TYPE	(		__name,
			__type,
			__member
	)		HDR_TYPE(__name, __type, struct vlan_hdr, __member)

Function Documentation

void proto_ctx_init	(	struct proto_ctx *	ctx,
		unsigned int	family
	)

proto_ctx_init - initialize protocol context for a given hook family

: protocol context : hook family

References hook_proto_desc::base, hook_proto_desc::desc, proto_ctx::desc, proto_ctx::family, and proto_ctx::protocol.

void proto_ctx_update	(	struct proto_ctx *	ctx,
		enum proto_bases	base,
		const struct location *	loc,
		const struct proto_desc *	desc
	)

proto_ctx_update: update protocol context for given protocol base

: protocol context : protocol base : location of the relational expression definiting the context : protocol description for the given layer

References hook_proto_desc::base, hook_proto_desc::desc, proto_ctx::desc, proto_ctx::location, and proto_ctx::protocol.

const struct proto_desc* proto_dev_desc

(

uint16_t

type

)

proto_dev_desc - return protocol description for an arphrd type

: the arphrd type

References array_size, dev_proto_desc::desc, and NULL.

int proto_dev_type	(	const struct proto_desc *	desc,
		uint16_t *	res
	)

proto_dev_type - return arphrd type linking a device and a protocol together

: the protocol description : pointer to result

References array_size, and dev_proto_desc::type.

Referenced by payload_gen_dependency().

Here is the caller graph for this function:

int proto_find_num	(	const struct proto_desc *	base,
		const struct proto_desc *	desc
	)

proto_find_num - return protocol number linking two protocols together

: lower layer protocol description : upper layer protocol description

References array_size, proto_desc::desc, proto_desc::num, and proto_desc::protocols.

Referenced by payload_gen_dependency().

Here is the caller graph for this function:

const struct proto_desc* proto_find_upper	(	const struct proto_desc *	base,
		unsigned int	num
	)

proto_find_upper - find higher layer protocol description by protocol value linking it to the lower layer protocol

: lower layer protocol description : protocol value

References array_size, proto_desc::desc, NULL, proto_desc::num, and proto_desc::protocols.

Variable Documentation

const struct datatype etheraddr_type

Initial value:

= {
    .type       = TYPE_ETHERADDR,
    .name       = "ether_addr",
    .desc       = "Ethernet address",
    .byteorder  = BYTEORDER_HOST_ENDIAN,
    .size       = ETH_ALEN * BITS_PER_BYTE,
    .basetype   = &lladdr_type,
}

const struct datatype ethertype_type

Initial value:

= {
    .type       = TYPE_ETHERTYPE,
    .name       = "ether_type",
    .desc       = "Ethernet protocol",
    .byteorder  = BYTEORDER_BIG_ENDIAN,
    .size       = 2 * BITS_PER_BYTE,
    .basetype   = &integer_type,
    .basefmt    = "0x%.4Zx",
    .print      = ethertype_print,
    .sym_tbl    = &ethertype_tbl,
}

const struct hook_proto_desc hook_proto_desc[]

Initial value:

= {
    [NFPROTO_BRIDGE]    = HOOK_PROTO_DESC(PROTO_BASE_LL_HDR,      &proto_eth),
    [NFPROTO_INET]      = HOOK_PROTO_DESC(PROTO_BASE_LL_HDR,      &proto_inet),
    [NFPROTO_IPV4]      = HOOK_PROTO_DESC(PROTO_BASE_NETWORK_HDR, &proto_ip),
    [NFPROTO_IPV6]      = HOOK_PROTO_DESC(PROTO_BASE_NETWORK_HDR, &proto_ip6),
    [NFPROTO_ARP]       = HOOK_PROTO_DESC(PROTO_BASE_NETWORK_HDR, &proto_arp),
}

const struct proto_desc proto_ah

Initial value:

= {
    .name       = "ah",
    .base       = PROTO_BASE_TRANSPORT_HDR,
    .protocol_key   = AHHDR_NEXTHDR,
    .protocols  = {
        PROTO_LINK(IPPROTO_ESP,     &proto_esp),
        PROTO_LINK(IPPROTO_AH,      &proto_ah),
        PROTO_LINK(IPPROTO_COMP,    &proto_comp),
        PROTO_LINK(IPPROTO_UDP,     &proto_udp),
        PROTO_LINK(IPPROTO_UDPLITE, &proto_udplite),
        PROTO_LINK(IPPROTO_TCP,     &proto_tcp),
        PROTO_LINK(IPPROTO_DCCP,    &proto_dccp),
        PROTO_LINK(IPPROTO_SCTP,    &proto_sctp),
    },
    .templates  = {
        [AHHDR_NEXTHDR]     = INET_PROTOCOL("nexthdr", struct ip_auth_hdr, nexthdr),
        [AHHDR_HDRLENGTH]   = AHHDR_FIELD("hdrlength", hdrlen),
        [AHHDR_RESERVED]    = AHHDR_FIELD("reserved", reserved),
        [AHHDR_SPI]     = AHHDR_FIELD("spi", spi),
        [AHHDR_SEQUENCE]    = AHHDR_FIELD("sequence", seq_no),
    },
}

const struct proto_desc proto_arp

Initial value:

= {
    .name       = "arp",
    .base       = PROTO_BASE_NETWORK_HDR,
    .templates  = {
        [ARPHDR_HRD]        = ARPHDR_FIELD("htype", ar_hrd),
        [ARPHDR_PRO]        = ARPHDR_TYPE("ptype", &ethertype_type, ar_pro),
        [ARPHDR_HLN]        = ARPHDR_FIELD("hlen", ar_hln),
        [ARPHDR_PLN]        = ARPHDR_FIELD("plen", ar_pln),
        [ARPHDR_OP]     = ARPHDR_TYPE("operation", &arpop_type, ar_op),
    },
}

const char* proto_base_names[]

Initial value:

= {
    [PROTO_BASE_INVALID]        = "invalid",
    [PROTO_BASE_LL_HDR]     = "link layer",
    [PROTO_BASE_NETWORK_HDR]    = "network layer",
    [PROTO_BASE_TRANSPORT_HDR]  = "transport layer",
}

Referenced by payload_gen_dependency().

const char* proto_base_tokens[]

Initial value:

= {
    [PROTO_BASE_INVALID]        = "invalid",
    [PROTO_BASE_LL_HDR]     = "ll",
    [PROTO_BASE_NETWORK_HDR]    = "nh",
    [PROTO_BASE_TRANSPORT_HDR]  = "th",
}

const struct proto_desc proto_comp

Initial value:

= {
    .name       = "comp",
    .base       = PROTO_BASE_TRANSPORT_HDR,
    .protocol_key   = COMPHDR_NEXTHDR,
    .protocols  = {
        PROTO_LINK(IPPROTO_ESP,     &proto_esp),
        PROTO_LINK(IPPROTO_AH,      &proto_ah),
        PROTO_LINK(IPPROTO_COMP,    &proto_comp),
        PROTO_LINK(IPPROTO_UDP,     &proto_udp),
        PROTO_LINK(IPPROTO_UDPLITE, &proto_udplite),
        PROTO_LINK(IPPROTO_TCP,     &proto_tcp),
        PROTO_LINK(IPPROTO_DCCP,    &proto_dccp),
        PROTO_LINK(IPPROTO_SCTP,    &proto_sctp),
    },
    .templates  = {
        [COMPHDR_NEXTHDR]   = INET_PROTOCOL("nexthdr", struct ip_comp_hdr, nexthdr),
        [COMPHDR_FLAGS]     = COMPHDR_FIELD("flags", flags),
        [COMPHDR_CPI]       = COMPHDR_FIELD("cpi", cpi),
    },
}

const struct proto_desc proto_dccp

Initial value:

= {
    .name       = "dccp",
    .base       = PROTO_BASE_TRANSPORT_HDR,
    .templates  = {
        [DCCPHDR_SPORT]     = INET_SERVICE("sport", struct dccp_hdr, dccph_sport),
        [DCCPHDR_DPORT]     = INET_SERVICE("dport", struct dccp_hdr, dccph_dport),
        [DCCPHDR_TYPE]      = HDR_BITFIELD("type", &dccp_pkttype_type, 67, 4),
    },
}

const struct proto_desc proto_esp

Initial value:

= {
    .name       = "esp",
    .base       = PROTO_BASE_TRANSPORT_HDR,
    .templates  = {
        [ESPHDR_SPI]        = ESPHDR_FIELD("spi", spi),
        [ESPHDR_SEQUENCE]   = ESPHDR_FIELD("sequence", seq_no),
    },
}

const struct proto_desc proto_eth

Initial value:

= {
    .name       = "ether",
    .base       = PROTO_BASE_LL_HDR,
    .protocol_key   = ETHHDR_TYPE,
    .protocols  = {
        PROTO_LINK(__constant_htons(ETH_P_IP),      &proto_ip),
        PROTO_LINK(__constant_htons(ETH_P_ARP),     &proto_arp),
        PROTO_LINK(__constant_htons(ETH_P_IPV6),    &proto_ip6),
        PROTO_LINK(__constant_htons(ETH_P_8021Q),   &proto_vlan),
    },
    .templates  = {
        [ETHHDR_DADDR]      = ETHHDR_ADDR("daddr", ether_dhost),
        [ETHHDR_SADDR]      = ETHHDR_ADDR("saddr", ether_shost),
        [ETHHDR_TYPE]       = ETHHDR_TYPE("type", ether_type),
    },
}

Referenced by payload_gen_dependency().

const struct proto_desc proto_icmp

Initial value:

= {
    .name       = "icmp",
    .base       = PROTO_BASE_TRANSPORT_HDR,
    .templates  = {
        [ICMPHDR_TYPE]      = ICMPHDR_TYPE("type", &icmp_type_type, type),
        [ICMPHDR_CODE]      = ICMPHDR_FIELD("code", code),
        [ICMPHDR_CHECKSUM]  = ICMPHDR_FIELD("checksum", checksum),
        [ICMPHDR_ID]        = ICMPHDR_FIELD("id", un.echo.id),
        [ICMPHDR_SEQ]       = ICMPHDR_FIELD("sequence", un.echo.sequence),
        [ICMPHDR_GATEWAY]   = ICMPHDR_FIELD("gateway", un.gateway),
        [ICMPHDR_MTU]       = ICMPHDR_FIELD("mtu", un.frag.mtu),
    },
}

const struct proto_desc proto_icmp6

Initial value:

= {
    .name       = "icmpv6",
    .base       = PROTO_BASE_TRANSPORT_HDR,
    .templates  = {
        [ICMP6HDR_TYPE]     = ICMP6HDR_TYPE("type", &icmp6_type_type, icmp6_type),
        [ICMP6HDR_CODE]     = ICMP6HDR_FIELD("code", icmp6_code),
        [ICMP6HDR_CHECKSUM] = ICMP6HDR_FIELD("checksum", icmp6_cksum),
        [ICMP6HDR_PPTR]     = ICMP6HDR_FIELD("parameter-problem", icmp6_pptr),
        [ICMP6HDR_MTU]      = ICMP6HDR_FIELD("packet-too-big", icmp6_mtu),
        [ICMP6HDR_ID]       = ICMP6HDR_FIELD("id", icmp6_id),
        [ICMP6HDR_SEQ]      = ICMP6HDR_FIELD("sequence", icmp6_seq),
        [ICMP6HDR_MAXDELAY] = ICMP6HDR_FIELD("max-delay", icmp6_maxdelay),
    },
}

const struct proto_desc proto_inet

Initial value:

= {
    .name       = "inet",
    .base       = PROTO_BASE_LL_HDR,
    .protocols  = {
        PROTO_LINK(NFPROTO_IPV4,    &proto_ip),
        PROTO_LINK(NFPROTO_IPV6,    &proto_ip6),
    },
    .templates  = {
        [0] = PROTO_META_TEMPLATE("nfproto", &nfproto_type, NFT_META_NFPROTO, 8),
    },
}

Referenced by payload_gen_dependency().

const struct proto_desc proto_inet_service

Initial value:

= {
    .name       = "inet-service",
    .base       = PROTO_BASE_TRANSPORT_HDR,
    .protocol_key   = 0,
    .protocols  = {
        PROTO_LINK(IPPROTO_ESP,     &proto_esp),
        PROTO_LINK(IPPROTO_AH,      &proto_ah),
        PROTO_LINK(IPPROTO_COMP,    &proto_comp),
        PROTO_LINK(IPPROTO_UDP,     &proto_udp),
        PROTO_LINK(IPPROTO_UDPLITE, &proto_udplite),
        PROTO_LINK(IPPROTO_TCP,     &proto_tcp),
        PROTO_LINK(IPPROTO_DCCP,    &proto_dccp),
        PROTO_LINK(IPPROTO_SCTP,    &proto_sctp),
    },
    .templates  = {
        [0] = PROTO_META_TEMPLATE("l4proto", &inet_protocol_type, NFT_META_L4PROTO, 8),
    },
}

Referenced by payload_gen_dependency().

const struct proto_desc proto_ip

Initial value:

= {
    .name       = "ip",
    .base       = PROTO_BASE_NETWORK_HDR,
    .protocol_key   = IPHDR_PROTOCOL,
    .protocols  = {
        PROTO_LINK(IPPROTO_ICMP,    &proto_icmp),
        PROTO_LINK(IPPROTO_ESP,     &proto_esp),
        PROTO_LINK(IPPROTO_AH,      &proto_ah),
        PROTO_LINK(IPPROTO_COMP,    &proto_comp),
        PROTO_LINK(IPPROTO_UDP,     &proto_udp),
        PROTO_LINK(IPPROTO_UDPLITE, &proto_udplite),
        PROTO_LINK(IPPROTO_TCP,     &proto_tcp),
        PROTO_LINK(IPPROTO_DCCP,    &proto_dccp),
        PROTO_LINK(IPPROTO_SCTP,    &proto_sctp),
    },
    .templates  = {
        [IPHDR_VERSION]     = HDR_BITFIELD("version", &integer_type, 0, 4),
        [IPHDR_HDRLENGTH]   = HDR_BITFIELD("hdrlength", &integer_type, 4, 4),
        [IPHDR_TOS]     = IPHDR_FIELD("tos",        tos),
        [IPHDR_LENGTH]      = IPHDR_FIELD("length",     tot_len),
        [IPHDR_ID]      = IPHDR_FIELD("id",     id),
        [IPHDR_FRAG_OFF]    = IPHDR_FIELD("frag-off",   frag_off),
        [IPHDR_TTL]     = IPHDR_FIELD("ttl",        ttl),
        [IPHDR_PROTOCOL]    = INET_PROTOCOL("protocol", struct iphdr, protocol),
        [IPHDR_CHECKSUM]    = IPHDR_FIELD("checksum",   check),
        [IPHDR_SADDR]       = IPHDR_ADDR("saddr",       saddr),
        [IPHDR_DADDR]       = IPHDR_ADDR("daddr",       daddr),
    },
}

Referenced by ct_expr_update_type().

const struct proto_desc proto_ip6

Initial value:

= {
    .name       = "ip6",
    .base       = PROTO_BASE_NETWORK_HDR,
    .protocol_key   = IP6HDR_NEXTHDR,
    .protocols  = {
        PROTO_LINK(IPPROTO_ESP,     &proto_esp),
        PROTO_LINK(IPPROTO_AH,      &proto_ah),
        PROTO_LINK(IPPROTO_COMP,    &proto_comp),
        PROTO_LINK(IPPROTO_UDP,     &proto_udp),
        PROTO_LINK(IPPROTO_UDPLITE, &proto_udplite),
        PROTO_LINK(IPPROTO_TCP,     &proto_tcp),
        PROTO_LINK(IPPROTO_DCCP,    &proto_dccp),
        PROTO_LINK(IPPROTO_SCTP,    &proto_sctp),
        PROTO_LINK(IPPROTO_ICMPV6,  &proto_icmp6),
    },
    .templates  = {
        [IP6HDR_VERSION]    = HDR_BITFIELD("version", &integer_type, 0, 4),
        [IP6HDR_PRIORITY]   = HDR_BITFIELD("priority", &integer_type, 4, 4),
        [IP6HDR_FLOWLABEL]  = IP6HDR_FIELD("flowlabel", flow_lbl),
        [IP6HDR_LENGTH]     = IP6HDR_FIELD("length",    payload_len),
        [IP6HDR_NEXTHDR]    = INET_PROTOCOL("nexthdr", struct ipv6hdr, nexthdr),
        [IP6HDR_HOPLIMIT]   = IP6HDR_FIELD("hoplimit",  hop_limit),
        [IP6HDR_SADDR]      = IP6HDR_ADDR("saddr",      saddr),
        [IP6HDR_DADDR]      = IP6HDR_ADDR("daddr",      daddr),
    },
}

Referenced by ct_expr_update_type().

const struct proto_desc proto_sctp

Initial value:

= {
    .name       = "sctp",
    .base       = PROTO_BASE_TRANSPORT_HDR,
    .templates  = {
        [SCTPHDR_SPORT]     = INET_SERVICE("sport", struct sctphdr, source),
        [SCTPHDR_DPORT]     = INET_SERVICE("dport", struct sctphdr, dest),
        [SCTPHDR_VTAG]      = SCTPHDR_FIELD("vtag", vtag),
        [SCTPHDR_CHECKSUM]  = SCTPHDR_FIELD("checksum", checksum),
    },
}

const struct proto_desc proto_tcp

Initial value:

= {
    .name       = "tcp",
    .base       = PROTO_BASE_TRANSPORT_HDR,
    .templates  = {
        [TCPHDR_SPORT]      = INET_SERVICE("sport", struct tcphdr, source),
        [TCPHDR_DPORT]      = INET_SERVICE("dport", struct tcphdr, dest),
        [TCPHDR_SEQ]        = TCPHDR_FIELD("sequence", seq),
        [TCPHDR_ACKSEQ]     = TCPHDR_FIELD("ackseq", ack_seq),
        [TCPHDR_DOFF]       = {},
        [TCPHDR_RESERVED]   = {},
        [TCPHDR_FLAGS]      = HDR_BITFIELD("flags", &tcp_flag_type,
                               13 * BITS_PER_BYTE,
                               BITS_PER_BYTE),
        [TCPHDR_WINDOW]     = TCPHDR_FIELD("window", window),
        [TCPHDR_CHECKSUM]   = TCPHDR_FIELD("checksum", check),
        [TCPHDR_URGPTR]     = TCPHDR_FIELD("urgptr", urg_ptr),
    },
}

const struct proto_desc proto_udp

Initial value:

= {
    .name       = "udp",
    .base       = PROTO_BASE_TRANSPORT_HDR,
    .templates  = {
        [UDPHDR_SPORT]      = INET_SERVICE("sport", struct udphdr, source),
        [UDPHDR_DPORT]      = INET_SERVICE("dport", struct udphdr, dest),
        [UDPHDR_LENGTH]     = UDPHDR_FIELD("length", len),
        [UDPHDR_CHECKSUM]   = UDPHDR_FIELD("checksum", check),
    },
}

const struct proto_desc proto_udplite

Initial value:

= {
    .name       = "udplite",
    .base       = PROTO_BASE_TRANSPORT_HDR,
    .templates  = {
        [UDPHDR_SPORT]      = INET_SERVICE("sport", struct udphdr, source),
        [UDPHDR_DPORT]      = INET_SERVICE("dport", struct udphdr, dest),
        [UDPHDR_CSUMCOV]    = UDPHDR_FIELD("csumcov", len),
        [UDPHDR_CHECKSUM]   = UDPHDR_FIELD("checksum", check),
    },
}

const struct proto_desc proto_unknown

Initial value:

= {
    .name       = "unknown",
    .base       = PROTO_BASE_INVALID,
}

Referenced by payload_expr_alloc().

const struct proto_hdr_template proto_unknown_template

Initial value:

=
    PROTO_HDR_TEMPLATE("unknown", &invalid_type, BYTEORDER_INVALID, 0, 0)

Referenced by payload_expr_alloc().

const struct proto_desc proto_vlan

Initial value:

= {
    .name       = "vlan",
    .base       = PROTO_BASE_LL_HDR,
    .protocol_key   = VLANHDR_TYPE,
    .protocols  = {
        PROTO_LINK(__constant_htons(ETH_P_IP),      &proto_ip),
        PROTO_LINK(__constant_htons(ETH_P_ARP),     &proto_arp),
        PROTO_LINK(__constant_htons(ETH_P_IPV6),    &proto_ip6),
        PROTO_LINK(__constant_htons(ETH_P_8021Q),   &proto_vlan),

    },
    .templates  = {
        [VLANHDR_VID]       = VLANHDR_BITFIELD("id", 0, 12),
        [VLANHDR_CFI]       = VLANHDR_BITFIELD("cfi", 12, 1),
        [VLANHDR_PCP]       = VLANHDR_BITFIELD("pcp", 13, 3),
        [VLANHDR_TYPE]      = VLANHDR_TYPE("type", &ethertype_type, vlan_type),
    },
}