gfwleak/stellar-stellar
Archived
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

rename layer_type to layer_proto

Browse Source
This commit is contained in:
luwenpeng
2024-06-12 18:21:45 +08:00
parent 10528bcfd3
commit 01958b56c5
20 changed files with 437 additions and 1049 deletions
Download Patch File Download Diff File Expand all files Collapse all files

246
src/packet/packet.cpp
View File

@@ -23,13 +23,13 @@
#define PACKET_LOG_DATA_INSUFFICIENCY(pkt, layer) \
{ \
PACKET_LOG_WARN("pkt: %p, layer: %s, data insufficiency", \
(pkt), layer_type_to_str(layer)); \
(pkt), layer_proto_to_str(layer)); \
}
#define PACKET_LOG_UNSUPPORT_PROTO(pkt, layer, next_proto) \
{ \
PACKET_LOG_WARN("pkt: %p, layer: %s, unsupport next proto %d", \
(pkt), layer_type_to_str(layer), (next_proto)); \
#define PACKET_LOG_UNSUPPORT_PROTO(pkt, layer, next_proto) \
{ \
PACKET_LOG_WARN("pkt: %p, layer: %s, unsupport next proto %d", \
(pkt), layer_proto_to_str(layer), (next_proto)); \
}
#define PACKET_LOG_UNSUPPORT_ETHPROTO(pkt, next_proto) \
@@ -49,11 +49,11 @@
******************************************************************************/
static inline const char *ldbc_method_to_str(enum ldbc_method method);
static inline const char *layer_type_to_str(enum layer_type type);
static inline const char *layer_proto_to_str(enum layer_proto type);
static inline void set_tuple2(const char *data, enum layer_type type, struct tuple2 *tuple);
static inline void set_tuple4(const char *data, enum layer_type type, struct tuple4 *tuple);
static inline void set_tuple6(const char *data, enum layer_type type, struct tuple6 *tuple, uint64_t domain);
static inline void set_tuple2(const char *data, enum layer_proto type, struct tuple2 *tuple);
static inline void set_tuple4(const char *data, enum layer_proto type, struct tuple4 *tuple);
static inline void set_tuple6(const char *data, enum layer_proto type, struct tuple6 *tuple, uint64_t domain);
static inline struct packet_layer *get_free_layer(struct packet *pkt);
@@ -112,65 +112,63 @@ static inline const char *ldbc_method_to_str(enum ldbc_method method)
}
}
static inline const char *layer_type_to_str(enum layer_type type)
static inline const char *layer_proto_to_str(enum layer_proto type)
{
switch (type)
{
case LAYER_TYPE_ETHER:
case LAYER_PROTO_ETHER:
return "ETH";
case LAYER_TYPE_PWETH:
case LAYER_PROTO_PWETH:
return "PWETH";
case LAYER_TYPE_PPP:
case LAYER_PROTO_PPP:
return "PPP";
case LAYER_TYPE_HDLC:
return "HDLC";
case LAYER_TYPE_L2TP:
case LAYER_PROTO_L2TP:
return "L2TP";
case LAYER_TYPE_VLAN:
case LAYER_PROTO_VLAN:
return "VLAN";
case LAYER_TYPE_PPPOE:
case LAYER_PROTO_PPPOE:
return "PPPOE";
case LAYER_TYPE_MPLS:
case LAYER_PROTO_MPLS:
return "MPLS";
case LAYER_TYPE_IPV4:
case LAYER_PROTO_IPV4:
return "IPV4";
case LAYER_TYPE_IPV6:
case LAYER_PROTO_IPV6:
return "IPV6";
case LAYER_TYPE_IPAH:
case LAYER_PROTO_IPAH:
return "IPAH";
case LAYER_TYPE_GRE:
case LAYER_PROTO_GRE:
return "GRE";
case LAYER_TYPE_UDP:
case LAYER_PROTO_UDP:
return "UDP";
case LAYER_TYPE_TCP:
case LAYER_PROTO_TCP:
return "TCP";
case LAYER_TYPE_ICMP:
case LAYER_PROTO_ICMP:
return "ICMP";
case LAYER_TYPE_ICMP6:
case LAYER_PROTO_ICMP6:
return "ICMP6";
case LAYER_TYPE_VXLAN:
case LAYER_PROTO_VXLAN:
return "VXLAN";
case LAYER_TYPE_GTPV1_U:
case LAYER_PROTO_GTPV1_U:
return "GTPV1";
default:
return "UNKNOWN";
}
}
static inline void set_tuple2(const char *data, enum layer_type type, struct tuple2 *tuple)
static inline void set_tuple2(const char *data, enum layer_proto type, struct tuple2 *tuple)
{
const struct ip *ipv4 = NULL;
const struct ip6_hdr *ipv6 = NULL;
switch (type)
{
case LAYER_TYPE_IPV4:
case LAYER_PROTO_IPV4:
ipv4 = (const struct ip *)data;
tuple->ip_type = IP_TYPE_V4;
tuple->src_addr.v4.s_addr = ipv4->ip_src.s_addr;
tuple->dst_addr.v4.s_addr = ipv4->ip_dst.s_addr;
break;
case LAYER_TYPE_IPV6:
case LAYER_PROTO_IPV6:
ipv6 = (const struct ip6_hdr *)data;
tuple->ip_type = IP_TYPE_V6;
tuple->src_addr.v6 = ipv6->ip6_src;
@@ -181,7 +179,7 @@ static inline void set_tuple2(const char *data, enum layer_type type, struct tup
}
}
static inline void set_tuple4(const char *data, enum layer_type type, struct tuple4 *tuple)
static inline void set_tuple4(const char *data, enum layer_proto type, struct tuple4 *tuple)
{
const struct ip *ipv4 = NULL;
const struct ip6_hdr *ipv6 = NULL;
@@ -190,23 +188,23 @@ static inline void set_tuple4(const char *data, enum layer_type type, struct tup
switch (type)
{
case LAYER_TYPE_TCP:
case LAYER_PROTO_TCP:
tcp = (const struct tcphdr *)data;
tuple->src_port = tcp->th_sport;
tuple->dst_port = tcp->th_dport;
break;
case LAYER_TYPE_UDP:
case LAYER_PROTO_UDP:
udp = (const struct udphdr *)data;
tuple->src_port = udp->uh_sport;
tuple->dst_port = udp->uh_dport;
break;
case LAYER_TYPE_IPV4:
case LAYER_PROTO_IPV4:
ipv4 = (const struct ip *)data;
tuple->ip_type = IP_TYPE_V4;
tuple->src_addr.v4.s_addr = ipv4->ip_src.s_addr;
tuple->dst_addr.v4.s_addr = ipv4->ip_dst.s_addr;
break;
case LAYER_TYPE_IPV6:
case LAYER_PROTO_IPV6:
ipv6 = (const struct ip6_hdr *)data;
tuple->ip_type = IP_TYPE_V6;
tuple->src_addr.v6 = ipv6->ip6_src;
@@ -217,7 +215,7 @@ static inline void set_tuple4(const char *data, enum layer_type type, struct tup
}
}
static inline void set_tuple6(const char *data, enum layer_type type, struct tuple6 *tuple, uint64_t domain)
static inline void set_tuple6(const char *data, enum layer_proto type, struct tuple6 *tuple, uint64_t domain)
{
const struct ip *ipv4 = NULL;
const struct ip6_hdr *ipv6 = NULL;
@@ -228,25 +226,25 @@ static inline void set_tuple6(const char *data, enum layer_type type, struct tup
switch (type)
{
case LAYER_TYPE_TCP:
case LAYER_PROTO_TCP:
tcp = (const struct tcphdr *)data;
tuple->ip_proto = IPPROTO_TCP;
tuple->src_port = tcp->th_sport;
tuple->dst_port = tcp->th_dport;
break;
case LAYER_TYPE_UDP:
case LAYER_PROTO_UDP:
udp = (const struct udphdr *)data;
tuple->ip_proto = IPPROTO_UDP;
tuple->src_port = udp->uh_sport;
tuple->dst_port = udp->uh_dport;
break;
case LAYER_TYPE_IPV4:
case LAYER_PROTO_IPV4:
ipv4 = (const struct ip *)data;
tuple->ip_type = IP_TYPE_V4;
tuple->src_addr.v4.s_addr = ipv4->ip_src.s_addr;
tuple->dst_addr.v4.s_addr = ipv4->ip_dst.s_addr;
break;
case LAYER_TYPE_IPV6:
case LAYER_PROTO_IPV6:
ipv6 = (const struct ip6_hdr *)data;
tuple->ip_type = IP_TYPE_V6;
tuple->src_addr.v6 = ipv6->ip6_src;
@@ -278,7 +276,7 @@ static inline struct packet_layer *get_free_layer(struct packet *pkt)
(_pkt)->trim_len += (_trim); \
(_pkt)->layers_used++; \
PACKET_LOG_DEBUG("layer[%d/%d]: %s, hdr_offset: %d, hdr_ptr: %p, hdr_len: %d, pld_ptr: %p, pld_len: %d", \
(_pkt)->layers_used - 1, (_pkt)->layers_size, layer_type_to_str((_type)), \
(_pkt)->layers_used - 1, (_pkt)->layers_size, layer_proto_to_str((_type)), \
(_layer)->hdr_offset, (_layer)->hdr_ptr, (_layer)->hdr_len, (_layer)->pld_ptr, (_layer)->pld_len); \
}
@@ -358,7 +356,7 @@ static inline const char *parse_ether(struct packet *pkt, const char *data, uint
{
if (unlikely(len < sizeof(struct ethhdr)))
{
PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_TYPE_ETHER);
PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_PROTO_ETHER);
return data;
}
@@ -368,7 +366,7 @@ static inline const char *parse_ether(struct packet *pkt, const char *data, uint
return data;
}
uint16_t next_proto = eth_hdr_get_proto((const struct ethhdr *)data);
SET_LAYER(pkt, layer, LAYER_TYPE_ETHER, sizeof(struct ethhdr), data, len, 0);
SET_LAYER(pkt, layer, LAYER_PROTO_ETHER, sizeof(struct ethhdr), data, len, 0);
return parse_l3(pkt, next_proto, layer->pld_ptr, layer->pld_len);
}
@@ -386,7 +384,7 @@ static inline const char *parse_pweth(struct packet *pkt, const char *data, uint
*/
if (unlikely(len < 4))
{
PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_TYPE_PWETH);
PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_PROTO_PWETH);
return data;
}
@@ -395,7 +393,7 @@ static inline const char *parse_pweth(struct packet *pkt, const char *data, uint
{
return data;
}
SET_LAYER(pkt, layer, LAYER_TYPE_PWETH, 4, data, len, 0);
SET_LAYER(pkt, layer, LAYER_PROTO_PWETH, 4, data, len, 0);
return parse_ether(pkt, layer->pld_ptr, layer->pld_len);
}
@@ -455,7 +453,7 @@ static inline const char *parse_ppp(struct packet *pkt, const char *data, uint16
*/
if (unlikely(len < 4))
{
PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_TYPE_PPP);
PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_PROTO_PPP);
return data;
}
@@ -488,7 +486,7 @@ success:
{
return data;
}
SET_LAYER(pkt, layer, LAYER_TYPE_PPP, hdr_len, data, len, 0);
SET_LAYER(pkt, layer, LAYER_PROTO_PPP, hdr_len, data, len, 0);
switch (next_proto)
{
case PPP_IP:
@@ -496,7 +494,7 @@ success:
case PPP_IPV6:
return parse_ipv6(pkt, layer->pld_ptr, layer->pld_len);
default:
PACKET_LOG_UNSUPPORT_PROTO(pkt, LAYER_TYPE_PPP, next_proto);
PACKET_LOG_UNSUPPORT_PROTO(pkt, LAYER_PROTO_PPP, next_proto);
return layer->pld_ptr;
}
}
@@ -506,7 +504,7 @@ static inline const char *parse_l2tpv2_over_udp(struct packet *pkt, const char *
uint16_t hdr_len = calc_udp_l2tpv2_hdr_len(data, len);
if (unlikely(hdr_len == 0 || hdr_len > len))
{
PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_TYPE_L2TP);
PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_PROTO_L2TP);
return data;
}
@@ -515,7 +513,7 @@ static inline const char *parse_l2tpv2_over_udp(struct packet *pkt, const char *
{
return data;
}
SET_LAYER(pkt, layer, LAYER_TYPE_L2TP, hdr_len, data, len, 0);
SET_LAYER(pkt, layer, LAYER_PROTO_L2TP, hdr_len, data, len, 0);
// control message
if (l2tp_hdr_get_type((const struct l2tp_hdr *)data))
@@ -534,7 +532,7 @@ static inline const char *parse_l2tpv3_over_udp(struct packet *pkt, const char *
uint16_t hdr_len = calc_udp_l2tpv3_hdr_len(data, len);
if (unlikely(hdr_len == 0 || hdr_len > len))
{
PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_TYPE_L2TP);
PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_PROTO_L2TP);
return data;
}
@@ -543,7 +541,7 @@ static inline const char *parse_l2tpv3_over_udp(struct packet *pkt, const char *
{
return data;
}
SET_LAYER(pkt, layer, LAYER_TYPE_L2TP, hdr_len, data, len, 0);
SET_LAYER(pkt, layer, LAYER_PROTO_L2TP, hdr_len, data, len, 0);
// control message
if (l2tp_hdr_get_type((const struct l2tp_hdr *)data))
@@ -563,7 +561,7 @@ static inline const char *parse_l2tpv3_over_ip(struct packet *pkt, const char *d
uint16_t hdr_len = calc_ip_l2tpv3_hdr_len(data, len);
if (unlikely(hdr_len == 0 || hdr_len > len))
{
PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_TYPE_L2TP);
PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_PROTO_L2TP);
return data;
}
@@ -572,7 +570,7 @@ static inline const char *parse_l2tpv3_over_ip(struct packet *pkt, const char *d
{
return data;
}
SET_LAYER(pkt, layer, LAYER_TYPE_L2TP, hdr_len, data, len, 0);
SET_LAYER(pkt, layer, LAYER_PROTO_L2TP, hdr_len, data, len, 0);
// data message
if (ntohl(*((uint32_t *)data)))
@@ -591,7 +589,7 @@ static inline const char *parse_vlan(struct packet *pkt, const char *data, uint1
{
if (unlikely(len < sizeof(struct vlan_hdr)))
{
PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_TYPE_VLAN);
PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_PROTO_VLAN);
return data;
}
@@ -601,7 +599,7 @@ static inline const char *parse_vlan(struct packet *pkt, const char *data, uint1
return data;
}
uint16_t next_proto = vlan_hdr_get_ethertype((const struct vlan_hdr *)data);
SET_LAYER(pkt, layer, LAYER_TYPE_VLAN, sizeof(struct vlan_hdr), data, len, 0);
SET_LAYER(pkt, layer, LAYER_PROTO_VLAN, sizeof(struct vlan_hdr), data, len, 0);
return parse_l3(pkt, next_proto, layer->pld_ptr, layer->pld_len);
}
@@ -610,7 +608,7 @@ static inline const char *parse_pppoe_ses(struct packet *pkt, const char *data,
{
if (unlikely(len < 6))
{
PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_TYPE_PPPOE);
PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_PROTO_PPPOE);
return data;
}
@@ -619,7 +617,7 @@ static inline const char *parse_pppoe_ses(struct packet *pkt, const char *data,
{
return data;
}
SET_LAYER(pkt, layer, LAYER_TYPE_PPPOE, 6, data, len, 0);
SET_LAYER(pkt, layer, LAYER_PROTO_PPPOE, 6, data, len, 0);
return parse_ppp(pkt, layer->pld_ptr, layer->pld_len);
}
@@ -628,7 +626,7 @@ static inline const char *parse_mpls(struct packet *pkt, const char *data, uint1
{
if (unlikely(len < 4))
{
PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_TYPE_MPLS);
PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_PROTO_MPLS);
return data;
}
@@ -640,7 +638,7 @@ static inline const char *parse_mpls(struct packet *pkt, const char *data, uint1
if (mpls_label_get_bos((const struct mpls_label *)data))
{
SET_LAYER(pkt, layer, LAYER_TYPE_MPLS, 4, data, len, 0);
SET_LAYER(pkt, layer, LAYER_PROTO_MPLS, 4, data, len, 0);
if (layer->pld_len == 0)
{
return layer->pld_ptr;
@@ -668,7 +666,7 @@ static inline const char *parse_mpls(struct packet *pkt, const char *data, uint1
}
else
{
SET_LAYER(pkt, layer, LAYER_TYPE_MPLS, 4, data, len, 0);
SET_LAYER(pkt, layer, LAYER_PROTO_MPLS, 4, data, len, 0);
return parse_mpls(pkt, layer->pld_ptr, layer->pld_len);
}
}
@@ -677,7 +675,7 @@ static inline const char *parse_ipv4(struct packet *pkt, const char *data, uint1
{
if (unlikely(len < sizeof(struct ip)))
{
PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_TYPE_IPV4);
PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_PROTO_IPV4);
return data;
}
@@ -690,14 +688,14 @@ static inline const char *parse_ipv4(struct packet *pkt, const char *data, uint1
uint16_t hdr_len = ipv4_hdr_get_hdr_len(hdr);
if (unlikely(hdr_len > len))
{
PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_TYPE_IPV4);
PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_PROTO_IPV4);
return data;
}
uint16_t total_len = ipv4_hdr_get_total_len(hdr);
if (unlikely(total_len > len))
{
PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_TYPE_IPV4);
PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_PROTO_IPV4);
return data;
}
if (unlikely(total_len < hdr_len))
@@ -706,7 +704,7 @@ static inline const char *parse_ipv4(struct packet *pkt, const char *data, uint1
return data;
}
uint16_t trim_len = len - total_len;
SET_LAYER(pkt, layer, LAYER_TYPE_IPV4, hdr_len, data, len, trim_len);
SET_LAYER(pkt, layer, LAYER_PROTO_IPV4, hdr_len, data, len, trim_len);
// ip fragmented
if (ipv4_hdr_get_mf_flag(hdr) || ipv4_hdr_get_frag_offset(hdr))
@@ -743,7 +741,7 @@ static inline const char *parse_ipv6(struct packet *pkt, const char *data, uint1
if (unlikely(len < sizeof(struct ip6_hdr)))
{
PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_TYPE_IPV6);
PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_PROTO_IPV6);
return data;
}
@@ -756,7 +754,7 @@ static inline const char *parse_ipv6(struct packet *pkt, const char *data, uint1
uint16_t pld_len = ipv6_hdr_get_payload_len(hdr);
if (unlikely(pld_len + sizeof(struct ip6_hdr) > len))
{
PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_TYPE_IPV6);
PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_PROTO_IPV6);
return data;
}
uint8_t next_proto = ipv6_hdr_get_next_header(hdr);
@@ -767,7 +765,7 @@ static inline const char *parse_ipv6(struct packet *pkt, const char *data, uint1
{
if (unlikely(pld_len < 2))
{
PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_TYPE_IPV6);
PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_PROTO_IPV6);
return data;
}
struct ip6_ext *ext = (struct ip6_ext *)next_hdr_ptr;
@@ -788,7 +786,7 @@ static inline const char *parse_ipv6(struct packet *pkt, const char *data, uint1
}
if (unlikely(skip_len > pld_len))
{
PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_TYPE_IPV6);
PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_PROTO_IPV6);
return data;
}
hdr_len += skip_len;
@@ -796,7 +794,7 @@ static inline const char *parse_ipv6(struct packet *pkt, const char *data, uint1
next_hdr_ptr += skip_len;
next_proto = ext->ip6e_nxt;
}
SET_LAYER(pkt, layer, LAYER_TYPE_IPV6, hdr_len, data, len, trim_len);
SET_LAYER(pkt, layer, LAYER_PROTO_IPV6, hdr_len, data, len, trim_len);
// ipv6 fragment
if (next_proto == IPPROTO_FRAGMENT)
@@ -835,7 +833,7 @@ static inline const char *parse_auth(struct packet *pkt, const char *data, uint1
if (unlikely(len < 12))
{
PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_TYPE_IPAH);
PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_PROTO_IPAH);
return data;
}
/*
@@ -848,7 +846,7 @@ static inline const char *parse_auth(struct packet *pkt, const char *data, uint1
uint16_t hdr_len = ((const uint8_t *)data)[1] * 4 + 8;
if (unlikely(len < hdr_len))
{
PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_TYPE_IPAH);
PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_PROTO_IPAH);
return data;
}
@@ -857,7 +855,7 @@ static inline const char *parse_auth(struct packet *pkt, const char *data, uint1
{
return data;
}
SET_LAYER(pkt, layer, LAYER_TYPE_IPAH, hdr_len, data, len, 0);
SET_LAYER(pkt, layer, LAYER_PROTO_IPAH, hdr_len, data, len, 0);
return parse_l4(pkt, next_proto, layer->pld_ptr, layer->pld_len);
}
@@ -867,7 +865,7 @@ static inline const char *parse_gre(struct packet *pkt, const char *data, uint16
uint16_t hdr_len = calc_gre_hdr_len(data, len);
if (unlikely(hdr_len == 0 || hdr_len > len))
{
PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_TYPE_GRE);
PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_PROTO_GRE);
return data;
}
@@ -877,7 +875,7 @@ static inline const char *parse_gre(struct packet *pkt, const char *data, uint16
return data;
}
uint16_t next_proto = gre_hdr_get_proto((const struct gre_hdr *)data);
SET_LAYER(pkt, layer, LAYER_TYPE_GRE, hdr_len, data, len, 0);
SET_LAYER(pkt, layer, LAYER_PROTO_GRE, hdr_len, data, len, 0);
return parse_l3(pkt, next_proto, layer->pld_ptr, layer->pld_len);
}
@@ -886,7 +884,7 @@ static inline const char *parse_udp(struct packet *pkt, const char *data, uint16
{
if (unlikely(len < sizeof(struct udphdr)))
{
PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_TYPE_UDP);
PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_PROTO_UDP);
return data;
}
@@ -896,7 +894,7 @@ static inline const char *parse_udp(struct packet *pkt, const char *data, uint16
return data;
}
const struct udphdr *hdr = (struct udphdr *)data;
SET_LAYER(pkt, layer, LAYER_TYPE_UDP, sizeof(struct udphdr), data, len, 0);
SET_LAYER(pkt, layer, LAYER_PROTO_UDP, sizeof(struct udphdr), data, len, 0);
uint16_t src_port = udp_hdr_get_src_port(hdr);
uint16_t dst_port = udp_hdr_get_dst_port(hdr);
@@ -963,7 +961,7 @@ static inline const char *parse_tcp(struct packet *pkt, const char *data, uint16
{
if (unlikely(len < sizeof(struct tcphdr)))
{
PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_TYPE_TCP);
PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_PROTO_TCP);
return data;
}
@@ -975,10 +973,10 @@ static inline const char *parse_tcp(struct packet *pkt, const char *data, uint16
uint16_t hdr_len = tcp_hdr_get_hdr_len((const struct tcphdr *)data);
if (unlikely(hdr_len > len))
{
PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_TYPE_TCP);
PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_PROTO_TCP);
return data;
}
SET_LAYER(pkt, layer, LAYER_TYPE_TCP, hdr_len, data, len, 0);
SET_LAYER(pkt, layer, LAYER_PROTO_TCP, hdr_len, data, len, 0);
return layer->pld_ptr;
}
@@ -987,7 +985,7 @@ static inline const char *parse_icmp(struct packet *pkt, const char *data, uint1
{
if (unlikely(len < sizeof(struct icmphdr)))
{
PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_TYPE_ICMP);
PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_PROTO_ICMP);
return data;
}
@@ -996,7 +994,7 @@ static inline const char *parse_icmp(struct packet *pkt, const char *data, uint1
{
return data;
}
SET_LAYER(pkt, layer, LAYER_TYPE_ICMP, sizeof(struct icmphdr), data, len, 0);
SET_LAYER(pkt, layer, LAYER_PROTO_ICMP, sizeof(struct icmphdr), data, len, 0);
return layer->pld_ptr;
}
@@ -1005,7 +1003,7 @@ static inline const char *parse_icmp6(struct packet *pkt, const char *data, uint
{
if (unlikely(len < sizeof(struct icmp6_hdr)))
{
PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_TYPE_ICMP6);
PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_PROTO_ICMP6);
return data;
}
@@ -1014,7 +1012,7 @@ static inline const char *parse_icmp6(struct packet *pkt, const char *data, uint
{
return data;
}
SET_LAYER(pkt, layer, LAYER_TYPE_ICMP6, sizeof(struct icmp6_hdr), data, len, 0);
SET_LAYER(pkt, layer, LAYER_PROTO_ICMP6, sizeof(struct icmp6_hdr), data, len, 0);
return layer->pld_ptr;
}
@@ -1023,7 +1021,7 @@ static inline const char *parse_vxlan(struct packet *pkt, const char *data, uint
{
if (unlikely(len < sizeof(struct vxlan_hdr)))
{
PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_TYPE_VXLAN);
PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_PROTO_VXLAN);
return data;
}
@@ -1032,7 +1030,7 @@ static inline const char *parse_vxlan(struct packet *pkt, const char *data, uint
{
return data;
}
SET_LAYER(pkt, layer, LAYER_TYPE_VXLAN, sizeof(struct vxlan_hdr), data, len, 0);
SET_LAYER(pkt, layer, LAYER_PROTO_VXLAN, sizeof(struct vxlan_hdr), data, len, 0);
return parse_ether(pkt, layer->pld_ptr, layer->pld_len);
}
@@ -1042,7 +1040,7 @@ static inline const char *parse_gtpv1_u(struct packet *pkt, const char *data, ui
uint16_t hdr_len = get_gtp_hdr_len(data, len);
if (unlikely(hdr_len == 0 || hdr_len > len))
{
PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_TYPE_GTPV1_U);
PACKET_LOG_DATA_INSUFFICIENCY(pkt, LAYER_PROTO_GTPV1_U);
return data;
}
@@ -1052,7 +1050,7 @@ static inline const char *parse_gtpv1_u(struct packet *pkt, const char *data, ui
return data;
}
uint8_t next_proto = (((const uint8_t *)(data + hdr_len))[0]) >> 4;
SET_LAYER(pkt, layer, LAYER_TYPE_GTPV1_U, hdr_len, data, len, 0);
SET_LAYER(pkt, layer, LAYER_PROTO_GTPV1_U, hdr_len, data, len, 0);
switch (next_proto)
{
@@ -1061,7 +1059,7 @@ static inline const char *parse_gtpv1_u(struct packet *pkt, const char *data, ui
case 6:
return parse_ipv6(pkt, layer->pld_ptr, layer->pld_len);
default:
PACKET_LOG_UNSUPPORT_PROTO(pkt, LAYER_TYPE_GTPV1_U, next_proto);
PACKET_LOG_UNSUPPORT_PROTO(pkt, LAYER_PROTO_GTPV1_U, next_proto);
return layer->pld_ptr;
}
}
@@ -1151,56 +1149,54 @@ void packet_print_str(const struct packet *pkt)
int used = 0;
const struct packet_layer *layer = &pkt->layers[i];
printf(" layer[%u]: %p, type: %s, hdr_offset: %u, hdr_ptr: %p, hdr_len: %u, pld_ptr: %p, pld_len: %u\n",
i, layer, layer_type_to_str(layer->type), layer->hdr_offset,
i, layer, layer_proto_to_str(layer->type), layer->hdr_offset,
layer->hdr_ptr, layer->hdr_len, layer->pld_ptr, layer->pld_len);
switch (layer->type)
{
case LAYER_TYPE_ETHER:
case LAYER_PROTO_ETHER:
used = eth_hdr_to_str((const struct ethhdr *)layer->hdr_ptr, buffer, sizeof(buffer));
break;
case LAYER_TYPE_PWETH:
case LAYER_PROTO_PWETH:
break;
case LAYER_TYPE_PPP:
case LAYER_PROTO_PPP:
break;
case LAYER_TYPE_HDLC:
break;
case LAYER_TYPE_L2TP:
case LAYER_PROTO_L2TP:
used = l2tp_hdr_to_str((const struct l2tp_hdr *)layer->hdr_ptr, buffer, sizeof(buffer));
break;
case LAYER_TYPE_VLAN:
case LAYER_PROTO_VLAN:
used = vlan_hdr_to_str((const struct vlan_hdr *)layer->hdr_ptr, buffer, sizeof(buffer));
break;
case LAYER_TYPE_PPPOE:
case LAYER_PROTO_PPPOE:
break;
case LAYER_TYPE_MPLS:
case LAYER_PROTO_MPLS:
used = mpls_label_to_str((const struct mpls_label *)layer->hdr_ptr, buffer, sizeof(buffer));
break;
break;
case LAYER_TYPE_IPV4:
case LAYER_PROTO_IPV4:
used = ipv4_hdr_to_str((const struct ip *)layer->hdr_ptr, buffer, sizeof(buffer));
break;
case LAYER_TYPE_IPV6:
case LAYER_PROTO_IPV6:
used = ipv6_hdr_to_str((const struct ip6_hdr *)layer->hdr_ptr, buffer, sizeof(buffer));
break;
case LAYER_TYPE_IPAH:
case LAYER_PROTO_IPAH:
break;
case LAYER_TYPE_GRE:
case LAYER_PROTO_GRE:
used = gre_hdr_to_str((const struct gre_hdr *)layer->hdr_ptr, buffer, sizeof(buffer));
break;
case LAYER_TYPE_UDP:
case LAYER_PROTO_UDP:
used = udp_hdr_to_str((const struct udphdr *)layer->hdr_ptr, buffer, sizeof(buffer));
break;
case LAYER_TYPE_TCP:
case LAYER_PROTO_TCP:
used = tcp_hdr_to_str((const struct tcphdr *)layer->hdr_ptr, buffer, sizeof(buffer));
break;
case LAYER_TYPE_ICMP:
case LAYER_PROTO_ICMP:
break;
case LAYER_TYPE_ICMP6:
case LAYER_PROTO_ICMP6:
break;
case LAYER_TYPE_VXLAN:
case LAYER_PROTO_VXLAN:
used = vxlan_hdr_to_str((const struct vxlan_hdr *)layer->hdr_ptr, buffer, sizeof(buffer));
break;
case LAYER_TYPE_GTPV1_U:
case LAYER_PROTO_GTPV1_U:
break;
default:
break;
@@ -1223,7 +1219,7 @@ int packet_get_innermost_tuple2(const struct packet *pkt, struct tuple2 *tuple)
{
layer = &pkt->layers[i];
if (layer->type & LAYER_TYPE_L3)
if (layer->type == LAYER_PROTO_IPV4 || layer->type == LAYER_PROTO_IPV6)
{
set_tuple2((const char *)pkt->data_ptr + layer->hdr_offset, layer->type, tuple);
return 0;
@@ -1244,7 +1240,7 @@ int packet_get_outermost_tuple2(const struct packet *pkt, struct tuple2 *tuple)
{
layer = &pkt->layers[i];
if (layer->type & LAYER_TYPE_L3)
if (layer->type == LAYER_PROTO_IPV4 || layer->type == LAYER_PROTO_IPV6)
{
set_tuple2((const char *)pkt->data_ptr + layer->hdr_offset, layer->type, tuple);
return 0;
@@ -1268,14 +1264,14 @@ int packet_get_innermost_tuple4(const struct packet *pkt, struct tuple4 *tuple)
layer = &pkt->layers[i];
// first get L4 layer
if (layer->type & (LAYER_TYPE_UDP | LAYER_TYPE_TCP))
if (layer->type == LAYER_PROTO_UDP || layer->type == LAYER_PROTO_TCP)
{
layer_l4 = layer;
continue;
}
// second get L3 layer
if (layer->type & LAYER_TYPE_L3)
if (layer->type == LAYER_PROTO_IPV4 || layer->type == LAYER_PROTO_IPV6)
{
layer_l3 = layer;
break;
@@ -1308,14 +1304,14 @@ int packet_get_outermost_tuple4(const struct packet *pkt, struct tuple4 *tuple)
layer = &pkt->layers[i];
// first get L3 layer
if (layer->type & LAYER_TYPE_L3)
if (layer->type == LAYER_PROTO_IPV4 || layer->type == LAYER_PROTO_IPV6)
{
layer_l3 = layer;
continue;
}
// second get L4 layer
if (layer->type & (LAYER_TYPE_UDP | LAYER_TYPE_TCP))
if (layer->type == LAYER_PROTO_UDP || layer->type == LAYER_PROTO_TCP)
{
layer_l4 = layer;
break;
@@ -1349,14 +1345,14 @@ int packet_get_innermost_tuple6(const struct packet *pkt, struct tuple6 *tuple)
layer = &pkt->layers[i];
// first get L4 layer
if (layer->type & (LAYER_TYPE_UDP | LAYER_TYPE_TCP))
if (layer->type == LAYER_PROTO_UDP || layer->type == LAYER_PROTO_TCP)
{
layer_l4 = layer;
continue;
}
// second get L3 layer
if (layer->type & LAYER_TYPE_L3)
if (layer->type == LAYER_PROTO_IPV4 || layer->type == LAYER_PROTO_IPV6)
{
layer_l3 = layer;
break;
@@ -1390,14 +1386,14 @@ int packet_get_outermost_tuple6(const struct packet *pkt, struct tuple6 *tuple)
layer = &pkt->layers[i];
// first get L3 layer
if (layer->type & LAYER_TYPE_L3)
if (layer->type == LAYER_PROTO_IPV4 || layer->type == LAYER_PROTO_IPV6)
{
layer_l3 = layer;
continue;
}
// second get L4 layer
if (layer->type & (LAYER_TYPE_UDP | LAYER_TYPE_TCP))
if (layer->type == LAYER_PROTO_UDP || layer->type == LAYER_PROTO_TCP)
{
layer_l4 = layer;
break;
@@ -1416,14 +1412,14 @@ int packet_get_outermost_tuple6(const struct packet *pkt, struct tuple6 *tuple)
}
}
const struct packet_layer *packet_get_innermost_layer(const struct packet *pkt, enum layer_type type)
const struct packet_layer *packet_get_innermost_layer(const struct packet *pkt, enum layer_proto type)
{
const struct packet_layer *layer = NULL;
for (int8_t i = pkt->layers_used - 1; i >= 0; i--)
{
layer = &pkt->layers[i];
if (layer->type & type)
if (layer->type == type)
{
return layer;
}
@@ -1432,14 +1428,14 @@ const struct packet_layer *packet_get_innermost_layer(const struct packet *pkt,
return NULL;
}
const struct packet_layer *packet_get_outermost_layer(const struct packet *pkt, enum layer_type type)
const struct packet_layer *packet_get_outermost_layer(const struct packet *pkt, enum layer_proto type)
{
const struct packet_layer *layer = NULL;
for (int8_t i = 0; i < pkt->layers_used; i++)
{
layer = &pkt->layers[i];
if (layer->type & type)
if (layer->type == type)
{
return layer;
}