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]
cpu_mask = [5, 6, 7, 8, 9, 10, 11, 12]
[ip_reassemble]
[ip_reassembly]
enable = 1
timeout = 10 # seconds
bucket_entries = 8

2
src/CMakeLists.txt
View File

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

2
src/config/CMakeLists.txt
View File

@@ -4,4 +4,4 @@
add_library(config config.cpp)
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
// 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;
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)
{
CONFIG_LOG_ERROR("config file missing ip_reassemble section");
CONFIG_LOG_ERROR("config file missing ip_reassembly section");
return -1;
}
ptr = toml_raw_in(ip_reass_table, "enable");
if (ptr == NULL)
{
CONFIG_LOG_ERROR("config file missing ip_reassemble.enable");
CONFIG_LOG_ERROR("config file missing ip_reassembly.enable");
return -1;
}
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");
if (ptr == NULL)
{
CONFIG_LOG_ERROR("config file missing ip_reassemble.timeout");
CONFIG_LOG_ERROR("config file missing ip_reassembly.timeout");
return -1;
}
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");
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;
}
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");
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;
}
ip_reass_cfg->bucket_num = atoi(ptr);
@@ -395,7 +395,7 @@ int config_load(struct config *cfg, const char *cfg_file)
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;
}
@@ -430,7 +430,7 @@ void config_dump(struct config *cfg)
struct device_config *dev_cfg = &cfg->dev_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;
// device config
@@ -455,10 +455,10 @@ void config_dump(struct config *cfg)
}
// ip reassemble config
CONFIG_LOG_DEBUG("ip_reassemble->enable : %d", ip_reass_cfg->enable);
CONFIG_LOG_DEBUG("ip_reassemble->timeout : %d", ip_reass_cfg->timeout);
CONFIG_LOG_DEBUG("ip_reassemble->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->enable : %d", ip_reass_cfg->enable);
CONFIG_LOG_DEBUG("ip_reassembly->timeout : %d", ip_reass_cfg->timeout);
CONFIG_LOG_DEBUG("ip_reassembly->bucket_entries : %d", ip_reass_cfg->bucket_entries);
CONFIG_LOG_DEBUG("ip_reassembly->bucket_num : %d", ip_reass_cfg->bucket_num);
// session manager config
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 "packet_io.h"
#include "ip_reassemble.h"
#include "ip_reassembly.h"
#include "session_manager.h"
#define CONFIG_LOG_ERROR(format, ...) LOG_ERROR("config", format, ##__VA_ARGS__)
@@ -32,7 +32,7 @@ struct config
{
struct device_config dev_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;
};

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)
target_include_directories(ip_reassemble PUBLIC ${CMAKE_CURRENT_LIST_DIR})
target_link_libraries(ip_reassemble timestamp packet)
add_library(ip_reassembly ip_reassembly.cpp)
target_include_directories(ip_reassembly PUBLIC ${CMAKE_CURRENT_LIST_DIR})
target_link_libraries(ip_reassembly timestamp packet)
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 "ipv6_utils.h"
#include "packet_utils.h"
#include "ip_reassemble.h"
#include "ip_reassembly.h"
#define IPV4_KEYLEN 1
#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_reassemble_manager
struct ip_reassembly
{
// config
bool enable;
@@ -122,7 +122,7 @@ struct ip_reassemble_manager
uint32_t entry_mask;
// stats
struct ip_reassemble_stat stat;
struct ip_reassembly_stat stat;
// hash table
struct
@@ -138,7 +138,7 @@ struct ip_reassemble_manager
* utils
******************************************************************************/
#define ip_reassemble_stat_inc(mgr, filed, key) \
#define ip_reassembly_stat_inc(mgr, filed, key) \
{ \
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));
}
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)
{
@@ -404,7 +404,7 @@ static inline int ip_flow_is_ready(struct ip_flow *flow)
// return 0 : success
// 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,
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)
{
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;
}
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)
{
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;
}
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)
{
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;
}
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
******************************************************************************/
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);
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);
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_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
* 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)
{
@@ -561,20 +561,20 @@ static struct ip_flow *ip_reassemble_manager_find_flow(struct ip_reassemble_mana
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 *free = 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 (expired)
{
IP_REASSEMBLE_DEBUG1("add ip flow success: reuse expired entry", key);
ip_reassemble_manager_reuse_flow(mgr, expired, key);
ip_reassemble_stat_inc(mgr, timeout, key);
ip_reassembly_reuse_flow(mgr, expired, key);
ip_reassembly_stat_inc(mgr, timeout, key);
mgr->last = 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_flow_init(free, key);
ip_reassemble_manager_add_flow(mgr, free);
ip_reassembly_add_flow(mgr, free);
mgr->last = free;
return free;
@@ -592,7 +592,7 @@ static struct ip_flow *ip_reassemble_manager_update_flow(struct ip_reassemble_ma
// no space
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;
}
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())
{
IP_REASSEMBLE_DEBUG1("add ip flow success: reuse expired entry", key);
ip_reassemble_manager_reuse_flow(mgr, flow, key);
ip_reassemble_stat_inc(mgr, timeout, key);
ip_reassembly_reuse_flow(mgr, flow, key);
ip_reassembly_stat_inc(mgr, timeout, key);
mgr->last = flow;
return flow;
@@ -622,7 +622,7 @@ static struct ip_flow *ip_reassemble_manager_update_flow(struct ip_reassemble_ma
* 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 *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;
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);
return NULL;
error_out_overlap:
ip_reassemble_stat_inc(mgr, fail_overlap, &flow->key);
ip_reassembly_stat_inc(mgr, fail_overlap, &flow->key);
packet_free(pkt);
return NULL;
}
@@ -752,14 +752,14 @@ error_out_overlap:
* 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;
}
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)
{
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;
}
void ip_reassemble_manager_destory(struct ip_reassemble_manager *mgr)
void ip_reassembly_destory(struct ip_reassembly *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;
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)
{
IP_REASSEMBLE_DEBUG1("expire ip flow: discarding old fragmented packets", &flow->key);
ip_reassemble_manager_del_flow(mgr, flow);
ip_reassemble_stat_inc(mgr, timeout, &flow->key);
ip_reassembly_del_flow(mgr, flow);
ip_reassembly_stat_inc(mgr, timeout, &flow->key);
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)
{
@@ -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)
{
@@ -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
*/
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 *pkt2;
@@ -896,10 +896,10 @@ struct packet *ip_reassemble_packet(struct ip_reassemble_manager *mgr, const str
if (layer->type == LAYER_TYPE_IPV4)
{
pkt1 = ipv4_reassemble_packet(mgr, pkt);
pkt1 = ipv4_reassembly_packet(mgr, pkt);
if (pkt1 && pkt1->frag_layer)
{
pkt2 = ip_reassemble_packet(mgr, pkt1);
pkt2 = ip_reassembly_packet(mgr, pkt1);
packet_free(pkt1);
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)
{
pkt1 = ipv6_reassemble_packet(mgr, pkt);
pkt1 = ipv6_reassembly_packet(mgr, pkt);
if (pkt1 && pkt1->frag_layer)
{
pkt2 = ip_reassemble_packet(mgr, pkt1);
pkt2 = ip_reassembly_packet(mgr, pkt1);
packet_free(pkt1);
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 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.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)
{
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);
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);
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);
ip_reassemble_manager_del_flow(mgr, flow);
ip_reassembly_del_flow(mgr, flow);
ip_flow_free(flow);
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 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.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)
{
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);
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);
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);
ip_reassemble_manager_del_flow(mgr, flow);
ip_reassembly_del_flow(mgr, flow);
ip_flow_free(flow);
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 "log.h"
#define IP_REASSEMBLE_DEBUG(format, ...) LOG_DEBUG("ip_reassemble", format, ##__VA_ARGS__)
#define IP_REASSEMBLE_ERROR(format, ...) LOG_ERROR("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_reassembly", format, ##__VA_ARGS__)
struct ip_reassemble_config
struct ip_reassembly_config
{
bool enable;
@@ -21,7 +21,7 @@ struct ip_reassemble_config
uint32_t bucket_num;
};
struct ip_reassemble_stat
struct ip_reassembly_stat
{
// IPv4 flow stat
uint64_t ip4_flow_find;
@@ -50,19 +50,19 @@ struct ip_reassemble_stat
uint64_t ip6_flow_bypass_dup_last_frag;
};
struct ip_reassemble_manager *ip_reassemble_manager_create(const struct ip_reassemble_config *config);
void ip_reassemble_manager_destory(struct ip_reassemble_manager *mgr);
void ip_reassemble_manager_expire(struct ip_reassemble_manager *mgr);
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 *ip_reassembly_create(const struct ip_reassembly_config *config);
void ip_reassembly_destory(struct ip_reassembly *mgr);
void ip_reassembly_expire(struct ip_reassembly *mgr);
void ip_reassembly_print_stat(struct ip_reassembly *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
* 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 *ipv4_reassemble_packet(struct ip_reassemble_manager *mgr, const struct packet *pkt);
struct packet *ipv6_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_reassembly_packet(struct ip_reassembly *mgr, const struct packet *pkt);
struct packet *ipv6_reassembly_packet(struct ip_reassembly *mgr, const struct packet *pkt);
#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 *new_pkt;
const struct layer_record *layer;
struct ip_reassemble_manager *mgr;
struct ip_reassemble_config config = {
struct ip_reassembly *mgr;
struct ip_reassembly_config config = {
.enable = true,
.timeout = 1,
.bucket_entries = 16,
@@ -207,10 +207,10 @@ TEST(IPV4_REASSEMBLE, PADDING_ORDER)
timestamp_update();
mgr = ip_reassemble_manager_create(&config);
mgr = ip_reassembly_create(&config);
EXPECT_TRUE(mgr != NULL);
// ip_reassemble_manager_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr),
// ip_reassembly_print_stat(mgr);
check_stat(ip_reassembly_get_stat(mgr),
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, // ip6: find, add, del, timeout
@@ -218,10 +218,10 @@ TEST(IPV4_REASSEMBLE, PADDING_ORDER)
// 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);
// ip_reassemble_manager_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr),
// ip_reassembly_print_stat(mgr);
check_stat(ip_reassembly_get_stat(mgr),
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, // ip6: find, add, del, timeout
@@ -229,10 +229,10 @@ TEST(IPV4_REASSEMBLE, PADDING_ORDER)
// 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);
// ip_reassemble_manager_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr),
// ip_reassembly_print_stat(mgr);
check_stat(ip_reassembly_get_stat(mgr),
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, // ip6: find, add, del, timeout
@@ -282,7 +282,7 @@ TEST(IPV4_REASSEMBLE, PADDING_ORDER)
// free packet
packet_free(new_pkt);
ip_reassemble_manager_destory(mgr);
ip_reassembly_destory(mgr);
}
#endif
@@ -292,8 +292,8 @@ TEST(IPV4_REASSEMBLE, PADDING_UNORDER)
struct packet pkt;
struct packet *new_pkt;
const struct layer_record *layer;
struct ip_reassemble_manager *mgr;
struct ip_reassemble_config config = {
struct ip_reassembly *mgr;
struct ip_reassembly_config config = {
.enable = true,
.timeout = 1,
.bucket_entries = 16,
@@ -302,10 +302,10 @@ TEST(IPV4_REASSEMBLE, PADDING_UNORDER)
timestamp_update();
mgr = ip_reassemble_manager_create(&config);
mgr = ip_reassembly_create(&config);
EXPECT_TRUE(mgr != NULL);
// ip_reassemble_manager_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr),
// ip_reassembly_print_stat(mgr);
check_stat(ip_reassembly_get_stat(mgr),
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, // ip6: find, add, del, timeout
@@ -313,10 +313,10 @@ TEST(IPV4_REASSEMBLE, PADDING_UNORDER)
// 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);
// ip_reassemble_manager_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr),
// ip_reassembly_print_stat(mgr);
check_stat(ip_reassembly_get_stat(mgr),
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, // ip6: find, add, del, timeout
@@ -324,10 +324,10 @@ TEST(IPV4_REASSEMBLE, PADDING_UNORDER)
// 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);
// ip_reassemble_manager_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr),
// ip_reassembly_print_stat(mgr);
check_stat(ip_reassembly_get_stat(mgr),
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, // ip6: find, add, del, timeout
@@ -377,7 +377,7 @@ TEST(IPV4_REASSEMBLE, PADDING_UNORDER)
// free packet
packet_free(new_pkt);
ip_reassemble_manager_destory(mgr);
ip_reassembly_destory(mgr);
}
#endif
@@ -386,8 +386,8 @@ TEST(IPV4_REASSEMBLE, EXPIRE)
{
struct packet pkt;
struct packet *new_pkt;
struct ip_reassemble_manager *mgr;
struct ip_reassemble_config config = {
struct ip_reassembly *mgr;
struct ip_reassembly_config config = {
.enable = true,
.timeout = 1,
.bucket_entries = 16,
@@ -396,10 +396,10 @@ TEST(IPV4_REASSEMBLE, EXPIRE)
timestamp_update();
mgr = ip_reassemble_manager_create(&config);
mgr = ip_reassembly_create(&config);
EXPECT_TRUE(mgr != NULL);
// ip_reassemble_manager_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr),
// ip_reassembly_print_stat(mgr);
check_stat(ip_reassembly_get_stat(mgr),
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, // ip6: find, add, del, timeout
@@ -407,10 +407,10 @@ TEST(IPV4_REASSEMBLE, EXPIRE)
// 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);
// ip_reassemble_manager_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr),
// ip_reassembly_print_stat(mgr);
check_stat(ip_reassembly_get_stat(mgr),
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, // ip6: find, add, del, timeout
@@ -422,10 +422,10 @@ TEST(IPV4_REASSEMBLE, EXPIRE)
// 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);
// ip_reassemble_manager_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr),
// ip_reassembly_print_stat(mgr);
check_stat(ip_reassembly_get_stat(mgr),
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, // ip6: find, add, del, timeout
@@ -434,7 +434,7 @@ TEST(IPV4_REASSEMBLE, EXPIRE)
// free packet
packet_free(new_pkt);
ip_reassemble_manager_destory(mgr);
ip_reassembly_destory(mgr);
}
#endif
@@ -444,8 +444,8 @@ TEST(IPV4_REASSEMBLE, DUP_FIRST_FRAG)
struct packet pkt;
struct packet *new_pkt;
const struct layer_record *layer;
struct ip_reassemble_manager *mgr;
struct ip_reassemble_config config = {
struct ip_reassembly *mgr;
struct ip_reassembly_config config = {
.enable = true,
.timeout = 1,
.bucket_entries = 16,
@@ -454,10 +454,10 @@ TEST(IPV4_REASSEMBLE, DUP_FIRST_FRAG)
timestamp_update();
mgr = ip_reassemble_manager_create(&config);
mgr = ip_reassembly_create(&config);
EXPECT_TRUE(mgr != NULL);
// ip_reassemble_manager_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr),
// ip_reassembly_print_stat(mgr);
check_stat(ip_reassembly_get_stat(mgr),
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, // ip6: find, add, del, timeout
@@ -465,10 +465,10 @@ TEST(IPV4_REASSEMBLE, DUP_FIRST_FRAG)
// 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);
// ip_reassemble_manager_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr),
// ip_reassembly_print_stat(mgr);
check_stat(ip_reassembly_get_stat(mgr),
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, // ip6: find, add, del, timeout
@@ -476,10 +476,10 @@ TEST(IPV4_REASSEMBLE, DUP_FIRST_FRAG)
// 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);
// ip_reassemble_manager_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr),
// ip_reassembly_print_stat(mgr);
check_stat(ip_reassembly_get_stat(mgr),
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, // ip6: find, add, del, timeout
@@ -487,10 +487,10 @@ TEST(IPV4_REASSEMBLE, DUP_FIRST_FRAG)
// 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);
// ip_reassemble_manager_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr),
// ip_reassembly_print_stat(mgr);
check_stat(ip_reassembly_get_stat(mgr),
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, // ip6: find, add, del, timeout
@@ -540,7 +540,7 @@ TEST(IPV4_REASSEMBLE, DUP_FIRST_FRAG)
// free packet
packet_free(new_pkt);
ip_reassemble_manager_destory(mgr);
ip_reassembly_destory(mgr);
}
#endif
@@ -550,8 +550,8 @@ TEST(IPV4_REASSEMBLE, DUP_LAST_FRAG)
struct packet pkt;
struct packet *new_pkt;
const struct layer_record *layer;
struct ip_reassemble_manager *mgr;
struct ip_reassemble_config config = {
struct ip_reassembly *mgr;
struct ip_reassembly_config config = {
.enable = true,
.timeout = 1,
.bucket_entries = 16,
@@ -560,10 +560,10 @@ TEST(IPV4_REASSEMBLE, DUP_LAST_FRAG)
timestamp_update();
mgr = ip_reassemble_manager_create(&config);
mgr = ip_reassembly_create(&config);
EXPECT_TRUE(mgr != NULL);
// ip_reassemble_manager_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr),
// ip_reassembly_print_stat(mgr);
check_stat(ip_reassembly_get_stat(mgr),
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, // ip6: find, add, del, timeout
@@ -571,10 +571,10 @@ TEST(IPV4_REASSEMBLE, DUP_LAST_FRAG)
// 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);
// ip_reassemble_manager_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr),
// ip_reassembly_print_stat(mgr);
check_stat(ip_reassembly_get_stat(mgr),
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, // ip6: find, add, del, timeout
@@ -582,10 +582,10 @@ TEST(IPV4_REASSEMBLE, DUP_LAST_FRAG)
// 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);
// ip_reassemble_manager_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr),
// ip_reassembly_print_stat(mgr);
check_stat(ip_reassembly_get_stat(mgr),
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, // ip6: find, add, del, timeout
@@ -593,10 +593,10 @@ TEST(IPV4_REASSEMBLE, DUP_LAST_FRAG)
// 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);
// ip_reassemble_manager_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr),
// ip_reassembly_print_stat(mgr);
check_stat(ip_reassembly_get_stat(mgr),
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, // ip6: find, add, del, timeout
@@ -646,7 +646,7 @@ TEST(IPV4_REASSEMBLE, DUP_LAST_FRAG)
// free packet
packet_free(new_pkt);
ip_reassemble_manager_destory(mgr);
ip_reassembly_destory(mgr);
}
#endif
@@ -655,8 +655,8 @@ TEST(IPV4_REASSEMBLE, FULL)
{
struct packet pkt;
struct packet *new_pkt;
struct ip_reassemble_manager *mgr;
struct ip_reassemble_config config = {
struct ip_reassembly *mgr;
struct ip_reassembly_config config = {
.enable = true,
.timeout = 1,
.bucket_entries = 1,
@@ -665,10 +665,10 @@ TEST(IPV4_REASSEMBLE, FULL)
timestamp_update();
mgr = ip_reassemble_manager_create(&config);
mgr = ip_reassembly_create(&config);
EXPECT_TRUE(mgr != NULL);
// ip_reassemble_manager_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr),
// ip_reassembly_print_stat(mgr);
check_stat(ip_reassembly_get_stat(mgr),
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, // ip6: find, add, del, timeout
@@ -680,10 +680,10 @@ TEST(IPV4_REASSEMBLE, FULL)
// flow1
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);
// ip_reassemble_manager_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr),
// ip_reassembly_print_stat(mgr);
check_stat(ip_reassembly_get_stat(mgr),
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, // ip6: find, add, del, timeout
@@ -691,10 +691,10 @@ TEST(IPV4_REASSEMBLE, FULL)
// flow2
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);
// ip_reassemble_manager_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr),
// ip_reassembly_print_stat(mgr);
check_stat(ip_reassembly_get_stat(mgr),
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, // ip6: find, add, del, timeout
@@ -702,10 +702,10 @@ TEST(IPV4_REASSEMBLE, FULL)
// flow3
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);
// ip_reassemble_manager_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr),
// ip_reassembly_print_stat(mgr);
check_stat(ip_reassembly_get_stat(mgr),
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
0, 0, 0, 0, // ip6: find, add, del, timeout
@@ -714,7 +714,7 @@ TEST(IPV4_REASSEMBLE, FULL)
// free packet
packet_free(new_pkt);
ip_reassemble_manager_destory(mgr);
ip_reassembly_destory(mgr);
}
#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 *new_pkt;
const struct layer_record *layer;
struct ip_reassemble_manager *mgr;
struct ip_reassemble_config config = {
struct ip_reassembly *mgr;
struct ip_reassembly_config config = {
.enable = true,
.timeout = 1,
.bucket_entries = 16,
@@ -618,10 +618,10 @@ TEST(IPV6_REASSEMBLE, NORMAL)
timestamp_update();
mgr = ip_reassemble_manager_create(&config);
mgr = ip_reassembly_create(&config);
EXPECT_TRUE(mgr != NULL);
// ip_reassemble_manager_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr),
// ip_reassembly_print_stat(mgr);
check_stat(ip_reassembly_get_stat(mgr),
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, // ip6: find, add, del, timeout
@@ -629,10 +629,10 @@ TEST(IPV6_REASSEMBLE, NORMAL)
// 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);
// ip_reassemble_manager_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr),
// ip_reassembly_print_stat(mgr);
check_stat(ip_reassembly_get_stat(mgr),
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
1, 1, 0, 0, // ip6: find, add, del, timeout
@@ -640,10 +640,10 @@ TEST(IPV6_REASSEMBLE, NORMAL)
// 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);
// ip_reassemble_manager_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr),
// ip_reassembly_print_stat(mgr);
check_stat(ip_reassembly_get_stat(mgr),
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
2, 1, 0, 0, // ip6: find, add, del, timeout
@@ -651,10 +651,10 @@ TEST(IPV6_REASSEMBLE, NORMAL)
// 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);
// ip_reassemble_manager_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr),
// ip_reassembly_print_stat(mgr);
check_stat(ip_reassembly_get_stat(mgr),
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
3, 1, 0, 0, // ip6: find, add, del, timeout
@@ -662,10 +662,10 @@ TEST(IPV6_REASSEMBLE, NORMAL)
// 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);
// ip_reassemble_manager_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr),
// ip_reassembly_print_stat(mgr);
check_stat(ip_reassembly_get_stat(mgr),
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
4, 1, 1, 0, // ip6: find, add, del, timeout
@@ -709,7 +709,7 @@ TEST(IPV6_REASSEMBLE, NORMAL)
// free packet
packet_free(new_pkt);
ip_reassemble_manager_destory(mgr);
ip_reassembly_destory(mgr);
}
#endif
@@ -718,8 +718,8 @@ TEST(IPV6_REASSEMBLE, EXPIRE)
{
struct packet pkt;
struct packet *new_pkt;
struct ip_reassemble_manager *mgr;
struct ip_reassemble_config config = {
struct ip_reassembly *mgr;
struct ip_reassembly_config config = {
.enable = true,
.timeout = 1,
.bucket_entries = 16,
@@ -728,10 +728,10 @@ TEST(IPV6_REASSEMBLE, EXPIRE)
timestamp_update();
mgr = ip_reassemble_manager_create(&config);
mgr = ip_reassembly_create(&config);
EXPECT_TRUE(mgr != NULL);
// ip_reassemble_manager_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr),
// ip_reassembly_print_stat(mgr);
check_stat(ip_reassembly_get_stat(mgr),
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, // ip6: find, add, del, timeout
@@ -739,10 +739,10 @@ TEST(IPV6_REASSEMBLE, EXPIRE)
// 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);
// ip_reassemble_manager_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr),
// ip_reassembly_print_stat(mgr);
check_stat(ip_reassembly_get_stat(mgr),
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
1, 1, 0, 0, // ip6: find, add, del, timeout
@@ -754,10 +754,10 @@ TEST(IPV6_REASSEMBLE, EXPIRE)
// 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);
// ip_reassemble_manager_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr),
// ip_reassembly_print_stat(mgr);
check_stat(ip_reassembly_get_stat(mgr),
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
2, 2, 1, 1, // ip6: find, add, del, timeout
@@ -766,7 +766,7 @@ TEST(IPV6_REASSEMBLE, EXPIRE)
// free packet
packet_free(new_pkt);
ip_reassemble_manager_destory(mgr);
ip_reassembly_destory(mgr);
}
#endif
@@ -776,8 +776,8 @@ TEST(IPV6_REASSEMBLE, DUP_FIRST_FRAG)
struct packet pkt;
struct packet *new_pkt;
const struct layer_record *layer;
struct ip_reassemble_manager *mgr;
struct ip_reassemble_config config = {
struct ip_reassembly *mgr;
struct ip_reassembly_config config = {
.enable = true,
.timeout = 1,
.bucket_entries = 16,
@@ -786,10 +786,10 @@ TEST(IPV6_REASSEMBLE, DUP_FIRST_FRAG)
timestamp_update();
mgr = ip_reassemble_manager_create(&config);
mgr = ip_reassembly_create(&config);
EXPECT_TRUE(mgr != NULL);
// ip_reassemble_manager_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr),
// ip_reassembly_print_stat(mgr);
check_stat(ip_reassembly_get_stat(mgr),
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, // ip6: find, add, del, timeout
@@ -797,10 +797,10 @@ TEST(IPV6_REASSEMBLE, DUP_FIRST_FRAG)
// 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);
// ip_reassemble_manager_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr),
// ip_reassembly_print_stat(mgr);
check_stat(ip_reassembly_get_stat(mgr),
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
1, 1, 0, 0, // ip6: find, add, del, timeout
@@ -808,10 +808,10 @@ TEST(IPV6_REASSEMBLE, DUP_FIRST_FRAG)
// 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);
// ip_reassemble_manager_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr),
// ip_reassembly_print_stat(mgr);
check_stat(ip_reassembly_get_stat(mgr),
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
2, 1, 0, 0, // ip6: find, add, del, timeout
@@ -819,10 +819,10 @@ TEST(IPV6_REASSEMBLE, DUP_FIRST_FRAG)
// 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);
// ip_reassemble_manager_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr),
// ip_reassembly_print_stat(mgr);
check_stat(ip_reassembly_get_stat(mgr),
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
3, 1, 0, 0, // ip6: find, add, del, timeout
@@ -830,10 +830,10 @@ TEST(IPV6_REASSEMBLE, DUP_FIRST_FRAG)
// 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);
// ip_reassemble_manager_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr),
// ip_reassembly_print_stat(mgr);
check_stat(ip_reassembly_get_stat(mgr),
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
4, 1, 0, 0, // ip6: find, add, del, timeout
@@ -841,10 +841,10 @@ TEST(IPV6_REASSEMBLE, DUP_FIRST_FRAG)
// 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);
// ip_reassemble_manager_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr),
// ip_reassembly_print_stat(mgr);
check_stat(ip_reassembly_get_stat(mgr),
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
5, 1, 1, 0, // ip6: find, add, del, timeout
@@ -888,7 +888,7 @@ TEST(IPV6_REASSEMBLE, DUP_FIRST_FRAG)
// free packet
packet_free(new_pkt);
ip_reassemble_manager_destory(mgr);
ip_reassembly_destory(mgr);
}
#endif
@@ -898,8 +898,8 @@ TEST(IPV6_REASSEMBLE, DUP_LAST_FRAG)
struct packet pkt;
struct packet *new_pkt;
const struct layer_record *layer;
struct ip_reassemble_manager *mgr;
struct ip_reassemble_config config = {
struct ip_reassembly *mgr;
struct ip_reassembly_config config = {
.enable = true,
.timeout = 1,
.bucket_entries = 16,
@@ -908,10 +908,10 @@ TEST(IPV6_REASSEMBLE, DUP_LAST_FRAG)
timestamp_update();
mgr = ip_reassemble_manager_create(&config);
mgr = ip_reassembly_create(&config);
EXPECT_TRUE(mgr != NULL);
// ip_reassemble_manager_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr),
// ip_reassembly_print_stat(mgr);
check_stat(ip_reassembly_get_stat(mgr),
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, // ip6: find, add, del, timeout
@@ -919,10 +919,10 @@ TEST(IPV6_REASSEMBLE, DUP_LAST_FRAG)
// 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);
// ip_reassemble_manager_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr),
// ip_reassembly_print_stat(mgr);
check_stat(ip_reassembly_get_stat(mgr),
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
1, 1, 0, 0, // ip6: find, add, del, timeout
@@ -930,10 +930,10 @@ TEST(IPV6_REASSEMBLE, DUP_LAST_FRAG)
// 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);
// ip_reassemble_manager_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr),
// ip_reassembly_print_stat(mgr);
check_stat(ip_reassembly_get_stat(mgr),
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
2, 1, 0, 0, // ip6: find, add, del, timeout
@@ -941,10 +941,10 @@ TEST(IPV6_REASSEMBLE, DUP_LAST_FRAG)
// 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);
// ip_reassemble_manager_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr),
// ip_reassembly_print_stat(mgr);
check_stat(ip_reassembly_get_stat(mgr),
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
3, 1, 0, 0, // ip6: find, add, del, timeout
@@ -952,10 +952,10 @@ TEST(IPV6_REASSEMBLE, DUP_LAST_FRAG)
// 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);
// ip_reassemble_manager_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr),
// ip_reassembly_print_stat(mgr);
check_stat(ip_reassembly_get_stat(mgr),
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
4, 1, 0, 0, // ip6: find, add, del, timeout
@@ -963,10 +963,10 @@ TEST(IPV6_REASSEMBLE, DUP_LAST_FRAG)
// 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);
// ip_reassemble_manager_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr),
// ip_reassembly_print_stat(mgr);
check_stat(ip_reassembly_get_stat(mgr),
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
5, 1, 1, 0, // ip6: find, add, del, timeout
@@ -1010,7 +1010,7 @@ TEST(IPV6_REASSEMBLE, DUP_LAST_FRAG)
// free packet
packet_free(new_pkt);
ip_reassemble_manager_destory(mgr);
ip_reassembly_destory(mgr);
}
#endif
@@ -1020,8 +1020,8 @@ TEST(IPV6_REASSEMBLE, FULL)
struct packet pkt;
struct packet *new_pkt;
struct in6_addr src_addr;
struct ip_reassemble_manager *mgr;
struct ip_reassemble_config config = {
struct ip_reassembly *mgr;
struct ip_reassembly_config config = {
.enable = true,
.timeout = 1,
.bucket_entries = 1,
@@ -1030,10 +1030,10 @@ TEST(IPV6_REASSEMBLE, FULL)
timestamp_update();
mgr = ip_reassemble_manager_create(&config);
mgr = ip_reassembly_create(&config);
EXPECT_TRUE(mgr != NULL);
// ip_reassemble_manager_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr),
// ip_reassembly_print_stat(mgr);
check_stat(ip_reassembly_get_stat(mgr),
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, // ip6: find, add, del, timeout
@@ -1046,10 +1046,10 @@ TEST(IPV6_REASSEMBLE, FULL)
// flow1
memset(&src_addr, 1, sizeof(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);
// ip_reassemble_manager_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr),
// ip_reassembly_print_stat(mgr);
check_stat(ip_reassembly_get_stat(mgr),
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
1, 1, 0, 0, // ip6: find, add, del, timeout
@@ -1058,10 +1058,10 @@ TEST(IPV6_REASSEMBLE, FULL)
// flow2
memset(&src_addr, 2, sizeof(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);
// ip_reassemble_manager_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr),
// ip_reassembly_print_stat(mgr);
check_stat(ip_reassembly_get_stat(mgr),
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
2, 2, 0, 0, // ip6: find, add, del, timeout
@@ -1070,10 +1070,10 @@ TEST(IPV6_REASSEMBLE, FULL)
// flow3
memset(&src_addr, 3, sizeof(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);
// ip_reassemble_manager_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr),
// ip_reassembly_print_stat(mgr);
check_stat(ip_reassembly_get_stat(mgr),
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
3, 2, 0, 0, // ip6: find, add, del, timeout
@@ -1082,7 +1082,7 @@ TEST(IPV6_REASSEMBLE, FULL)
// free packet
packet_free(new_pkt);
ip_reassemble_manager_destory(mgr);
ip_reassembly_destory(mgr);
}
#endif
@@ -1091,8 +1091,8 @@ TEST(IPV6_REASSEMBLE, OVERLAP)
{
struct packet pkt;
struct packet *new_pkt;
struct ip_reassemble_manager *mgr;
struct ip_reassemble_config config = {
struct ip_reassembly *mgr;
struct ip_reassembly_config config = {
.enable = true,
.timeout = 1,
.bucket_entries = 16,
@@ -1101,10 +1101,10 @@ TEST(IPV6_REASSEMBLE, OVERLAP)
timestamp_update();
mgr = ip_reassemble_manager_create(&config);
mgr = ip_reassembly_create(&config);
EXPECT_TRUE(mgr != NULL);
// ip_reassemble_manager_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr),
// ip_reassembly_print_stat(mgr);
check_stat(ip_reassembly_get_stat(mgr),
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, // ip6: find, add, del, timeout
@@ -1112,10 +1112,10 @@ TEST(IPV6_REASSEMBLE, OVERLAP)
// 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);
// ip_reassemble_manager_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr),
// ip_reassembly_print_stat(mgr);
check_stat(ip_reassembly_get_stat(mgr),
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
1, 1, 0, 0, // ip6: find, add, del, timeout
@@ -1123,10 +1123,10 @@ TEST(IPV6_REASSEMBLE, OVERLAP)
// 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);
// ip_reassemble_manager_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr),
// ip_reassembly_print_stat(mgr);
check_stat(ip_reassembly_get_stat(mgr),
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
2, 1, 0, 0, // ip6: find, add, del, timeout
@@ -1137,10 +1137,10 @@ TEST(IPV6_REASSEMBLE, OVERLAP)
memcpy(dup_frag, frag3, sizeof(frag3));
packet_parse(&pkt, (const char *)dup_frag, sizeof(dup_frag));
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);
// ip_reassemble_manager_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr),
// ip_reassembly_print_stat(mgr);
check_stat(ip_reassembly_get_stat(mgr),
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
3, 1, 0, 0, // ip6: find, add, del, timeout
@@ -1148,10 +1148,10 @@ TEST(IPV6_REASSEMBLE, OVERLAP)
// 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);
// ip_reassemble_manager_print_stat(mgr);
check_stat(ip_reassemble_manager_get_stat(mgr),
// ip_reassembly_print_stat(mgr);
check_stat(ip_reassembly_get_stat(mgr),
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
4, 1, 1, 0, // ip6: find, add, del, timeout
@@ -1160,7 +1160,7 @@ TEST(IPV6_REASSEMBLE, OVERLAP)
// free packet
packet_free(new_pkt);
ip_reassemble_manager_destory(mgr);
ip_reassembly_destory(mgr);
}
#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 "ipv6_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)
{
@@ -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);
}
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_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,

14
src/stellar/stellar.cpp
View File

@@ -15,7 +15,7 @@
#include "packet_io.h"
#include "timestamp.h"
#include "id_generator.h"
#include "ip_reassemble.h"
#include "ip_reassembly.h"
#include "session_manager.h"
#define STELLAR_LOG_STATE(format, ...) LOG_STATE("stellar", format, ##__VA_ARGS__)
@@ -32,7 +32,7 @@ struct thread_context
uint64_t need_exit;
uint64_t is_runing;
struct session_manager *sess_mgr;
struct ip_reassemble_manager *ip_mgr;
struct ip_reassembly *ip_mgr;
};
struct stellar_context
@@ -50,7 +50,7 @@ struct stellar_context *stellar_ctx = &stellar_context;
// config
struct device_config *dev_cfg = &stellar_context.config.dev_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;
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;
struct packet_io *packet_io = stellar_ctx->packet_io;
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)
{
@@ -163,7 +163,7 @@ static void *main_loop(void *arg)
// ip fragment reassemble
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
packet_io_send(packet_io, thd_idx, pkt);
if (temp == NULL)
@@ -214,7 +214,7 @@ static int thread_context_init(struct stellar_context *ctx, uint8_t nr_threads)
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)
{
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);
session_manager_destroy(threads_ctx->sess_mgr);
ip_reassemble_manager_destory(threads_ctx->ip_mgr);
ip_reassembly_destory(threads_ctx->ip_mgr);
}
}
}