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

TSG-13684 tsg-service-chaining-engine使用VLAN封装Packet并执行Traffic Mirroring

Browse Source
This commit is contained in:
luwenpeng
2023-10-18 10:08:10 +08:00
parent 18561bc4fe
commit 0753e8018c
57 changed files with 1784 additions and 1175 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
common/CMakeLists.txt
View File

@@ -1,4 +1,4 @@
add_library(common src/addr_tuple4.cpp src/session_table.cpp src/raw_packet.cpp src/ctrl_packet.cpp src/bfd.cpp src/utils.cpp src/g_vxlan.cpp src/log.cpp src/timestamp.cpp src/mpack.cpp)
add_library(common src/addr_tuple4.cpp src/session_table.cpp src/data_packet.cpp src/control_packet.cpp src/bfd.cpp src/utils.cpp src/g_vxlan.cpp src/log.cpp src/timestamp.cpp src/mpack.cpp)
target_link_libraries(common PUBLIC cjson)
target_link_libraries(common PUBLIC MESA_handle_logger)

11
common/include/ctrl_packet.h → common/include/control_packet.h
View File

@@ -1,5 +1,5 @@
#ifndef _CTRL_PACKET_H
#define _CTRL_PACKET_H
#ifndef _CONTROL_PACKET_H
#define _CONTROL_PACKET_H
#ifdef __cpluscplus
extern "C"
@@ -16,7 +16,7 @@ enum session_state
SESSION_STATE_RESETALL = 4,
};
struct ctrl_pkt_parser
struct control_packet
{
char tsync[4];
uint64_t session_id;
@@ -27,12 +27,11 @@ struct ctrl_pkt_parser
};
const char *session_state_to_string(enum session_state state);
void ctrl_packet_parser_init(struct ctrl_pkt_parser *handler);
// return 0 : success
// return -1 : error
int ctrl_packet_parser_parse(struct ctrl_pkt_parser *handler, const char *data, size_t length);
void ctrl_packet_parser_dump(struct ctrl_pkt_parser *handler);
int control_packet_parse(struct control_packet *handler, const char *data, size_t length);
void control_packet_dump(struct control_packet *handler);
#ifdef __cpluscplus
}

24
common/include/raw_packet.h → common/include/data_packet.h
View File

@@ -1,5 +1,5 @@
#ifndef _RAW_PACKET_H
#define _RAW_PACKET_H
#ifndef _DATA_PACKET_H
#define _DATA_PACKET_H
#ifdef __cpluscplus
extern "C"
@@ -67,30 +67,28 @@ struct layer_results
uint16_t layers_size;
};
struct raw_pkt_parser
struct data_packet
{
enum layer_type expect_type;
struct layer_results results;
const void *ptr_pkt_start;
uint64_t pkt_trace_id;
const void *data_ptr;
uint64_t trace_id;
};
void raw_packet_parser_init(struct raw_pkt_parser *handler, uint64_t pkt_trace_id, enum layer_type expect_type, uint16_t expect_results_num);
// return most inner payload
const void *raw_packet_parser_parse(struct raw_pkt_parser *handler, const void *data, size_t length);
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 raw_packet_parser_get_most_inner_tuple4(struct raw_pkt_parser *handler, struct addr_tuple4 *addr);
int raw_packet_parser_get_most_outer_tuple4(struct raw_pkt_parser *handler, struct addr_tuple4 *addr);
int data_packet_get_innermost_tuple4(struct data_packet *handler, struct addr_tuple4 *addr);
int data_packet_get_outermost_tuple4(struct data_packet *handler, struct addr_tuple4 *addr);
// return 0 : success
// return -1 : error
int raw_packet_parser_get_most_inner_address(struct raw_pkt_parser *handler, struct addr_tuple4 *addr);
int raw_packet_parser_get_most_outer_address(struct raw_pkt_parser *handler, struct addr_tuple4 *addr);
int data_packet_get_innermost_address(struct data_packet *handler, struct addr_tuple4 *addr);
int data_packet_get_outermost_address(struct data_packet *handler, struct addr_tuple4 *addr);
uint64_t raw_packet_parser_get_hash_value(struct raw_pkt_parser *handler, enum ldbc_method method, int dir_is_i2e);
uint64_t data_packet_get_hash(struct data_packet *handler, enum ldbc_method method, int dir_is_i2e);
#ifdef __cpluscplus
}

20
common/include/utils.h
View File

