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)

16
conf/sce.conf
View File

@@ -47,13 +47,17 @@ bypass_traffic=0
rx_burst_max=128
min_timeout_ms=900
app_symbol=sce
dev_endpoint=eth_sf_endpoint
dev_nf_interface=eth_nf_interface
dev_endpoint_src_ip=192.168.100.1
# If the configuration file does not set src mac, get src mac through marsio_get_device_ether_addr();
# If the configuration file has src mac set, use the src mac in the file
# dev_endpoint_src_mac=aa:aa:aa:aa:aa:aa
dev_nf_name=nf_0_sce
# dev_endpoint_l2 for vlan
dev_endpoint_l2_name=endpoint_0_sce_l2
vlan_encapsulate_replace_orig_vlan_header=0
# dev_endpoint_l3 for vxlan
dev_endpoint_l3_name=endpoint_0_sce_l3
dev_endpoint_l3_ip=192.168.100.1
# dev_endpoint_l3_mac=aa:aa:aa:aa:aa:aa
[stat]
output_file=log/sce.fs2

18
platform/include/global_metrics.h
View File

@@ -26,13 +26,17 @@ struct device_metrics
struct throughput_metrics nf_rx; // 累计值
struct throughput_metrics nf_tx; // 累计值
struct throughput_metrics endpoint_rx; // 累计值
struct throughput_metrics endpoint_tx; // 累计值
struct throughput_metrics endpoint_drop; // 累计值
struct throughput_metrics endpoint_vxlan_rx; // 累计值
struct throughput_metrics endpoint_vxlan_tx; // 累计值
struct throughput_metrics endpoint_vxlan_drop; // 累计值
struct throughput_metrics endpoint_vlan_rx; // 累计值
struct throughput_metrics endpoint_vlan_tx; // 累计值
struct throughput_metrics endpoint_vlan_drop; // 累计值
};
// raw_pkt_metrics 不包含 g_vxlan 所占的字节
struct raw_pkt_metrics
// data_pkt_metrics 不包含 g_vxlan 所占的字节
struct data_pkt_metrics
{
struct throughput_metrics mirr_bypass; // 累计值
struct throughput_metrics mirr_block; // 累计值
@@ -85,7 +89,7 @@ struct sf_session_metrics
struct thread_metrics
{
struct device_metrics device;
struct raw_pkt_metrics raw_pkt;
struct data_pkt_metrics data_pkt;
struct ctrl_pkt_metrics ctrl_pkt;
struct keepalived_pkt_metrics kee_pkt;
@@ -96,7 +100,7 @@ struct thread_metrics
struct global_metrics
{
struct device_metrics device;
struct raw_pkt_metrics raw_pkt;
struct data_pkt_metrics data_pkt;
struct ctrl_pkt_metrics ctrl_pkt;
struct keepalived_pkt_metrics kee_pkt;

20
platform/include/packet_io.h
View File

@@ -8,19 +8,35 @@ extern "C"
#include <marsio.h>
// only for gtest
/******************************************************************************
* Packet IO API for gtest
******************************************************************************/
int mbuff_get_metadata(marsio_buff_t *rx_buff, struct metadata *meta);
int mbuff_set_metadata(marsio_buff_t *tx_buff, struct metadata *meta);
void vlan_encapsulate(marsio_buff_t *mbuff, int vlan_id, int replace_orig_vlan_header);
struct mr_instance *packet_io_get_mr_instance(struct packet_io *handle);
/******************************************************************************
* Packet IO API for global
******************************************************************************/
struct packet_io *packet_io_create(const char *profile, int thread_num, cpu_set_t *coremask);
void packet_io_destory(struct packet_io *handle);
/******************************************************************************
* Packet IO API for thread
******************************************************************************/
// return 0 for success
// return -1 for error
int packet_io_thread_init(struct packet_io *handle, struct thread_ctx *thread_ctx);
void packet_io_thread_wait(struct packet_io *handle, struct thread_ctx *thread_ctx, int timeout_ms);
// return n_packet_recved
int packet_io_thread_polling_nf(struct packet_io *handle, struct thread_ctx *thread_ctx);
int packet_io_thread_polling_endpoint(struct packet_io *handle, struct thread_ctx *thread_ctx);
int packet_io_thread_polling_endpoint_l3(struct packet_io *handle, struct thread_ctx *thread_ctx);
int packet_io_thread_polling_endpoint_l2(struct packet_io *handle, struct thread_ctx *thread_ctx);
#ifdef __cpluscplus
}

18
platform/include/policy.h
View File

@@ -7,7 +7,7 @@ extern "C"
#endif
#include "utils.h"
#include "raw_packet.h"
#include "data_packet.h"
#include <linux/if_ether.h>
enum traffic_type
@@ -45,12 +45,12 @@ enum action_reason
ACTION_FORWAED_DUE_SELECTED_SF = 0x20,
};
enum package_method
enum encapsulate_method
{
PACKAGE_METHOD_NONE = 0,
PACKAGE_METHOD_LAYER2_SWITCH = 1,
PACKAGE_METHOD_LAYER3_SWITCH = 2,
PACKAGE_METHOD_VXLAN_G = 3,
ENCAPSULATE_METHOD_NONE = 0,
ENCAPSULATE_METHOD_LAYER2_SWITCH = 1,
ENCAPSULATE_METHOD_LAYER3_SWITCH = 2,
ENCAPSULATE_METHOD_VXLAN_G = 3,
};
enum health_check_method
@@ -73,7 +73,7 @@ struct health_check
struct connectivity
{
enum package_method method;
enum encapsulate_method method;
int int_vlan_tag;
int ext_vlan_tag;
char dest_ip[64];
@@ -123,7 +123,7 @@ const char *traffic_type_to_string(enum traffic_type traffic_type);
const char *forward_type_to_string(enum forward_type forward_type);
const char *session_action_to_string(enum session_action session_action);
const char *action_reason_to_string(enum action_reason action_reason);
const char *package_method_to_string(enum package_method package_method);
const char *encapsulate_method_to_string(enum encapsulate_method encap_method);
struct selected_chaining *selected_chaining_create(int chaining_size, uint64_t session_id, char *session_addr);
void selected_chaining_destory(struct selected_chaining *chaining);
@@ -140,7 +140,7 @@ void policy_enforcer_destory(struct policy_enforcer *enforcer);
// return -1 : error
int policy_enforcer_register(struct policy_enforcer *enforcer);
int policy_enforce_chaining_size(struct policy_enforcer *enforcer);
void policy_enforce_select_chainings(struct policy_enforcer *enforcer, struct selected_chainings *chainings, struct session_ctx *s_ctx, struct raw_pkt_parser *parser, uint64_t rule_id, int dir_is_i2e);
void policy_enforce_select_chainings(struct policy_enforcer *enforcer, struct selected_chainings *chainings, struct session_ctx *s_ctx, struct data_packet *data_pkt, uint64_t rule_id, int dir_is_i2e);
#ifdef __cpluscplus
}

2
platform/include/sce.h
View File

@@ -76,7 +76,7 @@ struct session_ctx
char *session_addr;
struct addr_tuple4 inner_tuple4;
struct fixed_num_array rule_ids;
struct mutable_array rule_ids;
struct metadata *decrypted_meta_i2e;
struct metadata *decrypted_meta_e2i;

322
platform/src/global_metrics.cpp
View File

@@ -8,68 +8,82 @@
enum SCE_STAT_FIELD
{
// device_metrics
// device_nf
STAT_DEVICE_NF_RX_PKT,
STAT_DEVICE_NF_RX_B,
STAT_DEVICE_NF_TX_PKT,
STAT_DEVICE_NF_TX_B,
STAT_DEVICE_ENDPOINT_RX_PKT,
STAT_DEVICE_ENDPOINT_RX_B,
STAT_DEVICE_ENDPOINT_TX_PKT,
STAT_DEVICE_ENDPOINT_TX_B,
// keepalived_pkt_metrics
STAT_KEE_PKT_DOWN_RX_PKT,
STAT_KEE_PKT_DOWN_RX_B,
STAT_KEE_PKT_DOWN_TX_PKT,
STAT_KEE_PKT_DOWN_TX_B,
// device_endpoint_vxlan
STAT_DEVICE_ENDPOINT_VXLAN_RX_PKT,
STAT_DEVICE_ENDPOINT_VXLAN_RX_B,
STAT_DEVICE_ENDPOINT_VXLAN_TX_PKT,
STAT_DEVICE_ENDPOINT_VXLAN_TX_B,
STAT_KEE_PKT_UP_RX_PKT,
STAT_KEE_PKT_UP_RX_B,
STAT_KEE_PKT_UP_TX_DROP_PKT,
STAT_KEE_PKT_UP_TX_DROP_B,
// raw_pkt_metrics
STAT_RAW_PKT_MIRR_BYPASS_PKT,
STAT_RAW_PKT_MIRR_BYPASS_B,
// device_endpoint_vlan
STAT_DEVICE_ENDPOINT_VLAN_RX_PKT,
STAT_DEVICE_ENDPOINT_VLAN_RX_B,
STAT_RAW_PKT_MIRR_BLOCK_PKT,
STAT_RAW_PKT_MIRR_BLOCK_B,
STAT_DEVICE_ENDPOINT_VLAN_TX_PKT,
STAT_DEVICE_ENDPOINT_VLAN_TX_B,
STAT_RAW_PKT_MIRR_RX_DROP_PKT,
STAT_RAW_PKT_MIRR_RX_DROP_B,
STAT_DEVICE_ENDPOINT_VXLAN_DROP_PKT,
STAT_DEVICE_ENDPOINT_VXLAN_DROP_B,
STAT_RAW_PKT_MIRR_TX_PKT,
STAT_RAW_PKT_MIRR_TX_B,
STAT_DEVICE_ENDPOINT_VLAN_DROP_PKT,
STAT_DEVICE_ENDPOINT_VLAN_DROP_B,
STAT_RAW_PKT_STEE_BYPASS_PKT,
STAT_RAW_PKT_STEE_BYPASS_B,
// data_pkt_metrics
STAT_DATA_PKT_MIRR_BYPASS_PKT,
STAT_DATA_PKT_MIRR_BYPASS_B,
STAT_RAW_PKT_STEE_BLOCK_PKT,
STAT_RAW_PKT_STEE_BLOCK_B,
STAT_DATA_PKT_MIRR_BLOCK_PKT,
STAT_DATA_PKT_MIRR_BLOCK_B,
STAT_RAW_PKT_STEE_RX_PKT,
STAT_RAW_PKT_STEE_RX_B,
STAT_DATA_PKT_MIRR_RX_DROP_PKT,
STAT_DATA_PKT_MIRR_RX_DROP_B,
STAT_RAW_PKT_STEE_TX_PKT,
STAT_RAW_PKT_STEE_TX_B,
STAT_DATA_PKT_MIRR_TX_PKT,
STAT_DATA_PKT_MIRR_TX_B,
STAT_RAW_PKT_MISS_SESS_PKT,
STAT_RAW_PKT_MISS_SESS_B,
STAT_DATA_PKT_STEE_BYPASS_PKT,
STAT_DATA_PKT_STEE_BYPASS_B,
STAT_RAW_PKT_ERROR_BYPASS_PKT,
STAT_RAW_PKT_ERROR_BYPASS_B,
STAT_DATA_PKT_STEE_BLOCK_PKT,
STAT_DATA_PKT_STEE_BLOCK_B,
STAT_RAW_PKT_ERROR_BLOCK_PKT,
STAT_RAW_PKT_ERROR_BLOCK_B,
STAT_DATA_PKT_STEE_RX_PKT,
STAT_DATA_PKT_STEE_RX_B,
STAT_DEVICE_ENDPOINT_DROP_PKT,
STAT_DEVICE_ENDPOINT_DROP_B,
STAT_DATA_PKT_STEE_TX_PKT,
STAT_DATA_PKT_STEE_TX_B,
STAT_DATA_PKT_MISS_SESS_PKT,
STAT_DATA_PKT_MISS_SESS_B,
STAT_DATA_PKT_ERROR_BYPASS_PKT,
STAT_DATA_PKT_ERROR_BYPASS_B,
STAT_DATA_PKT_ERROR_BLOCK_PKT,
STAT_DATA_PKT_ERROR_BLOCK_B,
// sf_status_metrics
STAT_SF_STATUS_ACTIVE,
STAT_SF_STATUS_INACTIVE,
// ctrl_pkt_metrics
STAT_CTRL_PKT_RX_PKT,
@@ -88,84 +102,94 @@ enum SCE_STAT_FIELD
STAT_SF_SESSION_NUM,
STAT_SF_SESSION_LOG,
// sf_status_metrics
STAT_SF_STATUS_ACTIVE,
STAT_SF_STATUS_INACTIVE,
// max
STAT_MAX,
};
static const char *stat_map[] =
{
// device_metrics
[STAT_DEVICE_NF_RX_PKT] = "nf_rx_pkt",
[STAT_DEVICE_NF_RX_B] = "nf_rx_B",
// device_nf
[STAT_DEVICE_NF_RX_PKT] = "dev_nf_rx_P",
[STAT_DEVICE_NF_RX_B] = "dev_nf_rx_B",
[STAT_DEVICE_NF_TX_PKT] = "nf_tx_pkt",
[STAT_DEVICE_NF_TX_B] = "nf_tx_B",
[STAT_DEVICE_NF_TX_PKT] = "dev_nf_tx_P",
[STAT_DEVICE_NF_TX_B] = "dev_nf_tx_B",
[STAT_DEVICE_ENDPOINT_RX_PKT] = "endp_rx_pkt",
[STAT_DEVICE_ENDPOINT_RX_B] = "endp_rx_B",
[STAT_DEVICE_ENDPOINT_TX_PKT] = "endp_tx_pkt",
[STAT_DEVICE_ENDPOINT_TX_B] = "endp_tx_B",
// keepalived_pkt_metrics
[STAT_KEE_PKT_DOWN_RX_PKT] = "kee_d_rx_pkt",
[STAT_KEE_PKT_DOWN_RX_PKT] = "kee_d_rx_P",
[STAT_KEE_PKT_DOWN_RX_B] = "kee_d_rx_B",
[STAT_KEE_PKT_DOWN_TX_PKT] = "kee_d_tx_pkt",
[STAT_KEE_PKT_DOWN_TX_PKT] = "kee_d_tx_P",
[STAT_KEE_PKT_DOWN_TX_B] = "kee_d_tx_B",
[STAT_KEE_PKT_UP_RX_PKT] = "kee_u_rx_pkt",
// device_endpoint_vxlan
[STAT_DEVICE_ENDPOINT_VXLAN_RX_PKT] = "dev_l3_rx_P",
[STAT_DEVICE_ENDPOINT_VXLAN_RX_B] = "dev_l3_rx_B",
[STAT_DEVICE_ENDPOINT_VXLAN_TX_PKT] = "dev_l3_tx_P",
[STAT_DEVICE_ENDPOINT_VXLAN_TX_B] = "dev_l3_tx_B",
[STAT_KEE_PKT_UP_RX_PKT] = "kee_u_rx_P",
[STAT_KEE_PKT_UP_RX_B] = "kee_u_rx_B",
[STAT_KEE_PKT_UP_TX_DROP_PKT] = "kee_u_rxdop_pkt",
[STAT_KEE_PKT_UP_TX_DROP_PKT] = "kee_u_rxdop_P",
[STAT_KEE_PKT_UP_TX_DROP_B] = "kee_u_rxdop_B",
// raw_pkt_metrics
[STAT_RAW_PKT_MIRR_BYPASS_PKT] = "mirr_bypass_pkt",
[STAT_RAW_PKT_MIRR_BYPASS_B] = "mirr_bypass_B",
// device_endpoint_vlan
[STAT_DEVICE_ENDPOINT_VLAN_RX_PKT] = "dev_l2_rx_P",
[STAT_DEVICE_ENDPOINT_VLAN_RX_B] = "dev_l2_rx_B",
[STAT_RAW_PKT_MIRR_BLOCK_PKT] = "mirr_block_pkt",
[STAT_RAW_PKT_MIRR_BLOCK_B] = "mirr_block_B",
[STAT_DEVICE_ENDPOINT_VLAN_TX_PKT] = "dev_l2_tx_P",
[STAT_DEVICE_ENDPOINT_VLAN_TX_B] = "dev_l2_tx_B",
[STAT_RAW_PKT_MIRR_RX_DROP_PKT] = "mirr_rxdop_pkt",
[STAT_RAW_PKT_MIRR_RX_DROP_B] = "mirr_rxdop_B",
[STAT_DEVICE_ENDPOINT_VXLAN_DROP_PKT] = "dev_l3_dop_P",
[STAT_DEVICE_ENDPOINT_VXLAN_DROP_B] = "dev_l3_dop_B",
[STAT_RAW_PKT_MIRR_TX_PKT] = "mirro_tx_pkt",
[STAT_RAW_PKT_MIRR_TX_B] = "mirro_tx_B",
[STAT_DEVICE_ENDPOINT_VLAN_DROP_PKT] = "dev_l2_dop_P",
[STAT_DEVICE_ENDPOINT_VLAN_DROP_B] = "dev_l2_dop_B",
[STAT_RAW_PKT_STEE_BYPASS_PKT] = "stee_bypass_pkt",
[STAT_RAW_PKT_STEE_BYPASS_B] = "stee_bypass_B",
// data_pkt_metrics
[STAT_DATA_PKT_MIRR_BYPASS_PKT] = "mirr_bypass_P",
[STAT_DATA_PKT_MIRR_BYPASS_B] = "mirr_bypass_B",
[STAT_RAW_PKT_STEE_BLOCK_PKT] = "stee_block_pkt",
[STAT_RAW_PKT_STEE_BLOCK_B] = "stee_block_B",
[STAT_DATA_PKT_MIRR_BLOCK_PKT] = "mirr_block_P",
[STAT_DATA_PKT_MIRR_BLOCK_B] = "mirr_block_B",
[STAT_RAW_PKT_STEE_RX_PKT] = "stee_rx_pkt",
[STAT_RAW_PKT_STEE_RX_B] = "stee_rx_B",
[STAT_DATA_PKT_MIRR_RX_DROP_PKT] = "mirr_rxdop_P",
[STAT_DATA_PKT_MIRR_RX_DROP_B] = "mirr_rxdop_B",
[STAT_RAW_PKT_STEE_TX_PKT] = "stee_tx_pkt",
[STAT_RAW_PKT_STEE_TX_B] = "stee_tx_B",
[STAT_DATA_PKT_MIRR_TX_PKT] = "mirro_tx_P",
[STAT_DATA_PKT_MIRR_TX_B] = "mirro_tx_B",
[STAT_RAW_PKT_MISS_SESS_PKT] = "miss_sess_pkt",
[STAT_RAW_PKT_MISS_SESS_B] = "miss_sess_B",
[STAT_DATA_PKT_STEE_BYPASS_PKT] = "stee_bypass_P",
[STAT_DATA_PKT_STEE_BYPASS_B] = "stee_bypass_B",
[STAT_RAW_PKT_ERROR_BYPASS_PKT] = "err_bypass_pkt",
[STAT_RAW_PKT_ERROR_BYPASS_B] = "err_bypass_B",
[STAT_DATA_PKT_STEE_BLOCK_PKT] = "stee_block_P",
[STAT_DATA_PKT_STEE_BLOCK_B] = "stee_block_B",
[STAT_RAW_PKT_ERROR_BLOCK_PKT] = "err_block_pkt",
[STAT_RAW_PKT_ERROR_BLOCK_B] = "err_block_B",
[STAT_DATA_PKT_STEE_RX_PKT] = "stee_rx_P",
[STAT_DATA_PKT_STEE_RX_B] = "stee_rx_B",
[STAT_DEVICE_ENDPOINT_DROP_PKT] = "endp_drop_pkt",
[STAT_DEVICE_ENDPOINT_DROP_B] = "endp_drop_B",
[STAT_DATA_PKT_STEE_TX_PKT] = "stee_tx_P",
[STAT_DATA_PKT_STEE_TX_B] = "stee_tx_B",
[STAT_DATA_PKT_MISS_SESS_PKT] = "miss_sess_P",
[STAT_DATA_PKT_MISS_SESS_B] = "miss_sess_B",
[STAT_DATA_PKT_ERROR_BYPASS_PKT] = "err_bypass_P",
[STAT_DATA_PKT_ERROR_BYPASS_B] = "err_bypass_B",
[STAT_DATA_PKT_ERROR_BLOCK_PKT] = "err_block_P",
[STAT_DATA_PKT_ERROR_BLOCK_B] = "err_block_B",
// sf_status_metrics
[STAT_SF_STATUS_ACTIVE] = "sf_active",
[STAT_SF_STATUS_INACTIVE] = "sf_inactive",
// ctrl_pkt_metrics
[STAT_CTRL_PKT_RX_PKT] = "ctrl_rx_pkt",
[STAT_CTRL_PKT_RX_PKT] = "ctrl_rx_P",
[STAT_CTRL_PKT_RX_B] = "ctrl_rx_B",
[STAT_CTRL_PKT_TX_PKT] = "ctrl_tx_pkt",
[STAT_CTRL_PKT_TX_PKT] = "ctrl_tx_P",
[STAT_CTRL_PKT_TX_B] = "ctrl_tx_B",
[STAT_CTRL_PKT_OPENING] = "ctrl_opening",
@@ -175,13 +199,9 @@ static const char *stat_map[] =
[STAT_CTRL_PKT_ERROR] = "ctrl_error",
// sf_session_metrics
[STAT_SF_SESSION_NUM] = "session_num",
[STAT_SF_SESSION_NUM] = "curr_sessions",
[STAT_SF_SESSION_LOG] = "session_logs",
// sf_status_metrics
[STAT_SF_STATUS_ACTIVE] = "sf_active",
[STAT_SF_STATUS_INACTIVE] = "sf_inactive",
[STAT_MAX] = NULL};
static void global_metrics_parse_config(const char *profile, struct metrics_config *config)
@@ -297,34 +317,43 @@ void global_metrics_dump(struct global_metrics *global_metrics)
global_metrics->device.nf_rx.n_bytes += thread_metrics->device.nf_rx.n_bytes;
global_metrics->device.nf_tx.n_pkts += thread_metrics->device.nf_tx.n_pkts;
global_metrics->device.nf_tx.n_bytes += thread_metrics->device.nf_tx.n_bytes;
global_metrics->device.endpoint_rx.n_pkts += thread_metrics->device.endpoint_rx.n_pkts;
global_metrics->device.endpoint_rx.n_bytes += thread_metrics->device.endpoint_rx.n_bytes;
global_metrics->device.endpoint_tx.n_pkts += thread_metrics->device.endpoint_tx.n_pkts;
global_metrics->device.endpoint_tx.n_bytes += thread_metrics->device.endpoint_tx.n_bytes;
global_metrics->device.endpoint_drop.n_pkts += thread_metrics->device.endpoint_drop.n_pkts;
global_metrics->device.endpoint_drop.n_bytes += thread_metrics->device.endpoint_drop.n_bytes;
global_metrics->raw_pkt.mirr_bypass.n_pkts += thread_metrics->raw_pkt.mirr_bypass.n_pkts;
global_metrics->raw_pkt.mirr_bypass.n_bytes += thread_metrics->raw_pkt.mirr_bypass.n_bytes;
global_metrics->raw_pkt.mirr_block.n_pkts += thread_metrics->raw_pkt.mirr_block.n_pkts;
global_metrics->raw_pkt.mirr_block.n_bytes += thread_metrics->raw_pkt.mirr_block.n_bytes;
global_metrics->raw_pkt.mirr_rx_drop.n_pkts += thread_metrics->raw_pkt.mirr_rx_drop.n_pkts;
global_metrics->raw_pkt.mirr_rx_drop.n_bytes += thread_metrics->raw_pkt.mirr_rx_drop.n_bytes;
global_metrics->raw_pkt.mirr_tx.n_pkts += thread_metrics->raw_pkt.mirr_tx.n_pkts;
global_metrics->raw_pkt.mirr_tx.n_bytes += thread_metrics->raw_pkt.mirr_tx.n_bytes;
global_metrics->raw_pkt.stee_bypass.n_pkts += thread_metrics->raw_pkt.stee_bypass.n_pkts;
global_metrics->raw_pkt.stee_bypass.n_bytes += thread_metrics->raw_pkt.stee_bypass.n_bytes;
global_metrics->raw_pkt.stee_block.n_pkts += thread_metrics->raw_pkt.stee_block.n_pkts;
global_metrics->raw_pkt.stee_block.n_bytes += thread_metrics->raw_pkt.stee_block.n_bytes;
global_metrics->raw_pkt.stee_rx.n_pkts += thread_metrics->raw_pkt.stee_rx.n_pkts;
global_metrics->raw_pkt.stee_rx.n_bytes += thread_metrics->raw_pkt.stee_rx.n_bytes;
global_metrics->raw_pkt.stee_tx.n_pkts += thread_metrics->raw_pkt.stee_tx.n_pkts;
global_metrics->raw_pkt.stee_tx.n_bytes += thread_metrics->raw_pkt.stee_tx.n_bytes;
global_metrics->raw_pkt.miss_sess.n_pkts += thread_metrics->raw_pkt.miss_sess.n_pkts;
global_metrics->raw_pkt.miss_sess.n_bytes += thread_metrics->raw_pkt.miss_sess.n_bytes;
global_metrics->raw_pkt.error_bypass.n_pkts += thread_metrics->raw_pkt.error_bypass.n_pkts;
global_metrics->raw_pkt.error_bypass.n_bytes += thread_metrics->raw_pkt.error_bypass.n_bytes;
global_metrics->raw_pkt.error_block.n_pkts += thread_metrics->raw_pkt.error_block.n_pkts;
global_metrics->raw_pkt.error_block.n_bytes += thread_metrics->raw_pkt.error_block.n_bytes;
global_metrics->device.endpoint_vxlan_rx.n_pkts += thread_metrics->device.endpoint_vxlan_rx.n_pkts;
global_metrics->device.endpoint_vxlan_rx.n_bytes += thread_metrics->device.endpoint_vxlan_rx.n_bytes;
global_metrics->device.endpoint_vxlan_tx.n_pkts += thread_metrics->device.endpoint_vxlan_tx.n_pkts;
global_metrics->device.endpoint_vxlan_tx.n_bytes += thread_metrics->device.endpoint_vxlan_tx.n_bytes;
global_metrics->device.endpoint_vxlan_drop.n_pkts += thread_metrics->device.endpoint_vxlan_drop.n_pkts;
global_metrics->device.endpoint_vxlan_drop.n_bytes += thread_metrics->device.endpoint_vxlan_drop.n_bytes;
global_metrics->device.endpoint_vlan_rx.n_pkts += thread_metrics->device.endpoint_vlan_rx.n_pkts;
global_metrics->device.endpoint_vlan_rx.n_bytes += thread_metrics->device.endpoint_vlan_rx.n_bytes;
global_metrics->device.endpoint_vlan_tx.n_pkts += thread_metrics->device.endpoint_vlan_tx.n_pkts;
global_metrics->device.endpoint_vlan_tx.n_bytes += thread_metrics->device.endpoint_vlan_tx.n_bytes;
global_metrics->device.endpoint_vlan_drop.n_pkts += thread_metrics->device.endpoint_vlan_drop.n_pkts;
global_metrics->device.endpoint_vlan_drop.n_bytes += thread_metrics->device.endpoint_vlan_drop.n_bytes;
global_metrics->data_pkt.mirr_bypass.n_pkts += thread_metrics->data_pkt.mirr_bypass.n_pkts;
global_metrics->data_pkt.mirr_bypass.n_bytes += thread_metrics->data_pkt.mirr_bypass.n_bytes;
global_metrics->data_pkt.mirr_block.n_pkts += thread_metrics->data_pkt.mirr_block.n_pkts;
global_metrics->data_pkt.mirr_block.n_bytes += thread_metrics->data_pkt.mirr_block.n_bytes;
global_metrics->data_pkt.mirr_rx_drop.n_pkts += thread_metrics->data_pkt.mirr_rx_drop.n_pkts;
global_metrics->data_pkt.mirr_rx_drop.n_bytes += thread_metrics->data_pkt.mirr_rx_drop.n_bytes;
global_metrics->data_pkt.mirr_tx.n_pkts += thread_metrics->data_pkt.mirr_tx.n_pkts;
global_metrics->data_pkt.mirr_tx.n_bytes += thread_metrics->data_pkt.mirr_tx.n_bytes;
global_metrics->data_pkt.stee_bypass.n_pkts += thread_metrics->data_pkt.stee_bypass.n_pkts;
global_metrics->data_pkt.stee_bypass.n_bytes += thread_metrics->data_pkt.stee_bypass.n_bytes;
global_metrics->data_pkt.stee_block.n_pkts += thread_metrics->data_pkt.stee_block.n_pkts;
global_metrics->data_pkt.stee_block.n_bytes += thread_metrics->data_pkt.stee_block.n_bytes;
global_metrics->data_pkt.stee_rx.n_pkts += thread_metrics->data_pkt.stee_rx.n_pkts;
global_metrics->data_pkt.stee_rx.n_bytes += thread_metrics->data_pkt.stee_rx.n_bytes;
global_metrics->data_pkt.stee_tx.n_pkts += thread_metrics->data_pkt.stee_tx.n_pkts;
global_metrics->data_pkt.stee_tx.n_bytes += thread_metrics->data_pkt.stee_tx.n_bytes;
global_metrics->data_pkt.miss_sess.n_pkts += thread_metrics->data_pkt.miss_sess.n_pkts;
global_metrics->data_pkt.miss_sess.n_bytes += thread_metrics->data_pkt.miss_sess.n_bytes;
global_metrics->data_pkt.error_bypass.n_pkts += thread_metrics->data_pkt.error_bypass.n_pkts;
global_metrics->data_pkt.error_bypass.n_bytes += thread_metrics->data_pkt.error_bypass.n_bytes;
global_metrics->data_pkt.error_block.n_pkts += thread_metrics->data_pkt.error_block.n_pkts;
global_metrics->data_pkt.error_block.n_bytes += thread_metrics->data_pkt.error_block.n_bytes;
global_metrics->ctrl_pkt.rx.n_pkts += thread_metrics->ctrl_pkt.rx.n_pkts;
global_metrics->ctrl_pkt.rx.n_bytes += thread_metrics->ctrl_pkt.rx.n_bytes;
global_metrics->ctrl_pkt.tx.n_pkts += thread_metrics->ctrl_pkt.tx.n_pkts;
@@ -359,48 +388,57 @@ void global_metrics_dump(struct global_metrics *global_metrics)
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_NF_TX_PKT], 0, FS_OP_SET, global_metrics->device.nf_tx.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_NF_TX_B], 0, FS_OP_SET, global_metrics->device.nf_tx.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_RX_PKT], 0, FS_OP_SET, global_metrics->device.endpoint_rx.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_RX_B], 0, FS_OP_SET, global_metrics->device.endpoint_rx.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_VXLAN_RX_PKT], 0, FS_OP_SET, global_metrics->device.endpoint_vxlan_rx.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_VXLAN_RX_B], 0, FS_OP_SET, global_metrics->device.endpoint_vxlan_rx.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_TX_PKT], 0, FS_OP_SET, global_metrics->device.endpoint_tx.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_TX_B], 0, FS_OP_SET, global_metrics->device.endpoint_tx.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_VXLAN_TX_PKT], 0, FS_OP_SET, global_metrics->device.endpoint_vxlan_tx.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_VXLAN_TX_B], 0, FS_OP_SET, global_metrics->device.endpoint_vxlan_tx.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_DROP_PKT], 0, FS_OP_SET, global_metrics->device.endpoint_drop.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_DROP_B], 0, FS_OP_SET, global_metrics->device.endpoint_drop.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_VXLAN_DROP_PKT], 0, FS_OP_SET, global_metrics->device.endpoint_vxlan_drop.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_VXLAN_DROP_B], 0, FS_OP_SET, global_metrics->device.endpoint_vxlan_drop.n_bytes);
// raw_pkt_metrics
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_RAW_PKT_MIRR_BYPASS_PKT], 0, FS_OP_SET, global_metrics->raw_pkt.mirr_bypass.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_RAW_PKT_MIRR_BYPASS_B], 0, FS_OP_SET, global_metrics->raw_pkt.mirr_bypass.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_VLAN_RX_PKT], 0, FS_OP_SET, global_metrics->device.endpoint_vlan_rx.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_VLAN_RX_B], 0, FS_OP_SET, global_metrics->device.endpoint_vlan_rx.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_RAW_PKT_MIRR_BLOCK_PKT], 0, FS_OP_SET, global_metrics->raw_pkt.mirr_block.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_RAW_PKT_MIRR_BLOCK_B], 0, FS_OP_SET, global_metrics->raw_pkt.mirr_block.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_VLAN_TX_PKT], 0, FS_OP_SET, global_metrics->device.endpoint_vlan_tx.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_VLAN_TX_B], 0, FS_OP_SET, global_metrics->device.endpoint_vlan_tx.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_RAW_PKT_MIRR_RX_DROP_PKT], 0, FS_OP_SET, global_metrics->raw_pkt.mirr_rx_drop.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_RAW_PKT_MIRR_RX_DROP_B], 0, FS_OP_SET, global_metrics->raw_pkt.mirr_rx_drop.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_VLAN_DROP_PKT], 0, FS_OP_SET, global_metrics->device.endpoint_vlan_drop.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_VLAN_DROP_B], 0, FS_OP_SET, global_metrics->device.endpoint_vlan_drop.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_RAW_PKT_MIRR_TX_PKT], 0, FS_OP_SET, global_metrics->raw_pkt.mirr_tx.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_RAW_PKT_MIRR_TX_B], 0, FS_OP_SET, global_metrics->raw_pkt.mirr_tx.n_bytes);
// data_pkt_metrics
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_MIRR_BYPASS_PKT], 0, FS_OP_SET, global_metrics->data_pkt.mirr_bypass.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_MIRR_BYPASS_B], 0, FS_OP_SET, global_metrics->data_pkt.mirr_bypass.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_RAW_PKT_STEE_BYPASS_PKT], 0, FS_OP_SET, global_metrics->raw_pkt.stee_bypass.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_RAW_PKT_STEE_BYPASS_B], 0, FS_OP_SET, global_metrics->raw_pkt.stee_bypass.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_MIRR_BLOCK_PKT], 0, FS_OP_SET, global_metrics->data_pkt.mirr_block.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_MIRR_BLOCK_B], 0, FS_OP_SET, global_metrics->data_pkt.mirr_block.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_RAW_PKT_STEE_BLOCK_PKT], 0, FS_OP_SET, global_metrics->raw_pkt.stee_block.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_RAW_PKT_STEE_BLOCK_B], 0, FS_OP_SET, global_metrics->raw_pkt.stee_block.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_MIRR_RX_DROP_PKT], 0, FS_OP_SET, global_metrics->data_pkt.mirr_rx_drop.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_MIRR_RX_DROP_B], 0, FS_OP_SET, global_metrics->data_pkt.mirr_rx_drop.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_RAW_PKT_STEE_RX_PKT], 0, FS_OP_SET, global_metrics->raw_pkt.stee_rx.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_RAW_PKT_STEE_RX_B], 0, FS_OP_SET, global_metrics->raw_pkt.stee_rx.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_MIRR_TX_PKT], 0, FS_OP_SET, global_metrics->data_pkt.mirr_tx.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_MIRR_TX_B], 0, FS_OP_SET, global_metrics->data_pkt.mirr_tx.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_RAW_PKT_STEE_TX_PKT], 0, FS_OP_SET, global_metrics->raw_pkt.stee_tx.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_RAW_PKT_STEE_TX_B], 0, FS_OP_SET, global_metrics->raw_pkt.stee_tx.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_STEE_BYPASS_PKT], 0, FS_OP_SET, global_metrics->data_pkt.stee_bypass.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_STEE_BYPASS_B], 0, FS_OP_SET, global_metrics->data_pkt.stee_bypass.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_RAW_PKT_MISS_SESS_PKT], 0, FS_OP_SET, global_metrics->raw_pkt.miss_sess.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_RAW_PKT_MISS_SESS_B], 0, FS_OP_SET, global_metrics->raw_pkt.miss_sess.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_STEE_BLOCK_PKT], 0, FS_OP_SET, global_metrics->data_pkt.stee_block.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_STEE_BLOCK_B], 0, FS_OP_SET, global_metrics->data_pkt.stee_block.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_RAW_PKT_ERROR_BYPASS_PKT], 0, FS_OP_SET, global_metrics->raw_pkt.error_bypass.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_RAW_PKT_ERROR_BYPASS_B], 0, FS_OP_SET, global_metrics->raw_pkt.error_bypass.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_STEE_RX_PKT], 0, FS_OP_SET, global_metrics->data_pkt.stee_rx.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_STEE_RX_B], 0, FS_OP_SET, global_metrics->data_pkt.stee_rx.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_RAW_PKT_ERROR_BLOCK_PKT], 0, FS_OP_SET, global_metrics->raw_pkt.error_block.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_RAW_PKT_ERROR_BLOCK_B], 0, FS_OP_SET, global_metrics->raw_pkt.error_block.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_STEE_TX_PKT], 0, FS_OP_SET, global_metrics->data_pkt.stee_tx.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_STEE_TX_B], 0, FS_OP_SET, global_metrics->data_pkt.stee_tx.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_MISS_SESS_PKT], 0, FS_OP_SET, global_metrics->data_pkt.miss_sess.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_MISS_SESS_B], 0, FS_OP_SET, global_metrics->data_pkt.miss_sess.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_ERROR_BYPASS_PKT], 0, FS_OP_SET, global_metrics->data_pkt.error_bypass.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_ERROR_BYPASS_B], 0, FS_OP_SET, global_metrics->data_pkt.error_bypass.n_bytes);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_ERROR_BLOCK_PKT], 0, FS_OP_SET, global_metrics->data_pkt.error_block.n_pkts);
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_ERROR_BLOCK_B], 0, FS_OP_SET, global_metrics->data_pkt.error_block.n_bytes);
// ctrl_pkt_metrics
FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_CTRL_PKT_RX_PKT], 0, FS_OP_SET, global_metrics->ctrl_pkt.rx.n_pkts);

