gfwleak/tango-tsg-service-chaining-engine
Archived
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

perf: 优化data packet的解析

Browse Source
This commit is contained in:
luwenpeng
2023-11-08 11:01:03 +08:00
parent 8fe574633b
commit 07f41fc298
4 changed files with 136 additions and 152 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
common/include/data_packet.h
View File

@@ -60,28 +60,23 @@ struct layer_result
enum layer_type type;
};
struct layer_results
struct data_packet
{
struct layer_result layers[16];
uint16_t layers_used;
uint16_t layers_size;
};
struct data_packet
{
struct layer_results results;
const void *data_ptr;
uint64_t trace_id;
};
// return most inner payload
// return innermost payload
const void *data_packet_parse(struct data_packet *handler, const void *data, size_t length, uint64_t trace_id);
// return 0 : success
// return -1 : error
int data_packet_get_innermost_tuple4(struct data_packet *handler, struct four_tuple *addr);
int data_packet_get_outermost_tuple4(struct data_packet *handler, struct four_tuple *addr);
int data_packet_get_innermost_four_tuple(struct data_packet *handler, struct four_tuple *addr);
int data_packet_get_outermost_four_tuple(struct data_packet *handler, struct four_tuple *addr);
// return 0 : success
// return -1 : error

221
common/src/data_packet.cpp
View File