@@ -11,7 +11,7 @@ extern "C"
#define LOG_TAG_SCE "SCE"
#define LOG_TAG_POLICY "POLICY"
#define LOG_TAG_PKTIO "PACKET_IO"
#define LOG_TAG_RAWPKT "RAW_PACKET"
#define LOG_TAG_RAWPKT "DATA_PACKET"
#define LOG_TAG_CTRLPKT "CTRL_PACKET"
#define LOG_TAG_METRICS "G_METRICS"
#define LOG_TAG_SF_METRICS "SF_METRICS"
@@ -36,23 +36,23 @@ extern "C"
#include <netinet/in.h>
/******************************************************************************
* fixed_num_array
* mutable_array
******************************************************************************/
struct fixed_num_array
struct mutable_array
{
uint64_t elems[128];
int num;
int size;
};
void fixed_num_array_init(struct fixed_num_array *array);
void fixed_num_array_add_elem(struct fixed_num_array *array, uint64_t elem);
void fixed_num_array_del_elem(struct fixed_num_array *array, uint64_t elem);
int fixed_num_array_is_full(struct fixed_num_array *array);
int fixed_num_array_count_elem(struct fixed_num_array *array);
int fixed_num_array_exist_elem(struct fixed_num_array *array, uint64_t elem);
int fixed_num_array_index_elem(struct fixed_num_array *array, int index);
void mutable_array_init(struct mutable_array *array);
void mutable_array_add_elem(struct mutable_array *array, uint64_t elem);
void mutable_array_del_elem(struct mutable_array *array, uint64_t elem);
int mutable_array_is_full(struct mutable_array *array);
int mutable_array_count_elem(struct mutable_array *array);
int mutable_array_exist_elem(struct mutable_array *array, uint64_t elem);
int mutable_array_index_elem(struct mutable_array *array, int index);
/******************************************************************************
* sids

145
common/src/ctrl_packet.cpp → common/src/control_packet.cpp
View File

@@ -6,7 +6,7 @@
#include "log.h"
#include "mpack.h"
#include "utils.h"
#include "ctrl_packet.h"
#include "control_packet.h"
const char *session_state_to_string(enum session_state state)
{
@@ -25,15 +25,12 @@ const char *session_state_to_string(enum session_state state)
}
}
void ctrl_packet_parser_init(struct ctrl_pkt_parser *handler)
{
memset(handler, 0, sizeof(struct ctrl_pkt_parser));
}
// return 0 : success
// return -1 : error
int ctrl_packet_parser_mpack(struct ctrl_pkt_parser *handler, const char *data, size_t length)
int control_packet_parse(struct control_packet *handler, const char *data, size_t length)
{
memset(handler, 0, sizeof(struct control_packet));
mpack_tree_t tree;
mpack_node_t root;
mpack_node_t temp;
@@ -174,139 +171,7 @@ error_out:
return -1;
}
// return 0 : success
// return -1 : error
int ctrl_packet_parser_cjson(struct ctrl_pkt_parser *handler, const char *data, size_t length)
{
int iter = 0;
cJSON *item = NULL;
cJSON *elem = NULL;
cJSON *json = NULL;
json = cJSON_Parse(data);
if (json == NULL)
{
LOG_ERROR("%s: unexpected control packet: (invalid json format) %s", LOG_TAG_CTRLPKT, data);
return -1;
}
// tsync
item = cJSON_GetObjectItem(json, "tsync");
if (!item || !cJSON_IsString(item))
{
LOG_ERROR("%s: unexpected control packet: (invalid tsync format) %s", LOG_TAG_CTRLPKT, data);
goto error_out;
}
memcpy(handler->tsync, item->valuestring, MIN(sizeof(handler->tsync), strlen(item->valuestring)));
// session_id
item = cJSON_GetObjectItem(json, "session_id");
if (!item || !cJSON_IsString(item))
{
LOG_ERROR("%s: unexpected control packet: (invalid session_id format) %s", LOG_TAG_CTRLPKT, data);
goto error_out;
}
handler->session_id = atoll(item->valuestring);
// state
item = cJSON_GetObjectItem(json, "state");
if (!item || !cJSON_IsString(item))
{
LOG_ERROR("%s: unexpected control packet: (invalid state format) %s", LOG_TAG_CTRLPKT, data);
goto error_out;
}
if (strcasecmp(item->valuestring, "opening") == 0)
{
handler->state = SESSION_STATE_OPENING;
}
else if (strcasecmp(item->valuestring, "active") == 0)
{
handler->state = SESSION_STATE_ACTIVE;
}
else if (strcasecmp(item->valuestring, "closing") == 0)
{
handler->state = SESSION_STATE_CLOSING;
}
else if (strcasecmp(item->valuestring, "resetall") == 0)
{
handler->state = SESSION_STATE_RESETALL;
}
else
{
LOG_ERROR("%s: unexpected control packet: (invalid state value) %s", LOG_TAG_CTRLPKT, data);
goto error_out;
}
if (handler->state != SESSION_STATE_ACTIVE)
{
goto success_out;
}
// method
item = cJSON_GetObjectItem(json, "method");
if (!item || !cJSON_IsString(item))
{
LOG_ERROR("%s: unexpected control packet: (invalid method format) %s", LOG_TAG_CTRLPKT, data);
goto error_out;
}
memcpy(handler->method, item->valuestring, MIN(sizeof(handler->method), strlen(item->valuestring)));
if (strcasecmp(item->valuestring, "policy_update") != 0)
{
LOG_ERROR("%s: unexpected control packet: (invalid method value) %s", LOG_TAG_CTRLPKT, data);
goto error_out;
}
// params
item = cJSON_GetObjectItem(json, "params");
if (!item || !cJSON_IsObject(item))
{
LOG_ERROR("%s: unexpected control packet: (invalid params format) %s", LOG_TAG_CTRLPKT, data);
goto error_out;
}
item = cJSON_GetObjectItem(item, "service_chaining");
if (!item || !cJSON_IsArray(item) || !cJSON_GetArraySize(item))
{
LOG_ERROR("%s: unexpected control packet: (invalid service_chaining format) %s", LOG_TAG_CTRLPKT, data);
goto error_out;
}
handler->rule_id_num = MIN(cJSON_GetArraySize(item), (int)(sizeof(handler->rule_ids) / sizeof(handler->rule_ids[0])));
cJSON_ArrayForEach(elem, item)
{
if (!cJSON_IsNumber(elem))
{
LOG_ERROR("%s: unexpected control packet: (invalid service_chaining value) %s", LOG_TAG_POLICY, data);
continue;
}
handler->rule_ids[iter] = elem->valueint;
iter++;
if (iter == handler->rule_id_num)
{
break;
}
}
success_out:
cJSON_Delete(json);
return 0;
error_out:
cJSON_Delete(json);
return -1;
}
// return 0 : success
// return -1 : error
int ctrl_packet_parser_parse(struct ctrl_pkt_parser *handler, const char *data, size_t length)
{
// return ctrl_packet_parser_cjson(handler, data, length);
return ctrl_packet_parser_mpack(handler, data, length);
}
void ctrl_packet_parser_dump(struct ctrl_pkt_parser *handler)
void control_packet_dump(struct control_packet *handler)
{
if (handler)
{

287
common/src/raw_packet.cpp → common/src/data_packet.cpp
View File

@@ -14,18 +14,12 @@
#include "utils.h"
#include "uthash.h"
#include "addr_tuple4.h"
#include "raw_packet.h"
#include "data_packet.h"
/******************************************************************************
* Struct
******************************************************************************/
enum parse_status
{
PARSE_STATUS_CONTINUE,
PARSE_STATUS_STOP
};
struct vlan_hdr
{
uint16_t vlan_cfi;
@@ -66,8 +60,7 @@ struct gtp_hdr
* Static API
******************************************************************************/
static int raw_packet_parser_push(struct raw_pkt_parser *handler, enum layer_type type, uint16_t offset);
static enum parse_status raw_packet_parser_status(struct raw_pkt_parser *handler, const void *data, enum layer_type this_type);
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);
@@ -77,44 +70,38 @@ static const char *layer_type2str(enum layer_type this_type);
static uint16_t parse_gtphdr_len(const struct gtp_hdr *gtph);
// parser protocol
static const void *parse_ether(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type);
static const void *parse_ipv4(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type);
static const void *parse_ipv6(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type);
static const void *parse_tcp(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type);
static const void *parse_udp(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type);
static const void *parse_pppoe_ses(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type);
static const void *parse_vxlan(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type);
static const void *parse_vlan8021q(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type);
static const void *parse_gtpv1_u(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type);
static const void *parse_mpls(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type);
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);
static const void *parse_tcp(struct data_packet *handler, const void *data, size_t length);
static const void *parse_udp(struct data_packet *handler, const void *data, size_t length);
static const void *parse_pppoe_ses(struct data_packet *handler, const void *data, size_t length);
static const void *parse_vxlan(struct data_packet *handler, const void *data, size_t length);
static const void *parse_vlan8021q(struct data_packet *handler, const void *data, size_t length);
static const void *parse_gtpv1_u(struct data_packet *handler, const void *data, size_t length);
static const void *parse_mpls(struct data_packet *handler, const void *data, size_t length);
/******************************************************************************
* Public API
******************************************************************************/
void raw_packet_parser_init(struct raw_pkt_parser *handler, uint64_t pkt_trace_id, enum layer_type expect_type, uint16_t expect_results_num)
{
memset(handler, 0, sizeof(struct raw_pkt_parser));
handler->expect_type = expect_type;
handler->results.layers_used = 0;
handler->results.layers_size = MIN(expect_results_num, (sizeof(handler->results.layers) / sizeof(handler->results.layers[0])));
handler->ptr_pkt_start = NULL;
handler->pkt_trace_id = pkt_trace_id;
}
// return most inner payload
const void *raw_packet_parser_parse(struct raw_pkt_parser *handler, const void *data, size_t length)
const void *data_packet_parse(struct data_packet *handler, const void *data, size_t length, uint64_t trace_id)
{
handler->ptr_pkt_start = data;
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->data_ptr = data;
handler->trace_id = trace_id;
// TESTED
return parse_ether(handler, data, length, LAYER_TYPE_ETHER);
return parse_ether(handler, data, length);
}
// return 0 : success
// return -1 : error
int raw_packet_parser_get_most_inner_tuple4(struct raw_pkt_parser *handler, struct addr_tuple4 *addr)
int data_packet_get_innermost_tuple4(struct data_packet *handler, struct addr_tuple4 *addr)
{
const char *l3_layer_data = NULL;
const char *l4_layer_data = NULL;
@@ -128,7 +115,7 @@ int raw_packet_parser_get_most_inner_tuple4(struct raw_pkt_parser *handler, stru
const struct layer_result *layer = &results->layers[i];
enum layer_type type = layer->type;
LOG_DEBUG("%s: find most inner tuple4, pkt_trace_id: %lu, layer[%d/%d]: %s", LOG_TAG_RAWPKT, handler->pkt_trace_id, i, results->layers_size, layer_type2str(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));
// first get L4 layer
if (type & LAYER_TYPE_L4)
@@ -147,13 +134,13 @@ int raw_packet_parser_get_most_inner_tuple4(struct raw_pkt_parser *handler, stru
if (l3_layer_result)
{
l3_layer_data = (const char *)handler->ptr_pkt_start + l3_layer_result->offset;
l3_layer_data = (const char *)handler->data_ptr + l3_layer_result->offset;
set_addr_tuple4(l3_layer_data, l3_layer_result->type, addr);
}
if (l4_layer_result)
{
l4_layer_data = (const char *)handler->ptr_pkt_start + l4_layer_result->offset;
l4_layer_data = (const char *)handler->data_ptr + l4_layer_result->offset;
set_addr_tuple4(l4_layer_data, l4_layer_result->type, addr);
}
@@ -169,7 +156,7 @@ int raw_packet_parser_get_most_inner_tuple4(struct raw_pkt_parser *handler, stru
// return 0 : success
// return -1 : error
int raw_packet_parser_get_most_outer_tuple4(struct raw_pkt_parser *handler, struct addr_tuple4 *addr)
int data_packet_get_outermost_tuple4(struct data_packet *handler, struct addr_tuple4 *addr)
{
const char *l3_layer_data = NULL;
const char *l4_layer_data = NULL;
@@ -183,7 +170,7 @@ int raw_packet_parser_get_most_outer_tuple4(struct raw_pkt_parser *handler, stru
const struct layer_result *layer = &results->layers[i];
enum layer_type type = layer->type;
LOG_DEBUG("%s: find most outer tuple4, pkt_trace_id: %lu, layer[%d/%d]: %s", LOG_TAG_RAWPKT, handler->pkt_trace_id, i, results->layers_size, layer_type2str(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));
// first get L3 layer
if (type & LAYER_TYPE_L3)
@@ -202,13 +189,13 @@ int raw_packet_parser_get_most_outer_tuple4(struct raw_pkt_parser *handler, stru
if (l3_layer_result)
{
l3_layer_data = (const char *)handler->ptr_pkt_start + l3_layer_result->offset;
l3_layer_data = (const char *)handler->data_ptr + l3_layer_result->offset;
set_addr_tuple4(l3_layer_data, l3_layer_result->type, addr);
}
if (l4_layer_result)
{
l4_layer_data = (const char *)handler->ptr_pkt_start + l4_layer_result->offset;
l4_layer_data = (const char *)handler->data_ptr + l4_layer_result->offset;
set_addr_tuple4(l4_layer_data, l4_layer_result->type, addr);
}
@@ -224,7 +211,7 @@ int raw_packet_parser_get_most_outer_tuple4(struct raw_pkt_parser *handler, stru
// return 0 : success
// return -1 : error
int raw_packet_parser_get_most_inner_address(struct raw_pkt_parser *handler, struct addr_tuple4 *addr)
int data_packet_get_innermost_address(struct data_packet *handler, struct addr_tuple4 *addr)
{
const char *l3_layer_data = NULL;
struct layer_results *results = &handler->results;
@@ -235,10 +222,10 @@ int raw_packet_parser_get_most_inner_address(struct raw_pkt_parser *handler, str
const struct layer_result *layer = &results->layers[i];
enum layer_type type = layer->type;
LOG_DEBUG("%s: find most inner address, pkt_trace_id: %lu, layer[%d/%d]: %s", LOG_TAG_RAWPKT, handler->pkt_trace_id, i, results->layers_size, layer_type2str(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));
if (type & LAYER_TYPE_L3)
{
l3_layer_data = (const char *)handler->ptr_pkt_start + layer->offset;
l3_layer_data = (const char *)handler->data_ptr + layer->offset;
set_addr_tuple4(l3_layer_data, type, addr);
return 0;
}
@@ -249,7 +236,7 @@ int raw_packet_parser_get_most_inner_address(struct raw_pkt_parser *handler, str
// return 0 : success
// return -1 : error
int raw_packet_parser_get_most_outer_address(struct raw_pkt_parser *handler, struct addr_tuple4 *addr)
int data_packet_get_outermost_address(struct data_packet *handler, struct addr_tuple4 *addr)
{
const char *l3_layer_data = NULL;
struct layer_results *results = &handler->results;
@@ -260,10 +247,10 @@ int raw_packet_parser_get_most_outer_address(struct raw_pkt_parser *handler, str
const struct layer_result *layer = &results->layers[i];
enum layer_type type = layer->type;
LOG_DEBUG("%s: find most outer address, pkt_trace_id: %lu, layer[%d/%d]: %s", LOG_TAG_RAWPKT, handler->pkt_trace_id, i, results->layers_size, layer_type2str(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));
if (type & LAYER_TYPE_L3)
{
l3_layer_data = (const char *)handler->ptr_pkt_start + layer->offset;
l3_layer_data = (const char *)handler->data_ptr + layer->offset;
set_addr_tuple4(l3_layer_data, type, addr);
return 0;
}
@@ -272,7 +259,7 @@ int raw_packet_parser_get_most_outer_address(struct raw_pkt_parser *handler, str
return -1;
}
uint64_t raw_packet_parser_get_hash_value(struct raw_pkt_parser *handler, enum ldbc_method method, int dir_is_i2e)
uint64_t data_packet_get_hash(struct data_packet *handler, enum ldbc_method method, int dir_is_i2e)
{
uint64_t temp = 0;
uint64_t hash_value = 1;
@@ -294,12 +281,12 @@ uint64_t raw_packet_parser_get_hash_value(struct raw_pkt_parser *handler, enum l
return hash_value;
}
if (raw_packet_parser_get_most_inner_address(handler, &inner_addr) == -1)
if (data_packet_get_innermost_address(handler, &inner_addr) == -1)
{
return hash_value;
}
if (raw_packet_parser_get_most_outer_address(handler, &outer_addr) == -1)
if (data_packet_get_outermost_address(handler, &outer_addr) == -1)
{
return hash_value;
}
@@ -392,8 +379,8 @@ uint64_t raw_packet_parser_get_hash_value(struct raw_pkt_parser *handler, enum l
char *inner_addr_str = addr_tuple4_to_str(&inner_addr);
char *outer_addr_str = addr_tuple4_to_str(&outer_addr);
LOG_DEBUG("%s: pkt_trace_id: %lu, outer_addr: %s, inner_addr: %s, is_internal: %d, hash_method: %s, hash_value: %lu",
LOG_TAG_RAWPKT, handler->pkt_trace_id, outer_addr_str, inner_addr_str, dir_is_i2e, ldbc_method_to_string(method), hash_value);
LOG_DEBUG("%s: trace_id: %lu, outer_addr: %s, inner_addr: %s, is_internal: %d, hash_method: %s, hash_value: %lu",
LOG_TAG_RAWPKT, handler->trace_id, outer_addr_str, inner_addr_str, dir_is_i2e, ldbc_method_to_string(method), hash_value);
free(inner_addr_str);
free(outer_addr_str);
@@ -406,7 +393,7 @@ uint64_t raw_packet_parser_get_hash_value(struct raw_pkt_parser *handler, enum l
// return 0 : success
// return -ENOMEM : error
static int raw_packet_parser_push(struct raw_pkt_parser *handler, enum layer_type type, uint16_t offset)
static int data_packet_push_layer(struct data_packet *handler, enum layer_type type, uint16_t offset)
{
struct layer_results *result = &handler->results;
@@ -422,30 +409,6 @@ static int raw_packet_parser_push(struct raw_pkt_parser *handler, enum layer_typ
return 0;
}
// return PARSE_STATUS_CONTINUE
// return PARSE_STATUS_STOP
static enum parse_status raw_packet_parser_status(struct raw_pkt_parser *handler, const void *data, enum layer_type this_type)
{
/*
* only when this_type & handler->expect_type is true,
* the information of the current layer will be recorded in results.
*/
if (!(this_type & handler->expect_type))
{
return PARSE_STATUS_CONTINUE;
}
uint16_t offset = (uintptr_t)data - (uintptr_t)(handler->ptr_pkt_start);
if (raw_packet_parser_push(handler, this_type, offset) < 0)
{
return PARSE_STATUS_STOP;
}
else
{
return PARSE_STATUS_CONTINUE;
}
}
static const char *ldbc_method_to_string(enum ldbc_method ldbc_method)
{
switch (ldbc_method)
@@ -583,15 +546,16 @@ static uint16_t parse_gtphdr_len(const struct gtp_hdr *gtph)
return (char *)p_ext_hdr - (char *)gtph;
}
static const void *parse_ether(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type)
static const void *parse_ether(struct data_packet *handler, const void *data, size_t length)
{
if (length < sizeof(struct ethhdr))
{
LOG_ERROR("%s: pkt_trace_id: %lu, this_layer: %s, err: data not enough", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type));
LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_ETHER));
return data;
}
if (raw_packet_parser_status(handler, data, this_type) == PARSE_STATUS_STOP)
uint16_t offset = (uintptr_t)data - (uintptr_t)(handler->data_ptr);
if (data_packet_push_layer(handler, LAYER_TYPE_ETHER, offset) < 0)
{
return data;
}
@@ -602,40 +566,41 @@ static const void *parse_ether(struct raw_pkt_parser *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: pkt_trace_id: %lu, this_layer: %s, payload_len: [%lu/%lu]", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type), data_next_length, length);
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);
switch (next_proto)
{
case ETH_P_8021Q:
case ETH_P_8021AD:
// TESTED
return parse_vlan8021q(handler, data_next_layer, data_next_length, LAYER_TYPE_VLAN);
return parse_vlan8021q(handler, data_next_layer, data_next_length);
case ETH_P_IP:
// TESTED
return parse_ipv4(handler, data_next_layer, data_next_length, LAYER_TYPE_IPV4);
return parse_ipv4(handler, data_next_layer, data_next_length);
case ETH_P_IPV6:
// TESTED
return parse_ipv6(handler, data_next_layer, data_next_length, LAYER_TYPE_IPV6);
return parse_ipv6(handler, data_next_layer, data_next_length);
case ETH_P_PPP_SES:
// TODO
return parse_pppoe_ses(handler, data_next_layer, data_next_length, LAYER_TYPE_PPPOE);
return parse_pppoe_ses(handler, data_next_layer, data_next_length);
case ETH_P_MPLS_UC:
// TESTED
return parse_mpls(handler, data_next_layer, data_next_length, LAYER_TYPE_MPLS);
return parse_mpls(handler, data_next_layer, data_next_length);
default:
LOG_ERROR("%s: pkt_trace_id: %lu, this_layer: %s, stop parse next protocol %d", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type), next_proto);
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);
return data_next_layer;
}
}
static const void *parse_ipv4(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type)
static const void *parse_ipv4(struct data_packet *handler, const void *data, size_t length)
{
if (length < sizeof(struct ip))
{
LOG_ERROR("%s: pkt_trace_id: %lu, this_layer: %s, err: data not enough", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type));
LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_IPV4));
return data;
}
if (raw_packet_parser_status(handler, data, this_type) == PARSE_STATUS_STOP)
uint16_t offset = (uintptr_t)data - (uintptr_t)(handler->data_ptr);
if (data_packet_push_layer(handler, LAYER_TYPE_IPV4, offset) < 0)
{
return data;
}
@@ -646,36 +611,37 @@ static const void *parse_ipv4(struct raw_pkt_parser *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: pkt_trace_id: %lu, this_layer: %s, payload_len: [%lu/%lu]", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type), data_next_length, length);
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);
switch (next_proto)
{
case IPPROTO_TCP:
// TESTED
return parse_tcp(handler, data_next_layer, data_next_length, LAYER_TYPE_TCP);
return parse_tcp(handler, data_next_layer, data_next_length);
case IPPROTO_UDP:
// TESTED
return parse_udp(handler, data_next_layer, data_next_length, LAYER_TYPE_UDP);
return parse_udp(handler, data_next_layer, data_next_length);
case IPPROTO_IPIP:
// TESTED
return parse_ipv4(handler, data_next_layer, data_next_length, LAYER_TYPE_IPV4);
return parse_ipv4(handler, data_next_layer, data_next_length);
case IPPROTO_IPV6:
// TESTED
return parse_ipv6(handler, data_next_layer, data_next_length, LAYER_TYPE_IPV6);
return parse_ipv6(handler, data_next_layer, data_next_length);
default:
LOG_ERROR("%s: pkt_trace_id: %lu, this_layer: %s, stop parse next protocol %d", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type), next_proto);
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);
return data_next_layer;
}
}
static const void *parse_ipv6(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type)
static const void *parse_ipv6(struct data_packet *handler, const void *data, size_t length)
{
if (length < sizeof(struct ip6_hdr))
{
LOG_ERROR("%s: pkt_trace_id: %lu, this_layer: %s, err: data not enough", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type));
LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_IPV6));
return data;
}
if (raw_packet_parser_status(handler, data, this_type) == PARSE_STATUS_STOP)
uint16_t offset = (uintptr_t)data - (uintptr_t)(handler->data_ptr);
if (data_packet_push_layer(handler, LAYER_TYPE_IPV6, offset) < 0)
{
return data;
}
@@ -686,36 +652,37 @@ static const void *parse_ipv6(struct raw_pkt_parser *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: pkt_trace_id: %lu, this_layer: %s, payload_len: [%lu/%lu]", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type), data_next_length, length);
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);
switch (next_proto)
{
case IPPROTO_TCP:
// TESTED
return parse_tcp(handler, data_next_layer, data_next_length, LAYER_TYPE_TCP);
return parse_tcp(handler, data_next_layer, data_next_length);
case IPPROTO_UDP:
// TESTED
return parse_udp(handler, data_next_layer, data_next_length, LAYER_TYPE_UDP);
return parse_udp(handler, data_next_layer, data_next_length);
case IPPROTO_IPIP:
// TESTED
return parse_ipv4(handler, data_next_layer, data_next_length, LAYER_TYPE_IPV4);
return parse_ipv4(handler, data_next_layer, data_next_length);
case IPPROTO_IPV6:
// TESTED
return parse_ipv6(handler, data_next_layer, data_next_length, LAYER_TYPE_IPV6);
return parse_ipv6(handler, data_next_layer, data_next_length);
default:
LOG_ERROR("%s: pkt_trace_id: %lu, this_layer: %s, stop parse next protocol %d", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type), next_proto);
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);
return data_next_layer;
}
}
static const void *parse_tcp(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type)
static const void *parse_tcp(struct data_packet *handler, const void *data, size_t length)
{
if (length < sizeof(struct tcphdr))
{
LOG_ERROR("%s: pkt_trace_id: %lu, this_layer: %s, err: data not enough", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type));
LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_TCP));
return data;
}
if (raw_packet_parser_status(handler, data, this_type) == PARSE_STATUS_STOP)
uint16_t offset = (uintptr_t)data - (uintptr_t)(handler->data_ptr);
if (data_packet_push_layer(handler, LAYER_TYPE_TCP, offset) < 0)
{
return data;
}
@@ -725,20 +692,21 @@ static const void *parse_tcp(struct raw_pkt_parser *handler, const void *data, s
const void *data_next_layer = (const char *)data + hdr_len;
size_t data_next_length = length - hdr_len;
LOG_DEBUG("%s: pkt_trace_id: %lu, this_layer: %s, payload_len: [%lu/%lu]", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type), data_next_length, length);
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);
return data_next_layer;
}
static const void *parse_udp(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type)
static const void *parse_udp(struct data_packet *handler, const void *data, size_t length)
{
if (length < sizeof(struct udp_hdr))
{
LOG_ERROR("%s: pkt_trace_id: %lu, this_layer: %s, err: data not enough", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type));
LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_UDP));
return data;
}
if (raw_packet_parser_status(handler, data, this_type) == PARSE_STATUS_STOP)
uint16_t offset = (uintptr_t)data - (uintptr_t)(handler->data_ptr);
if (data_packet_push_layer(handler, LAYER_TYPE_UDP, offset) < 0)
{
return data;
}
@@ -748,31 +716,32 @@ static const void *parse_udp(struct raw_pkt_parser *handler, const void *data, s
const void *data_next_layer = (const char *)data + hdr_len;
size_t data_next_length = length - hdr_len;
LOG_DEBUG("%s: pkt_trace_id: %lu, this_layer: %s, payload_len: [%lu/%lu]", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type), data_next_length, length);
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);
switch (ntohs(hdr->uh_dport))
{
// VXLAN_DPORT
case 4789:
// TESTED
return parse_vxlan(handler, data_next_layer, data_next_length, LAYER_TYPE_G_VXLAN);
return parse_vxlan(handler, data_next_layer, data_next_length);
// GTP1U_PORT
case 2152:
// TESTED
return parse_gtpv1_u(handler, data_next_layer, data_next_length, LAYER_TYPE_GTPV1_U);
return parse_gtpv1_u(handler, data_next_layer, data_next_length);
default:
return data_next_layer;
}
}
static const void *parse_pppoe_ses(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type)
static const void *parse_pppoe_ses(struct data_packet *handler, const void *data, size_t length)
{
if (length < 8)
{
LOG_ERROR("%s: pkt_trace_id: %lu, this_layer: %s, err: data not enough", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type));
LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_PPPOE));
return data;
}
if (raw_packet_parser_status(handler, data, this_type) == PARSE_STATUS_STOP)
uint16_t offset = (uintptr_t)data - (uintptr_t)(handler->data_ptr);
if (data_packet_push_layer(handler, LAYER_TYPE_PPPOE, offset) < 0)
{
return data;
}
@@ -782,32 +751,33 @@ static const void *parse_pppoe_ses(struct raw_pkt_parser *handler, const void *d
const void *data_next_layer = (const char *)data + hdr_len;
size_t data_next_length = length - hdr_len;
LOG_DEBUG("%s: pkt_trace_id: %lu, this_layer: %s, payload_len: [%lu/%lu]", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type), data_next_length, length);
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);
switch (next_proto)
{
// PPPOE_TYPE_IPV4
case 0x2100:
// TESTED
return parse_ipv4(handler, data_next_layer, data_next_length, LAYER_TYPE_IPV4);
return parse_ipv4(handler, data_next_layer, data_next_length);
// PPPOE_TYPE_IPV6
case 0x5700:
// TODO
return parse_ipv6(handler, data_next_layer, data_next_length, LAYER_TYPE_IPV6);
return parse_ipv6(handler, data_next_layer, data_next_length);
default:
LOG_ERROR("%s: pkt_trace_id: %lu, this_layer: %s, stop parse next protocol %d", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type), next_proto);
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);
return data_next_layer;
}
}
static const void *parse_vxlan(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type)
static const void *parse_vxlan(struct data_packet *handler, const void *data, size_t length)
{
if (length < sizeof(struct vxlan_hdr))
{
LOG_ERROR("%s: pkt_trace_id: %lu, this_layer: %s, err: data not enough", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type));
LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_G_VXLAN));
return NULL;
}
if (raw_packet_parser_status(handler, data, this_type) == PARSE_STATUS_STOP)
uint16_t offset = (uintptr_t)data - (uintptr_t)(handler->data_ptr);
if (data_packet_push_layer(handler, LAYER_TYPE_G_VXLAN, offset) < 0)
{
return data;
}
@@ -817,20 +787,21 @@ static const void *parse_vxlan(struct raw_pkt_parser *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: pkt_trace_id: %lu, this_layer: %s, payload_len: [%lu/%lu]", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type), data_next_length, length);
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);
// TESTED
return parse_ether(handler, data_next_layer, data_next_length, LAYER_TYPE_ETHER);
return parse_ether(handler, data_next_layer, data_next_length);
}
static const void *parse_vlan8021q(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type)
static const void *parse_vlan8021q(struct data_packet *handler, const void *data, size_t length)
{
if (length < sizeof(struct vlan_hdr))
{
LOG_ERROR("%s: pkt_trace_id: %lu, this_layer: %s, err: data not enough", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type));
LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_VLAN));
return NULL;
}
if (raw_packet_parser_status(handler, data, this_type) == PARSE_STATUS_STOP)
uint16_t offset = (uintptr_t)data - (uintptr_t)(handler->data_ptr);
if (data_packet_push_layer(handler, LAYER_TYPE_VLAN, offset) < 0)
{
return data;
}
@@ -841,35 +812,35 @@ static const void *parse_vlan8021q(struct raw_pkt_parser *handler, const void *d
const void *data_next_layer = (const char *)data + hdr_len;
size_t data_next_length = length - hdr_len;
LOG_DEBUG("%s: pkt_trace_id: %lu, this_layer: %s, payload_len: [%lu/%lu]", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type), data_next_length, length);
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);
switch (next_proto)
{
case ETH_P_8021Q:
// TESTED
return parse_vlan8021q(handler, data_next_layer, data_next_length, LAYER_TYPE_VLAN);
return parse_vlan8021q(handler, data_next_layer, data_next_length);
case ETH_P_IP:
// TESTED
return parse_ipv4(handler, data_next_layer, data_next_length, LAYER_TYPE_IPV4);
return parse_ipv4(handler, data_next_layer, data_next_length);
case ETH_P_IPV6:
// TODO
return parse_ipv6(handler, data_next_layer, data_next_length, LAYER_TYPE_IPV6);
return parse_ipv6(handler, data_next_layer, data_next_length);
case ETH_P_PPP_SES:
// TESTED
return parse_pppoe_ses(handler, data_next_layer, data_next_length, LAYER_TYPE_PPPOE);
return parse_pppoe_ses(handler, data_next_layer, data_next_length);
case ETH_P_MPLS_UC:
// TODO
return parse_mpls(handler, data_next_layer, data_next_length, LAYER_TYPE_MPLS);
return parse_mpls(handler, data_next_layer, data_next_length);
default:
LOG_ERROR("%s: pkt_trace_id: %lu, this_layer: %s, stop parse next protocol %d", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type), next_proto);
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);
return data_next_layer;
}
}
static const void *parse_gtpv1_u(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type)
static const void *parse_gtpv1_u(struct data_packet *handler, const void *data, size_t length)
{
if (length < sizeof(struct gtp_hdr))
{
LOG_ERROR("%s: pkt_trace_id: %lu, this_layer: %s, err: data not enough", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type));
LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_GTPV1_U));
return NULL;
}
@@ -879,7 +850,8 @@ static const void *parse_gtpv1_u(struct raw_pkt_parser *handler, const void *dat
return data;
}
if (raw_packet_parser_status(handler, data, this_type) == PARSE_STATUS_STOP)
uint16_t offset = (uintptr_t)data - (uintptr_t)(handler->data_ptr);
if (data_packet_push_layer(handler, LAYER_TYPE_GTPV1_U, offset) < 0)
{
return data;
}
@@ -888,30 +860,31 @@ static const void *parse_gtpv1_u(struct raw_pkt_parser *handler, const void *dat
const void *data_next_layer = (const char *)data + hdr_len;
size_t data_next_length = length - hdr_len;
LOG_DEBUG("%s: pkt_trace_id: %lu, this_layer: %s, payload_len: [%lu/%lu]", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type), data_next_length, length);
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);
switch (next_proto)
{
case 4:
// TESTED
return parse_ipv4(handler, data_next_layer, data_next_length, LAYER_TYPE_IPV4);
return parse_ipv4(handler, data_next_layer, data_next_length);
case 6:
// TESTED
return parse_ipv6(handler, data_next_layer, data_next_length, LAYER_TYPE_IPV6);
return parse_ipv6(handler, data_next_layer, data_next_length);
default:
LOG_ERROR("%s: pkt_trace_id: %lu, this_layer: %s, stop parse next protocol %d", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type), next_proto);
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);
return data_next_layer;
}
}
static const void *parse_mpls(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type)
static const void *parse_mpls(struct data_packet *handler, const void *data, size_t length)
{
if (length < 4)
{
LOG_ERROR("%s: pkt_trace_id: %lu, this_layer: %s, err: data not enough", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type));
LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_MPLS));
return data;
}
if (raw_packet_parser_status(handler, data, this_type) == PARSE_STATUS_STOP)
uint16_t offset = (uintptr_t)data - (uintptr_t)(handler->data_ptr);
if (data_packet_push_layer(handler, LAYER_TYPE_MPLS, offset) < 0)
{
return data;
}
@@ -961,33 +934,33 @@ static const void *parse_mpls(struct raw_pkt_parser *handler, const void *data,
data_next_layer = (const char *)data_next_layer + 4;
data_next_length = data_next_length - 4;
LOG_DEBUG("%s: pkt_trace_id: %lu, this_layer: %s, payload_len: [%lu/%lu]", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type), data_next_length, length);
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);
// TESTED
return parse_ether(handler, data_next_layer, data_next_length, LAYER_TYPE_ETHER);
return parse_ether(handler, data_next_layer, data_next_length);
}
else if (ip_version == 4)
{
LOG_DEBUG("%s: pkt_trace_id: %lu, this_layer: %s, payload_len: [%lu/%lu]", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type), data_next_length, length);
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);
// TESTED
return parse_ipv4(handler, data_next_layer, data_next_length, LAYER_TYPE_IPV4);
return parse_ipv4(handler, data_next_layer, data_next_length);
}
else if (ip_version == 6)
{
LOG_DEBUG("%s: pkt_trace_id: %lu, this_layer: %s, payload_len: [%lu/%lu]", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type), data_next_length, length);
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);
// TODO
return parse_ipv6(handler, data_next_layer, data_next_length, LAYER_TYPE_IPV6);
return parse_ipv6(handler, data_next_layer, data_next_length);
}
else
{
LOG_DEBUG("%s: pkt_trace_id: %lu, this_layer: %s, payload_len: [%lu/%lu]", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type), data_next_length, length);
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);
// TODO
return parse_ether(handler, data_next_layer, data_next_length, LAYER_TYPE_ETHER);
return parse_ether(handler, data_next_layer, data_next_length);
}
}
else
{
LOG_DEBUG("%s: pkt_trace_id: %lu, this_layer: %s, payload_len: [%lu/%lu]", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type), data_next_length, length);
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);
// TESTED
return parse_mpls(handler, data_next_layer, data_next_length, LAYER_TYPE_MPLS);
return parse_mpls(handler, data_next_layer, data_next_length);
}
}