10
platform/src/main.cpp
View File

@@ -72,8 +72,7 @@ static void *worker_thread_cycle(void *arg)
int thread_index = thread_ctx->thread_index;
int timeout_ms = 0;
int n_pkt_recv_from_nf = 0;
int n_pkt_recv_from_endp = 0;
int n_packet_recved = 0;
char thread_name[16];
uint64_t sf_metrics_last_send_ts = timestamp_get_msec(ts);
uint64_t sf_metrics_send_interval = sf_metrics_get_interval(sf_metrics) * 1000;
@@ -91,9 +90,10 @@ static void *worker_thread_cycle(void *arg)
while (!ATOMIC_READ(&is_need_stop))
{
n_pkt_recv_from_nf = packet_io_thread_polling_nf(handle, thread_ctx);
n_pkt_recv_from_endp = packet_io_thread_polling_endpoint(handle, thread_ctx);
if (n_pkt_recv_from_nf == 0 && n_pkt_recv_from_endp == 0)
n_packet_recved = packet_io_thread_polling_nf(handle, thread_ctx);
n_packet_recved += packet_io_thread_polling_endpoint_l3(handle, thread_ctx);
n_packet_recved += packet_io_thread_polling_endpoint_l2(handle, thread_ctx);
if (n_packet_recved == 0)
{
timeout_ms = sf_metrics_last_send_ts + sf_metrics_send_interval - timestamp_get_msec(ts);
if (timeout_ms <= 0)

476
platform/src/packet_io.cpp
View File

@@ -14,7 +14,7 @@
#include "g_vxlan.h"
#include "packet_io.h"
#include "sf_metrics.h"
#include "ctrl_packet.h"
#include "control_packet.h"
#include "global_metrics.h"
#define RX_BURST_MAX 128
@@ -30,13 +30,20 @@ struct config
int rx_burst_max;
int min_timeout_ms;
char app_symbol[256];
char dev_endpoint[256];
char dev_nf_interface[256];
char dev_endpoint_src_ip_str[16];
char dev_endpoint_src_mac_str[32];
in_addr_t dev_endpoint_src_ip;
u_char dev_endpoint_src_mac[ETH_ALEN];
// dev_nf
char dev_nf_name[256];
// dev_endpoint_l3
char dev_endpoint_l3_name[256];
char dev_endpoint_l3_ip_str[16];
char dev_endpoint_l3_mac_str[32];
in_addr_t dev_endpoint_l3_ip;
u_char dev_endpoint_l3_mac[ETH_ALEN];
// dev_endpoint_l2
char dev_endpoint_l2_name[256];
int vlan_encapsulate_replace_orig_vlan_header;
};
struct device
@@ -49,8 +56,9 @@ struct packet_io
{
int thread_num;
struct mr_instance *instance;
struct device dev_nf_interface;
struct device dev_endpoint;
struct device dev_nf;
struct device dev_endpoint_l3;
struct device dev_endpoint_l2;
struct config config;
};
@@ -337,19 +345,18 @@ static int is_uplink_keepalive_packet(marsio_buff_t *rx_buff)
// return !NULL
// return NULL
static struct session_ctx *raw_packet_search_session(struct session_table *table, const char *raw_data, int raw_len, uint64_t session_id)
static struct session_ctx *data_packet_search_session(struct session_table *table, const char *raw_data, int raw_len, uint64_t session_id)
{
struct addr_tuple4 inner_addr;
struct addr_tuple4 reverse_addr;
struct raw_pkt_parser raw_parser;
struct data_packet data_pkt;
memset(&inner_addr, 0, sizeof(struct addr_tuple4));
memset(&reverse_addr, 0, sizeof(struct addr_tuple4));
raw_packet_parser_init(&raw_parser, 0, LAYER_TYPE_ALL, 8);
raw_packet_parser_parse(&raw_parser, (const void *)raw_data, raw_len);
data_packet_parse(&data_pkt, (const void *)raw_data, raw_len, 0);
raw_packet_parser_get_most_inner_tuple4(&raw_parser, &inner_addr);
data_packet_get_innermost_tuple4(&data_pkt, &inner_addr);
addr_tuple4_reverse(&inner_addr, &reverse_addr);
struct session_node *node = session_table_search_by_id(table, session_id);
@@ -375,14 +382,13 @@ static struct session_ctx *raw_packet_search_session(struct session_table *table
static struct session_ctx *inject_packet_search_session(struct session_table *table, const char *raw_data, int raw_len)
{
struct addr_tuple4 inner_addr;
struct raw_pkt_parser raw_parser;
struct data_packet data_pkt;
memset(&inner_addr, 0, sizeof(struct addr_tuple4));
raw_packet_parser_init(&raw_parser, 0, LAYER_TYPE_ALL, 8);
raw_packet_parser_parse(&raw_parser, (const void *)raw_data, raw_len);
data_packet_parse(&data_pkt, (const void *)raw_data, raw_len, 0);
raw_packet_parser_get_most_inner_tuple4(&raw_parser, &inner_addr);
data_packet_get_innermost_tuple4(&data_pkt, &inner_addr);
struct session_node *node = session_table_search_by_addr(table, &inner_addr);
if (node == NULL)
@@ -400,13 +406,12 @@ static struct session_ctx *inject_packet_search_session(struct session_table *ta
* action bypass/block/forward
******************************************************************************/
static void vxlan_encapsulate(char *buffer,
static void vxlan_encapsulate(marsio_buff_t *mbuff,
const u_char src_mac[], const u_char dst_mac[],
const in_addr_t src_ip, const in_addr_t dst_ip,
int payload_len, int is_e2i, int is_decrypted, int sf_index,
uint64_t session_id, uint16_t ipid)
const in_addr_t src_ip, const in_addr_t dst_ip, uint16_t ipid,
uint16_t src_port, int payload_len, int is_e2i, int is_decrypted, int sf_index)
{
struct ethhdr *eth_hdr = (struct ethhdr *)buffer;
struct ethhdr *eth_hdr = (struct ethhdr *)marsio_buff_prepend(mbuff, sizeof(struct ethhdr) + sizeof(struct ip) + sizeof(struct udp_hdr) + sizeof(struct g_vxlan));
struct ip *ip_hdr = (struct ip *)((char *)eth_hdr + sizeof(struct ethhdr));
struct udp_hdr *udp_hdr = (struct udp_hdr *)((char *)ip_hdr + sizeof(struct ip));
struct g_vxlan *g_vxlan_hdr = (struct g_vxlan *)((char *)udp_hdr + sizeof(struct udp_hdr));
@@ -418,42 +423,121 @@ static void vxlan_encapsulate(char *buffer,
build_ether_header(eth_hdr, ETH_P_IP, src_mac, dst_mac);
build_ip_header(ip_hdr, IPPROTO_UDP, ipid, src_ip, dst_ip, sizeof(struct udp_hdr) + sizeof(struct g_vxlan) + payload_len);
build_udp_header((const char *)&ip_hdr->ip_src, 8, udp_hdr, session_id % (65535 - 49152) + 49152, 4789, sizeof(struct g_vxlan) + payload_len);
build_udp_header((const char *)&ip_hdr->ip_src, 8, udp_hdr, src_port, 4789, sizeof(struct g_vxlan) + payload_len);
}
static int send_packet_to_sf(marsio_buff_t *rx_buff, struct metadata *meta, struct selected_sf *sf, struct thread_ctx *thread_ctx)
struct vlan_hdr
{
uint16_t vlan_cfi;
uint16_t protocol;
} __attribute__((__packed__));
static void build_vlan_header(struct vlan_hdr *vlan_hdr, uint16_t vlan_id, uint16_t protocol)
{
vlan_hdr->vlan_cfi = 0;
vlan_hdr->vlan_cfi = htons(vlan_id & 0xFFF);
vlan_hdr->protocol = htons(protocol);
}
static void overwrite_vlan_id(struct vlan_hdr *vlan_hdr, uint16_t vlan_id)
{
vlan_hdr->vlan_cfi = 0;
vlan_hdr->vlan_cfi = htons(vlan_id & 0xFFF);
}
void vlan_encapsulate(marsio_buff_t *mbuff, int vlan_id, int replace_orig_vlan_header)
{
if (replace_orig_vlan_header == 0)
{
append:
struct ethhdr *eth_hdr = (struct ethhdr *)marsio_buff_prepend(mbuff, sizeof(struct vlan_hdr));
struct vlan_hdr *vlan_hdr = (struct vlan_hdr *)((char *)eth_hdr + sizeof(struct ethhdr));
memmove(eth_hdr, (char *)eth_hdr + sizeof(struct vlan_hdr), sizeof(struct ethhdr));
build_vlan_header(vlan_hdr, vlan_id, ntohs(eth_hdr->h_proto));
eth_hdr->h_proto = htons(ETH_P_8021Q);
return;
}
else
{
struct ethhdr *eth_hdr = (struct ethhdr *)marsio_buff_mtod(mbuff);
int next_proto = eth_hdr->h_proto;
char *start_layer = (char *)eth_hdr + sizeof(struct ethhdr);
char *next_layer = start_layer;
while (next_proto == htons(ETH_P_8021Q) || next_proto == htons(ETH_P_8021AD))
{
struct vlan_hdr *vlan_hdr = (struct vlan_hdr *)next_layer;
next_proto = vlan_hdr->protocol;
next_layer += sizeof(struct vlan_hdr);
}
// No vlan header found
uint64_t offset = next_layer - start_layer;
if (offset == 0)
{
goto append;
}
// Find a layer of vlan header
if (offset == sizeof(struct vlan_hdr))
{
struct vlan_hdr *vlan_hdr = (struct vlan_hdr *)start_layer;
overwrite_vlan_id(vlan_hdr, vlan_id);
return;
}
// Find the multi-layer vlan header
if (offset > sizeof(struct vlan_hdr))
{
struct vlan_hdr *vlan_hdr = (struct vlan_hdr *)(next_layer - sizeof(struct vlan_hdr));
struct ethhdr *new_eth_hdr = (struct ethhdr *)((char *)vlan_hdr - sizeof(struct ethhdr));
overwrite_vlan_id(vlan_hdr, vlan_id);
memmove(new_eth_hdr, (char *)eth_hdr, sizeof(struct ethhdr));
new_eth_hdr->h_proto = htons(ETH_P_8021Q);
marsio_buff_adj(mbuff, offset - sizeof(struct vlan_hdr));
return;
}
assert(0);
}
}
static int send_packet_to_sf(marsio_buff_t *mbuff, struct metadata *meta, struct selected_sf *sf, struct thread_ctx *thread_ctx)
{
thread_ctx->tx_packets_to_sf++;
int nsend = 0;
struct packet_io *packet_io = thread_ctx->ref_io;
int thread_index = thread_ctx->thread_index;
struct thread_metrics *thread_metrics = &thread_ctx->thread_metrics;
int payload_len = meta->raw_len;
int is_e2i = meta->is_e2i_dir;
int is_decrypted = meta->is_decrypted;
int sf_index = sf->sf_index;
int prepend_len = 0;
char *buffer = NULL;
marsio_buff_ctrlzone_reset(rx_buff);
marsio_buff_ctrlzone_reset(mbuff);
switch (sf->sf_connectivity.method)
{
case PACKAGE_METHOD_VXLAN_G:
prepend_len = sizeof(struct ethhdr) + sizeof(struct ip) + sizeof(struct udp_hdr) + sizeof(struct g_vxlan);
buffer = marsio_buff_prepend(rx_buff, prepend_len);
vxlan_encapsulate(buffer, packet_io->config.dev_endpoint_src_mac, sf->sf_dst_mac, packet_io->config.dev_endpoint_src_ip, sf->sf_dst_ip, payload_len, is_e2i, is_decrypted, sf_index, meta->session_id, thread_ctx->tx_packets_to_sf % 65535);
case ENCAPSULATE_METHOD_VXLAN_G:
vxlan_encapsulate(mbuff, packet_io->config.dev_endpoint_l3_mac, sf->sf_dst_mac,
packet_io->config.dev_endpoint_l3_ip, sf->sf_dst_ip, thread_ctx->tx_packets_to_sf % 65535,
meta->session_id % (65535 - 49152) + 49152, meta->raw_len, meta->is_e2i_dir, meta->is_decrypted, sf->sf_index);
nsend = marsio_buff_datalen(mbuff);
marsio_send_burst_with_options(packet_io->dev_endpoint_l3.mr_path, thread_ctx->thread_index, &mbuff, 1, MARSIO_SEND_OPT_REHASH);
throughput_metrics_inc(&(thread_metrics->device.endpoint_vxlan_tx), 1, nsend);
break;
case PACKAGE_METHOD_LAYER2_SWITCH:
// TODO
case ENCAPSULATE_METHOD_LAYER2_SWITCH:
vlan_encapsulate(mbuff,
meta->is_e2i_dir ? sf->sf_connectivity.ext_vlan_tag : sf->sf_connectivity.int_vlan_tag,
packet_io->config.vlan_encapsulate_replace_orig_vlan_header);
nsend = marsio_buff_datalen(mbuff);
marsio_send_burst_with_options(packet_io->dev_endpoint_l2.mr_path, thread_ctx->thread_index, &mbuff, 1, MARSIO_SEND_OPT_REHASH);
throughput_metrics_inc(&(thread_metrics->device.endpoint_vlan_tx), 1, nsend);
break;
case PACKAGE_METHOD_LAYER3_SWITCH:
case ENCAPSULATE_METHOD_LAYER3_SWITCH:
// TODO
break;
default:
break;
}
int nsend = marsio_buff_datalen(rx_buff);
marsio_send_burst_with_options(packet_io->dev_endpoint.mr_path, thread_index, &rx_buff, 1, MARSIO_SEND_OPT_REHASH);
return nsend;
}
@@ -466,7 +550,7 @@ static void action_err_bypass(marsio_buff_t *rx_buff, struct metadata *meta, str
int nsend = action_nf_inject(rx_buff, meta, sf, thread_ctx);
if (nsend > 0)
{
throughput_metrics_inc(&(thread_metrics->raw_pkt.error_bypass), 1, nsend);
throughput_metrics_inc(&(thread_metrics->data_pkt.error_bypass), 1, nsend);
}
}
@@ -477,7 +561,7 @@ static void action_err_block(marsio_buff_t *rx_buff, struct metadata *meta, stru
int thread_index = thread_ctx->thread_index;
int raw_len = marsio_buff_datalen(rx_buff);
throughput_metrics_inc(&(thread_metrics->raw_pkt.error_block), 1, raw_len);
throughput_metrics_inc(&(thread_metrics->data_pkt.error_block), 1, raw_len);
marsio_buff_free(packet_io->instance, &rx_buff, 1, 0, thread_index);
}
@@ -496,7 +580,7 @@ static int action_nf_inject(marsio_buff_t *rx_buff, struct metadata *meta, struc
}
int raw_len = marsio_buff_datalen(rx_buff);
marsio_send_burst(packet_io->dev_nf_interface.mr_path, thread_index, &rx_buff, 1);
marsio_send_burst(packet_io->dev_nf.mr_path, thread_index, &rx_buff, 1);
throughput_metrics_inc(&(thread_metrics->device.nf_tx), 1, raw_len);
return raw_len;
}
@@ -506,7 +590,7 @@ static void action_mirr_bypass(marsio_buff_t *rx_buff, struct metadata *meta, st
struct thread_metrics *thread_metrics = &thread_ctx->thread_metrics;
int raw_len = marsio_buff_datalen(rx_buff);
throughput_metrics_inc(&(thread_metrics->raw_pkt.mirr_bypass), 1, raw_len);
throughput_metrics_inc(&(thread_metrics->data_pkt.mirr_bypass), 1, raw_len);
}
static void action_mirr_block(marsio_buff_t *rx_buff, struct metadata *meta, struct selected_sf *sf, struct thread_ctx *thread_ctx)
@@ -514,7 +598,7 @@ static void action_mirr_block(marsio_buff_t *rx_buff, struct metadata *meta, str
struct thread_metrics *thread_metrics = &thread_ctx->thread_metrics;
int raw_len = marsio_buff_datalen(rx_buff);
throughput_metrics_inc(&(thread_metrics->raw_pkt.mirr_block), 1, raw_len);
throughput_metrics_inc(&(thread_metrics->data_pkt.mirr_block), 1, raw_len);
}
static void action_mirr_forward(marsio_buff_t *rx_buff, struct metadata *meta, struct selected_sf *sf, struct thread_ctx *thread_ctx)
@@ -537,8 +621,7 @@ static void action_mirr_forward(marsio_buff_t *rx_buff, struct metadata *meta, s
memcpy(copy_ptr, raw_data, raw_len);
int nsend = send_packet_to_sf(new_buff, meta, sf, thread_ctx);
throughput_metrics_inc(&(thread_metrics->device.endpoint_tx), 1, nsend);
throughput_metrics_inc(&(thread_metrics->raw_pkt.mirr_tx), 1, raw_len);
throughput_metrics_inc(&(thread_metrics->data_pkt.mirr_tx), 1, raw_len);
throughput_metrics_inc(&sf->tx, 1, nsend);
sf_metrics_inc(thread_ctx->sf_metrics, sf->rule_vsys_id, sf->rule_id, sf->sff_profile_id, sf->sf_profile_id, 0, 0, 1, nsend);
}
@@ -548,7 +631,7 @@ static void action_stee_bypass(marsio_buff_t *rx_buff, struct metadata *meta, st
struct thread_metrics *thread_metrics = &thread_ctx->thread_metrics;
int raw_len = marsio_buff_datalen(rx_buff);
throughput_metrics_inc(&(thread_metrics->raw_pkt.stee_bypass), 1, raw_len);
throughput_metrics_inc(&(thread_metrics->data_pkt.stee_bypass), 1, raw_len);
}
static void action_stee_block(marsio_buff_t *rx_buff, struct metadata *meta, struct selected_sf *sf, struct thread_ctx *thread_ctx)
@@ -558,7 +641,7 @@ static void action_stee_block(marsio_buff_t *rx_buff, struct metadata *meta, str
int thread_index = thread_ctx->thread_index;
int raw_len = marsio_buff_datalen(rx_buff);
throughput_metrics_inc(&(thread_metrics->raw_pkt.stee_block), 1, raw_len);
throughput_metrics_inc(&(thread_metrics->data_pkt.stee_block), 1, raw_len);
marsio_buff_free(packet_io->instance, &rx_buff, 1, 0, thread_index);
}
@@ -568,8 +651,7 @@ static void action_stee_forward(marsio_buff_t *rx_buff, struct metadata *meta, s
int raw_len = marsio_buff_datalen(rx_buff);
int nsend = send_packet_to_sf(rx_buff, meta, sf, thread_ctx);
throughput_metrics_inc(&(thread_metrics->device.endpoint_tx), 1, nsend);
throughput_metrics_inc(&(thread_metrics->raw_pkt.stee_tx), 1, raw_len);
throughput_metrics_inc(&(thread_metrics->data_pkt.stee_tx), 1, raw_len);
throughput_metrics_inc(&sf->tx, 1, nsend);
sf_metrics_inc(thread_ctx->sf_metrics, sf->rule_vsys_id, sf->rule_id, sf->sff_profile_id, sf->sf_profile_id, 0, 0, 1, nsend);
}
@@ -617,7 +699,7 @@ static void action_sf_chaining(struct thread_ctx *thread_ctx, struct session_ctx
}
case SESSION_ACTION_FORWARD:
if (sf->sf_connectivity.method != PACKAGE_METHOD_VXLAN_G)
if (sf->sf_connectivity.method != ENCAPSULATE_METHOD_VXLAN_G && sf->sf_connectivity.method != ENCAPSULATE_METHOD_LAYER2_SWITCH)
{
LOG_ERROR("%s: processing packets, session %lu %s requires encapsulation format not supported, bypass !!!",
LOG_TAG_PKTIO, session_ctx->session_id, session_ctx->session_addr);
@@ -723,23 +805,23 @@ static int send_ctrl_packet(struct session_ctx *session_ctx, struct selected_cha
LOG_INFO("%s: session %lu %s send event log %ld bytes", LOG_TAG_METRICS, session_ctx->session_id, session_ctx->session_addr, size);
marsio_buff_t *tx_buffs[1];
char *raw_packet_header_data = session_ctx->ctrl_meta->raw_data;
int raw_packet_header_len = session_ctx->ctrl_meta->l7offset;
char *packet_header_data = session_ctx->ctrl_meta->raw_data;
int packet_header_len = session_ctx->ctrl_meta->l7offset;
marsio_buff_malloc_global(packet_io->instance, tx_buffs, 1, 0, thread_index);
char *dst = marsio_buff_append(tx_buffs[0], raw_packet_header_len + size);
memcpy(dst, raw_packet_header_data, raw_packet_header_len);
memcpy(dst + raw_packet_header_len, data, size);
char *dst = marsio_buff_append(tx_buffs[0], packet_header_len + size);
memcpy(dst, packet_header_data, packet_header_len);
memcpy(dst + packet_header_len, data, size);
struct metadata meta = {0};
meta.session_id = session_ctx->session_id;
meta.l7offset = raw_packet_header_len;
meta.l7offset = packet_header_len;
meta.is_ctrl_pkt = 1;
meta.sids.num = 1;
meta.sids.elems[0] = sce_ctx->firewall_sids;
route_ctx_copy(&meta.route_ctx, &session_ctx->ctrl_meta->route_ctx);
mbuff_set_metadata(tx_buffs[0], &meta);
int nsend = marsio_buff_datalen(tx_buffs[0]);
marsio_send_burst(packet_io->dev_nf_interface.mr_path, thread_index, tx_buffs, 1);
marsio_send_burst(packet_io->dev_nf.mr_path, thread_index, tx_buffs, 1);
free(data);
return nsend;
@@ -797,28 +879,28 @@ static void session_value_free_cb(void *ctx)
session_ctx_free(s_ctx);
}
static void handle_policy_mutil_hits(struct policy_enforcer *enforcer, struct session_ctx *session_ctx, struct ctrl_pkt_parser *ctrl_parser, raw_pkt_parser *raw_parser, int is_e2i_dir)
static void handle_policy_mutil_hits(struct policy_enforcer *enforcer, struct session_ctx *session_ctx, struct control_packet *ctrl_pkt, data_packet *data_pkt, int is_e2i_dir)
{
for (int i = 0; i < ctrl_parser->rule_id_num; i++)
for (int i = 0; i < ctrl_pkt->rule_id_num; i++)
{
uint64_t rule_id = ctrl_parser->rule_ids[i];
if (fixed_num_array_exist_elem(&session_ctx->rule_ids, rule_id))
uint64_t rule_id = ctrl_pkt->rule_ids[i];
if (mutable_array_exist_elem(&session_ctx->rule_ids, rule_id))
{
continue;
}
else
{
policy_enforce_select_chainings(enforcer, &session_ctx->chainings, session_ctx, raw_parser, rule_id, is_e2i_dir);
policy_enforce_select_chainings(enforcer, &session_ctx->chainings, session_ctx, data_pkt, rule_id, is_e2i_dir);
selected_chaining_bref(session_ctx->chainings.chaining_raw);
selected_chaining_bref(session_ctx->chainings.chaining_decrypted);
fixed_num_array_add_elem(&session_ctx->rule_ids, rule_id);
mutable_array_add_elem(&session_ctx->rule_ids, rule_id);
}
}
}
static void handle_session_opening(struct metadata *meta, struct ctrl_pkt_parser *ctrl_parser, struct thread_ctx *thread_ctx)
static void handle_session_opening(struct metadata *meta, struct control_packet *ctrl_pkt, struct thread_ctx *thread_ctx)
{
struct thread_metrics *thread_metrics = &thread_ctx->thread_metrics;
struct policy_enforcer *enforcer = thread_ctx->ref_enforcer;
@@ -832,11 +914,10 @@ static void handle_session_opening(struct metadata *meta, struct ctrl_pkt_parser
}
#endif
struct raw_pkt_parser raw_parser;
struct data_packet data_pkt;
struct addr_tuple4 inner_tuple4;
raw_packet_parser_init(&raw_parser, meta->session_id, LAYER_TYPE_ALL, 8);
const void *payload = raw_packet_parser_parse(&raw_parser, (const void *)meta->raw_data, meta->raw_len);
raw_packet_parser_get_most_inner_tuple4(&raw_parser, &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);
uint16_t real_offset = (char *)payload - meta->raw_data;
if (real_offset != meta->l7offset)
{
@@ -855,14 +936,14 @@ static void handle_session_opening(struct metadata *meta, struct ctrl_pkt_parser
session_ctx->ref_thread_ctx = thread_ctx;
LOG_INFO("%s: session %lu %s active first", LOG_TAG_PKTIO, session_ctx->session_id, session_ctx->session_addr);
handle_policy_mutil_hits(enforcer, session_ctx, ctrl_parser, &raw_parser, meta->is_e2i_dir);
handle_policy_mutil_hits(enforcer, session_ctx, ctrl_pkt, &data_pkt, meta->is_e2i_dir);
send_event_log(session_ctx, thread_ctx);
session_table_insert(session_table, session_ctx->session_id, &session_ctx->inner_tuple4, session_ctx, session_value_free_cb);
ATOMIC_INC(&(thread_metrics->sf_session.num));
}
static void handle_session_closing(struct metadata *meta, struct ctrl_pkt_parser *ctrl_parser, struct thread_ctx *thread_ctx)
static void handle_session_closing(struct metadata *meta, struct control_packet *ctrl_pkt, struct thread_ctx *thread_ctx)
{
struct thread_metrics *thread_metrics = &thread_ctx->thread_metrics;
struct session_table *session_table = thread_ctx->session_table;
@@ -884,7 +965,7 @@ static void handle_session_closing(struct metadata *meta, struct ctrl_pkt_parser
}
}
static void handle_session_active(struct metadata *meta, struct ctrl_pkt_parser *ctrl_parser, struct thread_ctx *thread_ctx)
static void handle_session_active(struct metadata *meta, struct control_packet *ctrl_pkt, struct thread_ctx *thread_ctx)
{
struct session_table *session_table = thread_ctx->session_table;
struct policy_enforcer *enforcer = thread_ctx->ref_enforcer;
@@ -894,9 +975,8 @@ static void handle_session_active(struct metadata *meta, struct ctrl_pkt_parser
{
struct session_ctx *session_ctx = (struct session_ctx *)node->value;
struct raw_pkt_parser raw_parser;
raw_packet_parser_init(&raw_parser, meta->session_id, LAYER_TYPE_ALL, 8);
const void *payload = raw_packet_parser_parse(&raw_parser, (const void *)meta->raw_data, meta->raw_len);
struct data_packet data_pkt;
const void *payload = data_packet_parse(&data_pkt, (const void *)meta->raw_data, meta->raw_len, meta->session_id);
uint16_t real_offset = (char *)payload - meta->raw_data;
if (real_offset != meta->l7offset)
{
@@ -904,16 +984,16 @@ static void handle_session_active(struct metadata *meta, struct ctrl_pkt_parser
}
LOG_INFO("%s: session %lu %s active again", LOG_TAG_PKTIO, session_ctx->session_id, session_ctx->session_addr);
handle_policy_mutil_hits(enforcer, session_ctx, ctrl_parser, &raw_parser, meta->is_e2i_dir);
handle_policy_mutil_hits(enforcer, session_ctx, ctrl_pkt, &data_pkt, meta->is_e2i_dir);
send_event_log(session_ctx, thread_ctx);
}
else
{
handle_session_opening(meta, ctrl_parser, thread_ctx);
handle_session_opening(meta, ctrl_pkt, thread_ctx);
}
}
static void handle_session_resetall(struct metadata *meta, struct ctrl_pkt_parser *ctrl_parser, struct thread_ctx *thread_ctx)
static void handle_session_resetall(struct metadata *meta, struct control_packet *ctrl_pkt, struct thread_ctx *thread_ctx)
{
struct thread_metrics *thread_metrics = &thread_ctx->thread_metrics;
struct sce_ctx *sce_ctx = thread_ctx->ref_sce_ctx;
@@ -935,7 +1015,7 @@ static void handle_control_packet(marsio_buff_t *rx_buff, struct thread_ctx *thr
{
struct thread_metrics *thread_metrics = &thread_ctx->thread_metrics;
struct metadata meta;
struct ctrl_pkt_parser ctrl_parser;
struct control_packet ctrl_pkt;
if (mbuff_get_metadata(rx_buff, &meta) == -1)
{
@@ -943,37 +1023,36 @@ static void handle_control_packet(marsio_buff_t *rx_buff, struct thread_ctx *thr
goto error_ctrl_pkt;
}
ctrl_packet_parser_init(&ctrl_parser);
if (ctrl_packet_parser_parse(&ctrl_parser, meta.raw_data + meta.l7offset, meta.raw_len - meta.l7offset) == -1)
if (control_packet_parse(&ctrl_pkt, meta.raw_data + meta.l7offset, meta.raw_len - meta.l7offset) == -1)
{
LOG_ERROR("%s: unexpected control packet, unable to parse data", LOG_TAG_PKTIO);
goto error_ctrl_pkt;
}
if (ctrl_parser.session_id != meta.session_id)
if (ctrl_pkt.session_id != meta.session_id)
{
LOG_ERROR("%s: unexpected control packet, metadata's session %lu != control packet's session %lu", LOG_TAG_PKTIO, meta.session_id, ctrl_parser.session_id);
LOG_ERROR("%s: unexpected control packet, metadata's session %lu != control packet's session %lu", LOG_TAG_PKTIO, meta.session_id, ctrl_pkt.session_id);
goto error_ctrl_pkt;
}
switch (ctrl_parser.state)
switch (ctrl_pkt.state)
{
case SESSION_STATE_OPENING:
ATOMIC_INC(&(thread_metrics->ctrl_pkt.opening));
// when session opening, firewall not send policy id
// return handle_session_opening(&meta, &ctrl_parser, ctx);
// return handle_session_opening(&meta, &ctrl_pkt, ctx);
break;
case SESSION_STATE_CLOSING:
ATOMIC_INC(&(thread_metrics->ctrl_pkt.closing));
handle_session_closing(&meta, &ctrl_parser, thread_ctx);
handle_session_closing(&meta, &ctrl_pkt, thread_ctx);
break;
case SESSION_STATE_ACTIVE:
ATOMIC_INC(&(thread_metrics->ctrl_pkt.active));
handle_session_active(&meta, &ctrl_parser, thread_ctx);
handle_session_active(&meta, &ctrl_pkt, thread_ctx);
break;
case SESSION_STATE_RESETALL:
ATOMIC_INC(&(thread_metrics->ctrl_pkt.resetall));
handle_session_resetall(&meta, &ctrl_parser, thread_ctx);
handle_session_resetall(&meta, &ctrl_pkt, thread_ctx);
break;
default:
goto error_ctrl_pkt;
@@ -985,7 +1064,7 @@ error_ctrl_pkt:
return;
}
static void handle_raw_packet(marsio_buff_t *rx_buff, struct thread_ctx *thread_ctx)
static void handle_data_packet(marsio_buff_t *rx_buff, struct thread_ctx *thread_ctx)
{
struct session_table *session_table = thread_ctx->session_table;
struct thread_metrics *thread_metrics = &thread_ctx->thread_metrics;
@@ -1016,10 +1095,10 @@ static void handle_raw_packet(marsio_buff_t *rx_buff, struct thread_ctx *thread_
goto error_bypass;
}
session_ctx = raw_packet_search_session(session_table, meta.raw_data, meta.raw_len, meta.session_id);
session_ctx = data_packet_search_session(session_table, meta.raw_data, meta.raw_len, meta.session_id);
if (session_ctx == NULL)
{
throughput_metrics_inc(&(thread_metrics->raw_pkt.miss_sess), 1, meta.raw_len);
throughput_metrics_inc(&(thread_metrics->data_pkt.miss_sess), 1, meta.raw_len);
goto error_bypass;
}
@@ -1046,7 +1125,7 @@ error_bypass:
action_err_bypass(rx_buff, &meta, NULL, thread_ctx);
}
static void handle_inject_packet(marsio_buff_t *rx_buff, struct thread_ctx *thread_ctx)
static void handle_inject_vxlan_packet(marsio_buff_t *rx_buff, struct thread_ctx *thread_ctx)
{
struct session_table *session_table = thread_ctx->session_table;
struct thread_metrics *thread_metrics = &thread_ctx->thread_metrics;
@@ -1062,7 +1141,7 @@ static void handle_inject_packet(marsio_buff_t *rx_buff, struct thread_ctx *thre
char *raw_data = marsio_buff_mtod(rx_buff);
if (g_vxlan_decode(&g_vxlan_hdr, raw_data, raw_len) == -1)
{
throughput_metrics_inc(&(thread_metrics->device.endpoint_drop), 1, raw_len);
throughput_metrics_inc(&(thread_metrics->device.endpoint_vxlan_drop), 1, raw_len);
action_err_block(rx_buff, &meta, NULL, thread_ctx);
return;
}
@@ -1103,14 +1182,14 @@ static void handle_inject_packet(marsio_buff_t *rx_buff, struct thread_ctx *thre
{
LOG_DEBUG("%s: unexpected inject packet, session %lu %s with sf_profile_id %d executes mirror and does not require reflow, drop !!!",
LOG_TAG_PKTIO, session_ctx->session_id, session_ctx->session_addr, chaining->chaining[sf_index].sf_profile_id);
throughput_metrics_inc(&(thread_metrics->raw_pkt.mirr_rx_drop), 1, meta.raw_len);
throughput_metrics_inc(&(thread_metrics->data_pkt.mirr_rx_drop), 1, meta.raw_len);
goto error_block;
}
else
{
struct selected_sf *sf = &(chaining->chaining[sf_index]);
throughput_metrics_inc(&sf->rx, 1, raw_len);
throughput_metrics_inc(&(thread_metrics->raw_pkt.stee_rx), 1, meta.raw_len);
throughput_metrics_inc(&(thread_metrics->data_pkt.stee_rx), 1, meta.raw_len);
sf_metrics_inc(thread_ctx->sf_metrics, sf->rule_vsys_id, sf->rule_id, sf->sff_profile_id, sf->sf_profile_id, 1, raw_len, 0, 0);
}
@@ -1119,7 +1198,7 @@ static void handle_inject_packet(marsio_buff_t *rx_buff, struct thread_ctx *thre
return;
error_block:
throughput_metrics_inc(&(thread_metrics->device.endpoint_drop), 1, raw_len);
throughput_metrics_inc(&(thread_metrics->device.endpoint_vxlan_drop), 1, raw_len);
marsio_buff_adj(rx_buff, raw_len - meta.raw_len);
action_err_block(rx_buff, &meta, NULL, thread_ctx);
}
@@ -1140,11 +1219,15 @@ static int packet_io_config(const char *profile, struct config *config)
MESA_load_profile_int_def(profile, "PACKET_IO", "rx_burst_max", (int *)&(config->rx_burst_max), 1);
MESA_load_profile_int_def(profile, "PACKET_IO", "min_timeout_ms", (int *)&(config->min_timeout_ms), 900);
MESA_load_profile_string_nodef(profile, "PACKET_IO", "app_symbol", config->app_symbol, sizeof(config->app_symbol));
MESA_load_profile_string_nodef(profile, "PACKET_IO", "dev_endpoint", config->dev_endpoint, sizeof(config->dev_endpoint));
MESA_load_profile_string_nodef(profile, "PACKET_IO", "dev_nf_interface", config->dev_nf_interface, sizeof(config->dev_nf_interface));
MESA_load_profile_string_nodef(profile, "PACKET_IO", "dev_endpoint_src_ip", config->dev_endpoint_src_ip_str, sizeof(config->dev_endpoint_src_ip_str));
MESA_load_profile_string_nodef(profile, "PACKET_IO", "dev_endpoint_src_mac", config->dev_endpoint_src_mac_str, sizeof(config->dev_endpoint_src_mac_str));
MESA_load_profile_string_nodef(profile, "PACKET_IO", "dev_nf_name", config->dev_nf_name, sizeof(config->dev_nf_name));
MESA_load_profile_string_nodef(profile, "PACKET_IO", "dev_endpoint_l3_name", config->dev_endpoint_l3_name, sizeof(config->dev_endpoint_l3_name));
MESA_load_profile_string_nodef(profile, "PACKET_IO", "dev_endpoint_l3_ip", config->dev_endpoint_l3_ip_str, sizeof(config->dev_endpoint_l3_ip_str));
MESA_load_profile_string_nodef(profile, "PACKET_IO", "dev_endpoint_l3_mac", config->dev_endpoint_l3_mac_str, sizeof(config->dev_endpoint_l3_mac_str));
MESA_load_profile_string_nodef(profile, "PACKET_IO", "dev_endpoint_l2_name", config->dev_endpoint_l2_name, sizeof(config->dev_endpoint_l2_name));
MESA_load_profile_int_def(profile, "PACKET_IO", "vlan_encapsulate_replace_orig_vlan_header", (int *)&(config->vlan_encapsulate_replace_orig_vlan_header), 0);
if (config->rx_burst_max > RX_BURST_MAX)
{
@@ -1158,15 +1241,21 @@ static int packet_io_config(const char *profile, struct config *config)
return -1;
}
if (strlen(config->dev_endpoint) == 0)
if (strlen(config->dev_nf_name) == 0)
{
LOG_ERROR("%s: invalid dev_endpoint in %s", LOG_TAG_PKTIO, profile);
LOG_ERROR("%s: invalid dev_nf_name in %s", LOG_TAG_PKTIO, profile);
return -1;
}
if (strlen(config->dev_nf_interface) == 0)
if (strlen(config->dev_endpoint_l3_name) == 0)
{
LOG_ERROR("%s: invalid dev_nf_interface in %s", LOG_TAG_PKTIO, profile);
LOG_ERROR("%s: invalid dev_endpoint_l3_name in %s", LOG_TAG_PKTIO, profile);
return -1;
}
if (strlen(config->dev_endpoint_l2_name) == 0)
{
LOG_ERROR("%s: invalid dev_endpoint_l2_name in %s", LOG_TAG_PKTIO, profile);
return -1;
}
@@ -1174,12 +1263,15 @@ static int packet_io_config(const char *profile, struct config *config)
LOG_DEBUG("%s: PACKET_IO->rx_burst_max : %d", LOG_TAG_PKTIO, config->rx_burst_max);
LOG_DEBUG("%s: PACKET_IO->min_timeout_ms : %d", LOG_TAG_PKTIO, config->min_timeout_ms);
LOG_DEBUG("%s: PACKET_IO->app_symbol : %s", LOG_TAG_PKTIO, config->app_symbol);
LOG_DEBUG("%s: PACKET_IO->dev_endpoint : %s", LOG_TAG_PKTIO, config->dev_endpoint);
LOG_DEBUG("%s: PACKET_IO->dev_nf_interface : %s", LOG_TAG_PKTIO, config->dev_nf_interface);
LOG_DEBUG("%s: PACKET_IO->dev_endpoint_src_ip : %s", LOG_TAG_PKTIO, config->dev_endpoint_src_ip_str);
if (strlen(config->dev_endpoint_src_mac_str))
LOG_DEBUG("%s: PACKET_IO->dev_nf_name : %s", LOG_TAG_PKTIO, config->dev_nf_name);
LOG_DEBUG("%s: PACKET_IO->dev_endpoint_l3_name : %s", LOG_TAG_PKTIO, config->dev_endpoint_l3_name);
LOG_DEBUG("%s: PACKET_IO->dev_endpoint_l3_ip : %s", LOG_TAG_PKTIO, config->dev_endpoint_l3_ip_str);
LOG_DEBUG("%s: PACKET_IO->dev_endpoint_l2_name : %s", LOG_TAG_PKTIO, config->dev_endpoint_l2_name);
LOG_DEBUG("%s: PACKET_IO->vlan_encapsulate_replace_orig_vlan_header : %d", LOG_TAG_PKTIO, config->vlan_encapsulate_replace_orig_vlan_header);
if (strlen(config->dev_endpoint_l3_mac_str))
{
LOG_DEBUG("%s: PACKET_IO->dev_endpoint_src_mac : %s (get from configuration file)", LOG_TAG_PKTIO, config->dev_endpoint_src_mac_str);
LOG_DEBUG("%s: PACKET_IO->dev_endpoint_l3_mac : %s (get from configuration file)", LOG_TAG_PKTIO, config->dev_endpoint_l3_mac_str);
}
return 0;
@@ -1222,41 +1314,55 @@ struct packet_io *packet_io_create(const char *profile, int thread_num, cpu_set_
goto error_out;
}
handle->dev_nf_interface.mr_dev = marsio_open_device(handle->instance, handle->config.dev_nf_interface, handle->thread_num, handle->thread_num);
if (handle->dev_nf_interface.mr_dev == NULL)
handle->dev_nf.mr_dev = marsio_open_device(handle->instance, handle->config.dev_nf_name, handle->thread_num, handle->thread_num);
if (handle->dev_nf.mr_dev == NULL)
{
LOG_ERROR("%s: unable to open device %s", LOG_TAG_PKTIO, handle->config.dev_nf_interface);
LOG_ERROR("%s: unable to open device %s", LOG_TAG_PKTIO, handle->config.dev_nf_name);
goto error_out;
}
handle->dev_nf_interface.mr_path = marsio_sendpath_create_by_vdev(handle->dev_nf_interface.mr_dev);
if (handle->dev_nf_interface.mr_path == NULL)
handle->dev_nf.mr_path = marsio_sendpath_create_by_vdev(handle->dev_nf.mr_dev);
if (handle->dev_nf.mr_path == NULL)
{
LOG_ERROR("%s: unable to create sendpath for device %s", LOG_TAG_PKTIO, handle->config.dev_nf_interface);
LOG_ERROR("%s: unable to create sendpath for device %s", LOG_TAG_PKTIO, handle->config.dev_nf_name);
goto error_out;
}
handle->dev_endpoint.mr_dev = marsio_open_device(handle->instance, handle->config.dev_endpoint, handle->thread_num, handle->thread_num);
if (handle->dev_endpoint.mr_dev == NULL)
handle->dev_endpoint_l3.mr_dev = marsio_open_device(handle->instance, handle->config.dev_endpoint_l3_name, handle->thread_num, handle->thread_num);
if (handle->dev_endpoint_l3.mr_dev == NULL)
{
LOG_ERROR("%s: unable to open device %s", LOG_TAG_PKTIO, handle->config.dev_endpoint);
LOG_ERROR("%s: unable to open device %s", LOG_TAG_PKTIO, handle->config.dev_endpoint_l3_name);
goto error_out;
}
handle->dev_endpoint.mr_path = marsio_sendpath_create_by_vdev(handle->dev_endpoint.mr_dev);
if (handle->dev_endpoint.mr_path == NULL)
handle->dev_endpoint_l3.mr_path = marsio_sendpath_create_by_vdev(handle->dev_endpoint_l3.mr_dev);
if (handle->dev_endpoint_l3.mr_path == NULL)
{
LOG_ERROR("%s: unable to create sendpath for device %s", LOG_TAG_PKTIO, handle->config.dev_endpoint);
LOG_ERROR("%s: unable to create sendpath for device %s", LOG_TAG_PKTIO, handle->config.dev_endpoint_l3_name);
goto error_out;
}
if (strlen(handle->config.dev_endpoint_src_mac_str) == 0)
handle->dev_endpoint_l2.mr_dev = marsio_open_device(handle->instance, handle->config.dev_endpoint_l2_name, handle->thread_num, handle->thread_num);
if (handle->dev_endpoint_l2.mr_dev == NULL)
{
marsio_get_device_ether_addr(handle->dev_endpoint.mr_dev, handle->config.dev_endpoint_src_mac_str, sizeof(handle->config.dev_endpoint_src_mac_str));
LOG_DEBUG("%s: PACKET_IO->dev_endpoint_src_mac : %s (get from marsio api)", LOG_TAG_PKTIO, handle->config.dev_endpoint_src_mac_str);
LOG_ERROR("%s: unable to open device %s", LOG_TAG_PKTIO, handle->config.dev_endpoint_l2_name);
goto error_out;
}
str_to_mac(handle->config.dev_endpoint_src_mac_str, handle->config.dev_endpoint_src_mac);
handle->config.dev_endpoint_src_ip = inet_addr(handle->config.dev_endpoint_src_ip_str);
handle->dev_endpoint_l2.mr_path = marsio_sendpath_create_by_vdev(handle->dev_endpoint_l2.mr_dev);
if (handle->dev_endpoint_l2.mr_path == NULL)
{
LOG_ERROR("%s: unable to create sendpath for device %s", LOG_TAG_PKTIO, handle->config.dev_endpoint_l2_name);
goto error_out;
}
if (strlen(handle->config.dev_endpoint_l3_mac_str) == 0)
{
marsio_get_device_ether_addr(handle->dev_endpoint_l3.mr_dev, handle->config.dev_endpoint_l3_mac_str, sizeof(handle->config.dev_endpoint_l3_mac_str));
LOG_DEBUG("%s: PACKET_IO->dev_endpoint_l3_mac : %s (get from marsio api)", LOG_TAG_PKTIO, handle->config.dev_endpoint_l3_mac_str);
}
str_to_mac(handle->config.dev_endpoint_l3_mac_str, handle->config.dev_endpoint_l3_mac);
handle->config.dev_endpoint_l3_ip = inet_addr(handle->config.dev_endpoint_l3_ip_str);
return handle;
@@ -1269,28 +1375,40 @@ void packet_io_destory(struct packet_io *handle)
{
if (handle)
{
if (handle->dev_nf_interface.mr_path)
if (handle->dev_nf.mr_path)
{
marsio_sendpath_destory(handle->dev_nf_interface.mr_path);
handle->dev_nf_interface.mr_path = NULL;
marsio_sendpath_destory(handle->dev_nf.mr_path);
handle->dev_nf.mr_path = NULL;
}
if (handle->dev_nf_interface.mr_dev)
if (handle->dev_nf.mr_dev)
{
marsio_close_device(handle->dev_nf_interface.mr_dev);
handle->dev_nf_interface.mr_dev = NULL;
marsio_close_device(handle->dev_nf.mr_dev);
handle->dev_nf.mr_dev = NULL;
}
if (handle->dev_endpoint.mr_path)
if (handle->dev_endpoint_l3.mr_path)
{
marsio_sendpath_destory(handle->dev_endpoint.mr_path);
handle->dev_endpoint.mr_path = NULL;
marsio_sendpath_destory(handle->dev_endpoint_l3.mr_path);
handle->dev_endpoint_l3.mr_path = NULL;
}
if (handle->dev_endpoint.mr_dev)
if (handle->dev_endpoint_l3.mr_dev)
{
marsio_close_device(handle->dev_endpoint.mr_dev);
handle->dev_endpoint.mr_dev = NULL;
marsio_close_device(handle->dev_endpoint_l3.mr_dev);
handle->dev_endpoint_l3.mr_dev = NULL;
}
if (handle->dev_endpoint_l2.mr_path)
{
marsio_sendpath_destory(handle->dev_endpoint_l2.mr_path);
handle->dev_endpoint_l2.mr_path = NULL;
}
if (handle->dev_endpoint_l2.mr_dev)
{
marsio_close_device(handle->dev_endpoint_l2.mr_dev);
handle->dev_endpoint_l2.mr_dev = NULL;
}
if (handle->instance)
@@ -1318,13 +1436,15 @@ int packet_io_thread_init(struct packet_io *handle, struct thread_ctx *thread_ct
void packet_io_thread_wait(struct packet_io *handle, struct thread_ctx *thread_ctx, int timeout_ms)
{
static __thread struct mr_vdev *vdevs[] = {
handle->dev_nf_interface.mr_dev,
handle->dev_endpoint.mr_dev};
handle->dev_nf.mr_dev,
handle->dev_endpoint_l3.mr_dev,
handle->dev_endpoint_l2.mr_dev,
};
int min_timeout_ms = MIN(handle->config.min_timeout_ms, timeout_ms);
if (min_timeout_ms > 0)
{
marsio_poll_wait(handle->instance, vdevs, 2, thread_ctx->thread_index, min_timeout_ms);
marsio_poll_wait(handle->instance, vdevs, 3, thread_ctx->thread_index, min_timeout_ms);
}
else
{
@@ -1338,7 +1458,7 @@ int packet_io_thread_polling_nf(struct packet_io *handle, struct thread_ctx *thr
int thread_index = thread_ctx->thread_index;
static __thread marsio_buff_t *rx_buffs[RX_BURST_MAX];
int nr_recv = marsio_recv_burst(handle->dev_nf_interface.mr_dev, thread_index, rx_buffs, handle->config.rx_burst_max);
int nr_recv = marsio_recv_burst(handle->dev_nf.mr_dev, thread_index, rx_buffs, handle->config.rx_burst_max);
if (nr_recv <= 0)
{
return 0;
@@ -1354,7 +1474,7 @@ int packet_io_thread_polling_nf(struct packet_io *handle, struct thread_ctx *thr
throughput_metrics_inc(&(thread_metrics->device.nf_tx), 1, raw_len);
}
marsio_send_burst(handle->dev_nf_interface.mr_path, thread_index, rx_buffs, nr_recv);
marsio_send_burst(handle->dev_nf.mr_path, thread_index, rx_buffs, nr_recv);
return nr_recv;
}
@@ -1371,7 +1491,7 @@ int packet_io_thread_polling_nf(struct packet_io *handle, struct thread_ctx *thr
throughput_metrics_inc(&(thread_metrics->kee_pkt.downlink_rx), 1, raw_len);
throughput_metrics_inc(&(thread_metrics->kee_pkt.downlink_tx), 1, raw_len);
marsio_send_burst(handle->dev_nf_interface.mr_path, thread_index, &rx_buff, 1);
marsio_send_burst(handle->dev_nf.mr_path, thread_index, &rx_buff, 1);
}
else if (marsio_buff_is_ctrlbuf(rx_buff))
{
@@ -1382,26 +1502,26 @@ int packet_io_thread_polling_nf(struct packet_io *handle, struct thread_ctx *thr
throughput_metrics_inc(&(thread_metrics->ctrl_pkt.tx), 1, raw_len);
handle_control_packet(rx_buff, thread_ctx);
marsio_send_burst(handle->dev_nf_interface.mr_path, thread_index, &rx_buff, 1);
marsio_send_burst(handle->dev_nf.mr_path, thread_index, &rx_buff, 1);
}
else
{
throughput_metrics_inc(&(thread_metrics->device.nf_rx), 1, raw_len);
handle_raw_packet(rx_buff, thread_ctx);
handle_data_packet(rx_buff, thread_ctx);
}
}
return nr_recv;
}
int packet_io_thread_polling_endpoint(struct packet_io *handle, struct thread_ctx *thread_ctx)
int packet_io_thread_polling_endpoint_l3(struct packet_io *handle, struct thread_ctx *thread_ctx)
{
struct thread_metrics *thread_metrics = &thread_ctx->thread_metrics;
int thread_index = thread_ctx->thread_index;
static __thread marsio_buff_t *rx_buffs[RX_BURST_MAX];
int nr_recv = marsio_recv_burst(handle->dev_endpoint.mr_dev, thread_index, rx_buffs, handle->config.rx_burst_max);
int nr_recv = marsio_recv_burst(handle->dev_endpoint_l3.mr_dev, thread_index, rx_buffs, handle->config.rx_burst_max);
if (nr_recv <= 0)
{
return 0;
@@ -1413,11 +1533,11 @@ int packet_io_thread_polling_endpoint(struct packet_io *handle, struct thread_ct
{
int raw_len = marsio_buff_datalen(rx_buffs[j]);
throughput_metrics_inc(&(thread_metrics->device.endpoint_rx), 1, raw_len);
throughput_metrics_inc(&(thread_metrics->device.endpoint_tx), 1, raw_len);
throughput_metrics_inc(&(thread_metrics->device.endpoint_vxlan_rx), 1, raw_len);
throughput_metrics_inc(&(thread_metrics->device.endpoint_vxlan_tx), 1, raw_len);
}
marsio_send_burst(handle->dev_endpoint.mr_path, thread_index, rx_buffs, nr_recv);
marsio_send_burst(handle->dev_endpoint_l3.mr_path, thread_index, rx_buffs, nr_recv);
return nr_recv;
}
@@ -1428,7 +1548,7 @@ int packet_io_thread_polling_endpoint(struct packet_io *handle, struct thread_ct
if (is_uplink_keepalive_packet(rx_buff))
{
throughput_metrics_inc(&(thread_metrics->device.endpoint_rx), 1, raw_len);
throughput_metrics_inc(&(thread_metrics->device.endpoint_vxlan_rx), 1, raw_len);
throughput_metrics_inc(&(thread_metrics->kee_pkt.uplink_rx), 1, raw_len);
throughput_metrics_inc(&(thread_metrics->kee_pkt.uplink_tx_drop), 1, raw_len);
@@ -1436,15 +1556,55 @@ int packet_io_thread_polling_endpoint(struct packet_io *handle, struct thread_ct
}
else
{
throughput_metrics_inc(&(thread_metrics->device.endpoint_rx), 1, raw_len);
throughput_metrics_inc(&(thread_metrics->device.endpoint_vxlan_rx), 1, raw_len);
handle_inject_packet(rx_buff, thread_ctx);
handle_inject_vxlan_packet(rx_buff, thread_ctx);
}
}
return nr_recv;
}
int packet_io_thread_polling_endpoint_l2(struct packet_io *handle, struct thread_ctx *thread_ctx)
{
struct thread_metrics *thread_metrics = &thread_ctx->thread_metrics;
int thread_index = thread_ctx->thread_index;
static __thread marsio_buff_t *rx_buffs[RX_BURST_MAX];
int nr_recv = marsio_recv_burst(handle->dev_endpoint_l2.mr_dev, thread_index, rx_buffs, handle->config.rx_burst_max);
if (nr_recv <= 0)
{
return 0;
}
if (handle->config.bypass_traffic == 1)
{
for (int j = 0; j < nr_recv; j++)
{
int raw_len = marsio_buff_datalen(rx_buffs[j]);
throughput_metrics_inc(&(thread_metrics->device.endpoint_vlan_rx), 1, raw_len);
throughput_metrics_inc(&(thread_metrics->device.endpoint_vlan_tx), 1, raw_len);
}
marsio_send_burst(handle->dev_endpoint_l2.mr_path, thread_index, rx_buffs, nr_recv);
return nr_recv;
}
for (int j = 0; j < nr_recv; j++)
{
marsio_buff_t *rx_buff = rx_buffs[j];
int raw_len = marsio_buff_datalen(rx_buffs[j]);
throughput_metrics_inc(&(thread_metrics->device.endpoint_vlan_rx), 1, raw_len);
throughput_metrics_inc(&(thread_metrics->device.endpoint_vlan_drop), 1, raw_len);
marsio_buff_free(handle->instance, &rx_buff, 1, 0, thread_index);
}
return nr_recv;
}
struct mr_instance *packet_io_get_mr_instance(struct packet_io *handle)
{
if (handle)

84
platform/src/policy.cpp
View File

@@ -7,7 +7,7 @@
#include "global_metrics.h"
#include "health_check.h"
#include "raw_packet.h"
#include "data_packet.h"
#include "policy.h"
#include "utils.h"
#include "log.h"
@@ -800,24 +800,24 @@ static void sf_param_new_cb(const char *table_name, int table_id, const char *ke
}
if (0 == strcasecmp(item->valuestring, "layer2_switch"))
{
param->sf_connectivity.method = PACKAGE_METHOD_LAYER2_SWITCH;
param->sf_connectivity.method = ENCAPSULATE_METHOD_LAYER2_SWITCH;
}
else if (0 == strcasecmp(item->valuestring, "layer3_switch"))
{
param->sf_connectivity.method = PACKAGE_METHOD_LAYER3_SWITCH;
param->sf_connectivity.method = ENCAPSULATE_METHOD_LAYER3_SWITCH;
}
else if (0 == strcasecmp(item->valuestring, "vxlan_g"))
{
param->sf_connectivity.method = PACKAGE_METHOD_VXLAN_G;
param->sf_connectivity.method = ENCAPSULATE_METHOD_VXLAN_G;
}
else
{
LOG_ERROR("%s: unexpected sf profile: (invalid connectivity->method param) %s", LOG_TAG_POLICY, table_line);
goto error_out;
}
LOG_DEBUG("%s: parse sf profile: %d, connectivity->method: %s", LOG_TAG_POLICY, param->sf_profile_id, package_method_to_string(param->sf_connectivity.method));
LOG_DEBUG("%s: parse sf profile: %d, connectivity->method: %s", LOG_TAG_POLICY, param->sf_profile_id, encapsulate_method_to_string(param->sf_connectivity.method));
if (param->sf_connectivity.method == PACKAGE_METHOD_LAYER2_SWITCH || param->sf_connectivity.method == PACKAGE_METHOD_LAYER3_SWITCH)
if (param->sf_connectivity.method == ENCAPSULATE_METHOD_LAYER2_SWITCH || param->sf_connectivity.method == ENCAPSULATE_METHOD_LAYER3_SWITCH)
{
item = cJSON_GetObjectItem(root1, "int_vlan_tag");
if (!item || !cJSON_IsNumber(item))
@@ -837,7 +837,7 @@ static void sf_param_new_cb(const char *table_name, int table_id, const char *ke
param->sf_connectivity.ext_vlan_tag = item->valueint;
LOG_DEBUG("%s: parse sf profile: %d, connectivity->ext_vlan_tag: %d", LOG_TAG_POLICY, param->sf_profile_id, item->valueint);
}
else if (param->sf_connectivity.method == PACKAGE_METHOD_VXLAN_G)
else if (param->sf_connectivity.method == ENCAPSULATE_METHOD_VXLAN_G)
{
item = cJSON_GetObjectItem(root1, "dest_ip");
if (!item || !cJSON_IsString(item))
@@ -885,8 +885,8 @@ static void sf_param_new_cb(const char *table_name, int table_id, const char *ke
}
LOG_DEBUG("%s: parse sf profile: %d, health_check->method: %s", LOG_TAG_POLICY, param->sf_profile_id, item->valuestring);
if ((param->sf_health_check.method == HEALTH_CHECK_METHOD_BFD && param->sf_connectivity.method == PACKAGE_METHOD_VXLAN_G) ||
(param->sf_health_check.method == HEALTH_CHECK_METHOD_NONE && param->sf_connectivity.method == PACKAGE_METHOD_VXLAN_G))
if ((param->sf_health_check.method == HEALTH_CHECK_METHOD_BFD && param->sf_connectivity.method == ENCAPSULATE_METHOD_VXLAN_G) ||
(param->sf_health_check.method == HEALTH_CHECK_METHOD_NONE && param->sf_connectivity.method == ENCAPSULATE_METHOD_VXLAN_G))
{
memcpy(param->sf_health_check.address, param->sf_connectivity.dest_ip, strlen(param->sf_connectivity.dest_ip));
}
@@ -923,7 +923,10 @@ static void sf_param_new_cb(const char *table_name, int table_id, const char *ke
param->sf_health_check.retires = item->valueint;
LOG_DEBUG("%s: parse sf profile: %d, health_check->retires: %d", LOG_TAG_POLICY, param->sf_profile_id, item->valueint);
}
if (param->sf_connectivity.method != ENCAPSULATE_METHOD_LAYER2_SWITCH)
{
param->health_check_session_id = health_check_session_add(param->sf_profile_id, param->sf_vsys_id, &param->sf_health_check);
}
*ad = param;
LOG_INFO("%s: Add sf profile: %d", LOG_TAG_POLICY, param->sf_profile_id);
@@ -968,8 +971,11 @@ static void sf_param_free_cb(int table_id, void **ad, long argl, void *argp)
}
if ((__sync_sub_and_fetch(&param->sf_ref_cnt, 1) == 0))
{
if (param->sf_connectivity.method != ENCAPSULATE_METHOD_LAYER2_SWITCH)
{
health_check_session_del(param->health_check_session_id, param->sf_profile_id);
}
LOG_INFO("%s: Del sf profile: %d", LOG_TAG_POLICY, param->sf_profile_id);
free(param);
param = NULL;
@@ -998,7 +1004,7 @@ static void sf_param_free(struct sf_param *param)
}
// After return must check array elem nums
static void select_sf_by_nearby_and_adminstatus(struct policy_enforcer *enforcer, struct sff_param *sff_param, struct fixed_num_array *array)
static void select_sf_by_nearby_and_adminstatus(struct policy_enforcer *enforcer, struct sff_param *sff_param, struct mutable_array *array)
{
char buffer[16];
struct sf_param *sf = NULL;
@@ -1022,7 +1028,7 @@ static void select_sf_by_nearby_and_adminstatus(struct policy_enforcer *enforcer
{
if (sf->sf_admin_status == ADMMIN_STATUS_ACTIVE)
{
fixed_num_array_add_elem(array, sff_param->sf_profile_ids[i]);
mutable_array_add_elem(array, sff_param->sf_profile_ids[i]);
}
}
}
@@ -1032,7 +1038,7 @@ static void select_sf_by_nearby_and_adminstatus(struct policy_enforcer *enforcer
{
if (sf->sf_admin_status == ADMMIN_STATUS_ACTIVE)
{
fixed_num_array_add_elem(array, sff_param->sf_profile_ids[i]);
mutable_array_add_elem(array, sff_param->sf_profile_ids[i]);
}
}
}
@@ -1041,7 +1047,7 @@ static void select_sf_by_nearby_and_adminstatus(struct policy_enforcer *enforcer
{
if (sf->sf_admin_status == ADMMIN_STATUS_ACTIVE)
{
fixed_num_array_add_elem(array, sff_param->sf_profile_ids[i]);
mutable_array_add_elem(array, sff_param->sf_profile_ids[i]);
}
}
sf_param_free(sf);
@@ -1051,7 +1057,7 @@ static void select_sf_by_nearby_and_adminstatus(struct policy_enforcer *enforcer
// return : SESSION_ACTION_BYPASS, not care selected_sf_profile_id
// return : SESSION_ACTION_BLOCK, not care selected_sf_profile_id
// return : SESSION_ACTION_FORWARD, care selected_sf_profile_id
static enum session_action select_sf_by_ldbc(struct policy_enforcer *enforcer, struct session_ctx *s_ctx, struct sff_param *sff_param, struct selected_sf *sf, struct fixed_num_array *array, uint64_t hash)
static enum session_action select_sf_by_ldbc(struct policy_enforcer *enforcer, struct session_ctx *s_ctx, struct sff_param *sff_param, struct selected_sf *sf, struct mutable_array *array, uint64_t hash)
{
struct thread_ctx *thread = (struct thread_ctx *)s_ctx->ref_thread_ctx;
struct thread_metrics *thread_metrics = &thread->thread_metrics;
@@ -1063,13 +1069,14 @@ static enum session_action select_sf_by_ldbc(struct policy_enforcer *enforcer, s
int sf_profile_index = 0;
int sf_profile_num = 0;
uint64_t health_check_session_id = 0;
enum encapsulate_method encap_method;
sf_profile_num = fixed_num_array_count_elem(array);
sf_profile_num = mutable_array_count_elem(array);
while (sf_profile_num)
{
sf_profile_index = (int)(hash % sf_profile_num);
sf_profile_id = fixed_num_array_index_elem(array, sf_profile_index);
sf_profile_id = mutable_array_index_elem(array, sf_profile_index);
memset(&buffer, 0, sizeof(buffer));
snprintf(buffer, sizeof(buffer), "%u", sf_profile_id);
@@ -1077,13 +1084,26 @@ static enum session_action select_sf_by_ldbc(struct policy_enforcer *enforcer, s
if (sf_param == NULL)
{
LOG_ERROR("%s: failed to get sf parameter of profile %d", LOG_TAG_POLICY, sf_profile_id);
fixed_num_array_del_elem(array, sf_profile_id);
mutable_array_del_elem(array, sf_profile_id);
continue;
}
health_check_session_id = sf_param->health_check_session_id;
encap_method = sf_param->sf_connectivity.method;
sf_param_free(sf_param);
memset(sf->sf_dst_mac, 0, sizeof(sf->sf_dst_mac));
// VLAN encapsulation not require health check
if (encap_method == ENCAPSULATE_METHOD_LAYER2_SWITCH)
{
ATOMIC_INC(&(thread_metrics->sf_status.active));
sf->sf_profile_id = sf_profile_id;
sf->sf_action_reason = ACTION_FORWAED_DUE_SELECTED_SF;
return SESSION_ACTION_FORWARD;
}
// VXLAN encapsulation require health check
if (health_check_session_get_mac(health_check_session_id, sf->sf_dst_mac) == 0)
{
ATOMIC_INC(&(thread_metrics->sf_status.active));
@@ -1098,8 +1118,8 @@ static enum session_action select_sf_by_ldbc(struct policy_enforcer *enforcer, s
if (sff_param->sff_exception.fail_action == FAILURE_ACTION_RE_DISPATCH)
{
fixed_num_array_del_elem(array, sf_profile_id);
sf_profile_num = fixed_num_array_count_elem(array);
mutable_array_del_elem(array, sf_profile_id);
sf_profile_num = mutable_array_count_elem(array);
if (sff_param->sff_exception.health_service_func_lt > 0 && sf_profile_num < sff_param->sff_exception.health_service_func_lt)
{
@@ -1248,17 +1268,17 @@ const char *action_reason_to_string(enum action_reason action_reason)
}
}
const char *package_method_to_string(enum package_method package_method)
const char *encapsulate_method_to_string(enum encapsulate_method encap_method)
{
switch (package_method)
switch (encap_method)
{
case PACKAGE_METHOD_NONE:
case ENCAPSULATE_METHOD_NONE:
return "none";
case PACKAGE_METHOD_LAYER2_SWITCH:
case ENCAPSULATE_METHOD_LAYER2_SWITCH:
return "layer2_switch";
case PACKAGE_METHOD_LAYER3_SWITCH:
case ENCAPSULATE_METHOD_LAYER3_SWITCH:
return "layer3_switch";
case PACKAGE_METHOD_VXLAN_G:
case ENCAPSULATE_METHOD_VXLAN_G:
return "vxlan_g";
default:
return "unknown";
@@ -1325,7 +1345,7 @@ void selected_chaining_dump(struct selected_chaining *chaining)
LOG_DEBUG("%s: session %lu %s selected_chaining->node[%d]->sf_need_skip : %d", LOG_TAG_POLICY, chaining->session_id, chaining->session_addr, i, node->sf_need_skip);
LOG_DEBUG("%s: session %lu %s selected_chaining->node[%d]->sf_action : %s", LOG_TAG_POLICY, chaining->session_id, chaining->session_addr, i, session_action_to_string(node->sf_action));
LOG_DEBUG("%s: session %lu %s selected_chaining->node[%d]->sf_action_reason : %s", LOG_TAG_POLICY, chaining->session_id, chaining->session_addr, i, action_reason_to_string(node->sf_action_reason));
LOG_DEBUG("%s: session %lu %s selected_chaining->node[%d]->sf_connectivity->package_method : %s", LOG_TAG_POLICY, chaining->session_id, chaining->session_addr, i, package_method_to_string(node->sf_connectivity.method));
LOG_DEBUG("%s: session %lu %s selected_chaining->node[%d]->sf_connectivity->encapsulate_method : %s", LOG_TAG_POLICY, chaining->session_id, chaining->session_addr, i, encapsulate_method_to_string(node->sf_connectivity.method));
LOG_DEBUG("%s: session %lu %s selected_chaining->node[%d]->sf_connectivity->int_vlan_tag : %d", LOG_TAG_POLICY, chaining->session_id, chaining->session_addr, i, node->sf_connectivity.int_vlan_tag);
LOG_DEBUG("%s: session %lu %s selected_chaining->node[%d]->sf_connectivity->ext_vlan_tag : %d", LOG_TAG_POLICY, chaining->session_id, chaining->session_addr, i, node->sf_connectivity.ext_vlan_tag);
LOG_DEBUG("%s: session %lu %s selected_chaining->node[%d]->sf_connectivity->dest_ip : %s", LOG_TAG_POLICY, chaining->session_id, chaining->session_addr, i, node->sf_connectivity.dest_ip);
@@ -1585,13 +1605,13 @@ int policy_enforce_chaining_size(struct policy_enforcer *enforcer)
return enforcer->config.max_chaining_size;
}
void policy_enforce_select_chainings(struct policy_enforcer *enforcer, struct selected_chainings *chainings, struct session_ctx *s_ctx, struct raw_pkt_parser *parser, uint64_t rule_id, int dir_is_i2e)
void policy_enforce_select_chainings(struct policy_enforcer *enforcer, struct selected_chainings *chainings, struct session_ctx *s_ctx, struct data_packet *data_pkt, uint64_t rule_id, int dir_is_i2e)
{
uint64_t hash_value = 0;
char buffer[16] = {0};
struct sf_param *sf_param = NULL;
struct sff_param *sff_param = NULL;
struct fixed_num_array array = {0};
struct mutable_array array = {0};
struct chaining_param *chaining_param = NULL;
struct selected_chaining *chaining = NULL;
@@ -1638,10 +1658,10 @@ void policy_enforce_select_chainings(struct policy_enforcer *enforcer, struct se
item->sff_forward_type = sff_param->sff_forward_type;
memset(&array, 0, sizeof(array));
fixed_num_array_init(&array);
mutable_array_init(&array);
select_sf_by_nearby_and_adminstatus(enforcer, sff_param, &array);
LOG_DEBUG("%s: session %lu %s select sf from chaining rule %lu sff_profile %d, sf_profile_num (before filter: %d -> filter nearby/admin_status: %d)", LOG_TAG_POLICY, chaining->session_id, chaining->session_addr, rule_id, item->sff_profile_id, sff_param->sf_profile_ids_num, fixed_num_array_count_elem(&array));
if (fixed_num_array_count_elem(&array) == 0)
LOG_DEBUG("%s: session %lu %s select sf from chaining rule %lu sff_profile %d, sf_profile_num (before filter: %d -> filter nearby/admin_status: %d)", LOG_TAG_POLICY, chaining->session_id, chaining->session_addr, rule_id, item->sff_profile_id, sff_param->sf_profile_ids_num, mutable_array_count_elem(&array));
if (mutable_array_count_elem(&array) == 0)
{
switch (sff_param->sff_exception.fail_action)
{
@@ -1672,7 +1692,7 @@ void policy_enforce_select_chainings(struct policy_enforcer *enforcer, struct se
continue;
}
hash_value = raw_packet_parser_get_hash_value(parser, sff_param->sff_ldbc.method, dir_is_i2e);
hash_value = data_packet_get_hash(data_pkt, sff_param->sff_ldbc.method, dir_is_i2e);
item->sf_action = select_sf_by_ldbc(enforcer, s_ctx, sff_param, item, &array, hash_value);
if (item->sf_action != SESSION_ACTION_FORWARD)
{

2
platform/src/sce.cpp
View File

@@ -83,7 +83,7 @@ struct session_ctx *session_ctx_new()
struct session_ctx *session_ctx = (struct session_ctx *)calloc(1, sizeof(struct session_ctx));
assert(session_ctx != NULL);
fixed_num_array_init(&session_ctx->rule_ids);
mutable_array_init(&session_ctx->rule_ids);
session_ctx->decrypted_meta_i2e = metadata_new();
session_ctx->decrypted_meta_e2i = metadata_new();

8
platform/src/sf_metrics.cpp
View File

@@ -56,10 +56,10 @@ static void sf_metrics_parse_config(const char *profile, struct sf_metrics_confi
MESA_load_profile_int_def(profile, "METRICS", "telegraf_listen_port", &(config->telegraf_listen_port), 8300);
MESA_load_profile_string_def(profile, "METRICS", "telegraf_bind_address", config->telegraf_bind_address, sizeof(config->telegraf_bind_address), "127.0.0.1");
LOG_DEBUG("%s: METRICS->enable : %d", LOG_TAG_SF_METRICS, config->enable);
LOG_DEBUG("%s: METRICS->interval_s : %d", LOG_TAG_SF_METRICS, config->interval_s);
LOG_DEBUG("%s: METRICS->telegraf_listen_port : %d", LOG_TAG_SF_METRICS, config->telegraf_listen_port);
LOG_DEBUG("%s: METRICS->telegraf_bind_address : %s", LOG_TAG_SF_METRICS, config->telegraf_bind_address);
// LOG_DEBUG("%s: METRICS->enable : %d", LOG_TAG_SF_METRICS, config->enable);
// LOG_DEBUG("%s: METRICS->interval_s : %d", LOG_TAG_SF_METRICS, config->interval_s);
// LOG_DEBUG("%s: METRICS->telegraf_listen_port : %d", LOG_TAG_SF_METRICS, config->telegraf_listen_port);
// LOG_DEBUG("%s: METRICS->telegraf_bind_address : %s", LOG_TAG_SF_METRICS, config->telegraf_bind_address);
}
struct sf_metrics *sf_metrics_create(const char *profile)

7
platform/test/gtest_policy.cpp
View File

@@ -2,7 +2,7 @@
#include "sce.h"
#include "policy.h"
#include "raw_packet.h"
#include "data_packet.h"
#include "global_metrics.h"
unsigned char data1[] = {
@@ -35,10 +35,9 @@ TEST(POLICY, POLICY_ENFORCER_LIFE_CYCLE)
s_ctx.session_id = 1;
s_ctx.session_addr = (char *)"1.1.1.1 11 2.2.2.2 22";
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);

119
test/CMakeLists.txt
View File

@@ -40,85 +40,85 @@ target_include_directories(gtest_ctrl_pkt_active PUBLIC ${CMAKE_SOURCE_DIR}/plat
target_link_libraries(gtest_ctrl_pkt_active temp_platform gtest)
###############################################################################
# gtest_raw_pkt_stee_bypass
# gtest_data_pkt_stee_bypass
###############################################################################
add_executable(gtest_raw_pkt_stee_bypass gtest_raw_pkt_stee_bypass.cpp)
target_include_directories(gtest_raw_pkt_stee_bypass PUBLIC ${CMAKE_SOURCE_DIR}/common/include)
target_include_directories(gtest_raw_pkt_stee_bypass PUBLIC ${CMAKE_SOURCE_DIR}/platform/include)
target_link_libraries(gtest_raw_pkt_stee_bypass temp_platform gtest)
add_executable(gtest_data_pkt_stee_bypass gtest_data_pkt_stee_bypass.cpp)
target_include_directories(gtest_data_pkt_stee_bypass PUBLIC ${CMAKE_SOURCE_DIR}/common/include)
target_include_directories(gtest_data_pkt_stee_bypass PUBLIC ${CMAKE_SOURCE_DIR}/platform/include)
target_link_libraries(gtest_data_pkt_stee_bypass temp_platform gtest)
###############################################################################
# gtest_raw_pkt_stee_block
# gtest_data_pkt_stee_block
###############################################################################
add_executable(gtest_raw_pkt_stee_block gtest_raw_pkt_stee_block.cpp)
target_include_directories(gtest_raw_pkt_stee_block PUBLIC ${CMAKE_SOURCE_DIR}/common/include)
target_include_directories(gtest_raw_pkt_stee_block PUBLIC ${CMAKE_SOURCE_DIR}/platform/include)
target_link_libraries(gtest_raw_pkt_stee_block temp_platform gtest)
add_executable(gtest_data_pkt_stee_block gtest_data_pkt_stee_block.cpp)
target_include_directories(gtest_data_pkt_stee_block PUBLIC ${CMAKE_SOURCE_DIR}/common/include)
target_include_directories(gtest_data_pkt_stee_block PUBLIC ${CMAKE_SOURCE_DIR}/platform/include)
target_link_libraries(gtest_data_pkt_stee_block temp_platform gtest)
###############################################################################
# gtest_raw_pkt_stee_forward
# gtest_data_pkt_stee_forward
###############################################################################
add_executable(gtest_raw_pkt_stee_forward gtest_raw_pkt_stee_forward.cpp)
target_include_directories(gtest_raw_pkt_stee_forward PUBLIC ${CMAKE_SOURCE_DIR}/common/include)
target_include_directories(gtest_raw_pkt_stee_forward PUBLIC ${CMAKE_SOURCE_DIR}/platform/include)
target_link_libraries(gtest_raw_pkt_stee_forward temp_platform gtest)
add_executable(gtest_data_pkt_stee_forward gtest_data_pkt_stee_forward.cpp)
target_include_directories(gtest_data_pkt_stee_forward PUBLIC ${CMAKE_SOURCE_DIR}/common/include)
target_include_directories(gtest_data_pkt_stee_forward PUBLIC ${CMAKE_SOURCE_DIR}/platform/include)
target_link_libraries(gtest_data_pkt_stee_forward temp_platform gtest)
###############################################################################
# gtest_raw_pkt_stee_rx_egress
# gtest_data_pkt_stee_rx_egress
###############################################################################
add_executable(gtest_raw_pkt_stee_rx_egress gtest_raw_pkt_stee_rx_egress.cpp)
target_include_directories(gtest_raw_pkt_stee_rx_egress PUBLIC ${CMAKE_SOURCE_DIR}/common/include)
target_include_directories(gtest_raw_pkt_stee_rx_egress PUBLIC ${CMAKE_SOURCE_DIR}/platform/include)
target_link_libraries(gtest_raw_pkt_stee_rx_egress temp_platform gtest)
add_executable(gtest_data_pkt_stee_rx_egress gtest_data_pkt_stee_rx_egress.cpp)
target_include_directories(gtest_data_pkt_stee_rx_egress PUBLIC ${CMAKE_SOURCE_DIR}/common/include)
target_include_directories(gtest_data_pkt_stee_rx_egress PUBLIC ${CMAKE_SOURCE_DIR}/platform/include)
target_link_libraries(gtest_data_pkt_stee_rx_egress temp_platform gtest)
###############################################################################
# gtest_raw_pkt_mirr_bypass
# gtest_data_pkt_mirr_bypass
###############################################################################
add_executable(gtest_raw_pkt_mirr_bypass gtest_raw_pkt_mirr_bypass.cpp)
target_include_directories(gtest_raw_pkt_mirr_bypass PUBLIC ${CMAKE_SOURCE_DIR}/common/include)
target_include_directories(gtest_raw_pkt_mirr_bypass PUBLIC ${CMAKE_SOURCE_DIR}/platform/include)
target_link_libraries(gtest_raw_pkt_mirr_bypass temp_platform gtest)
add_executable(gtest_data_pkt_mirr_bypass gtest_data_pkt_mirr_bypass.cpp)
target_include_directories(gtest_data_pkt_mirr_bypass PUBLIC ${CMAKE_SOURCE_DIR}/common/include)
target_include_directories(gtest_data_pkt_mirr_bypass PUBLIC ${CMAKE_SOURCE_DIR}/platform/include)
target_link_libraries(gtest_data_pkt_mirr_bypass temp_platform gtest)
###############################################################################
# gtest_raw_pkt_mirr_block
# gtest_data_pkt_mirr_block
###############################################################################
add_executable(gtest_raw_pkt_mirr_block gtest_raw_pkt_mirr_block.cpp)
target_include_directories(gtest_raw_pkt_mirr_block PUBLIC ${CMAKE_SOURCE_DIR}/common/include)
target_include_directories(gtest_raw_pkt_mirr_block PUBLIC ${CMAKE_SOURCE_DIR}/platform/include)
target_link_libraries(gtest_raw_pkt_mirr_block temp_platform gtest)
add_executable(gtest_data_pkt_mirr_block gtest_data_pkt_mirr_block.cpp)
target_include_directories(gtest_data_pkt_mirr_block PUBLIC ${CMAKE_SOURCE_DIR}/common/include)
target_include_directories(gtest_data_pkt_mirr_block PUBLIC ${CMAKE_SOURCE_DIR}/platform/include)
target_link_libraries(gtest_data_pkt_mirr_block temp_platform gtest)
###############################################################################
# gtest_raw_pkt_mirr_forward
# gtest_data_pkt_mirr_forward
###############################################################################
add_executable(gtest_raw_pkt_mirr_forward gtest_raw_pkt_mirr_forward.cpp)
target_include_directories(gtest_raw_pkt_mirr_forward PUBLIC ${CMAKE_SOURCE_DIR}/common/include)
target_include_directories(gtest_raw_pkt_mirr_forward PUBLIC ${CMAKE_SOURCE_DIR}/platform/include)
target_link_libraries(gtest_raw_pkt_mirr_forward temp_platform gtest)
add_executable(gtest_data_pkt_mirr_forward gtest_data_pkt_mirr_forward.cpp)
target_include_directories(gtest_data_pkt_mirr_forward PUBLIC ${CMAKE_SOURCE_DIR}/common/include)
target_include_directories(gtest_data_pkt_mirr_forward PUBLIC ${CMAKE_SOURCE_DIR}/platform/include)
target_link_libraries(gtest_data_pkt_mirr_forward temp_platform gtest)
###############################################################################
# gtest_raw_pkt_mirr_rx_drop
# gtest_data_pkt_mirr_rx_drop
###############################################################################
add_executable(gtest_raw_pkt_mirr_rx_drop gtest_raw_pkt_mirr_rx_drop.cpp)
target_include_directories(gtest_raw_pkt_mirr_rx_drop PUBLIC ${CMAKE_SOURCE_DIR}/common/include)
target_include_directories(gtest_raw_pkt_mirr_rx_drop PUBLIC ${CMAKE_SOURCE_DIR}/platform/include)
target_link_libraries(gtest_raw_pkt_mirr_rx_drop temp_platform gtest)
add_executable(gtest_data_pkt_mirr_rx_drop gtest_data_pkt_mirr_rx_drop.cpp)
target_include_directories(gtest_data_pkt_mirr_rx_drop PUBLIC ${CMAKE_SOURCE_DIR}/common/include)
target_include_directories(gtest_data_pkt_mirr_rx_drop PUBLIC ${CMAKE_SOURCE_DIR}/platform/include)
target_link_libraries(gtest_data_pkt_mirr_rx_drop temp_platform gtest)
###############################################################################
# gtest_raw_pkt_error_bypass
# gtest_data_pkt_error_bypass
###############################################################################
add_executable(gtest_raw_pkt_error_bypass gtest_raw_pkt_error_bypass.cpp)
target_include_directories(gtest_raw_pkt_error_bypass PUBLIC ${CMAKE_SOURCE_DIR}/common/include)
target_include_directories(gtest_raw_pkt_error_bypass PUBLIC ${CMAKE_SOURCE_DIR}/platform/include)
target_link_libraries(gtest_raw_pkt_error_bypass temp_platform gtest)
add_executable(gtest_data_pkt_error_bypass gtest_data_pkt_error_bypass.cpp)
target_include_directories(gtest_data_pkt_error_bypass PUBLIC ${CMAKE_SOURCE_DIR}/common/include)
target_include_directories(gtest_data_pkt_error_bypass PUBLIC ${CMAKE_SOURCE_DIR}/platform/include)
target_link_libraries(gtest_data_pkt_error_bypass temp_platform gtest)
###############################################################################
# gtest_mix_pkt_stee_forward
@@ -129,6 +129,15 @@ target_include_directories(gtest_mix_pkt_stee_forward PUBLIC ${CMAKE_SOURCE_DIR}
target_include_directories(gtest_mix_pkt_stee_forward PUBLIC ${CMAKE_SOURCE_DIR}/platform/include)
target_link_libraries(gtest_mix_pkt_stee_forward temp_platform gtest)
###############################################################################
# gtest_vlan_encapsulate
###############################################################################
add_executable(gtest_vlan_encapsulate gtest_vlan_encapsulate.cpp)
target_include_directories(gtest_vlan_encapsulate PUBLIC ${CMAKE_SOURCE_DIR}/common/include)
target_include_directories(gtest_vlan_encapsulate PUBLIC ${CMAKE_SOURCE_DIR}/platform/include)
target_link_libraries(gtest_vlan_encapsulate temp_platform gtest)
###############################################################################
# gtest_discover_tests
###############################################################################
@@ -138,19 +147,21 @@ include(GoogleTest)
gtest_discover_tests(gtest_ctrl_pkt_opening)
gtest_discover_tests(gtest_ctrl_pkt_active)
gtest_discover_tests(gtest_raw_pkt_stee_bypass)
gtest_discover_tests(gtest_raw_pkt_stee_block)
gtest_discover_tests(gtest_raw_pkt_stee_forward)
gtest_discover_tests(gtest_raw_pkt_stee_rx_egress)
gtest_discover_tests(gtest_data_pkt_stee_bypass)
gtest_discover_tests(gtest_data_pkt_stee_block)
gtest_discover_tests(gtest_data_pkt_stee_forward)
gtest_discover_tests(gtest_data_pkt_stee_rx_egress)
gtest_discover_tests(gtest_raw_pkt_mirr_bypass)
gtest_discover_tests(gtest_raw_pkt_mirr_block)
gtest_discover_tests(gtest_raw_pkt_mirr_forward)
gtest_discover_tests(gtest_raw_pkt_mirr_rx_drop)
gtest_discover_tests(gtest_data_pkt_mirr_bypass)
gtest_discover_tests(gtest_data_pkt_mirr_block)
gtest_discover_tests(gtest_data_pkt_mirr_forward)
gtest_discover_tests(gtest_data_pkt_mirr_rx_drop)
gtest_discover_tests(gtest_raw_pkt_error_bypass)
gtest_discover_tests(gtest_data_pkt_error_bypass)
gtest_discover_tests(gtest_mix_pkt_stee_forward)
gtest_discover_tests(gtest_vlan_encapsulate)
file(COPY ./test_data/log/ DESTINATION ./log/)
file(COPY ./test_data/conf/ DESTINATION ./conf/)
file(COPY ./test_data/resource/ DESTINATION ./resource/)

8
test/gtest_raw_pkt_error_bypass.cpp → test/gtest_data_pkt_error_bypass.cpp
View File

@@ -1,7 +1,7 @@
#include "gtest_utils.h"
// 145 bytes
static u_char raw_pkt[] = {
static u_char data_pkt[] = {
0x48, 0x73, 0x97, 0x96, 0x38, 0x10, 0x0c, 0xa7, 0x5c, 0x64, 0x00, 0x01, 0x08, 0x00, 0x45, 0x00,
0x00, 0x83, 0x46, 0x1f, 0x40, 0x00, 0x40, 0x06, 0xd4, 0x92, 0xc0, 0xa8, 0x29, 0x40, 0x5d, 0xb8,
0xd8, 0x22, 0xce, 0xec, 0x00, 0x50, 0xf8, 0x77, 0x0d, 0xcf, 0x47, 0x34, 0x32, 0xb9, 0x80, 0x18,
@@ -13,16 +13,16 @@ static u_char raw_pkt[] = {
0x0d, 0x0a, 0x41, 0x63, 0x63, 0x65, 0x70, 0x74, 0x3a, 0x20, 0x2a, 0x2f, 0x2a, 0x0d, 0x0a, 0x0d,
0x0a};
TEST(PACKET_IO, RAW_PKT_ERROR_BYPASS)
TEST(PACKET_IO, DATA_PKT_ERROR_BYPASS)
{
marsio_buff_t *tx_mbuf = NULL;
marsio_buff_t *dup_mbuf = NULL;
struct gtest_frame *gtest_frame = NULL;
build_mbuf_for_raw_pkt(tx_mbuf, raw_pkt, sizeof(raw_pkt), 290484492702581737, 0);
build_mbuf_for_data_pkt(tx_mbuf, data_pkt, sizeof(data_pkt), 290484492702581737, 0);
dup_mbuf = marsio_mbuff_dup(tx_mbuf);
gtest_frame = gtest_frame_new("sce0.json", "raw_pkt_error_bypass");
gtest_frame = gtest_frame_new("sce0.json", "data_pkt_error_bypass");
gtest_frame_run(gtest_frame, tx_mbuf, dup_mbuf, 1);
gtest_frame_log(gtest_frame);

8
test/gtest_raw_pkt_stee_bypass.cpp → test/gtest_data_pkt_mirr_block.cpp
View File

@@ -16,7 +16,7 @@ static u_char ctrl_pkt_active[] = {
0x75, 0x6C, 0x65, 0x5F, 0x69, 0x64, 0x73, 0x91, 0xCE, 0x00, 0x0F, 0x2F, 0x7F};
// 145 bytes
static u_char raw_pkt[] = {
static u_char data_pkt[] = {
0x48, 0x73, 0x97, 0x96, 0x38, 0x10, 0x0c, 0xa7, 0x5c, 0x64, 0x00, 0x01, 0x08, 0x00, 0x45, 0x00,
0x00, 0x83, 0x46, 0x1f, 0x40, 0x00, 0x40, 0x06, 0xd4, 0x92, 0xc0, 0xa8, 0x29, 0x40, 0x5d, 0xb8,
0xd8, 0x22, 0xce, 0xec, 0x00, 0x50, 0xf8, 0x77, 0x0d, 0xcf, 0x47, 0x34, 0x32, 0xb9, 0x80, 0x18,
@@ -28,7 +28,7 @@ static u_char raw_pkt[] = {
0x0d, 0x0a, 0x41, 0x63, 0x63, 0x65, 0x70, 0x74, 0x3a, 0x20, 0x2a, 0x2f, 0x2a, 0x0d, 0x0a, 0x0d,
0x0a};
TEST(PACKET_IO, RAW_PKT_STEE_BYPASS)
TEST(PACKET_IO, DATA_PKT_MIRR_BLOCK)
{
marsio_buff_t *tx_mbuf1 = NULL;
marsio_buff_t *tx_mbuf2 = NULL;
@@ -37,11 +37,11 @@ TEST(PACKET_IO, RAW_PKT_STEE_BYPASS)
struct gtest_frame *gtest_frame = NULL;
build_mbuf_for_ctrl_pkt(tx_mbuf1, ctrl_pkt_active, sizeof(ctrl_pkt_active), 290484492702581737, 54);
build_mbuf_for_raw_pkt(tx_mbuf2, raw_pkt, sizeof(raw_pkt), 290484492702581737, 0);
build_mbuf_for_data_pkt(tx_mbuf2, data_pkt, sizeof(data_pkt), 290484492702581737, 0);
dup_mbuf1 = marsio_mbuff_dup(tx_mbuf1);
dup_mbuf2 = marsio_mbuff_dup(tx_mbuf2);
gtest_frame = gtest_frame_new("raw_pkt_stee_bypass.json", "raw_pkt_stee_bypass");
gtest_frame = gtest_frame_new("data_pkt_mirr_block.json", "data_pkt_mirr_block");
gtest_frame_run(gtest_frame, tx_mbuf1, dup_mbuf1, 1);
gtest_frame_run(gtest_frame, tx_mbuf2, dup_mbuf2, 1);

8
test/gtest_raw_pkt_mirr_block.cpp → test/gtest_data_pkt_mirr_bypass.cpp
View File

@@ -16,7 +16,7 @@ static u_char ctrl_pkt_active[] = {
0x75, 0x6C, 0x65, 0x5F, 0x69, 0x64, 0x73, 0x91, 0xCE, 0x00, 0x0F, 0x2F, 0x7F};
// 145 bytes
static u_char raw_pkt[] = {
static u_char data_pkt[] = {
0x48, 0x73, 0x97, 0x96, 0x38, 0x10, 0x0c, 0xa7, 0x5c, 0x64, 0x00, 0x01, 0x08, 0x00, 0x45, 0x00,
0x00, 0x83, 0x46, 0x1f, 0x40, 0x00, 0x40, 0x06, 0xd4, 0x92, 0xc0, 0xa8, 0x29, 0x40, 0x5d, 0xb8,
0xd8, 0x22, 0xce, 0xec, 0x00, 0x50, 0xf8, 0x77, 0x0d, 0xcf, 0x47, 0x34, 0x32, 0xb9, 0x80, 0x18,
@@ -28,7 +28,7 @@ static u_char raw_pkt[] = {
0x0d, 0x0a, 0x41, 0x63, 0x63, 0x65, 0x70, 0x74, 0x3a, 0x20, 0x2a, 0x2f, 0x2a, 0x0d, 0x0a, 0x0d,
0x0a};
TEST(PACKET_IO, RAW_PKT_MIRR_BLOCK)
TEST(PACKET_IO, DATA_PKT_MIRR_BYPASS)
{
marsio_buff_t *tx_mbuf1 = NULL;
marsio_buff_t *tx_mbuf2 = NULL;
@@ -37,11 +37,11 @@ TEST(PACKET_IO, RAW_PKT_MIRR_BLOCK)
struct gtest_frame *gtest_frame = NULL;
build_mbuf_for_ctrl_pkt(tx_mbuf1, ctrl_pkt_active, sizeof(ctrl_pkt_active), 290484492702581737, 54);
build_mbuf_for_raw_pkt(tx_mbuf2, raw_pkt, sizeof(raw_pkt), 290484492702581737, 0);
build_mbuf_for_data_pkt(tx_mbuf2, data_pkt, sizeof(data_pkt), 290484492702581737, 0);
dup_mbuf1 = marsio_mbuff_dup(tx_mbuf1);
dup_mbuf2 = marsio_mbuff_dup(tx_mbuf2);
gtest_frame = gtest_frame_new("raw_pkt_mirr_block.json", "raw_pkt_mirr_block");
gtest_frame = gtest_frame_new("data_pkt_mirr_bypass.json", "data_pkt_mirr_bypass");
gtest_frame_run(gtest_frame, tx_mbuf1, dup_mbuf1, 1);
gtest_frame_run(gtest_frame, tx_mbuf2, dup_mbuf2, 1);

8
test/gtest_raw_pkt_mirr_forward.cpp → test/gtest_data_pkt_mirr_forward.cpp
View File

@@ -16,7 +16,7 @@ static u_char ctrl_pkt_active[] = {
0x75, 0x6C, 0x65, 0x5F, 0x69, 0x64, 0x73, 0x91, 0xCE, 0x00, 0x0F, 0x2F, 0x7F};
// 145 bytes
static u_char raw_pkt[] = {
static u_char data_pkt[] = {
0x48, 0x73, 0x97, 0x96, 0x38, 0x10, 0x0c, 0xa7, 0x5c, 0x64, 0x00, 0x01, 0x08, 0x00, 0x45, 0x00,
0x00, 0x83, 0x46, 0x1f, 0x40, 0x00, 0x40, 0x06, 0xd4, 0x92, 0xc0, 0xa8, 0x29, 0x40, 0x5d, 0xb8,
0xd8, 0x22, 0xce, 0xec, 0x00, 0x50, 0xf8, 0x77, 0x0d, 0xcf, 0x47, 0x34, 0x32, 0xb9, 0x80, 0x18,
@@ -28,7 +28,7 @@ static u_char raw_pkt[] = {
0x0d, 0x0a, 0x41, 0x63, 0x63, 0x65, 0x70, 0x74, 0x3a, 0x20, 0x2a, 0x2f, 0x2a, 0x0d, 0x0a, 0x0d,
0x0a};
TEST(PACKET_IO, RAW_PKT_MIRR_FORWARD)
TEST(PACKET_IO, DATA_PKT_MIRR_FORWARD)
{
marsio_buff_t *tx_mbuf1 = NULL;
marsio_buff_t *tx_mbuf2 = NULL;
@@ -40,11 +40,11 @@ TEST(PACKET_IO, RAW_PKT_MIRR_FORWARD)
struct mr_instance *mr_instance = NULL;
build_mbuf_for_ctrl_pkt(tx_mbuf1, ctrl_pkt_active, sizeof(ctrl_pkt_active), 290484492702581737, 54);
build_mbuf_for_raw_pkt(tx_mbuf2, raw_pkt, sizeof(raw_pkt), 290484492702581737, 0);
build_mbuf_for_data_pkt(tx_mbuf2, data_pkt, sizeof(data_pkt), 290484492702581737, 0);
dup_mbuf1 = marsio_mbuff_dup(tx_mbuf1);
dup_mbuf2 = marsio_mbuff_dup(tx_mbuf2);
gtest_frame = gtest_frame_new("raw_pkt_mirr_forward.json", "raw_pkt_mirr_forward");
gtest_frame = gtest_frame_new("data_pkt_mirr_forward.json", "data_pkt_mirr_forward");
mr_instance = packet_io_get_mr_instance(gtest_frame->sce_ctx->io);
gtest_frame_run(gtest_frame, tx_mbuf1, dup_mbuf1, 1);
marsio_set_recv_mbuff(mr_instance, tx_mbuf2);

14
test/gtest_raw_pkt_mirr_rx_drop.cpp → test/gtest_data_pkt_mirr_rx_drop.cpp
View File

@@ -16,7 +16,7 @@ static u_char ctrl_pkt_active[] = {
0x75, 0x6C, 0x65, 0x5F, 0x69, 0x64, 0x73, 0x91, 0xCE, 0x00, 0x0F, 0x2F, 0x7F};
// 145 bytes
static u_char raw_pkt[] = {
static u_char data_pkt[] = {
0x48, 0x73, 0x97, 0x96, 0x38, 0x10, 0x0c, 0xa7, 0x5c, 0x64, 0x00, 0x01, 0x08, 0x00, 0x45, 0x00,
0x00, 0x83, 0x46, 0x1f, 0x40, 0x00, 0x40, 0x06, 0xd4, 0x92, 0xc0, 0xa8, 0x29, 0x40, 0x5d, 0xb8,
0xd8, 0x22, 0xce, 0xec, 0x00, 0x50, 0xf8, 0x77, 0x0d, 0xcf, 0x47, 0x34, 0x32, 0xb9, 0x80, 0x18,
@@ -28,7 +28,7 @@ static u_char raw_pkt[] = {
0x0d, 0x0a, 0x41, 0x63, 0x63, 0x65, 0x70, 0x74, 0x3a, 0x20, 0x2a, 0x2f, 0x2a, 0x0d, 0x0a, 0x0d,
0x0a};
TEST(PACKET_IO, RAW_PKT_MIRR_RX_DROP)
TEST(PACKET_IO, DATA_PKT_MIRR_RX_DROP)
{
marsio_buff_t *tx_mbuf1 = NULL;
marsio_buff_t *tx_mbuf2 = NULL;
@@ -40,17 +40,17 @@ TEST(PACKET_IO, RAW_PKT_MIRR_RX_DROP)
struct mr_instance *mr_instance = NULL;
build_mbuf_for_ctrl_pkt(tx_mbuf1, ctrl_pkt_active, sizeof(ctrl_pkt_active), 290484492702581737, 54);
build_mbuf_for_raw_pkt(tx_mbuf2, raw_pkt, sizeof(raw_pkt), 290484492702581737, 0);
build_mbuf_for_data_pkt(tx_mbuf2, data_pkt, sizeof(data_pkt), 290484492702581737, 0);
dup_mbuf1 = marsio_mbuff_dup(tx_mbuf1);
dup_mbuf2 = marsio_mbuff_dup(tx_mbuf2);
gtest_frame = gtest_frame_new("raw_pkt_mirr_forward.json", "raw_pkt_mirr_rx_drop");
gtest_frame = gtest_frame_new("data_pkt_mirr_forward.json", "data_pkt_mirr_rx_drop");
mr_instance = packet_io_get_mr_instance(gtest_frame->sce_ctx->io);
// recv ctrl_pkt_active from nf
// send ctrl_pkt_active to nf
gtest_frame_run(gtest_frame, tx_mbuf1, dup_mbuf1, 1);
// recv raw_pkt from nf
// recv data_pkt from nf
// send vxlan_pkt to sf
marsio_set_recv_mbuff(mr_instance, tx_mbuf2);
EXPECT_TRUE(packet_io_thread_polling_nf(gtest_frame->sce_ctx->io, &gtest_frame->sce_ctx->work_threads[0]) == 1);
@@ -58,9 +58,9 @@ TEST(PACKET_IO, RAW_PKT_MIRR_RX_DROP)
EXPECT_TRUE(mbuff_cmp_payload(dup_mbuf2, temp_mbuf) == 0);
EXPECT_TRUE(marsio_mbuff_cmp(dup_mbuf2, marsio_get_send_mbuff(mr_instance)) == 0);
// recv vxlan_pkt from sf
// send raw_pkt to nf
// send data_pkt to nf
marsio_set_recv_mbuff(mr_instance, temp_mbuf);
EXPECT_TRUE(packet_io_thread_polling_endpoint(gtest_frame->sce_ctx->io, &gtest_frame->sce_ctx->work_threads[0]) == 1);
EXPECT_TRUE(packet_io_thread_polling_endpoint_l3(gtest_frame->sce_ctx->io, &gtest_frame->sce_ctx->work_threads[0]) == 1);
EXPECT_TRUE(marsio_get_send_mbuff(mr_instance) == NULL);
gtest_frame_log(gtest_frame);

8
test/gtest_raw_pkt_stee_block.cpp → test/gtest_data_pkt_stee_block.cpp
View File

@@ -16,7 +16,7 @@ static u_char ctrl_pkt_active[] = {
0x75, 0x6C, 0x65, 0x5F, 0x69, 0x64, 0x73, 0x91, 0xCE, 0x00, 0x0F, 0x2F, 0x7F};
// 145 bytes
static u_char raw_pkt[] = {
static u_char data_pkt[] = {
0x48, 0x73, 0x97, 0x96, 0x38, 0x10, 0x0c, 0xa7, 0x5c, 0x64, 0x00, 0x01, 0x08, 0x00, 0x45, 0x00,
0x00, 0x83, 0x46, 0x1f, 0x40, 0x00, 0x40, 0x06, 0xd4, 0x92, 0xc0, 0xa8, 0x29, 0x40, 0x5d, 0xb8,
0xd8, 0x22, 0xce, 0xec, 0x00, 0x50, 0xf8, 0x77, 0x0d, 0xcf, 0x47, 0x34, 0x32, 0xb9, 0x80, 0x18,
@@ -28,7 +28,7 @@ static u_char raw_pkt[] = {
0x0d, 0x0a, 0x41, 0x63, 0x63, 0x65, 0x70, 0x74, 0x3a, 0x20, 0x2a, 0x2f, 0x2a, 0x0d, 0x0a, 0x0d,
0x0a};
TEST(PACKET_IO, RAW_PKT_STEE_BLOCK)
TEST(PACKET_IO, DATA_PKT_STEE_BLOCK)
{
marsio_buff_t *tx_mbuf1 = NULL;
marsio_buff_t *tx_mbuf2 = NULL;
@@ -36,10 +36,10 @@ TEST(PACKET_IO, RAW_PKT_STEE_BLOCK)
struct gtest_frame *gtest_frame = NULL;
build_mbuf_for_ctrl_pkt(tx_mbuf1, ctrl_pkt_active, sizeof(ctrl_pkt_active), 290484492702581737, 54);
build_mbuf_for_raw_pkt(tx_mbuf2, raw_pkt, sizeof(raw_pkt), 290484492702581737, 0);
build_mbuf_for_data_pkt(tx_mbuf2, data_pkt, sizeof(data_pkt), 290484492702581737, 0);
dup_mbuf1 = marsio_mbuff_dup(tx_mbuf1);
gtest_frame = gtest_frame_new("raw_pkt_stee_block.json", "raw_pkt_stee_block");
gtest_frame = gtest_frame_new("data_pkt_stee_block.json", "data_pkt_stee_block");
gtest_frame_run(gtest_frame, tx_mbuf1, dup_mbuf1, 1);
gtest_frame_run(gtest_frame, tx_mbuf2, NULL, 1);

8
test/gtest_raw_pkt_mirr_bypass.cpp → test/gtest_data_pkt_stee_bypass.cpp
View File

@@ -16,7 +16,7 @@ static u_char ctrl_pkt_active[] = {
0x75, 0x6C, 0x65, 0x5F, 0x69, 0x64, 0x73, 0x91, 0xCE, 0x00, 0x0F, 0x2F, 0x7F};
// 145 bytes
static u_char raw_pkt[] = {
static u_char data_pkt[] = {
0x48, 0x73, 0x97, 0x96, 0x38, 0x10, 0x0c, 0xa7, 0x5c, 0x64, 0x00, 0x01, 0x08, 0x00, 0x45, 0x00,
0x00, 0x83, 0x46, 0x1f, 0x40, 0x00, 0x40, 0x06, 0xd4, 0x92, 0xc0, 0xa8, 0x29, 0x40, 0x5d, 0xb8,
0xd8, 0x22, 0xce, 0xec, 0x00, 0x50, 0xf8, 0x77, 0x0d, 0xcf, 0x47, 0x34, 0x32, 0xb9, 0x80, 0x18,
@@ -28,7 +28,7 @@ static u_char raw_pkt[] = {
0x0d, 0x0a, 0x41, 0x63, 0x63, 0x65, 0x70, 0x74, 0x3a, 0x20, 0x2a, 0x2f, 0x2a, 0x0d, 0x0a, 0x0d,
0x0a};
TEST(PACKET_IO, RAW_PKT_MIRR_BYPASS)
TEST(PACKET_IO, DATA_PKT_STEE_BYPASS)
{
marsio_buff_t *tx_mbuf1 = NULL;
marsio_buff_t *tx_mbuf2 = NULL;
@@ -37,11 +37,11 @@ TEST(PACKET_IO, RAW_PKT_MIRR_BYPASS)
struct gtest_frame *gtest_frame = NULL;
build_mbuf_for_ctrl_pkt(tx_mbuf1, ctrl_pkt_active, sizeof(ctrl_pkt_active), 290484492702581737, 54);
build_mbuf_for_raw_pkt(tx_mbuf2, raw_pkt, sizeof(raw_pkt), 290484492702581737, 0);
build_mbuf_for_data_pkt(tx_mbuf2, data_pkt, sizeof(data_pkt), 290484492702581737, 0);
dup_mbuf1 = marsio_mbuff_dup(tx_mbuf1);
dup_mbuf2 = marsio_mbuff_dup(tx_mbuf2);
gtest_frame = gtest_frame_new("raw_pkt_mirr_bypass.json", "raw_pkt_mirr_bypass");
gtest_frame = gtest_frame_new("data_pkt_stee_bypass.json", "data_pkt_stee_bypass");
gtest_frame_run(gtest_frame, tx_mbuf1, dup_mbuf1, 1);
gtest_frame_run(gtest_frame, tx_mbuf2, dup_mbuf2, 1);

8
test/gtest_raw_pkt_stee_forward.cpp → test/gtest_data_pkt_stee_forward.cpp
View File

@@ -16,7 +16,7 @@ static u_char ctrl_pkt_active[] = {
0x75, 0x6C, 0x65, 0x5F, 0x69, 0x64, 0x73, 0x91, 0xCE, 0x00, 0x0F, 0x2F, 0x7F};
// 145 bytes
static u_char raw_pkt[] = {
static u_char data_pkt[] = {
0x48, 0x73, 0x97, 0x96, 0x38, 0x10, 0x0c, 0xa7, 0x5c, 0x64, 0x00, 0x01, 0x08, 0x00, 0x45, 0x00,
0x00, 0x83, 0x46, 0x1f, 0x40, 0x00, 0x40, 0x06, 0xd4, 0x92, 0xc0, 0xa8, 0x29, 0x40, 0x5d, 0xb8,
0xd8, 0x22, 0xce, 0xec, 0x00, 0x50, 0xf8, 0x77, 0x0d, 0xcf, 0x47, 0x34, 0x32, 0xb9, 0x80, 0x18,
@@ -28,7 +28,7 @@ static u_char raw_pkt[] = {
0x0d, 0x0a, 0x41, 0x63, 0x63, 0x65, 0x70, 0x74, 0x3a, 0x20, 0x2a, 0x2f, 0x2a, 0x0d, 0x0a, 0x0d,
0x0a};
TEST(PACKET_IO, RAW_PKT_STEE_FORWARD)
TEST(PACKET_IO, DATA_PKT_STEE_FORWARD)
{
marsio_buff_t *tx_mbuf1 = NULL;
marsio_buff_t *tx_mbuf2 = NULL;
@@ -38,11 +38,11 @@ TEST(PACKET_IO, RAW_PKT_STEE_FORWARD)
struct mr_instance *mr_instance = NULL;
build_mbuf_for_ctrl_pkt(tx_mbuf1, ctrl_pkt_active, sizeof(ctrl_pkt_active), 290484492702581737, 54);
build_mbuf_for_raw_pkt(tx_mbuf2, raw_pkt, sizeof(raw_pkt), 290484492702581737, 0);
build_mbuf_for_data_pkt(tx_mbuf2, data_pkt, sizeof(data_pkt), 290484492702581737, 0);
dup_mbuf1 = marsio_mbuff_dup(tx_mbuf1);
dup_mbuf2 = marsio_mbuff_dup(tx_mbuf2);
gtest_frame = gtest_frame_new("raw_pkt_stee_forward.json", "raw_pkt_stee_forward");
gtest_frame = gtest_frame_new("data_pkt_stee_forward.json", "data_pkt_stee_forward");
mr_instance = packet_io_get_mr_instance(gtest_frame->sce_ctx->io);
gtest_frame_run(gtest_frame, tx_mbuf1, dup_mbuf1, 1);
marsio_set_recv_mbuff(mr_instance, tx_mbuf2);

14
test/gtest_raw_pkt_stee_rx_egress.cpp → test/gtest_data_pkt_stee_rx_egress.cpp
View File

@@ -16,7 +16,7 @@ static u_char ctrl_pkt_active[] = {
0x75, 0x6C, 0x65, 0x5F, 0x69, 0x64, 0x73, 0x91, 0xCE, 0x00, 0x0F, 0x2F, 0x7F};
// 145 bytes
static u_char raw_pkt[] = {
static u_char data_pkt[] = {
0x48, 0x73, 0x97, 0x96, 0x38, 0x10, 0x0c, 0xa7, 0x5c, 0x64, 0x00, 0x01, 0x08, 0x00, 0x45, 0x00,
0x00, 0x83, 0x46, 0x1f, 0x40, 0x00, 0x40, 0x06, 0xd4, 0x92, 0xc0, 0xa8, 0x29, 0x40, 0x5d, 0xb8,
0xd8, 0x22, 0xce, 0xec, 0x00, 0x50, 0xf8, 0x77, 0x0d, 0xcf, 0x47, 0x34, 0x32, 0xb9, 0x80, 0x18,
@@ -28,7 +28,7 @@ static u_char raw_pkt[] = {
0x0d, 0x0a, 0x41, 0x63, 0x63, 0x65, 0x70, 0x74, 0x3a, 0x20, 0x2a, 0x2f, 0x2a, 0x0d, 0x0a, 0x0d,
0x0a};
TEST(PACKET_IO, RAW_PKT_STEE_RX_EGRESS)
TEST(PACKET_IO, DATA_PKT_STEE_RX_EGRESS)
{
marsio_buff_t *tx_mbuf1 = NULL;
marsio_buff_t *tx_mbuf2 = NULL;
@@ -39,26 +39,26 @@ TEST(PACKET_IO, RAW_PKT_STEE_RX_EGRESS)
struct mr_instance *mr_instance = NULL;
build_mbuf_for_ctrl_pkt(tx_mbuf1, ctrl_pkt_active, sizeof(ctrl_pkt_active), 290484492702581737, 54);
build_mbuf_for_raw_pkt(tx_mbuf2, raw_pkt, sizeof(raw_pkt), 290484492702581737, 0);
build_mbuf_for_data_pkt(tx_mbuf2, data_pkt, sizeof(data_pkt), 290484492702581737, 0);
dup_mbuf1 = marsio_mbuff_dup(tx_mbuf1);
dup_mbuf2 = marsio_mbuff_dup(tx_mbuf2);
gtest_frame = gtest_frame_new("raw_pkt_stee_forward.json", "raw_pkt_stee_rx_egress");
gtest_frame = gtest_frame_new("data_pkt_stee_forward.json", "data_pkt_stee_rx_egress");
mr_instance = packet_io_get_mr_instance(gtest_frame->sce_ctx->io);
// recv ctrl_pkt_active from nf
// send ctrl_pkt_active to nf
gtest_frame_run(gtest_frame, tx_mbuf1, dup_mbuf1, 1);
// recv raw_pkt from nf
// recv data_pkt from nf
// send vxlan_pkt to sf
marsio_set_recv_mbuff(mr_instance, tx_mbuf2);
EXPECT_TRUE(packet_io_thread_polling_nf(gtest_frame->sce_ctx->io, &gtest_frame->sce_ctx->work_threads[0]) == 1);
vxlan_mbuf = marsio_get_send_mbuff(mr_instance);
EXPECT_TRUE(mbuff_cmp_payload(dup_mbuf2, vxlan_mbuf) == 0);
// recv vxlan_pkt from sf
// send raw_pkt to nf
// send data_pkt to nf
marsio_set_recv_mbuff(mr_instance, vxlan_mbuf);
EXPECT_TRUE(packet_io_thread_polling_endpoint(gtest_frame->sce_ctx->io, &gtest_frame->sce_ctx->work_threads[0]) == 1);
EXPECT_TRUE(packet_io_thread_polling_endpoint_l3(gtest_frame->sce_ctx->io, &gtest_frame->sce_ctx->work_threads[0]) == 1);
EXPECT_TRUE(marsio_mbuff_cmp(dup_mbuf2, marsio_get_send_mbuff(mr_instance)) == 0);
gtest_frame_log(gtest_frame);

4
test/gtest_mix_pkt_stee_forward.cpp
View File

@@ -74,14 +74,14 @@ TEST(PACKET_IO, MIX_PKT_STEE_FORWARD)
// build ctrl packet for raw packet
build_mbuf_for_ctrl_pkt(tx_mbuf1, ctrl_pkt_active_for_raw_pkt, sizeof(ctrl_pkt_active_for_raw_pkt), 290484492702581737, 54);
// build raw packet
build_mbuf_for_raw_pkt(tx_mbuf2, raw_pkt, sizeof(raw_pkt), 290484492702581737, 0);
build_mbuf_for_data_pkt(tx_mbuf2, raw_pkt, sizeof(raw_pkt), 290484492702581737, 0);
dup_mbuf1 = marsio_mbuff_dup(tx_mbuf1);
dup_mbuf2 = marsio_mbuff_dup(tx_mbuf2);
// build ctrl packet for decrypted packet
build_mbuf_for_ctrl_pkt(tx_mbuf3, ctrl_pkt_active_for_decrypted_pkt, sizeof(ctrl_pkt_active_for_decrypted_pkt), 290484492702581737, 54);
// build decrypted packet
build_mbuf_for_raw_pkt(tx_mbuf4, decrypted_pkt, sizeof(decrypted_pkt), 290484492702581737, 1);
build_mbuf_for_data_pkt(tx_mbuf4, decrypted_pkt, sizeof(decrypted_pkt), 290484492702581737, 1);
dup_mbuf3 = marsio_mbuff_dup(tx_mbuf3);
dup_mbuf4 = marsio_mbuff_dup(tx_mbuf4);

14
test/gtest_utils.h
View File

@@ -51,7 +51,7 @@ extern marsio_buff_t *marsio_mbuff_dup(marsio_buff_t *m);
memcpy(ptr, data, len); \
}
#define build_mbuf_for_raw_pkt(mbuf, data, len, id, is_decrypt) \
#define build_mbuf_for_data_pkt(mbuf, data, len, id, is_decrypt) \
{ \
struct metadata meta; \
set_metadata(meta, id, 0, 0, is_decrypt); \
@@ -164,7 +164,7 @@ inline void gtest_frame_run(struct gtest_frame *instance, marsio_buff_t *tx_mbuf
}
else
{
EXPECT_TRUE(packet_io_thread_polling_endpoint(sce_ctx->io, thread_ctx) == 1);
EXPECT_TRUE(packet_io_thread_polling_endpoint_l3(sce_ctx->io, thread_ctx) == 1);
}
rx_mbuf = marsio_get_send_mbuff(mr_instance);
@@ -204,16 +204,16 @@ inline void gtest_frame_log(struct gtest_frame *instance)
system(cmdline);
}
inline int mbuff_cmp_payload(marsio_buff_t *raw_pkt, marsio_buff_t *vxlan_pkt)
inline int mbuff_cmp_payload(marsio_buff_t *buff, marsio_buff_t *vxlan_pkt)
{
struct g_vxlan *g_vxlan_hdr = NULL;
int raw_pkt_len = marsio_buff_datalen(raw_pkt);
char *raw_pkt_data = marsio_buff_mtod(raw_pkt);
int buff_len = marsio_buff_datalen(buff);
char *buff_data = marsio_buff_mtod(buff);
int vxlan_pkt_len = marsio_buff_datalen(vxlan_pkt);
char *vxlan_pkt_data = marsio_buff_mtod(vxlan_pkt);
if (raw_pkt_len + 50 != vxlan_pkt_len)
if (buff_len + 50 != vxlan_pkt_len)
{
goto error_out;
}
@@ -223,7 +223,7 @@ inline int mbuff_cmp_payload(marsio_buff_t *raw_pkt, marsio_buff_t *vxlan_pkt)
goto error_out;
}
if (memcmp(raw_pkt_data, vxlan_pkt_data + 50, raw_pkt_len) != 0)
if (memcmp(buff_data, vxlan_pkt_data + 50, buff_len) != 0)
{
goto error_out;
}

498
test/gtest_vlan_encapsulate.cpp Normal file
View File

@@ -0,0 +1,498 @@
#include "gtest_utils.h"
#include "packet_io.h"
/*
* Frame 3: 66 bytes on wire (528 bits), 66 bytes captured (528 bits)
* Encapsulation type: Ethernet (1)
* Arrival Time: Mar 1, 2019 11:22:58.243662000 CST
* [Time shift for this packet: 0.000000000 seconds]
* Epoch Time: 1551410578.243662000 seconds
* [Time delta from previous captured frame: 0.000428000 seconds]
* [Time delta from previous displayed frame: 0.000428000 seconds]
* [Time since reference or first frame: 0.000474000 seconds]
* Frame Number: 3
* Frame Length: 66 bytes (528 bits)
* Capture Length: 66 bytes (528 bits)
* [Frame is marked: False]
* [Frame is ignored: False]
* [Protocols in frame: eth:ethertype:ip:tcp]
* [Coloring Rule Name: TCP]
* [Coloring Rule String: tcp]
* Ethernet II, Src: 76:fc:ca:ef:29:28 (76:fc:ca:ef:29:28), Dst: AdlinkTe_4b:58:64 (00:30:64:4b:58:64)
* Destination: AdlinkTe_4b:58:64 (00:30:64:4b:58:64)
* Address: AdlinkTe_4b:58:64 (00:30:64:4b:58:64)
* .... ..0. .... .... .... .... = LG bit: Globally unique address (factory default)
* .... ...0 .... .... .... .... = IG bit: Individual address (unicast)
* Source: 76:fc:ca:ef:29:28 (76:fc:ca:ef:29:28)
* Address: 76:fc:ca:ef:29:28 (76:fc:ca:ef:29:28)
* .... ..1. .... .... .... .... = LG bit: Locally administered address (this is NOT the factory default)
* .... ...0 .... .... .... .... = IG bit: Individual address (unicast)
* Type: IPv4 (0x0800)
* Internet Protocol Version 4, Src: 192.168.10.250, Dst: 192.168.10.234
* 0100 .... = Version: 4
* .... 0101 = Header Length: 20 bytes (5)
* Differentiated Services Field: 0x00 (DSCP: CS0, ECN: Not-ECT)
* 0000 00.. = Differentiated Services Codepoint: Default (0)
* .... ..00 = Explicit Congestion Notification: Not ECN-Capable Transport (0)
* Total Length: 52
* Identification: 0x4878 (18552)
* 010. .... = Flags: 0x2, Don't fragment
* 0... .... = Reserved bit: Not set
* .1.. .... = Don't fragment: Set
* ..0. .... = More fragments: Not set
* ...0 0000 0000 0000 = Fragment Offset: 0
* Time to Live: 127
* Protocol: TCP (6)
* Header Checksum: 0x1c17 [correct]
* [Header checksum status: Good]
* [Calculated Checksum: 0x1c17]
* Source Address: 192.168.10.250
* Destination Address: 192.168.10.234
* Transmission Control Protocol, Src Port: 58725, Dst Port: 22, Seq: 1, Ack: 1, Len: 0
* Source Port: 58725
* Destination Port: 22
* [Stream index: 0]
* [Conversation completeness: Complete, WITH_DATA (31)]
* [TCP Segment Len: 0]
* Sequence Number: 1 (relative sequence number)
* Sequence Number (raw): 2587138324
* [Next Sequence Number: 1 (relative sequence number)]
* Acknowledgment Number: 1 (relative ack number)
* Acknowledgment number (raw): 2046996948
* 1000 .... = Header Length: 32 bytes (8)
* Flags: 0x010 (ACK)
* 000. .... .... = Reserved: Not set
* ...0 .... .... = Accurate ECN: Not set
* .... 0... .... = Congestion Window Reduced: Not set
* .... .0.. .... = ECN-Echo: Not set
* .... ..0. .... = Urgent: Not set
* .... ...1 .... = Acknowledgment: Set
* .... .... 0... = Push: Not set
* .... .... .0.. = Reset: Not set
* .... .... ..0. = Syn: Not set
* .... .... ...0 = Fin: Not set
* [TCP Flags: ·······A····]
* Window: 16646
* [Calculated window size: 66584]
* [Window size scaling factor: 4]
* Checksum: 0xa4ff [correct]
* [Checksum Status: Good]
* [Calculated Checksum: 0xa4ff]
* Urgent Pointer: 0
* Options: (12 bytes), No-Operation (NOP), No-Operation (NOP), Timestamps
* TCP Option - No-Operation (NOP)
* Kind: No-Operation (1)
* TCP Option - No-Operation (NOP)
* Kind: No-Operation (1)
* TCP Option - Timestamps
* Kind: Time Stamp Option (8)
* Length: 10
* Timestamp value: 155719012: TSval 155719012, TSecr 1560361273
* Timestamp echo reply: 1560361273
* [Timestamps]
* [Time since first frame in this TCP stream: 0.000474000 seconds]
* [Time since previous frame in this TCP stream: 0.000428000 seconds]
* [SEQ/ACK analysis]
* [This is an ACK to the segment in frame: 2]
* [The RTT to ACK the segment was: 0.000428000 seconds]
* [iRTT: 0.000474000 seconds]
*/
static u_char data_packet1_no_vlan_layer[] = {
0x00, 0x30, 0x64, 0x4b, 0x58, 0x64, 0x76, 0xfc, 0xca, 0xef, 0x29, 0x28, 0x08, 0x00, /* ETH */
0x45, 0x00, 0x00, 0x34, 0x48, 0x78, 0x40, 0x00, 0x7f, 0x06, 0x1c, 0x17, 0xc0, 0xa8, 0x0a, 0xfa,
0xc0, 0xa8, 0x0a, 0xea, /* IPv4 */
0xe5, 0x65, 0x00, 0x16, 0x9a, 0x34, 0x99, 0x14, 0x7a, 0x02, 0xb1, 0xd4, 0x80, 0x10, 0x41, 0x06,
0xa4, 0xff, 0x00, 0x00, 0x01, 0x01, 0x08, 0x0a, 0x09, 0x48, 0x15, 0x64, 0x5d, 0x01, 0x39, 0x39 /* TCP */};
/*
* Frame 1: 70 bytes on wire (560 bits), 70 bytes captured (560 bits)
* Encapsulation type: Ethernet (1)
* Arrival Time: Nov 6, 1999 02:20:41.093005000 CST
* [Time shift for this packet: 0.000000000 seconds]
* Epoch Time: 941826041.093005000 seconds
* [Time delta from previous captured frame: 0.000000000 seconds]
* [Time delta from previous displayed frame: 0.000000000 seconds]
* [Time since reference or first frame: 0.000000000 seconds]
* Frame Number: 1
* Frame Length: 70 bytes (560 bits)
* Capture Length: 70 bytes (560 bits)
* [Frame is marked: False]
* [Frame is ignored: False]
* [Protocols in frame: eth:ethertype:vlan:ethertype:ip:tcp]
* [Coloring Rule Name: TCP]
* [Coloring Rule String: tcp]
* Ethernet II, Src: 3com_9f:b1:f3 (00:60:08:9f:b1:f3), Dst: AniCommu_40:ef:24 (00:40:05:40:ef:24)
* Destination: AniCommu_40:ef:24 (00:40:05:40:ef:24)
* Address: AniCommu_40:ef:24 (00:40:05:40:ef:24)
* .... ..0. .... .... .... .... = LG bit: Globally unique address (factory default)
* .... ...0 .... .... .... .... = IG bit: Individual address (unicast)
* Source: 3com_9f:b1:f3 (00:60:08:9f:b1:f3)
* Address: 3com_9f:b1:f3 (00:60:08:9f:b1:f3)
* .... ..0. .... .... .... .... = LG bit: Globally unique address (factory default)
* .... ...0 .... .... .... .... = IG bit: Individual address (unicast)
* Type: 802.1Q Virtual LAN (0x8100)
* 802.1Q Virtual LAN, PRI: 0, DEI: 0, ID: 32
* 000. .... .... .... = Priority: Best Effort (default) (0)
* ...0 .... .... .... = DEI: Ineligible
* .... 0000 0010 0000 = ID: 32
* Type: IPv4 (0x0800)
* Internet Protocol Version 4, Src: 131.151.32.21, Dst: 131.151.32.129
* 0100 .... = Version: 4
* .... 0101 = Header Length: 20 bytes (5)
* Differentiated Services Field: 0x00 (DSCP: CS0, ECN: Not-ECT)
* 0000 00.. = Differentiated Services Codepoint: Default (0)
* .... ..00 = Explicit Congestion Notification: Not ECN-Capable Transport (0)
* Total Length: 52
* Identification: 0x8a9b (35483)
* 010. .... = Flags: 0x2, Don't fragment
* 0... .... = Reserved bit: Not set
* .1.. .... = Don't fragment: Set
* ..0. .... = More fragments: Not set
* ...0 0000 0000 0000 = Fragment Offset: 0
* Time to Live: 64
* Protocol: TCP (6)
* Header Checksum: 0x6864 [correct]
* [Header checksum status: Good]
* [Calculated Checksum: 0x6864]
* Source Address: 131.151.32.21
* Destination Address: 131.151.32.129
* Transmission Control Protocol, Src Port: 6000, Dst Port: 1162, Seq: 1, Ack: 1, Len: 0
* Source Port: 6000
* Destination Port: 1162
* [Stream index: 0]
* [Conversation completeness: Incomplete (4)]
* [TCP Segment Len: 0]
* Sequence Number: 1 (relative sequence number)
* Sequence Number (raw): 1295870649
* [Next Sequence Number: 1 (relative sequence number)]
* Acknowledgment Number: 1 (relative ack number)
* Acknowledgment number (raw): 1310007649
* 1000 .... = Header Length: 32 bytes (8)
* Flags: 0x010 (ACK)
* 000. .... .... = Reserved: Not set
* ...0 .... .... = Accurate ECN: Not set
* .... 0... .... = Congestion Window Reduced: Not set
* .... .0.. .... = ECN-Echo: Not set
* .... ..0. .... = Urgent: Not set
* .... ...1 .... = Acknowledgment: Set
* .... .... 0... = Push: Not set
* .... .... .0.. = Reset: Not set
* .... .... ..0. = Syn: Not set
* .... .... ...0 = Fin: Not set
* [TCP Flags: ·······A····]
* Window: 31856
* [Calculated window size: 31856]
* [Window size scaling factor: -1 (unknown)]
* Checksum: 0xd7f9 [correct]
* [Checksum Status: Good]
* [Calculated Checksum: 0xd7f9]
* Urgent Pointer: 0
* Options: (12 bytes), No-Operation (NOP), No-Operation (NOP), Timestamps
* TCP Option - No-Operation (NOP)
* Kind: No-Operation (1)
* TCP Option - No-Operation (NOP)
* Kind: No-Operation (1)
* TCP Option - Timestamps
* Kind: Time Stamp Option (8)
* Length: 10
* Timestamp value: 26846298: TSval 26846298, TSecr 323887
* Timestamp echo reply: 323887
* [Timestamps]
* [Time since first frame in this TCP stream: 0.000000000 seconds]
* [Time since previous frame in this TCP stream: 0.000000000 seconds]
*/
static u_char data_packet2_one_vlan_layer[] = {
0x00, 0x40, 0x05, 0x40, 0xef, 0x24, 0x00, 0x60, 0x08, 0x9f, 0xb1, 0xf3, 0x81, 0x00, /* ETH */
0x00, 0x20, 0x08, 0x00, /* VLAN */
0x45, 0x00, 0x00, 0x34, 0x8a, 0x9b, 0x40, 0x00, 0x40, 0x06, 0x68, 0x64, 0x83, 0x97, 0x20, 0x15,
0x83, 0x97, 0x20, 0x81, /* IPv4 */
0x17, 0x70, 0x04, 0x8a, 0x4d, 0x3d, 0x6a, 0xb9, 0x4e, 0x15, 0x21, 0x61, 0x80, 0x10, 0x7c, 0x70,
0xd7, 0xf9, 0x00, 0x00, 0x01, 0x01, 0x08, 0x0a, 0x01, 0x99, 0xa4, 0x5a, 0x00, 0x04, 0xf1, 0x2f /* TCP */};
/*
* Frame 1: 122 bytes on wire (976 bits), 122 bytes captured (976 bits)
* Encapsulation type: Ethernet (1)
* Arrival Time: Jun 30, 2010 03:41:35.140128000 CST
* [Time shift for this packet: 0.000000000 seconds]
* Epoch Time: 1277840495.140128000 seconds
* [Time delta from previous captured frame: 0.000000000 seconds]
* [Time delta from previous displayed frame: 0.000000000 seconds]
* [Time since reference or first frame: 0.000000000 seconds]
* Frame Number: 1
* Frame Length: 122 bytes (976 bits)
* Capture Length: 122 bytes (976 bits)
* [Frame is marked: False]
* [Frame is ignored: False]
* [Protocols in frame: eth:ethertype:vlan:ethertype:vlan:ethertype:ip:tcp:data]
* [Coloring Rule Name: TCP]
* [Coloring Rule String: tcp]
* Ethernet II, Src: Cisco_df:ae:18 (00:13:c3:df:ae:18), Dst: Cisco_1b:a4:d8 (00:1b:d4:1b:a4:d8)
* Destination: Cisco_1b:a4:d8 (00:1b:d4:1b:a4:d8)
* Address: Cisco_1b:a4:d8 (00:1b:d4:1b:a4:d8)
* .... ..0. .... .... .... .... = LG bit: Globally unique address (factory default)
* .... ...0 .... .... .... .... = IG bit: Individual address (unicast)
* Source: Cisco_df:ae:18 (00:13:c3:df:ae:18)
* Address: Cisco_df:ae:18 (00:13:c3:df:ae:18)
* .... ..0. .... .... .... .... = LG bit: Globally unique address (factory default)
* .... ...0 .... .... .... .... = IG bit: Individual address (unicast)
* Type: 802.1Q Virtual LAN (0x8100)
* 802.1Q Virtual LAN, PRI: 0, DEI: 0, ID: 118
* 000. .... .... .... = Priority: Best Effort (default) (0)
* ...0 .... .... .... = DEI: Ineligible
* .... 0000 0111 0110 = ID: 118
* Type: 802.1Q Virtual LAN (0x8100)
* 802.1Q Virtual LAN, PRI: 0, DEI: 0, ID: 10
* 000. .... .... .... = Priority: Best Effort (default) (0)
* ...0 .... .... .... = DEI: Ineligible
* .... 0000 0000 1010 = ID: 10
* Type: IPv4 (0x0800)
* Internet Protocol Version 4, Src: 10.118.10.1, Dst: 10.118.10.2
* 0100 .... = Version: 4
* .... 0101 = Header Length: 20 bytes (5)
* Differentiated Services Field: 0x00 (DSCP: CS0, ECN: Not-ECT)
* 0000 00.. = Differentiated Services Codepoint: Default (0)
* .... ..00 = Explicit Congestion Notification: Not ECN-Capable Transport (0)
* Total Length: 100
* Identification: 0x0012 (18)
* 000. .... = Flags: 0x0
* 0... .... = Reserved bit: Not set
* .0.. .... = Don't fragment: Not set
* ..0. .... = More fragments: Not set
* ...0 0000 0000 0000 = Fragment Offset: 0
* Time to Live: 255
* Protocol: TCP (6)
* Header Checksum: 0x9293 [correct]
* [Header checksum status: Good]
* [Calculated Checksum: 0x9293]
* Source Address: 10.118.10.1
* Destination Address: 10.118.10.2
* Transmission Control Protocol, Src Port: 2048, Dst Port: 52912, Seq: 1, Ack: 1, Len: 60
* Source Port: 2048
* Destination Port: 52912
* [Stream index: 0]
* [Conversation completeness: Incomplete (8)]
* [TCP Segment Len: 60]
* Sequence Number: 1 (relative sequence number)
* Sequence Number (raw): 196611
* [Next Sequence Number: 61 (relative sequence number)]
* Acknowledgment Number: 1 (relative ack number)
* Acknowledgment number (raw): 0
* 0101 .... = Header Length: 20 bytes (5)
* Flags: 0x010 (ACK)
* 000. .... .... = Reserved: Not set
* ...0 .... .... = Accurate ECN: Not set
* .... 0... .... = Congestion Window Reduced: Not set
* .... .0.. .... = ECN-Echo: Not set
* .... ..0. .... = Urgent: Not set
* .... ...1 .... = Acknowledgment: Set
* .... .... 0... = Push: Not set
* .... .... .0.. = Reset: Not set
* .... .... ..0. = Syn: Not set
* .... .... ...0 = Fin: Not set
* [TCP Flags: ·······A····]
* Window: 44916
* [Calculated window size: 44916]
* [Window size scaling factor: -1 (unknown)]
* Checksum: 0x8965 [correct]
* [Checksum Status: Good]
* [Calculated Checksum: 0x8965]
* Urgent Pointer: 0
* [Timestamps]
* [Time since first frame in this TCP stream: 0.000000000 seconds]
* [Time since previous frame in this TCP stream: 0.000000000 seconds]
* [SEQ/ACK analysis]
* [Bytes in flight: 60]
* [Bytes sent since last PSH flag: 60]
* TCP payload (60 bytes)
* Data (60 bytes)
* Data: 00cdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcd…
* [Length: 60]
*/
static u_char data_packet3_two_vlan_layer[] = {
0x00, 0x1b, 0xd4, 0x1b, 0xa4, 0xd8, 0x00, 0x13, 0xc3, 0xdf, 0xae, 0x18, 0x81, 0x00, /* ETH */
0x00, 0x76, 0x81, 0x00, /* VLAN */
0x00, 0x0a, 0x08, 0x00, /* VLAN */
0x45, 0x00, 0x00, 0x64, 0x00, 0x12, 0x00, 0x00, 0xff, 0x06, 0x92, 0x93, 0x0a, 0x76, 0x0a, 0x01,
0x0a, 0x76, 0x0a, 0x02, /* IPv4 */
0x08, 0x00, 0xce, 0xb0, 0x00, 0x03, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x50, 0x10, 0xaf, 0x74,
0x89, 0x65, 0x00, 0x00, 0x00, 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, 0xab, 0xcd, 0xab, 0xcd,
0xab, 0xcd, 0xab, 0xcd, 0xab, 0xcd, 0xab, 0xcd, 0xab, 0xcd, 0xab, 0xcd, 0xab, 0xcd, 0xab, 0xcd /* TCP */};
static u_char expect_packet1_prepend_vlan_header[] = {
0x00, 0x30, 0x64, 0x4b, 0x58, 0x64, 0x76, 0xfc, 0xca, 0xef, 0x29, 0x28, 0x81, 0x00, /* ETH */
0x04, 0x00, 0x08, 0x00, /* VLAN */
0x45, 0x00, 0x00, 0x34, 0x48, 0x78, 0x40, 0x00, 0x7f, 0x06, 0x1c, 0x17, 0xc0, 0xa8, 0x0a, 0xfa,
0xc0, 0xa8, 0x0a, 0xea, /* IPv4 */
0xe5, 0x65, 0x00, 0x16, 0x9a, 0x34, 0x99, 0x14, 0x7a, 0x02, 0xb1, 0xd4, 0x80, 0x10, 0x41, 0x06,
0xa4, 0xff, 0x00, 0x00, 0x01, 0x01, 0x08, 0x0a, 0x09, 0x48, 0x15, 0x64, 0x5d, 0x01, 0x39, 0x39 /* TCP */};
static u_char expect_packet2_prepend_vlan_header[] = {
0x00, 0x40, 0x05, 0x40, 0xef, 0x24, 0x00, 0x60, 0x08, 0x9f, 0xb1, 0xf3, 0x81, 0x00, /* ETH */
0x04, 0x00, 0x81, 0x00, /* VLAN */
0x00, 0x20, 0x08, 0x00, /* VLAN */
0x45, 0x00, 0x00, 0x34, 0x8a, 0x9b, 0x40, 0x00, 0x40, 0x06, 0x68, 0x64, 0x83, 0x97, 0x20, 0x15,
0x83, 0x97, 0x20, 0x81, /* IPv4 */
0x17, 0x70, 0x04, 0x8a, 0x4d, 0x3d, 0x6a, 0xb9, 0x4e, 0x15, 0x21, 0x61, 0x80, 0x10, 0x7c, 0x70,
0xd7, 0xf9, 0x00, 0x00, 0x01, 0x01, 0x08, 0x0a, 0x01, 0x99, 0xa4, 0x5a, 0x00, 0x04, 0xf1, 0x2f /* TCP */};
static u_char expect_packet3_prepend_vlan_header[] = {
0x00, 0x1b, 0xd4, 0x1b, 0xa4, 0xd8, 0x00, 0x13, 0xc3, 0xdf, 0xae, 0x18, 0x81, 0x00, /* ETH */
0x04, 0x00, 0x81, 0x00, /* VLAN */
0x00, 0x76, 0x81, 0x00, /* VLAN */
0x00, 0x0a, 0x08, 0x00, /* VLAN */
0x45, 0x00, 0x00, 0x64, 0x00, 0x12, 0x00, 0x00, 0xff, 0x06, 0x92, 0x93, 0x0a, 0x76, 0x0a, 0x01,
0x0a, 0x76, 0x0a, 0x02, /* IPv4 */
0x08, 0x00, 0xce, 0xb0, 0x00, 0x03, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x50, 0x10, 0xaf, 0x74,
0x89, 0x65, 0x00, 0x00, 0x00, 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, 0xab, 0xcd, 0xab, 0xcd,
0xab, 0xcd, 0xab, 0xcd, 0xab, 0xcd, 0xab, 0xcd, 0xab, 0xcd, 0xab, 0xcd, 0xab, 0xcd, 0xab, 0xcd /* TCP */};
static u_char expect_packet2_replace_vlan_header[] = {
0x00, 0x40, 0x05, 0x40, 0xef, 0x24, 0x00, 0x60, 0x08, 0x9f, 0xb1, 0xf3, 0x81, 0x00, /* ETH */
0x04, 0x00, 0x08, 0x00, /* VLAN */
0x45, 0x00, 0x00, 0x34, 0x8a, 0x9b, 0x40, 0x00, 0x40, 0x06, 0x68, 0x64, 0x83, 0x97, 0x20, 0x15,
0x83, 0x97, 0x20, 0x81, /* IPv4 */
0x17, 0x70, 0x04, 0x8a, 0x4d, 0x3d, 0x6a, 0xb9, 0x4e, 0x15, 0x21, 0x61, 0x80, 0x10, 0x7c, 0x70,
0xd7, 0xf9, 0x00, 0x00, 0x01, 0x01, 0x08, 0x0a, 0x01, 0x99, 0xa4, 0x5a, 0x00, 0x04, 0xf1, 0x2f /* TCP */};
static u_char expect_packet3_replace_vlan_header[] = {
0x00, 0x1b, 0xd4, 0x1b, 0xa4, 0xd8, 0x00, 0x13, 0xc3, 0xdf, 0xae, 0x18, 0x81, 0x00, /* ETH */
0x04, 0x00, 0x08, 0x00, /* VLAN */
0x45, 0x00, 0x00, 0x64, 0x00, 0x12, 0x00, 0x00, 0xff, 0x06, 0x92, 0x93, 0x0a, 0x76, 0x0a, 0x01,
0x0a, 0x76, 0x0a, 0x02, /* IPv4 */
0x08, 0x00, 0xce, 0xb0, 0x00, 0x03, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x50, 0x10, 0xaf, 0x74,
0x89, 0x65, 0x00, 0x00, 0x00, 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, 0xab, 0xcd, 0xab, 0xcd,
0xab, 0xcd, 0xab, 0xcd, 0xab, 0xcd, 0xab, 0xcd, 0xab, 0xcd, 0xab, 0xcd, 0xab, 0xcd, 0xab, 0xcd /* TCP */};
static void hexdump(char *data, uint32_t len)
{
for (uint32_t i = 0; i < len; i++)
{
printf("%02X", data[i] & 0xFF);
}
printf("\n");
for (uint32_t i = 0; i < len; i++)
{
printf("0x%02X, ", data[i] & 0xFF);
}
printf("\n");
}
TEST(PACKET_IO, VLAN_ENCAPSULATE_PREPEND_HEADER_1)
{
marsio_buff_t *mbuff = NULL;
int replace_orig_vlan_header = 0;
build_mbuf_for_data_pkt(mbuff, data_packet1_no_vlan_layer, sizeof(data_packet1_no_vlan_layer), 290484492702581737, 1);
vlan_encapsulate(mbuff, 1024, replace_orig_vlan_header);
char *data = marsio_buff_mtod(mbuff);
uint32_t len = marsio_buff_datalen(mbuff);
hexdump(data, len);
EXPECT_TRUE(len == sizeof(expect_packet1_prepend_vlan_header));
EXPECT_TRUE(memcmp(data, expect_packet1_prepend_vlan_header, len) == 0);
marsio_buff_free(NULL, &mbuff, 1, 0, 0);
}
TEST(PACKET_IO, VLAN_ENCAPSULATE_PREPEND_HEADER_2)
{
marsio_buff_t *mbuff = NULL;
int replace_orig_vlan_header = 0;
build_mbuf_for_data_pkt(mbuff, data_packet2_one_vlan_layer, sizeof(data_packet2_one_vlan_layer), 290484492702581737, 1);
vlan_encapsulate(mbuff, 1024, replace_orig_vlan_header);
char *data = marsio_buff_mtod(mbuff);
uint32_t len = marsio_buff_datalen(mbuff);
hexdump(data, len);
EXPECT_TRUE(len == sizeof(expect_packet2_prepend_vlan_header));
EXPECT_TRUE(memcmp(data, expect_packet2_prepend_vlan_header, len) == 0);
marsio_buff_free(NULL, &mbuff, 1, 0, 0);
}
TEST(PACKET_IO, VLAN_ENCAPSULATE_PREPEND_HEADER_3)
{
marsio_buff_t *mbuff = NULL;
int replace_orig_vlan_header = 0;
build_mbuf_for_data_pkt(mbuff, data_packet3_two_vlan_layer, sizeof(data_packet3_two_vlan_layer), 290484492702581737, 1);
vlan_encapsulate(mbuff, 1024, replace_orig_vlan_header);
char *data = marsio_buff_mtod(mbuff);
uint32_t len = marsio_buff_datalen(mbuff);
hexdump(data, len);
EXPECT_TRUE(len == sizeof(expect_packet3_prepend_vlan_header));
EXPECT_TRUE(memcmp(data, expect_packet3_prepend_vlan_header, len) == 0);
marsio_buff_free(NULL, &mbuff, 1, 0, 0);
}
TEST(PACKET_IO, VLAN_ENCAPSULATE_PEPLACE_HEADER_1)
{
marsio_buff_t *mbuff = NULL;
int replace_orig_vlan_header = 1;
build_mbuf_for_data_pkt(mbuff, data_packet1_no_vlan_layer, sizeof(data_packet1_no_vlan_layer), 290484492702581737, 1);
vlan_encapsulate(mbuff, 1024, replace_orig_vlan_header);
char *data = marsio_buff_mtod(mbuff);
uint32_t len = marsio_buff_datalen(mbuff);
hexdump(data, len);
EXPECT_TRUE(len == sizeof(expect_packet1_prepend_vlan_header));
EXPECT_TRUE(memcmp(data, expect_packet1_prepend_vlan_header, len) == 0);
marsio_buff_free(NULL, &mbuff, 1, 0, 0);
}
TEST(PACKET_IO, VLAN_ENCAPSULATE_PEPLACE_HEADER_2)
{
marsio_buff_t *mbuff = NULL;
int replace_orig_vlan_header = 1;
build_mbuf_for_data_pkt(mbuff, data_packet2_one_vlan_layer, sizeof(data_packet2_one_vlan_layer), 290484492702581737, 1);
vlan_encapsulate(mbuff, 1024, replace_orig_vlan_header);
char *data = marsio_buff_mtod(mbuff);
uint32_t len = marsio_buff_datalen(mbuff);
hexdump(data, len);
EXPECT_TRUE(len == sizeof(expect_packet2_replace_vlan_header));
EXPECT_TRUE(memcmp(data, expect_packet2_replace_vlan_header, len) == 0);
marsio_buff_free(NULL, &mbuff, 1, 0, 0);
}
TEST(PACKET_IO, VLAN_ENCAPSULATE_PEPLACE_HEADER_3)
{
marsio_buff_t *mbuff = NULL;
int replace_orig_vlan_header = 1;
build_mbuf_for_data_pkt(mbuff, data_packet3_two_vlan_layer, sizeof(data_packet3_two_vlan_layer), 290484492702581737, 1);
vlan_encapsulate(mbuff, 1024, replace_orig_vlan_header);
char *data = marsio_buff_mtod(mbuff);
uint32_t len = marsio_buff_datalen(mbuff);
hexdump(data, len);
EXPECT_TRUE(len == sizeof(expect_packet3_replace_vlan_header));
EXPECT_TRUE(memcmp(data, expect_packet3_replace_vlan_header, len) == 0);
marsio_buff_free(NULL, &mbuff, 1, 0, 0);
}
int main(int argc, char **argv)
{
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}

16
test/test_data/conf/sce.conf
View File

@@ -46,13 +46,17 @@ max_chaining_size=32
bypass_traffic=0
rx_burst_max=128
app_symbol=sce
dev_endpoint=eth_sf_endpoint
dev_nf_interface=eth_nf_interface
dev_endpoint_src_ip=192.168.100.1
# If the configuration file does not set src mac, get src mac through marsio_get_device_ether_addr();
# If the configuration file has src mac set, use the src mac in the file
# dev_endpoint_src_mac=aa:aa:aa:aa:aa:aa
dev_nf_name=eth_nf_interface
# dev_endpoint_l2 for vlan
dev_endpoint_l2_name=endpoint_0_sce_l2
vlan_encapsulate_replace_orig_vlan_header=0
# dev_endpoint_l3 for vxlan
dev_endpoint_l3_name=endpoint_0_sce_l3
dev_endpoint_l3_ip=192.168.100.1
# dev_endpoint_l3_mac=aa:aa:aa:aa:aa:aa
[stat]
output_file=log/sce.fs2

23
test/test_data/log/test_ctr_pkt_active_ok.fs2
View File

@@ -1,23 +1,26 @@
============================================================Thu Mar 30 09:36:37 2023============================================================
nf_rx_pkt nf_rx_B nf_tx_pkt nf_tx_B endp_rx_pkt endp_rx_B endp_tx_pkt endp_tx_B
============================================================Wed Oct 18 08:51:32 2023============================================================
dev_nf_rx_P dev_nf_rx_B dev_nf_tx_P dev_nf_tx_B kee_d_rx_P kee_d_rx_B kee_d_tx_P kee_d_tx_B
sum 1 147 1 147 0 0 0 0
speed/s 0 0 0 0 0 0 0 0
kee_d_rx_pkt kee_d_rx_B kee_d_tx_pkt kee_d_tx_B kee_u_rx_pkt kee_u_rx_B kee_u_rxdop_pkt kee_u_rxdop_B
dev_l3_rx_P dev_l3_rx_B dev_l3_tx_P dev_l3_tx_B kee_u_rx_P kee_u_rx_B kee_u_rxdop_P kee_u_rxdop_B
sum 0 0 0 0 0 0 0 0
speed/s 0 0 0 0 0 0 0 0
mirr_bypass_pkt mirr_bypass_B mirr_block_pkt mirr_block_B mirr_rxdop_pkt mirr_rxdop_B mirro_tx_pkt mirro_tx_B
dev_l2_rx_P dev_l2_rx_B dev_l2_tx_P dev_l2_tx_B dev_l3_dop_P dev_l3_dop_B dev_l2_dop_P dev_l2_dop_B
sum 0 0 0 0 0 0 0 0
speed/s 0 0 0 0 0 0 0 0
stee_bypass_pkt stee_bypass_B stee_block_pkt stee_block_B stee_rx_pkt stee_rx_B stee_tx_pkt stee_tx_B
mirr_bypass_P mirr_bypass_B mirr_block_P mirr_block_B mirr_rxdop_P mirr_rxdop_B mirro_tx_P mirro_tx_B
sum 0 0 0 0 0 0 0 0
speed/s 0 0 0 0 0 0 0 0
miss_sess_pkt miss_sess_B err_bypass_pkt err_bypass_B err_block_pkt err_block_B endp_drop_pkt endp_drop_B
stee_bypass_P stee_bypass_B stee_block_P stee_block_B stee_rx_P stee_rx_B stee_tx_P stee_tx_B
sum 0 0 0 0 0 0 0 0
speed/s 0 0 0 0 0 0 0 0
ctrl_rx_pkt ctrl_rx_B ctrl_tx_pkt ctrl_tx_B ctrl_opening ctrl_active ctrl_closing ctrl_resetall
miss_sess_P miss_sess_B err_bypass_P err_bypass_B err_block_P err_block_B sf_active sf_inactive
sum 0 0 0 0 0 0 1 0
speed/s 0 0 0 0 0 0 0 0
ctrl_rx_P ctrl_rx_B ctrl_tx_P ctrl_tx_B ctrl_opening ctrl_active ctrl_closing ctrl_resetall
sum 1 147 1 147 0 1 0 0
speed/s 0 0 0 0 0 0 0 0
ctrl_error session_num session_logs sf_active sf_inactive
sum 0 1 0 1 0
speed/s 0 0 0 0 0
ctrl_error curr_sessions session_logs
sum 0 1 0
speed/s 0 0 0
________________________________________________________________________________________________________________________________________________

23
test/test_data/log/test_ctr_pkt_opening_ok.fs2
View File

@@ -1,23 +1,26 @@
============================================================Fri Apr 28 05:45:07 2023============================================================
nf_rx_pkt nf_rx_B nf_tx_pkt nf_tx_B endp_rx_pkt endp_rx_B endp_tx_pkt endp_tx_B
============================================================Wed Oct 18 08:46:49 2023============================================================
dev_nf_rx_P dev_nf_rx_B dev_nf_tx_P dev_nf_tx_B kee_d_rx_P kee_d_rx_B kee_d_tx_P kee_d_tx_B
sum 1 99 1 99 0 0 0 0
speed/s 0 0 0 0 0 0 0 0
kee_d_rx_pkt kee_d_rx_B kee_d_tx_pkt kee_d_tx_B kee_u_rx_pkt kee_u_rx_B kee_u_rxdop_pkt kee_u_rxdop_B
dev_l3_rx_P dev_l3_rx_B dev_l3_tx_P dev_l3_tx_B kee_u_rx_P kee_u_rx_B kee_u_rxdop_P kee_u_rxdop_B
sum 0 0 0 0 0 0 0 0
speed/s 0 0 0 0 0 0 0 0
mirr_bypass_pkt mirr_bypass_B mirr_block_pkt mirr_block_B mirr_rxdop_pkt mirr_rxdop_B mirro_tx_pkt mirro_tx_B
dev_l2_rx_P dev_l2_rx_B dev_l2_tx_P dev_l2_tx_B dev_l3_dop_P dev_l3_dop_B dev_l2_dop_P dev_l2_dop_B
sum 0 0 0 0 0 0 0 0
speed/s 0 0 0 0 0 0 0 0
stee_bypass_pkt stee_bypass_B stee_block_pkt stee_block_B stee_rx_pkt stee_rx_B stee_tx_pkt stee_tx_B
mirr_bypass_P mirr_bypass_B mirr_block_P mirr_block_B mirr_rxdop_P mirr_rxdop_B mirro_tx_P mirro_tx_B
sum 0 0 0 0 0 0 0 0
speed/s 0 0 0 0 0 0 0 0
miss_sess_pkt miss_sess_B err_bypass_pkt err_bypass_B err_block_pkt err_block_B endp_drop_pkt endp_drop_B
stee_bypass_P stee_bypass_B stee_block_P stee_block_B stee_rx_P stee_rx_B stee_tx_P stee_tx_B
sum 0 0 0 0 0 0 0 0
speed/s 0 0 0 0 0 0 0 0
ctrl_rx_pkt ctrl_rx_B ctrl_tx_pkt ctrl_tx_B ctrl_opening ctrl_active ctrl_closing ctrl_resetall
miss_sess_P miss_sess_B err_bypass_P err_bypass_B err_block_P err_block_B sf_active sf_inactive
sum 0 0 0 0 0 0 0 0
speed/s 0 0 0 0 0 0 0 0
ctrl_rx_P ctrl_rx_B ctrl_tx_P ctrl_tx_B ctrl_opening ctrl_active ctrl_closing ctrl_resetall
sum 1 99 1 99 1 0 0 0
speed/s 0 0 0 0 0 0 0 0
ctrl_error session_num session_logs sf_active sf_inactive
sum 0 0 0 0 0
speed/s 0 0 0 0 0
ctrl_error curr_sessions session_logs
sum 0 0 0
speed/s 0 0 0
________________________________________________________________________________________________________________________________________________

23
test/test_data/log/test_raw_pkt_error_bypass_ok.fs2 → test/test_data/log/test_data_pkt_error_bypass_ok.fs2
View File

@@ -1,23 +1,26 @@
============================================================Fri Apr 7 09:41:37 2023============================================================
nf_rx_pkt nf_rx_B nf_tx_pkt nf_tx_B endp_rx_pkt endp_rx_B endp_tx_pkt endp_tx_B
============================================================Wed Oct 18 08:56:42 2023============================================================
dev_nf_rx_P dev_nf_rx_B dev_nf_tx_P dev_nf_tx_B kee_d_rx_P kee_d_rx_B kee_d_tx_P kee_d_tx_B
sum 1 145 1 145 0 0 0 0
speed/s 0 0 0 0 0 0 0 0
kee_d_rx_pkt kee_d_rx_B kee_d_tx_pkt kee_d_tx_B kee_u_rx_pkt kee_u_rx_B kee_u_rxdop_pkt kee_u_rxdop_B
dev_l3_rx_P dev_l3_rx_B dev_l3_tx_P dev_l3_tx_B kee_u_rx_P kee_u_rx_B kee_u_rxdop_P kee_u_rxdop_B
sum 0 0 0 0 0 0 0 0
speed/s 0 0 0 0 0 0 0 0
mirr_bypass_pkt mirr_bypass_B mirr_block_pkt mirr_block_B mirr_rxdop_pkt mirr_rxdop_B mirro_tx_pkt mirro_tx_B
dev_l2_rx_P dev_l2_rx_B dev_l2_tx_P dev_l2_tx_B dev_l3_dop_P dev_l3_dop_B dev_l2_dop_P dev_l2_dop_B
sum 0 0 0 0 0 0 0 0
speed/s 0 0 0 0 0 0 0 0
stee_bypass_pkt stee_bypass_B stee_block_pkt stee_block_B stee_rx_pkt stee_rx_B stee_tx_pkt stee_tx_B
mirr_bypass_P mirr_bypass_B mirr_block_P mirr_block_B mirr_rxdop_P mirr_rxdop_B mirro_tx_P mirro_tx_B
sum 0 0 0 0 0 0 0 0
speed/s 0 0 0 0 0 0 0 0
miss_sess_pkt miss_sess_B err_bypass_pkt err_bypass_B err_block_pkt err_block_B endp_drop_pkt endp_drop_B
stee_bypass_P stee_bypass_B stee_block_P stee_block_B stee_rx_P stee_rx_B stee_tx_P stee_tx_B
sum 0 0 0 0 0 0 0 0
speed/s 0 0 0 0 0 0 0 0
miss_sess_P miss_sess_B err_bypass_P err_bypass_B err_block_P err_block_B sf_active sf_inactive
sum 1 145 1 145 0 0 0 0
speed/s 0 0 0 0 0 0 0 0
ctrl_rx_pkt ctrl_rx_B ctrl_tx_pkt ctrl_tx_B ctrl_opening ctrl_active ctrl_closing ctrl_resetall
ctrl_rx_P ctrl_rx_B ctrl_tx_P ctrl_tx_B ctrl_opening ctrl_active ctrl_closing ctrl_resetall
sum 0 0 0 0 0 0 0 0
speed/s 0 0 0 0 0 0 0 0
ctrl_error session_num session_logs sf_active sf_inactive
sum 0 0 0 0 0
speed/s 0 0 0 0 0
ctrl_error curr_sessions session_logs
sum 0 0 0
speed/s 0 0 0
________________________________________________________________________________________________________________________________________________

23
test/test_data/log/test_raw_pkt_mirr_block_ok.fs2 → test/test_data/log/test_data_pkt_mirr_block_ok.fs2
View File

@@ -1,23 +1,26 @@
============================================================Fri Apr 7 08:47:52 2023============================================================
nf_rx_pkt nf_rx_B nf_tx_pkt nf_tx_B endp_rx_pkt endp_rx_B endp_tx_pkt endp_tx_B
============================================================Wed Oct 18 08:57:52 2023============================================================
dev_nf_rx_P dev_nf_rx_B dev_nf_tx_P dev_nf_tx_B kee_d_rx_P kee_d_rx_B kee_d_tx_P kee_d_tx_B
sum 2 292 2 292 0 0 0 0
speed/s 0 0 0 0 0 0 0 0
kee_d_rx_pkt kee_d_rx_B kee_d_tx_pkt kee_d_tx_B kee_u_rx_pkt kee_u_rx_B kee_u_rxdop_pkt kee_u_rxdop_B
dev_l3_rx_P dev_l3_rx_B dev_l3_tx_P dev_l3_tx_B kee_u_rx_P kee_u_rx_B kee_u_rxdop_P kee_u_rxdop_B
sum 0 0 0 0 0 0 0 0
speed/s 0 0 0 0 0 0 0 0
mirr_bypass_pkt mirr_bypass_B mirr_block_pkt mirr_block_B mirr_rxdop_pkt mirr_rxdop_B mirro_tx_pkt mirro_tx_B
dev_l2_rx_P dev_l2_rx_B dev_l2_tx_P dev_l2_tx_B dev_l3_dop_P dev_l3_dop_B dev_l2_dop_P dev_l2_dop_B
sum 0 0 0 0 0 0 0 0
speed/s 0 0 0 0 0 0 0 0
mirr_bypass_P mirr_bypass_B mirr_block_P mirr_block_B mirr_rxdop_P mirr_rxdop_B mirro_tx_P mirro_tx_B
sum 0 0 1 145 0 0 0 0
speed/s 0 0 0 0 0 0 0 0
stee_bypass_pkt stee_bypass_B stee_block_pkt stee_block_B stee_rx_pkt stee_rx_B stee_tx_pkt stee_tx_B
stee_bypass_P stee_bypass_B stee_block_P stee_block_B stee_rx_P stee_rx_B stee_tx_P stee_tx_B
sum 0 0 0 0 0 0 0 0
speed/s 0 0 0 0 0 0 0 0
miss_sess_pkt miss_sess_B err_bypass_pkt err_bypass_B err_block_pkt err_block_B endp_drop_pkt endp_drop_B
miss_sess_P miss_sess_B err_bypass_P err_bypass_B err_block_P err_block_B sf_active sf_inactive
sum 0 0 0 0 0 0 0 0
speed/s 0 0 0 0 0 0 0 0
ctrl_rx_pkt ctrl_rx_B ctrl_tx_pkt ctrl_tx_B ctrl_opening ctrl_active ctrl_closing ctrl_resetall
ctrl_rx_P ctrl_rx_B ctrl_tx_P ctrl_tx_B ctrl_opening ctrl_active ctrl_closing ctrl_resetall
sum 1 147 1 147 0 1 0 0
speed/s 0 0 0 0 0 0 0 0
ctrl_error session_num session_logs sf_active sf_inactive
sum 0 1 0 0 0
speed/s 0 0 0 0 0
ctrl_error curr_sessions session_logs
sum 0 1 0
speed/s 0 0 0
________________________________________________________________________________________________________________________________________________

23
test/test_data/log/test_raw_pkt_stee_bypass_ok.fs2 → test/test_data/log/test_data_pkt_mirr_bypass_ok.fs2
View File

@@ -1,23 +1,26 @@
============================================================Thu Apr 6 02:56:08 2023============================================================
nf_rx_pkt nf_rx_B nf_tx_pkt nf_tx_B endp_rx_pkt endp_rx_B endp_tx_pkt endp_tx_B
============================================================Wed Oct 18 08:59:09 2023============================================================
dev_nf_rx_P dev_nf_rx_B dev_nf_tx_P dev_nf_tx_B kee_d_rx_P kee_d_rx_B kee_d_tx_P kee_d_tx_B
sum 2 292 2 292 0 0 0 0
speed/s 0 0 0 0 0 0 0 0
kee_d_rx_pkt kee_d_rx_B kee_d_tx_pkt kee_d_tx_B kee_u_rx_pkt kee_u_rx_B kee_u_rxdop_pkt kee_u_rxdop_B
dev_l3_rx_P dev_l3_rx_B dev_l3_tx_P dev_l3_tx_B kee_u_rx_P kee_u_rx_B kee_u_rxdop_P kee_u_rxdop_B
sum 0 0 0 0 0 0 0 0
speed/s 0 0 0 0 0 0 0 0
mirr_bypass_pkt mirr_bypass_B mirr_block_pkt mirr_block_B mirr_rxdop_pkt mirr_rxdop_B mirro_tx_pkt mirro_tx_B
dev_l2_rx_P dev_l2_rx_B dev_l2_tx_P dev_l2_tx_B dev_l3_dop_P dev_l3_dop_B dev_l2_dop_P dev_l2_dop_B
sum 0 0 0 0 0 0 0 0
speed/s 0 0 0 0 0 0 0 0
stee_bypass_pkt stee_bypass_B stee_block_pkt stee_block_B stee_rx_pkt stee_rx_B stee_tx_pkt stee_tx_B
mirr_bypass_P mirr_bypass_B mirr_block_P mirr_block_B mirr_rxdop_P mirr_rxdop_B mirro_tx_P mirro_tx_B
sum 1 145 0 0 0 0 0 0
speed/s 0 0 0 0 0 0 0 0
miss_sess_pkt miss_sess_B err_bypass_pkt err_bypass_B err_block_pkt err_block_B endp_drop_pkt endp_drop_B
stee_bypass_P stee_bypass_B stee_block_P stee_block_B stee_rx_P stee_rx_B stee_tx_P stee_tx_B
sum 0 0 0 0 0 0 0 0
speed/s 0 0 0 0 0 0 0 0
ctrl_rx_pkt ctrl_rx_B ctrl_tx_pkt ctrl_tx_B ctrl_opening ctrl_active ctrl_closing ctrl_resetall
miss_sess_P miss_sess_B err_bypass_P err_bypass_B err_block_P err_block_B sf_active sf_inactive
sum 0 0 0 0 0 0 0 0
speed/s 0 0 0 0 0 0 0 0
ctrl_rx_P ctrl_rx_B ctrl_tx_P ctrl_tx_B ctrl_opening ctrl_active ctrl_closing ctrl_resetall
sum 1 147 1 147 0 1 0 0
speed/s 0 0 0 0 0 0 0 0
ctrl_error session_num session_logs sf_active sf_inactive
sum 0 1 0 0 0
speed/s 0 0 0 0 0
ctrl_error curr_sessions session_logs
sum 0 1 0
speed/s 0 0 0
________________________________________________________________________________________________________________________________________________

27
test/test_data/log/test_raw_pkt_mirr_forward_ok.fs2 → test/test_data/log/test_data_pkt_mirr_forward_ok.fs2
View File

@@ -1,23 +1,26 @@
============================================================Fri Apr 7 09:26:07 2023============================================================
nf_rx_pkt nf_rx_B nf_tx_pkt nf_tx_B endp_rx_pkt endp_rx_B endp_tx_pkt endp_tx_B
sum 2 292 2 292 0 0 1 195
============================================================Wed Oct 18 09:00:21 2023============================================================
dev_nf_rx_P dev_nf_rx_B dev_nf_tx_P dev_nf_tx_B kee_d_rx_P kee_d_rx_B kee_d_tx_P kee_d_tx_B
sum 2 292 2 292 0 0 0 0
speed/s 0 0 0 0 0 0 0 0
kee_d_rx_pkt kee_d_rx_B kee_d_tx_pkt kee_d_tx_B kee_u_rx_pkt kee_u_rx_B kee_u_rxdop_pkt kee_u_rxdop_B
dev_l3_rx_P dev_l3_rx_B dev_l3_tx_P dev_l3_tx_B kee_u_rx_P kee_u_rx_B kee_u_rxdop_P kee_u_rxdop_B
sum 0 0 1 195 0 0 0 0
speed/s 0 0 0 0 0 0 0 0
dev_l2_rx_P dev_l2_rx_B dev_l2_tx_P dev_l2_tx_B dev_l3_dop_P dev_l3_dop_B dev_l2_dop_P dev_l2_dop_B
sum 0 0 0 0 0 0 0 0
speed/s 0 0 0 0 0 0 0 0
mirr_bypass_pkt mirr_bypass_B mirr_block_pkt mirr_block_B mirr_rxdop_pkt mirr_rxdop_B mirro_tx_pkt mirro_tx_B
mirr_bypass_P mirr_bypass_B mirr_block_P mirr_block_B mirr_rxdop_P mirr_rxdop_B mirro_tx_P mirro_tx_B
sum 0 0 0 0 0 0 1 145
speed/s 0 0 0 0 0 0 0 0
stee_bypass_pkt stee_bypass_B stee_block_pkt stee_block_B stee_rx_pkt stee_rx_B stee_tx_pkt stee_tx_B
stee_bypass_P stee_bypass_B stee_block_P stee_block_B stee_rx_P stee_rx_B stee_tx_P stee_tx_B
sum 0 0 0 0 0 0 0 0
speed/s 0 0 0 0 0 0 0 0
miss_sess_pkt miss_sess_B err_bypass_pkt err_bypass_B err_block_pkt err_block_B endp_drop_pkt endp_drop_B
sum 0 0 0 0 0 0 0 0
miss_sess_P miss_sess_B err_bypass_P err_bypass_B err_block_P err_block_B sf_active sf_inactive
sum 0 0 0 0 0 0 1 0
speed/s 0 0 0 0 0 0 0 0
ctrl_rx_pkt ctrl_rx_B ctrl_tx_pkt ctrl_tx_B ctrl_opening ctrl_active ctrl_closing ctrl_resetall
ctrl_rx_P ctrl_rx_B ctrl_tx_P ctrl_tx_B ctrl_opening ctrl_active ctrl_closing ctrl_resetall
sum 1 147 1 147 0 1 0 0
speed/s 0 0 0 0 0 0 0 0
ctrl_error session_num session_logs sf_active sf_inactive
sum 0 1 0 1 0
speed/s 0 0 0 0 0
ctrl_error curr_sessions session_logs
sum 0 1 0
speed/s 0 0 0
________________________________________________________________________________________________________________________________________________

26
test/test_data/log/test_data_pkt_mirr_rx_drop_ok.fs2 Normal file
View File

@@ -0,0 +1,26 @@
============================================================Wed Oct 18 09:05:25 2023============================================================
dev_nf_rx_P dev_nf_rx_B dev_nf_tx_P dev_nf_tx_B kee_d_rx_P kee_d_rx_B kee_d_tx_P kee_d_tx_B
sum 2 292 2 292 0 0 0 0
speed/s 0 0 0 0 0 0 0 0
dev_l3_rx_P dev_l3_rx_B dev_l3_tx_P dev_l3_tx_B kee_u_rx_P kee_u_rx_B kee_u_rxdop_P kee_u_rxdop_B
sum 1 195 1 195 0 0 0 0
speed/s 0 0 0 0 0 0 0 0
dev_l2_rx_P dev_l2_rx_B dev_l2_tx_P dev_l2_tx_B dev_l3_dop_P dev_l3_dop_B dev_l2_dop_P dev_l2_dop_B
sum 0 0 0 0 1 195 0 0
speed/s 0 0 0 0 0 0 0 0
mirr_bypass_P mirr_bypass_B mirr_block_P mirr_block_B mirr_rxdop_P mirr_rxdop_B mirro_tx_P mirro_tx_B
sum 0 0 0 0 1 145 1 145
speed/s 0 0 0 0 0 0 0 0
stee_bypass_P stee_bypass_B stee_block_P stee_block_B stee_rx_P stee_rx_B stee_tx_P stee_tx_B
sum 0 0 0 0 0 0 0 0
speed/s 0 0 0 0 0 0 0 0
miss_sess_P miss_sess_B err_bypass_P err_bypass_B err_block_P err_block_B sf_active sf_inactive
sum 0 0 0 0 1 145 1 0
speed/s 0 0 0 0 0 0 0 0
ctrl_rx_P ctrl_rx_B ctrl_tx_P ctrl_tx_B ctrl_opening ctrl_active ctrl_closing ctrl_resetall
sum 1 147 1 147 0 1 0 0
speed/s 0 0 0 0 0 0 0 0
ctrl_error curr_sessions session_logs
sum 0 1 0
speed/s 0 0 0
________________________________________________________________________________________________________________________________________________

23
test/test_data/log/test_raw_pkt_stee_block_ok.fs2 → test/test_data/log/test_data_pkt_stee_block_ok.fs2
View File

@@ -1,23 +1,26 @@
============================================================Thu Apr 6 03:13:22 2023============================================================
nf_rx_pkt nf_rx_B nf_tx_pkt nf_tx_B endp_rx_pkt endp_rx_B endp_tx_pkt endp_tx_B
============================================================Wed Oct 18 09:07:22 2023============================================================
dev_nf_rx_P dev_nf_rx_B dev_nf_tx_P dev_nf_tx_B kee_d_rx_P kee_d_rx_B kee_d_tx_P kee_d_tx_B
sum 2 292 1 147 0 0 0 0
speed/s 0 0 0 0 0 0 0 0
kee_d_rx_pkt kee_d_rx_B kee_d_tx_pkt kee_d_tx_B kee_u_rx_pkt kee_u_rx_B kee_u_rxdop_pkt kee_u_rxdop_B
dev_l3_rx_P dev_l3_rx_B dev_l3_tx_P dev_l3_tx_B kee_u_rx_P kee_u_rx_B kee_u_rxdop_P kee_u_rxdop_B
sum 0 0 0 0 0 0 0 0
speed/s 0 0 0 0 0 0 0 0
mirr_bypass_pkt mirr_bypass_B mirr_block_pkt mirr_block_B mirr_rxdop_pkt mirr_rxdop_B mirro_tx_pkt mirro_tx_B
dev_l2_rx_P dev_l2_rx_B dev_l2_tx_P dev_l2_tx_B dev_l3_dop_P dev_l3_dop_B dev_l2_dop_P dev_l2_dop_B
sum 0 0 0 0 0 0 0 0
speed/s 0 0 0 0 0 0 0 0
stee_bypass_pkt stee_bypass_B stee_block_pkt stee_block_B stee_rx_pkt stee_rx_B stee_tx_pkt stee_tx_B
mirr_bypass_P mirr_bypass_B mirr_block_P mirr_block_B mirr_rxdop_P mirr_rxdop_B mirro_tx_P mirro_tx_B
sum 0 0 0 0 0 0 0 0
speed/s 0 0 0 0 0 0 0 0
stee_bypass_P stee_bypass_B stee_block_P stee_block_B stee_rx_P stee_rx_B stee_tx_P stee_tx_B
sum 0 0 1 145 0 0 0 0
speed/s 0 0 0 0 0 0 0 0
miss_sess_pkt miss_sess_B err_bypass_pkt err_bypass_B err_block_pkt err_block_B endp_drop_pkt endp_drop_B
miss_sess_P miss_sess_B err_bypass_P err_bypass_B err_block_P err_block_B sf_active sf_inactive
sum 0 0 0 0 0 0 0 0
speed/s 0 0 0 0 0 0 0 0
ctrl_rx_pkt ctrl_rx_B ctrl_tx_pkt ctrl_tx_B ctrl_opening ctrl_active ctrl_closing ctrl_resetall
ctrl_rx_P ctrl_rx_B ctrl_tx_P ctrl_tx_B ctrl_opening ctrl_active ctrl_closing ctrl_resetall
sum 1 147 1 147 0 1 0 0
speed/s 0 0 0 0 0 0 0 0
ctrl_error session_num session_logs sf_active sf_inactive
sum 0 1 0 0 0
speed/s 0 0 0 0 0
ctrl_error curr_sessions session_logs
sum 0 1 0
speed/s 0 0 0
________________________________________________________________________________________________________________________________________________

27
test/test_data/log/test_raw_pkt_mirr_bypass_ok.fs2 → test/test_data/log/test_data_pkt_stee_bypass_ok.fs2
View File

@@ -1,23 +1,26 @@
============================================================Fri Apr 7 09:01:03 2023============================================================
nf_rx_pkt nf_rx_B nf_tx_pkt nf_tx_B endp_rx_pkt endp_rx_B endp_tx_pkt endp_tx_B
============================================================Wed Oct 18 09:09:00 2023============================================================
dev_nf_rx_P dev_nf_rx_B dev_nf_tx_P dev_nf_tx_B kee_d_rx_P kee_d_rx_B kee_d_tx_P kee_d_tx_B
sum 2 292 2 292 0 0 0 0
speed/s 0 0 0 0 0 0 0 0
kee_d_rx_pkt kee_d_rx_B kee_d_tx_pkt kee_d_tx_B kee_u_rx_pkt kee_u_rx_B kee_u_rxdop_pkt kee_u_rxdop_B
dev_l3_rx_P dev_l3_rx_B dev_l3_tx_P dev_l3_tx_B kee_u_rx_P kee_u_rx_B kee_u_rxdop_P kee_u_rxdop_B
sum 0 0 0 0 0 0 0 0
speed/s 0 0 0 0 0 0 0 0
mirr_bypass_pkt mirr_bypass_B mirr_block_pkt mirr_block_B mirr_rxdop_pkt mirr_rxdop_B mirro_tx_pkt mirro_tx_B
dev_l2_rx_P dev_l2_rx_B dev_l2_tx_P dev_l2_tx_B dev_l3_dop_P dev_l3_dop_B dev_l2_dop_P dev_l2_dop_B
sum 0 0 0 0 0 0 0 0
speed/s 0 0 0 0 0 0 0 0
mirr_bypass_P mirr_bypass_B mirr_block_P mirr_block_B mirr_rxdop_P mirr_rxdop_B mirro_tx_P mirro_tx_B
sum 0 0 0 0 0 0 0 0
speed/s 0 0 0 0 0 0 0 0
stee_bypass_P stee_bypass_B stee_block_P stee_block_B stee_rx_P stee_rx_B stee_tx_P stee_tx_B
sum 1 145 0 0 0 0 0 0
speed/s 0 0 0 0 0 0 0 0
stee_bypass_pkt stee_bypass_B stee_block_pkt stee_block_B stee_rx_pkt stee_rx_B stee_tx_pkt stee_tx_B
miss_sess_P miss_sess_B err_bypass_P err_bypass_B err_block_P err_block_B sf_active sf_inactive
sum 0 0 0 0 0 0 0 0
speed/s 0 0 0 0 0 0 0 0
miss_sess_pkt miss_sess_B err_bypass_pkt err_bypass_B err_block_pkt err_block_B endp_drop_pkt endp_drop_B
sum 0 0 0 0 0 0 0 0
speed/s 0 0 0 0 0 0 0 0
ctrl_rx_pkt ctrl_rx_B ctrl_tx_pkt ctrl_tx_B ctrl_opening ctrl_active ctrl_closing ctrl_resetall
ctrl_rx_P ctrl_rx_B ctrl_tx_P ctrl_tx_B ctrl_opening ctrl_active ctrl_closing ctrl_resetall
sum 1 147 1 147 0 1 0 0
speed/s 0 0 0 0 0 0 0 0
ctrl_error session_num session_logs sf_active sf_inactive
sum 0 1 0 0 0
speed/s 0 0 0 0 0
ctrl_error curr_sessions session_logs
sum 0 1 0
speed/s 0 0 0
________________________________________________________________________________________________________________________________________________

27
test/test_data/log/test_raw_pkt_stee_forward_ok.fs2 → test/test_data/log/test_data_pkt_stee_forward_ok.fs2
View File

@@ -1,23 +1,26 @@
============================================================Thu Apr 6 09:56:11 2023============================================================
nf_rx_pkt nf_rx_B nf_tx_pkt nf_tx_B endp_rx_pkt endp_rx_B endp_tx_pkt endp_tx_B
sum 2 292 1 147 0 0 1 195
============================================================Wed Oct 18 09:10:46 2023============================================================
dev_nf_rx_P dev_nf_rx_B dev_nf_tx_P dev_nf_tx_B kee_d_rx_P kee_d_rx_B kee_d_tx_P kee_d_tx_B
sum 2 292 1 147 0 0 0 0
speed/s 0 0 0 0 0 0 0 0
kee_d_rx_pkt kee_d_rx_B kee_d_tx_pkt kee_d_tx_B kee_u_rx_pkt kee_u_rx_B kee_u_rxdop_pkt kee_u_rxdop_B
dev_l3_rx_P dev_l3_rx_B dev_l3_tx_P dev_l3_tx_B kee_u_rx_P kee_u_rx_B kee_u_rxdop_P kee_u_rxdop_B
sum 0 0 1 195 0 0 0 0
speed/s 0 0 0 0 0 0 0 0
dev_l2_rx_P dev_l2_rx_B dev_l2_tx_P dev_l2_tx_B dev_l3_dop_P dev_l3_dop_B dev_l2_dop_P dev_l2_dop_B
sum 0 0 0 0 0 0 0 0
speed/s 0 0 0 0 0 0 0 0
mirr_bypass_pkt mirr_bypass_B mirr_block_pkt mirr_block_B mirr_rxdop_pkt mirr_rxdop_B mirro_tx_pkt mirro_tx_B
mirr_bypass_P mirr_bypass_B mirr_block_P mirr_block_B mirr_rxdop_P mirr_rxdop_B mirro_tx_P mirro_tx_B
sum 0 0 0 0 0 0 0 0
speed/s 0 0 0 0 0 0 0 0
stee_bypass_pkt stee_bypass_B stee_block_pkt stee_block_B stee_rx_pkt stee_rx_B stee_tx_pkt stee_tx_B
stee_bypass_P stee_bypass_B stee_block_P stee_block_B stee_rx_P stee_rx_B stee_tx_P stee_tx_B
sum 0 0 0 0 0 0 1 145
speed/s 0 0 0 0 0 0 0 0
miss_sess_pkt miss_sess_B err_bypass_pkt err_bypass_B err_block_pkt err_block_B endp_drop_pkt endp_drop_B
sum 0 0 0 0 0 0 0 0
miss_sess_P miss_sess_B err_bypass_P err_bypass_B err_block_P err_block_B sf_active sf_inactive
sum 0 0 0 0 0 0 1 0
speed/s 0 0 0 0 0 0 0 0
ctrl_rx_pkt ctrl_rx_B ctrl_tx_pkt ctrl_tx_B ctrl_opening ctrl_active ctrl_closing ctrl_resetall
ctrl_rx_P ctrl_rx_B ctrl_tx_P ctrl_tx_B ctrl_opening ctrl_active ctrl_closing ctrl_resetall
sum 1 147 1 147 0 1 0 0
speed/s 0 0 0 0 0 0 0 0
ctrl_error session_num session_logs sf_active sf_inactive
sum 0 1 0 1 0
speed/s 0 0 0 0 0
ctrl_error curr_sessions session_logs
sum 0 1 0
speed/s 0 0 0
________________________________________________________________________________________________________________________________________________

26
test/test_data/log/test_data_pkt_stee_rx_egress_ok.fs2 Normal file
View File

@@ -0,0 +1,26 @@
============================================================Wed Oct 18 09:12:31 2023============================================================
dev_nf_rx_P dev_nf_rx_B dev_nf_tx_P dev_nf_tx_B kee_d_rx_P kee_d_rx_B kee_d_tx_P kee_d_tx_B
sum 2 292 2 292 0 0 0 0
speed/s 0 0 0 0 0 0 0 0
dev_l3_rx_P dev_l3_rx_B dev_l3_tx_P dev_l3_tx_B kee_u_rx_P kee_u_rx_B kee_u_rxdop_P kee_u_rxdop_B
sum 1 195 1 195 0 0 0 0
speed/s 0 0 0 0 0 0 0 0
dev_l2_rx_P dev_l2_rx_B dev_l2_tx_P dev_l2_tx_B dev_l3_dop_P dev_l3_dop_B dev_l2_dop_P dev_l2_dop_B
sum 0 0 0 0 0 0 0 0
speed/s 0 0 0 0 0 0 0 0
mirr_bypass_P mirr_bypass_B mirr_block_P mirr_block_B mirr_rxdop_P mirr_rxdop_B mirro_tx_P mirro_tx_B
sum 0 0 0 0 0 0 0 0
speed/s 0 0 0 0 0 0 0 0
stee_bypass_P stee_bypass_B stee_block_P stee_block_B stee_rx_P stee_rx_B stee_tx_P stee_tx_B
sum 0 0 0 0 1 145 1 145
speed/s 0 0 0 0 0 0 0 0
miss_sess_P miss_sess_B err_bypass_P err_bypass_B err_block_P err_block_B sf_active sf_inactive
sum 0 0 0 0 0 0 1 0
speed/s 0 0 0 0 0 0 0 0
ctrl_rx_P ctrl_rx_B ctrl_tx_P ctrl_tx_B ctrl_opening ctrl_active ctrl_closing ctrl_resetall
sum 1 147 1 147 0 1 0 0
speed/s 0 0 0 0 0 0 0 0
ctrl_error curr_sessions session_logs
sum 0 1 0
speed/s 0 0 0
________________________________________________________________________________________________________________________________________________

27
test/test_data/log/test_mix_pkt_stee_forward_ok.fs2
View File

@@ -1,23 +1,26 @@
============================================================Fri May 5 11:08:21 2023============================================================
nf_rx_pkt nf_rx_B nf_tx_pkt nf_tx_B endp_rx_pkt endp_rx_B endp_tx_pkt endp_tx_B
sum 4 584 2 294 0 0 2 390
============================================================Wed Oct 18 08:53:58 2023============================================================
dev_nf_rx_P dev_nf_rx_B dev_nf_tx_P dev_nf_tx_B kee_d_rx_P kee_d_rx_B kee_d_tx_P kee_d_tx_B
sum 4 584 2 294 0 0 0 0
speed/s 0 0 0 0 0 0 0 0
kee_d_rx_pkt kee_d_rx_B kee_d_tx_pkt kee_d_tx_B kee_u_rx_pkt kee_u_rx_B kee_u_rxdop_pkt kee_u_rxdop_B
dev_l3_rx_P dev_l3_rx_B dev_l3_tx_P dev_l3_tx_B kee_u_rx_P kee_u_rx_B kee_u_rxdop_P kee_u_rxdop_B
sum 0 0 2 390 0 0 0 0
speed/s 0 0 0 0 0 0 0 0
dev_l2_rx_P dev_l2_rx_B dev_l2_tx_P dev_l2_tx_B dev_l3_dop_P dev_l3_dop_B dev_l2_dop_P dev_l2_dop_B
sum 0 0 0 0 0 0 0 0
speed/s 0 0 0 0 0 0 0 0
mirr_bypass_pkt mirr_bypass_B mirr_block_pkt mirr_block_B mirr_rxdop_pkt mirr_rxdop_B mirro_tx_pkt mirro_tx_B
mirr_bypass_P mirr_bypass_B mirr_block_P mirr_block_B mirr_rxdop_P mirr_rxdop_B mirro_tx_P mirro_tx_B
sum 0 0 0 0 0 0 0 0
speed/s 0 0 0 0 0 0 0 0
stee_bypass_pkt stee_bypass_B stee_block_pkt stee_block_B stee_rx_pkt stee_rx_B stee_tx_pkt stee_tx_B
stee_bypass_P stee_bypass_B stee_block_P stee_block_B stee_rx_P stee_rx_B stee_tx_P stee_tx_B
sum 0 0 0 0 0 0 2 290
speed/s 0 0 0 0 0 0 0 0
miss_sess_pkt miss_sess_B err_bypass_pkt err_bypass_B err_block_pkt err_block_B endp_drop_pkt endp_drop_B
sum 0 0 0 0 0 0 0 0
miss_sess_P miss_sess_B err_bypass_P err_bypass_B err_block_P err_block_B sf_active sf_inactive
sum 0 0 0 0 0 0 2 0
speed/s 0 0 0 0 0 0 0 0
ctrl_rx_pkt ctrl_rx_B ctrl_tx_pkt ctrl_tx_B ctrl_opening ctrl_active ctrl_closing ctrl_resetall
ctrl_rx_P ctrl_rx_B ctrl_tx_P ctrl_tx_B ctrl_opening ctrl_active ctrl_closing ctrl_resetall
sum 2 294 2 294 0 2 0 0
speed/s 0 0 0 0 0 0 0 0
ctrl_error session_num session_logs sf_active sf_inactive
sum 0 1 0 2 0
speed/s 0 0 0 0 0
ctrl_error curr_sessions session_logs
sum 0 1 0
speed/s 0 0 0
________________________________________________________________________________________________________________________________________________

23
test/test_data/log/test_raw_pkt_mirr_rx_drop_ok.fs2
View File

@@ -1,23 +0,0 @@
============================================================Wed Apr 12 07:27:30 2023============================================================
nf_rx_pkt nf_rx_B nf_tx_pkt nf_tx_B endp_rx_pkt endp_rx_B endp_tx_pkt endp_tx_B
sum 2 292 2 292 1 195 1 195
speed/s 0 0 0 0 0 0 0 0
kee_d_rx_pkt kee_d_rx_B kee_d_tx_pkt kee_d_tx_B kee_u_rx_pkt kee_u_rx_B kee_u_rxdop_pkt kee_u_rxdop_B
sum 0 0 0 0 0 0 0 0
speed/s 0 0 0 0 0 0 0 0
mirr_bypass_pkt mirr_bypass_B mirr_block_pkt mirr_block_B mirr_rxdop_pkt mirr_rxdop_B mirro_tx_pkt mirro_tx_B
sum 0 0 0 0 1 145 1 145
speed/s 0 0 0 0 0 0 0 0
stee_bypass_pkt stee_bypass_B stee_block_pkt stee_block_B stee_rx_pkt stee_rx_B stee_tx_pkt stee_tx_B
sum 0 0 0 0 0 0 0 0
speed/s 0 0 0 0 0 0 0 0
miss_sess_pkt miss_sess_B err_bypass_pkt err_bypass_B err_block_pkt err_block_B endp_drop_pkt endp_drop_B
sum 0 0 0 0 1 145 1 195
speed/s 0 0 0 0 0 0 0 0
ctrl_rx_pkt ctrl_rx_B ctrl_tx_pkt ctrl_tx_B ctrl_opening ctrl_active ctrl_closing ctrl_resetall
sum 1 147 1 147 0 1 0 0
speed/s 0 0 0 0 0 0 0 0
ctrl_error session_num session_logs sf_active sf_inactive
sum 0 1 0 1 0
speed/s 0 0 0 0 0
________________________________________________________________________________________________________________________________________________

23
test/test_data/log/test_raw_pkt_stee_rx_egress_ok.fs2
View File

@@ -1,23 +0,0 @@
============================================================Fri Apr 7 10:51:51 2023============================================================
nf_rx_pkt nf_rx_B nf_tx_pkt nf_tx_B endp_rx_pkt endp_rx_B endp_tx_pkt endp_tx_B
sum 2 292 2 292 1 195 1 195
speed/s 0 0 0 0 0 0 0 0
kee_d_rx_pkt kee_d_rx_B kee_d_tx_pkt kee_d_tx_B kee_u_rx_pkt kee_u_rx_B kee_u_rxdop_pkt kee_u_rxdop_B
sum 0 0 0 0 0 0 0 0
speed/s 0 0 0 0 0 0 0 0
mirr_bypass_pkt mirr_bypass_B mirr_block_pkt mirr_block_B mirr_rxdop_pkt mirr_rxdop_B mirro_tx_pkt mirro_tx_B
sum 0 0 0 0 0 0 0 0
speed/s 0 0 0 0 0 0 0 0
stee_bypass_pkt stee_bypass_B stee_block_pkt stee_block_B stee_rx_pkt stee_rx_B stee_tx_pkt stee_tx_B
sum 0 0 0 0 1 145 1 145
speed/s 0 0 0 0 0 0 0 0
miss_sess_pkt miss_sess_B err_bypass_pkt err_bypass_B err_block_pkt err_block_B endp_drop_pkt endp_drop_B
sum 0 0 0 0 0 0 0 0
speed/s 0 0 0 0 0 0 0 0
ctrl_rx_pkt ctrl_rx_B ctrl_tx_pkt ctrl_tx_B ctrl_opening ctrl_active ctrl_closing ctrl_resetall
sum 1 147 1 147 0 1 0 0
speed/s 0 0 0 0 0 0 0 0
ctrl_error session_num session_logs sf_active sf_inactive
sum 0 1 0 1 0
speed/s 0 0 0 0 0
________________________________________________________________________________________________________________________________________________

0
test/test_data/resource/raw_pkt_mirr_block.json → test/test_data/resource/data_pkt_mirr_block.json
View File

0
test/test_data/resource/raw_pkt_mirr_bypass.json → test/test_data/resource/data_pkt_mirr_bypass.json
View File

0
test/test_data/resource/raw_pkt_mirr_forward.json → test/test_data/resource/data_pkt_mirr_forward.json
View File

0
test/test_data/resource/raw_pkt_stee_block.json → test/test_data/resource/data_pkt_stee_block.json
View File

0
test/test_data/resource/raw_pkt_stee_bypass.json → test/test_data/resource/data_pkt_stee_bypass.json
View File

0
test/test_data/resource/raw_pkt_stee_forward.json → test/test_data/resource/data_pkt_stee_forward.json
View File