@@ -60,16 +60,13 @@ struct gtp_hdr
* Static API
******************************************************************************/
static int data_packet_push_layer(struct data_packet *handler, enum layer_type type, uint16_t offset);
static const char *ldbc_method_to_string(enum ldbc_method ldbc_method);
// parser utils
static void set_addr_tuple4(const void *data, enum layer_type layer_type, struct four_tuple *addr);
static const char *layer_type2str(enum layer_type this_type);
static uint16_t parse_gtphdr_len(const struct gtp_hdr *gtph);
static const char *layer_type_to_string(enum layer_type this_type);
static int data_packet_push_layer(struct data_packet *handler, enum layer_type type, uint16_t offset);
static void populate_four_tuple_from_layer(const void *data, enum layer_type layer_type, struct four_tuple *addr);
// parser protocol
static uint16_t parse_gtphdr_len(const struct gtp_hdr *gtph);
static const void *parse_ether(struct data_packet *handler, const void *data, size_t length);
static const void *parse_ipv4(struct data_packet *handler, const void *data, size_t length);
static const void *parse_ipv6(struct data_packet *handler, const void *data, size_t length);
@@ -85,13 +82,13 @@ static const void *parse_mpls(struct data_packet *handler, const void *data, siz
* Public API
******************************************************************************/
// return most inner payload
// return innermost payload
const void *data_packet_parse(struct data_packet *handler, const void *data, size_t length, uint64_t trace_id)
{
memset(handler, 0, sizeof(struct data_packet));
handler->results.layers_used = 0;
handler->results.layers_size = sizeof(handler->results.layers) / sizeof(handler->results.layers[0]);
handler->layers_used = 0;
handler->layers_size = sizeof(handler->layers) / sizeof(handler->layers[0]);
handler->data_ptr = data;
handler->trace_id = trace_id;
@@ -101,21 +98,20 @@ const void *data_packet_parse(struct data_packet *handler, const void *data, siz
// return 0 : success
// return -1 : error
int data_packet_get_innermost_tuple4(struct data_packet *handler, struct four_tuple *addr)
int data_packet_get_innermost_four_tuple(struct data_packet *handler, struct four_tuple *addr)
{
const char *l3_layer_data = NULL;
const char *l4_layer_data = NULL;
const struct layer_result *l3_layer_result = NULL;
const struct layer_result *l4_layer_result = NULL;
struct layer_results *results = &handler->results;
// search L4 layer and L3 layer in reverse order
for (int8_t i = results->layers_used - 1; i >= 0; i--)
for (int8_t i = handler->layers_used - 1; i >= 0; i--)
{
const struct layer_result *layer = &results->layers[i];
const struct layer_result *layer = &handler->layers[i];
enum layer_type type = layer->type;
LOG_DEBUG("%s: find most inner tuple4, trace_id: %lu, layer[%d/%d]: %s", LOG_TAG_RAWPKT, handler->trace_id, i, results->layers_size, layer_type2str(type));
LOG_DEBUG("%s: find innermost tuple4, trace_id: %lu, layer[%d/%d]: %s", LOG_TAG_RAWPKT, handler->trace_id, i, handler->layers_size, layer_type_to_string(type));
// first get L4 layer
if (type & LAYER_TYPE_L4)
@@ -135,13 +131,13 @@ int data_packet_get_innermost_tuple4(struct data_packet *handler, struct four_tu
if (l3_layer_result)
{
l3_layer_data = (const char *)handler->data_ptr + l3_layer_result->offset;
set_addr_tuple4(l3_layer_data, l3_layer_result->type, addr);
populate_four_tuple_from_layer(l3_layer_data, l3_layer_result->type, addr);
}
if (l4_layer_result)
{
l4_layer_data = (const char *)handler->data_ptr + l4_layer_result->offset;
set_addr_tuple4(l4_layer_data, l4_layer_result->type, addr);
populate_four_tuple_from_layer(l4_layer_data, l4_layer_result->type, addr);
}
if (l3_layer_result && l4_layer_result)
@@ -156,21 +152,20 @@ int data_packet_get_innermost_tuple4(struct data_packet *handler, struct four_tu
// return 0 : success
// return -1 : error
int data_packet_get_outermost_tuple4(struct data_packet *handler, struct four_tuple *addr)
int data_packet_get_outermost_four_tuple(struct data_packet *handler, struct four_tuple *addr)
{
const char *l3_layer_data = NULL;
const char *l4_layer_data = NULL;
const struct layer_result *l3_layer_result = NULL;
const struct layer_result *l4_layer_result = NULL;
struct layer_results *results = &handler->results;
// search L3 layer and L4 layer in order
for (int8_t i = 0; i <= results->layers_used - 1; i++)
for (int8_t i = 0; i <= handler->layers_used - 1; i++)
{
const struct layer_result *layer = &results->layers[i];
const struct layer_result *layer = &handler->layers[i];
enum layer_type type = layer->type;
LOG_DEBUG("%s: find most outer tuple4, trace_id: %lu, layer[%d/%d]: %s", LOG_TAG_RAWPKT, handler->trace_id, i, results->layers_size, layer_type2str(type));
LOG_DEBUG("%s: find outermost tuple4, trace_id: %lu, layer[%d/%d]: %s", LOG_TAG_RAWPKT, handler->trace_id, i, handler->layers_size, layer_type_to_string(type));
// first get L3 layer
if (type & LAYER_TYPE_L3)
@@ -190,13 +185,13 @@ int data_packet_get_outermost_tuple4(struct data_packet *handler, struct four_tu
if (l3_layer_result)
{
l3_layer_data = (const char *)handler->data_ptr + l3_layer_result->offset;
set_addr_tuple4(l3_layer_data, l3_layer_result->type, addr);
populate_four_tuple_from_layer(l3_layer_data, l3_layer_result->type, addr);
}
if (l4_layer_result)
{
l4_layer_data = (const char *)handler->data_ptr + l4_layer_result->offset;
set_addr_tuple4(l4_layer_data, l4_layer_result->type, addr);
populate_four_tuple_from_layer(l4_layer_data, l4_layer_result->type, addr);
}
if (l3_layer_result && l4_layer_result)
@@ -214,19 +209,18 @@ int data_packet_get_outermost_tuple4(struct data_packet *handler, struct four_tu
int data_packet_get_innermost_address(struct data_packet *handler, struct four_tuple *addr)
{
const char *l3_layer_data = NULL;
struct layer_results *results = &handler->results;
// search L3 layer in reverse order
for (int8_t i = results->layers_used - 1; i >= 0; i--)
for (int8_t i = handler->layers_used - 1; i >= 0; i--)
{
const struct layer_result *layer = &results->layers[i];
const struct layer_result *layer = &handler->layers[i];
enum layer_type type = layer->type;
LOG_DEBUG("%s: find most inner address, trace_id: %lu, layer[%d/%d]: %s", LOG_TAG_RAWPKT, handler->trace_id, i, results->layers_size, layer_type2str(type));
LOG_DEBUG("%s: find innermost address, trace_id: %lu, layer[%d/%d]: %s", LOG_TAG_RAWPKT, handler->trace_id, i, handler->layers_size, layer_type_to_string(type));
if (type & LAYER_TYPE_L3)
{
l3_layer_data = (const char *)handler->data_ptr + layer->offset;
set_addr_tuple4(l3_layer_data, type, addr);
populate_four_tuple_from_layer(l3_layer_data, type, addr);
return 0;
}
}
@@ -239,19 +233,18 @@ int data_packet_get_innermost_address(struct data_packet *handler, struct four_t
int data_packet_get_outermost_address(struct data_packet *handler, struct four_tuple *addr)
{
const char *l3_layer_data = NULL;
struct layer_results *results = &handler->results;
// search L3 layer in order
for (int8_t i = 0; i <= results->layers_used - 1; i++)
for (int8_t i = 0; i <= handler->layers_used - 1; i++)
{
const struct layer_result *layer = &results->layers[i];
const struct layer_result *layer = &handler->layers[i];
enum layer_type type = layer->type;
LOG_DEBUG("%s: find most outer address, trace_id: %lu, layer[%d/%d]: %s", LOG_TAG_RAWPKT, handler->trace_id, i, results->layers_size, layer_type2str(type));
LOG_DEBUG("%s: find outermost address, trace_id: %lu, layer[%d/%d]: %s", LOG_TAG_RAWPKT, handler->trace_id, i, handler->layers_size, layer_type_to_string(type));
if (type & LAYER_TYPE_L3)
{
l3_layer_data = (const char *)handler->data_ptr + layer->offset;
set_addr_tuple4(l3_layer_data, type, addr);
populate_four_tuple_from_layer(l3_layer_data, type, addr);
return 0;
}
}
@@ -391,24 +384,6 @@ uint64_t data_packet_get_hash(struct data_packet *handler, enum ldbc_method meth
* Private API
******************************************************************************/
// return 0 : success
// return -ENOMEM : error
static int data_packet_push_layer(struct data_packet *handler, enum layer_type type, uint16_t offset)
{
struct layer_results *result = &handler->results;
if (result->layers_used >= result->layers_size)
{
return -ENOMEM;
}
result->layers[result->layers_used].offset = offset;
result->layers[result->layers_used].type = type;
result->layers_used++;
return 0;
}
static const char *ldbc_method_to_string(enum ldbc_method ldbc_method)
{
switch (ldbc_method)
@@ -428,7 +403,54 @@ static const char *ldbc_method_to_string(enum ldbc_method ldbc_method)
}
}
static void set_addr_tuple4(const void *data, enum layer_type layer_type, struct four_tuple *addr)
static const char *layer_type_to_string(enum layer_type this_type)
{
switch (this_type)
{
case LAYER_TYPE_ETHER:
return "ETHER";
case LAYER_TYPE_PPP:
return "PPP";
case LAYER_TYPE_HDLC:
return "HDLC";
case LAYER_TYPE_VLAN:
return "VLAN";
case LAYER_TYPE_PPPOE:
return "PPPOE";
case LAYER_TYPE_MPLS:
return "MPLS";
case LAYER_TYPE_IPV4:
return "IPV4";
case LAYER_TYPE_IPV6:
return "IPV6";
case LAYER_TYPE_UDP:
return "UDP";
case LAYER_TYPE_TCP:
return "TCP";
case LAYER_TYPE_G_VXLAN:
return "G_VXLAN";
case LAYER_TYPE_GTPV1_U:
return "GTPV1_U";
default:
return "UNKNOWN";
}
}
static int data_packet_push_layer(struct data_packet *handler, enum layer_type type, uint16_t offset)
{
if (handler->layers_used >= handler->layers_size)
{
return -ENOMEM;
}
handler->layers[handler->layers_used].offset = offset;
handler->layers[handler->layers_used].type = type;
handler->layers_used++;
return 0;
}
static void populate_four_tuple_from_layer(const void *data, enum layer_type layer_type, struct four_tuple *addr)
{
const struct tcphdr *tcp_hdr = NULL;
const struct udp_hdr *udp_hdr = NULL;
@@ -464,39 +486,6 @@ static void set_addr_tuple4(const void *data, enum layer_type layer_type, struct
}
}
static const char *layer_type2str(enum layer_type this_type)
{
switch (this_type)
{
case LAYER_TYPE_ETHER:
return "ETHER";
case LAYER_TYPE_PPP:
return "PPP";
case LAYER_TYPE_HDLC:
return "HDLC";
case LAYER_TYPE_VLAN:
return "VLAN";
case LAYER_TYPE_PPPOE:
return "PPPOE";
case LAYER_TYPE_MPLS:
return "MPLS";
case LAYER_TYPE_IPV4:
return "IPV4";
case LAYER_TYPE_IPV6:
return "IPV6";
case LAYER_TYPE_UDP:
return "UDP";
case LAYER_TYPE_TCP:
return "TCP";
case LAYER_TYPE_G_VXLAN:
return "G_VXLAN";
case LAYER_TYPE_GTPV1_U:
return "GTPV1_U";
default:
return "UNKNOWN";
}
}
// FROM SAPP
static uint16_t parse_gtphdr_len(const struct gtp_hdr *gtph)
{
@@ -550,7 +539,7 @@ static const void *parse_ether(struct data_packet *handler, const void *data, si
{
if (length < sizeof(struct ethhdr))
{
LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_ETHER));
LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_ETHER));
return data;
}
@@ -566,7 +555,7 @@ static const void *parse_ether(struct data_packet *handler, const void *data, si
const void *data_next_layer = (const char *)data + hdr_len;
size_t data_next_length = length - hdr_len;
LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_ETHER), data_next_length, length);
LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_ETHER), data_next_length, length);
switch (next_proto)
{
case ETH_P_8021Q:
@@ -586,7 +575,7 @@ static const void *parse_ether(struct data_packet *handler, const void *data, si
// TESTED
return parse_mpls(handler, data_next_layer, data_next_length);
default:
LOG_ERROR("%s: trace_id: %lu, %s, stop parse next protocol %d", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_ETHER), next_proto);
LOG_ERROR("%s: trace_id: %lu, %s, stop parse next protocol %d", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_ETHER), next_proto);
return data_next_layer;
}
}
@@ -595,7 +584,7 @@ static const void *parse_ipv4(struct data_packet *handler, const void *data, siz
{
if (length < sizeof(struct ip))
{
LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_IPV4));
LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_IPV4));
return data;
}
@@ -611,7 +600,7 @@ static const void *parse_ipv4(struct data_packet *handler, const void *data, siz
const void *data_next_layer = (const char *)data + hdr_len;
size_t data_next_length = length - hdr_len;
LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_IPV4), data_next_length, length);
LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_IPV4), data_next_length, length);
switch (next_proto)
{
case IPPROTO_TCP:
@@ -627,7 +616,7 @@ static const void *parse_ipv4(struct data_packet *handler, const void *data, siz
// TESTED
return parse_ipv6(handler, data_next_layer, data_next_length);
default:
LOG_ERROR("%s: trace_id: %lu, %s, stop parse next protocol %d", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_IPV4), next_proto);
LOG_ERROR("%s: trace_id: %lu, %s, stop parse next protocol %d", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_IPV4), next_proto);
return data_next_layer;
}
}
@@ -636,7 +625,7 @@ static const void *parse_ipv6(struct data_packet *handler, const void *data, siz
{
if (length < sizeof(struct ip6_hdr))
{
LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_IPV6));
LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_IPV6));
return data;
}
@@ -652,7 +641,7 @@ static const void *parse_ipv6(struct data_packet *handler, const void *data, siz
const void *data_next_layer = (const char *)data + hdr_len;
size_t data_next_length = length - hdr_len;
LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_IPV6), data_next_length, length);
LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_IPV6), data_next_length, length);
switch (next_proto)
{
case IPPROTO_TCP:
@@ -668,7 +657,7 @@ static const void *parse_ipv6(struct data_packet *handler, const void *data, siz
// TESTED
return parse_ipv6(handler, data_next_layer, data_next_length);
default:
LOG_ERROR("%s: trace_id: %lu, %s, stop parse next protocol %d", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_IPV6), next_proto);
LOG_ERROR("%s: trace_id: %lu, %s, stop parse next protocol %d", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_IPV6), next_proto);
return data_next_layer;
}
}
@@ -677,7 +666,7 @@ static const void *parse_tcp(struct data_packet *handler, const void *data, size
{
if (length < sizeof(struct tcphdr))
{
LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_TCP));
LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_TCP));
return data;
}
@@ -692,7 +681,7 @@ static const void *parse_tcp(struct data_packet *handler, const void *data, size
const void *data_next_layer = (const char *)data + hdr_len;
size_t data_next_length = length - hdr_len;
LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_TCP), data_next_length, length);
LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_TCP), data_next_length, length);
return data_next_layer;
}
@@ -701,7 +690,7 @@ static const void *parse_udp(struct data_packet *handler, const void *data, size
{
if (length < sizeof(struct udp_hdr))
{
LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_UDP));
LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_UDP));
return data;
}
@@ -716,7 +705,7 @@ static const void *parse_udp(struct data_packet *handler, const void *data, size
const void *data_next_layer = (const char *)data + hdr_len;
size_t data_next_length = length - hdr_len;
LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_UDP), data_next_length, length);
LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_UDP), data_next_length, length);
switch (ntohs(hdr->uh_dport))
{
// VXLAN_DPORT
@@ -736,7 +725,7 @@ static const void *parse_pppoe_ses(struct data_packet *handler, const void *data
{
if (length < 8)
{
LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_PPPOE));
LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_PPPOE));
return data;
}
@@ -751,7 +740,7 @@ static const void *parse_pppoe_ses(struct data_packet *handler, const void *data
const void *data_next_layer = (const char *)data + hdr_len;
size_t data_next_length = length - hdr_len;
LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_PPPOE), data_next_length, length);
LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_PPPOE), data_next_length, length);
switch (next_proto)
{
// PPPOE_TYPE_IPV4
@@ -763,7 +752,7 @@ static const void *parse_pppoe_ses(struct data_packet *handler, const void *data
// TODO
return parse_ipv6(handler, data_next_layer, data_next_length);
default:
LOG_ERROR("%s: trace_id: %lu, %s, stop parse next protocol %d", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_PPPOE), next_proto);
LOG_ERROR("%s: trace_id: %lu, %s, stop parse next protocol %d", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_PPPOE), next_proto);
return data_next_layer;
}
}
@@ -772,7 +761,7 @@ static const void *parse_vxlan(struct data_packet *handler, const void *data, si
{
if (length < sizeof(struct vxlan_hdr))
{
LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_G_VXLAN));
LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_G_VXLAN));
return NULL;
}
@@ -787,7 +776,7 @@ static const void *parse_vxlan(struct data_packet *handler, const void *data, si
const void *data_next_layer = (const char *)data + hdr_len;
size_t data_next_length = length - hdr_len;
LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_G_VXLAN), data_next_length, length);
LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_G_VXLAN), data_next_length, length);
// TESTED
return parse_ether(handler, data_next_layer, data_next_length);
}
@@ -796,7 +785,7 @@ static const void *parse_vlan8021q(struct data_packet *handler, const void *data
{
if (length < sizeof(struct vlan_hdr))
{
LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_VLAN));
LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_VLAN));
return NULL;
}
@@ -812,7 +801,7 @@ static const void *parse_vlan8021q(struct data_packet *handler, const void *data
const void *data_next_layer = (const char *)data + hdr_len;
size_t data_next_length = length - hdr_len;
LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_VLAN), data_next_length, length);
LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_VLAN), data_next_length, length);
switch (next_proto)
{
case ETH_P_8021Q:
@@ -831,7 +820,7 @@ static const void *parse_vlan8021q(struct data_packet *handler, const void *data
// TODO
return parse_mpls(handler, data_next_layer, data_next_length);
default:
LOG_ERROR("%s: trace_id: %lu, %s, stop parse next protocol %d", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_VLAN), next_proto);
LOG_ERROR("%s: trace_id: %lu, %s, stop parse next protocol %d", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_VLAN), next_proto);
return data_next_layer;
}
}
@@ -840,7 +829,7 @@ static const void *parse_gtpv1_u(struct data_packet *handler, const void *data,
{
if (length < sizeof(struct gtp_hdr))
{
LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_GTPV1_U));
LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_GTPV1_U));
return NULL;
}
@@ -860,7 +849,7 @@ static const void *parse_gtpv1_u(struct data_packet *handler, const void *data,
const void *data_next_layer = (const char *)data + hdr_len;
size_t data_next_length = length - hdr_len;
LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_GTPV1_U), data_next_length, length);
LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_GTPV1_U), data_next_length, length);
switch (next_proto)
{
case 4:
@@ -870,7 +859,7 @@ static const void *parse_gtpv1_u(struct data_packet *handler, const void *data,
// TESTED
return parse_ipv6(handler, data_next_layer, data_next_length);
default:
LOG_ERROR("%s: trace_id: %lu, %s, stop parse next protocol %d", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_GTPV1_U), next_proto);
LOG_ERROR("%s: trace_id: %lu, %s, stop parse next protocol %d", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_GTPV1_U), next_proto);
return data_next_layer;
}
}
@@ -879,7 +868,7 @@ static const void *parse_mpls(struct data_packet *handler, const void *data, siz
{
if (length < 4)
{
LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_MPLS));
LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_MPLS));
return data;
}
@@ -934,32 +923,32 @@ static const void *parse_mpls(struct data_packet *handler, const void *data, siz
data_next_layer = (const char *)data_next_layer + 4;
data_next_length = data_next_length - 4;
LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_MPLS), data_next_length, length);
LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_MPLS), data_next_length, length);
// TESTED
return parse_ether(handler, data_next_layer, data_next_length);
}
else if (ip_version == 4)
{
LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_MPLS), data_next_length, length);
LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_MPLS), data_next_length, length);
// TESTED
return parse_ipv4(handler, data_next_layer, data_next_length);
}
else if (ip_version == 6)
{
LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_MPLS), data_next_length, length);
LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_MPLS), data_next_length, length);
// TODO
return parse_ipv6(handler, data_next_layer, data_next_length);
}
else
{
LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_MPLS), data_next_length, length);
LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_MPLS), data_next_length, length);
// TODO
return parse_ether(handler, data_next_layer, data_next_length);
}
}
else
{
LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_MPLS), data_next_length, length);
LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_MPLS), data_next_length, length);
// TESTED
return parse_mpls(handler, data_next_layer, data_next_length);
}

