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

Add tcp reassembly test case

Browse Source
This commit is contained in:
luwenpeng
2024-03-25 17:30:48 +08:00
parent 2ad811f68d
commit 5b92d6d8de
9 changed files with 1389 additions and 596 deletions
Download Patch File Download Diff File Expand all files Collapse all files

204
src/ip_reassembly/ip_reassembly.cpp
View File

@@ -14,7 +14,7 @@
#define IPV6_KEYLEN 4
#define PRIME_VALUE 0xeaad8405
#define IP_FRAG_HASH_FNUM 2
#define IP_FRAG_TBL_POS(assembler, sig) ((assembler)->table + ((sig) & (assembler)->entry_mask))
#define IP_FRAG_TBL_POS(assy, sig) ((assy)->table + ((sig) & (assy)->entry_mask))
#define KEY_TO_STR(key, str_str, dst_str) \
do \
@@ -136,16 +136,16 @@ struct ip_reassembly
* utils
******************************************************************************/
#define ip_reassembly_stat_inc(assembler, filed, key) \
{ \
if ((key)->src_dst_len == IPV4_KEYLEN) \
{ \
(assembler)->stat.ip4_flow_##filed++; \
} \
else \
{ \
(assembler)->stat.ip6_flow_##filed++; \
} \
#define ip_reassembly_stat_inc(assy, filed, key) \
{ \
if ((key)->src_dst_len == IPV4_KEYLEN) \
{ \
(assy)->stat.ip4_flow_##filed++; \
} \
else \
{ \
(assy)->stat.ip6_flow_##filed++; \
} \
}
static inline void *memdup(const void *src, size_t len)
@@ -402,7 +402,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_reassembly *assembler,
static inline int ip_flow_update(struct ip_reassembly *assy,
struct ip_flow *flow, const struct packet *pkt,
char *frag_data, uint16_t frag_len, uint16_t frag_offset, bool more_frags)
{
@@ -424,7 +424,7 @@ static inline int ip_flow_update(struct ip_reassembly *assembler,
if (flow->frags[IP_FIRST_FRAG_IDX].data != NULL)
{
IP_REASSEMBLE_DEBUG1("duplicate first fragment bypass", &flow->key);
ip_reassembly_stat_inc(assembler, bypass_dup_fist_frag, &flow->key);
ip_reassembly_stat_inc(assy, bypass_dup_fist_frag, &flow->key);
return 0;
}
idx = IP_FIRST_FRAG_IDX;
@@ -435,7 +435,7 @@ static inline int ip_flow_update(struct ip_reassembly *assembler,
if (flow->frags[IP_LAST_FRAG_IDX].data != NULL)
{
IP_REASSEMBLE_DEBUG1("duplicate last fragment bypass", &flow->key);
ip_reassembly_stat_inc(assembler, bypass_dup_last_frag, &flow->key);
ip_reassembly_stat_inc(assy, bypass_dup_last_frag, &flow->key);
return 0;
}
idx = IP_LAST_FRAG_IDX;
@@ -446,7 +446,7 @@ static inline int ip_flow_update(struct ip_reassembly *assembler,
if (flow->next_fill_idx >= IP_MAX_FRAG_NUM)
{
IP_REASSEMBLE_ERROR1("max number of fragment exceeded", &flow->key);
ip_reassembly_stat_inc(assembler, fail_many_frag, &flow->key);
ip_reassembly_stat_inc(assy, fail_many_frag, &flow->key);
return -1;
}
idx = flow->next_fill_idx;
@@ -464,26 +464,26 @@ static inline int ip_flow_update(struct ip_reassembly *assembler,
* ip reassemble manager add/del/reuse/find/update flow
******************************************************************************/
static inline void ip_reassembly_add_flow(struct ip_reassembly *assembler, struct ip_flow *flow)
static inline void ip_reassembly_add_flow(struct ip_reassembly *assy, struct ip_flow *flow)
{
ip_reassembly_stat_inc(assembler, add, &flow->key);
TAILQ_INSERT_TAIL(&assembler->lru, flow, lru);
assembler->entry_used++;
ip_reassembly_stat_inc(assy, add, &flow->key);
TAILQ_INSERT_TAIL(&assy->lru, flow, lru);
assy->entry_used++;
}
static inline void ip_reassembly_del_flow(struct ip_reassembly *assembler, struct ip_flow *flow)
static inline void ip_reassembly_del_flow(struct ip_reassembly *assy, struct ip_flow *flow)
{
ip_reassembly_stat_inc(assembler, del, &flow->key);
TAILQ_REMOVE(&assembler->lru, flow, lru);
assembler->entry_used--;
ip_reassembly_stat_inc(assy, del, &flow->key);
TAILQ_REMOVE(&assy->lru, flow, lru);
assy->entry_used--;
}
static inline void ip_reassembly_reuse_flow(struct ip_reassembly *assembler, struct ip_flow *flow, const struct ip_flow_key *key, uint64_t now)
static inline void ip_reassembly_reuse_flow(struct ip_reassembly *assy, struct ip_flow *flow, const struct ip_flow_key *key, uint64_t now)
{
ip_reassembly_del_flow(assembler, flow);
ip_reassembly_del_flow(assy, flow);
ip_flow_free(flow);
ip_flow_init(flow, key, now);
ip_reassembly_add_flow(assembler, flow);
ip_reassembly_add_flow(assy, flow);
}
/*
@@ -491,13 +491,13 @@ static inline void ip_reassembly_reuse_flow(struct ip_reassembly *assembler, str
* 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 *assembler, const struct ip_flow_key *key, struct ip_flow **free, struct ip_flow **expired, uint64_t now)
static struct ip_flow *ip_reassembly_find_flow(struct ip_reassembly *assy, const struct ip_flow_key *key, struct ip_flow **free, struct ip_flow **expired, uint64_t now)
{
ip_reassembly_stat_inc(assembler, find, key);
ip_reassembly_stat_inc(assy, find, key);
if (assembler->last != NULL && ip_flow_key_cmp(key, &assembler->last->key) == 0)
if (assy->last != NULL && ip_flow_key_cmp(key, &assy->last->key) == 0)
{
return assembler->last;
return assy->last;
}
uint32_t sig1 = 0;
@@ -512,14 +512,14 @@ static struct ip_flow *ip_reassembly_find_flow(struct ip_reassembly *assembler,
}
// get the bucket by hash
struct ip_flow *p1 = IP_FRAG_TBL_POS(assembler, sig1);
struct ip_flow *p2 = IP_FRAG_TBL_POS(assembler, sig2);
struct ip_flow *p1 = IP_FRAG_TBL_POS(assy, sig1);
struct ip_flow *p2 = IP_FRAG_TBL_POS(assy, sig2);
// search in the bucket
struct ip_flow *old = NULL;
struct ip_flow *empty = NULL;
uint64_t timeout = assembler->timeout;
uint32_t assoc = assembler->bucket_entries;
uint64_t timeout = assy->timeout;
uint32_t assoc = assy->bucket_entries;
for (uint32_t i = 0; i != assoc; i++)
{
if (ip_flow_key_cmp(key, &p1[i].key) == 0)
@@ -558,22 +558,22 @@ static struct ip_flow *ip_reassembly_find_flow(struct ip_reassembly *assembler,
return NULL;
}
static struct ip_flow *ip_reassembly_update_flow(struct ip_reassembly *assembler, const struct ip_flow_key *key, uint64_t now)
static struct ip_flow *ip_reassembly_update_flow(struct ip_reassembly *assy, const struct ip_flow_key *key, uint64_t now)
{
struct ip_flow *flow = NULL;
struct ip_flow *free = NULL;
struct ip_flow *expired = NULL;
flow = ip_reassembly_find_flow(assembler, key, &free, &expired, now);
flow = ip_reassembly_find_flow(assy, key, &free, &expired, now);
if (flow == NULL)
{
if (expired)
{
IP_REASSEMBLE_DEBUG1("add ip flow success: reuse expired entry", key);
ip_reassembly_reuse_flow(assembler, expired, key, now);
ip_reassembly_stat_inc(assembler, timeout, key);
ip_reassembly_reuse_flow(assy, expired, key, now);
ip_reassembly_stat_inc(assy, timeout, key);
assembler->last = expired;
assy->last = expired;
return expired;
}
@@ -581,27 +581,27 @@ static struct ip_flow *ip_reassembly_update_flow(struct ip_reassembly *assembler
{
IP_REASSEMBLE_DEBUG1("add ip flow success: use free entry", key);
ip_flow_init(free, key, now);
ip_reassembly_add_flow(assembler, free);
ip_reassembly_add_flow(assy, free);
assembler->last = free;
assy->last = free;
return free;
}
// no space
IP_REASSEMBLE_ERROR1("add ip flow failed: bucket full", key);
ip_reassembly_stat_inc(assembler, fail_no_space, key);
ip_reassembly_stat_inc(assy, fail_no_space, key);
return NULL;
}
else
{
// expired
if (assembler->timeout + flow->create_time <= now)
if (assy->timeout + flow->create_time <= now)
{
IP_REASSEMBLE_DEBUG1("add ip flow success: reuse expired entry", key);
ip_reassembly_reuse_flow(assembler, flow, key, now);
ip_reassembly_stat_inc(assembler, timeout, key);
ip_reassembly_reuse_flow(assy, flow, key, now);
ip_reassembly_stat_inc(assy, timeout, key);
assembler->last = flow;
assy->last = flow;
return flow;
}
// not expired
@@ -609,7 +609,7 @@ static struct ip_flow *ip_reassembly_update_flow(struct ip_reassembly *assembler
{
IP_REASSEMBLE_DEBUG1("find ip flow success: not expire", key);
assembler->last = flow;
assy->last = flow;
return flow;
}
}
@@ -619,7 +619,7 @@ static struct ip_flow *ip_reassembly_update_flow(struct ip_reassembly *assembler
* frag reassemble
******************************************************************************/
static struct packet *ip_frag_reassemble(struct ip_reassembly *assembler, struct ip_flow *flow)
static struct packet *ip_frag_reassemble(struct ip_reassembly *assy, 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];
@@ -735,12 +735,12 @@ static struct packet *ip_frag_reassemble(struct ip_reassembly *assembler, struct
return pkt;
error_out_invalid_length:
ip_reassembly_stat_inc(assembler, fail_invalid_length, &flow->key);
ip_reassembly_stat_inc(assy, fail_invalid_length, &flow->key);
packet_free(pkt);
return NULL;
error_out_overlap:
ip_reassembly_stat_inc(assembler, fail_overlap, &flow->key);
ip_reassembly_stat_inc(assy, fail_overlap, &flow->key);
packet_free(pkt);
return NULL;
}
@@ -756,84 +756,84 @@ struct ip_reassembly *ip_reassembly_new(const struct ip_reassembly_options *opts
return NULL;
}
struct ip_reassembly *assembler = (struct ip_reassembly *)calloc(1, sizeof(struct ip_reassembly));
if (assembler == NULL)
struct ip_reassembly *assy = (struct ip_reassembly *)calloc(1, sizeof(struct ip_reassembly));
if (assy == NULL)
{
IP_REASSEMBLE_ERROR("unable to allocate memory");
return NULL;
}
assembler->enable = opts->enable;
assembler->timeout = opts->timeout;
assembler->bucket_entries = opts->bucket_entries;
assembler->bucket_num = opts->bucket_num;
assy->enable = opts->enable;
assy->timeout = opts->timeout;
assy->bucket_entries = opts->bucket_entries;
assy->bucket_num = opts->bucket_num;
if (!assembler->enable)
if (!assy->enable)
{
return assembler;
return assy;
}
uint64_t entry_total = align32pow2(assembler->bucket_num) * assembler->bucket_entries * IP_FRAG_HASH_FNUM;
uint64_t entry_total = align32pow2(assy->bucket_num) * assy->bucket_entries * IP_FRAG_HASH_FNUM;
if (entry_total > UINT32_MAX)
{
IP_REASSEMBLE_ERROR("bucket_num * bucket_entries is too large");
free(assembler);
free(assy);
return NULL;
}
assembler->entry_total = (uint32_t)entry_total;
assembler->entry_mask = (assembler->entry_total - 1) & ~(assembler->bucket_entries - 1);
assembler->table = (struct ip_flow *)calloc(assembler->entry_total, sizeof(struct ip_flow));
if (assembler->table == NULL)
assy->entry_total = (uint32_t)entry_total;
assy->entry_mask = (assy->entry_total - 1) & ~(assy->bucket_entries - 1);
assy->table = (struct ip_flow *)calloc(assy->entry_total, sizeof(struct ip_flow));
if (assy->table == NULL)
{
IP_REASSEMBLE_ERROR("unable to allocate memory");
free(assembler);
free(assy);
return NULL;
}
TAILQ_INIT(&(assembler->lru));
TAILQ_INIT(&(assy->lru));
return assembler;
return assy;
}
void ip_reassembly_free(struct ip_reassembly *assembler)
void ip_reassembly_free(struct ip_reassembly *assy)
{
if (assembler)
if (assy)
{
if (assembler->table)
if (assy->table)
{
for (uint32_t i = 0; i < assembler->entry_total; i++)
for (uint32_t i = 0; i < assy->entry_total; i++)
{
ip_flow_free(assembler->table + i);
ip_flow_free(assy->table + i);
}
free(assembler->table);
assembler->table = NULL;
free(assy->table);
assy->table = NULL;
}
free(assembler);
assembler = NULL;
free(assy);
assy = NULL;
}
}
void ip_reassembly_expire(struct ip_reassembly *assembler, uint64_t now)
void ip_reassembly_expire(struct ip_reassembly *assy, uint64_t now)
{
struct ip_flow *flow = NULL;
uint64_t timeout = assembler->timeout;
uint64_t timeout = assy->timeout;
TAILQ_FOREACH(flow, &assembler->lru, lru)
TAILQ_FOREACH(flow, &assy->lru, lru)
if (timeout + flow->create_time <= now)
{
IP_REASSEMBLE_DEBUG1("expire ip flow: discarding old fragmented packets", &flow->key);
ip_reassembly_del_flow(assembler, flow);
ip_reassembly_stat_inc(assembler, timeout, &flow->key);
ip_reassembly_del_flow(assy, flow);
ip_reassembly_stat_inc(assy, timeout, &flow->key);
ip_flow_free(flow);
}
}
struct ip_reassembly_stat *ip_reassembly_get_stat(struct ip_reassembly *assembler)
struct ip_reassembly_stat *ip_reassembly_get_stat(struct ip_reassembly *assy)
{
if (assembler)
if (assy)
{
return &(assembler->stat);
return &(assy->stat);
}
else
{
@@ -846,12 +846,12 @@ struct ip_reassembly_stat *ip_reassembly_get_stat(struct ip_reassembly *assemble
* The returned packet should be freed by calling the packet_free() function
*/
struct packet *ip_reassembly_packet(struct ip_reassembly *assembler, const struct packet *pkt, uint64_t now)
struct packet *ip_reassembly_packet(struct ip_reassembly *assy, const struct packet *pkt, uint64_t now)
{
struct packet *pkt1;
struct packet *pkt2;
if (!assembler->enable)
if (!assy->enable)
{
return NULL;
}
@@ -864,10 +864,10 @@ struct packet *ip_reassembly_packet(struct ip_reassembly *assembler, const struc
if (layer->type == LAYER_TYPE_IPV4)
{
pkt1 = ipv4_reassembly_packet(assembler, pkt, now);
pkt1 = ipv4_reassembly_packet(assy, pkt, now);
if (pkt1 && pkt1->frag_layer)
{
pkt2 = ip_reassembly_packet(assembler, pkt1, now);
pkt2 = ip_reassembly_packet(assy, pkt1, now);
packet_free(pkt1);
return pkt2;
}
@@ -876,10 +876,10 @@ struct packet *ip_reassembly_packet(struct ip_reassembly *assembler, const struc
}
else if (layer->type == LAYER_TYPE_IPV6)
{
pkt1 = ipv6_reassembly_packet(assembler, pkt, now);
pkt1 = ipv6_reassembly_packet(assy, pkt, now);
if (pkt1 && pkt1->frag_layer)
{
pkt2 = ip_reassembly_packet(assembler, pkt1, now);
pkt2 = ip_reassembly_packet(assy, pkt1, now);
packet_free(pkt1);
return pkt2;
}
@@ -892,7 +892,7 @@ struct packet *ip_reassembly_packet(struct ip_reassembly *assembler, const struc
}
}
struct packet *ipv4_reassembly_packet(struct ip_reassembly *assembler, const struct packet *pkt, uint64_t now)
struct packet *ipv4_reassembly_packet(struct ip_reassembly *assy, const struct packet *pkt, uint64_t now)
{
const struct layer *layer = pkt->frag_layer;
const struct ip *hdr = (const struct ip *)layer->hdr_ptr;
@@ -911,7 +911,7 @@ struct packet *ipv4_reassembly_packet(struct ip_reassembly *assembler, const str
key.ip_id = ipv4_hdr_get_ipid(hdr);
key.proto = ipv4_hdr_get_proto(hdr);
struct ip_flow *flow = ip_reassembly_update_flow(assembler, &key, now);
struct ip_flow *flow = ip_reassembly_update_flow(assy, &key, now);
if (flow == NULL)
{
return NULL;
@@ -920,9 +920,9 @@ struct packet *ipv4_reassembly_packet(struct ip_reassembly *assembler, const str
char *frag_data = (char *)layer->pld_ptr;
bool more_frags = ipv4_hdr_get_mf_flag(hdr);
uint16_t frag_offset = ipv4_hdr_get_frag_offset(hdr);
if (ip_flow_update(assembler, flow, pkt, frag_data, frag_len, frag_offset, more_frags) != 0)
if (ip_flow_update(assy, flow, pkt, frag_data, frag_len, frag_offset, more_frags) != 0)
{
ip_reassembly_del_flow(assembler, flow);
ip_reassembly_del_flow(assy, flow);
ip_flow_free(flow);
return NULL;
}
@@ -932,8 +932,8 @@ struct packet *ipv4_reassembly_packet(struct ip_reassembly *assembler, const str
return NULL;
}
struct packet *new_pkt = ip_frag_reassemble(assembler, flow);
ip_reassembly_del_flow(assembler, flow);
struct packet *new_pkt = ip_frag_reassemble(assy, flow);
ip_reassembly_del_flow(assy, flow);
ip_flow_free(flow);
return new_pkt;
@@ -978,7 +978,7 @@ struct packet *ipv4_reassembly_packet(struct ip_reassembly *assembler, const str
* +-----------------+-----------------+--------+--------+-//-+--------+
*/
struct packet *ipv6_reassembly_packet(struct ip_reassembly *assembler, const struct packet *pkt, uint64_t now)
struct packet *ipv6_reassembly_packet(struct ip_reassembly *assy, const struct packet *pkt, uint64_t now)
{
const struct layer *layer = pkt->frag_layer;
const struct ip6_hdr *hdr = (const struct ip6_hdr *)layer->hdr_ptr;
@@ -1003,7 +1003,7 @@ struct packet *ipv6_reassembly_packet(struct ip_reassembly *assembler, const str
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(assembler, &key, now);
struct ip_flow *flow = ip_reassembly_update_flow(assy, &key, now);
if (flow == NULL)
{
return NULL;
@@ -1011,9 +1011,9 @@ struct packet *ipv6_reassembly_packet(struct ip_reassembly *assembler, const str
bool more_frags = ipv6_frag_get_more(frag_hdr);
uint16_t frag_offset = ipv6_frag_get_offset(frag_hdr);
if (ip_flow_update(assembler, flow, pkt, frag_data, frag_len, frag_offset, more_frags) != 0)
if (ip_flow_update(assy, flow, pkt, frag_data, frag_len, frag_offset, more_frags) != 0)
{
ip_reassembly_del_flow(assembler, flow);
ip_reassembly_del_flow(assy, flow);
ip_flow_free(flow);
return NULL;
}
@@ -1023,8 +1023,8 @@ struct packet *ipv6_reassembly_packet(struct ip_reassembly *assembler, const str
return NULL;
}
struct packet *new_pkt = ip_frag_reassemble(assembler, flow);
ip_reassembly_del_flow(assembler, flow);
struct packet *new_pkt = ip_frag_reassemble(assy, flow);
ip_reassembly_del_flow(assy, flow);
ip_flow_free(flow);
return new_pkt;