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

rename flow_direction to flow_type

Browse Source
This commit is contained in:
luwenpeng
2024-09-02 17:49:33 +08:00
parent f8ec4dc5a7
commit a8206cffc0
28 changed files with 598 additions and 599 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
decoders/http/http_decoder.c
View File

@@ -128,7 +128,7 @@ static void http_event_handler(enum http_event event, struct http_decoder_half_d
case HTTP_EVENT_REQ_LINE:
msg = http_message_new(HTTP_MESSAGE_REQ_LINE, queue, queue_idx, HTTP_REQUEST);
session_mq_publish_message(ev_ctx->ref_session, exdata->pub_topic_id, msg);
if (httpd_tunnel_identify(httpd_env, FLOW_DIRECTION_C2S, half_data))
if (httpd_tunnel_identify(httpd_env, FLOW_TYPE_C2S, half_data))
{
exdata->tunnel_state = HTTP_TUN_C2S_HDR_START;
// http_decoder_stat_update(&httpd_env->hd_stat, thread_id, HTTPD_STAT_TUNNEL, 1);
@@ -259,7 +259,7 @@ static void http_event_handler(enum http_event event, struct http_decoder_half_d
case HTTP_EVENT_RES_LINE:
msg = http_message_new(HTTP_MESSAGE_RES_LINE, queue, queue_idx, HTTP_RESPONSE);
session_mq_publish_message(ev_ctx->ref_session, exdata->pub_topic_id, msg);
if (httpd_tunnel_identify(httpd_env, FLOW_DIRECTION_S2C, half_data))
if (httpd_tunnel_identify(httpd_env, FLOW_TYPE_S2C, half_data))
{
exdata->tunnel_state = HTTP_TUN_S2C_START;
}
@@ -668,8 +668,8 @@ extern "C"
int thread_id = stellar_get_current_thread_index();
struct http_decoder_half *cur_half = NULL;
enum flow_direction sess_dir = session_get_current_flow_direction(sess);
if (FLOW_DIRECTION_C2S == sess_dir)
enum flow_type sess_dir = session_get_flow_type(sess);
if (FLOW_TYPE_C2S == sess_dir)
{
cur_half = exdata->decoder->c2s_half;
http_decoder_stat_update(&httpd_env->hd_stat, thread_id, HTTP_C2S_BYTES, payload_len);

2
decoders/http/http_decoder_tunnel.c
View File

@@ -19,7 +19,7 @@ int httpd_tunnel_identify(struct http_decoder_env *httpd_env, int curdir, struct
return 0;
}
if (FLOW_DIRECTION_C2S == curdir)
if (FLOW_TYPE_C2S == curdir)
{
struct http_request_line reqline = {};
http_decoder_half_data_get_request_line(hfdata, &reqline);

18
decoders/http/http_decoder_utils.c
View File

@@ -110,8 +110,8 @@ int http_message_type_is_req(struct session *sess, enum http_message_type msg_ty
case HTTP_TRANSACTION_START:
case HTTP_TRANSACTION_END:
{
enum flow_direction cur_dir = session_get_current_flow_direction(sess);
if (FLOW_DIRECTION_C2S == cur_dir)
enum flow_type cur_dir = session_get_flow_type(sess);
if (FLOW_TYPE_C2S == cur_dir)
{
is_req_msg = 1;
}
@@ -233,9 +233,9 @@ int httpd_url_is_encoded(const char *url, size_t len)
return 0;
}
static void httpd_set_tcp_addr(const struct tcphdr *tcph, struct httpd_session_addr *addr, enum flow_direction fdir)
static void httpd_set_tcp_addr(const struct tcphdr *tcph, struct httpd_session_addr *addr, enum flow_type fdir)
{
if (FLOW_DIRECTION_C2S == fdir)
if (FLOW_TYPE_C2S == fdir)
{
addr->sport = tcph->th_sport;
addr->dport = tcph->th_dport;
@@ -246,10 +246,10 @@ static void httpd_set_tcp_addr(const struct tcphdr *tcph, struct httpd_session_a
addr->dport = tcph->th_sport;
}
}
static void httpd_set_ipv4_addr(const struct ip *ip4h, struct httpd_session_addr *addr, enum flow_direction fdir)
static void httpd_set_ipv4_addr(const struct ip *ip4h, struct httpd_session_addr *addr, enum flow_type fdir)
{
addr->ipver = 4;
if (FLOW_DIRECTION_C2S == fdir)
if (FLOW_TYPE_C2S == fdir)
{
addr->saddr4 = ip4h->ip_src.s_addr;
addr->daddr4 = ip4h->ip_dst.s_addr;
@@ -260,10 +260,10 @@ static void httpd_set_ipv4_addr(const struct ip *ip4h, struct httpd_session_addr
addr->daddr4 = ip4h->ip_src.s_addr;
}
}
static void httpd_set_ipv6_addr(const struct ip6_hdr *ip6h, struct httpd_session_addr *addr, enum flow_direction fdir)
static void httpd_set_ipv6_addr(const struct ip6_hdr *ip6h, struct httpd_session_addr *addr, enum flow_type fdir)
{
addr->ipver = 6;
if (FLOW_DIRECTION_C2S == fdir)
if (FLOW_TYPE_C2S == fdir)
{
memcpy(&addr->saddr6, &ip6h->ip6_src, sizeof(struct in6_addr));
memcpy(&addr->daddr6, &ip6h->ip6_dst, sizeof(struct in6_addr));
@@ -281,7 +281,7 @@ void httpd_session_get_addr(const struct session *sess, struct httpd_session_add
{
return;
}
enum flow_direction fdir = session_get_current_flow_direction(sess);
enum flow_type fdir = session_get_flow_type(sess);
const struct packet *raw_pkt = session_get_first_packet(sess, fdir);
if (NULL == raw_pkt)
{

18
decoders/lpi/lpi_plugin.cpp
View File

@@ -152,8 +152,8 @@ static void get_host_order_port(struct session *sess __unused, unsigned short *s
//get host order port from stellar session api
const struct packet *pkt = session_get0_current_packet(sess);
enum flow_direction flow_dir=session_get_current_flow_direction(sess);
if(pkt && (flow_dir==FLOW_DIRECTION_C2S || flow_dir==FLOW_DIRECTION_S2C))
enum flow_type flow_type=session_get_flow_type(sess);
if(pkt && (flow_type==FLOW_TYPE_C2S || flow_type==FLOW_TYPE_S2C))
{
int layer_cnt=packet_get_layer_count(pkt);
const struct layer *layer = packet_get_layer_by_idx(pkt, layer_cnt - 1);
@@ -168,7 +168,7 @@ static void get_host_order_port(struct session *sess __unused, unsigned short *s
*dport = ntohs(layer->hdr.udp->uh_dport);
}
//S2C, swap sport and dport
if(flow_dir == FLOW_DIRECTION_S2C)
if(flow_type == FLOW_TYPE_S2C)
{
unsigned short tmp = *sport;
*sport = *dport;
@@ -539,10 +539,10 @@ static int lpi_detector(struct session *sess, struct traffic_context *context, s
struct l7_protocol_label *l7_protocol=NULL;
//const struct packet *raw_packet=session_get0_current_packet(sess);
//int cur_pkt_dir= packet_get_direction(raw_packet);
int cur_pkt_dir=session_get_current_flow_direction(sess);
int cur_pkt_dir=session_get_flow_type(sess);
context->pkt_cnt++;
(cur_pkt_dir==FLOW_DIRECTION_C2S) ? (context->c2s_pkt++) : (context->s2c_pkt++);
int is_c2s_pkt=((cur_pkt_dir==FLOW_DIRECTION_C2S) ? 1 : 0);
(cur_pkt_dir==FLOW_TYPE_C2S) ? (context->c2s_pkt++) : (context->s2c_pkt++);
int is_c2s_pkt=((cur_pkt_dir==FLOW_TYPE_C2S) ? 1 : 0);
ret=lpi_update_dpkt(&(context->lpi_data), sess, scan_data, scan_data_len, l4_proto, is_c2s_pkt);
if(!ret)
{
@@ -560,7 +560,7 @@ static int lpi_detector(struct session *sess, struct traffic_context *context, s
{
ret=revise_lpi_result(sess, scan_data, scan_data_len, &modify_lpi_result, context,
(l4_proto==6?1:0),
(cur_pkt_dir==FLOW_DIRECTION_C2S?1:0));
(cur_pkt_dir==FLOW_TYPE_C2S?1:0));
if(ret==0)
{
return 1;
@@ -569,7 +569,7 @@ static int lpi_detector(struct session *sess, struct traffic_context *context, s
plpi_mod=&modify_lpi_result;
}
if (plpi_mod->protocol == LPI_PROTO_FTP_CONTROL && context->is_first_payload == 1 && cur_pkt_dir == FLOW_DIRECTION_S2C)
if (plpi_mod->protocol == LPI_PROTO_FTP_CONTROL && context->is_first_payload == 1 && cur_pkt_dir == FLOW_TYPE_S2C)
{
if ((((scan_data_len >= 4 && (memcmp(scan_data, "220-", 4) == 0)) || memcmp(scan_data, "220 ", 4) == 0)) &&
(((scan_data_len >= 7 && (memmem(scan_data, scan_data_len, " ESMTP ", 7) != NULL)) ||
@@ -585,7 +585,7 @@ static int lpi_detector(struct session *sess, struct traffic_context *context, s
}
}
if (plpi_mod->protocol == LPI_PROTO_SMTP && context->is_first_payload == 1 && cur_pkt_dir == FLOW_DIRECTION_S2C)
if (plpi_mod->protocol == LPI_PROTO_SMTP && context->is_first_payload == 1 && cur_pkt_dir == FLOW_TYPE_S2C)
{
if (
(scan_data_len >= 4) &&

16
include/stellar/session.h
View File

@@ -32,12 +32,12 @@ enum session_direction
SESSION_DIRECTION_OUTBOUND = 1,
};
enum flow_direction
enum flow_type
{
FLOW_DIRECTION_NONE = -1,
FLOW_DIRECTION_C2S = 0,
FLOW_DIRECTION_S2C = 1,
MAX_FLOW_DIRECTION = 2,
FLOW_TYPE_NONE = -1,
FLOW_TYPE_C2S = 0,
FLOW_TYPE_S2C = 1,
MAX_FLOW_TYPE = 2,
};
enum closing_reason
@@ -135,11 +135,11 @@ const struct packet *session_get0_current_packet(const struct session *sess);
enum closing_reason session_get_closing_reason(const struct session *sess);
enum session_direction session_get_direction(const struct session *sess);
enum flow_direction session_get_current_flow_direction(const struct session *sess);
const struct packet *session_get_first_packet(const struct session *sess, enum flow_direction dir);
enum flow_type session_get_flow_type(const struct session *sess);
const struct packet *session_get_first_packet(const struct session *sess, enum flow_type type);
uint64_t session_get_id(const struct session *sess);
uint64_t session_get_timestamp(const struct session *sess, enum session_timestamp type);
uint64_t session_get_stat(const struct session *sess, enum flow_direction dir, enum session_stat stat);
uint64_t session_get_stat(const struct session *sess, enum flow_type type, enum session_stat stat);
const char *session_get0_readable_addr(const struct session *sess);

170
infra/session_manager/session_manager.c
View File

@@ -165,15 +165,15 @@ static uint64_t snowflake_generate(struct snowflake *sf, uint64_t now_sec)
static void tcp_clean(struct session_manager *mgr, struct session *sess)
{
struct tcp_reassembly *c2s_ssembler = sess->tcp_halfs[FLOW_DIRECTION_C2S].assembler;
struct tcp_reassembly *s2c_ssembler = sess->tcp_halfs[FLOW_DIRECTION_S2C].assembler;
struct tcp_reassembly *c2s_ssembler = sess->tcp_halfs[FLOW_TYPE_C2S].assembler;
struct tcp_reassembly *s2c_ssembler = sess->tcp_halfs[FLOW_TYPE_S2C].assembler;
struct tcp_segment *seg;
if (c2s_ssembler)
{
while ((seg = tcp_reassembly_expire(c2s_ssembler, UINT64_MAX)))
{
session_inc_stat(sess, FLOW_DIRECTION_C2S, STAT_TCP_SEGMENTS_RELEASED, 1);
session_inc_stat(sess, FLOW_DIRECTION_C2S, STAT_TCP_PAYLOADS_RELEASED, seg->len);
session_inc_stat(sess, FLOW_TYPE_C2S, STAT_TCP_SEGMENTS_RELEASED, 1);
session_inc_stat(sess, FLOW_TYPE_C2S, STAT_TCP_PAYLOADS_RELEASED, seg->len);
mgr->stat.tcp_segs_freed++;
tcp_segment_free(seg);
}
@@ -183,8 +183,8 @@ static void tcp_clean(struct session_manager *mgr, struct session *sess)
{
while ((seg = tcp_reassembly_expire(s2c_ssembler, UINT64_MAX)))
{
session_inc_stat(sess, FLOW_DIRECTION_S2C, STAT_TCP_SEGMENTS_RELEASED, 1);
session_inc_stat(sess, FLOW_DIRECTION_S2C, STAT_TCP_PAYLOADS_RELEASED, seg->len);
session_inc_stat(sess, FLOW_TYPE_S2C, STAT_TCP_SEGMENTS_RELEASED, 1);
session_inc_stat(sess, FLOW_TYPE_S2C, STAT_TCP_PAYLOADS_RELEASED, seg->len);
mgr->stat.tcp_segs_freed++;
tcp_segment_free(seg);
}
@@ -199,9 +199,9 @@ static int tcp_init(struct session_manager *mgr, struct session *sess)
return 0;
}
sess->tcp_halfs[FLOW_DIRECTION_C2S].assembler = tcp_reassembly_new(mgr->cfg.tcp_reassembly.timeout_ms, mgr->cfg.tcp_reassembly.buffered_segments_max);
sess->tcp_halfs[FLOW_DIRECTION_S2C].assembler = tcp_reassembly_new(mgr->cfg.tcp_reassembly.timeout_ms, mgr->cfg.tcp_reassembly.buffered_segments_max);
if (sess->tcp_halfs[FLOW_DIRECTION_C2S].assembler == NULL || sess->tcp_halfs[FLOW_DIRECTION_S2C].assembler == NULL)
sess->tcp_halfs[FLOW_TYPE_C2S].assembler = tcp_reassembly_new(mgr->cfg.tcp_reassembly.timeout_ms, mgr->cfg.tcp_reassembly.buffered_segments_max);
sess->tcp_halfs[FLOW_TYPE_S2C].assembler = tcp_reassembly_new(mgr->cfg.tcp_reassembly.timeout_ms, mgr->cfg.tcp_reassembly.buffered_segments_max);
if (sess->tcp_halfs[FLOW_TYPE_C2S].assembler == NULL || sess->tcp_halfs[FLOW_TYPE_S2C].assembler == NULL)
{
tcp_clean(mgr, sess);
return -1;
@@ -209,17 +209,17 @@ static int tcp_init(struct session_manager *mgr, struct session *sess)
SESSION_LOG_DEBUG("session %lu %s new c2s tcp assembler %p, s2c tcp assembler %p",
session_get_id(sess), session_get0_readable_addr(sess),
sess->tcp_halfs[FLOW_DIRECTION_C2S].assembler,
sess->tcp_halfs[FLOW_DIRECTION_S2C].assembler);
sess->tcp_halfs[FLOW_TYPE_C2S].assembler,
sess->tcp_halfs[FLOW_TYPE_S2C].assembler);
return 0;
}
static void tcp_update(struct session_manager *mgr, struct session *sess, enum flow_direction dir, const struct layer_private *tcp_layer)
static void tcp_update(struct session_manager *mgr, struct session *sess, enum flow_type type, const struct layer_private *tcp_layer)
{
struct tcp_segment *seg;
struct tcphdr *hdr = (struct tcphdr *)tcp_layer->hdr_ptr;
struct tcp_half *half = &sess->tcp_halfs[dir];
struct tcp_half *half = &sess->tcp_halfs[type];
uint8_t flags = tcp_hdr_get_flags(hdr);
uint16_t len = tcp_layer->pld_len;
@@ -237,12 +237,12 @@ static void tcp_update(struct session_manager *mgr, struct session *sess, enum f
{
if (len)
{
session_inc_stat(sess, dir, STAT_TCP_SEGMENTS_RECEIVED, 1);
session_inc_stat(sess, dir, STAT_TCP_PAYLOADS_RECEIVED, len);
session_inc_stat(sess, type, STAT_TCP_SEGMENTS_RECEIVED, 1);
session_inc_stat(sess, type, STAT_TCP_PAYLOADS_RECEIVED, len);
mgr->stat.tcp_segs_input++;
session_inc_stat(sess, dir, STAT_TCP_SEGMENTS_INORDER, 1);
session_inc_stat(sess, dir, STAT_TCP_PAYLOADS_INORDER, len);
session_inc_stat(sess, type, STAT_TCP_SEGMENTS_INORDER, 1);
session_inc_stat(sess, type, STAT_TCP_PAYLOADS_INORDER, len);
mgr->stat.tcp_segs_inorder++;
half->in_order.data = tcp_layer->pld_ptr;
@@ -261,12 +261,12 @@ static void tcp_update(struct session_manager *mgr, struct session *sess, enum f
seg = tcp_reassembly_expire(half->assembler, mgr->now_ms);
if (seg)
{
session_inc_stat(sess, dir, STAT_TCP_SEGMENTS_EXPIRED, 1);
session_inc_stat(sess, dir, STAT_TCP_PAYLOADS_EXPIRED, seg->len);
session_inc_stat(sess, type, STAT_TCP_SEGMENTS_EXPIRED, 1);
session_inc_stat(sess, type, STAT_TCP_PAYLOADS_EXPIRED, seg->len);
mgr->stat.tcp_segs_timeout++;
session_inc_stat(sess, dir, STAT_TCP_SEGMENTS_RELEASED, 1);
session_inc_stat(sess, dir, STAT_TCP_PAYLOADS_RELEASED, seg->len);
session_inc_stat(sess, type, STAT_TCP_SEGMENTS_RELEASED, 1);
session_inc_stat(sess, type, STAT_TCP_PAYLOADS_RELEASED, seg->len);
mgr->stat.tcp_segs_freed++;
tcp_segment_free(seg);
@@ -274,16 +274,16 @@ static void tcp_update(struct session_manager *mgr, struct session *sess, enum f
if (len)
{
session_inc_stat(sess, dir, STAT_TCP_SEGMENTS_RECEIVED, 1);
session_inc_stat(sess, dir, STAT_TCP_PAYLOADS_RECEIVED, len);
session_inc_stat(sess, type, STAT_TCP_SEGMENTS_RECEIVED, 1);
session_inc_stat(sess, type, STAT_TCP_PAYLOADS_RECEIVED, len);
mgr->stat.tcp_segs_input++;
uint32_t rcv_nxt = tcp_reassembly_get_recv_next(half->assembler);
// in order
if (half->seq == rcv_nxt)
{
session_inc_stat(sess, dir, STAT_TCP_SEGMENTS_INORDER, 1);
session_inc_stat(sess, dir, STAT_TCP_PAYLOADS_INORDER, len);
session_inc_stat(sess, type, STAT_TCP_SEGMENTS_INORDER, 1);
session_inc_stat(sess, type, STAT_TCP_PAYLOADS_INORDER, len);
mgr->stat.tcp_segs_inorder++;
half->in_order.data = tcp_layer->pld_ptr;
@@ -294,8 +294,8 @@ static void tcp_update(struct session_manager *mgr, struct session *sess, enum f
// retransmission
else if (uint32_before(uint32_add(half->seq, len), rcv_nxt))
{
session_inc_stat(sess, dir, STAT_TCP_SEGMENTS_RETRANSMIT, 1);
session_inc_stat(sess, dir, STAT_TCP_PAYLOADS_RETRANSMIT, len);
session_inc_stat(sess, type, STAT_TCP_SEGMENTS_RETRANSMIT, 1);
session_inc_stat(sess, type, STAT_TCP_PAYLOADS_RETRANSMIT, len);
mgr->stat.tcp_segs_retransmited++;
}
else if ((seg = tcp_segment_new(half->seq, tcp_layer->pld_ptr, len)))
@@ -303,29 +303,29 @@ static void tcp_update(struct session_manager *mgr, struct session *sess, enum f
switch (tcp_reassembly_push(half->assembler, seg, mgr->now_ms))
{
case -2:
session_inc_stat(sess, dir, STAT_TCP_SEGMENTS_RETRANSMIT, 1);
session_inc_stat(sess, dir, STAT_TCP_PAYLOADS_RETRANSMIT, len);
session_inc_stat(sess, type, STAT_TCP_SEGMENTS_RETRANSMIT, 1);
session_inc_stat(sess, type, STAT_TCP_PAYLOADS_RETRANSMIT, len);
mgr->stat.tcp_segs_retransmited++;
tcp_segment_free(seg);
break;
case -1:
session_inc_stat(sess, dir, STAT_TCP_SEGMENTS_NOSPACE, 1);
session_inc_stat(sess, dir, STAT_TCP_PAYLOADS_NOSPACE, len);
session_inc_stat(sess, type, STAT_TCP_SEGMENTS_NOSPACE, 1);
session_inc_stat(sess, type, STAT_TCP_PAYLOADS_NOSPACE, len);
mgr->stat.tcp_segs_omitted_too_many++;
tcp_segment_free(seg);
break;
case 0:
session_inc_stat(sess, dir, STAT_TCP_SEGMENTS_BUFFERED, 1);
session_inc_stat(sess, dir, STAT_TCP_PAYLOADS_BUFFERED, len);
session_inc_stat(sess, type, STAT_TCP_SEGMENTS_BUFFERED, 1);
session_inc_stat(sess, type, STAT_TCP_PAYLOADS_BUFFERED, len);
mgr->stat.tcp_segs_buffered++;
break;
case 1:
session_inc_stat(sess, dir, STAT_TCP_SEGMENTS_OVERLAP, 1);
session_inc_stat(sess, dir, STAT_TCP_PAYLOADS_OVERLAP, len);
session_inc_stat(sess, type, STAT_TCP_SEGMENTS_OVERLAP, 1);
session_inc_stat(sess, type, STAT_TCP_PAYLOADS_OVERLAP, len);
mgr->stat.tcp_segs_overlapped++;
session_inc_stat(sess, dir, STAT_TCP_SEGMENTS_BUFFERED, 1);
session_inc_stat(sess, dir, STAT_TCP_PAYLOADS_BUFFERED, len);
session_inc_stat(sess, type, STAT_TCP_SEGMENTS_BUFFERED, 1);
session_inc_stat(sess, type, STAT_TCP_PAYLOADS_BUFFERED, len);
mgr->stat.tcp_segs_buffered++;
break;
default:
@@ -335,8 +335,8 @@ static void tcp_update(struct session_manager *mgr, struct session *sess, enum f
}
else
{
session_inc_stat(sess, dir, STAT_TCP_SEGMENTS_NOSPACE, 1);
session_inc_stat(sess, dir, STAT_TCP_PAYLOADS_NOSPACE, len);
session_inc_stat(sess, type, STAT_TCP_SEGMENTS_NOSPACE, 1);
session_inc_stat(sess, type, STAT_TCP_PAYLOADS_NOSPACE, len);
mgr->stat.tcp_segs_omitted_too_many++;
}
}
@@ -346,33 +346,33 @@ static void tcp_update(struct session_manager *mgr, struct session *sess, enum f
* session direction identify
******************************************************************************/
static enum flow_direction identify_direction_by_port(uint16_t src_port, uint16_t dst_port)
static enum flow_type identify_flow_type_by_port(uint16_t src_port, uint16_t dst_port)
{
// big port is client
if (src_port > dst_port)
{
return FLOW_DIRECTION_C2S;
return FLOW_TYPE_C2S;
}
else if (src_port < dst_port)
{
return FLOW_DIRECTION_S2C;
return FLOW_TYPE_S2C;
}
else
{
// if port is equal, first packet is C2S
return FLOW_DIRECTION_C2S;
return FLOW_TYPE_C2S;
}
}
static enum flow_direction identify_direction_by_history(const struct session *sess, const struct tuple6 *key)
static enum flow_type identify_flow_type_by_history(const struct session *sess, const struct tuple6 *key)
{
if (tuple6_cmp(session_get_tuple6(sess), key) == 0)
{
return FLOW_DIRECTION_C2S;
return FLOW_TYPE_C2S;
}
else
{
return FLOW_DIRECTION_S2C;
return FLOW_TYPE_S2C;
}
}
@@ -420,13 +420,13 @@ static int duplicated_packet_bypass(struct session_manager *mgr, struct session
return 0;
}
enum flow_direction dir = identify_direction_by_history(sess, key);
if (session_get_stat(sess, dir, STAT_RAW_PACKETS_RECEIVED) < 3 || session_has_duplicate_traffic(sess))
enum flow_type type = identify_flow_type_by_history(sess, key);
if (session_get_stat(sess, type, STAT_RAW_PACKETS_RECEIVED) < 3 || session_has_duplicate_traffic(sess))
{
if (packet_filter_lookup(mgr->dup_pkt_filter, pkt, mgr->now_ms))
{
session_inc_stat(sess, dir, STAT_DUPLICATE_PACKETS_BYPASS, 1);
session_inc_stat(sess, dir, STAT_DUPLICATE_BYTES_BYPASS, packet_get_raw_len(pkt));
session_inc_stat(sess, type, STAT_DUPLICATE_PACKETS_BYPASS, 1);
session_inc_stat(sess, type, STAT_DUPLICATE_BYTES_BYPASS, packet_get_raw_len(pkt));
switch (session_get_type(sess))
{
case SESSION_TYPE_TCP:
@@ -442,7 +442,7 @@ static int duplicated_packet_bypass(struct session_manager *mgr, struct session
session_set_duplicate_traffic(sess);
session_set_current_packet(sess, pkt);
session_set_current_flow_direction(sess, dir);
session_set_flow_type(sess, type);
return 1;
}
else
@@ -459,14 +459,14 @@ static int duplicated_packet_bypass(struct session_manager *mgr, struct session
* session manager utils
******************************************************************************/
static void session_update(struct session_manager *mgr, struct session *sess, enum session_state next_state, const struct packet *pkt, const struct tuple6 *key, enum flow_direction dir)
static void session_update(struct session_manager *mgr, struct session *sess, enum session_state next_state, const struct packet *pkt, const struct tuple6 *key, enum flow_type type)
{
if (session_get_current_state(sess) == SESSION_STATE_INIT)
{
uint64_t sess_id = snowflake_generate(mgr->sf, mgr->now_ms / 1000);
session_set_id(sess, sess_id);
enum packet_direction pkt_dir = packet_get_direction(pkt);
if (dir == FLOW_DIRECTION_C2S)
if (type == FLOW_TYPE_C2S)
{
session_set_tuple6(sess, key);
if (pkt_dir == PACKET_DIRECTION_OUTGOING) // Internal -> External
@@ -510,18 +510,18 @@ static void session_update(struct session_manager *mgr, struct session *sess, en
}
}
session_inc_stat(sess, dir, STAT_RAW_PACKETS_RECEIVED, 1);
session_inc_stat(sess, dir, STAT_RAW_BYTES_RECEIVED, packet_get_raw_len(pkt));
session_inc_stat(sess, type, STAT_RAW_PACKETS_RECEIVED, 1);
session_inc_stat(sess, type, STAT_RAW_BYTES_RECEIVED, packet_get_raw_len(pkt));
if (!session_get_first_packet(sess, dir))
if (!session_get_first_packet(sess, type))
{
session_set_first_packet(sess, dir, packet_dup(pkt));
session_set_route_ctx(sess, dir, packet_get_route_ctx(pkt));
session_set_sids(sess, dir, packet_get_sids(pkt));
session_set_first_packet(sess, type, packet_dup(pkt));
session_set_route_ctx(sess, type, packet_get_route_ctx(pkt));
session_set_sids(sess, type, packet_get_sids(pkt));
}
session_set_current_packet(sess, pkt);
session_set_current_flow_direction(sess, dir);
session_set_flow_type(sess, type);
session_set_timestamp(sess, SESSION_TIMESTAMP_LAST, mgr->now_ms);
session_set_current_state(sess, next_state);
}
@@ -592,8 +592,8 @@ static struct session *session_manager_lookup_tcp_session(struct session_manager
return sess;
}
enum flow_direction dir = identify_direction_by_history(sess, key);
struct tcp_half *half = &sess->tcp_halfs[dir];
enum flow_type type = identify_flow_type_by_history(sess, key);
struct tcp_half *half = &sess->tcp_halfs[type];
if ((half->isn && half->isn != tcp_hdr_get_seq(hdr)) || // recv SYN with different ISN
((half->history & TH_FIN) || (half->history & TH_RST))) // recv SYN after FIN or RST
{
@@ -626,7 +626,7 @@ static struct session *session_manager_new_tcp_session(struct session_manager *m
session_manager_evicte_session(mgr, evic_sess, LRU_EVICT);
}
enum flow_direction dir = (flags & TH_ACK) ? FLOW_DIRECTION_S2C : FLOW_DIRECTION_C2S;
enum flow_type type = (flags & TH_ACK) ? FLOW_TYPE_S2C : FLOW_TYPE_C2S;
struct session *sess = session_pool_pop(mgr->sess_pool);
if (sess == NULL)
{
@@ -638,7 +638,7 @@ static struct session *session_manager_new_tcp_session(struct session_manager *m
sess->mgr_stat = &mgr->stat;
enum session_state next_state = session_transition_run(SESSION_STATE_INIT, TCP_SYN);
session_update(mgr, sess, next_state, pkt, key, dir);
session_update(mgr, sess, next_state, pkt, key, type);
session_transition_log(sess, SESSION_STATE_INIT, next_state, TCP_SYN);
if (tcp_init(mgr, sess) == -1)
@@ -647,7 +647,7 @@ static struct session *session_manager_new_tcp_session(struct session_manager *m
session_pool_push(mgr->sess_pool, sess);
return NULL;
}
tcp_update(mgr, sess, dir, tcp_layer);
tcp_update(mgr, sess, type, tcp_layer);
uint64_t timeout = (flags & TH_ACK) ? mgr->cfg.tcp_timeout_ms.handshake : mgr->cfg.tcp_timeout_ms.init;
session_timer_update(mgr->sess_timer, sess, mgr->now_ms + timeout);
@@ -684,9 +684,9 @@ static struct session *session_manager_new_udp_session(struct session_manager *m
sess->mgr = mgr;
sess->mgr_stat = &mgr->stat;
enum flow_direction dir = identify_direction_by_port(ntohs(key->src_port), ntohs(key->dst_port));
enum flow_type type = identify_flow_type_by_port(ntohs(key->src_port), ntohs(key->dst_port));
enum session_state next_state = session_transition_run(SESSION_STATE_INIT, UDP_DATA);
session_update(mgr, sess, next_state, pkt, key, dir);
session_update(mgr, sess, next_state, pkt, key, type);
session_transition_log(sess, SESSION_STATE_INIT, next_state, UDP_DATA);
session_timer_update(mgr->sess_timer, sess, mgr->now_ms + mgr->cfg.udp_timeout_ms.data);
@@ -703,7 +703,7 @@ static int session_manager_update_tcp_session(struct session_manager *mgr, struc
{
const struct layer_private *tcp_layer = packet_get_innermost_layer(pkt, LAYER_PROTO_TCP);
const struct tcphdr *hdr = (const struct tcphdr *)tcp_layer->hdr_ptr;
enum flow_direction dir = identify_direction_by_history(sess, key);
enum flow_type type = identify_flow_type_by_history(sess, key);
uint8_t flags = tcp_hdr_get_flags(hdr);
int inputs = 0;
inputs |= (flags & TH_SYN) ? TCP_SYN : NONE;
@@ -716,28 +716,28 @@ static int session_manager_update_tcp_session(struct session_manager *mgr, struc
enum session_state next_state = session_transition_run(curr_state, inputs);
// update session
session_update(mgr, sess, next_state, pkt, key, dir);
session_update(mgr, sess, next_state, pkt, key, type);
session_transition_log(sess, curr_state, next_state, inputs);
// update tcp
tcp_update(mgr, sess, dir, tcp_layer);
tcp_update(mgr, sess, type, tcp_layer);
// set closing reason
if (next_state == SESSION_STATE_CLOSING && !session_get_closing_reason(sess))
{
if (flags & TH_FIN)
{
session_set_closing_reason(sess, (dir == FLOW_DIRECTION_C2S ? CLOSING_BY_CLIENT_FIN : CLOSING_BY_SERVER_FIN));
session_set_closing_reason(sess, (type == FLOW_TYPE_C2S ? CLOSING_BY_CLIENT_FIN : CLOSING_BY_SERVER_FIN));
}
if (flags & TH_RST)
{
session_set_closing_reason(sess, (dir == FLOW_DIRECTION_C2S ? CLOSING_BY_CLIENT_RST : CLOSING_BY_SERVER_RST));
session_set_closing_reason(sess, (type == FLOW_TYPE_C2S ? CLOSING_BY_CLIENT_RST : CLOSING_BY_SERVER_RST));
}
}
// update timeout
struct tcp_half *curr = &sess->tcp_halfs[dir];
struct tcp_half *peer = &sess->tcp_halfs[(dir == FLOW_DIRECTION_C2S ? FLOW_DIRECTION_S2C : FLOW_DIRECTION_C2S)];
struct tcp_half *curr = &sess->tcp_halfs[type];
struct tcp_half *peer = &sess->tcp_halfs[(type == FLOW_TYPE_C2S ? FLOW_TYPE_S2C : FLOW_TYPE_C2S)];
uint64_t timeout = 0;
switch (next_state)
{
@@ -786,10 +786,10 @@ static int session_manager_update_tcp_session(struct session_manager *mgr, struc
static int session_manager_update_udp_session(struct session_manager *mgr, struct session *sess, const struct packet *pkt, const struct tuple6 *key)
{
enum flow_direction dir = identify_direction_by_history(sess, key);
enum flow_type type = identify_flow_type_by_history(sess, key);
enum session_state curr_state = session_get_current_state(sess);
enum session_state next_state = session_transition_run(curr_state, UDP_DATA);
session_update(mgr, sess, next_state, pkt, key, dir);
session_update(mgr, sess, next_state, pkt, key, type);
session_transition_log(sess, curr_state, next_state, UDP_DATA);
if (session_get_current_state(sess) == SESSION_STATE_DISCARD)
@@ -1100,17 +1100,17 @@ void session_manager_free_session(struct session_manager *mgr, struct session *s
break;
}
packet_free((struct packet *)session_get_first_packet(sess, FLOW_DIRECTION_C2S));
packet_free((struct packet *)session_get_first_packet(sess, FLOW_DIRECTION_S2C));
session_set_first_packet(sess, FLOW_DIRECTION_C2S, NULL);
session_set_first_packet(sess, FLOW_DIRECTION_S2C, NULL);
session_clear_route_ctx(sess, FLOW_DIRECTION_C2S);
session_clear_route_ctx(sess, FLOW_DIRECTION_S2C);
session_clear_sids(sess, FLOW_DIRECTION_C2S);
session_clear_sids(sess, FLOW_DIRECTION_S2C);
packet_free((struct packet *)session_get_first_packet(sess, FLOW_TYPE_C2S));
packet_free((struct packet *)session_get_first_packet(sess, FLOW_TYPE_S2C));
session_set_first_packet(sess, FLOW_TYPE_C2S, NULL);
session_set_first_packet(sess, FLOW_TYPE_S2C, NULL);
session_clear_route_ctx(sess, FLOW_TYPE_C2S);
session_clear_route_ctx(sess, FLOW_TYPE_S2C);
session_clear_sids(sess, FLOW_TYPE_C2S);
session_clear_sids(sess, FLOW_TYPE_S2C);
session_set_current_state(sess, SESSION_STATE_INIT);
session_set_current_packet(sess, NULL);
session_set_current_flow_direction(sess, FLOW_DIRECTION_NONE);
session_set_flow_type(sess, FLOW_TYPE_NONE);
session_pool_push(mgr->sess_pool, sess);
sess = NULL;
}

41
infra/session_manager/session_private.h
View File

@@ -47,9 +47,9 @@ struct tcp_half
struct session
{
uint64_t id;
uint64_t stats[MAX_FLOW_DIRECTION][MAX_STAT];
uint64_t stats[MAX_FLOW_TYPE][MAX_STAT];
uint64_t timestamps[MAX_TIMESTAMP]; // realtime msec
struct tcp_half tcp_halfs[MAX_FLOW_DIRECTION];
struct tcp_half tcp_halfs[MAX_FLOW_TYPE];
struct timeout timeout;
struct list_head lru;
struct list_head free;
@@ -59,18 +59,17 @@ struct session
UT_hash_handle hh3;
struct tuple6 tuple;
char tuple_str[TUPLE6_STR_SIZE];
struct sids sids[MAX_FLOW_DIRECTION];
struct route_ctx route_ctx[MAX_FLOW_DIRECTION];
const struct packet *first_pkt[MAX_FLOW_DIRECTION];
struct sids sids[MAX_FLOW_TYPE];
struct route_ctx route_ctx[MAX_FLOW_TYPE];
const struct packet *first_pkt[MAX_FLOW_TYPE];
const struct packet *curr_pkt;
void *ex_data[EX_DATA_MAX_COUNT];
void *user_data;
int is_symmetric;
int dup;
enum session_direction sess_dir;
enum flow_direction tuple_dir;
enum flow_direction flow_dir;
enum session_type type;
enum flow_type flow_type;
enum session_type sess_type;
enum session_state state;
enum closing_reason reason;
struct session_manager *mgr;
@@ -89,8 +88,8 @@ const struct tuple6 *session_get_tuple6(const struct session *sess);
void session_set_direction(struct session *sess, enum session_direction dir);
enum session_direction session_get_direction(const struct session *sess);
void session_set_current_flow_direction(struct session *sess, enum flow_direction dir);
// enum flow_direction session_get_current_flow_direction(const struct session *sess);
void session_set_flow_type(struct session *sess, enum flow_type type);
// enum flow_type session_get_flow_type(const struct session *sess);
void session_set_current_state(struct session *sess, enum session_state state);
// enum session_state session_get_current_state(const struct session *sess);
@@ -104,22 +103,22 @@ void session_set_duplicate_traffic(struct session *sess);
void session_set_closing_reason(struct session *sess, enum closing_reason reason);
// enum closing_reason session_get_closing_reason(const struct session *sess);
void session_inc_stat(struct session *sess, enum flow_direction dir, enum session_stat stat, uint64_t val);
// uint64_t session_get_stat(const struct session *sess, enum flow_direction dir, enum session_stat stat);
void session_inc_stat(struct session *sess, enum flow_type type, enum session_stat stat, uint64_t val);
// uint64_t session_get_stat(const struct session *sess, enum flow_type dir, enum session_stat stat);
void session_set_timestamp(struct session *sess, enum session_timestamp type, uint64_t value);
// uint64_t session_get_timestamp(const struct session *sess, enum session_timestamp type);
void session_clear_sids(struct session *sess, enum flow_direction dir);
void session_set_sids(struct session *sess, enum flow_direction dir, const struct sids *sids);
const struct sids *session_get_sids(const struct session *sess, enum flow_direction dir);
void session_clear_sids(struct session *sess, enum flow_type type);
void session_set_sids(struct session *sess, enum flow_type type, const struct sids *sids);
const struct sids *session_get_sids(const struct session *sess, enum flow_type type);
void session_clear_route_ctx(struct session *sess, enum flow_direction dir);
void session_set_route_ctx(struct session *sess, enum flow_direction dir, const struct route_ctx *ctx);
const struct route_ctx *session_get_route_ctx(const struct session *sess, enum flow_direction dir);
void session_clear_route_ctx(struct session *sess, enum flow_type type);
void session_set_route_ctx(struct session *sess, enum flow_type type, const struct route_ctx *ctx);
const struct route_ctx *session_get_route_ctx(const struct session *sess, enum flow_type type);
void session_set_first_packet(struct session *sess, enum flow_direction dir, const struct packet *pkt);
// const struct packet *session_get_first_packet(const struct session *sess, enum flow_direction dir);
void session_set_first_packet(struct session *sess, enum flow_type type, const struct packet *pkt);
// const struct packet *session_get_first_packet(const struct session *sess, enum flow_type type);
void session_set_current_packet(struct session *sess, const struct packet *pkt);
// const struct packet *session_get0_current_packet(const struct session *sess);
@@ -139,7 +138,7 @@ void session_free_tcp_segment(struct session *sess, struct tcp_segment *seg);
const char *closing_reason_to_str(enum closing_reason reason);
const char *session_state_to_str(enum session_state state);
const char *session_type_to_str(enum session_type type);
const char *flow_direction_to_str(enum flow_direction dir);
const char *flow_direction_to_str(enum flow_type type);
// bref : 1, output session bref info
// bref : 0, output session detail info

168
infra/session_manager/session_utils.c
View File

@@ -41,14 +41,14 @@ enum session_direction session_get_direction(const struct session *sess)
return sess->sess_dir;
}
void session_set_current_flow_direction(struct session *sess, enum flow_direction dir)
void session_set_flow_type(struct session *sess, enum flow_type type)
{
sess->flow_dir = dir;
sess->flow_type = type;
}
enum flow_direction session_get_current_flow_direction(const struct session *sess)
enum flow_type session_get_flow_type(const struct session *sess)
{
return sess->flow_dir;
return sess->flow_type;
}
void session_set_current_state(struct session *sess, enum session_state state)
@@ -63,12 +63,12 @@ enum session_state session_get_current_state(const struct session *sess)
void session_set_type(struct session *sess, enum session_type type)
{
sess->type = type;
sess->sess_type = type;
}
enum session_type session_get_type(const struct session *sess)
{
return sess->type;
return sess->sess_type;
}
void session_set_duplicate_traffic(struct session *sess)
@@ -91,14 +91,14 @@ enum closing_reason session_get_closing_reason(const struct session *sess)
return sess->reason;
}
void session_inc_stat(struct session *sess, enum flow_direction dir, enum session_stat stat, uint64_t val)
void session_inc_stat(struct session *sess, enum flow_type type, enum session_stat stat, uint64_t val)
{
sess->stats[dir][stat] += val;
sess->stats[type][stat] += val;
}
uint64_t session_get_stat(const struct session *sess, enum flow_direction dir, enum session_stat stat)
uint64_t session_get_stat(const struct session *sess, enum flow_type type, enum session_stat stat)
{
return sess->stats[dir][stat];
return sess->stats[type][stat];
}
void session_set_timestamp(struct session *sess, enum session_timestamp type, uint64_t value)
@@ -111,44 +111,44 @@ uint64_t session_get_timestamp(const struct session *sess, enum session_timestam
return sess->timestamps[type];
}
void session_clear_sids(struct session *sess, enum flow_direction dir)
void session_clear_sids(struct session *sess, enum flow_type type)
{
memset(&sess->sids[dir], 0, sizeof(struct sids));
memset(&sess->sids[type], 0, sizeof(struct sids));
}
void session_set_sids(struct session *sess, enum flow_direction dir, const struct sids *sids)
void session_set_sids(struct session *sess, enum flow_type type, const struct sids *sids)
{
sess->sids[dir] = *sids;
sess->sids[type] = *sids;
}
const struct sids *session_get_sids(const struct session *sess, enum flow_direction dir)
const struct sids *session_get_sids(const struct session *sess, enum flow_type type)
{
return &sess->sids[dir];
return &sess->sids[type];
}
void session_clear_route_ctx(struct session *sess, enum flow_direction dir)
void session_clear_route_ctx(struct session *sess, enum flow_type type)
{
memset(&sess->route_ctx[dir], 0, sizeof(struct route_ctx));
memset(&sess->route_ctx[type], 0, sizeof(struct route_ctx));
}
void session_set_route_ctx(struct session *sess, enum flow_direction dir, const struct route_ctx *ctx)
void session_set_route_ctx(struct session *sess, enum flow_type type, const struct route_ctx *ctx)
{
sess->route_ctx[dir] = *ctx;
sess->route_ctx[type] = *ctx;
}
const struct route_ctx *session_get_route_ctx(const struct session *sess, enum flow_direction dir)
const struct route_ctx *session_get_route_ctx(const struct session *sess, enum flow_type type)
{
return &sess->route_ctx[dir];
return &sess->route_ctx[type];
}
void session_set_first_packet(struct session *sess, enum flow_direction dir, const struct packet *pkt)
void session_set_first_packet(struct session *sess, enum flow_type type, const struct packet *pkt)
{
sess->first_pkt[dir] = pkt;
sess->first_pkt[type] = pkt;
}
const struct packet *session_get_first_packet(const struct session *sess, enum flow_direction dir)
const struct packet *session_get_first_packet(const struct session *sess, enum flow_type type)
{
return sess->first_pkt[dir];
return sess->first_pkt[type];
}
void session_set_current_packet(struct session *sess, const struct packet *pkt)
@@ -164,7 +164,7 @@ const struct packet *session_get0_current_packet(const struct session *sess)
int session_is_symmetric(const struct session *sess, unsigned char *flag)
{
int is_symmetric = 0;
if (sess->first_pkt[FLOW_DIRECTION_C2S] && sess->first_pkt[FLOW_DIRECTION_S2C])
if (sess->first_pkt[FLOW_TYPE_C2S] && sess->first_pkt[FLOW_TYPE_S2C])
{
if (flag)
{
@@ -172,14 +172,14 @@ int session_is_symmetric(const struct session *sess, unsigned char *flag)
}
is_symmetric = 1;
}
else if (sess->first_pkt[FLOW_DIRECTION_C2S])
else if (sess->first_pkt[FLOW_TYPE_C2S])
{
if (flag)
{
*flag = SESSION_SEEN_C2S_FLOW;
}
}
else if (sess->first_pkt[FLOW_DIRECTION_S2C])
else if (sess->first_pkt[FLOW_TYPE_S2C])
{
if (flag)
{
@@ -201,8 +201,8 @@ void *session_get_user_data(const struct session *sess)
struct tcp_segment *session_get_tcp_segment(struct session *sess)
{
enum flow_direction dir = session_get_current_flow_direction(sess);
struct tcp_half *half = &sess->tcp_halfs[dir];
enum flow_type type = session_get_flow_type(sess);
struct tcp_half *half = &sess->tcp_halfs[type];
if (half->in_order.data != NULL && half->in_order.len > 0 && half->in_order_ref == 0)
{
@@ -215,8 +215,8 @@ struct tcp_segment *session_get_tcp_segment(struct session *sess)
struct tcp_segment *seg = tcp_reassembly_pop(half->assembler);
if (seg)
{
session_inc_stat(sess, dir, STAT_TCP_SEGMENTS_REORDERED, 1);
session_inc_stat(sess, dir, STAT_TCP_PAYLOADS_REORDERED, seg->len);
session_inc_stat(sess, type, STAT_TCP_SEGMENTS_REORDERED, 1);
session_inc_stat(sess, type, STAT_TCP_PAYLOADS_REORDERED, seg->len);
// TODO
sess->mgr_stat->tcp_segs_consumed++;
@@ -233,8 +233,8 @@ void session_free_tcp_segment(struct session *sess, struct tcp_segment *seg)
return;
}
enum flow_direction dir = session_get_current_flow_direction(sess);
struct tcp_half *half = &sess->tcp_halfs[dir];
enum flow_type type = session_get_flow_type(sess);
struct tcp_half *half = &sess->tcp_halfs[type];
if (seg == &half->in_order)
{
@@ -244,8 +244,8 @@ void session_free_tcp_segment(struct session *sess, struct tcp_segment *seg)
}
else
{
session_inc_stat(sess, dir, STAT_TCP_SEGMENTS_RELEASED, 1);
session_inc_stat(sess, dir, STAT_TCP_PAYLOADS_RELEASED, seg->len);
session_inc_stat(sess, type, STAT_TCP_SEGMENTS_RELEASED, 1);
session_inc_stat(sess, type, STAT_TCP_PAYLOADS_RELEASED, seg->len);
sess->mgr_stat->tcp_segs_freed++;
tcp_segment_free(seg);
@@ -309,13 +309,13 @@ const char *session_type_to_str(enum session_type type)
}
}
const char *flow_direction_to_str(enum flow_direction dir)
const char *flow_direction_to_str(enum flow_type type)
{
switch (dir)
switch (type)
{
case FLOW_DIRECTION_C2S:
case FLOW_TYPE_C2S:
return "C2S";
case FLOW_DIRECTION_S2C:
case FLOW_TYPE_S2C:
return "S2C";
default:
return "unknown";
@@ -357,9 +357,9 @@ int session_to_str(const struct session *sess, int bref, char *buff, int size)
session_get0_readable_addr(sess),
session_type_to_str(session_get_type(sess)),
session_state_to_str(session_get_current_state(sess)),
flow_direction_to_str(session_get_current_flow_direction(sess)),
session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED),
session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED));
flow_direction_to_str(session_get_flow_type(sess)),
session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED),
session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED));
}
else
{
@@ -375,75 +375,75 @@ int session_to_str(const struct session *sess, int bref, char *buff, int size)
used += snprintf(buff + used, size - used, "\"current_packet\":\"%p\",", session_get0_current_packet(sess));
const char *str[] = {"c2s", "s2c"};
enum flow_direction dir[] = {FLOW_DIRECTION_C2S, FLOW_DIRECTION_S2C};
enum flow_type type[] = {FLOW_TYPE_C2S, FLOW_TYPE_S2C};
for (int i = 0; i < 2; i++)
{
// raw packets
used += snprintf(buff + used, size - used, "\"%s_raw_packets_received\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_RAW_PACKETS_RECEIVED));
used += snprintf(buff + used, size - used, "\"%s_raw_bytes_received\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_RAW_BYTES_RECEIVED));
used += snprintf(buff + used, size - used, "\"%s_raw_packets_received\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_RAW_PACKETS_RECEIVED));
used += snprintf(buff + used, size - used, "\"%s_raw_bytes_received\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_RAW_BYTES_RECEIVED));
used += snprintf(buff + used, size - used, "\"%s_raw_packets_transmitted\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_RAW_PACKETS_TRANSMITTED));
used += snprintf(buff + used, size - used, "\"%s_raw_bytes_transmitted\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_RAW_BYTES_TRANSMITTED));
used += snprintf(buff + used, size - used, "\"%s_raw_packets_transmitted\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_RAW_PACKETS_TRANSMITTED));
used += snprintf(buff + used, size - used, "\"%s_raw_bytes_transmitted\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_RAW_BYTES_TRANSMITTED));
used += snprintf(buff + used, size - used, "\"%s_raw_packets_dropped\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_RAW_PACKETS_DROPPED));
used += snprintf(buff + used, size - used, "\"%s_raw_bytes_dropped\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_RAW_BYTES_DROPPED));
used += snprintf(buff + used, size - used, "\"%s_raw_packets_dropped\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_RAW_PACKETS_DROPPED));
used += snprintf(buff + used, size - used, "\"%s_raw_bytes_dropped\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_RAW_BYTES_DROPPED));
// duplicate packets
used += snprintf(buff + used, size - used, "\"%s_duplicate_packets_bypass\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_DUPLICATE_PACKETS_BYPASS));
used += snprintf(buff + used, size - used, "\"%s_duplicate_bytes_bypass\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_DUPLICATE_BYTES_BYPASS));
used += snprintf(buff + used, size - used, "\"%s_duplicate_packets_bypass\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_DUPLICATE_PACKETS_BYPASS));
used += snprintf(buff + used, size - used, "\"%s_duplicate_bytes_bypass\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_DUPLICATE_BYTES_BYPASS));
// injected packets
used += snprintf(buff + used, size - used, "\"%s_injected_packets_failed\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_INJECTED_PACKETS_FAILED));
used += snprintf(buff + used, size - used, "\"%s_injected_packets_success\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_INJECTED_PACKETS_SUCCESS));
used += snprintf(buff + used, size - used, "\"%s_injected_bytes_success\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_INJECTED_BYTES_SUCCESS));
used += snprintf(buff + used, size - used, "\"%s_injected_packets_failed\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_INJECTED_PACKETS_FAILED));
used += snprintf(buff + used, size - used, "\"%s_injected_packets_success\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_INJECTED_PACKETS_SUCCESS));
used += snprintf(buff + used, size - used, "\"%s_injected_bytes_success\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_INJECTED_BYTES_SUCCESS));
// control packets
used += snprintf(buff + used, size - used, "\"%s_control_packets_received\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_CONTROL_PACKETS_RECEIVED));
used += snprintf(buff + used, size - used, "\"%s_control_bytes_received\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_CONTROL_BYTES_RECEIVED));
used += snprintf(buff + used, size - used, "\"%s_control_packets_received\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_CONTROL_PACKETS_RECEIVED));
used += snprintf(buff + used, size - used, "\"%s_control_bytes_received\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_CONTROL_BYTES_RECEIVED));
used += snprintf(buff + used, size - used, "\"%s_control_packets_transmitted\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_CONTROL_PACKETS_TRANSMITTED));
used += snprintf(buff + used, size - used, "\"%s_control_bytes_transmitted\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_CONTROL_BYTES_TRANSMITTED));
used += snprintf(buff + used, size - used, "\"%s_control_packets_transmitted\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_CONTROL_PACKETS_TRANSMITTED));
used += snprintf(buff + used, size - used, "\"%s_control_bytes_transmitted\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_CONTROL_BYTES_TRANSMITTED));
used += snprintf(buff + used, size - used, "\"%s_control_packets_dropped\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_CONTROL_PACKETS_DROPPED));
used += snprintf(buff + used, size - used, "\"%s_control_bytes_dropped\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_CONTROL_BYTES_DROPPED));
used += snprintf(buff + used, size - used, "\"%s_control_packets_dropped\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_CONTROL_PACKETS_DROPPED));
used += snprintf(buff + used, size - used, "\"%s_control_bytes_dropped\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_CONTROL_BYTES_DROPPED));
if (session_get_type(sess) == SESSION_TYPE_TCP)
{
used += snprintf(buff + used, size - used, "\"%s_tcp_last_seq\":%u,", str[i], sess->tcp_halfs[dir[i]].seq);
used += snprintf(buff + used, size - used, "\"%s_tcp_last_ack\":%u,", str[i], sess->tcp_halfs[dir[i]].ack);
used += snprintf(buff + used, size - used, "\"%s_tcp_last_seq\":%u,", str[i], sess->tcp_halfs[type[i]].seq);
used += snprintf(buff + used, size - used, "\"%s_tcp_last_ack\":%u,", str[i], sess->tcp_halfs[type[i]].ack);
memset(flags, 0, sizeof(flags));
tcp_flags_to_str(sess->tcp_halfs[dir[i]].flags, flags, sizeof(flags));
tcp_flags_to_str(sess->tcp_halfs[type[i]].flags, flags, sizeof(flags));
used += snprintf(buff + used, size - used, "\"%s_tcp_flags\":\"%s\",", str[i], flags);
used += snprintf(buff + used, size - used, "\"%s_tcp_segments_received\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_TCP_SEGMENTS_RECEIVED));
used += snprintf(buff + used, size - used, "\"%s_tcp_payloads_received\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_TCP_PAYLOADS_RECEIVED));
used += snprintf(buff + used, size - used, "\"%s_tcp_segments_received\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_TCP_SEGMENTS_RECEIVED));
used += snprintf(buff + used, size - used, "\"%s_tcp_payloads_received\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_TCP_PAYLOADS_RECEIVED));
used += snprintf(buff + used, size - used, "\"%s_tcp_segments_expired\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_TCP_SEGMENTS_EXPIRED));
used += snprintf(buff + used, size - used, "\"%s_tcp_payloads_expired\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_TCP_PAYLOADS_EXPIRED));
used += snprintf(buff + used, size - used, "\"%s_tcp_segments_expired\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_TCP_SEGMENTS_EXPIRED));
used += snprintf(buff + used, size - used, "\"%s_tcp_payloads_expired\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_TCP_PAYLOADS_EXPIRED));
used += snprintf(buff + used, size - used, "\"%s_tcp_segments_retransmit\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_TCP_SEGMENTS_RETRANSMIT));
used += snprintf(buff + used, size - used, "\"%s_tcp_payloads_retransmit\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_TCP_PAYLOADS_RETRANSMIT));
used += snprintf(buff + used, size - used, "\"%s_tcp_segments_retransmit\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_TCP_SEGMENTS_RETRANSMIT));
used += snprintf(buff + used, size - used, "\"%s_tcp_payloads_retransmit\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_TCP_PAYLOADS_RETRANSMIT));
used += snprintf(buff + used, size - used, "\"%s_tcp_segments_overlap\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_TCP_SEGMENTS_OVERLAP));
used += snprintf(buff + used, size - used, "\"%s_tcp_payloads_overlap\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_TCP_PAYLOADS_OVERLAP));
used += snprintf(buff + used, size - used, "\"%s_tcp_segments_overlap\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_TCP_SEGMENTS_OVERLAP));
used += snprintf(buff + used, size - used, "\"%s_tcp_payloads_overlap\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_TCP_PAYLOADS_OVERLAP));
used += snprintf(buff + used, size - used, "\"%s_tcp_segments_nospace\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_TCP_SEGMENTS_NOSPACE));
used += snprintf(buff + used, size - used, "\"%s_tcp_payloads_nospace\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_TCP_PAYLOADS_NOSPACE));
used += snprintf(buff + used, size - used, "\"%s_tcp_segments_nospace\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_TCP_SEGMENTS_NOSPACE));
used += snprintf(buff + used, size - used, "\"%s_tcp_payloads_nospace\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_TCP_PAYLOADS_NOSPACE));
used += snprintf(buff + used, size - used, "\"%s_tcp_segments_inorder\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_TCP_SEGMENTS_INORDER));
used += snprintf(buff + used, size - used, "\"%s_tcp_payloads_inorder\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_TCP_PAYLOADS_INORDER));
used += snprintf(buff + used, size - used, "\"%s_tcp_segments_inorder\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_TCP_SEGMENTS_INORDER));
used += snprintf(buff + used, size - used, "\"%s_tcp_payloads_inorder\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_TCP_PAYLOADS_INORDER));
used += snprintf(buff + used, size - used, "\"%s_tcp_segments_reordered\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_TCP_SEGMENTS_REORDERED));
used += snprintf(buff + used, size - used, "\"%s_tcp_payloads_reordered\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_TCP_PAYLOADS_REORDERED));
used += snprintf(buff + used, size - used, "\"%s_tcp_segments_reordered\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_TCP_SEGMENTS_REORDERED));
used += snprintf(buff + used, size - used, "\"%s_tcp_payloads_reordered\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_TCP_PAYLOADS_REORDERED));
used += snprintf(buff + used, size - used, "\"%s_tcp_segments_buffered\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_TCP_SEGMENTS_BUFFERED));
used += snprintf(buff + used, size - used, "\"%s_tcp_payloads_buffered\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_TCP_PAYLOADS_BUFFERED));
used += snprintf(buff + used, size - used, "\"%s_tcp_segments_buffered\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_TCP_SEGMENTS_BUFFERED));
used += snprintf(buff + used, size - used, "\"%s_tcp_payloads_buffered\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_TCP_PAYLOADS_BUFFERED));
used += snprintf(buff + used, size - used, "\"%s_tcp_segments_released\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_TCP_SEGMENTS_RELEASED));
used += snprintf(buff + used, size - used, "\"%s_tcp_payloads_released\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_TCP_PAYLOADS_RELEASED));
used += snprintf(buff + used, size - used, "\"%s_tcp_segments_released\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_TCP_SEGMENTS_RELEASED));
used += snprintf(buff + used, size - used, "\"%s_tcp_payloads_released\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_TCP_PAYLOADS_RELEASED));
}
used += snprintf(buff + used, size - used, "\"%s_first_packet\":\"%p\"", str[i], session_get_first_packet(sess, dir[i]));
used += snprintf(buff + used, size - used, "\"%s_first_packet\":\"%p\"", str[i], session_get_first_packet(sess, type[i]));
if (i == 0)
{
used += snprintf(buff + used, size - used, ",");

86
infra/session_manager/test/gtest_case_tcp_fast_open.cpp
View File

@@ -288,55 +288,55 @@ TEST(CASE, TCP_FAST_OPEN)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 280);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 280);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 0);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_C2S);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) == NULL);
EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_C2S);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) == NULL);
// TCP Segment
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_TCP_SEGMENTS_RECEIVED) == 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_TCP_PAYLOADS_RECEIVED) == 166);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_TCP_SEGMENTS_EXPIRED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_TCP_PAYLOADS_EXPIRED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_TCP_SEGMENTS_RETRANSMIT) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_TCP_PAYLOADS_RETRANSMIT) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_TCP_SEGMENTS_OVERLAP) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_TCP_PAYLOADS_OVERLAP) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_TCP_SEGMENTS_NOSPACE) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_TCP_PAYLOADS_NOSPACE) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_TCP_SEGMENTS_INORDER) == 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_TCP_PAYLOADS_INORDER) == 166);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_TCP_SEGMENTS_REORDERED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_TCP_PAYLOADS_REORDERED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_TCP_SEGMENTS_BUFFERED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_TCP_PAYLOADS_BUFFERED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_TCP_SEGMENTS_RELEASED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_TCP_PAYLOADS_RELEASED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_TCP_SEGMENTS_RECEIVED) == 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_TCP_PAYLOADS_RECEIVED) == 166);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_TCP_SEGMENTS_EXPIRED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_TCP_PAYLOADS_EXPIRED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_TCP_SEGMENTS_RETRANSMIT) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_TCP_PAYLOADS_RETRANSMIT) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_TCP_SEGMENTS_OVERLAP) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_TCP_PAYLOADS_OVERLAP) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_TCP_SEGMENTS_NOSPACE) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_TCP_PAYLOADS_NOSPACE) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_TCP_SEGMENTS_INORDER) == 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_TCP_PAYLOADS_INORDER) == 166);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_TCP_SEGMENTS_REORDERED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_TCP_PAYLOADS_REORDERED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_TCP_SEGMENTS_BUFFERED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_TCP_PAYLOADS_BUFFERED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_TCP_SEGMENTS_RELEASED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_TCP_PAYLOADS_RELEASED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_TCP_SEGMENTS_RECEIVED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_TCP_PAYLOADS_RECEIVED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_TCP_SEGMENTS_EXPIRED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_TCP_PAYLOADS_EXPIRED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_TCP_SEGMENTS_RETRANSMIT) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_TCP_PAYLOADS_RETRANSMIT) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_TCP_SEGMENTS_OVERLAP) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_TCP_PAYLOADS_OVERLAP) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_TCP_SEGMENTS_NOSPACE) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_TCP_PAYLOADS_NOSPACE) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_TCP_SEGMENTS_INORDER) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_TCP_PAYLOADS_INORDER) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_TCP_SEGMENTS_REORDERED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_TCP_PAYLOADS_REORDERED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_TCP_SEGMENTS_BUFFERED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_TCP_PAYLOADS_BUFFERED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_TCP_SEGMENTS_RELEASED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_TCP_PAYLOADS_RELEASED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_TCP_SEGMENTS_RECEIVED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_TCP_PAYLOADS_RECEIVED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_TCP_SEGMENTS_EXPIRED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_TCP_PAYLOADS_EXPIRED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_TCP_SEGMENTS_RETRANSMIT) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_TCP_PAYLOADS_RETRANSMIT) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_TCP_SEGMENTS_OVERLAP) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_TCP_PAYLOADS_OVERLAP) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_TCP_SEGMENTS_NOSPACE) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_TCP_PAYLOADS_NOSPACE) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_TCP_SEGMENTS_INORDER) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_TCP_PAYLOADS_INORDER) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_TCP_SEGMENTS_REORDERED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_TCP_PAYLOADS_REORDERED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_TCP_SEGMENTS_BUFFERED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_TCP_PAYLOADS_BUFFERED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_TCP_SEGMENTS_RELEASED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_TCP_PAYLOADS_RELEASED) == 0);
session_print(sess);

70
infra/session_manager/test/gtest_state_tcp_active_to_closing.cpp
View File

@@ -87,16 +87,16 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_FIN_FIN)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 145 + 66);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 66);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1 + 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 145 + 66);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 66);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1 + 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_S2C);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL);
EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_S2C);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
session_print(sess);
// check stat
@@ -172,16 +172,16 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_RST)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_RST);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 145 + 66);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1 + 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 145 + 66);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1 + 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 0);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_C2S);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) == NULL);
EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_C2S);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) == NULL);
session_print(sess);
// check stat
@@ -257,16 +257,16 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_RST)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_RST);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 145);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 66);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 145);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 66);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_S2C);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL);
EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_S2C);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
session_print(sess);
// check stat
@@ -383,16 +383,16 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_HALF_CLOSED_TIMEOUT)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 145 + 66);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1 + 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 145 + 66);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1 + 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 0);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_C2S);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) == NULL);
EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_C2S);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) == NULL);
session_print(sess);
// check stat
@@ -462,16 +462,16 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_HALF_CLOSED_TIMEOUT)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_FIN);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 145);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 66);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 145);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 66);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_S2C);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL);
EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_S2C);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
session_print(sess);
// check stat

112
infra/session_manager/test/gtest_state_tcp_init_to_opening.cpp
View File

@@ -43,16 +43,16 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 78);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 78);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 0);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_C2S);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) == NULL);
EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_C2S);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) == NULL);
session_print(sess);
// check stat
@@ -120,16 +120,16 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 74);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 74);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_S2C);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) == NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL);
EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_S2C);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) == NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
session_print(sess);
// check stat
@@ -209,16 +209,16 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 78);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 74);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 78);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 74);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_S2C);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL);
EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_S2C);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
session_print(sess);
// check stat
@@ -310,16 +310,16 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK_ACK)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 66);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 74);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 66);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 74);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_C2S);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL);
EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_C2S);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
session_print(sess);
// check stat
@@ -406,16 +406,16 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_RETRANSMISSION)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 78);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 78);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 0);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_C2S);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) == NULL);
EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_C2S);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) == NULL);
session_print(sess);
// check stat
@@ -503,16 +503,16 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK_RETRANSMISSION)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 74 + 74);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 1 + 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 74 + 74);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 1 + 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_S2C);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) == NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL);
EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_S2C);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) == NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
session_print(sess);
// check stat
@@ -592,16 +592,16 @@ TEST(TCP_INIT_TO_OPENING, BY_C2S_ASMMETRIC)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 66);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 66);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 0);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_C2S);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) == NULL);
EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_C2S);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) == NULL);
session_print(sess);
// check stat
@@ -681,16 +681,16 @@ TEST(TCP_INIT_TO_OPENING, BY_S2C_ASMMETRIC)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 74 + 66);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 1 + 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 74 + 66);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 1 + 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_S2C);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) == NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL);
EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_S2C);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) == NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
session_print(sess);
// check stat