48
common/test/gtest_data_packet.cpp
View File

@@ -90,8 +90,8 @@ TEST(DATA_PACKET, ETH_VLAN_VLAN_IP4_IP4_UDP)
memset(&inner_addr, 0, sizeof(inner_addr));
memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0);
EXPECT_TRUE(data_packet_get_innermost_four_tuple(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_four_tuple(&handler, &outer_addr) == 0);
inner_addr_str = four_tuple_to_string(&inner_addr);
outer_addr_str = four_tuple_to_string(&outer_addr);
EXPECT_STREQ(inner_addr_str, "10.10.100.25 62367 10.10.101.2 17000");
@@ -220,8 +220,8 @@ TEST(DATA_PACKET, ETH_IP6_IP4_TCP_SSH)
memset(&inner_addr, 0, sizeof(inner_addr));
memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0);
EXPECT_TRUE(data_packet_get_innermost_four_tuple(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_four_tuple(&handler, &outer_addr) == 0);
inner_addr_str = four_tuple_to_string(&inner_addr);
outer_addr_str = four_tuple_to_string(&outer_addr);
EXPECT_STREQ(inner_addr_str, "1.1.1.1 57639 2.2.2.2 22");
@@ -345,8 +345,8 @@ TEST(DATA_PACKET, ETH_VLAN_IP6_IP4_GRE_PPP_IP4_UDP_DNS)
memset(&inner_addr, 0, sizeof(inner_addr));
memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0);
EXPECT_TRUE(data_packet_get_innermost_four_tuple(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_four_tuple(&handler, &outer_addr) == 0);
inner_addr_str = four_tuple_to_string(&inner_addr);
outer_addr_str = four_tuple_to_string(&outer_addr);
EXPECT_STREQ(inner_addr_str, "8.8.8.8 53 172.16.44.3 9879");
@@ -445,8 +445,8 @@ TEST(DATA_PACKET, ETH_IP4_IP6_TCP)
memset(&inner_addr, 0, sizeof(inner_addr));
memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0);
EXPECT_TRUE(data_packet_get_innermost_four_tuple(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_four_tuple(&handler, &outer_addr) == 0);
inner_addr_str = four_tuple_to_string(&inner_addr);
outer_addr_str = four_tuple_to_string(&outer_addr);
EXPECT_STREQ(inner_addr_str, "2001:da8:200:900e:200:5efe:d24d:58a3 52556 2600:140e:6::1702:1058 80");
@@ -530,8 +530,8 @@ TEST(DATA_PACKET, ETH_IP6_IP6_UDP)
memset(&inner_addr, 0, sizeof(inner_addr));
memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0);
EXPECT_TRUE(data_packet_get_innermost_four_tuple(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_four_tuple(&handler, &outer_addr) == 0);
inner_addr_str = four_tuple_to_string(&inner_addr);
outer_addr_str = four_tuple_to_string(&outer_addr);
EXPECT_STREQ(inner_addr_str, "dead::beef 30000 cafe::babe 13000");
@@ -622,8 +622,8 @@ TEST(DATA_PACKET, ETH_MPLS_IP4_TCP)
memset(&inner_addr, 0, sizeof(inner_addr));
memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0);
EXPECT_TRUE(data_packet_get_innermost_four_tuple(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_four_tuple(&handler, &outer_addr) == 0);
inner_addr_str = four_tuple_to_string(&inner_addr);
outer_addr_str = four_tuple_to_string(&outer_addr);
EXPECT_STREQ(inner_addr_str, "119.40.37.65 61853 123.125.29.250 80");
@@ -719,8 +719,8 @@ TEST(DATA_PACKET, ETH_MPLS_MPLS_IP4_TCP)
memset(&inner_addr, 0, sizeof(inner_addr));
memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0);
EXPECT_TRUE(data_packet_get_innermost_four_tuple(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_four_tuple(&handler, &outer_addr) == 0);
inner_addr_str = four_tuple_to_string(&inner_addr);
outer_addr_str = four_tuple_to_string(&outer_addr);
EXPECT_STREQ(inner_addr_str, "10.31.0.1 11001 10.34.0.1 23");
@@ -821,8 +821,8 @@ TEST(DATA_PACKET, ETH_VLAN_PPPOE_IP4_TCP)
memset(&inner_addr, 0, sizeof(inner_addr));
memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0);
EXPECT_TRUE(data_packet_get_innermost_four_tuple(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_four_tuple(&handler, &outer_addr) == 0);
inner_addr_str = four_tuple_to_string(&inner_addr);
outer_addr_str = four_tuple_to_string(&outer_addr);
EXPECT_STREQ(inner_addr_str, "100.65.55.0 34532 91.185.14.33 443");
@@ -982,8 +982,8 @@ TEST(DATA_PACKET, ETH_IP6_UDP_GTP_IP6_TCP_TLS)
memset(&inner_addr, 0, sizeof(inner_addr));
memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0);
EXPECT_TRUE(data_packet_get_innermost_four_tuple(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_four_tuple(&handler, &outer_addr) == 0);
inner_addr_str = four_tuple_to_string(&inner_addr);
outer_addr_str = four_tuple_to_string(&outer_addr);
EXPECT_STREQ(inner_addr_str, "2409:8c34:4400:700:0:4:0:3 443 2409:8934:5082:2100:ecad:e0e4:530a:c269 46582");
@@ -1150,8 +1150,8 @@ TEST(DATA_PACKET, ETH_IP6_UDP_GTP_IP4_TCP_TLS)
memset(&inner_addr, 0, sizeof(inner_addr));
memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0);
EXPECT_TRUE(data_packet_get_innermost_four_tuple(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_four_tuple(&handler, &outer_addr) == 0);
inner_addr_str = four_tuple_to_string(&inner_addr);
outer_addr_str = four_tuple_to_string(&outer_addr);
EXPECT_STREQ(inner_addr_str, "10.49.115.138 50081 121.196.250.66 443");
@@ -1260,8 +1260,8 @@ TEST(DATA_PACKET, ETH_IP4_UDP_VXLAN_ETH_IP4_UDP_DNS)
memset(&inner_addr, 0, sizeof(inner_addr));
memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0);
EXPECT_TRUE(data_packet_get_innermost_four_tuple(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_four_tuple(&handler, &outer_addr) == 0);
inner_addr_str = four_tuple_to_string(&inner_addr);
outer_addr_str = four_tuple_to_string(&outer_addr);
EXPECT_STREQ(inner_addr_str, "192.168.11.193 65290 114.114.114.114 53");
@@ -1328,8 +1328,8 @@ TEST(DATA_PACKET, ETH_MPLS_MPLS_PWETHCW_ETH_ARP)
struct four_tuple inner_addr;
struct four_tuple outer_addr;
EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == -1);
EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == -1);
EXPECT_TRUE(data_packet_get_innermost_four_tuple(&handler, &inner_addr) == -1);
EXPECT_TRUE(data_packet_get_outermost_four_tuple(&handler, &outer_addr) == -1);
EXPECT_TRUE(data_packet_get_innermost_address(&handler, &inner_addr) == -1);
EXPECT_TRUE(data_packet_get_outermost_address(&handler, &outer_addr) == -1);

