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

Refactor TCP reassembly, the session knows where the TCP segment comes from: raw packet or tcp segment queue

Browse Source
This commit is contained in:
luwenpeng
2024-04-02 16:21:39 +08:00
parent a509f0ce3b
commit e8e60cee6d
25 changed files with 678 additions and 1419 deletions
Download Patch File Download Diff File Expand all files Collapse all files

172
src/session/session.cpp
View File

@@ -2,6 +2,7 @@
#include "session.h"
#include "tcp_utils.h"
#include "tcp_reassembly.h"
#define EX_KEY_MAX_LEN 64
@@ -178,6 +179,43 @@ void *session_get_user_data(const struct session *sess)
return sess->user_data;
}
struct tcp_segment *session_get_tcp_segment(struct session *sess)
{
struct tcp_pcb *pcb = &sess->tcp_pcb;
if (pcb->order_seg.data != NULL && pcb->order_seg.len > 0)
{
return &pcb->order_seg;
}
if (session_get_cur_dir(sess) == SESSION_DIR_C2S)
{
return tcp_reassembly_pop(pcb->c2s_assembler);
}
else
{
return tcp_reassembly_pop(pcb->s2c_assembler);
}
}
void session_free_tcp_segment(struct session *sess, struct tcp_segment *seg)
{
if (seg == NULL)
{
return;
}
if (seg == &sess->tcp_pcb.order_seg)
{
sess->tcp_pcb.order_seg.data = NULL;
sess->tcp_pcb.order_seg.len = 0;
return;
}
else
{
tcp_segment_free(seg);
}
}
/******************************************************************************
* to string
******************************************************************************/
@@ -277,140 +315,6 @@ void session_dump(struct session *sess)
}
}
/******************************************************************************
* tcp session
******************************************************************************/
static void tcp_sub_state_update(struct tcp_session *tcp_sess, enum session_dir dir, uint8_t tcp_flags)
{
if (tcp_flags & TH_SYN)
{
tcp_sess->sub_state |= (tcp_flags & TH_ACK) ? TCP_SYN_ACK_RCVD : TCP_SYN_RCVD;
}
if (tcp_flags & TH_FIN)
{
tcp_sess->sub_state |= dir == SESSION_DIR_C2S ? TCP_C2S_FIN_RCVD : TCP_S2C_FIN_RCVD;
}
if (tcp_flags & TH_RST)
{
/*
* https://www.rfc-editor.org/rfc/rfc5961#section-3.2
*
* If the RST bit is set and the sequence number exactly matches the
* next expected sequence number (RCV.NXT), then TCP MUST reset the
* connection.
*/
uint16_t curr_seq = dir == SESSION_DIR_C2S ? tcp_sess->c2s_seq : tcp_sess->s2c_seq;
uint16_t expect_seq = dir == SESSION_DIR_C2S ? tcp_sess->s2c_ack : tcp_sess->c2s_ack;
// if fin is received, the expected sequence number should be increased by 1
expect_seq += dir == SESSION_DIR_C2S ? (tcp_sess->sub_state & TCP_S2C_FIN_RCVD ? 1 : 0) : (tcp_sess->sub_state & TCP_C2S_FIN_RCVD ? 1 : 0);
if (curr_seq == expect_seq)
{
tcp_sess->sub_state |= dir == SESSION_DIR_C2S ? TCP_C2S_RST_RCVD : TCP_S2C_RST_RCVD;
}
// RST is unverified if the sequence number is not as expected
else
{
tcp_sess->sub_state |= dir == SESSION_DIR_C2S ? TCP_C2S_UNVERIFIED_RST_RCVD : TCP_S2C_UNVERIFIED_RST_RCVD;
}
}
}
int tcp_sess_init(struct session *sess, struct tcp_reassembly_options *opts)
{
struct tcp_session *tcp_sess = &sess->data.tcp;
tcp_sess->c2s_data_queue = tcp_reassembly_new(opts);
if (tcp_sess->c2s_data_queue == NULL)
{
return -1;
}
tcp_sess->s2c_data_queue = tcp_reassembly_new(opts);
if (tcp_sess->s2c_data_queue == NULL)
{
tcp_reassembly_free(tcp_sess->c2s_data_queue);
return -1;
}
return 0;
}
void tcp_sess_clean(struct session *sess)
{
struct tcp_session *tcp_sess = &sess->data.tcp;
tcp_reassembly_free(tcp_sess->c2s_data_queue);
tcp_reassembly_free(tcp_sess->s2c_data_queue);
}
void tcp_data_enqueue(struct session *sess, const struct pkt_layer *tcp_layer, uint64_t now)
{
struct tcp_session *tcp_sess = &sess->data.tcp;
struct tcphdr *hdr = (struct tcphdr *)tcp_layer->hdr_ptr;
uint8_t flags = tcp_hdr_get_flags(hdr);
if (sess->cur_dir == SESSION_DIR_C2S)
{
tcp_sess->c2s_seq = tcp_hdr_get_seq(hdr);
tcp_sess->c2s_ack = tcp_hdr_get_ack(hdr);
if (flags & TH_SYN)
{
tcp_reassembly_init(tcp_sess->c2s_data_queue, tcp_sess->c2s_seq);
}
tcp_reassembly_insert(tcp_sess->c2s_data_queue, tcp_sess->c2s_seq, tcp_layer->pld_ptr, tcp_layer->pld_len, now);
}
else
{
tcp_sess->s2c_seq = tcp_hdr_get_seq(hdr);
tcp_sess->s2c_ack = tcp_hdr_get_ack(hdr);
if (flags & TH_SYN)
{
tcp_reassembly_init(tcp_sess->s2c_data_queue, tcp_sess->s2c_seq);
}
tcp_reassembly_insert(tcp_sess->s2c_data_queue, tcp_sess->s2c_seq, tcp_layer->pld_ptr, tcp_layer->pld_len, now);
}
tcp_sub_state_update(tcp_sess, sess->cur_dir, flags);
}
void tcp_data_dequeue(struct session *sess, uint32_t len)
{
struct tcp_session *tcp_sess = &sess->data.tcp;
if (sess->cur_dir == SESSION_DIR_C2S)
{
tcp_reassembly_consume(tcp_sess->c2s_data_queue, len);
}
else
{
tcp_reassembly_consume(tcp_sess->s2c_data_queue, len);
}
}
const char *tcp_data_peek(struct session *sess, uint32_t *len)
{
struct tcp_session *tcp_sess = &sess->data.tcp;
if (sess->cur_dir == SESSION_DIR_C2S)
{
return tcp_reassembly_peek(tcp_sess->c2s_data_queue, len);
}
else
{
return tcp_reassembly_peek(tcp_sess->s2c_data_queue, len);
}
}
void tcp_data_expire(struct session *sess, uint64_t now)
{
struct tcp_session *tcp_sess = &sess->data.tcp;
tcp_reassembly_expire(tcp_sess->c2s_data_queue, now);
tcp_reassembly_expire(tcp_sess->s2c_data_queue, now);
}
/******************************************************************************
* session ex data
******************************************************************************/