154
infra/session_manager/test/gtest_state_tcp_init_to_opening_to_active_to_closing_to_closed.cpp
View File

@@ -40,16 +40,16 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 78);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 78);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 0);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_C2S);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) == NULL);
EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_C2S);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) == NULL);
// S2C SYNACK Packet
printf("\n=> Packet Parse: TCP S2C SYNACK packet\n");
@@ -71,16 +71,16 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 78);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 74);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 78);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 74);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_S2C);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL);
EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_S2C);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
// C2S ACK Packet
printf("\n=> Packet Parse: TCP C2S ACK packet\n");
@@ -102,16 +102,16 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 66);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 74);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 66);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 74);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_C2S);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL);
EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_C2S);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
// C2S REQ Packet
printf("\n=> Packet Parse: TCP C2S REQ packet\n");
@@ -133,16 +133,16 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 66 + 145);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 74);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1 + 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 66 + 145);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 74);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1 + 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_C2S);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL);
EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_C2S);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
// S2C ACK Packet
printf("\n=> Packet Parse: TCP S2C ACK packet\n");
@@ -164,16 +164,16 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 66 + 145);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 74 + 66);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1 + 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 1 + 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 66 + 145);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 74 + 66);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1 + 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 1 + 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_S2C);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL);
EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_S2C);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
// S2C HTTP Resp Packet1
printf("\n=> Packet Parse: TCP S2C Resp packet1\n");
@@ -195,16 +195,16 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 66 + 145);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 74 + 66 + 1354);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1 + 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 1 + 1 + 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 66 + 145);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 74 + 66 + 1354);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1 + 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 1 + 1 + 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_S2C);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL);
EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_S2C);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
// S2C HTTP Resp Packet2
printf("\n=> Packet Parse: TCP S2C Resp packet2\n");
@@ -226,16 +226,16 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 66 + 145);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 74 + 66 + 1354 + 385);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1 + 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 1 + 1 + 1 + 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 66 + 145);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 74 + 66 + 1354 + 385);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1 + 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 1 + 1 + 1 + 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_S2C);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL);
EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_S2C);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
// C2S ACK Packet
printf("\n=> Packet Parse: TCP C2S ACK packet\n");
@@ -257,16 +257,16 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 66 + 145 + 66);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 74 + 66 + 1354 + 385);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1 + 1 + 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 1 + 1 + 1 + 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 66 + 145 + 66);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 74 + 66 + 1354 + 385);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1 + 1 + 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 1 + 1 + 1 + 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_C2S);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL);
EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_C2S);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
// C2S FIN Packet
printf("\n=> Packet Parse: TCP C2S FIN packet\n");
@@ -288,16 +288,16 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 66 + 145 + 66 + 66);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 74 + 66 + 1354 + 385);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1 + 1 + 1 + 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 1 + 1 + 1 + 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 66 + 145 + 66 + 66);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 74 + 66 + 1354 + 385);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1 + 1 + 1 + 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 1 + 1 + 1 + 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_C2S);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL);
EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_C2S);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
// S2C FIN Packet
printf("\n=> Packet Parse: TCP S2C FIN packet\n");
@@ -319,16 +319,16 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 66 + 145 + 66 + 66);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 74 + 66 + 1354 + 385 + 66);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1 + 1 + 1 + 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 1 + 1 + 1 + 1 + 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 66 + 145 + 66 + 66);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 74 + 66 + 1354 + 385 + 66);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1 + 1 + 1 + 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 1 + 1 + 1 + 1 + 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_S2C);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL);
EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_S2C);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
// C2S ACK Packet
printf("\n=> Packet Parse: TCP C2S ACK packet\n");
@@ -350,16 +350,16 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 66 + 145 + 66 + 66 + 66);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 74 + 66 + 1354 + 385 + 66);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1 + 1 + 1 + 1 + 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 1 + 1 + 1 + 1 + 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 66 + 145 + 66 + 66 + 66);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 74 + 66 + 1354 + 385 + 66);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1 + 1 + 1 + 1 + 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 1 + 1 + 1 + 1 + 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_C2S);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL);
EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_C2S);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
// check stat
stat = session_manager_stat(mgr);