18
common/src/utils.cpp
View File

@@ -12,17 +12,17 @@
#include "log.h"
/******************************************************************************
* fixed_num_array
* mutable_array
******************************************************************************/
void fixed_num_array_init(struct fixed_num_array *array)
void mutable_array_init(struct mutable_array *array)
{
memset(array, 0, sizeof(fixed_num_array));
memset(array, 0, sizeof(mutable_array));
array->num = 0;
array->size = sizeof(array->elems) / sizeof(array->elems[0]);
}
void fixed_num_array_add_elem(struct fixed_num_array *array, uint64_t elem)
void mutable_array_add_elem(struct mutable_array *array, uint64_t elem)
{
if (array->num < array->size)
{
@@ -35,7 +35,7 @@ void fixed_num_array_add_elem(struct fixed_num_array *array, uint64_t elem)
}
}
void fixed_num_array_del_elem(struct fixed_num_array *array, uint64_t elem)
void mutable_array_del_elem(struct mutable_array *array, uint64_t elem)
{
for (int i = 0; i < array->num; i++)
{
@@ -51,7 +51,7 @@ void fixed_num_array_del_elem(struct fixed_num_array *array, uint64_t elem)
}
}
int fixed_num_array_is_full(struct fixed_num_array *array)
int mutable_array_is_full(struct mutable_array *array)
{
if (array->num == array->size)
{
@@ -63,7 +63,7 @@ int fixed_num_array_is_full(struct fixed_num_array *array)
}
}
int fixed_num_array_count_elem(struct fixed_num_array *array)
int mutable_array_count_elem(struct mutable_array *array)
{
if (array)
{
@@ -75,7 +75,7 @@ int fixed_num_array_count_elem(struct fixed_num_array *array)
}
}
int fixed_num_array_exist_elem(struct fixed_num_array *array, uint64_t elem)
int mutable_array_exist_elem(struct mutable_array *array, uint64_t elem)
{
for (int i = 0; i < array->num; i++)
{
@@ -88,7 +88,7 @@ int fixed_num_array_exist_elem(struct fixed_num_array *array, uint64_t elem)
return 0;
}
int fixed_num_array_index_elem(struct fixed_num_array *array, int index)
int mutable_array_index_elem(struct mutable_array *array, int index)
{
if (index >= array->num)
{

20
common/test/CMakeLists.txt
View File

@@ -15,20 +15,20 @@ target_include_directories(gtest_session_table PUBLIC ${CMAKE_SOURCE_DIR}/common
target_link_libraries(gtest_session_table common gtest)
###############################################################################
# gtest_raw_packet
# gtest_data_packet
###############################################################################
add_executable(gtest_raw_packet gtest_raw_packet.cpp)
target_include_directories(gtest_raw_packet PUBLIC ${CMAKE_SOURCE_DIR}/common/include)
target_link_libraries(gtest_raw_packet common gtest)
add_executable(gtest_data_packet gtest_data_packet.cpp)
target_include_directories(gtest_data_packet PUBLIC ${CMAKE_SOURCE_DIR}/common/include)
target_link_libraries(gtest_data_packet common gtest)
###############################################################################
# gtest_ctrl_packet
# gtest_control_packet
###############################################################################
add_executable(gtest_ctrl_packet gtest_ctrl_packet.cpp)
target_include_directories(gtest_ctrl_packet PUBLIC ${CMAKE_SOURCE_DIR}/common/include)
target_link_libraries(gtest_ctrl_packet common gtest)
add_executable(gtest_control_packet gtest_control_packet.cpp)
target_include_directories(gtest_control_packet PUBLIC ${CMAKE_SOURCE_DIR}/common/include)
target_link_libraries(gtest_control_packet common gtest)
###############################################################################
# gtest_utils
@@ -53,7 +53,7 @@ target_link_libraries(gtest_health_check_table common gtest platform)
include(GoogleTest)
gtest_discover_tests(gtest_addr_tuple4)
gtest_discover_tests(gtest_session_table)
gtest_discover_tests(gtest_raw_packet)
gtest_discover_tests(gtest_ctrl_packet)
gtest_discover_tests(gtest_data_packet)
gtest_discover_tests(gtest_control_packet)
gtest_discover_tests(gtest_utils)
gtest_discover_tests(gtest_health_check_table)

89
common/test/gtest_ctrl_packet.cpp → common/test/gtest_control_packet.cpp
View File

@@ -1,9 +1,9 @@
#include <gtest/gtest.h>
#include "mpack.h"
#include "ctrl_packet.h"
#include "control_packet.h"
static u_char ctrl_pkt_active0[] = {
static u_char control_packet_active0[] = {
0x85, 0xA5, 0x74, 0x73, 0x79, 0x6E, 0x63, 0xA3, 0x32, 0x2E, 0x30, 0xAA, 0x73, 0x65, 0x73, 0x73,
0x69, 0x6F, 0x6E, 0x5F, 0x69, 0x64, 0xCF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xA5,
0x73, 0x74, 0x61, 0x74, 0x65, 0xA6, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0xA6, 0x6D, 0x65, 0x74,
@@ -22,7 +22,7 @@ static u_char ctrl_pkt_active0[] = {
0x0A, 0x92, 0xCD, 0x15, 0xB3, 0xCD, 0x1A, 0x0A, 0x92, 0xCD, 0x15, 0xB3, 0xCD, 0x1A, 0x0A, 0x92,
0x01, 0x01, 0x92, 0x01, 0x01};
static u_char ctrl_pkt_active1[] = {
static u_char control_packet_active1[] = {
0x85, 0xA5, 0x74, 0x73, 0x79, 0x6E, 0x63, 0xA3, 0x32, 0x2E, 0x30, 0xAA, 0x73, 0x65, 0x73, 0x73,
0x69, 0x6F, 0x6E, 0x5F, 0x69, 0x64, 0xCF, 0x04, 0x08, 0x02, 0x1B, 0x68, 0x4C, 0x03, 0xE9, 0xA5,
0x73, 0x74, 0x61, 0x74, 0x65, 0xA6, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0xA6, 0x6D, 0x65, 0x74,
@@ -30,12 +30,12 @@ static u_char ctrl_pkt_active1[] = {
0x65, 0xA6, 0x70, 0x61, 0x72, 0x61, 0x6D, 0x73, 0x81, 0xA3, 0x73, 0x63, 0x65, 0x81, 0xA8, 0x72,
0x75, 0x6C, 0x65, 0x5F, 0x69, 0x64, 0x73, 0x91, 0xCE, 0x00, 0x0F, 0x2F, 0x7F};
static u_char ctrl_pkt_opening[] = {
static u_char control_packet_opening[] = {
0x83, 0xA5, 0x74, 0x73, 0x79, 0x6E, 0x63, 0xA3, 0x32, 0x2E, 0x30, 0xAA, 0x73, 0x65, 0x73, 0x73,
0x69, 0x6F, 0x6E, 0x5F, 0x69, 0x64, 0xCF, 0x04, 0x08, 0x02, 0x1B, 0x68, 0x4C, 0x03, 0xE9, 0xA5,
0x73, 0x74, 0x61, 0x74, 0x65, 0xA7, 0x6F, 0x70, 0x65, 0x6E, 0x69, 0x6E, 0x67};
TEST(CTRL_PACKET, PACKAGE0)
TEST(CONTROL_PACKET, PACKAGE0)
{
char *data;
size_t size;
@@ -171,8 +171,8 @@ TEST(CTRL_PACKET, PACKAGE0)
// finish writing
EXPECT_TRUE(mpack_writer_destroy(&writer) == mpack_ok);
EXPECT_TRUE(size == sizeof(ctrl_pkt_active0));
EXPECT_TRUE(memcmp(data, ctrl_pkt_active0, size) == 0);
EXPECT_TRUE(size == sizeof(control_packet_active0));
EXPECT_TRUE(memcmp(data, control_packet_active0, size) == 0);
// data to hex
for (size_t i = 0; i < size; i++)
@@ -184,7 +184,7 @@ TEST(CTRL_PACKET, PACKAGE0)
free(data);
}
TEST(CTRL_PACKET, PACKAGE1)
TEST(CONTROL_PACKET, PACKAGE1)
{
char *data;
size_t size;
@@ -235,8 +235,8 @@ TEST(CTRL_PACKET, PACKAGE1)
// finish writing
EXPECT_TRUE(mpack_writer_destroy(&writer) == mpack_ok);
EXPECT_TRUE(size == sizeof(ctrl_pkt_active1));
EXPECT_TRUE(memcmp(data, ctrl_pkt_active1, size) == 0);
EXPECT_TRUE(size == sizeof(control_packet_active1));
EXPECT_TRUE(memcmp(data, control_packet_active1, size) == 0);
// data to hex
for (size_t i = 0; i < size; i++)
@@ -248,7 +248,7 @@ TEST(CTRL_PACKET, PACKAGE1)
free(data);
}
TEST(CTRL_PACKET, PACKAGE2)
TEST(CONTROL_PACKET, PACKAGE2)
{
char *data;
size_t size;
@@ -274,8 +274,8 @@ TEST(CTRL_PACKET, PACKAGE2)
// finish writing
EXPECT_TRUE(mpack_writer_destroy(&writer) == mpack_ok);
EXPECT_TRUE(size == sizeof(ctrl_pkt_opening));
EXPECT_TRUE(memcmp(data, ctrl_pkt_opening, size) == 0);
EXPECT_TRUE(size == sizeof(control_packet_opening));
EXPECT_TRUE(memcmp(data, control_packet_opening, size) == 0);
// data to hex
for (size_t i = 0; i < size; i++)
@@ -287,49 +287,46 @@ TEST(CTRL_PACKET, PACKAGE2)
free(data);
}
TEST(CTRL_PACKET, PARSE0)
TEST(CONTROL_PACKET, PARSE0)
{
struct ctrl_pkt_parser parser;
ctrl_packet_parser_init(&parser);
EXPECT_TRUE(ctrl_packet_parser_parse(&parser, (const char *)ctrl_pkt_active0, sizeof(ctrl_pkt_active0)) == 0);
ctrl_packet_parser_dump(&parser);
struct control_packet handler;
EXPECT_TRUE(control_packet_parse(&handler, (const char *)control_packet_active0, sizeof(control_packet_active0)) == 0);
control_packet_dump(&handler);
EXPECT_STREQ(parser.tsync, "2.0");
EXPECT_TRUE(parser.session_id == 18446744073709551615);
EXPECT_TRUE(parser.state == SESSION_STATE_ACTIVE);
EXPECT_STREQ(parser.method, "policy_update");
EXPECT_TRUE(parser.rule_id_num == 2);
EXPECT_TRUE(parser.rule_ids[0] == 1111);
EXPECT_TRUE(parser.rule_ids[1] == 2222);
EXPECT_STREQ(handler.tsync, "2.0");
EXPECT_TRUE(handler.session_id == 18446744073709551615);
EXPECT_TRUE(handler.state == SESSION_STATE_ACTIVE);
EXPECT_STREQ(handler.method, "policy_update");
EXPECT_TRUE(handler.rule_id_num == 2);
EXPECT_TRUE(handler.rule_ids[0] == 1111);
EXPECT_TRUE(handler.rule_ids[1] == 2222);
}
TEST(CTRL_PACKET, PARSE1)
TEST(CONTROL_PACKET, PARSE1)
{
struct ctrl_pkt_parser parser;
ctrl_packet_parser_init(&parser);
EXPECT_TRUE(ctrl_packet_parser_parse(&parser, (const char *)ctrl_pkt_active1, sizeof(ctrl_pkt_active1)) == 0);
ctrl_packet_parser_dump(&parser);
struct control_packet handler;
EXPECT_TRUE(control_packet_parse(&handler, (const char *)control_packet_active1, sizeof(control_packet_active1)) == 0);
control_packet_dump(&handler);
EXPECT_STREQ(parser.tsync, "2.0");
EXPECT_TRUE(parser.session_id == 290484492702581737);
EXPECT_TRUE(parser.state == SESSION_STATE_ACTIVE);
EXPECT_STREQ(parser.method, "policy_update");
EXPECT_TRUE(parser.rule_id_num == 1);
EXPECT_TRUE(parser.rule_ids[0] == 995199);
EXPECT_STREQ(handler.tsync, "2.0");
EXPECT_TRUE(handler.session_id == 290484492702581737);
EXPECT_TRUE(handler.state == SESSION_STATE_ACTIVE);
EXPECT_STREQ(handler.method, "policy_update");
EXPECT_TRUE(handler.rule_id_num == 1);
EXPECT_TRUE(handler.rule_ids[0] == 995199);
}
TEST(CTRL_PACKET, PARSE2)
TEST(CONTROL_PACKET, PARSE2)
{
struct ctrl_pkt_parser parser;
ctrl_packet_parser_init(&parser);
EXPECT_TRUE(ctrl_packet_parser_parse(&parser, (const char *)ctrl_pkt_opening, sizeof(ctrl_pkt_opening)) == 0);
ctrl_packet_parser_dump(&parser);
struct control_packet handler;
EXPECT_TRUE(control_packet_parse(&handler, (const char *)control_packet_opening, sizeof(control_packet_opening)) == 0);
control_packet_dump(&handler);
EXPECT_STREQ(parser.tsync, "2.0");
EXPECT_TRUE(parser.session_id == 290484492702581737);
EXPECT_TRUE(parser.state == SESSION_STATE_OPENING);
EXPECT_STREQ(parser.method, "");
EXPECT_TRUE(parser.rule_id_num == 0);
EXPECT_STREQ(handler.tsync, "2.0");
EXPECT_TRUE(handler.session_id == 290484492702581737);
EXPECT_TRUE(handler.state == SESSION_STATE_OPENING);
EXPECT_STREQ(handler.method, "");
EXPECT_TRUE(handler.rule_id_num == 0);
}
int main(int argc, char **argv)

197
common/test/gtest_raw_packet.cpp → common/test/gtest_data_packet.cpp
View File

@@ -1,7 +1,7 @@
#include <gtest/gtest.h>
#include <arpa/inet.h>
#include "raw_packet.h"
#include "data_packet.h"
#include "addr_tuple4.h"
/******************************************************************************
@@ -75,12 +75,11 @@ unsigned char data1[] = {
0xab, 0xcd, 0xab, 0xcd, 0xab, 0xcd, 0xab, 0xcd, 0xab, 0xcd, 0xab, 0xcd, 0xab, 0xcd, 0xab, 0xcd, 0xab, 0xcd, 0xab, 0xcd, 0xab, 0xcd, 0xab, 0xcd, 0xab, 0xcd,
0xab, 0xcd, 0xab, 0xcd, 0xab, 0xcd, 0xab, 0xcd, 0xab, 0xcd, 0xab, 0xcd, 0xab, 0xcd};
TEST(RAW_PACKET, ETH_VLAN_VLAN_IP4_IP4_UDP)
TEST(DATA_PACKET, ETH_VLAN_VLAN_IP4_IP4_UDP)
{
struct raw_pkt_parser handler;
raw_packet_parser_init(&handler, 0, LAYER_TYPE_ALL, 8);
struct data_packet handler;
const void *payload = raw_packet_parser_parse(&handler, (const void *)data1, sizeof(data1));
const void *payload = data_packet_parse(&handler, (const void *)data1, sizeof(data1), 0);
EXPECT_TRUE(payload != nullptr);
EXPECT_TRUE((char *)payload - (char *)&data1 == 70);
@@ -91,8 +90,8 @@ TEST(RAW_PACKET, ETH_VLAN_VLAN_IP4_IP4_UDP)
memset(&inner_addr, 0, sizeof(inner_addr));
memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(raw_packet_parser_get_most_inner_tuple4(&handler, &inner_addr) == 0);
EXPECT_TRUE(raw_packet_parser_get_most_outer_tuple4(&handler, &outer_addr) == 0);
EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0);
inner_addr_str = addr_tuple4_to_str(&inner_addr);
outer_addr_str = addr_tuple4_to_str(&outer_addr);
EXPECT_STREQ(inner_addr_str, "10.10.100.25 62367 10.10.101.2 17000");
@@ -102,8 +101,8 @@ TEST(RAW_PACKET, ETH_VLAN_VLAN_IP4_IP4_UDP)
memset(&inner_addr, 0, sizeof(inner_addr));
memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(raw_packet_parser_get_most_inner_address(&handler, &inner_addr) == 0);
EXPECT_TRUE(raw_packet_parser_get_most_outer_address(&handler, &outer_addr) == 0);
EXPECT_TRUE(data_packet_get_innermost_address(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_address(&handler, &outer_addr) == 0);
inner_addr_str = addr_tuple4_to_str(&inner_addr);
outer_addr_str = addr_tuple4_to_str(&outer_addr);
EXPECT_STREQ(inner_addr_str, "10.10.100.25 0 10.10.101.2 0");
@@ -206,12 +205,11 @@ unsigned char data2[] = {
0xef, 0x9e, 0x67, 0x7e, 0x1e, 0xb0, 0x2a, 0x7f, 0x97, 0xf3, 0x5a, 0xbc, 0x21, 0x8d, 0xf9, 0xc3, 0x30, 0x45, 0xfe, 0x72, 0x74, 0x04, 0x53, 0x99, 0xe7, 0xd1,
0x2b, 0xb6, 0x3a, 0x9c, 0x84, 0x0e, 0x15, 0x5e, 0x75, 0x3b, 0xc9, 0x0e, 0x94, 0xe6, 0x48, 0x0e, 0x37, 0x07, 0xf8, 0xd9, 0x59, 0x4b, 0x04, 0x50};
TEST(RAW_PACKET, ETH_IP6_IP4_TCP_SSH)
TEST(DATA_PACKET, ETH_IP6_IP4_TCP_SSH)
{
struct raw_pkt_parser handler;
raw_packet_parser_init(&handler, 0, LAYER_TYPE_ALL, 8);
struct data_packet handler;
const void *payload = raw_packet_parser_parse(&handler, (const void *)data2, sizeof(data2));
const void *payload = data_packet_parse(&handler, (const void *)data2, sizeof(data2), 0);
EXPECT_TRUE(payload != nullptr);
EXPECT_TRUE((char *)payload - (char *)&data2 == 94);
@@ -222,8 +220,8 @@ TEST(RAW_PACKET, ETH_IP6_IP4_TCP_SSH)
memset(&inner_addr, 0, sizeof(inner_addr));
memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(raw_packet_parser_get_most_inner_tuple4(&handler, &inner_addr) == 0);
EXPECT_TRUE(raw_packet_parser_get_most_outer_tuple4(&handler, &outer_addr) == 0);
EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0);
inner_addr_str = addr_tuple4_to_str(&inner_addr);
outer_addr_str = addr_tuple4_to_str(&outer_addr);
EXPECT_STREQ(inner_addr_str, "1.1.1.1 57639 2.2.2.2 22");
@@ -233,8 +231,8 @@ TEST(RAW_PACKET, ETH_IP6_IP4_TCP_SSH)
memset(&inner_addr, 0, sizeof(inner_addr));
memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(raw_packet_parser_get_most_inner_address(&handler, &inner_addr) == 0);
EXPECT_TRUE(raw_packet_parser_get_most_outer_address(&handler, &outer_addr) == 0);
EXPECT_TRUE(data_packet_get_innermost_address(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_address(&handler, &outer_addr) == 0);
inner_addr_str = addr_tuple4_to_str(&inner_addr);
outer_addr_str = addr_tuple4_to_str(&outer_addr);
EXPECT_STREQ(inner_addr_str, "1.1.1.1 0 2.2.2.2 0");
@@ -332,12 +330,11 @@ unsigned char data3[] = {
0x00, 0x00, 0x03, 0x84, 0x00, 0x09, 0x3a, 0x80, 0x00, 0x01, 0x51, 0x80};
#if 0
TEST(RAW_PACKET, ETH_VLAN_IP6_IP4_GRE_PPP_IP4_UDP_DNS)
TEST(DATA_PACKET, ETH_VLAN_IP6_IP4_GRE_PPP_IP4_UDP_DNS)
{
struct raw_pkt_parser handler;
raw_packet_parser_init(&handler, 0 , LAYER_TYPE_ALL, 8);
struct data_packet handler;
const void *payload = raw_packet_parser_parse(&handler, (const void *)data3, sizeof(data3));
const void *payload = data_packet_parse(&handler, (const void *)data3, sizeof(data3), 0);
EXPECT_TRUE(payload != nullptr);
EXPECT_TRUE((char *)payload - (char *)&data3 == 126);
@@ -348,8 +345,8 @@ TEST(RAW_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(raw_packet_parser_get_most_inner_tuple4(&handler, &inner_addr) == 0);
EXPECT_TRUE(raw_packet_parser_get_most_outer_tuple4(&handler, &outer_addr) == 0);
EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0);
inner_addr_str = addr_tuple4_to_str(&inner_addr);
outer_addr_str = addr_tuple4_to_str(&outer_addr);
EXPECT_STREQ(inner_addr_str, "8.8.8.8 53 172.16.44.3 9879");
@@ -359,8 +356,8 @@ TEST(RAW_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(raw_packet_parser_get_most_inner_address(&handler, &inner_addr) == 0);
EXPECT_TRUE(raw_packet_parser_get_most_outer_address(&handler, &outer_addr) == 0);
EXPECT_TRUE(data_packet_get_innermost_address(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_address(&handler, &outer_addr) == 0);
inner_addr_str = addr_tuple4_to_str(&inner_addr);
outer_addr_str = addr_tuple4_to_str(&outer_addr);
EXPECT_STREQ(inner_addr_str, "8.8.8.8 0 172.16.44.3 0");
@@ -433,12 +430,11 @@ unsigned char data4[] = {
0x81, 0x80, 0x5c, 0x76, 0x00, 0x00, 0x00, 0x00, 0x80, 0x02, 0x20, 0x00, 0xf7, 0x57, 0x00, 0x00, 0x02, 0x04, 0x04, 0xc4, 0x01, 0x03, 0x03, 0x08, 0x01, 0x01,
0x04, 0x02};
TEST(RAW_PACKET, ETH_IP4_IP6_TCP)
TEST(DATA_PACKET, ETH_IP4_IP6_TCP)
{
struct raw_pkt_parser handler;
raw_packet_parser_init(&handler, 0, LAYER_TYPE_ALL, 8);
struct data_packet handler;
const void *payload = raw_packet_parser_parse(&handler, (const void *)data4, sizeof(data4));
const void *payload = data_packet_parse(&handler, (const void *)data4, sizeof(data4), 0);
EXPECT_TRUE(payload != nullptr);
EXPECT_TRUE((char *)payload - (char *)&data4 == 106);
@@ -449,8 +445,8 @@ TEST(RAW_PACKET, ETH_IP4_IP6_TCP)
memset(&inner_addr, 0, sizeof(inner_addr));
memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(raw_packet_parser_get_most_inner_tuple4(&handler, &inner_addr) == 0);
EXPECT_TRUE(raw_packet_parser_get_most_outer_tuple4(&handler, &outer_addr) == 0);
EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0);
inner_addr_str = addr_tuple4_to_str(&inner_addr);
outer_addr_str = addr_tuple4_to_str(&outer_addr);
EXPECT_STREQ(inner_addr_str, "2001:da8:200:900e:200:5efe:d24d:58a3 52556 2600:140e:6::1702:1058 80");
@@ -460,8 +456,8 @@ TEST(RAW_PACKET, ETH_IP4_IP6_TCP)
memset(&inner_addr, 0, sizeof(inner_addr));
memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(raw_packet_parser_get_most_inner_address(&handler, &inner_addr) == 0);
EXPECT_TRUE(raw_packet_parser_get_most_outer_address(&handler, &outer_addr) == 0);
EXPECT_TRUE(data_packet_get_innermost_address(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_address(&handler, &outer_addr) == 0);
inner_addr_str = addr_tuple4_to_str(&inner_addr);
outer_addr_str = addr_tuple4_to_str(&outer_addr);
EXPECT_STREQ(inner_addr_str, "2001:da8:200:900e:200:5efe:d24d:58a3 0 2600:140e:6::1702:1058 0");
@@ -519,12 +515,11 @@ unsigned char data5[] = {
0xca, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xba, 0xbe, 0x75, 0x30, 0x32, 0xc8, 0x00, 0x0c, 0x83, 0xd2, 0x58, 0x58,
0x58, 0x58};
TEST(RAW_PACKET, ETH_IP6_IP6_UDP)
TEST(DATA_PACKET, ETH_IP6_IP6_UDP)
{
struct raw_pkt_parser handler;
raw_packet_parser_init(&handler, 0, LAYER_TYPE_ALL, 8);
struct data_packet handler;
const void *payload = raw_packet_parser_parse(&handler, (const void *)data5, sizeof(data5));
const void *payload = data_packet_parse(&handler, (const void *)data5, sizeof(data5), 0);
EXPECT_TRUE(payload != nullptr);
EXPECT_TRUE((char *)payload - (char *)&data5 == 102);
@@ -535,8 +530,8 @@ TEST(RAW_PACKET, ETH_IP6_IP6_UDP)
memset(&inner_addr, 0, sizeof(inner_addr));
memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(raw_packet_parser_get_most_inner_tuple4(&handler, &inner_addr) == 0);
EXPECT_TRUE(raw_packet_parser_get_most_outer_tuple4(&handler, &outer_addr) == 0);
EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0);
inner_addr_str = addr_tuple4_to_str(&inner_addr);
outer_addr_str = addr_tuple4_to_str(&outer_addr);
EXPECT_STREQ(inner_addr_str, "dead::beef 30000 cafe::babe 13000");
@@ -546,8 +541,8 @@ TEST(RAW_PACKET, ETH_IP6_IP6_UDP)
memset(&inner_addr, 0, sizeof(inner_addr));
memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(raw_packet_parser_get_most_inner_address(&handler, &inner_addr) == 0);
EXPECT_TRUE(raw_packet_parser_get_most_outer_address(&handler, &outer_addr) == 0);
EXPECT_TRUE(data_packet_get_innermost_address(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_address(&handler, &outer_addr) == 0);
inner_addr_str = addr_tuple4_to_str(&inner_addr);
outer_addr_str = addr_tuple4_to_str(&outer_addr);
EXPECT_STREQ(inner_addr_str, "dead::beef 0 cafe::babe 0");
@@ -612,12 +607,11 @@ unsigned char data6[] = {
0x7e, 0x06, 0xc4, 0x42, 0x77, 0x28, 0x25, 0x41, 0x7b, 0x7d, 0x1d, 0xfa, 0xf1, 0x9d, 0x00, 0x50, 0x65, 0xf5, 0x19, 0xd5, 0x00, 0x00, 0x00, 0x00, 0x80, 0x02,
0x20, 0x00, 0xa7, 0x77, 0x00, 0x00, 0x02, 0x04, 0x05, 0xb4, 0x01, 0x03, 0x03, 0x08, 0x01, 0x01, 0x04, 0x02};
TEST(RAW_PACKET, ETH_MPLS_IP4_TCP)
TEST(DATA_PACKET, ETH_MPLS_IP4_TCP)
{
struct raw_pkt_parser handler;
raw_packet_parser_init(&handler, 0, LAYER_TYPE_ALL, 8);
struct data_packet handler;
const void *payload = raw_packet_parser_parse(&handler, (const void *)data6, sizeof(data6));
const void *payload = data_packet_parse(&handler, (const void *)data6, sizeof(data6), 0);
EXPECT_TRUE(payload != nullptr);
EXPECT_TRUE((char *)payload - (char *)&data6 == 70);
@@ -628,8 +622,8 @@ TEST(RAW_PACKET, ETH_MPLS_IP4_TCP)
memset(&inner_addr, 0, sizeof(inner_addr));
memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(raw_packet_parser_get_most_inner_tuple4(&handler, &inner_addr) == 0);
EXPECT_TRUE(raw_packet_parser_get_most_outer_tuple4(&handler, &outer_addr) == 0);
EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0);
inner_addr_str = addr_tuple4_to_str(&inner_addr);
outer_addr_str = addr_tuple4_to_str(&outer_addr);
EXPECT_STREQ(inner_addr_str, "119.40.37.65 61853 123.125.29.250 80");
@@ -639,8 +633,8 @@ TEST(RAW_PACKET, ETH_MPLS_IP4_TCP)
memset(&inner_addr, 0, sizeof(inner_addr));
memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(raw_packet_parser_get_most_inner_address(&handler, &inner_addr) == 0);
EXPECT_TRUE(raw_packet_parser_get_most_outer_address(&handler, &outer_addr) == 0);
EXPECT_TRUE(data_packet_get_innermost_address(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_address(&handler, &outer_addr) == 0);
inner_addr_str = addr_tuple4_to_str(&inner_addr);
outer_addr_str = addr_tuple4_to_str(&outer_addr);
EXPECT_STREQ(inner_addr_str, "119.40.37.65 0 123.125.29.250 0");
@@ -710,12 +704,11 @@ unsigned char data7[] = {
0x00, 0x00, 0x00, 0x00, 0xff, 0x06, 0xa6, 0xd9, 0x0a, 0x1f, 0x00, 0x01, 0x0a, 0x22, 0x00, 0x01, 0x2a, 0xf9, 0x00, 0x17, 0xcf, 0x84, 0x85, 0x39, 0x00, 0x00,
0x00, 0x00, 0x60, 0x02, 0x10, 0x20, 0xf7, 0x91, 0x00, 0x00, 0x02, 0x04, 0x02, 0x18};
TEST(RAW_PACKET, ETH_MPLS_MPLS_IP4_TCP)
TEST(DATA_PACKET, ETH_MPLS_MPLS_IP4_TCP)
{
struct raw_pkt_parser handler;
raw_packet_parser_init(&handler, 0, LAYER_TYPE_ALL, 8);
struct data_packet handler;
const void *payload = raw_packet_parser_parse(&handler, (const void *)data7, sizeof(data7));
const void *payload = data_packet_parse(&handler, (const void *)data7, sizeof(data7), 0);
EXPECT_TRUE(payload != nullptr);
EXPECT_TRUE((char *)payload - (char *)&data7 == 66);
@@ -726,8 +719,8 @@ TEST(RAW_PACKET, ETH_MPLS_MPLS_IP4_TCP)
memset(&inner_addr, 0, sizeof(inner_addr));
memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(raw_packet_parser_get_most_inner_tuple4(&handler, &inner_addr) == 0);
EXPECT_TRUE(raw_packet_parser_get_most_outer_tuple4(&handler, &outer_addr) == 0);
EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0);
inner_addr_str = addr_tuple4_to_str(&inner_addr);
outer_addr_str = addr_tuple4_to_str(&outer_addr);
EXPECT_STREQ(inner_addr_str, "10.31.0.1 11001 10.34.0.1 23");
@@ -737,8 +730,8 @@ TEST(RAW_PACKET, ETH_MPLS_MPLS_IP4_TCP)
memset(&inner_addr, 0, sizeof(inner_addr));
memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(raw_packet_parser_get_most_inner_address(&handler, &inner_addr) == 0);
EXPECT_TRUE(raw_packet_parser_get_most_outer_address(&handler, &outer_addr) == 0);
EXPECT_TRUE(data_packet_get_innermost_address(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_address(&handler, &outer_addr) == 0);
inner_addr_str = addr_tuple4_to_str(&inner_addr);
outer_addr_str = addr_tuple4_to_str(&outer_addr);
EXPECT_STREQ(inner_addr_str, "10.31.0.1 0 10.34.0.1 0");
@@ -813,12 +806,11 @@ unsigned char data8[] = {
0x45, 0x00, 0x00, 0x34, 0x4b, 0xa7, 0x40, 0x00, 0x3f, 0x06, 0xeb, 0x01, 0x64, 0x41, 0x37, 0x00, 0x5b, 0xb9, 0x0e, 0x21, 0x86, 0xe4, 0x01, 0xbb, 0xb6, 0xa5,
0xda, 0x72, 0x7c, 0x31, 0xf8, 0x20, 0x80, 0x10, 0x0f, 0xc0, 0xc3, 0x61, 0x00, 0x00, 0x01, 0x01, 0x08, 0x0a, 0x00, 0x6f, 0xab, 0xdf, 0x9c, 0x61, 0xc7, 0xc5};
TEST(RAW_PACKET, ETH_VLAN_PPPOE_IP4_TCP)
TEST(DATA_PACKET, ETH_VLAN_PPPOE_IP4_TCP)
{
struct raw_pkt_parser handler;
raw_packet_parser_init(&handler, 0, LAYER_TYPE_ALL, 8);
struct data_packet handler;
const void *payload = raw_packet_parser_parse(&handler, (const void *)data8, sizeof(data8));
const void *payload = data_packet_parse(&handler, (const void *)data8, sizeof(data8), 0);
EXPECT_TRUE(payload != nullptr);
EXPECT_TRUE((char *)payload - (char *)&data8 == 78);
@@ -829,8 +821,8 @@ TEST(RAW_PACKET, ETH_VLAN_PPPOE_IP4_TCP)
memset(&inner_addr, 0, sizeof(inner_addr));
memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(raw_packet_parser_get_most_inner_tuple4(&handler, &inner_addr) == 0);
EXPECT_TRUE(raw_packet_parser_get_most_outer_tuple4(&handler, &outer_addr) == 0);
EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0);
inner_addr_str = addr_tuple4_to_str(&inner_addr);
outer_addr_str = addr_tuple4_to_str(&outer_addr);
EXPECT_STREQ(inner_addr_str, "100.65.55.0 34532 91.185.14.33 443");
@@ -840,8 +832,8 @@ TEST(RAW_PACKET, ETH_VLAN_PPPOE_IP4_TCP)
memset(&inner_addr, 0, sizeof(inner_addr));
memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(raw_packet_parser_get_most_inner_address(&handler, &inner_addr) == 0);
EXPECT_TRUE(raw_packet_parser_get_most_outer_address(&handler, &outer_addr) == 0);
EXPECT_TRUE(data_packet_get_innermost_address(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_address(&handler, &outer_addr) == 0);
inner_addr_str = addr_tuple4_to_str(&inner_addr);
outer_addr_str = addr_tuple4_to_str(&outer_addr);
EXPECT_STREQ(inner_addr_str, "100.65.55.0 0 91.185.14.33 0");
@@ -975,12 +967,11 @@ unsigned char data9[] = {
0xb7, 0x9d, 0xd4, 0x4f, 0xe3, 0xac, 0x64, 0xdb, 0x6f, 0x1d, 0xdf, 0xd8, 0x41, 0xd7, 0xd9, 0x50, 0x55, 0x30, 0xeb, 0x4b, 0x19, 0xce, 0x78, 0x1f, 0xa8, 0x1e,
0x87, 0x9c, 0x8f, 0x93, 0x97, 0xd4, 0xa2, 0x28, 0x2c, 0x79, 0x22, 0xc8};
TEST(RAW_PACKET, ETH_IP6_UDP_GTP_IP6_TCP_TLS)
TEST(DATA_PACKET, ETH_IP6_UDP_GTP_IP6_TCP_TLS)
{
struct raw_pkt_parser handler;
raw_packet_parser_init(&handler, 0, LAYER_TYPE_ALL, 8);
struct data_packet handler;
const void *payload = raw_packet_parser_parse(&handler, (const void *)data9, sizeof(data9));
const void *payload = data_packet_parse(&handler, (const void *)data9, sizeof(data9), 0);
EXPECT_TRUE(payload != nullptr);
EXPECT_TRUE((char *)payload - (char *)&data9 == 130);
@@ -991,8 +982,8 @@ TEST(RAW_PACKET, ETH_IP6_UDP_GTP_IP6_TCP_TLS)
memset(&inner_addr, 0, sizeof(inner_addr));
memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(raw_packet_parser_get_most_inner_tuple4(&handler, &inner_addr) == 0);
EXPECT_TRUE(raw_packet_parser_get_most_outer_tuple4(&handler, &outer_addr) == 0);
EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0);
inner_addr_str = addr_tuple4_to_str(&inner_addr);
outer_addr_str = addr_tuple4_to_str(&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");
@@ -1002,8 +993,8 @@ TEST(RAW_PACKET, ETH_IP6_UDP_GTP_IP6_TCP_TLS)
memset(&inner_addr, 0, sizeof(inner_addr));
memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(raw_packet_parser_get_most_inner_address(&handler, &inner_addr) == 0);
EXPECT_TRUE(raw_packet_parser_get_most_outer_address(&handler, &outer_addr) == 0);
EXPECT_TRUE(data_packet_get_innermost_address(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_address(&handler, &outer_addr) == 0);
inner_addr_str = addr_tuple4_to_str(&inner_addr);
outer_addr_str = addr_tuple4_to_str(&outer_addr);
EXPECT_STREQ(inner_addr_str, "2409:8c34:4400:700:0:4:0:3 0 2409:8934:5082:2100:ecad:e0e4:530a:c269 0");
@@ -1144,12 +1135,11 @@ unsigned char data10[] = {
0x0b, 0x4b, 0x21, 0xa2, 0x52, 0x86, 0x95, 0x4e, 0x18, 0xac, 0xa2, 0xaf, 0x29, 0x5b, 0xe7, 0x05, 0xa1, 0xc8, 0xe1, 0x80, 0xfa, 0xb6, 0x5a, 0xed, 0x94, 0x32,
0x4f, 0xe9, 0xf5, 0xf0, 0x61, 0x5d, 0x7f, 0xc4, 0xc4, 0xd1, 0x05, 0x54, 0x13, 0xdb};
TEST(RAW_PACKET, ETH_IP6_UDP_GTP_IP4_TCP_TLS)
TEST(DATA_PACKET, ETH_IP6_UDP_GTP_IP4_TCP_TLS)
{
struct raw_pkt_parser handler;
raw_packet_parser_init(&handler, 0, LAYER_TYPE_ALL, 8);
struct data_packet handler;
const void *payload = raw_packet_parser_parse(&handler, (const void *)data10, sizeof(data10));
const void *payload = data_packet_parse(&handler, (const void *)data10, sizeof(data10), 0);
EXPECT_TRUE(payload != nullptr);
EXPECT_TRUE((char *)payload - (char *)&data10 == 122);
@@ -1160,8 +1150,8 @@ TEST(RAW_PACKET, ETH_IP6_UDP_GTP_IP4_TCP_TLS)
memset(&inner_addr, 0, sizeof(inner_addr));
memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(raw_packet_parser_get_most_inner_tuple4(&handler, &inner_addr) == 0);
EXPECT_TRUE(raw_packet_parser_get_most_outer_tuple4(&handler, &outer_addr) == 0);
EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0);
inner_addr_str = addr_tuple4_to_str(&inner_addr);
outer_addr_str = addr_tuple4_to_str(&outer_addr);
EXPECT_STREQ(inner_addr_str, "10.49.115.138 50081 121.196.250.66 443");
@@ -1171,8 +1161,8 @@ TEST(RAW_PACKET, ETH_IP6_UDP_GTP_IP4_TCP_TLS)
memset(&inner_addr, 0, sizeof(inner_addr));
memset(&outer_addr, 0, sizeof(outer_addr));
EXPECT_TRUE(raw_packet_parser_get_most_inner_address(&handler, &inner_addr) == 0);
EXPECT_TRUE(raw_packet_parser_get_most_outer_address(&handler, &outer_addr) == 0);
EXPECT_TRUE(data_packet_get_innermost_address(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_address(&handler, &outer_addr) == 0);
inner_addr_str = addr_tuple4_to_str(&inner_addr);
outer_addr_str = addr_tuple4_to_str(&outer_addr);
EXPECT_STREQ(inner_addr_str, "10.49.115.138 0 121.196.250.66 0");
@@ -1255,12 +1245,11 @@ unsigned char data11[] = {
0x0b, 0xc1, 0x72, 0x72, 0x72, 0x72, 0xff, 0x0a, 0x00, 0x35, 0x00, 0x28, 0x39, 0xe4, 0x86, 0x84, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x03, 0x77, 0x77, 0x77, 0x06, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x03, 0x63, 0x6f, 0x6d, 0x00, 0x00, 0x01, 0x00, 0x01};
TEST(RAW_PACKET, ETH_IP4_UDP_VXLAN_ETH_IP4_UDP_DNS)
TEST(DATA_PACKET, ETH_IP4_UDP_VXLAN_ETH_IP4_UDP_DNS)
{
struct raw_pkt_parser handler;
raw_packet_parser_init(&handler, 0, LAYER_TYPE_ALL, 8);
struct data_packet handler;
const void *payload = raw_packet_parser_parse(&handler, (const void *)data11, sizeof(data11));
const void *payload = data_packet_parse(&handler, (const void *)data11, sizeof(data11), 0);
EXPECT_TRUE(payload != nullptr);
EXPECT_TRUE((char *)payload - (char *)&data11 == 92);
@@ -1271,8 +1260,8 @@ TEST(RAW_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(raw_packet_parser_get_most_inner_tuple4(&handler, &inner_addr) == 0);
EXPECT_TRUE(raw_packet_parser_get_most_outer_tuple4(&handler, &outer_addr) == 0);
EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0);
inner_addr_str = addr_tuple4_to_str(&inner_addr);
outer_addr_str = addr_tuple4_to_str(&outer_addr);
EXPECT_STREQ(inner_addr_str, "192.168.11.193 65290 114.114.114.114 53");
@@ -1282,8 +1271,8 @@ TEST(RAW_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(raw_packet_parser_get_most_inner_address(&handler, &inner_addr) == 0);
EXPECT_TRUE(raw_packet_parser_get_most_outer_address(&handler, &outer_addr) == 0);
EXPECT_TRUE(data_packet_get_innermost_address(&handler, &inner_addr) == 0);
EXPECT_TRUE(data_packet_get_outermost_address(&handler, &outer_addr) == 0);
inner_addr_str = addr_tuple4_to_str(&inner_addr);
outer_addr_str = addr_tuple4_to_str(&outer_addr);
EXPECT_STREQ(inner_addr_str, "192.168.11.193 0 114.114.114.114 0");
@@ -1328,42 +1317,40 @@ unsigned char data12[] = {
0x68, 0x00, 0xc0, 0xa8, 0x00, 0x0a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0xa8, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
TEST(RAW_PACKET, ETH_MPLS_MPLS_PWETHCW_ETH_ARP)
TEST(DATA_PACKET, ETH_MPLS_MPLS_PWETHCW_ETH_ARP)
{
struct raw_pkt_parser handler;
raw_packet_parser_init(&handler, 0, LAYER_TYPE_ALL, 8);
struct data_packet handler;
const void *payload = raw_packet_parser_parse(&handler, (const void *)data12, sizeof(data12));
const void *payload = data_packet_parse(&handler, (const void *)data12, sizeof(data12), 0);
EXPECT_TRUE(payload != nullptr);
EXPECT_TRUE((char *)payload - (char *)&data12 == 40);
struct addr_tuple4 inner_addr;
struct addr_tuple4 outer_addr;
EXPECT_TRUE(raw_packet_parser_get_most_inner_tuple4(&handler, &inner_addr) == -1);
EXPECT_TRUE(raw_packet_parser_get_most_outer_tuple4(&handler, &outer_addr) == -1);
EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == -1);
EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == -1);
EXPECT_TRUE(raw_packet_parser_get_most_inner_address(&handler, &inner_addr) == -1);
EXPECT_TRUE(raw_packet_parser_get_most_outer_address(&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);
}
TEST(RAW_PACKET, GET_HASH_VALUE)
TEST(DATA_PACKET, GET_HASH_VALUE)
{
struct raw_pkt_parser handler;
raw_packet_parser_init(&handler, 0, LAYER_TYPE_ALL, 8);
struct data_packet handler;
const void *payload = raw_packet_parser_parse(&handler, (const void *)data4, sizeof(data4));
const void *payload = data_packet_parse(&handler, (const void *)data4, sizeof(data4), 0);
EXPECT_TRUE(payload != nullptr);
EXPECT_TRUE((char *)payload - (char *)&data4 == 106);
// inner_addr_str: "2001:da8:200:900e:200:5efe:d24d:58a3 0 2600:140e:6::1702:1058 0"
// outer_addr_str: "210.77.88.163 0 59.66.4.50 0"
EXPECT_TRUE(raw_packet_parser_get_hash_value(&handler, LDBC_METHOD_HASH_INT_IP, 1) == raw_packet_parser_get_hash_value(&handler, LDBC_METHOD_HASH_EXT_IP, 0));
EXPECT_TRUE(raw_packet_parser_get_hash_value(&handler, LDBC_METHOD_HASH_EXT_IP, 1) == raw_packet_parser_get_hash_value(&handler, LDBC_METHOD_HASH_INT_IP, 0));
EXPECT_TRUE(data_packet_get_hash(&handler, LDBC_METHOD_HASH_INT_IP, 1) == data_packet_get_hash(&handler, LDBC_METHOD_HASH_EXT_IP, 0));
EXPECT_TRUE(data_packet_get_hash(&handler, LDBC_METHOD_HASH_EXT_IP, 1) == data_packet_get_hash(&handler, LDBC_METHOD_HASH_INT_IP, 0));
EXPECT_TRUE(raw_packet_parser_get_hash_value(&handler, LDBC_METHOD_HASH_INT_IP_AND_EXT_IP, 1) == raw_packet_parser_get_hash_value(&handler, LDBC_METHOD_HASH_INT_IP_AND_EXT_IP, 0));
EXPECT_TRUE(raw_packet_parser_get_hash_value(&handler, LDBC_METHOD_HASH_INNERMOST_INT_IP, 1) == raw_packet_parser_get_hash_value(&handler, LDBC_METHOD_HASH_INNERMOST_EXT_IP, 0));
EXPECT_TRUE(data_packet_get_hash(&handler, LDBC_METHOD_HASH_INT_IP_AND_EXT_IP, 1) == data_packet_get_hash(&handler, LDBC_METHOD_HASH_INT_IP_AND_EXT_IP, 0));
EXPECT_TRUE(data_packet_get_hash(&handler, LDBC_METHOD_HASH_INNERMOST_INT_IP, 1) == data_packet_get_hash(&handler, LDBC_METHOD_HASH_INNERMOST_EXT_IP, 0));
}
int main(int argc, char **argv)

50
common/test/gtest_utils.cpp
View File

@@ -4,36 +4,36 @@
TEST(UTILS, FIXED_NUM_ARRAY)
{
struct fixed_num_array array;
fixed_num_array_init(&array);
struct mutable_array array;
mutable_array_init(&array);
fixed_num_array_add_elem(&array, 1);
fixed_num_array_add_elem(&array, 2);
fixed_num_array_add_elem(&array, 3);
fixed_num_array_add_elem(&array, 1);
fixed_num_array_add_elem(&array, 2);
mutable_array_add_elem(&array, 1);
mutable_array_add_elem(&array, 2);
mutable_array_add_elem(&array, 3);
mutable_array_add_elem(&array, 1);
mutable_array_add_elem(&array, 2);
EXPECT_TRUE(fixed_num_array_count_elem(&array) == 5);
EXPECT_TRUE(fixed_num_array_index_elem(&array, 0) == 1);
EXPECT_TRUE(fixed_num_array_index_elem(&array, 1) == 2);
EXPECT_TRUE(fixed_num_array_index_elem(&array, 2) == 3);
EXPECT_TRUE(fixed_num_array_index_elem(&array, 3) == 1);
EXPECT_TRUE(fixed_num_array_index_elem(&array, 4) == 2);
EXPECT_TRUE(mutable_array_count_elem(&array) == 5);
EXPECT_TRUE(mutable_array_index_elem(&array, 0) == 1);
EXPECT_TRUE(mutable_array_index_elem(&array, 1) == 2);
EXPECT_TRUE(mutable_array_index_elem(&array, 2) == 3);
EXPECT_TRUE(mutable_array_index_elem(&array, 3) == 1);
EXPECT_TRUE(mutable_array_index_elem(&array, 4) == 2);
fixed_num_array_del_elem(&array, 3); // 1,2,1,2
EXPECT_TRUE(fixed_num_array_count_elem(&array) == 4);
EXPECT_TRUE(fixed_num_array_index_elem(&array, 0) == 1);
EXPECT_TRUE(fixed_num_array_index_elem(&array, 1) == 2);
EXPECT_TRUE(fixed_num_array_index_elem(&array, 2) == 1);
EXPECT_TRUE(fixed_num_array_index_elem(&array, 3) == 2);
mutable_array_del_elem(&array, 3); // 1,2,1,2
EXPECT_TRUE(mutable_array_count_elem(&array) == 4);
EXPECT_TRUE(mutable_array_index_elem(&array, 0) == 1);
EXPECT_TRUE(mutable_array_index_elem(&array, 1) == 2);
EXPECT_TRUE(mutable_array_index_elem(&array, 2) == 1);
EXPECT_TRUE(mutable_array_index_elem(&array, 3) == 2);
fixed_num_array_del_elem(&array, 2); // 1,1
EXPECT_TRUE(fixed_num_array_count_elem(&array) == 2);
EXPECT_TRUE(fixed_num_array_index_elem(&array, 0) == 1);
EXPECT_TRUE(fixed_num_array_index_elem(&array, 1) == 1);
mutable_array_del_elem(&array, 2); // 1,1
EXPECT_TRUE(mutable_array_count_elem(&array) == 2);
EXPECT_TRUE(mutable_array_index_elem(&array, 0) == 1);
EXPECT_TRUE(mutable_array_index_elem(&array, 1) == 1);
fixed_num_array_del_elem(&array, 1);
EXPECT_TRUE(fixed_num_array_count_elem(&array) == 0);
mutable_array_del_elem(&array, 1);
EXPECT_TRUE(mutable_array_count_elem(&array) == 0);
}
TEST(UTILS, SIDS)