41
src/session/session.h
View File

@@ -75,7 +75,7 @@ enum session_packet_index
MAX_PACKETS,
};
enum tcp_sub_state
enum tcp_state
{
TCP_SYN_RCVD = 1 << 0,
TCP_SYN_ACK_RCVD = 1 << 1,
@@ -90,12 +90,14 @@ enum tcp_sub_state
TCP_S2C_UNVERIFIED_RST_RCVD = 1 << 7,
};
struct tcp_session
// the TCP protocol control block
struct tcp_pcb
{
struct tcp_reassembly *c2s_data_queue;
struct tcp_reassembly *s2c_data_queue;
struct tcp_reassembly *c2s_assembler;
struct tcp_reassembly *s2c_assembler;
uint16_t sub_state;
struct tcp_segment order_seg; // order segment from raw packet
uint16_t sub_state; // tcp sub state
uint32_t c2s_seq;
uint32_t s2c_seq;
@@ -104,14 +106,6 @@ struct tcp_session
uint32_t s2c_ack;
};
struct udp_session
{
};
struct icmp_session
{
};
struct session
{
uint64_t id;
@@ -137,12 +131,7 @@ struct session
void *ex_data[EX_DATA_MAX_COUNT];
void *user_data;
union
{
struct tcp_session tcp;
struct udp_session udp;
struct icmp_session icmp;
} data;
struct tcp_pcb tcp_pcb;
};
/******************************************************************************
@@ -189,6 +178,9 @@ const struct packet *session_get_packet(const struct session *sess, enum session
void session_set_user_data(struct session *sess, void *user_data);
void *session_get_user_data(const struct session *sess);
struct tcp_segment *session_get_tcp_segment(struct session *sess);
void session_free_tcp_segment(struct session *sess, struct tcp_segment *seg);
/******************************************************************************
* to string
******************************************************************************/
@@ -199,17 +191,6 @@ const char *session_type_to_str(enum session_type type);
const char *session_dir_to_str(enum session_dir dir);
void session_dump(struct session *sess);
/******************************************************************************
* tcp session
******************************************************************************/
int tcp_sess_init(struct session *sess, struct tcp_reassembly_options *opts);
void tcp_sess_clean(struct session *sess);
void tcp_data_enqueue(struct session *sess, const struct pkt_layer *tcp_layer, uint64_t now);
void tcp_data_dequeue(struct session *sess, uint32_t len);
const char *tcp_data_peek(struct session *sess, uint32_t *len);
void tcp_data_expire(struct session *sess, uint64_t now);
/******************************************************************************
* session ex data
******************************************************************************/