28
infra/session_manager/test/gtest_state_tcp_opening_to_active.cpp
View File

@@ -55,16 +55,16 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYN_C2S_DATA)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 145);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 145);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 0);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_C2S);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) == NULL);
EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_C2S);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) == NULL);
session_print(sess);
// check stat
@@ -144,16 +144,16 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYNACK_S2C_DATA)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 74 + 1354);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 1 + 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 74 + 1354);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 1 + 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_S2C);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) == NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL);
EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_S2C);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) == NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
session_print(sess);
// check stat

98
infra/session_manager/test/gtest_state_tcp_opening_to_closing.cpp
View File

@@ -67,16 +67,16 @@ TEST(TCP_OPENING_TO_CLOSING, BY_FIN_FIN)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 66);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 66);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 66);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 66);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_S2C);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL);
EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_S2C);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
session_print(sess);
// check stat
@@ -161,16 +161,16 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_RST)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_RST);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 66);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 66);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 0);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_C2S);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) == NULL);
EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_C2S);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) == NULL);
session_print(sess);
// check stat
@@ -255,16 +255,16 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_RST)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_RST);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 78);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 66);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 78);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 66);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_S2C);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL);
EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_S2C);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
session_print(sess);
// check stat
@@ -400,16 +400,16 @@ TEST(TCP_OPENING_TO_CLOSING, BY_HANDSHAKE_TIMEOUT)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 78);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 74);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 78);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 74);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_S2C);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL);
EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_S2C);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
session_print(sess);
// check stat
@@ -501,16 +501,16 @@ TEST(TCP_OPENING_TO_CLOSING, BY_DATA_TIMEOUT)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 66);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 74);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 66);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 74);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_C2S);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL);
EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_C2S);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
session_print(sess);
// check stat
@@ -590,16 +590,16 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_HALF_FIN)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 66);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 66);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 0);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_C2S);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) == NULL);
EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_C2S);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) == NULL);
session_print(sess);
// check stat
@@ -678,16 +678,16 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_HALF_FIN)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_FIN);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 78);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 66);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 78);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 66);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_S2C);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL);
EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_S2C);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
session_print(sess);
// check stat

28
infra/session_manager/test/gtest_state_udp_init_to_opening_to_active_to_closing.cpp
View File

@@ -39,16 +39,16 @@ TEST(UDP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING, TEST)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_UDP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 74);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 74);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 0);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_C2S);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) == NULL);
EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_C2S);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) == NULL);
// S2C RESP Packet
printf("\n=> Packet Parse: UDP S2C RESP packet\n");
@@ -69,16 +69,16 @@ TEST(UDP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING, TEST)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_UDP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 74);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 550);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 74);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 550);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_S2C);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL);
EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_S2C);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
session_print(sess);
// check stat

28
infra/session_manager/test/gtest_state_udp_init_to_opening_to_closing.cpp
View File

@@ -44,16 +44,16 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_C2S)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_UDP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 74);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 74);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 0);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_C2S);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) == NULL);
EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_C2S);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) == NULL);
session_print(sess);
// check stat
@@ -122,16 +122,16 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_S2C)
EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_UDP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 550);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 550);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_S2C);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) == NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL);
EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_S2C);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) == NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
session_print(sess);
// check stat

18
infra/stellar_core.c
View File

@@ -79,21 +79,21 @@ uint64_t stellar_generate_session_id(uint64_t now_sec);
* Stellar Thread Main Loop
******************************************************************************/
static void update_session_stat(struct session *sess, struct packet *pkt)
static void update_stat(struct session *sess, struct packet *pkt)
{
enum flow_direction dir = session_get_current_flow_direction(sess);
assert(dir != FLOW_DIRECTION_NONE);
enum flow_type type = session_get_flow_type(sess);
assert(type != FLOW_TYPE_NONE);
int is_ctrl = packet_is_ctrl(pkt);
uint16_t len = packet_get_raw_len(pkt);
switch (packet_get_action(pkt))
{
case PACKET_ACTION_DROP:
session_inc_stat(sess, dir, (is_ctrl ? STAT_CONTROL_PACKETS_DROPPED : STAT_RAW_PACKETS_DROPPED), 1);
session_inc_stat(sess, dir, (is_ctrl ? STAT_CONTROL_BYTES_DROPPED : STAT_RAW_BYTES_DROPPED), len);
session_inc_stat(sess, type, (is_ctrl ? STAT_CONTROL_PACKETS_DROPPED : STAT_RAW_PACKETS_DROPPED), 1);
session_inc_stat(sess, type, (is_ctrl ? STAT_CONTROL_BYTES_DROPPED : STAT_RAW_BYTES_DROPPED), len);
break;
case PACKET_ACTION_FORWARD:
session_inc_stat(sess, dir, (is_ctrl ? STAT_CONTROL_PACKETS_TRANSMITTED : STAT_RAW_PACKETS_TRANSMITTED), 1);
session_inc_stat(sess, dir, (is_ctrl ? STAT_CONTROL_BYTES_TRANSMITTED : STAT_RAW_BYTES_TRANSMITTED), len);
session_inc_stat(sess, type, (is_ctrl ? STAT_CONTROL_PACKETS_TRANSMITTED : STAT_RAW_PACKETS_TRANSMITTED), 1);
session_inc_stat(sess, type, (is_ctrl ? STAT_CONTROL_BYTES_TRANSMITTED : STAT_RAW_BYTES_TRANSMITTED), len);
break;
default:
assert(0);
@@ -242,9 +242,9 @@ static void *worker_thread(void *arg)
packet_set_action(pkt, PACKET_ACTION_DROP);
}
update_session_stat(sess, pkt);
update_stat(sess, pkt);
session_set_current_packet(sess, NULL);
session_set_current_flow_direction(sess, FLOW_DIRECTION_NONE);
session_set_flow_type(sess, FLOW_TYPE_NONE);
}
if (packet_get_action(pkt) == PACKET_ACTION_DROP)

2
infra/version.map
View File

@@ -42,7 +42,7 @@ global:
session_get0_current_packet;
session_get_closing_reason;
session_get_direction;
session_get_current_flow_direction;
session_get_flow_type;
session_get_first_packet;
session_get_id;
session_get_timestamp;

6
test/debug_plugin/debug_plugin.c
View File

@@ -146,7 +146,7 @@ static void on_sess_udp_msg(struct session *sess, int topic_id, const void *msg,
const struct timeval *tv = packet_get_timeval(pkt);
struct plugin_ctx *ctx = (struct plugin_ctx *)plugin_ctx;
struct session_exdata *exdata = (struct session_exdata *)session_exdata_get(sess, ctx->sess_exdata_idx);
if (session_get_current_flow_direction(sess) == FLOW_DIRECTION_C2S)
if (session_get_flow_type(sess) == FLOW_TYPE_C2S)
{
exdata->c2s_rx_pkts++;
exdata->c2s_rx_bytes += packet_get_raw_len(pkt);
@@ -182,7 +182,7 @@ static void on_sess_tcp_msg(struct session *sess, int topic_id, const void *msg,
const struct timeval *tv = packet_get_timeval(pkt);
struct plugin_ctx *ctx = (struct plugin_ctx *)plugin_ctx;
struct session_exdata *exdata = (struct session_exdata *)session_exdata_get(sess, ctx->sess_exdata_idx);
if (session_get_current_flow_direction(sess) == FLOW_DIRECTION_C2S)
if (session_get_flow_type(sess) == FLOW_TYPE_C2S)
{
exdata->c2s_rx_pkts++;
exdata->c2s_rx_bytes += packet_get_raw_len(pkt);
@@ -225,7 +225,7 @@ static void on_sess_tcp_stream_msg(struct session *sess, int topic_id, const voi
debug_plugin_log(ctx->fd, "debug plugin", "on TCP stream msg: %s", buff);
pthread_spin_lock(&ctx->lock);
if (session_get_current_flow_direction(sess) == FLOW_DIRECTION_C2S)
if (session_get_flow_type(sess) == FLOW_TYPE_C2S)
{
debug_plugin_log(ctx->fd, "debug plugin", "rx C2S TCP segment: len: %d, data: %p", len, data);
hexdump_to_fd(ctx->fd, exdata->c2s_rx_tcp_bytes, data, len);

4
test/decoders/http/http_test_plug.cpp
View File

@@ -607,10 +607,10 @@ extern "C" void http_decoder_tunnel_entry(struct session *sess, int topic_id, co
case HTTP_TUNNEL_ACTIVE:
{
enum flow_direction curdir = session_get_current_flow_direction(sess);
enum flow_type curdir = session_get_flow_type(sess);
hstring tunnel_payload = {};
http_tunnel_message_get_payload((const struct http_tunnel_message *)raw_msg, &tunnel_payload);
if (FLOW_DIRECTION_C2S == curdir)
if (FLOW_TYPE_C2S == curdir)
{
req_payload_block++;
req_payload_size += tunnel_payload.iov_len;

2
test/packet_inject/conf/inject_ipv4_based_tcp_payload_after_recv_c2s_first_payload.toml
View File

@@ -2,6 +2,6 @@
[packet_inject]
filter_ip = any # eg: 2001:db8::1, 192.168.1.100, any
filter_port = 0 # eg: 80, 443 (0 for any)
filter_dir = C2S # eg: C2S, S2C
flow_type = C2S # eg: C2S, S2C
filter_pkts = 3 # can not be 0
inject_type = TCP-PAYLOAD # eg: TCP-RST, TCP-FIN, TCP-PAYLOAD, TCP-PAYLOAD-FIN-RST, UDP-PAYLOAD, CTRL-MSG

2
test/packet_inject/conf/inject_ipv4_based_tcp_payload_after_recv_s2c_first_payload.toml
View File

@@ -2,6 +2,6 @@
[packet_inject]
filter_ip = any # eg: 2001:db8::1, 192.168.1.100, any
filter_port = 0 # eg: 80, 443 (0 for any)
filter_dir = S2C # eg: C2S, S2C
flow_type = S2C # eg: C2S, S2C
filter_pkts = 3 # can not be 0
inject_type = TCP-PAYLOAD # eg: TCP-RST, TCP-FIN, TCP-PAYLOAD, TCP-PAYLOAD-FIN-RST, UDP-PAYLOAD, CTRL-MSG

2
test/packet_inject/conf/inject_ipv4_based_tcp_payload_fin_rst_after_recv_c2s_first_payload.toml
View File

@@ -2,6 +2,6 @@
[packet_inject]
filter_ip = any # eg: 2001:db8::1, 192.168.1.100, any
filter_port = 0 # eg: 80, 443 (0 for any)
filter_dir = C2S # eg: C2S, S2C
flow_type = C2S # eg: C2S, S2C
filter_pkts = 3 # can not be 0
inject_type = TCP-PAYLOAD-FIN-RST # eg: TCP-RST, TCP-FIN, TCP-PAYLOAD, TCP-PAYLOAD-FIN-RST, UDP-PAYLOAD, CTRL-MSG

2
test/packet_inject/conf/inject_ipv4_based_tcp_rst_after_recv_c2s_first_payload.toml
View File

@@ -2,6 +2,6 @@
[packet_inject]
filter_ip = any # eg: 2001:db8::1, 192.168.1.100, any
filter_port = 0 # eg: 80, 443 (0 for any)
filter_dir = C2S # eg: C2S, S2C
flow_type = C2S # eg: C2S, S2C
filter_pkts = 3 # can not be 0
inject_type = TCP-RST # eg: TCP-RST, TCP-FIN, TCP-PAYLOAD, TCP-PAYLOAD-FIN-RST, UDP-PAYLOAD, CTRL-MSG

2
test/packet_inject/conf/inject_ipv4_based_tcp_rst_after_recv_s2c_first_payload.toml
View File

@@ -2,6 +2,6 @@
[packet_inject]
filter_ip = any # eg: 2001:db8::1, 192.168.1.100, any
filter_port = 0 # eg: 80, 443 (0 for any)
filter_dir = S2C # eg: C2S, S2C
flow_type = S2C # eg: C2S, S2C
filter_pkts = 3 # can not be 0
inject_type = TCP-RST # eg: TCP-RST, TCP-FIN, TCP-PAYLOAD, TCP-PAYLOAD-FIN-RST, UDP-PAYLOAD, CTRL-MSG

2
test/packet_inject/conf/inject_ipv4_based_tcp_rst_after_recv_sub_ack.toml
View File

@@ -2,6 +2,6 @@
[packet_inject]
filter_ip = any # eg: 2001:db8::1, 192.168.1.100, any
filter_port = 0 # eg: 80, 443 (0 for any)
filter_dir = C2S # eg: C2S, S2C
flow_type = C2S # eg: C2S, S2C
filter_pkts = 2 # can not be 0
inject_type = TCP-RST # eg: TCP-RST, TCP-FIN, TCP-PAYLOAD, TCP-PAYLOAD-FIN-RST, UDP-PAYLOAD, CTRL-MSG

2
test/packet_inject/conf/inject_ipv4_based_tcp_rst_after_recv_syn_ack.toml
View File

@@ -2,6 +2,6 @@
[packet_inject]
filter_ip = any # eg: 2001:db8::1, 192.168.1.100, any
filter_port = 0 # eg: 80, 443 (0 for any)
filter_dir = S2C # eg: C2S, S2C
flow_type = S2C # eg: C2S, S2C
filter_pkts = 1 # can not be 0
inject_type = TCP-RST # eg: TCP-RST, TCP-FIN, TCP-PAYLOAD, TCP-PAYLOAD-FIN-RST, UDP-PAYLOAD, CTRL-MSG

108
test/packet_inject/packet_inject.c
View File

@@ -36,9 +36,9 @@ struct config
struct sockaddr_in6 v6;
} addr;
uint16_t port;
uint64_t number; // inject packet after (C2S/S2C) direction receiving n packets
enum inject_type type;
enum flow_direction direction;
uint64_t number; // inject packet after (C2S/S2C) flow_type receiving n packets
enum inject_type inject_type;
enum flow_type flow_type;
};
struct inject_plugin_ctx
@@ -53,7 +53,7 @@ struct inject_plugin_ctx
struct packet_exdata
{
enum flow_direction flow_dir;
enum flow_type flow_type;
union
{
@@ -161,23 +161,23 @@ static int load_config(struct logger *logger, struct config *config, const char
}
config->port = atoi(ptr);
ptr = toml_raw_in(sub, "filter_dir");
ptr = toml_raw_in(sub, "flow_type");
if (ptr == NULL)
{
INJTECT_PLUGIN_LOG_ERROR(logger, "config file missing packet_inject->filter_dir");
INJTECT_PLUGIN_LOG_ERROR(logger, "config file missing packet_inject->flow_type");
goto error_out;
}
if (strcmp(ptr, "C2S") == 0)
{
config->direction = FLOW_DIRECTION_C2S;
config->flow_type = FLOW_TYPE_C2S;
}
else if (strcmp(ptr, "S2C") == 0)
{
config->direction = FLOW_DIRECTION_S2C;
config->flow_type = FLOW_TYPE_S2C;
}
else
{
INJTECT_PLUGIN_LOG_ERROR(logger, "parse packet_inject->filter_dir failed, invalid direction: %s", ptr);
INJTECT_PLUGIN_LOG_ERROR(logger, "parse packet_inject->flow_type failed, invalid flow_type: %s", ptr);
goto error_out;
}
@@ -202,31 +202,31 @@ static int load_config(struct logger *logger, struct config *config, const char
}
if (strcmp(ptr, "TCP-RST") == 0)
{
config->type = INJECT_TCP_RST;
config->inject_type = INJECT_TCP_RST;
}
else if (strcmp(ptr, "TCP-FIN") == 0)
{
config->type = INJECT_TCP_FIN;
config->inject_type = INJECT_TCP_FIN;
}
else if (strcmp(ptr, "TCP-PAYLOAD") == 0)
{
config->type = INJECT_TCP_PAYLOAD;
config->inject_type = INJECT_TCP_PAYLOAD;
}
else if (strcmp(ptr, "TCP-PAYLOAD-FIN-RST") == 0)
{
config->type = INJECT_TCP_PAYLOAD_FIN_RST;
config->inject_type = INJECT_TCP_PAYLOAD_FIN_RST;
}
else if (strcmp(ptr, "UDP-PAYLOAD") == 0)
{
config->type = INJECT_UDP_PAYLOAD;
config->inject_type = INJECT_UDP_PAYLOAD;
}
else if (strcmp(ptr, "CTRL-MSG") == 0)
{
config->type = INJECT_CTRL_MSG;
config->inject_type = INJECT_CTRL_MSG;
}
else
{
INJTECT_PLUGIN_LOG_ERROR(logger, "parse packet_inject->inject_type failed, invalid inject type: %s", ptr);
INJTECT_PLUGIN_LOG_ERROR(logger, "parse packet_inject->inject_type failed, invalid inject_type: %s", ptr);
goto error_out;
}
@@ -265,20 +265,20 @@ static void print_config(struct logger *logger, const struct config *config)
INJTECT_PLUGIN_LOG_INFO(logger, "config->filter_ip : %s", addr_str);
INJTECT_PLUGIN_LOG_INFO(logger, "config->filter_port : %d", config->port);
INJTECT_PLUGIN_LOG_INFO(logger, "config->filter_dir : %s", config->direction == FLOW_DIRECTION_C2S ? "C2S" : "S2C");
INJTECT_PLUGIN_LOG_INFO(logger, "config->flow_type : %s", config->flow_type == FLOW_TYPE_C2S ? "C2S" : "S2C");
INJTECT_PLUGIN_LOG_INFO(logger, "config->filter_pkts : %lu", config->number);
INJTECT_PLUGIN_LOG_INFO(logger, "config->inject_type : %s", type_to_str(config->type));
INJTECT_PLUGIN_LOG_INFO(logger, "config->inject_type : %s", type_to_str(config->inject_type));
}
/******************************************************************************
* Utils
******************************************************************************/
static inline void packet_exdata_init(const struct packet *pkt, enum flow_direction dir, struct packet_exdata *pkt_exdata)
static inline void packet_exdata_init(const struct packet *pkt, enum flow_type type, struct packet_exdata *pkt_exdata)
{
memset(pkt_exdata, 0, sizeof(struct packet_exdata));
pkt_exdata->flow_dir = dir;
pkt_exdata->flow_type = type;
int get_inner_addr = 0;
int count = packet_get_layer_count(pkt);
@@ -335,12 +335,12 @@ static inline uint32_t uint32_add(uint32_t seq, uint32_t inc)
}
static void build_and_send_udp_packet(struct inject_plugin_ctx *ctx, struct session *sess, struct packet_exdata *pkt_exdata,
enum flow_direction inject_dir, const char *udp_payload, uint16_t udp_payload_len)
enum flow_type type, const char *udp_payload, uint16_t udp_payload_len)
{
const struct packet *origin_pkt = session_get_first_packet(sess, inject_dir);
const struct packet *origin_pkt = session_get_first_packet(sess, type);
if (origin_pkt == NULL)
{
INJTECT_PLUGIN_LOG_ERROR(ctx->logger, "build UDP packet failed, %s origin packet is NULL", inject_dir == FLOW_DIRECTION_C2S ? "C2S" : "S2C");
INJTECT_PLUGIN_LOG_ERROR(ctx->logger, "build UDP packet failed, %s origin packet is NULL", type == FLOW_TYPE_C2S ? "C2S" : "S2C");
return;
}
@@ -355,7 +355,7 @@ static void build_and_send_udp_packet(struct inject_plugin_ctx *ctx, struct sess
}
static void build_and_send_tcp_packet(struct inject_plugin_ctx *ctx, struct session *sess, struct packet_exdata *pkt_exdata,
enum flow_direction inject_dir, uint8_t tcp_flags, const char *tcp_payload, uint16_t tcp_payload_len)
enum flow_type type, uint8_t tcp_flags, const char *tcp_payload, uint16_t tcp_payload_len)
{
uint32_t tcp_seq = 0;
uint32_t tcp_ack = 0;
@@ -369,11 +369,11 @@ static void build_and_send_tcp_packet(struct inject_plugin_ctx *ctx, struct sess
*
* for example: current packet is C2S
*
* inject direction == current direction (inject C2S RST)
* inject flow_type == current flow_type (inject C2S RST)
* tcp_seq = current_packet_seq
* tcp_ack = current_packet_ack
*
* inject direction != current direction (inject S2C RST)
* inject flow_type != current flow_type (inject S2C RST)
* tcp_seq = current_packet_ack
* tcp_ack = current_packet_seq + current_packet_payload_len
* or if current packet is a SYN-ACK packet
@@ -381,7 +381,7 @@ static void build_and_send_tcp_packet(struct inject_plugin_ctx *ctx, struct sess
* tcp_ack = current_packet_ack + current_packet_payload_len + 1
*/
if (inject_dir == pkt_exdata->flow_dir)
if (type == pkt_exdata->flow_type)
{
tcp_seq = uint32_add(pkt_exdata->tcp_seq, pkt_exdata->inc_seq);
tcp_ack = pkt_exdata->tcp_ack;
@@ -398,10 +398,10 @@ static void build_and_send_tcp_packet(struct inject_plugin_ctx *ctx, struct sess
pkt_exdata->inc_ack += (tcp_flags & TH_FIN) ? 1 : 0; // inject RST packer after FIN packer, ack should be increased by 1
}
const struct packet *origin_pkt = session_get_first_packet(sess, inject_dir);
const struct packet *origin_pkt = session_get_first_packet(sess, type);
if (origin_pkt == NULL)
{
INJTECT_PLUGIN_LOG_ERROR(ctx->logger, "build TCP packet failed, %s origin packet is NULL", inject_dir == FLOW_DIRECTION_C2S ? "C2S" : "S2C");
INJTECT_PLUGIN_LOG_ERROR(ctx->logger, "build TCP packet failed, %s origin packet is NULL", type == FLOW_TYPE_C2S ? "C2S" : "S2C");
return;
}
@@ -443,14 +443,14 @@ static void on_sess_msg(struct session *sess, int topic_id, const void *msg, voi
struct packet *pkt = (struct packet *)msg;
struct inject_plugin_ctx *ctx = (struct inject_plugin_ctx *)plugin_ctx;
struct config *config = &ctx->config;
enum flow_direction flow_dir = session_get_current_flow_direction(sess);
enum flow_type type = session_get_flow_type(sess);
INJTECT_PLUGIN_LOG_INFO(ctx->logger, "handle session msg: %s (C2S received packets: %lu, S2C received packets: %lu)",
session_get0_readable_addr(sess),
session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED),
session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED));
session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED),
session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED));
struct packet_exdata pkt_exdata;
packet_exdata_init(pkt, flow_dir, &pkt_exdata);
packet_exdata_init(pkt, type, &pkt_exdata);
if (config->family == AF_INET &&
memcmp(&config->addr.v4, &pkt_exdata.src_addr.v4, sizeof(struct in_addr)) != 0 &&
@@ -473,55 +473,55 @@ static void on_sess_msg(struct session *sess, int topic_id, const void *msg, voi
return;
}
if (session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_INJECTED_PACKETS_SUCCESS) > 0 ||
session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_INJECTED_PACKETS_SUCCESS) > 0)
if (session_get_stat(sess, FLOW_TYPE_C2S, STAT_INJECTED_PACKETS_SUCCESS) > 0 ||
session_get_stat(sess, FLOW_TYPE_S2C, STAT_INJECTED_PACKETS_SUCCESS) > 0)
{
return;
}
if (config->direction == FLOW_DIRECTION_C2S && session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) != config->number)
if (config->flow_type == FLOW_TYPE_C2S && session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) != config->number)
{
return;
}
if (config->direction == FLOW_DIRECTION_S2C && session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) != config->number)
if (config->flow_type == FLOW_TYPE_S2C && session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) != config->number)
{
return;
}
switch (config->type)
switch (config->inject_type)
{
case INJECT_TCP_RST:
build_and_send_tcp_packet(ctx, sess, &pkt_exdata, FLOW_DIRECTION_C2S, TH_RST | TH_ACK, NULL, 0);
build_and_send_tcp_packet(ctx, sess, &pkt_exdata, FLOW_DIRECTION_S2C, TH_RST | TH_ACK, NULL, 0);
build_and_send_tcp_packet(ctx, sess, &pkt_exdata, FLOW_TYPE_C2S, TH_RST | TH_ACK, NULL, 0);
build_and_send_tcp_packet(ctx, sess, &pkt_exdata, FLOW_TYPE_S2C, TH_RST | TH_ACK, NULL, 0);
session_set_discard(sess);
break;
case INJECT_TCP_FIN:
build_and_send_tcp_packet(ctx, sess, &pkt_exdata, FLOW_DIRECTION_C2S, TH_FIN | TH_ACK, NULL, 0);
build_and_send_tcp_packet(ctx, sess, &pkt_exdata, FLOW_DIRECTION_S2C, TH_FIN | TH_ACK, NULL, 0);
build_and_send_tcp_packet(ctx, sess, &pkt_exdata, FLOW_TYPE_C2S, TH_FIN | TH_ACK, NULL, 0);
build_and_send_tcp_packet(ctx, sess, &pkt_exdata, FLOW_TYPE_S2C, TH_FIN | TH_ACK, NULL, 0);
session_set_discard(sess);
break;
case INJECT_TCP_PAYLOAD:
snprintf(buffer, sizeof(buffer), "HTTP/1.1 200 OK\r\nContent-Length: %d\r\n\r\n%s", 5 + 5 + 2, "Hello");
build_and_send_tcp_packet(ctx, sess, &pkt_exdata, FLOW_DIRECTION_S2C, TH_ACK, buffer, strlen(buffer)); // inject payload to client
build_and_send_tcp_packet(ctx, sess, &pkt_exdata, FLOW_DIRECTION_S2C, TH_ACK, "World\r\n", 7); // inject payload to client
build_and_send_tcp_packet(ctx, sess, &pkt_exdata, FLOW_DIRECTION_S2C, TH_RST | TH_ACK, NULL, 0); // inject RST to client
build_and_send_tcp_packet(ctx, sess, &pkt_exdata, FLOW_DIRECTION_C2S, TH_RST | TH_ACK, NULL, 0); // inject RST to server
build_and_send_tcp_packet(ctx, sess, &pkt_exdata, FLOW_TYPE_S2C, TH_ACK, buffer, strlen(buffer)); // inject payload to client
build_and_send_tcp_packet(ctx, sess, &pkt_exdata, FLOW_TYPE_S2C, TH_ACK, "World\r\n", 7); // inject payload to client
build_and_send_tcp_packet(ctx, sess, &pkt_exdata, FLOW_TYPE_S2C, TH_RST | TH_ACK, NULL, 0); // inject RST to client
build_and_send_tcp_packet(ctx, sess, &pkt_exdata, FLOW_TYPE_C2S, TH_RST | TH_ACK, NULL, 0); // inject RST to server
session_set_discard(sess);
break;
case INJECT_TCP_PAYLOAD_FIN_RST:
snprintf(buffer, sizeof(buffer), "HTTP/1.1 200 OK\r\nContent-Length: %d\r\n\r\n%s", 5 + 5 + 2, "Hello");
build_and_send_tcp_packet(ctx, sess, &pkt_exdata, FLOW_DIRECTION_S2C, TH_ACK, buffer, strlen(buffer)); // inject payload to client
build_and_send_tcp_packet(ctx, sess, &pkt_exdata, FLOW_DIRECTION_S2C, TH_ACK, "World\r\n", 7); // inject payload to client
build_and_send_tcp_packet(ctx, sess, &pkt_exdata, FLOW_DIRECTION_S2C, TH_FIN | TH_ACK, NULL, 0); // inject FIN to client
build_and_send_tcp_packet(ctx, sess, &pkt_exdata, FLOW_DIRECTION_S2C, TH_RST | TH_ACK, NULL, 0); // inject RST to client
build_and_send_tcp_packet(ctx, sess, &pkt_exdata, FLOW_DIRECTION_C2S, TH_FIN | TH_ACK, NULL, 0); // inject FIN to server
build_and_send_tcp_packet(ctx, sess, &pkt_exdata, FLOW_DIRECTION_C2S, TH_RST | TH_ACK, NULL, 0); // inject RST to server
build_and_send_tcp_packet(ctx, sess, &pkt_exdata, FLOW_TYPE_S2C, TH_ACK, buffer, strlen(buffer)); // inject payload to client
build_and_send_tcp_packet(ctx, sess, &pkt_exdata, FLOW_TYPE_S2C, TH_ACK, "World\r\n", 7); // inject payload to client
build_and_send_tcp_packet(ctx, sess, &pkt_exdata, FLOW_TYPE_S2C, TH_FIN | TH_ACK, NULL, 0); // inject FIN to client
build_and_send_tcp_packet(ctx, sess, &pkt_exdata, FLOW_TYPE_S2C, TH_RST | TH_ACK, NULL, 0); // inject RST to client
build_and_send_tcp_packet(ctx, sess, &pkt_exdata, FLOW_TYPE_C2S, TH_FIN | TH_ACK, NULL, 0); // inject FIN to server
build_and_send_tcp_packet(ctx, sess, &pkt_exdata, FLOW_TYPE_C2S, TH_RST | TH_ACK, NULL, 0); // inject RST to server
session_set_discard(sess);
break;
case INJECT_UDP_PAYLOAD:
build_and_send_udp_packet(ctx, sess, &pkt_exdata, FLOW_DIRECTION_C2S, "Hello Server", 12);
build_and_send_udp_packet(ctx, sess, &pkt_exdata, FLOW_DIRECTION_S2C, "Hello Client", 12);
build_and_send_udp_packet(ctx, sess, &pkt_exdata, FLOW_TYPE_C2S, "Hello Server", 12);
build_and_send_udp_packet(ctx, sess, &pkt_exdata, FLOW_TYPE_S2C, "Hello Client", 12);
session_set_discard(sess);
break;
case INJECT_CTRL_MSG: