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

rename ip_reassemble -> ip_reassembly

Browse Source
This commit is contained in:
luwenpeng
2024-03-08 13:55:17 +08:00
parent d7370e0e19
commit 9d562ffee6
15 changed files with 297 additions and 297 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
conf/stellar.toml
View File

@@ -11,7 +11,7 @@ dev_symbol = nf_0_fw
nr_threads = 1 # [1, 256] nr_threads = 1 # [1, 256]
cpu_mask = [5, 6, 7, 8, 9, 10, 11, 12] cpu_mask = [5, 6, 7, 8, 9, 10, 11, 12]
[ip_reassemble] [ip_reassembly]
enable = 1 enable = 1
timeout = 10 # seconds timeout = 10 # seconds
bucket_entries = 8 bucket_entries = 8

2
src/CMakeLists.txt
View File

@@ -5,7 +5,7 @@ add_subdirectory(tuple)
add_subdirectory(packet) add_subdirectory(packet)
add_subdirectory(packet_io) add_subdirectory(packet_io)
add_subdirectory(id_generator) add_subdirectory(id_generator)
add_subdirectory(ip_reassemble) add_subdirectory(ip_reassembly)
add_subdirectory(dupkt_filter) add_subdirectory(dupkt_filter)
add_subdirectory(eviction_filter) add_subdirectory(eviction_filter)
add_subdirectory(session) add_subdirectory(session)

2
src/config/CMakeLists.txt
View File

@@ -4,4 +4,4 @@
add_library(config config.cpp) add_library(config config.cpp)
target_include_directories(config PUBLIC ${CMAKE_CURRENT_LIST_DIR}) target_include_directories(config PUBLIC ${CMAKE_CURRENT_LIST_DIR})
target_link_libraries(config toml packet_io ip_reassemble session_manager) target_link_libraries(config toml packet_io ip_reassembly session_manager)

26
src/config/config.cpp
View File

