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

reactor packet I/O & duplicated packet filter & evicted session filter

Browse Source
This commit is contained in:
luwenpeng
2024-03-09 19:28:14 +08:00
parent ee35a26a9d
commit 512dfddd03
79 changed files with 1974 additions and 2093 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/ip_reassembly/CMakeLists.txt
View File

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

88
src/ip_reassembly/ip_reassembly.cpp
View File

@@ -4,12 +4,10 @@
#include <assert.h>
#include "packet.h"
#include "timestamp.h"
#include "crc32_hash.h"
#include "checksum.h"
#include "ipv4_utils.h"
#include "ipv6_utils.h"
#include "packet_utils.h"
#include "ip_reassembly.h"
#define IPV4_KEYLEN 1
@@ -303,7 +301,7 @@ static inline void ip_flow_key_zero(struct ip_flow_key *key)
static inline void ip_frag_hdr_init(struct ip_frag_hdr *hdr, const struct packet *pkt)
{
struct layer_record *layer = pkt->frag_layer;
struct layer *layer = pkt->frag_layer;
if (layer->type == LAYER_TYPE_IPV6)
{
@@ -367,7 +365,7 @@ static inline void ip_frag_pkt_free(struct ip_frag_pkt *frag)
* ip flow
******************************************************************************/
static inline void ip_flow_init(struct ip_flow *flow, const struct ip_flow_key *key)
static inline void ip_flow_init(struct ip_flow *flow, const struct ip_flow_key *key, uint64_t now_sec)
{
static const struct ip_frag_pkt zero_frag = {
.data = NULL,
@@ -378,7 +376,7 @@ static inline void ip_flow_init(struct ip_flow *flow, const struct ip_flow_key *
flow->lru.tqe_next = NULL;
flow->lru.tqe_prev = NULL;
flow->key = *key;
flow->create_time = timestamp_get_sec();
flow->create_time = now_sec;
flow->expected_total_size = UINT32_MAX;
flow->received_frag_size = 0;
flow->next_fill_idx = IP_MIN_FRAG_NUM;
@@ -480,11 +478,11 @@ static inline void ip_reassembly_del_flow(struct ip_reassembly *mgr, struct ip_f
mgr->entry_used--;
}
static inline void ip_reassembly_reuse_flow(struct ip_reassembly *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, uint64_t now_sec)
{
ip_reassembly_del_flow(mgr, flow);
ip_flow_free(flow);
ip_flow_init(flow, key);
ip_flow_init(flow, key, now_sec);
ip_reassembly_add_flow(mgr, flow);
}
@@ -493,7 +491,7 @@ static inline void ip_reassembly_reuse_flow(struct ip_reassembly *mgr, struct ip
* free : the first empty entry in the bucket
* expired: the first timed-out entry in the bucket
*/
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)
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, uint64_t now_sec)
{
ip_reassembly_stat_inc(mgr, find, key);
@@ -522,7 +520,6 @@ static struct ip_flow *ip_reassembly_find_flow(struct ip_reassembly *mgr, const
struct ip_flow *empty = NULL;
uint64_t timeout = mgr->timeout;
uint32_t assoc = mgr->bucket_entries;
uint64_t tms = timestamp_get_sec();
for (uint32_t i = 0; i != assoc; i++)
{
if (ip_flow_key_cmp(key, &p1[i].key) == 0)
@@ -535,7 +532,7 @@ static struct ip_flow *ip_reassembly_find_flow(struct ip_reassembly *mgr, const
{
empty = (empty == NULL) ? (p1 + i) : empty;
}
else if (timeout + p1[i].create_time <= tms)
else if (timeout + p1[i].create_time <= now_sec)
{
old = (old == NULL) ? (p1 + i) : old;
}
@@ -550,7 +547,7 @@ static struct ip_flow *ip_reassembly_find_flow(struct ip_reassembly *mgr, const
{
empty = (empty == NULL) ? (p2 + i) : empty;
}
else if (timeout + p2[i].create_time <= tms)
else if (timeout + p2[i].create_time <= now_sec)
{
old = (old == NULL) ? (p2 + i) : old;
}
@@ -561,19 +558,19 @@ static struct ip_flow *ip_reassembly_find_flow(struct ip_reassembly *mgr, const
return NULL;
}
static struct ip_flow *ip_reassembly_update_flow(struct ip_reassembly *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, uint64_t now_sec)
{
struct ip_flow *flow = NULL;
struct ip_flow *free = NULL;
struct ip_flow *expired = NULL;
flow = ip_reassembly_find_flow(mgr, key, &free, &expired);
flow = ip_reassembly_find_flow(mgr, key, &free, &expired, now_sec);
if (flow == NULL)
{
if (expired)
{
IP_REASSEMBLE_DEBUG1("add ip flow success: reuse expired entry", key);
ip_reassembly_reuse_flow(mgr, expired, key);
ip_reassembly_reuse_flow(mgr, expired, key, now_sec);
ip_reassembly_stat_inc(mgr, timeout, key);
mgr->last = expired;
@@ -583,7 +580,7 @@ static struct ip_flow *ip_reassembly_update_flow(struct ip_reassembly *mgr, cons
if (free)
{
IP_REASSEMBLE_DEBUG1("add ip flow success: use free entry", key);
ip_flow_init(free, key);
ip_flow_init(free, key, now_sec);
ip_reassembly_add_flow(mgr, free);
mgr->last = free;
@@ -598,10 +595,10 @@ static struct ip_flow *ip_reassembly_update_flow(struct ip_reassembly *mgr, cons
else
{
// expired
if (mgr->timeout + flow->create_time <= timestamp_get_sec())
if (mgr->timeout + flow->create_time <= now_sec)
{
IP_REASSEMBLE_DEBUG1("add ip flow success: reuse expired entry", key);
ip_reassembly_reuse_flow(mgr, flow, key);
ip_reassembly_reuse_flow(mgr, flow, key, now_sec);
ip_reassembly_stat_inc(mgr, timeout, key);
mgr->last = flow;
@@ -817,14 +814,13 @@ void ip_reassembly_free(struct ip_reassembly *mgr)
}
}
void ip_reassembly_expire(struct ip_reassembly *mgr)
void ip_reassembly_expire(struct ip_reassembly *mgr, uint64_t now_sec)
{
struct ip_flow *flow = NULL;
uint64_t curr_ts = timestamp_get_sec();
uint64_t timeout = mgr->timeout;
TAILQ_FOREACH(flow, &mgr->lru, lru)
if (timeout + flow->create_time <= curr_ts)
if (timeout + flow->create_time <= now_sec)
{
IP_REASSEMBLE_DEBUG1("expire ip flow: discarding old fragmented packets", &flow->key);
ip_reassembly_del_flow(mgr, flow);
@@ -833,34 +829,6 @@ void ip_reassembly_expire(struct ip_reassembly *mgr)
}
}
void ip_reassembly_print_stat(struct ip_reassembly *mgr)
{
if (mgr)
{
IP_REASSEMBLE_DEBUG("ip4_flow_find : %lu", mgr->stat.ip4_flow_find);
IP_REASSEMBLE_DEBUG("ip4_flow_add : %lu", mgr->stat.ip4_flow_add);
IP_REASSEMBLE_DEBUG("ip4_flow_del : %lu", mgr->stat.ip4_flow_del);
IP_REASSEMBLE_DEBUG("ip4_flow_timeout : %lu", mgr->stat.ip4_flow_timeout);
IP_REASSEMBLE_DEBUG("ip4_flow_fail_no_space : %lu", mgr->stat.ip4_flow_fail_no_space);
IP_REASSEMBLE_DEBUG("ip4_flow_fail_overlap : %lu", mgr->stat.ip4_flow_fail_overlap);
IP_REASSEMBLE_DEBUG("ip4_flow_fail_many_frag : %lu", mgr->stat.ip4_flow_fail_many_frag);
IP_REASSEMBLE_DEBUG("ip4_flow_fail_invalid_length : %lu", mgr->stat.ip4_flow_fail_invalid_length);
IP_REASSEMBLE_DEBUG("ip4_flow_bypass_dup_fist_frag : %lu", mgr->stat.ip4_flow_bypass_dup_fist_frag);
IP_REASSEMBLE_DEBUG("ip4_flow_bypass_dup_last_frag : %lu", mgr->stat.ip4_flow_bypass_dup_last_frag);
IP_REASSEMBLE_DEBUG("ip6_flow_find : %lu", mgr->stat.ip6_flow_find);
IP_REASSEMBLE_DEBUG("ip6_flow_add : %lu", mgr->stat.ip6_flow_add);
IP_REASSEMBLE_DEBUG("ip6_flow_del : %lu", mgr->stat.ip6_flow_del);
IP_REASSEMBLE_DEBUG("ip6_flow_timeout : %lu", mgr->stat.ip6_flow_timeout);
IP_REASSEMBLE_DEBUG("ip6_flow_fail_no_space : %lu", mgr->stat.ip6_flow_fail_no_space);
IP_REASSEMBLE_DEBUG("ip6_flow_fail_overlap : %lu", mgr->stat.ip6_flow_fail_overlap);
IP_REASSEMBLE_DEBUG("ip6_flow_fail_many_frag : %lu", mgr->stat.ip6_flow_fail_many_frag);
IP_REASSEMBLE_DEBUG("ip6_flow_fail_invalid_length : %lu", mgr->stat.ip6_flow_fail_invalid_length);
IP_REASSEMBLE_DEBUG("ip6_flow_bypass_dup_fist_frag : %lu", mgr->stat.ip6_flow_bypass_dup_fist_frag);
IP_REASSEMBLE_DEBUG("ip6_flow_bypass_dup_last_frag : %lu", mgr->stat.ip6_flow_bypass_dup_last_frag);
}
}
struct ip_reassembly_stat *ip_reassembly_get_stat(struct ip_reassembly *mgr)
{
if (mgr)
@@ -878,7 +846,7 @@ struct ip_reassembly_stat *ip_reassembly_get_stat(struct ip_reassembly *mgr)
* The returned packet should be freed by calling the packet_free() function
*/
struct packet *ip_reassembly_packet(struct ip_reassembly *mgr, const struct packet *pkt)
struct packet *ip_reassembly_packet(struct ip_reassembly *mgr, const struct packet *pkt, uint64_t now_sec)
{
struct packet *pkt1;
struct packet *pkt2;
@@ -888,7 +856,7 @@ struct packet *ip_reassembly_packet(struct ip_reassembly *mgr, const struct pack
return NULL;
}
const struct layer_record *layer = pkt->frag_layer;
const struct layer *layer = pkt->frag_layer;
if (layer == NULL)
{
return NULL;
@@ -896,10 +864,10 @@ struct packet *ip_reassembly_packet(struct ip_reassembly *mgr, const struct pack
if (layer->type == LAYER_TYPE_IPV4)
{
pkt1 = ipv4_reassembly_packet(mgr, pkt);
pkt1 = ipv4_reassembly_packet(mgr, pkt, now_sec);
if (pkt1 && pkt1->frag_layer)
{
pkt2 = ip_reassembly_packet(mgr, pkt1);
pkt2 = ip_reassembly_packet(mgr, pkt1, now_sec);
packet_free(pkt1);
return pkt2;
}
@@ -908,10 +876,10 @@ struct packet *ip_reassembly_packet(struct ip_reassembly *mgr, const struct pack
}
else if (layer->type == LAYER_TYPE_IPV6)
{
pkt1 = ipv6_reassembly_packet(mgr, pkt);
pkt1 = ipv6_reassembly_packet(mgr, pkt, now_sec);
if (pkt1 && pkt1->frag_layer)
{
pkt2 = ip_reassembly_packet(mgr, pkt1);
pkt2 = ip_reassembly_packet(mgr, pkt1, now_sec);
packet_free(pkt1);
return pkt2;
}
@@ -924,9 +892,9 @@ struct packet *ip_reassembly_packet(struct ip_reassembly *mgr, const struct pack
}
}
struct packet *ipv4_reassembly_packet(struct ip_reassembly *mgr, const struct packet *pkt)
struct packet *ipv4_reassembly_packet(struct ip_reassembly *mgr, const struct packet *pkt, uint64_t now_sec)
{
const struct layer_record *layer = pkt->frag_layer;
const struct layer *layer = pkt->frag_layer;
const struct ip *hdr = (const struct ip *)layer->hdr_ptr;
uint16_t frag_len = ipv4_hdr_get_total_len(hdr) - ipv4_hdr_get_hdr_len(hdr);
if (frag_len > layer->pld_len)
@@ -943,7 +911,7 @@ struct packet *ipv4_reassembly_packet(struct ip_reassembly *mgr, const struct pa
key.ip_id = ipv4_hdr_get_ipid(hdr);
key.proto = ipv4_hdr_get_proto(hdr);
struct ip_flow *flow = ip_reassembly_update_flow(mgr, &key);
struct ip_flow *flow = ip_reassembly_update_flow(mgr, &key, now_sec);
if (flow == NULL)
{
return NULL;
@@ -1010,9 +978,9 @@ struct packet *ipv4_reassembly_packet(struct ip_reassembly *mgr, const struct pa
* +-----------------+-----------------+--------+--------+-//-+--------+
*/
struct packet *ipv6_reassembly_packet(struct ip_reassembly *mgr, const struct packet *pkt)
struct packet *ipv6_reassembly_packet(struct ip_reassembly *mgr, const struct packet *pkt, uint64_t now_sec)
{
const struct layer_record *layer = pkt->frag_layer;
const struct layer *layer = pkt->frag_layer;
const struct ip6_hdr *hdr = (const struct ip6_hdr *)layer->hdr_ptr;
const struct ip6_frag *frag_hdr = ipv6_hdr_get_frag_ext(hdr);
if (frag_hdr == NULL)
@@ -1035,7 +1003,7 @@ struct packet *ipv6_reassembly_packet(struct ip_reassembly *mgr, const struct pa
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_reassembly_update_flow(mgr, &key);
struct ip_flow *flow = ip_reassembly_update_flow(mgr, &key, now_sec);
if (flow == NULL)
{
return NULL;

9
src/ip_reassembly/ip_reassembly.h
View File

@@ -52,17 +52,16 @@ struct ip_reassembly_stat
struct ip_reassembly *ip_reassembly_new(const struct ip_reassembly_options *opts);
void ip_reassembly_free(struct ip_reassembly *mgr);
void ip_reassembly_expire(struct ip_reassembly *mgr);
void ip_reassembly_print_stat(struct ip_reassembly *mgr);
void ip_reassembly_expire(struct ip_reassembly *mgr, uint64_t now_sec);
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_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);
struct packet *ip_reassembly_packet(struct ip_reassembly *mgr, const struct packet *pkt, uint64_t now_sec);
struct packet *ipv4_reassembly_packet(struct ip_reassembly *mgr, const struct packet *pkt, uint64_t now_sec);
struct packet *ipv6_reassembly_packet(struct ip_reassembly *mgr, const struct packet *pkt, uint64_t now_sec);
#ifdef __cpluscplus
}

4
src/ip_reassembly/test/CMakeLists.txt
View File

@@ -1,7 +1,3 @@
###############################################################################
# gtest
###############################################################################
add_executable(gtest_ipv4_reassembly gtest_ipv4_reassembly.cpp)
target_link_libraries(gtest_ipv4_reassembly ip_reassembly gtest)

96
src/ip_reassembly/test/gtest_ipv4_reassembly.cpp
View File

@@ -196,7 +196,7 @@ TEST(IPV4_REASSEMBLE, PADDING_ORDER)
{
struct packet pkt;
struct packet *new_pkt;
const struct layer_record *layer;
const struct layer *layer;
struct ip_reassembly *mgr;
struct ip_reassembly_options opts = {
.enable = true,
@@ -205,11 +205,9 @@ TEST(IPV4_REASSEMBLE, PADDING_ORDER)
.bucket_num = 8,
};
timestamp_update();
mgr = ip_reassembly_new(&opts);
EXPECT_TRUE(mgr != NULL);
// 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
@@ -218,9 +216,9 @@ TEST(IPV4_REASSEMBLE, PADDING_ORDER)
// frag1
packet_parse(&pkt, (const char *)frag1, sizeof(frag1));
new_pkt = ip_reassembly_packet(mgr, &pkt);
new_pkt = ip_reassembly_packet(mgr, &pkt, 1);
EXPECT_TRUE(new_pkt == NULL);
// 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
@@ -229,9 +227,9 @@ TEST(IPV4_REASSEMBLE, PADDING_ORDER)
// frag2
packet_parse(&pkt, (const char *)frag2, sizeof(frag2));
new_pkt = ip_reassembly_packet(mgr, &pkt);
new_pkt = ip_reassembly_packet(mgr, &pkt, 1);
EXPECT_TRUE(new_pkt);
// 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
@@ -291,7 +289,7 @@ TEST(IPV4_REASSEMBLE, PADDING_UNORDER)
{
struct packet pkt;
struct packet *new_pkt;
const struct layer_record *layer;
const struct layer *layer;
struct ip_reassembly *mgr;
struct ip_reassembly_options opts = {
.enable = true,
@@ -300,11 +298,9 @@ TEST(IPV4_REASSEMBLE, PADDING_UNORDER)
.bucket_num = 8,
};
timestamp_update();
mgr = ip_reassembly_new(&opts);
EXPECT_TRUE(mgr != NULL);
// 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
@@ -313,9 +309,9 @@ TEST(IPV4_REASSEMBLE, PADDING_UNORDER)
// frag2
packet_parse(&pkt, (const char *)frag2, sizeof(frag2));
new_pkt = ip_reassembly_packet(mgr, &pkt);
new_pkt = ip_reassembly_packet(mgr, &pkt, 1);
EXPECT_TRUE(new_pkt == NULL);
// 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
@@ -324,9 +320,9 @@ TEST(IPV4_REASSEMBLE, PADDING_UNORDER)
// frag1
packet_parse(&pkt, (const char *)frag1, sizeof(frag1));
new_pkt = ip_reassembly_packet(mgr, &pkt);
new_pkt = ip_reassembly_packet(mgr, &pkt, 1);
EXPECT_TRUE(new_pkt);
// 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
@@ -394,11 +390,9 @@ TEST(IPV4_REASSEMBLE, EXPIRE)
.bucket_num = 8,
};
timestamp_update();
mgr = ip_reassembly_new(&opts);
EXPECT_TRUE(mgr != NULL);
// 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
@@ -407,24 +401,20 @@ TEST(IPV4_REASSEMBLE, EXPIRE)
// frag1
packet_parse(&pkt, (const char *)frag1, sizeof(frag1));
new_pkt = ip_reassembly_packet(mgr, &pkt);
new_pkt = ip_reassembly_packet(mgr, &pkt, 1);
EXPECT_TRUE(new_pkt == NULL);
// 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
0, 0, 0, 0, 0, 0); // ip6: nospace, overlap, many frag, invalid length, dup first frag, dup last frag
// sleep 1s
sleep(1);
timestamp_update();
// frag2
packet_parse(&pkt, (const char *)frag2, sizeof(frag2));
new_pkt = ip_reassembly_packet(mgr, &pkt);
new_pkt = ip_reassembly_packet(mgr, &pkt, 2);
EXPECT_TRUE(new_pkt == NULL);
// 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
@@ -443,7 +433,7 @@ TEST(IPV4_REASSEMBLE, DUP_FIRST_FRAG)
{
struct packet pkt;
struct packet *new_pkt;
const struct layer_record *layer;
const struct layer *layer;
struct ip_reassembly *mgr;
struct ip_reassembly_options opts = {
.enable = true,
@@ -452,11 +442,9 @@ TEST(IPV4_REASSEMBLE, DUP_FIRST_FRAG)
.bucket_num = 8,
};
timestamp_update();
mgr = ip_reassembly_new(&opts);
EXPECT_TRUE(mgr != NULL);
// 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
@@ -465,9 +453,9 @@ TEST(IPV4_REASSEMBLE, DUP_FIRST_FRAG)
// frag1
packet_parse(&pkt, (const char *)frag1, sizeof(frag1));
new_pkt = ip_reassembly_packet(mgr, &pkt);
new_pkt = ip_reassembly_packet(mgr, &pkt, 1);
EXPECT_TRUE(new_pkt == NULL);
// 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
@@ -476,9 +464,9 @@ TEST(IPV4_REASSEMBLE, DUP_FIRST_FRAG)
// frag1
packet_parse(&pkt, (const char *)frag1, sizeof(frag1));
new_pkt = ip_reassembly_packet(mgr, &pkt);
new_pkt = ip_reassembly_packet(mgr, &pkt, 1);
EXPECT_TRUE(new_pkt == NULL);
// 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
@@ -487,9 +475,9 @@ TEST(IPV4_REASSEMBLE, DUP_FIRST_FRAG)
// frag2
packet_parse(&pkt, (const char *)frag2, sizeof(frag2));
new_pkt = ip_reassembly_packet(mgr, &pkt);
new_pkt = ip_reassembly_packet(mgr, &pkt, 1);
EXPECT_TRUE(new_pkt);
// 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
@@ -549,7 +537,7 @@ TEST(IPV4_REASSEMBLE, DUP_LAST_FRAG)
{
struct packet pkt;
struct packet *new_pkt;
const struct layer_record *layer;
const struct layer *layer;
struct ip_reassembly *mgr;
struct ip_reassembly_options opts = {
.enable = true,
@@ -558,11 +546,9 @@ TEST(IPV4_REASSEMBLE, DUP_LAST_FRAG)
.bucket_num = 8,
};
timestamp_update();
mgr = ip_reassembly_new(&opts);
EXPECT_TRUE(mgr != NULL);
// 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
@@ -571,9 +557,9 @@ TEST(IPV4_REASSEMBLE, DUP_LAST_FRAG)
// frag2
packet_parse(&pkt, (const char *)frag2, sizeof(frag2));
new_pkt = ip_reassembly_packet(mgr, &pkt);
new_pkt = ip_reassembly_packet(mgr, &pkt, 1);
EXPECT_TRUE(new_pkt == NULL);
// 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
@@ -582,9 +568,9 @@ TEST(IPV4_REASSEMBLE, DUP_LAST_FRAG)
// frag2
packet_parse(&pkt, (const char *)frag2, sizeof(frag2));
new_pkt = ip_reassembly_packet(mgr, &pkt);
new_pkt = ip_reassembly_packet(mgr, &pkt, 1);
EXPECT_TRUE(new_pkt == NULL);
// 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
@@ -593,9 +579,9 @@ TEST(IPV4_REASSEMBLE, DUP_LAST_FRAG)
// frag1
packet_parse(&pkt, (const char *)frag1, sizeof(frag1));
new_pkt = ip_reassembly_packet(mgr, &pkt);
new_pkt = ip_reassembly_packet(mgr, &pkt, 1);
EXPECT_TRUE(new_pkt);
// 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
@@ -663,11 +649,9 @@ TEST(IPV4_REASSEMBLE, FULL)
.bucket_num = 1,
};
timestamp_update();
mgr = ip_reassembly_new(&opts);
EXPECT_TRUE(mgr != NULL);
// 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
@@ -680,9 +664,9 @@ TEST(IPV4_REASSEMBLE, FULL)
// flow1
packet_set_ipv4_src_addr(&pkt, 1);
new_pkt = ip_reassembly_packet(mgr, &pkt);
new_pkt = ip_reassembly_packet(mgr, &pkt, 1);
EXPECT_TRUE(new_pkt == NULL);
// 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
@@ -691,9 +675,9 @@ TEST(IPV4_REASSEMBLE, FULL)
// flow2
packet_set_ipv4_src_addr(&pkt, 2);
new_pkt = ip_reassembly_packet(mgr, &pkt);
new_pkt = ip_reassembly_packet(mgr, &pkt, 1);
EXPECT_TRUE(new_pkt == NULL);
// 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
@@ -702,9 +686,9 @@ TEST(IPV4_REASSEMBLE, FULL)
// flow3
packet_set_ipv4_src_addr(&pkt, 3);
new_pkt = ip_reassembly_packet(mgr, &pkt);
new_pkt = ip_reassembly_packet(mgr, &pkt, 1);
EXPECT_TRUE(new_pkt == NULL);
// 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

126
src/ip_reassembly/test/gtest_ipv6_reassembly.cpp
View File

@@ -607,7 +607,7 @@ TEST(IPV6_REASSEMBLE, NORMAL)
{
struct packet pkt;
struct packet *new_pkt;
const struct layer_record *layer;
const struct layer *layer;
struct ip_reassembly *mgr;
struct ip_reassembly_options opts = {
.enable = true,
@@ -616,11 +616,9 @@ TEST(IPV6_REASSEMBLE, NORMAL)
.bucket_num = 8,
};
timestamp_update();
mgr = ip_reassembly_new(&opts);
EXPECT_TRUE(mgr != NULL);
// 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
@@ -629,9 +627,9 @@ TEST(IPV6_REASSEMBLE, NORMAL)
// frag1
packet_parse(&pkt, (const char *)frag1, sizeof(frag1));
new_pkt = ip_reassembly_packet(mgr, &pkt);
new_pkt = ip_reassembly_packet(mgr, &pkt, 1);
EXPECT_TRUE(new_pkt == NULL);
// 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
@@ -640,9 +638,9 @@ TEST(IPV6_REASSEMBLE, NORMAL)
// frag2
packet_parse(&pkt, (const char *)frag2, sizeof(frag2));
new_pkt = ip_reassembly_packet(mgr, &pkt);
new_pkt = ip_reassembly_packet(mgr, &pkt, 1);
EXPECT_TRUE(new_pkt == NULL);
// 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
@@ -651,9 +649,9 @@ TEST(IPV6_REASSEMBLE, NORMAL)
// frag3
packet_parse(&pkt, (const char *)frag3, sizeof(frag3));
new_pkt = ip_reassembly_packet(mgr, &pkt);
new_pkt = ip_reassembly_packet(mgr, &pkt, 1);
EXPECT_TRUE(new_pkt == NULL);
// 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
@@ -662,9 +660,9 @@ TEST(IPV6_REASSEMBLE, NORMAL)
// frag4
packet_parse(&pkt, (const char *)frag4, sizeof(frag4));
new_pkt = ip_reassembly_packet(mgr, &pkt);
new_pkt = ip_reassembly_packet(mgr, &pkt, 1);
EXPECT_TRUE(new_pkt);
// 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
@@ -726,11 +724,9 @@ TEST(IPV6_REASSEMBLE, EXPIRE)
.bucket_num = 8,
};
timestamp_update();
mgr = ip_reassembly_new(&opts);
EXPECT_TRUE(mgr != NULL);
// 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
@@ -739,24 +735,20 @@ TEST(IPV6_REASSEMBLE, EXPIRE)
// frag1
packet_parse(&pkt, (const char *)frag1, sizeof(frag1));
new_pkt = ip_reassembly_packet(mgr, &pkt);
new_pkt = ip_reassembly_packet(mgr, &pkt, 1);
EXPECT_TRUE(new_pkt == NULL);
// 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
0, 0, 0, 0, 0, 0); // ip6: nospace, overlap, many frag, invalid length, dup first frag, dup last frag
// sleep 1
sleep(1);
timestamp_update();
// frag2
packet_parse(&pkt, (const char *)frag2, sizeof(frag2));
new_pkt = ip_reassembly_packet(mgr, &pkt);
new_pkt = ip_reassembly_packet(mgr, &pkt, 2);
EXPECT_TRUE(new_pkt == NULL);
// 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
@@ -775,7 +767,7 @@ TEST(IPV6_REASSEMBLE, DUP_FIRST_FRAG)
{
struct packet pkt;
struct packet *new_pkt;
const struct layer_record *layer;
const struct layer *layer;
struct ip_reassembly *mgr;
struct ip_reassembly_options opts = {
.enable = true,
@@ -784,11 +776,9 @@ TEST(IPV6_REASSEMBLE, DUP_FIRST_FRAG)
.bucket_num = 8,
};
timestamp_update();
mgr = ip_reassembly_new(&opts);
EXPECT_TRUE(mgr != NULL);
// 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
@@ -797,9 +787,9 @@ TEST(IPV6_REASSEMBLE, DUP_FIRST_FRAG)
// frag1
packet_parse(&pkt, (const char *)frag1, sizeof(frag1));
new_pkt = ip_reassembly_packet(mgr, &pkt);
new_pkt = ip_reassembly_packet(mgr, &pkt, 1);
EXPECT_TRUE(new_pkt == NULL);
// 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
@@ -808,9 +798,9 @@ TEST(IPV6_REASSEMBLE, DUP_FIRST_FRAG)
// frag1
packet_parse(&pkt, (const char *)frag1, sizeof(frag1));
new_pkt = ip_reassembly_packet(mgr, &pkt);
new_pkt = ip_reassembly_packet(mgr, &pkt, 1);
EXPECT_TRUE(new_pkt == NULL);
// 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
@@ -819,9 +809,9 @@ TEST(IPV6_REASSEMBLE, DUP_FIRST_FRAG)
// frag2
packet_parse(&pkt, (const char *)frag2, sizeof(frag2));
new_pkt = ip_reassembly_packet(mgr, &pkt);
new_pkt = ip_reassembly_packet(mgr, &pkt, 1);
EXPECT_TRUE(new_pkt == NULL);
// 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
@@ -830,9 +820,9 @@ TEST(IPV6_REASSEMBLE, DUP_FIRST_FRAG)
// frag3
packet_parse(&pkt, (const char *)frag3, sizeof(frag3));
new_pkt = ip_reassembly_packet(mgr, &pkt);
new_pkt = ip_reassembly_packet(mgr, &pkt, 1);
EXPECT_TRUE(new_pkt == NULL);
// 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
@@ -841,9 +831,9 @@ TEST(IPV6_REASSEMBLE, DUP_FIRST_FRAG)
// frag4
packet_parse(&pkt, (const char *)frag4, sizeof(frag4));
new_pkt = ip_reassembly_packet(mgr, &pkt);
new_pkt = ip_reassembly_packet(mgr, &pkt, 1);
EXPECT_TRUE(new_pkt);
// 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
@@ -897,7 +887,7 @@ TEST(IPV6_REASSEMBLE, DUP_LAST_FRAG)
{
struct packet pkt;
struct packet *new_pkt;
const struct layer_record *layer;
const struct layer *layer;
struct ip_reassembly *mgr;
struct ip_reassembly_options opts = {
.enable = true,
@@ -906,11 +896,9 @@ TEST(IPV6_REASSEMBLE, DUP_LAST_FRAG)
.bucket_num = 8,
};
timestamp_update();
mgr = ip_reassembly_new(&opts);
EXPECT_TRUE(mgr != NULL);
// 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
@@ -919,9 +907,9 @@ TEST(IPV6_REASSEMBLE, DUP_LAST_FRAG)
// frag4
packet_parse(&pkt, (const char *)frag4, sizeof(frag4));
new_pkt = ip_reassembly_packet(mgr, &pkt);
new_pkt = ip_reassembly_packet(mgr, &pkt, 1);
EXPECT_TRUE(new_pkt == NULL);
// 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
@@ -930,9 +918,9 @@ TEST(IPV6_REASSEMBLE, DUP_LAST_FRAG)
// frag4
packet_parse(&pkt, (const char *)frag4, sizeof(frag4));
new_pkt = ip_reassembly_packet(mgr, &pkt);
new_pkt = ip_reassembly_packet(mgr, &pkt, 1);
EXPECT_TRUE(new_pkt == NULL);
// 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
@@ -941,9 +929,9 @@ TEST(IPV6_REASSEMBLE, DUP_LAST_FRAG)
// frag3
packet_parse(&pkt, (const char *)frag3, sizeof(frag3));
new_pkt = ip_reassembly_packet(mgr, &pkt);
new_pkt = ip_reassembly_packet(mgr, &pkt, 1);
EXPECT_TRUE(new_pkt == NULL);
// 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
@@ -952,9 +940,9 @@ TEST(IPV6_REASSEMBLE, DUP_LAST_FRAG)
// frag2
packet_parse(&pkt, (const char *)frag2, sizeof(frag2));
new_pkt = ip_reassembly_packet(mgr, &pkt);
new_pkt = ip_reassembly_packet(mgr, &pkt, 1);
EXPECT_TRUE(new_pkt == NULL);
// 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
@@ -963,9 +951,9 @@ TEST(IPV6_REASSEMBLE, DUP_LAST_FRAG)
// frag1
packet_parse(&pkt, (const char *)frag1, sizeof(frag1));
new_pkt = ip_reassembly_packet(mgr, &pkt);
new_pkt = ip_reassembly_packet(mgr, &pkt, 1);
EXPECT_TRUE(new_pkt);
// 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
@@ -1028,11 +1016,9 @@ TEST(IPV6_REASSEMBLE, FULL)
.bucket_num = 1,
};
timestamp_update();
mgr = ip_reassembly_new(&opts);
EXPECT_TRUE(mgr != NULL);
// 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
@@ -1046,9 +1032,9 @@ TEST(IPV6_REASSEMBLE, FULL)
// flow1
memset(&src_addr, 1, sizeof(src_addr));
packet_set_ipv6_src_addr(&pkt, src_addr);
new_pkt = ip_reassembly_packet(mgr, &pkt);
new_pkt = ip_reassembly_packet(mgr, &pkt, 1);
EXPECT_TRUE(new_pkt == NULL);
// 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
@@ -1058,9 +1044,9 @@ TEST(IPV6_REASSEMBLE, FULL)
// flow2
memset(&src_addr, 2, sizeof(src_addr));
packet_set_ipv6_src_addr(&pkt, src_addr);
new_pkt = ip_reassembly_packet(mgr, &pkt);
new_pkt = ip_reassembly_packet(mgr, &pkt, 1);
EXPECT_TRUE(new_pkt == NULL);
// 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
@@ -1070,9 +1056,9 @@ TEST(IPV6_REASSEMBLE, FULL)
// flow3
memset(&src_addr, 3, sizeof(src_addr));
packet_set_ipv6_src_addr(&pkt, src_addr);
new_pkt = ip_reassembly_packet(mgr, &pkt);
new_pkt = ip_reassembly_packet(mgr, &pkt, 1);
EXPECT_TRUE(new_pkt == NULL);
// 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
@@ -1099,11 +1085,9 @@ TEST(IPV6_REASSEMBLE, OVERLAP)
.bucket_num = 8,
};
timestamp_update();
mgr = ip_reassembly_new(&opts);
EXPECT_TRUE(mgr != NULL);
// 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
@@ -1112,9 +1096,9 @@ TEST(IPV6_REASSEMBLE, OVERLAP)
// frag1
packet_parse(&pkt, (const char *)frag1, sizeof(frag1));
new_pkt = ip_reassembly_packet(mgr, &pkt);
new_pkt = ip_reassembly_packet(mgr, &pkt, 1);
EXPECT_TRUE(new_pkt == NULL);
// 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
@@ -1123,9 +1107,9 @@ TEST(IPV6_REASSEMBLE, OVERLAP)
// frag2
packet_parse(&pkt, (const char *)frag2, sizeof(frag2));
new_pkt = ip_reassembly_packet(mgr, &pkt);
new_pkt = ip_reassembly_packet(mgr, &pkt, 1);
EXPECT_TRUE(new_pkt == NULL);
// 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
@@ -1137,9 +1121,9 @@ 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_reassembly_packet(mgr, &pkt);
new_pkt = ip_reassembly_packet(mgr, &pkt, 1);
EXPECT_TRUE(new_pkt == NULL);
// 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
@@ -1148,9 +1132,9 @@ TEST(IPV6_REASSEMBLE, OVERLAP)
// frag4
packet_parse(&pkt, (const char *)frag4, sizeof(frag4));
new_pkt = ip_reassembly_packet(mgr, &pkt);
new_pkt = ip_reassembly_packet(mgr, &pkt, 1);
EXPECT_TRUE(new_pkt == NULL);
// 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

8
src/ip_reassembly/test/gtest_utils.h
View File

@@ -8,17 +8,15 @@ extern "C"
#include <gtest/gtest.h>
#include "timestamp.h"
#include "udp_utils.h"
#include "tcp_utils.h"
#include "ipv4_utils.h"
#include "ipv6_utils.h"
#include "packet_utils.h"
#include "ip_reassembly.h"
static inline void packet_set_ipv4_src_addr(struct packet *pkt, uint32_t saddr)
{
const struct layer_record *ipv4_layer = packet_get_innermost_layer(pkt, LAYER_TYPE_IPV4);
const struct layer *ipv4_layer = packet_get_innermost_layer(pkt, LAYER_TYPE_IPV4);
EXPECT_TRUE(ipv4_layer);
struct ip *hdr = (struct ip *)ipv4_layer->hdr_ptr;
ipv4_hdr_set_src_addr(hdr, saddr);
@@ -26,7 +24,7 @@ static inline void packet_set_ipv4_src_addr(struct packet *pkt, uint32_t saddr)
static inline void packet_set_ipv6_src_addr(struct packet *pkt, struct in6_addr saddr)
{
const struct layer_record *ipv6_layer = packet_get_innermost_layer(pkt, LAYER_TYPE_IPV6);
const struct layer *ipv6_layer = packet_get_innermost_layer(pkt, LAYER_TYPE_IPV6);
EXPECT_TRUE(ipv6_layer);
struct ip6_hdr *hdr = (struct ip6_hdr *)ipv6_layer->hdr_ptr;
ipv6_hdr_set_src_in6_addr(hdr, saddr);
@@ -34,7 +32,7 @@ static inline void packet_set_ipv6_src_addr(struct packet *pkt, struct in6_addr
static inline void packet_set_ipv6_frag_offset(struct packet *pkt, uint16_t offset)
{
const struct layer_record *ipv6_layer = (struct layer_record *)packet_get_innermost_layer(pkt, LAYER_TYPE_IPV6);
const struct layer *ipv6_layer = (struct layer *)packet_get_innermost_layer(pkt, LAYER_TYPE_IPV6);
EXPECT_TRUE(ipv6_layer);
struct ip6_hdr *hdr = (struct ip6_hdr *)ipv6_layer->hdr_ptr;
struct ip6_frag *frag_hdr = ipv6_hdr_get_frag_ext(hdr);