167
src/session/session_manager.cpp
View File

@@ -31,8 +31,9 @@ struct session_manager
uint64_t tcp_unverified_rst_timeout; // range: [1, 600000]
// UDP timeout
uint64_t udp_data_timeout; // range: [1, 15999999000]
struct tcp_reassembly_options tcp_reassembly_opts;
// TCP reassembly
uint32_t tcp_reassembly_max_timeout; // range: [1, 60000] (ms)
uint32_t tcp_reassembly_max_segments; // range: [2, 32]
struct session_pool *sess_pool;
struct session_table *tcp_sess_table;
@@ -101,6 +102,135 @@ int check_options(const struct session_manager_options *opts)
return 0;
}
/*
* The next routines deal with comparing 32 bit unsigned ints
* and worry about wraparound (automatic with unsigned arithmetic).
*/
static inline bool before(uint32_t seq1, uint32_t seq2)
{
return (int32_t)(seq1 - seq2) < 0;
}
static void tcp_pcb_clean(struct tcp_pcb *pcb)
{
if (pcb)
{
tcp_reassembly_free(pcb->c2s_assembler);
tcp_reassembly_free(pcb->s2c_assembler);
}
}
static int tcp_pcb_init(struct tcp_pcb *pcb, uint64_t max_timeout, uint64_t max_seg_num)
{
pcb->c2s_assembler = tcp_reassembly_new(max_timeout, max_seg_num);
pcb->s2c_assembler = tcp_reassembly_new(max_timeout, max_seg_num);
if (pcb->c2s_assembler == NULL || pcb->s2c_assembler == NULL)
{
tcp_pcb_clean(pcb);
return -1;
}
return 0;
}
static void tcp_pcb_update(struct tcp_pcb *pcb, enum session_dir dir, const struct pkt_layer *tcp_layer, uint64_t now)
{
struct tcp_segment *seg;
struct tcp_reassembly *assembler;
struct tcphdr *hdr = (struct tcphdr *)tcp_layer->hdr_ptr;
uint32_t seq = tcp_hdr_get_seq(hdr);
uint32_t ack = tcp_hdr_get_ack(hdr);
uint8_t flags = tcp_hdr_get_flags(hdr);
uint32_t rcv_nxt;
/*
* https://www.rfc-editor.org/rfc/rfc5961#section-3.2
*
* If the RST bit is set and the sequence number exactly matches the
* next expected sequence number (RCV.NXT), then TCP MUST reset the
* connection.
*
* if fin is received, the expected sequence number should be increased by 1
*/
uint16_t expect = 0;
if (dir == SESSION_DIR_C2S)
{
pcb->c2s_seq = seq;
pcb->c2s_ack = ack;
assembler = pcb->c2s_assembler;
expect = pcb->s2c_ack;
expect += pcb->sub_state & TCP_S2C_FIN_RCVD ? 1 : 0;
pcb->sub_state |= (flags & TH_SYN) ? TCP_SYN_RCVD : 0;
pcb->sub_state |= (flags & TH_FIN) ? TCP_C2S_FIN_RCVD : 0;
pcb->sub_state |= ((flags & TH_RST) && (seq == expect)) ? TCP_C2S_RST_RCVD : 0;
pcb->sub_state |= ((flags & TH_RST) && (seq != expect)) ? TCP_C2S_UNVERIFIED_RST_RCVD : 0;
}
else
{
pcb->s2c_seq = seq;
pcb->s2c_ack = ack;
assembler = pcb->s2c_assembler;
expect = pcb->c2s_ack;
expect += pcb->sub_state & TCP_C2S_FIN_RCVD ? 1 : 0;
pcb->sub_state |= (flags & TH_SYN) ? TCP_SYN_ACK_RCVD : 0;
pcb->sub_state |= (flags & TH_FIN) ? TCP_S2C_FIN_RCVD : 0;
pcb->sub_state |= ((flags & TH_RST) && (seq == expect)) ? TCP_S2C_RST_RCVD : 0;
pcb->sub_state |= ((flags & TH_RST) && (seq != expect)) ? TCP_S2C_UNVERIFIED_RST_RCVD : 0;
}
if (flags & TH_SYN)
{
tcp_reassembly_set_recv_next(assembler, seq + 1);
}
seg = tcp_reassembly_expire(assembler, now);
if (seg)
{
// TODO add metric (expire)
tcp_segment_free(seg);
}
if (tcp_layer->pld_len)
{
rcv_nxt = tcp_reassembly_get_recv_next(assembler);
if (seq == rcv_nxt)
{
pcb->order_seg.data = tcp_layer->pld_ptr;
pcb->order_seg.len = tcp_layer->pld_len;
tcp_reassembly_inc_recv_next(assembler, tcp_layer->pld_len);
}
else if (before(seq, rcv_nxt))
{
// TODO add metric (overlap)
}
else if ((seg = tcp_segment_new(seq, tcp_layer->pld_ptr, tcp_layer->pld_len)))
{
switch (tcp_reassembly_push(assembler, seg, now))
{
case -1:
// TODO add metric (assembler full)
tcp_segment_free(seg);
break;
case 0:
// TODO add metric (assembler push success)
break;
case 1:
// TODO add metric (assembler push success, overlap)
break;
default:
assert(0);
break;
}
}
}
}
/******************************************************************************
* Stat
******************************************************************************/
@@ -435,6 +565,7 @@ static struct session *session_manager_new_tcp_session(struct session_manager *m
session_manager_evicte_session(mgr, evic_sess, now);
}
enum session_dir dir = (flags & TH_ACK) ? SESSION_DIR_S2C : SESSION_DIR_C2S;
struct session *sess = session_pool_pop(mgr->sess_pool);
if (sess == NULL)
{
@@ -443,27 +574,26 @@ static struct session *session_manager_new_tcp_session(struct session_manager *m
}
session_init(sess);
session_set_id(sess, id_generator_alloc());
if (tcp_sess_init(sess, &mgr->tcp_reassembly_opts) == -1)
if (tcp_pcb_init(&sess->tcp_pcb, mgr->tcp_reassembly_max_timeout, mgr->tcp_reassembly_max_segments) == -1)
{
assert(0);
session_pool_push(mgr->sess_pool, sess);
return NULL;
}
mgr->stat.tcp_sess.nr_sess_used++;
tcp_pcb_update(&sess->tcp_pcb, dir, tcp_layer, now);
enum session_dir dir = tcp_hdr_get_ack_flag(hdr) ? SESSION_DIR_S2C : SESSION_DIR_C2S;
enum session_state next_state = session_transition_run(SESSION_STATE_INIT, TCP_SYN);
session_update(sess, next_state, pkt, key, dir, now);
session_transition_log(sess, SESSION_STATE_INIT, next_state, TCP_SYN);
session_stat_inc(&mgr->stat.tcp_sess, next_state);
tcp_data_enqueue(sess, tcp_layer, now);
uint64_t timeout = (flags & TH_ACK) ? mgr->tcp_handshake_timeout : mgr->tcp_init_timeout;
session_timer_update(mgr->sess_timer, sess, now + timeout);
session_table_add(mgr->tcp_sess_table, key, sess);
duplicated_packet_filter_add(mgr->dup_pkt_filter, pkt, now);
mgr->stat.tcp_sess.nr_sess_used++;
return sess;
}
@@ -515,8 +645,7 @@ static int session_manager_update_tcp_session(struct session_manager *mgr, struc
session_transition_log(sess, curr_state, next_state, inputs);
session_stat_update(mgr, sess, curr_state, next_state);
tcp_data_expire(sess, now);
tcp_data_enqueue(sess, tcp_layer, now);
tcp_pcb_update(&sess->tcp_pcb, dir, tcp_layer, now);
// set closing reason
if (next_state == SESSION_STATE_CLOSING && !session_get_closing_reason(sess))
@@ -531,7 +660,7 @@ static int session_manager_update_tcp_session(struct session_manager *mgr, struc
}
}
uint16_t sub_state = sess->data.tcp.sub_state;
uint16_t sub_state = sess->tcp_pcb.sub_state;
uint64_t timeout = 0;
switch (next_state)
@@ -620,6 +749,10 @@ struct session_manager *session_manager_new(struct session_manager_options *opts
mgr->tcp_discard_timeout = opts->tcp_discard_timeout;
mgr->tcp_unverified_rst_timeout = opts->tcp_unverified_rst_timeout;
mgr->udp_data_timeout = opts->udp_data_timeout;
// tcp reassembly
mgr->tcp_reassembly_max_timeout = opts->tcp_reassembly_max_timeout;
mgr->tcp_reassembly_max_segments = opts->tcp_reassembly_max_segments;
// duplicated packet filter
struct duplicated_packet_filter_options duplicated_packet_filter_opts = {
.enable = opts->duplicated_packet_filter_enable,
@@ -634,13 +767,6 @@ struct session_manager *session_manager_new(struct session_manager_options *opts
.timeout = opts->evicted_session_filter_timeout,
.error_rate = opts->evicted_session_filter_error_rate,
};
// tcp reassembly
mgr->tcp_reassembly_opts = {
.enable = opts->tcp_reassembly_enable,
.max_timeout = opts->tcp_reassembly_max_timeout,
.max_segments = opts->tcp_reassembly_max_segments,
.max_bytes = opts->tcp_reassembly_max_bytes,
};
mgr->sess_pool = session_pool_new(mgr->max_tcp_session_num + mgr->max_udp_session_num);
mgr->tcp_sess_table = session_table_new();
@@ -729,7 +855,7 @@ void session_manager_free_session(struct session_manager *mgr, struct session *s
switch (session_get_type(sess))
{
case SESSION_TYPE_TCP:
tcp_sess_clean(sess);
tcp_pcb_clean(&sess->tcp_pcb);
session_table_del(mgr->tcp_sess_table, session_get_tuple(sess));
session_stat_dec(&mgr->stat.tcp_sess, session_get_state(sess));
mgr->stat.tcp_sess.nr_sess_used--;
@@ -839,14 +965,13 @@ struct session *session_manager_get_expired_session(struct session_manager *mgr,
struct session *session_manager_get_evicted_session(struct session_manager *mgr)
{
struct session *sess = NULL;
if (list_empty(&mgr->evicte_queue))
{
return sess;
return NULL;
}
else
{
sess = list_first_entry(&mgr->evicte_queue, struct session, evicte);
struct session *sess = list_first_entry(&mgr->evicte_queue, struct session, evicte);
list_del(&sess->evicte);
return sess;
}

3
src/session/session_manager.h
View File

@@ -46,10 +46,9 @@ struct session_manager_options
double evicted_session_filter_error_rate; // range: [0.0, 1.0]
// TCP reassembly
uint8_t tcp_reassembly_enable;
uint8_t tcp_reassembly_enable; // TODO not support
uint32_t tcp_reassembly_max_timeout; // range: [1, 60000] (ms)
uint32_t tcp_reassembly_max_segments; // range: [2, 32]
uint32_t tcp_reassembly_max_bytes; // range: [2920, 46720] [2*MSS, 32*MSS]
};
struct session_stat

1
src/session/test/gtest_filter_tcp_dupkt.cpp
View File

@@ -43,7 +43,6 @@ struct session_manager_options opts = {
.tcp_reassembly_enable = 1,
.tcp_reassembly_max_timeout = 60000,
.tcp_reassembly_max_segments = 0,
.tcp_reassembly_max_bytes = 0,
};
static void packet_set_ip_id(struct packet *pkt, uint16_t ip_id)

1
src/session/test/gtest_overload_evict_tcp_sess.cpp
View File

@@ -45,7 +45,6 @@ struct session_manager_options opts = {
.tcp_reassembly_enable = 1,
.tcp_reassembly_max_timeout = 60000,
.tcp_reassembly_max_segments = 0,
.tcp_reassembly_max_bytes = 0,
};
static void packet_set_tcp_src_addr(struct packet *pkt, uint32_t addr)

1
src/session/test/gtest_overload_evict_udp_sess.cpp
View File

@@ -45,7 +45,6 @@ struct session_manager_options opts = {
.tcp_reassembly_enable = 1,
.tcp_reassembly_max_timeout = 60000,
.tcp_reassembly_max_segments = 0,
.tcp_reassembly_max_bytes = 0,
};
static void packet_set_tcp_src_addr(struct packet *pkt, uint32_t addr)

133
src/session/test/gtest_sess_mgr_tcp_reassembly.cpp
View File

@@ -42,8 +42,7 @@ struct session_manager_options opts = {
// TCP Reassembly
.tcp_reassembly_enable = 1,
.tcp_reassembly_max_timeout = 60000,
.tcp_reassembly_max_segments = 0,
.tcp_reassembly_max_bytes = 0,
.tcp_reassembly_max_segments = 16,
};
static void hex_dump(const char *payload, uint32_t len)
@@ -63,8 +62,7 @@ static void hex_dump(const char *payload, uint32_t len)
#if 1
TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
{
uint32_t len = 0;
const char *payload = NULL;
struct tcp_segment *seg;
struct packet pkt;
struct session *sess = NULL;
struct session_manager *mgr = NULL;
@@ -83,9 +81,8 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
sess = session_manager_new_session(mgr, &pkt, 1);
EXPECT_TRUE(sess);
payload = tcp_data_peek(sess, &len);
EXPECT_TRUE(payload == NULL);
EXPECT_TRUE(len == 0);
seg = session_get_tcp_segment(sess);
EXPECT_TRUE(seg == NULL);
// C2S ACK Packet
printf("\n=> Packet Parse: TCP C2S ACK packet\n");
@@ -98,9 +95,8 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
// update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0);
payload = tcp_data_peek(sess, &len);
EXPECT_TRUE(payload == NULL);
EXPECT_TRUE(len == 0);
seg = session_get_tcp_segment(sess);
EXPECT_TRUE(seg == NULL);
// C2S Data Packet 2222
printf("\n=> Packet Parse: TCP C2S Data packet\n");
@@ -113,9 +109,8 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
// update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 3) == 0);
payload = tcp_data_peek(sess, &len);
EXPECT_TRUE(payload == NULL);
EXPECT_TRUE(len == 0);
seg = session_get_tcp_segment(sess);
EXPECT_TRUE(seg == NULL);
// C2S Data Packet 3333
printf("\n=> Packet Parse: TCP C2S Data packet\n");
@@ -128,9 +123,8 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
// update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 4) == 0);
payload = tcp_data_peek(sess, &len);
EXPECT_TRUE(payload == NULL);
EXPECT_TRUE(len == 0);
seg = session_get_tcp_segment(sess);
EXPECT_TRUE(seg == NULL);
// C2S Data Packet 4444
printf("\n=> Packet Parse: TCP C2S Data packet\n");
@@ -143,9 +137,8 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
// update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 5) == 0);
payload = tcp_data_peek(sess, &len);
EXPECT_TRUE(payload == NULL);
EXPECT_TRUE(len == 0);
seg = session_get_tcp_segment(sess);
EXPECT_TRUE(seg == NULL);
// C2S Data Packet 5555
printf("\n=> Packet Parse: TCP C2S Data packet\n");
@@ -158,9 +151,8 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
// update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 6) == 0);
payload = tcp_data_peek(sess, &len);
EXPECT_TRUE(payload == NULL);
EXPECT_TRUE(len == 0);
seg = session_get_tcp_segment(sess);
EXPECT_TRUE(seg == NULL);
// C2S Data Packet 1111
printf("\n=> Packet Parse: TCP C2S Data packet\n");
@@ -202,40 +194,40 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35,
0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x0a};
payload = tcp_data_peek(sess, &len);
EXPECT_TRUE(payload != NULL);
EXPECT_TRUE(len == sizeof(payload1));
EXPECT_TRUE(memcmp((void *)payload, payload1, sizeof(payload1)) == 0);
hex_dump(payload, len);
tcp_data_dequeue(sess, len);
seg = session_get_tcp_segment(sess);
EXPECT_TRUE(seg != NULL);
EXPECT_TRUE(seg->len == sizeof(payload1));
EXPECT_TRUE(memcmp((void *)seg->data, payload1, sizeof(payload1)) == 0);
hex_dump((const char *)seg->data, seg->len);
session_free_tcp_segment(sess, seg);
payload = tcp_data_peek(sess, &len);
EXPECT_TRUE(payload != NULL);
EXPECT_TRUE(len == sizeof(payload2));
EXPECT_TRUE(memcmp((void *)payload, payload2, sizeof(payload2)) == 0);
hex_dump(payload, len);
tcp_data_dequeue(sess, len);
seg = session_get_tcp_segment(sess);
EXPECT_TRUE(seg != NULL);
EXPECT_TRUE(seg->len == sizeof(payload2));
EXPECT_TRUE(memcmp((void *)seg->data, payload2, sizeof(payload2)) == 0);
hex_dump((const char *)seg->data, seg->len);
session_free_tcp_segment(sess, seg);
payload = tcp_data_peek(sess, &len);
EXPECT_TRUE(payload != NULL);
EXPECT_TRUE(len == sizeof(payload3));
EXPECT_TRUE(memcmp((void *)payload, payload3, sizeof(payload3)) == 0);
hex_dump(payload, len);
tcp_data_dequeue(sess, len);
seg = session_get_tcp_segment(sess);
EXPECT_TRUE(seg != NULL);
EXPECT_TRUE(seg->len == sizeof(payload3));
EXPECT_TRUE(memcmp((void *)seg->data, payload3, sizeof(payload3)) == 0);
hex_dump((const char *)seg->data, seg->len);
session_free_tcp_segment(sess, seg);
payload = tcp_data_peek(sess, &len);
EXPECT_TRUE(payload != NULL);
EXPECT_TRUE(len == sizeof(payload4));
EXPECT_TRUE(memcmp((void *)payload, payload4, sizeof(payload4)) == 0);
hex_dump(payload, len);
tcp_data_dequeue(sess, len);
seg = session_get_tcp_segment(sess);
EXPECT_TRUE(seg != NULL);
EXPECT_TRUE(seg->len == sizeof(payload4));
EXPECT_TRUE(memcmp((void *)seg->data, payload4, sizeof(payload4)) == 0);
hex_dump((const char *)seg->data, seg->len);
session_free_tcp_segment(sess, seg);
payload = tcp_data_peek(sess, &len);
EXPECT_TRUE(payload != NULL);
EXPECT_TRUE(len == sizeof(payload5));
EXPECT_TRUE(memcmp((void *)payload, payload5, sizeof(payload5)) == 0);
hex_dump(payload, len);
tcp_data_dequeue(sess, len);
seg = session_get_tcp_segment(sess);
EXPECT_TRUE(seg != NULL);
EXPECT_TRUE(seg->len == sizeof(payload5));
EXPECT_TRUE(memcmp((void *)seg->data, payload5, sizeof(payload5)) == 0);
hex_dump((const char *)seg->data, seg->len);
session_free_tcp_segment(sess, seg);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 7 + opts.tcp_data_timeout) == NULL); // active -> closing
@@ -254,8 +246,7 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
#if 1
TEST(SESS_MGR_TCP_REASSEMBLY, SEQ_WRAPAROUND)
{
uint32_t len = 0;
const char *payload = NULL;
struct tcp_segment *seg;
struct packet pkt;
struct session *sess = NULL;
struct session_manager *mgr = NULL;
@@ -274,9 +265,8 @@ TEST(SESS_MGR_TCP_REASSEMBLY, SEQ_WRAPAROUND)
sess = session_manager_new_session(mgr, &pkt, 1);
EXPECT_TRUE(sess);
payload = tcp_data_peek(sess, &len);
EXPECT_TRUE(payload == NULL);
EXPECT_TRUE(len == 0);
seg = session_get_tcp_segment(sess);
EXPECT_TRUE(seg == NULL);
// C2S ACK Packet
printf("\n=> Packet Parse: TCP C2S ACK packet\n");
@@ -289,9 +279,8 @@ TEST(SESS_MGR_TCP_REASSEMBLY, SEQ_WRAPAROUND)
// update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0);
payload = tcp_data_peek(sess, &len);
EXPECT_TRUE(payload == NULL);
EXPECT_TRUE(len == 0);
seg = session_get_tcp_segment(sess);
EXPECT_TRUE(seg == NULL);
// C2S Data Packet
printf("\n=> Packet Parse: TCP C2S Data packet\n");
@@ -304,12 +293,12 @@ TEST(SESS_MGR_TCP_REASSEMBLY, SEQ_WRAPAROUND)
// update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 3) == 0);
payload = tcp_data_peek(sess, &len);
EXPECT_TRUE(payload != NULL);
EXPECT_TRUE(len == sizeof(tcp_seq_wraparound_pkt3_payload));
EXPECT_TRUE(memcmp((void *)payload, tcp_seq_wraparound_pkt3_payload, sizeof(tcp_seq_wraparound_pkt3_payload)) == 0);
hex_dump(payload, len);
tcp_data_dequeue(sess, len);
seg = session_get_tcp_segment(sess);
EXPECT_TRUE(seg != NULL);
EXPECT_TRUE(seg->len == sizeof(tcp_seq_wraparound_pkt3_payload));
EXPECT_TRUE(memcmp((void *)seg->data, tcp_seq_wraparound_pkt3_payload, sizeof(tcp_seq_wraparound_pkt3_payload)) == 0);
hex_dump((const char *)seg->data, seg->len);
session_free_tcp_segment(sess, seg);
// C2S Data Packet
printf("\n=> Packet Parse: TCP C2S Data packet\n");
@@ -322,12 +311,12 @@ TEST(SESS_MGR_TCP_REASSEMBLY, SEQ_WRAPAROUND)
// update session
EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 4) == 0);
payload = tcp_data_peek(sess, &len);
EXPECT_TRUE(payload != NULL);
EXPECT_TRUE(len == sizeof(tcp_seq_wraparound_pkt4_payload));
EXPECT_TRUE(memcmp((void *)payload, tcp_seq_wraparound_pkt4_payload, sizeof(tcp_seq_wraparound_pkt4_payload)) == 0);
hex_dump(payload, len);
tcp_data_dequeue(sess, len);
seg = session_get_tcp_segment(sess);
EXPECT_TRUE(seg != NULL);
EXPECT_TRUE(seg->len == sizeof(tcp_seq_wraparound_pkt4_payload));
EXPECT_TRUE(memcmp((void *)seg->data, tcp_seq_wraparound_pkt4_payload, sizeof(tcp_seq_wraparound_pkt4_payload)) == 0);
hex_dump((const char *)seg->data, seg->len);
session_free_tcp_segment(sess, seg);
// expire session
EXPECT_TRUE(session_manager_get_expired_session(mgr, 4 + opts.tcp_data_timeout) == NULL); // active -> closing

1
src/session/test/gtest_state_tcp_active_to_closing.cpp
View File

@@ -44,7 +44,6 @@ struct session_manager_options opts = {
.tcp_reassembly_enable = 1,
.tcp_reassembly_max_timeout = 60000,
.tcp_reassembly_max_segments = 0,
.tcp_reassembly_max_bytes = 0,
};
static void build_active_tcp_session(struct session_manager *mgr, struct session *sess)

1
src/session/test/gtest_state_tcp_init_to_opening.cpp
View File

@@ -44,7 +44,6 @@ struct session_manager_options opts = {
.tcp_reassembly_enable = 1,
.tcp_reassembly_max_timeout = 60000,
.tcp_reassembly_max_segments = 0,
.tcp_reassembly_max_bytes = 0,
};
/******************************************************************************

1
src/session/test/gtest_state_tcp_init_to_opening_to_active_to_closing_to_closed.cpp
View File

@@ -43,7 +43,6 @@ struct session_manager_options opts = {
.tcp_reassembly_enable = 1,
.tcp_reassembly_max_timeout = 60000,
.tcp_reassembly_max_segments = 0,
.tcp_reassembly_max_bytes = 0,
};
#if 1

1
src/session/test/gtest_state_tcp_opening_to_active.cpp
View File

@@ -43,7 +43,6 @@ struct session_manager_options opts = {
.tcp_reassembly_enable = 1,
.tcp_reassembly_max_timeout = 60000,
.tcp_reassembly_max_segments = 0,
.tcp_reassembly_max_bytes = 0,
};
/******************************************************************************

1
src/session/test/gtest_state_tcp_opening_to_closing.cpp
View File

@@ -44,7 +44,6 @@ struct session_manager_options opts = {
.tcp_reassembly_enable = 1,
.tcp_reassembly_max_timeout = 60000,
.tcp_reassembly_max_segments = 0,
.tcp_reassembly_max_bytes = 0,
};
/******************************************************************************

1
src/session/test/gtest_state_udp_init_to_opening_to_active_to_closing.cpp
View File

@@ -43,7 +43,6 @@ struct session_manager_options opts = {
.tcp_reassembly_enable = 1,
.tcp_reassembly_max_timeout = 60000,
.tcp_reassembly_max_segments = 0,
.tcp_reassembly_max_bytes = 0,
};
#if 1

1
src/session/test/gtest_state_udp_init_to_opening_to_closing.cpp
View File

@@ -43,7 +43,6 @@ struct session_manager_options opts = {
.tcp_reassembly_enable = 1,
.tcp_reassembly_max_timeout = 60000,
.tcp_reassembly_max_segments = 0,
.tcp_reassembly_max_bytes = 0,
};
/******************************************************************************

1
src/session/test/gtest_timeout_tcp_data.cpp
View File

@@ -42,7 +42,6 @@ struct session_manager_options opts = {
.tcp_reassembly_enable = 1,
.tcp_reassembly_max_timeout = 60000,
.tcp_reassembly_max_segments = 0,
.tcp_reassembly_max_bytes = 0,
};
#if 1

1
src/session/test/gtest_timeout_tcp_handshake.cpp
View File

@@ -43,7 +43,6 @@ struct session_manager_options opts = {
.tcp_reassembly_enable = 1,
.tcp_reassembly_max_timeout = 60000,
.tcp_reassembly_max_segments = 0,
.tcp_reassembly_max_bytes = 0,
};
#if 1

1
src/session/test/gtest_timeout_tcp_init.cpp
View File

@@ -43,7 +43,6 @@ struct session_manager_options opts = {
.tcp_reassembly_enable = 1,
.tcp_reassembly_max_timeout = 60000,
.tcp_reassembly_max_segments = 0,
.tcp_reassembly_max_bytes = 0,
};
#if 1

1
src/session/test/gtest_timeout_udp_data.cpp
View File

@@ -42,7 +42,6 @@ struct session_manager_options opts = {
.tcp_reassembly_enable = 1,
.tcp_reassembly_max_timeout = 60000,
.tcp_reassembly_max_segments = 0,
.tcp_reassembly_max_bytes = 0,
};
#if 1