@@ -138,22 +138,22 @@ static int parse_packet_io_config(struct packet_io_config *pkt_io_cfg, toml_tabl
// return 0: success // return 0: success
// retuun -1: failed // retuun -1: failed
static int parse_ip_reassemble_config(struct ip_reassemble_config *ip_reass_cfg, toml_table_t *conf_file_handle) static int parse_ip_reassembly_config(struct ip_reassembly_config *ip_reass_cfg, toml_table_t *conf_file_handle)
{ {
const char *ptr; const char *ptr;
toml_table_t *ip_reass_table; toml_table_t *ip_reass_table;
ip_reass_table = toml_table_in(conf_file_handle, "ip_reassemble"); ip_reass_table = toml_table_in(conf_file_handle, "ip_reassembly");
if (ip_reass_table == NULL) if (ip_reass_table == NULL)
{ {
CONFIG_LOG_ERROR("config file missing ip_reassemble section"); CONFIG_LOG_ERROR("config file missing ip_reassembly section");
return -1; return -1;
} }
ptr = toml_raw_in(ip_reass_table, "enable"); ptr = toml_raw_in(ip_reass_table, "enable");
if (ptr == NULL) if (ptr == NULL)
{ {
CONFIG_LOG_ERROR("config file missing ip_reassemble.enable"); CONFIG_LOG_ERROR("config file missing ip_reassembly.enable");
return -1; return -1;
} }
ip_reass_cfg->enable = atoi(ptr); ip_reass_cfg->enable = atoi(ptr);
@@ -161,7 +161,7 @@ static int parse_ip_reassemble_config(struct ip_reassemble_config *ip_reass_cfg,
ptr = toml_raw_in(ip_reass_table, "timeout"); ptr = toml_raw_in(ip_reass_table, "timeout");
if (ptr == NULL) if (ptr == NULL)
{ {
CONFIG_LOG_ERROR("config file missing ip_reassemble.timeout"); CONFIG_LOG_ERROR("config file missing ip_reassembly.timeout");
return -1; return -1;
} }
ip_reass_cfg->timeout = atoi(ptr); ip_reass_cfg->timeout = atoi(ptr);
@@ -169,7 +169,7 @@ static int parse_ip_reassemble_config(struct ip_reassemble_config *ip_reass_cfg,
ptr = toml_raw_in(ip_reass_table, "bucket_entries"); ptr = toml_raw_in(ip_reass_table, "bucket_entries");
if (ptr == NULL) if (ptr == NULL)
{ {
CONFIG_LOG_ERROR("config file missing ip_reassemble.bucket_entries"); CONFIG_LOG_ERROR("config file missing ip_reassembly.bucket_entries");
return -1; return -1;
} }
ip_reass_cfg->bucket_entries = atoi(ptr); ip_reass_cfg->bucket_entries = atoi(ptr);
@@ -177,7 +177,7 @@ static int parse_ip_reassemble_config(struct ip_reassemble_config *ip_reass_cfg,
ptr = toml_raw_in(ip_reass_table, "bucket_num"); ptr = toml_raw_in(ip_reass_table, "bucket_num");
if (ptr == NULL) if (ptr == NULL)
{ {
CONFIG_LOG_ERROR("config file missing ip_reassemble.bucket_num"); CONFIG_LOG_ERROR("config file missing ip_reassembly.bucket_num");
return -1; return -1;
} }
ip_reass_cfg->bucket_num = atoi(ptr); ip_reass_cfg->bucket_num = atoi(ptr);
@@ -395,7 +395,7 @@ int config_load(struct config *cfg, const char *cfg_file)
goto error_out; goto error_out;
} }
if (parse_ip_reassemble_config(&cfg->ip_reass_cfg, conf_file_handle) != 0) if (parse_ip_reassembly_config(&cfg->ip_reass_cfg, conf_file_handle) != 0)
{ {
goto error_out; goto error_out;
} }
@@ -430,7 +430,7 @@ void config_dump(struct config *cfg)
struct device_config *dev_cfg = &cfg->dev_cfg; struct device_config *dev_cfg = &cfg->dev_cfg;
struct packet_io_config *pkt_io_cfg = &cfg->pkt_io_cfg; struct packet_io_config *pkt_io_cfg = &cfg->pkt_io_cfg;
struct ip_reassemble_config *ip_reass_cfg = &cfg->ip_reass_cfg; struct ip_reassembly_config *ip_reass_cfg = &cfg->ip_reass_cfg;
struct session_manager_config *sess_mgr_cfg = &cfg->sess_mgr_cfg; struct session_manager_config *sess_mgr_cfg = &cfg->sess_mgr_cfg;
// device config // device config
@@ -455,10 +455,10 @@ void config_dump(struct config *cfg)
} }
// ip reassemble config // ip reassemble config
CONFIG_LOG_DEBUG("ip_reassemble->enable : %d", ip_reass_cfg->enable); CONFIG_LOG_DEBUG("ip_reassembly->enable : %d", ip_reass_cfg->enable);
CONFIG_LOG_DEBUG("ip_reassemble->timeout : %d", ip_reass_cfg->timeout); CONFIG_LOG_DEBUG("ip_reassembly->timeout : %d", ip_reass_cfg->timeout);
CONFIG_LOG_DEBUG("ip_reassemble->bucket_entries : %d", ip_reass_cfg->bucket_entries); CONFIG_LOG_DEBUG("ip_reassembly->bucket_entries : %d", ip_reass_cfg->bucket_entries);
CONFIG_LOG_DEBUG("ip_reassemble->bucket_num : %d", ip_reass_cfg->bucket_num); CONFIG_LOG_DEBUG("ip_reassembly->bucket_num : %d", ip_reass_cfg->bucket_num);
// session manager config // session manager config
CONFIG_LOG_DEBUG("session_manager->max_tcp_session_num : %ld", sess_mgr_cfg->max_tcp_session_num); CONFIG_LOG_DEBUG("session_manager->max_tcp_session_num : %ld", sess_mgr_cfg->max_tcp_session_num);

4
src/config/config.h
View File

@@ -8,7 +8,7 @@ extern "C"
#include "stellar.h" #include "stellar.h"
#include "packet_io.h" #include "packet_io.h"
#include "ip_reassemble.h" #include "ip_reassembly.h"
#include "session_manager.h" #include "session_manager.h"
#define CONFIG_LOG_ERROR(format, ...) LOG_ERROR("config", format, ##__VA_ARGS__) #define CONFIG_LOG_ERROR(format, ...) LOG_ERROR("config", format, ##__VA_ARGS__)
@@ -32,7 +32,7 @@ struct config
{ {
struct device_config dev_cfg; struct device_config dev_cfg;
struct packet_io_config pkt_io_cfg; struct packet_io_config pkt_io_cfg;
struct ip_reassemble_config ip_reass_cfg; struct ip_reassembly_config ip_reass_cfg;
struct session_manager_config sess_mgr_cfg; struct session_manager_config sess_mgr_cfg;
}; };

17
src/ip_reassemble/test/CMakeLists.txt
View File

@@ -1,17 +0,0 @@
###############################################################################
# gtest
###############################################################################
add_executable(gtest_ipv4_reassemble gtest_ipv4_reassemble.cpp)
target_link_libraries(gtest_ipv4_reassemble ip_reassemble gtest)
add_executable(gtest_ipv6_reassemble gtest_ipv6_reassemble.cpp)
target_link_libraries(gtest_ipv6_reassemble ip_reassemble gtest)
add_executable(gtest_ip_reassemble gtest_ip_reassemble.cpp)
target_link_libraries(gtest_ip_reassemble ip_reassemble gtest)
include(GoogleTest)
gtest_discover_tests(gtest_ipv4_reassemble)
gtest_discover_tests(gtest_ipv6_reassemble)
gtest_discover_tests(gtest_ip_reassemble)

8
src/ip_reassemble/CMakeLists.txt → src/ip_reassembly/CMakeLists.txt
View File

@@ -1,9 +1,9 @@
############################################################################### ###############################################################################
# ip_reassemble # ip_reassembly
############################################################################### ###############################################################################
add_library(ip_reassemble ip_reassemble.cpp) add_library(ip_reassembly ip_reassembly.cpp)
target_include_directories(ip_reassemble PUBLIC ${CMAKE_CURRENT_LIST_DIR}) target_include_directories(ip_reassembly PUBLIC ${CMAKE_CURRENT_LIST_DIR})
target_link_libraries(ip_reassemble timestamp packet) target_link_libraries(ip_reassembly timestamp packet)
add_subdirectory(test) add_subdirectory(test)

102
src/ip_reassemble/ip_reassemble.cpp → src/ip_reassembly/ip_reassembly.cpp
View File

@@ -10,7 +10,7 @@
#include "ipv4_utils.h" #include "ipv4_utils.h"
#include "ipv6_utils.h" #include "ipv6_utils.h"
#include "packet_utils.h" #include "packet_utils.h"
#include "ip_reassemble.h" #include "ip_reassembly.h"
#define IPV4_KEYLEN 1 #define IPV4_KEYLEN 1
#define IPV6_KEYLEN 4 #define IPV6_KEYLEN 4
@@ -108,7 +108,7 @@ struct ip_flow
struct ip_frag_pkt frags[IP_MAX_FRAG_NUM]; // first two entries in the frags[] array are for the last and first fragments. struct ip_frag_pkt frags[IP_MAX_FRAG_NUM]; // first two entries in the frags[] array are for the last and first fragments.
}; };
struct ip_reassemble_manager struct ip_reassembly
{ {
// config // config
bool enable; bool enable;
@@ -122,7 +122,7 @@ struct ip_reassemble_manager
uint32_t entry_mask; uint32_t entry_mask;
// stats // stats
struct ip_reassemble_stat stat; struct ip_reassembly_stat stat;
// hash table // hash table
struct struct
@@ -138,7 +138,7 @@ struct ip_reassemble_manager
* utils * utils
******************************************************************************/ ******************************************************************************/
#define ip_reassemble_stat_inc(mgr, filed, key) \ #define ip_reassembly_stat_inc(mgr, filed, key) \
{ \ { \
if ((key)->src_dst_len == IPV4_KEYLEN) \ if ((key)->src_dst_len == IPV4_KEYLEN) \
{ \ { \
@@ -189,7 +189,7 @@ static inline int is_power_of_2(uint32_t n)
return n && !(n & (n - 1)); return n && !(n & (n - 1));
} }
static inline int ip_reassemble_check_config(const struct ip_reassemble_config *config) static inline int ip_reassembly_check_config(const struct ip_reassembly_config *config)
{ {
if (config == NULL) if (config == NULL)
{ {
@@ -404,7 +404,7 @@ static inline int ip_flow_is_ready(struct ip_flow *flow)
// return 0 : success // return 0 : success
// return -1 : failed // return -1 : failed
static inline int ip_flow_update(struct ip_reassemble_manager *mgr, static inline int ip_flow_update(struct ip_reassembly *mgr,
struct ip_flow *flow, const struct packet *pkt, struct ip_flow *flow, const struct packet *pkt,
char *frag_data, uint16_t frag_len, uint16_t frag_offset, bool more_frags) char *frag_data, uint16_t frag_len, uint16_t frag_offset, bool more_frags)
{ {
@@ -426,7 +426,7 @@ static inline int ip_flow_update(struct ip_reassemble_manager *mgr,
if (flow->frags[IP_FIRST_FRAG_IDX].data != NULL) if (flow->frags[IP_FIRST_FRAG_IDX].data != NULL)
{ {
IP_REASSEMBLE_DEBUG1("duplicate first fragment bypass", &flow->key); IP_REASSEMBLE_DEBUG1("duplicate first fragment bypass", &flow->key);
ip_reassemble_stat_inc(mgr, bypass_dup_fist_frag, &flow->key); ip_reassembly_stat_inc(mgr, bypass_dup_fist_frag, &flow->key);
return 0; return 0;
} }
idx = IP_FIRST_FRAG_IDX; idx = IP_FIRST_FRAG_IDX;
@@ -437,7 +437,7 @@ static inline int ip_flow_update(struct ip_reassemble_manager *mgr,
if (flow->frags[IP_LAST_FRAG_IDX].data != NULL) if (flow->frags[IP_LAST_FRAG_IDX].data != NULL)
{ {
IP_REASSEMBLE_DEBUG1("duplicate last fragment bypass", &flow->key); IP_REASSEMBLE_DEBUG1("duplicate last fragment bypass", &flow->key);
ip_reassemble_stat_inc(mgr, bypass_dup_last_frag, &flow->key); ip_reassembly_stat_inc(mgr, bypass_dup_last_frag, &flow->key);
return 0; return 0;
} }
idx = IP_LAST_FRAG_IDX; idx = IP_LAST_FRAG_IDX;
@@ -448,7 +448,7 @@ static inline int ip_flow_update(struct ip_reassemble_manager *mgr,
if (flow->next_fill_idx >= IP_MAX_FRAG_NUM) if (flow->next_fill_idx >= IP_MAX_FRAG_NUM)
{ {
IP_REASSEMBLE_ERROR1("max number of fragment exceeded", &flow->key); IP_REASSEMBLE_ERROR1("max number of fragment exceeded", &flow->key);
ip_reassemble_stat_inc(mgr, fail_many_frag, &flow->key); ip_reassembly_stat_inc(mgr, fail_many_frag, &flow->key);
return -1; return -1;
} }
idx = flow->next_fill_idx; idx = flow->next_fill_idx;
@@ -466,26 +466,26 @@ static inline int ip_flow_update(struct ip_reassemble_manager *mgr,
* ip reassemble manager add/del/reuse/find/update flow * ip reassemble manager add/del/reuse/find/update flow
******************************************************************************/ ******************************************************************************/
static inline void ip_reassemble_manager_add_flow(struct ip_reassemble_manager *mgr, struct ip_flow *flow) static inline void ip_reassembly_add_flow(struct ip_reassembly *mgr, struct ip_flow *flow)
{ {
ip_reassemble_stat_inc(mgr, add, &flow->key); ip_reassembly_stat_inc(mgr, add, &flow->key);
TAILQ_INSERT_TAIL(&mgr->lru, flow, lru); TAILQ_INSERT_TAIL(&mgr->lru, flow, lru);
mgr->entry_used++; mgr->entry_used++;
} }
static inline void ip_reassemble_manager_del_flow(struct ip_reassemble_manager *mgr, struct ip_flow *flow) static inline void ip_reassembly_del_flow(struct ip_reassembly *mgr, struct ip_flow *flow)
{ {
ip_reassemble_stat_inc(mgr, del, &flow->key); ip_reassembly_stat_inc(mgr, del, &flow->key);
TAILQ_REMOVE(&mgr->lru, flow, lru); TAILQ_REMOVE(&mgr->lru, flow, lru);
mgr->entry_used--; mgr->entry_used--;
} }
static inline void ip_reassemble_manager_reuse_flow(struct ip_reassemble_manager *mgr, struct ip_flow *flow, const struct ip_flow_key *key) static inline void ip_reassembly_reuse_flow(struct ip_reassembly *mgr, struct ip_flow *flow, const struct ip_flow_key *key)
{ {
ip_reassemble_manager_del_flow(mgr, flow); ip_reassembly_del_flow(mgr, flow);
ip_flow_free(flow); ip_flow_free(flow);
ip_flow_init(flow, key); ip_flow_init(flow, key);
ip_reassemble_manager_add_flow(mgr, flow); ip_reassembly_add_flow(mgr, flow);
} }
/* /*
@@ -493,9 +493,9 @@ static inline void ip_reassemble_manager_reuse_flow(struct ip_reassemble_manager
* free : the first empty entry in the bucket * free : the first empty entry in the bucket
* expired: the first timed-out entry in the bucket * expired: the first timed-out entry in the bucket
*/ */
static struct ip_flow *ip_reassemble_manager_find_flow(struct ip_reassemble_manager *mgr, const struct ip_flow_key *key, struct ip_flow **free, struct ip_flow **expired) static struct ip_flow *ip_reassembly_find_flow(struct ip_reassembly *mgr, const struct ip_flow_key *key, struct ip_flow **free, struct ip_flow **expired)
{ {
ip_reassemble_stat_inc(mgr, find, key); ip_reassembly_stat_inc(mgr, find, key);
if (mgr->last != NULL && ip_flow_key_cmp(key, &mgr->last->key) == 0) if (mgr->last != NULL && ip_flow_key_cmp(key, &mgr->last->key) == 0)
{ {
@@ -561,20 +561,20 @@ static struct ip_flow *ip_reassemble_manager_find_flow(struct ip_reassemble_mana
return NULL; return NULL;
} }
static struct ip_flow *ip_reassemble_manager_update_flow(struct ip_reassemble_manager *mgr, const struct ip_flow_key *key) static struct ip_flow *ip_reassembly_update_flow(struct ip_reassembly *mgr, const struct ip_flow_key *key)
{ {
struct ip_flow *flow = NULL; struct ip_flow *flow = NULL;
struct ip_flow *free = NULL; struct ip_flow *free = NULL;
struct ip_flow *expired = NULL; struct ip_flow *expired = NULL;
flow = ip_reassemble_manager_find_flow(mgr, key, &free, &expired); flow = ip_reassembly_find_flow(mgr, key, &free, &expired);
if (flow == NULL) if (flow == NULL)
{ {
if (expired) if (expired)
{ {
IP_REASSEMBLE_DEBUG1("add ip flow success: reuse expired entry", key); IP_REASSEMBLE_DEBUG1("add ip flow success: reuse expired entry", key);
ip_reassemble_manager_reuse_flow(mgr, expired, key); ip_reassembly_reuse_flow(mgr, expired, key);
ip_reassemble_stat_inc(mgr, timeout, key); ip_reassembly_stat_inc(mgr, timeout, key);
mgr->last = expired; mgr->last = expired;
return expired; return expired;
@@ -584,7 +584,7 @@ static struct ip_flow *ip_reassemble_manager_update_flow(struct ip_reassemble_ma
{ {
IP_REASSEMBLE_DEBUG1("add ip flow success: use free entry", key); IP_REASSEMBLE_DEBUG1("add ip flow success: use free entry", key);
ip_flow_init(free, key); ip_flow_init(free, key);
ip_reassemble_manager_add_flow(mgr, free); ip_reassembly_add_flow(mgr, free);
mgr->last = free; mgr->last = free;
return free; return free;
@@ -592,7 +592,7 @@ static struct ip_flow *ip_reassemble_manager_update_flow(struct ip_reassemble_ma
// no space // no space
IP_REASSEMBLE_ERROR1("add ip flow failed: bucket full", key); IP_REASSEMBLE_ERROR1("add ip flow failed: bucket full", key);
ip_reassemble_stat_inc(mgr, fail_no_space, key); ip_reassembly_stat_inc(mgr, fail_no_space, key);
return NULL; return NULL;
} }
else else
@@ -601,8 +601,8 @@ static struct ip_flow *ip_reassemble_manager_update_flow(struct ip_reassemble_ma
if (mgr->timeout + flow->create_time <= timestamp_get_sec()) if (mgr->timeout + flow->create_time <= timestamp_get_sec())
{ {
IP_REASSEMBLE_DEBUG1("add ip flow success: reuse expired entry", key); IP_REASSEMBLE_DEBUG1("add ip flow success: reuse expired entry", key);
ip_reassemble_manager_reuse_flow(mgr, flow, key); ip_reassembly_reuse_flow(mgr, flow, key);
ip_reassemble_stat_inc(mgr, timeout, key); ip_reassembly_stat_inc(mgr, timeout, key);
mgr->last = flow; mgr->last = flow;
return flow; return flow;
@@ -622,7 +622,7 @@ static struct ip_flow *ip_reassemble_manager_update_flow(struct ip_reassemble_ma
* frag reassemble * frag reassemble
******************************************************************************/ ******************************************************************************/
static struct packet *ip_frag_reassemble(struct ip_reassemble_manager *mgr, struct ip_flow *flow) static struct packet *ip_frag_reassemble(struct ip_reassembly *mgr, struct ip_flow *flow)
{ {
struct ip_frag_pkt *first = &flow->frags[IP_FIRST_FRAG_IDX]; struct ip_frag_pkt *first = &flow->frags[IP_FIRST_FRAG_IDX];
struct ip_frag_pkt *last = &flow->frags[IP_LAST_FRAG_IDX]; struct ip_frag_pkt *last = &flow->frags[IP_LAST_FRAG_IDX];
@@ -738,12 +738,12 @@ static struct packet *ip_frag_reassemble(struct ip_reassemble_manager *mgr, stru
return pkt; return pkt;
error_out_invalid_length: error_out_invalid_length:
ip_reassemble_stat_inc(mgr, fail_invalid_length, &flow->key); ip_reassembly_stat_inc(mgr, fail_invalid_length, &flow->key);
packet_free(pkt); packet_free(pkt);
return NULL; return NULL;
error_out_overlap: error_out_overlap:
ip_reassemble_stat_inc(mgr, fail_overlap, &flow->key); ip_reassembly_stat_inc(mgr, fail_overlap, &flow->key);
packet_free(pkt); packet_free(pkt);
return NULL; return NULL;
} }
@@ -752,14 +752,14 @@ error_out_overlap:
* Public API * Public API
******************************************************************************/ ******************************************************************************/
struct ip_reassemble_manager *ip_reassemble_manager_create(const struct ip_reassemble_config *config) struct ip_reassembly *ip_reassembly_create(const struct ip_reassembly_config *config)
{ {
if (ip_reassemble_check_config(config) != 0) if (ip_reassembly_check_config(config) != 0)
{ {
return NULL; return NULL;
} }
struct ip_reassemble_manager *mgr = (struct ip_reassemble_manager *)calloc(1, sizeof(struct ip_reassemble_manager)); struct ip_reassembly *mgr = (struct ip_reassembly *)calloc(1, sizeof(struct ip_reassembly));
if (mgr == NULL) if (mgr == NULL)
{ {
IP_REASSEMBLE_ERROR("unable to allocate memory"); IP_REASSEMBLE_ERROR("unable to allocate memory");
@@ -798,7 +798,7 @@ struct ip_reassemble_manager *ip_reassemble_manager_create(const struct ip_reass
return mgr; return mgr;
} }
void ip_reassemble_manager_destory(struct ip_reassemble_manager *mgr) void ip_reassembly_destory(struct ip_reassembly *mgr)
{ {
if (mgr) if (mgr)
{ {
@@ -817,7 +817,7 @@ void ip_reassemble_manager_destory(struct ip_reassemble_manager *mgr)
} }
} }
void ip_reassemble_manager_expire(struct ip_reassemble_manager *mgr) void ip_reassembly_expire(struct ip_reassembly *mgr)
{ {
struct ip_flow *flow = NULL; struct ip_flow *flow = NULL;
uint64_t curr_ts = timestamp_get_sec(); uint64_t curr_ts = timestamp_get_sec();
@@ -827,13 +827,13 @@ void ip_reassemble_manager_expire(struct ip_reassemble_manager *mgr)
if (timeout + flow->create_time <= curr_ts) if (timeout + flow->create_time <= curr_ts)
{ {
IP_REASSEMBLE_DEBUG1("expire ip flow: discarding old fragmented packets", &flow->key); IP_REASSEMBLE_DEBUG1("expire ip flow: discarding old fragmented packets", &flow->key);
ip_reassemble_manager_del_flow(mgr, flow); ip_reassembly_del_flow(mgr, flow);
ip_reassemble_stat_inc(mgr, timeout, &flow->key); ip_reassembly_stat_inc(mgr, timeout, &flow->key);
ip_flow_free(flow); ip_flow_free(flow);
} }
} }
void ip_reassemble_manager_print_stat(struct ip_reassemble_manager *mgr) void ip_reassembly_print_stat(struct ip_reassembly *mgr)
{ {
if (mgr) if (mgr)
{ {
@@ -861,7 +861,7 @@ void ip_reassemble_manager_print_stat(struct ip_reassemble_manager *mgr)
} }
} }
struct ip_reassemble_stat *ip_reassemble_manager_get_stat(struct ip_reassemble_manager *mgr) struct ip_reassembly_stat *ip_reassembly_get_stat(struct ip_reassembly *mgr)
{ {
if (mgr) if (mgr)
{ {
@@ -878,7 +878,7 @@ struct ip_reassemble_stat *ip_reassemble_manager_get_stat(struct ip_reassemble_m
* The returned packet should be freed by calling the packet_free() function * The returned packet should be freed by calling the packet_free() function
*/ */
struct packet *ip_reassemble_packet(struct ip_reassemble_manager *mgr, const struct packet *pkt) struct packet *ip_reassembly_packet(struct ip_reassembly *mgr, const struct packet *pkt)
{ {
struct packet *pkt1; struct packet *pkt1;
struct packet *pkt2; struct packet *pkt2;
@@ -896,10 +896,10 @@ struct packet *ip_reassemble_packet(struct ip_reassemble_manager *mgr, const str
if (layer->type == LAYER_TYPE_IPV4) if (layer->type == LAYER_TYPE_IPV4)
{ {
pkt1 = ipv4_reassemble_packet(mgr, pkt); pkt1 = ipv4_reassembly_packet(mgr, pkt);
if (pkt1 && pkt1->frag_layer) if (pkt1 && pkt1->frag_layer)
{ {
pkt2 = ip_reassemble_packet(mgr, pkt1); pkt2 = ip_reassembly_packet(mgr, pkt1);
packet_free(pkt1); packet_free(pkt1);
return pkt2; return pkt2;
} }
@@ -908,10 +908,10 @@ struct packet *ip_reassemble_packet(struct ip_reassemble_manager *mgr, const str
} }
else if (layer->type == LAYER_TYPE_IPV6) else if (layer->type == LAYER_TYPE_IPV6)
{ {
pkt1 = ipv6_reassemble_packet(mgr, pkt); pkt1 = ipv6_reassembly_packet(mgr, pkt);
if (pkt1 && pkt1->frag_layer) if (pkt1 && pkt1->frag_layer)
{ {
pkt2 = ip_reassemble_packet(mgr, pkt1); pkt2 = ip_reassembly_packet(mgr, pkt1);
packet_free(pkt1); packet_free(pkt1);
return pkt2; return pkt2;
} }
@@ -924,7 +924,7 @@ struct packet *ip_reassemble_packet(struct ip_reassemble_manager *mgr, const str
} }
} }
struct packet *ipv4_reassemble_packet(struct ip_reassemble_manager *mgr, const struct packet *pkt) struct packet *ipv4_reassembly_packet(struct ip_reassembly *mgr, const struct packet *pkt)
{ {
const struct layer_record *layer = pkt->frag_layer; const struct layer_record *layer = pkt->frag_layer;
const struct ip *hdr = (const struct ip *)layer->hdr_ptr; const struct ip *hdr = (const struct ip *)layer->hdr_ptr;
@@ -943,7 +943,7 @@ struct packet *ipv4_reassemble_packet(struct ip_reassemble_manager *mgr, const s
key.ip_id = ipv4_hdr_get_ipid(hdr); key.ip_id = ipv4_hdr_get_ipid(hdr);
key.proto = ipv4_hdr_get_proto(hdr); key.proto = ipv4_hdr_get_proto(hdr);
struct ip_flow *flow = ip_reassemble_manager_update_flow(mgr, &key); struct ip_flow *flow = ip_reassembly_update_flow(mgr, &key);
if (flow == NULL) if (flow == NULL)
{ {
return NULL; return NULL;
@@ -954,7 +954,7 @@ struct packet *ipv4_reassemble_packet(struct ip_reassemble_manager *mgr, const s
uint16_t frag_offset = ipv4_hdr_get_frag_offset(hdr); uint16_t frag_offset = ipv4_hdr_get_frag_offset(hdr);
if (ip_flow_update(mgr, flow, pkt, frag_data, frag_len, frag_offset, more_frags) != 0) if (ip_flow_update(mgr, flow, pkt, frag_data, frag_len, frag_offset, more_frags) != 0)
{ {
ip_reassemble_manager_del_flow(mgr, flow); ip_reassembly_del_flow(mgr, flow);
ip_flow_free(flow); ip_flow_free(flow);
return NULL; return NULL;
} }
@@ -965,7 +965,7 @@ struct packet *ipv4_reassemble_packet(struct ip_reassemble_manager *mgr, const s
} }
struct packet *new_pkt = ip_frag_reassemble(mgr, flow); struct packet *new_pkt = ip_frag_reassemble(mgr, flow);
ip_reassemble_manager_del_flow(mgr, flow); ip_reassembly_del_flow(mgr, flow);
ip_flow_free(flow); ip_flow_free(flow);
return new_pkt; return new_pkt;
@@ -1010,7 +1010,7 @@ struct packet *ipv4_reassemble_packet(struct ip_reassemble_manager *mgr, const s
* +-----------------+-----------------+--------+--------+-//-+--------+ * +-----------------+-----------------+--------+--------+-//-+--------+
*/ */
struct packet *ipv6_reassemble_packet(struct ip_reassemble_manager *mgr, const struct packet *pkt) struct packet *ipv6_reassembly_packet(struct ip_reassembly *mgr, const struct packet *pkt)
{ {
const struct layer_record *layer = pkt->frag_layer; const struct layer_record *layer = pkt->frag_layer;
const struct ip6_hdr *hdr = (const struct ip6_hdr *)layer->hdr_ptr; const struct ip6_hdr *hdr = (const struct ip6_hdr *)layer->hdr_ptr;
@@ -1035,7 +1035,7 @@ struct packet *ipv6_reassemble_packet(struct ip_reassemble_manager *mgr, const s
key.ip_id = ipv6_frag_get_ident(frag_hdr); key.ip_id = ipv6_frag_get_ident(frag_hdr);
key.proto = 0; // only first fragment has the upper layer protocol key.proto = 0; // only first fragment has the upper layer protocol
struct ip_flow *flow = ip_reassemble_manager_update_flow(mgr, &key); struct ip_flow *flow = ip_reassembly_update_flow(mgr, &key);
if (flow == NULL) if (flow == NULL)
{ {
return NULL; return NULL;
@@ -1045,7 +1045,7 @@ struct packet *ipv6_reassemble_packet(struct ip_reassemble_manager *mgr, const s
uint16_t frag_offset = ipv6_frag_get_offset(frag_hdr); uint16_t frag_offset = ipv6_frag_get_offset(frag_hdr);
if (ip_flow_update(mgr, flow, pkt, frag_data, frag_len, frag_offset, more_frags) != 0) if (ip_flow_update(mgr, flow, pkt, frag_data, frag_len, frag_offset, more_frags) != 0)
{ {
ip_reassemble_manager_del_flow(mgr, flow); ip_reassembly_del_flow(mgr, flow);
ip_flow_free(flow); ip_flow_free(flow);
return NULL; return NULL;
} }
@@ -1056,7 +1056,7 @@ struct packet *ipv6_reassemble_packet(struct ip_reassemble_manager *mgr, const s
} }
struct packet *new_pkt = ip_frag_reassemble(mgr, flow); struct packet *new_pkt = ip_frag_reassemble(mgr, flow);
ip_reassemble_manager_del_flow(mgr, flow); ip_reassembly_del_flow(mgr, flow);
ip_flow_free(flow); ip_flow_free(flow);
return new_pkt; return new_pkt;

24
src/ip_reassemble/ip_reassemble.h → src/ip_reassembly/ip_reassembly.h
View File

@@ -9,10 +9,10 @@ extern "C"
#include "packet.h" #include "packet.h"
#include "log.h" #include "log.h"
#define IP_REASSEMBLE_DEBUG(format, ...) LOG_DEBUG("ip_reassemble", format, ##__VA_ARGS__) #define IP_REASSEMBLE_DEBUG(format, ...) LOG_DEBUG("ip_reassembly", format, ##__VA_ARGS__)
#define IP_REASSEMBLE_ERROR(format, ...) LOG_ERROR("ip_reassemble", format, ##__VA_ARGS__) #define IP_REASSEMBLE_ERROR(format, ...) LOG_ERROR("ip_reassembly", format, ##__VA_ARGS__)
struct ip_reassemble_config struct ip_reassembly_config
{ {
bool enable; bool enable;
@@ -21,7 +21,7 @@ struct ip_reassemble_config
uint32_t bucket_num; uint32_t bucket_num;
}; };
struct ip_reassemble_stat struct ip_reassembly_stat
{ {
// IPv4 flow stat // IPv4 flow stat
uint64_t ip4_flow_find; uint64_t ip4_flow_find;
@@ -50,19 +50,19 @@ struct ip_reassemble_stat
uint64_t ip6_flow_bypass_dup_last_frag; uint64_t ip6_flow_bypass_dup_last_frag;
}; };
struct ip_reassemble_manager *ip_reassemble_manager_create(const struct ip_reassemble_config *config); struct ip_reassembly *ip_reassembly_create(const struct ip_reassembly_config *config);
void ip_reassemble_manager_destory(struct ip_reassemble_manager *mgr); void ip_reassembly_destory(struct ip_reassembly *mgr);
void ip_reassemble_manager_expire(struct ip_reassemble_manager *mgr); void ip_reassembly_expire(struct ip_reassembly *mgr);
void ip_reassemble_manager_print_stat(struct ip_reassemble_manager *mgr); void ip_reassembly_print_stat(struct ip_reassembly *mgr);
struct ip_reassemble_stat *ip_reassemble_manager_get_stat(struct ip_reassemble_manager *mgr); struct ip_reassembly_stat *ip_reassembly_get_stat(struct ip_reassembly *mgr);
/* /*
* Returns the reassembled packet, or NULL if the packet is not reassembled * Returns the reassembled packet, or NULL if the packet is not reassembled
* The returned packet should be freed by calling the packet_free() function * The returned packet should be freed by calling the packet_free() function
*/ */
struct packet *ip_reassemble_packet(struct ip_reassemble_manager *mgr, const struct packet *pkt); struct packet *ip_reassembly_packet(struct ip_reassembly *mgr, const struct packet *pkt);
struct packet *ipv4_reassemble_packet(struct ip_reassemble_manager *mgr, const struct packet *pkt); struct packet *ipv4_reassembly_packet(struct ip_reassembly *mgr, const struct packet *pkt);
struct packet *ipv6_reassemble_packet(struct ip_reassemble_manager *mgr, const struct packet *pkt); struct packet *ipv6_reassembly_packet(struct ip_reassembly *mgr, const struct packet *pkt);
#ifdef __cpluscplus #ifdef __cpluscplus
} }

17
src/ip_reassembly/test/CMakeLists.txt Normal file
View File

@@ -0,0 +1,17 @@
###############################################################################
# gtest
###############################################################################
add_executable(gtest_ipv4_reassembly gtest_ipv4_reassembly.cpp)
target_link_libraries(gtest_ipv4_reassembly ip_reassembly gtest)
add_executable(gtest_ipv6_reassembly gtest_ipv6_reassembly.cpp)
target_link_libraries(gtest_ipv6_reassembly ip_reassembly gtest)
add_executable(gtest_ip_reassembly gtest_ip_reassembly.cpp)
target_link_libraries(gtest_ip_reassembly ip_reassembly gtest)
include(GoogleTest)
gtest_discover_tests(gtest_ipv4_reassembly)
gtest_discover_tests(gtest_ipv6_reassembly)
gtest_discover_tests(gtest_ip_reassembly)

0
src/ip_reassemble/test/gtest_ip_reassemble.cpp → src/ip_reassembly/test/gtest_ip_reassembly.cpp
View File

162
src/ip_reassemble/test/gtest_ipv4_reassemble.cpp → src/ip_reassembly/test/gtest_ipv4_reassembly.cpp
View File

@@ -197,8 +197,8 @@ TEST(IPV4_REASSEMBLE, PADDING_ORDER)
struct packet pkt; struct packet pkt;
struct packet *new_pkt; struct packet *new_pkt;
const struct layer_record *layer; const struct layer_record *layer;
struct ip_reassemble_manager *mgr; struct ip_reassembly *mgr;
struct ip_reassemble_config config = { struct ip_reassembly_config config = {
.enable = true, .enable = true,
.timeout = 1, .timeout = 1,
.bucket_entries = 16, .bucket_entries = 16,
@@ -207,10 +207,10 @@ TEST(IPV4_REASSEMBLE, PADDING_ORDER)
timestamp_update(); timestamp_update();
mgr = ip_reassemble_manager_create(&config); mgr = ip_reassembly_create(&config);
EXPECT_TRUE(mgr != NULL); EXPECT_TRUE(mgr != NULL);
// ip_reassemble_manager_print_stat(mgr); // ip_reassembly_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr), check_stat(ip_reassembly_get_stat(mgr),
0, 0, 0, 0, // ip4: find, add, del, timeout 0, 0, 0, 0, // ip4: find, add, del, timeout
0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag 0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag
0, 0, 0, 0, // ip6: find, add, del, timeout 0, 0, 0, 0, // ip6: find, add, del, timeout
@@ -218,10 +218,10 @@ TEST(IPV4_REASSEMBLE, PADDING_ORDER)
// frag1 // frag1
packet_parse(&pkt, (const char *)frag1, sizeof(frag1)); packet_parse(&pkt, (const char *)frag1, sizeof(frag1));
new_pkt = ip_reassemble_packet(mgr, &pkt); new_pkt = ip_reassembly_packet(mgr, &pkt);
EXPECT_TRUE(new_pkt == NULL); EXPECT_TRUE(new_pkt == NULL);
// ip_reassemble_manager_print_stat(mgr); // ip_reassembly_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr), check_stat(ip_reassembly_get_stat(mgr),
1, 1, 0, 0, // ip4: find, add, del, timeout 1, 1, 0, 0, // ip4: find, add, del, timeout
0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag 0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag
0, 0, 0, 0, // ip6: find, add, del, timeout 0, 0, 0, 0, // ip6: find, add, del, timeout
@@ -229,10 +229,10 @@ TEST(IPV4_REASSEMBLE, PADDING_ORDER)
// frag2 // frag2
packet_parse(&pkt, (const char *)frag2, sizeof(frag2)); packet_parse(&pkt, (const char *)frag2, sizeof(frag2));
new_pkt = ip_reassemble_packet(mgr, &pkt); new_pkt = ip_reassembly_packet(mgr, &pkt);
EXPECT_TRUE(new_pkt); EXPECT_TRUE(new_pkt);
// ip_reassemble_manager_print_stat(mgr); // ip_reassembly_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr), check_stat(ip_reassembly_get_stat(mgr),
2, 1, 1, 0, // ip4: find, add, del, timeout 2, 1, 1, 0, // ip4: find, add, del, timeout
0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag 0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag
0, 0, 0, 0, // ip6: find, add, del, timeout 0, 0, 0, 0, // ip6: find, add, del, timeout
@@ -282,7 +282,7 @@ TEST(IPV4_REASSEMBLE, PADDING_ORDER)
// free packet // free packet
packet_free(new_pkt); packet_free(new_pkt);
ip_reassemble_manager_destory(mgr); ip_reassembly_destory(mgr);
} }
#endif #endif
@@ -292,8 +292,8 @@ TEST(IPV4_REASSEMBLE, PADDING_UNORDER)
struct packet pkt; struct packet pkt;
struct packet *new_pkt; struct packet *new_pkt;
const struct layer_record *layer; const struct layer_record *layer;
struct ip_reassemble_manager *mgr; struct ip_reassembly *mgr;
struct ip_reassemble_config config = { struct ip_reassembly_config config = {
.enable = true, .enable = true,
.timeout = 1, .timeout = 1,
.bucket_entries = 16, .bucket_entries = 16,
@@ -302,10 +302,10 @@ TEST(IPV4_REASSEMBLE, PADDING_UNORDER)
timestamp_update(); timestamp_update();
mgr = ip_reassemble_manager_create(&config); mgr = ip_reassembly_create(&config);
EXPECT_TRUE(mgr != NULL); EXPECT_TRUE(mgr != NULL);
// ip_reassemble_manager_print_stat(mgr); // ip_reassembly_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr), check_stat(ip_reassembly_get_stat(mgr),
0, 0, 0, 0, // ip4: find, add, del, timeout 0, 0, 0, 0, // ip4: find, add, del, timeout
0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag 0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag
0, 0, 0, 0, // ip6: find, add, del, timeout 0, 0, 0, 0, // ip6: find, add, del, timeout
@@ -313,10 +313,10 @@ TEST(IPV4_REASSEMBLE, PADDING_UNORDER)
// frag2 // frag2
packet_parse(&pkt, (const char *)frag2, sizeof(frag2)); packet_parse(&pkt, (const char *)frag2, sizeof(frag2));
new_pkt = ip_reassemble_packet(mgr, &pkt); new_pkt = ip_reassembly_packet(mgr, &pkt);
EXPECT_TRUE(new_pkt == NULL); EXPECT_TRUE(new_pkt == NULL);
// ip_reassemble_manager_print_stat(mgr); // ip_reassembly_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr), check_stat(ip_reassembly_get_stat(mgr),
1, 1, 0, 0, // ip4: find, add, del, timeout 1, 1, 0, 0, // ip4: find, add, del, timeout
0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag 0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag
0, 0, 0, 0, // ip6: find, add, del, timeout 0, 0, 0, 0, // ip6: find, add, del, timeout
@@ -324,10 +324,10 @@ TEST(IPV4_REASSEMBLE, PADDING_UNORDER)
// frag1 // frag1
packet_parse(&pkt, (const char *)frag1, sizeof(frag1)); packet_parse(&pkt, (const char *)frag1, sizeof(frag1));
new_pkt = ip_reassemble_packet(mgr, &pkt); new_pkt = ip_reassembly_packet(mgr, &pkt);
EXPECT_TRUE(new_pkt); EXPECT_TRUE(new_pkt);
// ip_reassemble_manager_print_stat(mgr); // ip_reassembly_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr), check_stat(ip_reassembly_get_stat(mgr),
2, 1, 1, 0, // ip4: find, add, del, timeout 2, 1, 1, 0, // ip4: find, add, del, timeout
0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag 0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag
0, 0, 0, 0, // ip6: find, add, del, timeout 0, 0, 0, 0, // ip6: find, add, del, timeout
@@ -377,7 +377,7 @@ TEST(IPV4_REASSEMBLE, PADDING_UNORDER)
// free packet // free packet
packet_free(new_pkt); packet_free(new_pkt);
ip_reassemble_manager_destory(mgr); ip_reassembly_destory(mgr);
} }
#endif #endif
@@ -386,8 +386,8 @@ TEST(IPV4_REASSEMBLE, EXPIRE)
{ {
struct packet pkt; struct packet pkt;
struct packet *new_pkt; struct packet *new_pkt;
struct ip_reassemble_manager *mgr; struct ip_reassembly *mgr;
struct ip_reassemble_config config = { struct ip_reassembly_config config = {
.enable = true, .enable = true,
.timeout = 1, .timeout = 1,
.bucket_entries = 16, .bucket_entries = 16,
@@ -396,10 +396,10 @@ TEST(IPV4_REASSEMBLE, EXPIRE)
timestamp_update(); timestamp_update();
mgr = ip_reassemble_manager_create(&config); mgr = ip_reassembly_create(&config);
EXPECT_TRUE(mgr != NULL); EXPECT_TRUE(mgr != NULL);
// ip_reassemble_manager_print_stat(mgr); // ip_reassembly_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr), check_stat(ip_reassembly_get_stat(mgr),
0, 0, 0, 0, // ip4: find, add, del, timeout 0, 0, 0, 0, // ip4: find, add, del, timeout
0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag 0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag
0, 0, 0, 0, // ip6: find, add, del, timeout 0, 0, 0, 0, // ip6: find, add, del, timeout
@@ -407,10 +407,10 @@ TEST(IPV4_REASSEMBLE, EXPIRE)
// frag1 // frag1
packet_parse(&pkt, (const char *)frag1, sizeof(frag1)); packet_parse(&pkt, (const char *)frag1, sizeof(frag1));
new_pkt = ip_reassemble_packet(mgr, &pkt); new_pkt = ip_reassembly_packet(mgr, &pkt);
EXPECT_TRUE(new_pkt == NULL); EXPECT_TRUE(new_pkt == NULL);
// ip_reassemble_manager_print_stat(mgr); // ip_reassembly_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr), check_stat(ip_reassembly_get_stat(mgr),
1, 1, 0, 0, // ip4: find, add, del, timeout 1, 1, 0, 0, // ip4: find, add, del, timeout
0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag 0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag
0, 0, 0, 0, // ip6: find, add, del, timeout 0, 0, 0, 0, // ip6: find, add, del, timeout
@@ -422,10 +422,10 @@ TEST(IPV4_REASSEMBLE, EXPIRE)
// frag2 // frag2
packet_parse(&pkt, (const char *)frag2, sizeof(frag2)); packet_parse(&pkt, (const char *)frag2, sizeof(frag2));
new_pkt = ip_reassemble_packet(mgr, &pkt); new_pkt = ip_reassembly_packet(mgr, &pkt);
EXPECT_TRUE(new_pkt == NULL); EXPECT_TRUE(new_pkt == NULL);
// ip_reassemble_manager_print_stat(mgr); // ip_reassembly_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr), check_stat(ip_reassembly_get_stat(mgr),
2, 2, 1, 1, // ip4: find, add, del, timeout 2, 2, 1, 1, // ip4: find, add, del, timeout
0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag 0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag
0, 0, 0, 0, // ip6: find, add, del, timeout 0, 0, 0, 0, // ip6: find, add, del, timeout
@@ -434,7 +434,7 @@ TEST(IPV4_REASSEMBLE, EXPIRE)
// free packet // free packet
packet_free(new_pkt); packet_free(new_pkt);
ip_reassemble_manager_destory(mgr); ip_reassembly_destory(mgr);
} }
#endif #endif
@@ -444,8 +444,8 @@ TEST(IPV4_REASSEMBLE, DUP_FIRST_FRAG)
struct packet pkt; struct packet pkt;
struct packet *new_pkt; struct packet *new_pkt;
const struct layer_record *layer; const struct layer_record *layer;
struct ip_reassemble_manager *mgr; struct ip_reassembly *mgr;
struct ip_reassemble_config config = { struct ip_reassembly_config config = {
.enable = true, .enable = true,
.timeout = 1, .timeout = 1,
.bucket_entries = 16, .bucket_entries = 16,
@@ -454,10 +454,10 @@ TEST(IPV4_REASSEMBLE, DUP_FIRST_FRAG)
timestamp_update(); timestamp_update();
mgr = ip_reassemble_manager_create(&config); mgr = ip_reassembly_create(&config);
EXPECT_TRUE(mgr != NULL); EXPECT_TRUE(mgr != NULL);
// ip_reassemble_manager_print_stat(mgr); // ip_reassembly_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr), check_stat(ip_reassembly_get_stat(mgr),
0, 0, 0, 0, // ip4: find, add, del, timeout 0, 0, 0, 0, // ip4: find, add, del, timeout
0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag 0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag
0, 0, 0, 0, // ip6: find, add, del, timeout 0, 0, 0, 0, // ip6: find, add, del, timeout
@@ -465,10 +465,10 @@ TEST(IPV4_REASSEMBLE, DUP_FIRST_FRAG)
// frag1 // frag1
packet_parse(&pkt, (const char *)frag1, sizeof(frag1)); packet_parse(&pkt, (const char *)frag1, sizeof(frag1));
new_pkt = ip_reassemble_packet(mgr, &pkt); new_pkt = ip_reassembly_packet(mgr, &pkt);
EXPECT_TRUE(new_pkt == NULL); EXPECT_TRUE(new_pkt == NULL);
// ip_reassemble_manager_print_stat(mgr); // ip_reassembly_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr), check_stat(ip_reassembly_get_stat(mgr),
1, 1, 0, 0, // ip4: find, add, del, timeout 1, 1, 0, 0, // ip4: find, add, del, timeout
0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag 0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag
0, 0, 0, 0, // ip6: find, add, del, timeout 0, 0, 0, 0, // ip6: find, add, del, timeout
@@ -476,10 +476,10 @@ TEST(IPV4_REASSEMBLE, DUP_FIRST_FRAG)
// frag1 // frag1
packet_parse(&pkt, (const char *)frag1, sizeof(frag1)); packet_parse(&pkt, (const char *)frag1, sizeof(frag1));
new_pkt = ip_reassemble_packet(mgr, &pkt); new_pkt = ip_reassembly_packet(mgr, &pkt);
EXPECT_TRUE(new_pkt == NULL); EXPECT_TRUE(new_pkt == NULL);
// ip_reassemble_manager_print_stat(mgr); // ip_reassembly_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr), check_stat(ip_reassembly_get_stat(mgr),
2, 1, 0, 0, // ip4: find, add, del, timeout 2, 1, 0, 0, // ip4: find, add, del, timeout
0, 0, 0, 0, 1, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag 0, 0, 0, 0, 1, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag
0, 0, 0, 0, // ip6: find, add, del, timeout 0, 0, 0, 0, // ip6: find, add, del, timeout
@@ -487,10 +487,10 @@ TEST(IPV4_REASSEMBLE, DUP_FIRST_FRAG)
// frag2 // frag2
packet_parse(&pkt, (const char *)frag2, sizeof(frag2)); packet_parse(&pkt, (const char *)frag2, sizeof(frag2));
new_pkt = ip_reassemble_packet(mgr, &pkt); new_pkt = ip_reassembly_packet(mgr, &pkt);
EXPECT_TRUE(new_pkt); EXPECT_TRUE(new_pkt);
// ip_reassemble_manager_print_stat(mgr); // ip_reassembly_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr), check_stat(ip_reassembly_get_stat(mgr),
3, 1, 1, 0, // ip4: find, add, del, timeout 3, 1, 1, 0, // ip4: find, add, del, timeout
0, 0, 0, 0, 1, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag 0, 0, 0, 0, 1, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag
0, 0, 0, 0, // ip6: find, add, del, timeout 0, 0, 0, 0, // ip6: find, add, del, timeout
@@ -540,7 +540,7 @@ TEST(IPV4_REASSEMBLE, DUP_FIRST_FRAG)
// free packet // free packet
packet_free(new_pkt); packet_free(new_pkt);
ip_reassemble_manager_destory(mgr); ip_reassembly_destory(mgr);
} }
#endif #endif
@@ -550,8 +550,8 @@ TEST(IPV4_REASSEMBLE, DUP_LAST_FRAG)
struct packet pkt; struct packet pkt;
struct packet *new_pkt; struct packet *new_pkt;
const struct layer_record *layer; const struct layer_record *layer;
struct ip_reassemble_manager *mgr; struct ip_reassembly *mgr;
struct ip_reassemble_config config = { struct ip_reassembly_config config = {
.enable = true, .enable = true,
.timeout = 1, .timeout = 1,
.bucket_entries = 16, .bucket_entries = 16,
@@ -560,10 +560,10 @@ TEST(IPV4_REASSEMBLE, DUP_LAST_FRAG)
timestamp_update(); timestamp_update();
mgr = ip_reassemble_manager_create(&config); mgr = ip_reassembly_create(&config);
EXPECT_TRUE(mgr != NULL); EXPECT_TRUE(mgr != NULL);
// ip_reassemble_manager_print_stat(mgr); // ip_reassembly_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr), check_stat(ip_reassembly_get_stat(mgr),
0, 0, 0, 0, // ip4: find, add, del, timeout 0, 0, 0, 0, // ip4: find, add, del, timeout
0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag 0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag
0, 0, 0, 0, // ip6: find, add, del, timeout 0, 0, 0, 0, // ip6: find, add, del, timeout
@@ -571,10 +571,10 @@ TEST(IPV4_REASSEMBLE, DUP_LAST_FRAG)
// frag2 // frag2
packet_parse(&pkt, (const char *)frag2, sizeof(frag2)); packet_parse(&pkt, (const char *)frag2, sizeof(frag2));
new_pkt = ip_reassemble_packet(mgr, &pkt); new_pkt = ip_reassembly_packet(mgr, &pkt);
EXPECT_TRUE(new_pkt == NULL); EXPECT_TRUE(new_pkt == NULL);
// ip_reassemble_manager_print_stat(mgr); // ip_reassembly_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr), check_stat(ip_reassembly_get_stat(mgr),
1, 1, 0, 0, // ip4: find, add, del, timeout 1, 1, 0, 0, // ip4: find, add, del, timeout
0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag 0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag
0, 0, 0, 0, // ip6: find, add, del, timeout 0, 0, 0, 0, // ip6: find, add, del, timeout
@@ -582,10 +582,10 @@ TEST(IPV4_REASSEMBLE, DUP_LAST_FRAG)
// frag2 // frag2
packet_parse(&pkt, (const char *)frag2, sizeof(frag2)); packet_parse(&pkt, (const char *)frag2, sizeof(frag2));
new_pkt = ip_reassemble_packet(mgr, &pkt); new_pkt = ip_reassembly_packet(mgr, &pkt);
EXPECT_TRUE(new_pkt == NULL); EXPECT_TRUE(new_pkt == NULL);
// ip_reassemble_manager_print_stat(mgr); // ip_reassembly_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr), check_stat(ip_reassembly_get_stat(mgr),
2, 1, 0, 0, // ip4: find, add, del, timeout 2, 1, 0, 0, // ip4: find, add, del, timeout
0, 0, 0, 0, 0, 1, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag 0, 0, 0, 0, 0, 1, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag
0, 0, 0, 0, // ip6: find, add, del, timeout 0, 0, 0, 0, // ip6: find, add, del, timeout
@@ -593,10 +593,10 @@ TEST(IPV4_REASSEMBLE, DUP_LAST_FRAG)
// frag1 // frag1
packet_parse(&pkt, (const char *)frag1, sizeof(frag1)); packet_parse(&pkt, (const char *)frag1, sizeof(frag1));
new_pkt = ip_reassemble_packet(mgr, &pkt); new_pkt = ip_reassembly_packet(mgr, &pkt);
EXPECT_TRUE(new_pkt); EXPECT_TRUE(new_pkt);
// ip_reassemble_manager_print_stat(mgr); // ip_reassembly_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr), check_stat(ip_reassembly_get_stat(mgr),
3, 1, 1, 0, // ip4: find, add, del, timeout 3, 1, 1, 0, // ip4: find, add, del, timeout
0, 0, 0, 0, 0, 1, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag 0, 0, 0, 0, 0, 1, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag
0, 0, 0, 0, // ip6: find, add, del, timeout 0, 0, 0, 0, // ip6: find, add, del, timeout
@@ -646,7 +646,7 @@ TEST(IPV4_REASSEMBLE, DUP_LAST_FRAG)
// free packet // free packet
packet_free(new_pkt); packet_free(new_pkt);
ip_reassemble_manager_destory(mgr); ip_reassembly_destory(mgr);
} }
#endif #endif
@@ -655,8 +655,8 @@ TEST(IPV4_REASSEMBLE, FULL)
{ {
struct packet pkt; struct packet pkt;
struct packet *new_pkt; struct packet *new_pkt;
struct ip_reassemble_manager *mgr; struct ip_reassembly *mgr;
struct ip_reassemble_config config = { struct ip_reassembly_config config = {
.enable = true, .enable = true,
.timeout = 1, .timeout = 1,
.bucket_entries = 1, .bucket_entries = 1,
@@ -665,10 +665,10 @@ TEST(IPV4_REASSEMBLE, FULL)
timestamp_update(); timestamp_update();
mgr = ip_reassemble_manager_create(&config); mgr = ip_reassembly_create(&config);
EXPECT_TRUE(mgr != NULL); EXPECT_TRUE(mgr != NULL);
// ip_reassemble_manager_print_stat(mgr); // ip_reassembly_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr), check_stat(ip_reassembly_get_stat(mgr),
0, 0, 0, 0, // ip4: find, add, del, timeout 0, 0, 0, 0, // ip4: find, add, del, timeout
0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag 0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag
0, 0, 0, 0, // ip6: find, add, del, timeout 0, 0, 0, 0, // ip6: find, add, del, timeout
@@ -680,10 +680,10 @@ TEST(IPV4_REASSEMBLE, FULL)
// flow1 // flow1
packet_set_ipv4_src_addr(&pkt, 1); packet_set_ipv4_src_addr(&pkt, 1);
new_pkt = ip_reassemble_packet(mgr, &pkt); new_pkt = ip_reassembly_packet(mgr, &pkt);
EXPECT_TRUE(new_pkt == NULL); EXPECT_TRUE(new_pkt == NULL);
// ip_reassemble_manager_print_stat(mgr); // ip_reassembly_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr), check_stat(ip_reassembly_get_stat(mgr),
1, 1, 0, 0, // ip4: find, add, del, timeout 1, 1, 0, 0, // ip4: find, add, del, timeout
0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag 0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag
0, 0, 0, 0, // ip6: find, add, del, timeout 0, 0, 0, 0, // ip6: find, add, del, timeout
@@ -691,10 +691,10 @@ TEST(IPV4_REASSEMBLE, FULL)
// flow2 // flow2
packet_set_ipv4_src_addr(&pkt, 2); packet_set_ipv4_src_addr(&pkt, 2);
new_pkt = ip_reassemble_packet(mgr, &pkt); new_pkt = ip_reassembly_packet(mgr, &pkt);
EXPECT_TRUE(new_pkt == NULL); EXPECT_TRUE(new_pkt == NULL);
// ip_reassemble_manager_print_stat(mgr); // ip_reassembly_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr), check_stat(ip_reassembly_get_stat(mgr),
2, 2, 0, 0, // ip4: find, add, del, timeout 2, 2, 0, 0, // ip4: find, add, del, timeout
0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag 0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag
0, 0, 0, 0, // ip6: find, add, del, timeout 0, 0, 0, 0, // ip6: find, add, del, timeout
@@ -702,10 +702,10 @@ TEST(IPV4_REASSEMBLE, FULL)
// flow3 // flow3
packet_set_ipv4_src_addr(&pkt, 3); packet_set_ipv4_src_addr(&pkt, 3);
new_pkt = ip_reassemble_packet(mgr, &pkt); new_pkt = ip_reassembly_packet(mgr, &pkt);
EXPECT_TRUE(new_pkt == NULL); EXPECT_TRUE(new_pkt == NULL);
// ip_reassemble_manager_print_stat(mgr); // ip_reassembly_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr), check_stat(ip_reassembly_get_stat(mgr),
3, 2, 0, 0, // ip4: find, add, del, timeout 3, 2, 0, 0, // ip4: find, add, del, timeout
1, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag 1, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag
0, 0, 0, 0, // ip6: find, add, del, timeout 0, 0, 0, 0, // ip6: find, add, del, timeout
@@ -714,7 +714,7 @@ TEST(IPV4_REASSEMBLE, FULL)
// free packet // free packet
packet_free(new_pkt); packet_free(new_pkt);
ip_reassemble_manager_destory(mgr); ip_reassembly_destory(mgr);
} }
#endif #endif

210
src/ip_reassemble/test/gtest_ipv6_reassemble.cpp → src/ip_reassembly/test/gtest_ipv6_reassembly.cpp
View File

@@ -608,8 +608,8 @@ TEST(IPV6_REASSEMBLE, NORMAL)
struct packet pkt; struct packet pkt;
struct packet *new_pkt; struct packet *new_pkt;
const struct layer_record *layer; const struct layer_record *layer;
struct ip_reassemble_manager *mgr; struct ip_reassembly *mgr;
struct ip_reassemble_config config = { struct ip_reassembly_config config = {
.enable = true, .enable = true,
.timeout = 1, .timeout = 1,
.bucket_entries = 16, .bucket_entries = 16,
@@ -618,10 +618,10 @@ TEST(IPV6_REASSEMBLE, NORMAL)
timestamp_update(); timestamp_update();
mgr = ip_reassemble_manager_create(&config); mgr = ip_reassembly_create(&config);
EXPECT_TRUE(mgr != NULL); EXPECT_TRUE(mgr != NULL);
// ip_reassemble_manager_print_stat(mgr); // ip_reassembly_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr), check_stat(ip_reassembly_get_stat(mgr),
0, 0, 0, 0, // ip4: find, add, del, timeout 0, 0, 0, 0, // ip4: find, add, del, timeout
0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag 0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag
0, 0, 0, 0, // ip6: find, add, del, timeout 0, 0, 0, 0, // ip6: find, add, del, timeout
@@ -629,10 +629,10 @@ TEST(IPV6_REASSEMBLE, NORMAL)
// frag1 // frag1
packet_parse(&pkt, (const char *)frag1, sizeof(frag1)); packet_parse(&pkt, (const char *)frag1, sizeof(frag1));
new_pkt = ip_reassemble_packet(mgr, &pkt); new_pkt = ip_reassembly_packet(mgr, &pkt);
EXPECT_TRUE(new_pkt == NULL); EXPECT_TRUE(new_pkt == NULL);
// ip_reassemble_manager_print_stat(mgr); // ip_reassembly_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr), check_stat(ip_reassembly_get_stat(mgr),
0, 0, 0, 0, // ip4: find, add, del, timeout 0, 0, 0, 0, // ip4: find, add, del, timeout
0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag 0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag
1, 1, 0, 0, // ip6: find, add, del, timeout 1, 1, 0, 0, // ip6: find, add, del, timeout
@@ -640,10 +640,10 @@ TEST(IPV6_REASSEMBLE, NORMAL)
// frag2 // frag2
packet_parse(&pkt, (const char *)frag2, sizeof(frag2)); packet_parse(&pkt, (const char *)frag2, sizeof(frag2));
new_pkt = ip_reassemble_packet(mgr, &pkt); new_pkt = ip_reassembly_packet(mgr, &pkt);
EXPECT_TRUE(new_pkt == NULL); EXPECT_TRUE(new_pkt == NULL);
// ip_reassemble_manager_print_stat(mgr); // ip_reassembly_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr), check_stat(ip_reassembly_get_stat(mgr),
0, 0, 0, 0, // ip4: find, add, del, timeout 0, 0, 0, 0, // ip4: find, add, del, timeout
0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag 0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag
2, 1, 0, 0, // ip6: find, add, del, timeout 2, 1, 0, 0, // ip6: find, add, del, timeout
@@ -651,10 +651,10 @@ TEST(IPV6_REASSEMBLE, NORMAL)
// frag3 // frag3
packet_parse(&pkt, (const char *)frag3, sizeof(frag3)); packet_parse(&pkt, (const char *)frag3, sizeof(frag3));
new_pkt = ip_reassemble_packet(mgr, &pkt); new_pkt = ip_reassembly_packet(mgr, &pkt);
EXPECT_TRUE(new_pkt == NULL); EXPECT_TRUE(new_pkt == NULL);
// ip_reassemble_manager_print_stat(mgr); // ip_reassembly_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr), check_stat(ip_reassembly_get_stat(mgr),
0, 0, 0, 0, // ip4: find, add, del, timeout 0, 0, 0, 0, // ip4: find, add, del, timeout
0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag 0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag
3, 1, 0, 0, // ip6: find, add, del, timeout 3, 1, 0, 0, // ip6: find, add, del, timeout
@@ -662,10 +662,10 @@ TEST(IPV6_REASSEMBLE, NORMAL)
// frag4 // frag4
packet_parse(&pkt, (const char *)frag4, sizeof(frag4)); packet_parse(&pkt, (const char *)frag4, sizeof(frag4));
new_pkt = ip_reassemble_packet(mgr, &pkt); new_pkt = ip_reassembly_packet(mgr, &pkt);
EXPECT_TRUE(new_pkt); EXPECT_TRUE(new_pkt);
// ip_reassemble_manager_print_stat(mgr); // ip_reassembly_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr), check_stat(ip_reassembly_get_stat(mgr),
0, 0, 0, 0, // ip4: find, add, del, timeout 0, 0, 0, 0, // ip4: find, add, del, timeout
0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag 0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag
4, 1, 1, 0, // ip6: find, add, del, timeout 4, 1, 1, 0, // ip6: find, add, del, timeout
@@ -709,7 +709,7 @@ TEST(IPV6_REASSEMBLE, NORMAL)
// free packet // free packet
packet_free(new_pkt); packet_free(new_pkt);
ip_reassemble_manager_destory(mgr); ip_reassembly_destory(mgr);
} }
#endif #endif
@@ -718,8 +718,8 @@ TEST(IPV6_REASSEMBLE, EXPIRE)
{ {
struct packet pkt; struct packet pkt;
struct packet *new_pkt; struct packet *new_pkt;
struct ip_reassemble_manager *mgr; struct ip_reassembly *mgr;
struct ip_reassemble_config config = { struct ip_reassembly_config config = {
.enable = true, .enable = true,
.timeout = 1, .timeout = 1,
.bucket_entries = 16, .bucket_entries = 16,
@@ -728,10 +728,10 @@ TEST(IPV6_REASSEMBLE, EXPIRE)
timestamp_update(); timestamp_update();
mgr = ip_reassemble_manager_create(&config); mgr = ip_reassembly_create(&config);
EXPECT_TRUE(mgr != NULL); EXPECT_TRUE(mgr != NULL);
// ip_reassemble_manager_print_stat(mgr); // ip_reassembly_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr), check_stat(ip_reassembly_get_stat(mgr),
0, 0, 0, 0, // ip4: find, add, del, timeout 0, 0, 0, 0, // ip4: find, add, del, timeout
0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag 0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag
0, 0, 0, 0, // ip6: find, add, del, timeout 0, 0, 0, 0, // ip6: find, add, del, timeout
@@ -739,10 +739,10 @@ TEST(IPV6_REASSEMBLE, EXPIRE)
// frag1 // frag1
packet_parse(&pkt, (const char *)frag1, sizeof(frag1)); packet_parse(&pkt, (const char *)frag1, sizeof(frag1));
new_pkt = ip_reassemble_packet(mgr, &pkt); new_pkt = ip_reassembly_packet(mgr, &pkt);
EXPECT_TRUE(new_pkt == NULL); EXPECT_TRUE(new_pkt == NULL);
// ip_reassemble_manager_print_stat(mgr); // ip_reassembly_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr), check_stat(ip_reassembly_get_stat(mgr),
0, 0, 0, 0, // ip4: find, add, del, timeout 0, 0, 0, 0, // ip4: find, add, del, timeout
0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag 0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag
1, 1, 0, 0, // ip6: find, add, del, timeout 1, 1, 0, 0, // ip6: find, add, del, timeout
@@ -754,10 +754,10 @@ TEST(IPV6_REASSEMBLE, EXPIRE)
// frag2 // frag2
packet_parse(&pkt, (const char *)frag2, sizeof(frag2)); packet_parse(&pkt, (const char *)frag2, sizeof(frag2));
new_pkt = ip_reassemble_packet(mgr, &pkt); new_pkt = ip_reassembly_packet(mgr, &pkt);
EXPECT_TRUE(new_pkt == NULL); EXPECT_TRUE(new_pkt == NULL);
// ip_reassemble_manager_print_stat(mgr); // ip_reassembly_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr), check_stat(ip_reassembly_get_stat(mgr),
0, 0, 0, 0, // ip4: find, add, del, timeout 0, 0, 0, 0, // ip4: find, add, del, timeout
0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag 0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag
2, 2, 1, 1, // ip6: find, add, del, timeout 2, 2, 1, 1, // ip6: find, add, del, timeout
@@ -766,7 +766,7 @@ TEST(IPV6_REASSEMBLE, EXPIRE)
// free packet // free packet
packet_free(new_pkt); packet_free(new_pkt);
ip_reassemble_manager_destory(mgr); ip_reassembly_destory(mgr);
} }
#endif #endif
@@ -776,8 +776,8 @@ TEST(IPV6_REASSEMBLE, DUP_FIRST_FRAG)
struct packet pkt; struct packet pkt;
struct packet *new_pkt; struct packet *new_pkt;
const struct layer_record *layer; const struct layer_record *layer;
struct ip_reassemble_manager *mgr; struct ip_reassembly *mgr;
struct ip_reassemble_config config = { struct ip_reassembly_config config = {
.enable = true, .enable = true,
.timeout = 1, .timeout = 1,
.bucket_entries = 16, .bucket_entries = 16,
@@ -786,10 +786,10 @@ TEST(IPV6_REASSEMBLE, DUP_FIRST_FRAG)
timestamp_update(); timestamp_update();
mgr = ip_reassemble_manager_create(&config); mgr = ip_reassembly_create(&config);
EXPECT_TRUE(mgr != NULL); EXPECT_TRUE(mgr != NULL);
// ip_reassemble_manager_print_stat(mgr); // ip_reassembly_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr), check_stat(ip_reassembly_get_stat(mgr),
0, 0, 0, 0, // ip4: find, add, del, timeout 0, 0, 0, 0, // ip4: find, add, del, timeout
0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag 0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag
0, 0, 0, 0, // ip6: find, add, del, timeout 0, 0, 0, 0, // ip6: find, add, del, timeout
@@ -797,10 +797,10 @@ TEST(IPV6_REASSEMBLE, DUP_FIRST_FRAG)
// frag1 // frag1
packet_parse(&pkt, (const char *)frag1, sizeof(frag1)); packet_parse(&pkt, (const char *)frag1, sizeof(frag1));
new_pkt = ip_reassemble_packet(mgr, &pkt); new_pkt = ip_reassembly_packet(mgr, &pkt);
EXPECT_TRUE(new_pkt == NULL); EXPECT_TRUE(new_pkt == NULL);
// ip_reassemble_manager_print_stat(mgr); // ip_reassembly_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr), check_stat(ip_reassembly_get_stat(mgr),
0, 0, 0, 0, // ip4: find, add, del, timeout 0, 0, 0, 0, // ip4: find, add, del, timeout
0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag 0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag
1, 1, 0, 0, // ip6: find, add, del, timeout 1, 1, 0, 0, // ip6: find, add, del, timeout
@@ -808,10 +808,10 @@ TEST(IPV6_REASSEMBLE, DUP_FIRST_FRAG)
// frag1 // frag1
packet_parse(&pkt, (const char *)frag1, sizeof(frag1)); packet_parse(&pkt, (const char *)frag1, sizeof(frag1));
new_pkt = ip_reassemble_packet(mgr, &pkt); new_pkt = ip_reassembly_packet(mgr, &pkt);
EXPECT_TRUE(new_pkt == NULL); EXPECT_TRUE(new_pkt == NULL);
// ip_reassemble_manager_print_stat(mgr); // ip_reassembly_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr), check_stat(ip_reassembly_get_stat(mgr),
0, 0, 0, 0, // ip4: find, add, del, timeout 0, 0, 0, 0, // ip4: find, add, del, timeout
0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag 0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag
2, 1, 0, 0, // ip6: find, add, del, timeout 2, 1, 0, 0, // ip6: find, add, del, timeout
@@ -819,10 +819,10 @@ TEST(IPV6_REASSEMBLE, DUP_FIRST_FRAG)
// frag2 // frag2
packet_parse(&pkt, (const char *)frag2, sizeof(frag2)); packet_parse(&pkt, (const char *)frag2, sizeof(frag2));
new_pkt = ip_reassemble_packet(mgr, &pkt); new_pkt = ip_reassembly_packet(mgr, &pkt);
EXPECT_TRUE(new_pkt == NULL); EXPECT_TRUE(new_pkt == NULL);
// ip_reassemble_manager_print_stat(mgr); // ip_reassembly_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr), check_stat(ip_reassembly_get_stat(mgr),
0, 0, 0, 0, // ip4: find, add, del, timeout 0, 0, 0, 0, // ip4: find, add, del, timeout
0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag 0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag
3, 1, 0, 0, // ip6: find, add, del, timeout 3, 1, 0, 0, // ip6: find, add, del, timeout
@@ -830,10 +830,10 @@ TEST(IPV6_REASSEMBLE, DUP_FIRST_FRAG)
// frag3 // frag3
packet_parse(&pkt, (const char *)frag3, sizeof(frag3)); packet_parse(&pkt, (const char *)frag3, sizeof(frag3));
new_pkt = ip_reassemble_packet(mgr, &pkt); new_pkt = ip_reassembly_packet(mgr, &pkt);
EXPECT_TRUE(new_pkt == NULL); EXPECT_TRUE(new_pkt == NULL);
// ip_reassemble_manager_print_stat(mgr); // ip_reassembly_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr), check_stat(ip_reassembly_get_stat(mgr),
0, 0, 0, 0, // ip4: find, add, del, timeout 0, 0, 0, 0, // ip4: find, add, del, timeout
0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag 0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag
4, 1, 0, 0, // ip6: find, add, del, timeout 4, 1, 0, 0, // ip6: find, add, del, timeout
@@ -841,10 +841,10 @@ TEST(IPV6_REASSEMBLE, DUP_FIRST_FRAG)
// frag4 // frag4
packet_parse(&pkt, (const char *)frag4, sizeof(frag4)); packet_parse(&pkt, (const char *)frag4, sizeof(frag4));
new_pkt = ip_reassemble_packet(mgr, &pkt); new_pkt = ip_reassembly_packet(mgr, &pkt);
EXPECT_TRUE(new_pkt); EXPECT_TRUE(new_pkt);
// ip_reassemble_manager_print_stat(mgr); // ip_reassembly_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr), check_stat(ip_reassembly_get_stat(mgr),
0, 0, 0, 0, // ip4: find, add, del, timeout 0, 0, 0, 0, // ip4: find, add, del, timeout
0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag 0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag
5, 1, 1, 0, // ip6: find, add, del, timeout 5, 1, 1, 0, // ip6: find, add, del, timeout
@@ -888,7 +888,7 @@ TEST(IPV6_REASSEMBLE, DUP_FIRST_FRAG)
// free packet // free packet
packet_free(new_pkt); packet_free(new_pkt);
ip_reassemble_manager_destory(mgr); ip_reassembly_destory(mgr);
} }
#endif #endif
@@ -898,8 +898,8 @@ TEST(IPV6_REASSEMBLE, DUP_LAST_FRAG)
struct packet pkt; struct packet pkt;
struct packet *new_pkt; struct packet *new_pkt;
const struct layer_record *layer; const struct layer_record *layer;
struct ip_reassemble_manager *mgr; struct ip_reassembly *mgr;
struct ip_reassemble_config config = { struct ip_reassembly_config config = {
.enable = true, .enable = true,
.timeout = 1, .timeout = 1,
.bucket_entries = 16, .bucket_entries = 16,
@@ -908,10 +908,10 @@ TEST(IPV6_REASSEMBLE, DUP_LAST_FRAG)
timestamp_update(); timestamp_update();
mgr = ip_reassemble_manager_create(&config); mgr = ip_reassembly_create(&config);
EXPECT_TRUE(mgr != NULL); EXPECT_TRUE(mgr != NULL);
// ip_reassemble_manager_print_stat(mgr); // ip_reassembly_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr), check_stat(ip_reassembly_get_stat(mgr),
0, 0, 0, 0, // ip4: find, add, del, timeout 0, 0, 0, 0, // ip4: find, add, del, timeout
0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag 0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag
0, 0, 0, 0, // ip6: find, add, del, timeout 0, 0, 0, 0, // ip6: find, add, del, timeout
@@ -919,10 +919,10 @@ TEST(IPV6_REASSEMBLE, DUP_LAST_FRAG)
// frag4 // frag4
packet_parse(&pkt, (const char *)frag4, sizeof(frag4)); packet_parse(&pkt, (const char *)frag4, sizeof(frag4));
new_pkt = ip_reassemble_packet(mgr, &pkt); new_pkt = ip_reassembly_packet(mgr, &pkt);
EXPECT_TRUE(new_pkt == NULL); EXPECT_TRUE(new_pkt == NULL);
// ip_reassemble_manager_print_stat(mgr); // ip_reassembly_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr), check_stat(ip_reassembly_get_stat(mgr),
0, 0, 0, 0, // ip4: find, add, del, timeout 0, 0, 0, 0, // ip4: find, add, del, timeout
0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag 0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag
1, 1, 0, 0, // ip6: find, add, del, timeout 1, 1, 0, 0, // ip6: find, add, del, timeout
@@ -930,10 +930,10 @@ TEST(IPV6_REASSEMBLE, DUP_LAST_FRAG)
// frag4 // frag4
packet_parse(&pkt, (const char *)frag4, sizeof(frag4)); packet_parse(&pkt, (const char *)frag4, sizeof(frag4));
new_pkt = ip_reassemble_packet(mgr, &pkt); new_pkt = ip_reassembly_packet(mgr, &pkt);
EXPECT_TRUE(new_pkt == NULL); EXPECT_TRUE(new_pkt == NULL);
// ip_reassemble_manager_print_stat(mgr); // ip_reassembly_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr), check_stat(ip_reassembly_get_stat(mgr),
0, 0, 0, 0, // ip4: find, add, del, timeout 0, 0, 0, 0, // ip4: find, add, del, timeout
0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag 0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag
2, 1, 0, 0, // ip6: find, add, del, timeout 2, 1, 0, 0, // ip6: find, add, del, timeout
@@ -941,10 +941,10 @@ TEST(IPV6_REASSEMBLE, DUP_LAST_FRAG)
// frag3 // frag3
packet_parse(&pkt, (const char *)frag3, sizeof(frag3)); packet_parse(&pkt, (const char *)frag3, sizeof(frag3));
new_pkt = ip_reassemble_packet(mgr, &pkt); new_pkt = ip_reassembly_packet(mgr, &pkt);
EXPECT_TRUE(new_pkt == NULL); EXPECT_TRUE(new_pkt == NULL);
// ip_reassemble_manager_print_stat(mgr); // ip_reassembly_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr), check_stat(ip_reassembly_get_stat(mgr),
0, 0, 0, 0, // ip4: find, add, del, timeout 0, 0, 0, 0, // ip4: find, add, del, timeout
0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag 0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag
3, 1, 0, 0, // ip6: find, add, del, timeout 3, 1, 0, 0, // ip6: find, add, del, timeout
@@ -952,10 +952,10 @@ TEST(IPV6_REASSEMBLE, DUP_LAST_FRAG)
// frag2 // frag2
packet_parse(&pkt, (const char *)frag2, sizeof(frag2)); packet_parse(&pkt, (const char *)frag2, sizeof(frag2));
new_pkt = ip_reassemble_packet(mgr, &pkt); new_pkt = ip_reassembly_packet(mgr, &pkt);
EXPECT_TRUE(new_pkt == NULL); EXPECT_TRUE(new_pkt == NULL);
// ip_reassemble_manager_print_stat(mgr); // ip_reassembly_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr), check_stat(ip_reassembly_get_stat(mgr),
0, 0, 0, 0, // ip4: find, add, del, timeout 0, 0, 0, 0, // ip4: find, add, del, timeout
0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag 0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag
4, 1, 0, 0, // ip6: find, add, del, timeout 4, 1, 0, 0, // ip6: find, add, del, timeout
@@ -963,10 +963,10 @@ TEST(IPV6_REASSEMBLE, DUP_LAST_FRAG)
// frag1 // frag1
packet_parse(&pkt, (const char *)frag1, sizeof(frag1)); packet_parse(&pkt, (const char *)frag1, sizeof(frag1));
new_pkt = ip_reassemble_packet(mgr, &pkt); new_pkt = ip_reassembly_packet(mgr, &pkt);
EXPECT_TRUE(new_pkt); EXPECT_TRUE(new_pkt);
// ip_reassemble_manager_print_stat(mgr); // ip_reassembly_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr), check_stat(ip_reassembly_get_stat(mgr),
0, 0, 0, 0, // ip4: find, add, del, timeout 0, 0, 0, 0, // ip4: find, add, del, timeout
0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag 0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag
5, 1, 1, 0, // ip6: find, add, del, timeout 5, 1, 1, 0, // ip6: find, add, del, timeout
@@ -1010,7 +1010,7 @@ TEST(IPV6_REASSEMBLE, DUP_LAST_FRAG)
// free packet // free packet
packet_free(new_pkt); packet_free(new_pkt);
ip_reassemble_manager_destory(mgr); ip_reassembly_destory(mgr);
} }
#endif #endif
@@ -1020,8 +1020,8 @@ TEST(IPV6_REASSEMBLE, FULL)
struct packet pkt; struct packet pkt;
struct packet *new_pkt; struct packet *new_pkt;
struct in6_addr src_addr; struct in6_addr src_addr;
struct ip_reassemble_manager *mgr; struct ip_reassembly *mgr;
struct ip_reassemble_config config = { struct ip_reassembly_config config = {
.enable = true, .enable = true,
.timeout = 1, .timeout = 1,
.bucket_entries = 1, .bucket_entries = 1,
@@ -1030,10 +1030,10 @@ TEST(IPV6_REASSEMBLE, FULL)
timestamp_update(); timestamp_update();
mgr = ip_reassemble_manager_create(&config); mgr = ip_reassembly_create(&config);
EXPECT_TRUE(mgr != NULL); EXPECT_TRUE(mgr != NULL);
// ip_reassemble_manager_print_stat(mgr); // ip_reassembly_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr), check_stat(ip_reassembly_get_stat(mgr),
0, 0, 0, 0, // ip4: find, add, del, timeout 0, 0, 0, 0, // ip4: find, add, del, timeout
0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag 0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag
0, 0, 0, 0, // ip6: find, add, del, timeout 0, 0, 0, 0, // ip6: find, add, del, timeout
@@ -1046,10 +1046,10 @@ TEST(IPV6_REASSEMBLE, FULL)
// flow1 // flow1
memset(&src_addr, 1, sizeof(src_addr)); memset(&src_addr, 1, sizeof(src_addr));
packet_set_ipv6_src_addr(&pkt, src_addr); packet_set_ipv6_src_addr(&pkt, src_addr);
new_pkt = ip_reassemble_packet(mgr, &pkt); new_pkt = ip_reassembly_packet(mgr, &pkt);
EXPECT_TRUE(new_pkt == NULL); EXPECT_TRUE(new_pkt == NULL);
// ip_reassemble_manager_print_stat(mgr); // ip_reassembly_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr), check_stat(ip_reassembly_get_stat(mgr),
0, 0, 0, 0, // ip4: find, add, del, timeout 0, 0, 0, 0, // ip4: find, add, del, timeout
0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag 0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag
1, 1, 0, 0, // ip6: find, add, del, timeout 1, 1, 0, 0, // ip6: find, add, del, timeout
@@ -1058,10 +1058,10 @@ TEST(IPV6_REASSEMBLE, FULL)
// flow2 // flow2
memset(&src_addr, 2, sizeof(src_addr)); memset(&src_addr, 2, sizeof(src_addr));
packet_set_ipv6_src_addr(&pkt, src_addr); packet_set_ipv6_src_addr(&pkt, src_addr);
new_pkt = ip_reassemble_packet(mgr, &pkt); new_pkt = ip_reassembly_packet(mgr, &pkt);
EXPECT_TRUE(new_pkt == NULL); EXPECT_TRUE(new_pkt == NULL);
// ip_reassemble_manager_print_stat(mgr); // ip_reassembly_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr), check_stat(ip_reassembly_get_stat(mgr),
0, 0, 0, 0, // ip4: find, add, del, timeout 0, 0, 0, 0, // ip4: find, add, del, timeout
0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag 0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag
2, 2, 0, 0, // ip6: find, add, del, timeout 2, 2, 0, 0, // ip6: find, add, del, timeout
@@ -1070,10 +1070,10 @@ TEST(IPV6_REASSEMBLE, FULL)
// flow3 // flow3
memset(&src_addr, 3, sizeof(src_addr)); memset(&src_addr, 3, sizeof(src_addr));
packet_set_ipv6_src_addr(&pkt, src_addr); packet_set_ipv6_src_addr(&pkt, src_addr);
new_pkt = ip_reassemble_packet(mgr, &pkt); new_pkt = ip_reassembly_packet(mgr, &pkt);
EXPECT_TRUE(new_pkt == NULL); EXPECT_TRUE(new_pkt == NULL);
// ip_reassemble_manager_print_stat(mgr); // ip_reassembly_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr), check_stat(ip_reassembly_get_stat(mgr),
0, 0, 0, 0, // ip4: find, add, del, timeout 0, 0, 0, 0, // ip4: find, add, del, timeout
0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag 0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag
3, 2, 0, 0, // ip6: find, add, del, timeout 3, 2, 0, 0, // ip6: find, add, del, timeout
@@ -1082,7 +1082,7 @@ TEST(IPV6_REASSEMBLE, FULL)
// free packet // free packet
packet_free(new_pkt); packet_free(new_pkt);
ip_reassemble_manager_destory(mgr); ip_reassembly_destory(mgr);
} }
#endif #endif
@@ -1091,8 +1091,8 @@ TEST(IPV6_REASSEMBLE, OVERLAP)
{ {
struct packet pkt; struct packet pkt;
struct packet *new_pkt; struct packet *new_pkt;
struct ip_reassemble_manager *mgr; struct ip_reassembly *mgr;
struct ip_reassemble_config config = { struct ip_reassembly_config config = {
.enable = true, .enable = true,
.timeout = 1, .timeout = 1,
.bucket_entries = 16, .bucket_entries = 16,
@@ -1101,10 +1101,10 @@ TEST(IPV6_REASSEMBLE, OVERLAP)
timestamp_update(); timestamp_update();
mgr = ip_reassemble_manager_create(&config); mgr = ip_reassembly_create(&config);
EXPECT_TRUE(mgr != NULL); EXPECT_TRUE(mgr != NULL);
// ip_reassemble_manager_print_stat(mgr); // ip_reassembly_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr), check_stat(ip_reassembly_get_stat(mgr),
0, 0, 0, 0, // ip4: find, add, del, timeout 0, 0, 0, 0, // ip4: find, add, del, timeout
0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag 0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag
0, 0, 0, 0, // ip6: find, add, del, timeout 0, 0, 0, 0, // ip6: find, add, del, timeout
@@ -1112,10 +1112,10 @@ TEST(IPV6_REASSEMBLE, OVERLAP)
// frag1 // frag1
packet_parse(&pkt, (const char *)frag1, sizeof(frag1)); packet_parse(&pkt, (const char *)frag1, sizeof(frag1));
new_pkt = ip_reassemble_packet(mgr, &pkt); new_pkt = ip_reassembly_packet(mgr, &pkt);
EXPECT_TRUE(new_pkt == NULL); EXPECT_TRUE(new_pkt == NULL);
// ip_reassemble_manager_print_stat(mgr); // ip_reassembly_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr), check_stat(ip_reassembly_get_stat(mgr),
0, 0, 0, 0, // ip4: find, add, del, timeout 0, 0, 0, 0, // ip4: find, add, del, timeout
0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag 0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag
1, 1, 0, 0, // ip6: find, add, del, timeout 1, 1, 0, 0, // ip6: find, add, del, timeout
@@ -1123,10 +1123,10 @@ TEST(IPV6_REASSEMBLE, OVERLAP)
// frag2 // frag2
packet_parse(&pkt, (const char *)frag2, sizeof(frag2)); packet_parse(&pkt, (const char *)frag2, sizeof(frag2));
new_pkt = ip_reassemble_packet(mgr, &pkt); new_pkt = ip_reassembly_packet(mgr, &pkt);
EXPECT_TRUE(new_pkt == NULL); EXPECT_TRUE(new_pkt == NULL);
// ip_reassemble_manager_print_stat(mgr); // ip_reassembly_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr), check_stat(ip_reassembly_get_stat(mgr),
0, 0, 0, 0, // ip4: find, add, del, timeout 0, 0, 0, 0, // ip4: find, add, del, timeout
0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag 0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag
2, 1, 0, 0, // ip6: find, add, del, timeout 2, 1, 0, 0, // ip6: find, add, del, timeout
@@ -1137,10 +1137,10 @@ TEST(IPV6_REASSEMBLE, OVERLAP)
memcpy(dup_frag, frag3, sizeof(frag3)); memcpy(dup_frag, frag3, sizeof(frag3));
packet_parse(&pkt, (const char *)dup_frag, sizeof(dup_frag)); packet_parse(&pkt, (const char *)dup_frag, sizeof(dup_frag));
packet_set_ipv6_frag_offset(&pkt, 2048); packet_set_ipv6_frag_offset(&pkt, 2048);
new_pkt = ip_reassemble_packet(mgr, &pkt); new_pkt = ip_reassembly_packet(mgr, &pkt);
EXPECT_TRUE(new_pkt == NULL); EXPECT_TRUE(new_pkt == NULL);
// ip_reassemble_manager_print_stat(mgr); // ip_reassembly_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr), check_stat(ip_reassembly_get_stat(mgr),
0, 0, 0, 0, // ip4: find, add, del, timeout 0, 0, 0, 0, // ip4: find, add, del, timeout
0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag 0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag
3, 1, 0, 0, // ip6: find, add, del, timeout 3, 1, 0, 0, // ip6: find, add, del, timeout
@@ -1148,10 +1148,10 @@ TEST(IPV6_REASSEMBLE, OVERLAP)
// frag4 // frag4
packet_parse(&pkt, (const char *)frag4, sizeof(frag4)); packet_parse(&pkt, (const char *)frag4, sizeof(frag4));
new_pkt = ip_reassemble_packet(mgr, &pkt); new_pkt = ip_reassembly_packet(mgr, &pkt);
EXPECT_TRUE(new_pkt == NULL); EXPECT_TRUE(new_pkt == NULL);
// ip_reassemble_manager_print_stat(mgr); // ip_reassembly_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr), check_stat(ip_reassembly_get_stat(mgr),
0, 0, 0, 0, // ip4: find, add, del, timeout 0, 0, 0, 0, // ip4: find, add, del, timeout
0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag 0, 0, 0, 0, 0, 0, // ip4: nospace, overlap, many frag, invalid length, dup first frag, dup last frag
4, 1, 1, 0, // ip6: find, add, del, timeout 4, 1, 1, 0, // ip6: find, add, del, timeout
@@ -1160,7 +1160,7 @@ TEST(IPV6_REASSEMBLE, OVERLAP)
// free packet // free packet
packet_free(new_pkt); packet_free(new_pkt);
ip_reassemble_manager_destory(mgr); ip_reassembly_destory(mgr);
} }
#endif #endif

4
src/ip_reassemble/test/gtest_utils.h → src/ip_reassembly/test/gtest_utils.h
View File

@@ -14,7 +14,7 @@ extern "C"
#include "ipv4_utils.h" #include "ipv4_utils.h"
#include "ipv6_utils.h" #include "ipv6_utils.h"
#include "packet_utils.h" #include "packet_utils.h"
#include "ip_reassemble.h" #include "ip_reassembly.h"
static inline void packet_set_ipv4_src_addr(struct packet *pkt, uint32_t saddr) static inline void packet_set_ipv4_src_addr(struct packet *pkt, uint32_t saddr)
{ {
@@ -42,7 +42,7 @@ static inline void packet_set_ipv6_frag_offset(struct packet *pkt, uint16_t offs
ipv6_frag_set_offset(frag_hdr, offset); ipv6_frag_set_offset(frag_hdr, offset);
} }
static inline void check_stat(struct ip_reassemble_stat *stat, static inline void check_stat(struct ip_reassembly_stat *stat,
uint64_t ip4_flow_find, uint64_t ip4_flow_add, uint64_t ip4_flow_del, uint64_t ip4_flow_timeout, uint64_t ip4_flow_find, uint64_t ip4_flow_add, uint64_t ip4_flow_del, uint64_t ip4_flow_timeout,
uint64_t ip4_flow_fail_no_space, uint64_t ip4_flow_fail_overlap, uint64_t ip4_flow_fail_many_frag, uint64_t ip4_flow_fail_no_space, uint64_t ip4_flow_fail_overlap, uint64_t ip4_flow_fail_many_frag,
uint64_t ip4_flow_fail_invalid_length, uint64_t ip4_flow_bypass_dup_fist_frag, uint64_t ip4_flow_bypass_dup_last_frag, uint64_t ip4_flow_fail_invalid_length, uint64_t ip4_flow_bypass_dup_fist_frag, uint64_t ip4_flow_bypass_dup_last_frag,

14
src/stellar/stellar.cpp
View File

@@ -15,7 +15,7 @@
#include "packet_io.h" #include "packet_io.h"
#include "timestamp.h" #include "timestamp.h"
#include "id_generator.h" #include "id_generator.h"
#include "ip_reassemble.h" #include "ip_reassembly.h"
#include "session_manager.h" #include "session_manager.h"
#define STELLAR_LOG_STATE(format, ...) LOG_STATE("stellar", format, ##__VA_ARGS__) #define STELLAR_LOG_STATE(format, ...) LOG_STATE("stellar", format, ##__VA_ARGS__)
@@ -32,7 +32,7 @@ struct thread_context
uint64_t need_exit; uint64_t need_exit;
uint64_t is_runing; uint64_t is_runing;
struct session_manager *sess_mgr; struct session_manager *sess_mgr;
struct ip_reassemble_manager *ip_mgr; struct ip_reassembly *ip_mgr;
}; };
struct stellar_context struct stellar_context
@@ -50,7 +50,7 @@ struct stellar_context *stellar_ctx = &stellar_context;
// config // config
struct device_config *dev_cfg = &stellar_context.config.dev_cfg; struct device_config *dev_cfg = &stellar_context.config.dev_cfg;
struct packet_io_config *pkt_io_cfg = &stellar_context.config.pkt_io_cfg; struct packet_io_config *pkt_io_cfg = &stellar_context.config.pkt_io_cfg;
struct ip_reassemble_config *ip_reass_cfg = &stellar_context.config.ip_reass_cfg; struct ip_reassembly_config *ip_reass_cfg = &stellar_context.config.ip_reass_cfg;
struct session_manager_config *sess_mgr_cfg = &stellar_context.config.sess_mgr_cfg; struct session_manager_config *sess_mgr_cfg = &stellar_context.config.sess_mgr_cfg;
static const char *log_config_file = "./conf/log.toml"; static const char *log_config_file = "./conf/log.toml";
@@ -137,7 +137,7 @@ static void *main_loop(void *arg)
uint16_t thd_idx = threads_ctx->index; uint16_t thd_idx = threads_ctx->index;
struct packet_io *packet_io = stellar_ctx->packet_io; struct packet_io *packet_io = stellar_ctx->packet_io;
struct session_manager *sess_mgr = threads_ctx->sess_mgr; struct session_manager *sess_mgr = threads_ctx->sess_mgr;
struct ip_reassemble_manager *ip_mgr = threads_ctx->ip_mgr; struct ip_reassembly *ip_mgr = threads_ctx->ip_mgr;
if (packet_io_init(packet_io, thd_idx) != 0) if (packet_io_init(packet_io, thd_idx) != 0)
{ {
@@ -163,7 +163,7 @@ static void *main_loop(void *arg)
// ip fragment reassemble // ip fragment reassemble
if (pkt->frag_layer) if (pkt->frag_layer)
{ {
struct packet *temp = ip_reassemble_packet(ip_mgr, pkt); struct packet *temp = ip_reassembly_packet(ip_mgr, pkt);
// forward the original fragment packet // forward the original fragment packet
packet_io_send(packet_io, thd_idx, pkt); packet_io_send(packet_io, thd_idx, pkt);
if (temp == NULL) if (temp == NULL)
@@ -214,7 +214,7 @@ static int thread_context_init(struct stellar_context *ctx, uint8_t nr_threads)
return -1; return -1;
} }
threads_ctx->ip_mgr = ip_reassemble_manager_create(ip_reass_cfg); threads_ctx->ip_mgr = ip_reassembly_create(ip_reass_cfg);
if (threads_ctx->ip_mgr == NULL) if (threads_ctx->ip_mgr == NULL)
{ {
STELLAR_LOG_ERROR("unable to create ip reassemble manager"); STELLAR_LOG_ERROR("unable to create ip reassemble manager");
@@ -234,7 +234,7 @@ static void thread_context_free(struct stellar_context *ctx, uint8_t nr_threads)
{ {
STELLAR_LOG_STATE("wait worker thread %d free context", i); STELLAR_LOG_STATE("wait worker thread %d free context", i);
session_manager_destroy(threads_ctx->sess_mgr); session_manager_destroy(threads_ctx->sess_mgr);
ip_reassemble_manager_destory(threads_ctx->ip_mgr); ip_reassembly_destory(threads_ctx->ip_mgr);
} }
} }
} }