6
platform/src/packet_io.cpp
View File

@@ -356,7 +356,7 @@ static struct session_ctx *data_packet_search_session(struct session_table *tabl
data_packet_parse(&data_pkt, (const void *)raw_data, raw_len, 0);
data_packet_get_innermost_tuple4(&data_pkt, &inner_addr);
data_packet_get_innermost_four_tuple(&data_pkt, &inner_addr);
four_tuple_reverse(&inner_addr, &reverse_addr);
struct session_node *node = session_table_search_by_id(table, session_id);
@@ -388,7 +388,7 @@ static struct session_ctx *inject_packet_search_session(struct session_table *ta
data_packet_parse(&data_pkt, (const void *)raw_data, raw_len, 0);
data_packet_get_innermost_tuple4(&data_pkt, &inner_addr);
data_packet_get_innermost_four_tuple(&data_pkt, &inner_addr);
struct session_node *node = session_table_search_by_addr(table, &inner_addr);
if (node == NULL)
@@ -916,7 +916,7 @@ static void handle_session_opening(struct metadata *meta, struct control_packet
struct data_packet data_pkt;
struct four_tuple inner_tuple4;
const void *payload = data_packet_parse(&data_pkt, (const void *)meta->raw_data, meta->raw_len, meta->session_id);
data_packet_get_innermost_tuple4(&data_pkt, &inner_tuple4);
data_packet_get_innermost_four_tuple(&data_pkt, &inner_tuple4);
uint16_t real_offset = (char *)payload - meta->raw_data;
if (real_offset != meta->l7offset)
{