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: case HTTP_EVENT_REQ_LINE:
msg = http_message_new(HTTP_MESSAGE_REQ_LINE, queue, queue_idx, HTTP_REQUEST); 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); 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; exdata->tunnel_state = HTTP_TUN_C2S_HDR_START;
// http_decoder_stat_update(&httpd_env->hd_stat, thread_id, HTTPD_STAT_TUNNEL, 1); // 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: case HTTP_EVENT_RES_LINE:
msg = http_message_new(HTTP_MESSAGE_RES_LINE, queue, queue_idx, HTTP_RESPONSE); 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); 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; exdata->tunnel_state = HTTP_TUN_S2C_START;
} }
@@ -668,8 +668,8 @@ extern "C"
int thread_id = stellar_get_current_thread_index(); int thread_id = stellar_get_current_thread_index();
struct http_decoder_half *cur_half = NULL; struct http_decoder_half *cur_half = NULL;
enum flow_direction sess_dir = session_get_current_flow_direction(sess); enum flow_type sess_dir = session_get_flow_type(sess);
if (FLOW_DIRECTION_C2S == sess_dir) if (FLOW_TYPE_C2S == sess_dir)
{ {
cur_half = exdata->decoder->c2s_half; cur_half = exdata->decoder->c2s_half;
http_decoder_stat_update(&httpd_env->hd_stat, thread_id, HTTP_C2S_BYTES, payload_len); 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; return 0;
} }
if (FLOW_DIRECTION_C2S == curdir) if (FLOW_TYPE_C2S == curdir)
{ {
struct http_request_line reqline = {}; struct http_request_line reqline = {};
http_decoder_half_data_get_request_line(hfdata, &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_START:
case HTTP_TRANSACTION_END: case HTTP_TRANSACTION_END:
{ {
enum flow_direction cur_dir = session_get_current_flow_direction(sess); enum flow_type cur_dir = session_get_flow_type(sess);
if (FLOW_DIRECTION_C2S == cur_dir) if (FLOW_TYPE_C2S == cur_dir)
{ {
is_req_msg = 1; is_req_msg = 1;
} }
@@ -233,9 +233,9 @@ int httpd_url_is_encoded(const char *url, size_t len)
return 0; 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->sport = tcph->th_sport;
addr->dport = tcph->th_dport; 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; 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; addr->ipver = 4;
if (FLOW_DIRECTION_C2S == fdir) if (FLOW_TYPE_C2S == fdir)
{ {
addr->saddr4 = ip4h->ip_src.s_addr; addr->saddr4 = ip4h->ip_src.s_addr;
addr->daddr4 = ip4h->ip_dst.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; 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; 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->saddr6, &ip6h->ip6_src, sizeof(struct in6_addr));
memcpy(&addr->daddr6, &ip6h->ip6_dst, 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; 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); const struct packet *raw_pkt = session_get_first_packet(sess, fdir);
if (NULL == raw_pkt) 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 //get host order port from stellar session api
const struct packet *pkt = session_get0_current_packet(sess); const struct packet *pkt = session_get0_current_packet(sess);
enum flow_direction flow_dir=session_get_current_flow_direction(sess); enum flow_type flow_type=session_get_flow_type(sess);
if(pkt && (flow_dir==FLOW_DIRECTION_C2S || flow_dir==FLOW_DIRECTION_S2C)) if(pkt && (flow_type==FLOW_TYPE_C2S || flow_type==FLOW_TYPE_S2C))
{ {
int layer_cnt=packet_get_layer_count(pkt); int layer_cnt=packet_get_layer_count(pkt);
const struct layer *layer = packet_get_layer_by_idx(pkt, layer_cnt - 1); 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); *dport = ntohs(layer->hdr.udp->uh_dport);
} }
//S2C, swap sport and dport //S2C, swap sport and dport
if(flow_dir == FLOW_DIRECTION_S2C) if(flow_type == FLOW_TYPE_S2C)
{ {
unsigned short tmp = *sport; unsigned short tmp = *sport;
*sport = *dport; *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; struct l7_protocol_label *l7_protocol=NULL;
//const struct packet *raw_packet=session_get0_current_packet(sess); //const struct packet *raw_packet=session_get0_current_packet(sess);
//int cur_pkt_dir= packet_get_direction(raw_packet); //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++; context->pkt_cnt++;
(cur_pkt_dir==FLOW_DIRECTION_C2S) ? (context->c2s_pkt++) : (context->s2c_pkt++); (cur_pkt_dir==FLOW_TYPE_C2S) ? (context->c2s_pkt++) : (context->s2c_pkt++);
int is_c2s_pkt=((cur_pkt_dir==FLOW_DIRECTION_C2S) ? 1 : 0); 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); ret=lpi_update_dpkt(&(context->lpi_data), sess, scan_data, scan_data_len, l4_proto, is_c2s_pkt);
if(!ret) 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, ret=revise_lpi_result(sess, scan_data, scan_data_len, &modify_lpi_result, context,
(l4_proto==6?1:0), (l4_proto==6?1:0),
(cur_pkt_dir==FLOW_DIRECTION_C2S?1:0)); (cur_pkt_dir==FLOW_TYPE_C2S?1:0));
if(ret==0) if(ret==0)
{ {
return 1; return 1;
@@ -569,7 +569,7 @@ static int lpi_detector(struct session *sess, struct traffic_context *context, s
plpi_mod=&modify_lpi_result; 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)) && 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)) || (((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 ( if (
(scan_data_len >= 4) && (scan_data_len >= 4) &&

16
include/stellar/session.h
View File

@@ -32,12 +32,12 @@ enum session_direction
SESSION_DIRECTION_OUTBOUND = 1, SESSION_DIRECTION_OUTBOUND = 1,
}; };
enum flow_direction enum flow_type
{ {
FLOW_DIRECTION_NONE = -1, FLOW_TYPE_NONE = -1,
FLOW_DIRECTION_C2S = 0, FLOW_TYPE_C2S = 0,
FLOW_DIRECTION_S2C = 1, FLOW_TYPE_S2C = 1,
MAX_FLOW_DIRECTION = 2, MAX_FLOW_TYPE = 2,
}; };
enum closing_reason 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 closing_reason session_get_closing_reason(const struct session *sess);
enum session_direction session_get_direction(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); enum flow_type session_get_flow_type(const struct session *sess);
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);
uint64_t session_get_id(const struct session *sess); 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_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); 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) 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 *c2s_ssembler = sess->tcp_halfs[FLOW_TYPE_C2S].assembler;
struct tcp_reassembly *s2c_ssembler = sess->tcp_halfs[FLOW_DIRECTION_S2C].assembler; struct tcp_reassembly *s2c_ssembler = sess->tcp_halfs[FLOW_TYPE_S2C].assembler;
struct tcp_segment *seg; struct tcp_segment *seg;
if (c2s_ssembler) if (c2s_ssembler)
{ {
while ((seg = tcp_reassembly_expire(c2s_ssembler, UINT64_MAX))) 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_TYPE_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_PAYLOADS_RELEASED, seg->len);
mgr->stat.tcp_segs_freed++; mgr->stat.tcp_segs_freed++;
tcp_segment_free(seg); 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))) 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_TYPE_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_PAYLOADS_RELEASED, seg->len);
mgr->stat.tcp_segs_freed++; mgr->stat.tcp_segs_freed++;
tcp_segment_free(seg); tcp_segment_free(seg);
} }
@@ -199,9 +199,9 @@ static int tcp_init(struct session_manager *mgr, struct session *sess)
return 0; 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_TYPE_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); 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_DIRECTION_C2S].assembler == NULL || sess->tcp_halfs[FLOW_DIRECTION_S2C].assembler == NULL) if (sess->tcp_halfs[FLOW_TYPE_C2S].assembler == NULL || sess->tcp_halfs[FLOW_TYPE_S2C].assembler == NULL)
{ {
tcp_clean(mgr, sess); tcp_clean(mgr, sess);
return -1; 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_LOG_DEBUG("session %lu %s new c2s tcp assembler %p, s2c tcp assembler %p",
session_get_id(sess), session_get0_readable_addr(sess), session_get_id(sess), session_get0_readable_addr(sess),
sess->tcp_halfs[FLOW_DIRECTION_C2S].assembler, sess->tcp_halfs[FLOW_TYPE_C2S].assembler,
sess->tcp_halfs[FLOW_DIRECTION_S2C].assembler); sess->tcp_halfs[FLOW_TYPE_S2C].assembler);
return 0; 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 tcp_segment *seg;
struct tcphdr *hdr = (struct tcphdr *)tcp_layer->hdr_ptr; 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); uint8_t flags = tcp_hdr_get_flags(hdr);
uint16_t len = tcp_layer->pld_len; 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) if (len)
{ {
session_inc_stat(sess, dir, STAT_TCP_SEGMENTS_RECEIVED, 1); session_inc_stat(sess, type, STAT_TCP_SEGMENTS_RECEIVED, 1);
session_inc_stat(sess, dir, STAT_TCP_PAYLOADS_RECEIVED, len); session_inc_stat(sess, type, STAT_TCP_PAYLOADS_RECEIVED, len);
mgr->stat.tcp_segs_input++; mgr->stat.tcp_segs_input++;
session_inc_stat(sess, dir, STAT_TCP_SEGMENTS_INORDER, 1); session_inc_stat(sess, type, STAT_TCP_SEGMENTS_INORDER, 1);
session_inc_stat(sess, dir, STAT_TCP_PAYLOADS_INORDER, len); session_inc_stat(sess, type, STAT_TCP_PAYLOADS_INORDER, len);
mgr->stat.tcp_segs_inorder++; mgr->stat.tcp_segs_inorder++;
half->in_order.data = tcp_layer->pld_ptr; 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); seg = tcp_reassembly_expire(half->assembler, mgr->now_ms);
if (seg) if (seg)
{ {
session_inc_stat(sess, dir, STAT_TCP_SEGMENTS_EXPIRED, 1); session_inc_stat(sess, type, STAT_TCP_SEGMENTS_EXPIRED, 1);
session_inc_stat(sess, dir, STAT_TCP_PAYLOADS_EXPIRED, seg->len); session_inc_stat(sess, type, STAT_TCP_PAYLOADS_EXPIRED, seg->len);
mgr->stat.tcp_segs_timeout++; mgr->stat.tcp_segs_timeout++;
session_inc_stat(sess, dir, STAT_TCP_SEGMENTS_RELEASED, 1); session_inc_stat(sess, type, STAT_TCP_SEGMENTS_RELEASED, 1);
session_inc_stat(sess, dir, STAT_TCP_PAYLOADS_RELEASED, seg->len); session_inc_stat(sess, type, STAT_TCP_PAYLOADS_RELEASED, seg->len);
mgr->stat.tcp_segs_freed++; mgr->stat.tcp_segs_freed++;
tcp_segment_free(seg); tcp_segment_free(seg);
@@ -274,16 +274,16 @@ static void tcp_update(struct session_manager *mgr, struct session *sess, enum f
if (len) if (len)
{ {
session_inc_stat(sess, dir, STAT_TCP_SEGMENTS_RECEIVED, 1); session_inc_stat(sess, type, STAT_TCP_SEGMENTS_RECEIVED, 1);
session_inc_stat(sess, dir, STAT_TCP_PAYLOADS_RECEIVED, len); session_inc_stat(sess, type, STAT_TCP_PAYLOADS_RECEIVED, len);
mgr->stat.tcp_segs_input++; mgr->stat.tcp_segs_input++;
uint32_t rcv_nxt = tcp_reassembly_get_recv_next(half->assembler); uint32_t rcv_nxt = tcp_reassembly_get_recv_next(half->assembler);
// in order // in order
if (half->seq == rcv_nxt) if (half->seq == rcv_nxt)
{ {
session_inc_stat(sess, dir, STAT_TCP_SEGMENTS_INORDER, 1); session_inc_stat(sess, type, STAT_TCP_SEGMENTS_INORDER, 1);
session_inc_stat(sess, dir, STAT_TCP_PAYLOADS_INORDER, len); session_inc_stat(sess, type, STAT_TCP_PAYLOADS_INORDER, len);
mgr->stat.tcp_segs_inorder++; mgr->stat.tcp_segs_inorder++;
half->in_order.data = tcp_layer->pld_ptr; 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 // retransmission
else if (uint32_before(uint32_add(half->seq, len), rcv_nxt)) 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, type, STAT_TCP_SEGMENTS_RETRANSMIT, 1);
session_inc_stat(sess, dir, STAT_TCP_PAYLOADS_RETRANSMIT, len); session_inc_stat(sess, type, STAT_TCP_PAYLOADS_RETRANSMIT, len);
mgr->stat.tcp_segs_retransmited++; mgr->stat.tcp_segs_retransmited++;
} }
else if ((seg = tcp_segment_new(half->seq, tcp_layer->pld_ptr, len))) 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)) switch (tcp_reassembly_push(half->assembler, seg, mgr->now_ms))
{ {
case -2: case -2:
session_inc_stat(sess, dir, STAT_TCP_SEGMENTS_RETRANSMIT, 1); session_inc_stat(sess, type, STAT_TCP_SEGMENTS_RETRANSMIT, 1);
session_inc_stat(sess, dir, STAT_TCP_PAYLOADS_RETRANSMIT, len); session_inc_stat(sess, type, STAT_TCP_PAYLOADS_RETRANSMIT, len);
mgr->stat.tcp_segs_retransmited++; mgr->stat.tcp_segs_retransmited++;
tcp_segment_free(seg); tcp_segment_free(seg);
break; break;
case -1: case -1:
session_inc_stat(sess, dir, STAT_TCP_SEGMENTS_NOSPACE, 1); session_inc_stat(sess, type, STAT_TCP_SEGMENTS_NOSPACE, 1);
session_inc_stat(sess, dir, STAT_TCP_PAYLOADS_NOSPACE, len); session_inc_stat(sess, type, STAT_TCP_PAYLOADS_NOSPACE, len);
mgr->stat.tcp_segs_omitted_too_many++; mgr->stat.tcp_segs_omitted_too_many++;
tcp_segment_free(seg); tcp_segment_free(seg);
break; break;
case 0: case 0:
session_inc_stat(sess, dir, STAT_TCP_SEGMENTS_BUFFERED, 1); session_inc_stat(sess, type, STAT_TCP_SEGMENTS_BUFFERED, 1);
session_inc_stat(sess, dir, STAT_TCP_PAYLOADS_BUFFERED, len); session_inc_stat(sess, type, STAT_TCP_PAYLOADS_BUFFERED, len);
mgr->stat.tcp_segs_buffered++; mgr->stat.tcp_segs_buffered++;
break; break;
case 1: case 1:
session_inc_stat(sess, dir, STAT_TCP_SEGMENTS_OVERLAP, 1); session_inc_stat(sess, type, STAT_TCP_SEGMENTS_OVERLAP, 1);
session_inc_stat(sess, dir, STAT_TCP_PAYLOADS_OVERLAP, len); session_inc_stat(sess, type, STAT_TCP_PAYLOADS_OVERLAP, len);
mgr->stat.tcp_segs_overlapped++; mgr->stat.tcp_segs_overlapped++;
session_inc_stat(sess, dir, STAT_TCP_SEGMENTS_BUFFERED, 1); session_inc_stat(sess, type, STAT_TCP_SEGMENTS_BUFFERED, 1);
session_inc_stat(sess, dir, STAT_TCP_PAYLOADS_BUFFERED, len); session_inc_stat(sess, type, STAT_TCP_PAYLOADS_BUFFERED, len);
mgr->stat.tcp_segs_buffered++; mgr->stat.tcp_segs_buffered++;
break; break;
default: default:
@@ -335,8 +335,8 @@ static void tcp_update(struct session_manager *mgr, struct session *sess, enum f
} }
else else
{ {
session_inc_stat(sess, dir, STAT_TCP_SEGMENTS_NOSPACE, 1); session_inc_stat(sess, type, STAT_TCP_SEGMENTS_NOSPACE, 1);
session_inc_stat(sess, dir, STAT_TCP_PAYLOADS_NOSPACE, len); session_inc_stat(sess, type, STAT_TCP_PAYLOADS_NOSPACE, len);
mgr->stat.tcp_segs_omitted_too_many++; 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 * 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 // big port is client
if (src_port > dst_port) if (src_port > dst_port)
{ {
return FLOW_DIRECTION_C2S; return FLOW_TYPE_C2S;
} }
else if (src_port < dst_port) else if (src_port < dst_port)
{ {
return FLOW_DIRECTION_S2C; return FLOW_TYPE_S2C;
} }
else else
{ {
// if port is equal, first packet is C2S // 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) if (tuple6_cmp(session_get_tuple6(sess), key) == 0)
{ {
return FLOW_DIRECTION_C2S; return FLOW_TYPE_C2S;
} }
else 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; return 0;
} }
enum flow_direction dir = identify_direction_by_history(sess, key); enum flow_type type = identify_flow_type_by_history(sess, key);
if (session_get_stat(sess, dir, STAT_RAW_PACKETS_RECEIVED) < 3 || session_has_duplicate_traffic(sess)) 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)) 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, type, 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_BYTES_BYPASS, packet_get_raw_len(pkt));
switch (session_get_type(sess)) switch (session_get_type(sess))
{ {
case SESSION_TYPE_TCP: 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_duplicate_traffic(sess);
session_set_current_packet(sess, pkt); session_set_current_packet(sess, pkt);
session_set_current_flow_direction(sess, dir); session_set_flow_type(sess, type);
return 1; return 1;
} }
else else
@@ -459,14 +459,14 @@ static int duplicated_packet_bypass(struct session_manager *mgr, struct session
* session manager utils * 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) if (session_get_current_state(sess) == SESSION_STATE_INIT)
{ {
uint64_t sess_id = snowflake_generate(mgr->sf, mgr->now_ms / 1000); uint64_t sess_id = snowflake_generate(mgr->sf, mgr->now_ms / 1000);
session_set_id(sess, sess_id); session_set_id(sess, sess_id);
enum packet_direction pkt_dir = packet_get_direction(pkt); enum packet_direction pkt_dir = packet_get_direction(pkt);
if (dir == FLOW_DIRECTION_C2S) if (type == FLOW_TYPE_C2S)
{ {
session_set_tuple6(sess, key); session_set_tuple6(sess, key);
if (pkt_dir == PACKET_DIRECTION_OUTGOING) // Internal -> External 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, type, 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_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_first_packet(sess, type, packet_dup(pkt));
session_set_route_ctx(sess, dir, packet_get_route_ctx(pkt)); session_set_route_ctx(sess, type, packet_get_route_ctx(pkt));
session_set_sids(sess, dir, packet_get_sids(pkt)); session_set_sids(sess, type, packet_get_sids(pkt));
} }
session_set_current_packet(sess, 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_timestamp(sess, SESSION_TIMESTAMP_LAST, mgr->now_ms);
session_set_current_state(sess, next_state); session_set_current_state(sess, next_state);
} }
@@ -592,8 +592,8 @@ static struct session *session_manager_lookup_tcp_session(struct session_manager
return sess; return sess;
} }
enum flow_direction dir = identify_direction_by_history(sess, key); enum flow_type type = identify_flow_type_by_history(sess, key);
struct tcp_half *half = &sess->tcp_halfs[dir]; struct tcp_half *half = &sess->tcp_halfs[type];
if ((half->isn && half->isn != tcp_hdr_get_seq(hdr)) || // recv SYN with different ISN 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 ((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); 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); struct session *sess = session_pool_pop(mgr->sess_pool);
if (sess == NULL) if (sess == NULL)
{ {
@@ -638,7 +638,7 @@ static struct session *session_manager_new_tcp_session(struct session_manager *m
sess->mgr_stat = &mgr->stat; sess->mgr_stat = &mgr->stat;
enum session_state next_state = session_transition_run(SESSION_STATE_INIT, TCP_SYN); 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); session_transition_log(sess, SESSION_STATE_INIT, next_state, TCP_SYN);
if (tcp_init(mgr, sess) == -1) 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); session_pool_push(mgr->sess_pool, sess);
return NULL; 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; 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); 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 = mgr;
sess->mgr_stat = &mgr->stat; 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); 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_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); 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 layer_private *tcp_layer = packet_get_innermost_layer(pkt, LAYER_PROTO_TCP);
const struct tcphdr *hdr = (const struct tcphdr *)tcp_layer->hdr_ptr; 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); uint8_t flags = tcp_hdr_get_flags(hdr);
int inputs = 0; int inputs = 0;
inputs |= (flags & TH_SYN) ? TCP_SYN : NONE; 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); enum session_state next_state = session_transition_run(curr_state, inputs);
// update session // 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); session_transition_log(sess, curr_state, next_state, inputs);
// update tcp // update tcp
tcp_update(mgr, sess, dir, tcp_layer); tcp_update(mgr, sess, type, tcp_layer);
// set closing reason // set closing reason
if (next_state == SESSION_STATE_CLOSING && !session_get_closing_reason(sess)) if (next_state == SESSION_STATE_CLOSING && !session_get_closing_reason(sess))
{ {
if (flags & TH_FIN) 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) 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 // update timeout
struct tcp_half *curr = &sess->tcp_halfs[dir]; struct tcp_half *curr = &sess->tcp_halfs[type];
struct tcp_half *peer = &sess->tcp_halfs[(dir == FLOW_DIRECTION_C2S ? FLOW_DIRECTION_S2C : FLOW_DIRECTION_C2S)]; struct tcp_half *peer = &sess->tcp_halfs[(type == FLOW_TYPE_C2S ? FLOW_TYPE_S2C : FLOW_TYPE_C2S)];
uint64_t timeout = 0; uint64_t timeout = 0;
switch (next_state) 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) 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 curr_state = session_get_current_state(sess);
enum session_state next_state = session_transition_run(curr_state, UDP_DATA); 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); session_transition_log(sess, curr_state, next_state, UDP_DATA);
if (session_get_current_state(sess) == SESSION_STATE_DISCARD) 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; break;
} }
packet_free((struct packet *)session_get_first_packet(sess, FLOW_DIRECTION_C2S)); packet_free((struct packet *)session_get_first_packet(sess, FLOW_TYPE_C2S));
packet_free((struct packet *)session_get_first_packet(sess, FLOW_DIRECTION_S2C)); packet_free((struct packet *)session_get_first_packet(sess, FLOW_TYPE_S2C));
session_set_first_packet(sess, FLOW_DIRECTION_C2S, NULL); session_set_first_packet(sess, FLOW_TYPE_C2S, NULL);
session_set_first_packet(sess, FLOW_DIRECTION_S2C, NULL); session_set_first_packet(sess, FLOW_TYPE_S2C, NULL);
session_clear_route_ctx(sess, FLOW_DIRECTION_C2S); session_clear_route_ctx(sess, FLOW_TYPE_C2S);
session_clear_route_ctx(sess, FLOW_DIRECTION_S2C); session_clear_route_ctx(sess, FLOW_TYPE_S2C);
session_clear_sids(sess, FLOW_DIRECTION_C2S); session_clear_sids(sess, FLOW_TYPE_C2S);
session_clear_sids(sess, FLOW_DIRECTION_S2C); session_clear_sids(sess, FLOW_TYPE_S2C);
session_set_current_state(sess, SESSION_STATE_INIT); session_set_current_state(sess, SESSION_STATE_INIT);
session_set_current_packet(sess, NULL); 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); session_pool_push(mgr->sess_pool, sess);
sess = NULL; sess = NULL;
} }

41
infra/session_manager/session_private.h
View File

@@ -47,9 +47,9 @@ struct tcp_half
struct session struct session
{ {
uint64_t id; 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 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 timeout timeout;
struct list_head lru; struct list_head lru;
struct list_head free; struct list_head free;
@@ -59,18 +59,17 @@ struct session
UT_hash_handle hh3; UT_hash_handle hh3;
struct tuple6 tuple; struct tuple6 tuple;
char tuple_str[TUPLE6_STR_SIZE]; char tuple_str[TUPLE6_STR_SIZE];
struct sids sids[MAX_FLOW_DIRECTION]; struct sids sids[MAX_FLOW_TYPE];
struct route_ctx route_ctx[MAX_FLOW_DIRECTION]; struct route_ctx route_ctx[MAX_FLOW_TYPE];
const struct packet *first_pkt[MAX_FLOW_DIRECTION]; const struct packet *first_pkt[MAX_FLOW_TYPE];
const struct packet *curr_pkt; const struct packet *curr_pkt;
void *ex_data[EX_DATA_MAX_COUNT]; void *ex_data[EX_DATA_MAX_COUNT];
void *user_data; void *user_data;
int is_symmetric; int is_symmetric;
int dup; int dup;
enum session_direction sess_dir; enum session_direction sess_dir;
enum flow_direction tuple_dir; enum flow_type flow_type;
enum flow_direction flow_dir; enum session_type sess_type;
enum session_type type;
enum session_state state; enum session_state state;
enum closing_reason reason; enum closing_reason reason;
struct session_manager *mgr; 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); void session_set_direction(struct session *sess, enum session_direction dir);
enum session_direction session_get_direction(const struct session *sess); enum session_direction session_get_direction(const struct session *sess);
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);
// enum flow_direction session_get_current_flow_direction(const struct session *sess); // enum flow_type session_get_flow_type(const struct session *sess);
void session_set_current_state(struct session *sess, enum session_state state); void session_set_current_state(struct session *sess, enum session_state state);
// enum session_state session_get_current_state(const struct session *sess); // 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); void session_set_closing_reason(struct session *sess, enum closing_reason reason);
// enum closing_reason session_get_closing_reason(const struct session *sess); // 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); 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_direction dir, enum session_stat stat); // 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); 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); // 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_clear_sids(struct session *sess, enum flow_type type);
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);
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);
void session_clear_route_ctx(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_direction dir, const struct route_ctx *ctx); 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_direction dir); 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); 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_direction dir); // 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); void session_set_current_packet(struct session *sess, const struct packet *pkt);
// const struct packet *session_get0_current_packet(const struct session *sess); // 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 *closing_reason_to_str(enum closing_reason reason);
const char *session_state_to_str(enum session_state state); const char *session_state_to_str(enum session_state state);
const char *session_type_to_str(enum session_type type); 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 : 1, output session bref info
// bref : 0, output session detail 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; 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) 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) 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) 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) 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; 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) 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]; 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) 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 session_is_symmetric(const struct session *sess, unsigned char *flag)
{ {
int is_symmetric = 0; 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) if (flag)
{ {
@@ -172,14 +172,14 @@ int session_is_symmetric(const struct session *sess, unsigned char *flag)
} }
is_symmetric = 1; is_symmetric = 1;
} }
else if (sess->first_pkt[FLOW_DIRECTION_C2S]) else if (sess->first_pkt[FLOW_TYPE_C2S])
{ {
if (flag) if (flag)
{ {
*flag = SESSION_SEEN_C2S_FLOW; *flag = SESSION_SEEN_C2S_FLOW;
} }
} }
else if (sess->first_pkt[FLOW_DIRECTION_S2C]) else if (sess->first_pkt[FLOW_TYPE_S2C])
{ {
if (flag) 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) struct tcp_segment *session_get_tcp_segment(struct session *sess)
{ {
enum flow_direction dir = session_get_current_flow_direction(sess); enum flow_type type = session_get_flow_type(sess);
struct tcp_half *half = &sess->tcp_halfs[dir]; struct tcp_half *half = &sess->tcp_halfs[type];
if (half->in_order.data != NULL && half->in_order.len > 0 && half->in_order_ref == 0) 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); struct tcp_segment *seg = tcp_reassembly_pop(half->assembler);
if (seg) if (seg)
{ {
session_inc_stat(sess, dir, STAT_TCP_SEGMENTS_REORDERED, 1); session_inc_stat(sess, type, STAT_TCP_SEGMENTS_REORDERED, 1);
session_inc_stat(sess, dir, STAT_TCP_PAYLOADS_REORDERED, seg->len); session_inc_stat(sess, type, STAT_TCP_PAYLOADS_REORDERED, seg->len);
// TODO // TODO
sess->mgr_stat->tcp_segs_consumed++; sess->mgr_stat->tcp_segs_consumed++;
@@ -233,8 +233,8 @@ void session_free_tcp_segment(struct session *sess, struct tcp_segment *seg)
return; return;
} }
enum flow_direction dir = session_get_current_flow_direction(sess); enum flow_type type = session_get_flow_type(sess);
struct tcp_half *half = &sess->tcp_halfs[dir]; struct tcp_half *half = &sess->tcp_halfs[type];
if (seg == &half->in_order) if (seg == &half->in_order)
{ {
@@ -244,8 +244,8 @@ void session_free_tcp_segment(struct session *sess, struct tcp_segment *seg)
} }
else else
{ {
session_inc_stat(sess, dir, STAT_TCP_SEGMENTS_RELEASED, 1); session_inc_stat(sess, type, STAT_TCP_SEGMENTS_RELEASED, 1);
session_inc_stat(sess, dir, STAT_TCP_PAYLOADS_RELEASED, seg->len); session_inc_stat(sess, type, STAT_TCP_PAYLOADS_RELEASED, seg->len);
sess->mgr_stat->tcp_segs_freed++; sess->mgr_stat->tcp_segs_freed++;
tcp_segment_free(seg); 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"; return "C2S";
case FLOW_DIRECTION_S2C: case FLOW_TYPE_S2C:
return "S2C"; return "S2C";
default: default:
return "unknown"; 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_get0_readable_addr(sess),
session_type_to_str(session_get_type(sess)), session_type_to_str(session_get_type(sess)),
session_state_to_str(session_get_current_state(sess)), session_state_to_str(session_get_current_state(sess)),
flow_direction_to_str(session_get_current_flow_direction(sess)), flow_direction_to_str(session_get_flow_type(sess)),
session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED), session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED),
session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED)); session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED));
} }
else 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)); used += snprintf(buff + used, size - used, "\"current_packet\":\"%p\",", session_get0_current_packet(sess));
const char *str[] = {"c2s", "s2c"}; 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++) for (int i = 0; i < 2; i++)
{ {
// raw packets // 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_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, dir[i], STAT_RAW_BYTES_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_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, dir[i], STAT_RAW_BYTES_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_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, dir[i], STAT_RAW_BYTES_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 // 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_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, dir[i], STAT_DUPLICATE_BYTES_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 // 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_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, dir[i], STAT_INJECTED_PACKETS_SUCCESS)); 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, dir[i], STAT_INJECTED_BYTES_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 // 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_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, dir[i], STAT_CONTROL_BYTES_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_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, dir[i], STAT_CONTROL_BYTES_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_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, dir[i], STAT_CONTROL_BYTES_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) 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_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[dir[i]].ack); used += snprintf(buff + used, size - used, "\"%s_tcp_last_ack\":%u,", str[i], sess->tcp_halfs[type[i]].ack);
memset(flags, 0, sizeof(flags)); 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_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_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, dir[i], STAT_TCP_PAYLOADS_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_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, dir[i], STAT_TCP_PAYLOADS_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_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, dir[i], STAT_TCP_PAYLOADS_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_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, dir[i], STAT_TCP_PAYLOADS_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_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, dir[i], STAT_TCP_PAYLOADS_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_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, dir[i], STAT_TCP_PAYLOADS_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_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, dir[i], STAT_TCP_PAYLOADS_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_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, dir[i], STAT_TCP_PAYLOADS_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_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, dir[i], STAT_TCP_PAYLOADS_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) if (i == 0)
{ {
used += snprintf(buff + used, size - used, ","); 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_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(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_TYPE_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_TYPE_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_TYPE_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_S2C, STAT_RAW_PACKETS_RECEIVED) == 0);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt); EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_C2S); EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_C2S);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) == NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) == NULL);
// TCP Segment // TCP Segment
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_TCP_SEGMENTS_RECEIVED) == 1); EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_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_TYPE_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_TYPE_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_TYPE_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_TYPE_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_TYPE_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_TYPE_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_TYPE_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_TYPE_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_TYPE_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_TYPE_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_TYPE_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_TYPE_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_TYPE_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_TYPE_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_TYPE_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_TYPE_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_PAYLOADS_RELEASED) == 0);
EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_TCP_SEGMENTS_RECEIVED) == 0); EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_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_TYPE_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_TYPE_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_TYPE_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_TYPE_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_TYPE_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_TYPE_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_TYPE_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_TYPE_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_TYPE_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_TYPE_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_TYPE_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_TYPE_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_TYPE_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_TYPE_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_TYPE_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_TYPE_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_PAYLOADS_RELEASED) == 0);
session_print(sess); 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_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN); 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_TYPE_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_TYPE_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_TYPE_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_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt); EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_S2C); EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_S2C);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
session_print(sess); session_print(sess);
// check stat // 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_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_RST); 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_TYPE_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_TYPE_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_TYPE_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_S2C, STAT_RAW_PACKETS_RECEIVED) == 0);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt); EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_C2S); EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_C2S);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) == NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) == NULL);
session_print(sess); session_print(sess);
// check stat // 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_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_RST); 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_TYPE_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_TYPE_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_TYPE_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_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt); EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_S2C); EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_S2C);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
session_print(sess); session_print(sess);
// check stat // 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_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN); 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_TYPE_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_TYPE_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_TYPE_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_S2C, STAT_RAW_PACKETS_RECEIVED) == 0);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt); EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_C2S); EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_C2S);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) == NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) == NULL);
session_print(sess); session_print(sess);
// check stat // 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_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_FIN); 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_TYPE_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_TYPE_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_TYPE_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_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt); EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_S2C); EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_S2C);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
session_print(sess); session_print(sess);
// check stat // 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_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(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_TYPE_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_TYPE_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_TYPE_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_S2C, STAT_RAW_PACKETS_RECEIVED) == 0);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt); EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_C2S); EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_C2S);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) == NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) == NULL);
session_print(sess); session_print(sess);
// check stat // 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_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(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_TYPE_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_TYPE_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_TYPE_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_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt); EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_S2C); EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_S2C);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) == NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) == NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
session_print(sess); session_print(sess);
// check stat // 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_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(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_TYPE_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_TYPE_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_TYPE_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_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt); EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_S2C); EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_S2C);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
session_print(sess); session_print(sess);
// check stat // 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_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(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_TYPE_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_TYPE_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_TYPE_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_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt); EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_C2S); EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_C2S);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
session_print(sess); session_print(sess);
// check stat // 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_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(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_TYPE_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_TYPE_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_TYPE_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_S2C, STAT_RAW_PACKETS_RECEIVED) == 0);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt); EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_C2S); EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_C2S);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) == NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) == NULL);
session_print(sess); session_print(sess);
// check stat // 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_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(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_TYPE_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_TYPE_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_TYPE_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_S2C, STAT_RAW_PACKETS_RECEIVED) == 1 + 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt); EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_S2C); EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_S2C);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) == NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) == NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
session_print(sess); session_print(sess);
// check stat // 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_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(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_TYPE_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_TYPE_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_TYPE_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_S2C, STAT_RAW_PACKETS_RECEIVED) == 0);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt); EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_C2S); EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_C2S);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) == NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) == NULL);
session_print(sess); session_print(sess);
// check stat // 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_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(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_TYPE_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_TYPE_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_TYPE_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_S2C, STAT_RAW_PACKETS_RECEIVED) == 1 + 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt); EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_S2C); EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_S2C);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) == NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) == NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
session_print(sess); session_print(sess);
// check stat // 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_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(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_TYPE_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_TYPE_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_TYPE_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_S2C, STAT_RAW_PACKETS_RECEIVED) == 0);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt); EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_C2S); EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_C2S);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) == NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) == NULL);
// S2C SYNACK Packet // S2C SYNACK Packet
printf("\n=> Packet Parse: TCP S2C SYNACK packet\n"); 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_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(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_TYPE_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_TYPE_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_TYPE_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_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt); EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_S2C); EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_S2C);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
// C2S ACK Packet // C2S ACK Packet
printf("\n=> Packet Parse: TCP C2S ACK packet\n"); 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_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(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_TYPE_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_TYPE_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_TYPE_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_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt); EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_C2S); EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_C2S);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
// C2S REQ Packet // C2S REQ Packet
printf("\n=> Packet Parse: TCP C2S REQ packet\n"); 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_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(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_TYPE_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_TYPE_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_TYPE_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_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt); EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_C2S); EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_C2S);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
// S2C ACK Packet // S2C ACK Packet
printf("\n=> Packet Parse: TCP S2C ACK packet\n"); 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_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(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_TYPE_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_TYPE_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_TYPE_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_S2C, STAT_RAW_PACKETS_RECEIVED) == 1 + 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt); EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_S2C); EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_S2C);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
// S2C HTTP Resp Packet1 // S2C HTTP Resp Packet1
printf("\n=> Packet Parse: TCP S2C Resp packet1\n"); 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_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(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_TYPE_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_TYPE_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_TYPE_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_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_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt); EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_S2C); EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_S2C);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
// S2C HTTP Resp Packet2 // S2C HTTP Resp Packet2
printf("\n=> Packet Parse: TCP S2C Resp packet2\n"); 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_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(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_TYPE_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_TYPE_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_TYPE_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_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_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt); EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_S2C); EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_S2C);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
// C2S ACK Packet // C2S ACK Packet
printf("\n=> Packet Parse: TCP C2S ACK packet\n"); 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_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(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_TYPE_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_TYPE_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_TYPE_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_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_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt); EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_C2S); EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_C2S);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
// C2S FIN Packet // C2S FIN Packet
printf("\n=> Packet Parse: TCP C2S FIN packet\n"); 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_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN); 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_TYPE_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_TYPE_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_TYPE_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_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_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt); EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_C2S); EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_C2S);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
// S2C FIN Packet // S2C FIN Packet
printf("\n=> Packet Parse: TCP S2C FIN packet\n"); 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_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN); 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_TYPE_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_TYPE_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_TYPE_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_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_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt); EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_S2C); EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_S2C);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
// C2S ACK Packet // C2S ACK Packet
printf("\n=> Packet Parse: TCP C2S ACK packet\n"); 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_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN); 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_TYPE_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_TYPE_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_TYPE_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_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_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt); EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_C2S); EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_C2S);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
// check stat // check stat
stat = session_manager_stat(mgr); 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_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(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_TYPE_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_TYPE_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_TYPE_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_S2C, STAT_RAW_PACKETS_RECEIVED) == 0);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt); EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_C2S); EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_C2S);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) == NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) == NULL);
session_print(sess); session_print(sess);
// check stat // 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_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(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_TYPE_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_TYPE_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_TYPE_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_S2C, STAT_RAW_PACKETS_RECEIVED) == 1 + 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt); EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_S2C); EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_S2C);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) == NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) == NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
session_print(sess); session_print(sess);
// check stat // 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_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN); 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_TYPE_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_TYPE_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_TYPE_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_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt); EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_S2C); EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_S2C);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
session_print(sess); session_print(sess);
// check stat // 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_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_RST); 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_TYPE_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_TYPE_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_TYPE_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_S2C, STAT_RAW_PACKETS_RECEIVED) == 0);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt); EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_C2S); EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_C2S);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) == NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) == NULL);
session_print(sess); session_print(sess);
// check stat // 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_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_RST); 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_TYPE_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_TYPE_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_TYPE_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_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt); EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_S2C); EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_S2C);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
session_print(sess); session_print(sess);
// check stat // 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_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(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_TYPE_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_TYPE_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_TYPE_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_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt); EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_S2C); EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_S2C);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
session_print(sess); session_print(sess);
// check stat // 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_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(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_TYPE_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_TYPE_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_TYPE_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_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt); EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_C2S); EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_C2S);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
session_print(sess); session_print(sess);
// check stat // 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_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN); 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_TYPE_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_TYPE_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_TYPE_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_S2C, STAT_RAW_PACKETS_RECEIVED) == 0);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt); EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_C2S); EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_C2S);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) == NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) == NULL);
session_print(sess); session_print(sess);
// check stat // 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_get_type(sess) == SESSION_TYPE_TCP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_FIN); 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_TYPE_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_TYPE_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_TYPE_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_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt); EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_S2C); EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_S2C);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
session_print(sess); session_print(sess);
// check stat // 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_get_type(sess) == SESSION_TYPE_UDP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(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_TYPE_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_TYPE_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_TYPE_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_S2C, STAT_RAW_PACKETS_RECEIVED) == 0);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt); EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_C2S); EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_C2S);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) == NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) == NULL);
// S2C RESP Packet // S2C RESP Packet
printf("\n=> Packet Parse: UDP S2C RESP packet\n"); 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_get_type(sess) == SESSION_TYPE_UDP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(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_TYPE_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_TYPE_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_TYPE_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_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt); EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_S2C); EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_S2C);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
session_print(sess); session_print(sess);
// check stat // 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_get_type(sess) == SESSION_TYPE_UDP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(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_TYPE_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_TYPE_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_TYPE_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_S2C, STAT_RAW_PACKETS_RECEIVED) == 0);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt); EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_C2S); EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_C2S);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) == NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) == NULL);
session_print(sess); session_print(sess);
// check stat // 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_get_type(sess) == SESSION_TYPE_UDP);
EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0); EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
EXPECT_TRUE(session_get_closing_reason(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_TYPE_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_TYPE_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_TYPE_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_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST)); EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
EXPECT_TRUE(session_get0_current_packet(sess) == &pkt); EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_S2C); EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_S2C);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) == NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) == NULL);
EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL); EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
session_print(sess); session_print(sess);
// check stat // 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 * 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); enum flow_type type = session_get_flow_type(sess);
assert(dir != FLOW_DIRECTION_NONE); assert(type != FLOW_TYPE_NONE);
int is_ctrl = packet_is_ctrl(pkt); int is_ctrl = packet_is_ctrl(pkt);
uint16_t len = packet_get_raw_len(pkt); uint16_t len = packet_get_raw_len(pkt);
switch (packet_get_action(pkt)) switch (packet_get_action(pkt))
{ {
case PACKET_ACTION_DROP: case PACKET_ACTION_DROP:
session_inc_stat(sess, dir, (is_ctrl ? STAT_CONTROL_PACKETS_DROPPED : STAT_RAW_PACKETS_DROPPED), 1); session_inc_stat(sess, type, (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_BYTES_DROPPED : STAT_RAW_BYTES_DROPPED), len);
break; break;
case PACKET_ACTION_FORWARD: case PACKET_ACTION_FORWARD:
session_inc_stat(sess, dir, (is_ctrl ? STAT_CONTROL_PACKETS_TRANSMITTED : STAT_RAW_PACKETS_TRANSMITTED), 1); session_inc_stat(sess, type, (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_BYTES_TRANSMITTED : STAT_RAW_BYTES_TRANSMITTED), len);
break; break;
default: default:
assert(0); assert(0);
@@ -242,9 +242,9 @@ static void *worker_thread(void *arg)
packet_set_action(pkt, PACKET_ACTION_DROP); 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_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) if (packet_get_action(pkt) == PACKET_ACTION_DROP)

2
infra/version.map
View File

@@ -42,7 +42,7 @@ global:
session_get0_current_packet; session_get0_current_packet;
session_get_closing_reason; session_get_closing_reason;
session_get_direction; session_get_direction;
session_get_current_flow_direction; session_get_flow_type;
session_get_first_packet; session_get_first_packet;
session_get_id; session_get_id;
session_get_timestamp; 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); const struct timeval *tv = packet_get_timeval(pkt);
struct plugin_ctx *ctx = (struct plugin_ctx *)plugin_ctx; struct plugin_ctx *ctx = (struct plugin_ctx *)plugin_ctx;
struct session_exdata *exdata = (struct session_exdata *)session_exdata_get(sess, ctx->sess_exdata_idx); 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_pkts++;
exdata->c2s_rx_bytes += packet_get_raw_len(pkt); 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); const struct timeval *tv = packet_get_timeval(pkt);
struct plugin_ctx *ctx = (struct plugin_ctx *)plugin_ctx; struct plugin_ctx *ctx = (struct plugin_ctx *)plugin_ctx;
struct session_exdata *exdata = (struct session_exdata *)session_exdata_get(sess, ctx->sess_exdata_idx); 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_pkts++;
exdata->c2s_rx_bytes += packet_get_raw_len(pkt); 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); debug_plugin_log(ctx->fd, "debug plugin", "on TCP stream msg: %s", buff);
pthread_spin_lock(&ctx->lock); 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); 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); 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: 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 = {}; hstring tunnel_payload = {};
http_tunnel_message_get_payload((const struct http_tunnel_message *)raw_msg, &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_block++;
req_payload_size += tunnel_payload.iov_len; 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] [packet_inject]
filter_ip = any # eg: 2001:db8::1, 192.168.1.100, any filter_ip = any # eg: 2001:db8::1, 192.168.1.100, any
filter_port = 0 # eg: 80, 443 (0 for 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 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 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] [packet_inject]
filter_ip = any # eg: 2001:db8::1, 192.168.1.100, any filter_ip = any # eg: 2001:db8::1, 192.168.1.100, any
filter_port = 0 # eg: 80, 443 (0 for 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 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 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] [packet_inject]
filter_ip = any # eg: 2001:db8::1, 192.168.1.100, any filter_ip = any # eg: 2001:db8::1, 192.168.1.100, any
filter_port = 0 # eg: 80, 443 (0 for 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 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 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] [packet_inject]
filter_ip = any # eg: 2001:db8::1, 192.168.1.100, any filter_ip = any # eg: 2001:db8::1, 192.168.1.100, any
filter_port = 0 # eg: 80, 443 (0 for 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 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 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] [packet_inject]
filter_ip = any # eg: 2001:db8::1, 192.168.1.100, any filter_ip = any # eg: 2001:db8::1, 192.168.1.100, any
filter_port = 0 # eg: 80, 443 (0 for 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 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 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] [packet_inject]
filter_ip = any # eg: 2001:db8::1, 192.168.1.100, any filter_ip = any # eg: 2001:db8::1, 192.168.1.100, any
filter_port = 0 # eg: 80, 443 (0 for 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 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 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] [packet_inject]
filter_ip = any # eg: 2001:db8::1, 192.168.1.100, any filter_ip = any # eg: 2001:db8::1, 192.168.1.100, any
filter_port = 0 # eg: 80, 443 (0 for 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 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 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; struct sockaddr_in6 v6;
} addr; } addr;
uint16_t port; uint16_t port;
uint64_t number; // inject packet after (C2S/S2C) direction receiving n packets uint64_t number; // inject packet after (C2S/S2C) flow_type receiving n packets
enum inject_type type; enum inject_type inject_type;
enum flow_direction direction; enum flow_type flow_type;
}; };
struct inject_plugin_ctx struct inject_plugin_ctx
@@ -53,7 +53,7 @@ struct inject_plugin_ctx
struct packet_exdata struct packet_exdata
{ {
enum flow_direction flow_dir; enum flow_type flow_type;
union union
{ {
@@ -161,23 +161,23 @@ static int load_config(struct logger *logger, struct config *config, const char
} }
config->port = atoi(ptr); config->port = atoi(ptr);
ptr = toml_raw_in(sub, "filter_dir"); ptr = toml_raw_in(sub, "flow_type");
if (ptr == NULL) 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; goto error_out;
} }
if (strcmp(ptr, "C2S") == 0) if (strcmp(ptr, "C2S") == 0)
{ {
config->direction = FLOW_DIRECTION_C2S; config->flow_type = FLOW_TYPE_C2S;
} }
else if (strcmp(ptr, "S2C") == 0) else if (strcmp(ptr, "S2C") == 0)
{ {
config->direction = FLOW_DIRECTION_S2C; config->flow_type = FLOW_TYPE_S2C;
} }
else 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; 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) if (strcmp(ptr, "TCP-RST") == 0)
{ {
config->type = INJECT_TCP_RST; config->inject_type = INJECT_TCP_RST;
} }
else if (strcmp(ptr, "TCP-FIN") == 0) 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) 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) 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) 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) else if (strcmp(ptr, "CTRL-MSG") == 0)
{ {
config->type = INJECT_CTRL_MSG; config->inject_type = INJECT_CTRL_MSG;
} }
else 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; 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_ip : %s", addr_str);
INJTECT_PLUGIN_LOG_INFO(logger, "config->filter_port : %d", config->port); 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->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 * 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)); memset(pkt_exdata, 0, sizeof(struct packet_exdata));
pkt_exdata->flow_dir = dir; pkt_exdata->flow_type = type;
int get_inner_addr = 0; int get_inner_addr = 0;
int count = packet_get_layer_count(pkt); 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, 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) 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; 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, 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_seq = 0;
uint32_t tcp_ack = 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 * 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_seq = current_packet_seq
* tcp_ack = current_packet_ack * 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_seq = current_packet_ack
* tcp_ack = current_packet_seq + current_packet_payload_len * tcp_ack = current_packet_seq + current_packet_payload_len
* or if current packet is a SYN-ACK packet * 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 * 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_seq = uint32_add(pkt_exdata->tcp_seq, pkt_exdata->inc_seq);
tcp_ack = pkt_exdata->tcp_ack; 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 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) 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; 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 packet *pkt = (struct packet *)msg;
struct inject_plugin_ctx *ctx = (struct inject_plugin_ctx *)plugin_ctx; struct inject_plugin_ctx *ctx = (struct inject_plugin_ctx *)plugin_ctx;
struct config *config = &ctx->config; 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)", INJTECT_PLUGIN_LOG_INFO(ctx->logger, "handle session msg: %s (C2S received packets: %lu, S2C received packets: %lu)",
session_get0_readable_addr(sess), session_get0_readable_addr(sess),
session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED), session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED),
session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED)); session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED));
struct packet_exdata pkt_exdata; 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 && if (config->family == AF_INET &&
memcmp(&config->addr.v4, &pkt_exdata.src_addr.v4, sizeof(struct in_addr)) != 0 && 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; return;
} }
if (session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_INJECTED_PACKETS_SUCCESS) > 0 || if (session_get_stat(sess, FLOW_TYPE_C2S, STAT_INJECTED_PACKETS_SUCCESS) > 0 ||
session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_INJECTED_PACKETS_SUCCESS) > 0) session_get_stat(sess, FLOW_TYPE_S2C, STAT_INJECTED_PACKETS_SUCCESS) > 0)
{ {
return; 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; 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; return;
} }
switch (config->type) switch (config->inject_type)
{ {
case INJECT_TCP_RST: 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_TYPE_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_S2C, TH_RST | TH_ACK, NULL, 0);
session_set_discard(sess); session_set_discard(sess);
break; break;
case INJECT_TCP_FIN: 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_TYPE_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_S2C, TH_FIN | TH_ACK, NULL, 0);
session_set_discard(sess); session_set_discard(sess);
break; break;
case INJECT_TCP_PAYLOAD: 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"); 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_TYPE_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_TYPE_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_TYPE_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_C2S, TH_RST | TH_ACK, NULL, 0); // inject RST to server
session_set_discard(sess); session_set_discard(sess);
break; break;
case INJECT_TCP_PAYLOAD_FIN_RST: 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"); 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_TYPE_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_TYPE_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_TYPE_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_TYPE_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_TYPE_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_C2S, TH_RST | TH_ACK, NULL, 0); // inject RST to server
session_set_discard(sess); session_set_discard(sess);
break; break;
case INJECT_UDP_PAYLOAD: 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_TYPE_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_S2C, "Hello Client", 12);
session_set_discard(sess); session_set_discard(sess);
break; break;
case INJECT_CTRL_MSG: case INJECT_CTRL_MSG: