diff --git a/decoders/http/http_decoder.c b/decoders/http/http_decoder.c
index e30f459..5e2db72 100644
--- a/decoders/http/http_decoder.c
+++ b/decoders/http/http_decoder.c
@@ -128,7 +128,7 @@ static void http_event_handler(enum http_event event, struct http_decoder_half_d
     case HTTP_EVENT_REQ_LINE:
         msg = http_message_new(HTTP_MESSAGE_REQ_LINE, queue, queue_idx, HTTP_REQUEST);
         session_mq_publish_message(ev_ctx->ref_session, exdata->pub_topic_id, msg);
-        if (httpd_tunnel_identify(httpd_env, FLOW_DIRECTION_C2S, half_data))
+        if (httpd_tunnel_identify(httpd_env, FLOW_TYPE_C2S, half_data))
         {
             exdata->tunnel_state = HTTP_TUN_C2S_HDR_START;
             // http_decoder_stat_update(&httpd_env->hd_stat, thread_id, HTTPD_STAT_TUNNEL, 1);
@@ -259,7 +259,7 @@ static void http_event_handler(enum http_event event, struct http_decoder_half_d
     case HTTP_EVENT_RES_LINE:
         msg = http_message_new(HTTP_MESSAGE_RES_LINE, queue, queue_idx, HTTP_RESPONSE);
         session_mq_publish_message(ev_ctx->ref_session, exdata->pub_topic_id, msg);
-        if (httpd_tunnel_identify(httpd_env, FLOW_DIRECTION_S2C, half_data))
+        if (httpd_tunnel_identify(httpd_env, FLOW_TYPE_S2C, half_data))
         {
             exdata->tunnel_state = HTTP_TUN_S2C_START;
         }
@@ -668,8 +668,8 @@ extern "C"
 
         int thread_id = stellar_get_current_thread_index();
         struct http_decoder_half *cur_half = NULL;
-        enum flow_direction sess_dir = session_get_current_flow_direction(sess);
-        if (FLOW_DIRECTION_C2S == sess_dir)
+        enum flow_type sess_dir = session_get_flow_type(sess);
+        if (FLOW_TYPE_C2S == sess_dir)
         {
             cur_half = exdata->decoder->c2s_half;
             http_decoder_stat_update(&httpd_env->hd_stat, thread_id, HTTP_C2S_BYTES, payload_len);
diff --git a/decoders/http/http_decoder_tunnel.c b/decoders/http/http_decoder_tunnel.c
index 6396051..a6abda8 100644
--- a/decoders/http/http_decoder_tunnel.c
+++ b/decoders/http/http_decoder_tunnel.c
@@ -19,7 +19,7 @@ int httpd_tunnel_identify(struct http_decoder_env *httpd_env, int curdir, struct
         return 0;
     }
 
-    if (FLOW_DIRECTION_C2S == curdir)
+    if (FLOW_TYPE_C2S == curdir)
     {
         struct http_request_line reqline = {};
         http_decoder_half_data_get_request_line(hfdata, &reqline);
diff --git a/decoders/http/http_decoder_utils.c b/decoders/http/http_decoder_utils.c
index 10162d4..08c66b0 100644
--- a/decoders/http/http_decoder_utils.c
+++ b/decoders/http/http_decoder_utils.c
@@ -110,8 +110,8 @@ int http_message_type_is_req(struct session *sess, enum http_message_type msg_ty
     case HTTP_TRANSACTION_START:
     case HTTP_TRANSACTION_END:
     {
-        enum flow_direction cur_dir = session_get_current_flow_direction(sess);
-        if (FLOW_DIRECTION_C2S == cur_dir)
+        enum flow_type cur_dir = session_get_flow_type(sess);
+        if (FLOW_TYPE_C2S == cur_dir)
         {
             is_req_msg = 1;
         }
@@ -233,9 +233,9 @@ int httpd_url_is_encoded(const char *url, size_t len)
     return 0;
 }
 
-static void httpd_set_tcp_addr(const struct tcphdr *tcph, struct httpd_session_addr *addr, enum flow_direction fdir)
+static void httpd_set_tcp_addr(const struct tcphdr *tcph, struct httpd_session_addr *addr, enum flow_type fdir)
 {
-    if (FLOW_DIRECTION_C2S == fdir)
+    if (FLOW_TYPE_C2S == fdir)
     {
         addr->sport = tcph->th_sport;
         addr->dport = tcph->th_dport;
@@ -246,10 +246,10 @@ static void httpd_set_tcp_addr(const struct tcphdr *tcph, struct httpd_session_a
         addr->dport = tcph->th_sport;
     }
 }
-static void httpd_set_ipv4_addr(const struct ip *ip4h, struct httpd_session_addr *addr, enum flow_direction fdir)
+static void httpd_set_ipv4_addr(const struct ip *ip4h, struct httpd_session_addr *addr, enum flow_type fdir)
 {
     addr->ipver = 4;
-    if (FLOW_DIRECTION_C2S == fdir)
+    if (FLOW_TYPE_C2S == fdir)
     {
         addr->saddr4 = ip4h->ip_src.s_addr;
         addr->daddr4 = ip4h->ip_dst.s_addr;
@@ -260,10 +260,10 @@ static void httpd_set_ipv4_addr(const struct ip *ip4h, struct httpd_session_addr
         addr->daddr4 = ip4h->ip_src.s_addr;
     }
 }
-static void httpd_set_ipv6_addr(const struct ip6_hdr *ip6h, struct httpd_session_addr *addr, enum flow_direction fdir)
+static void httpd_set_ipv6_addr(const struct ip6_hdr *ip6h, struct httpd_session_addr *addr, enum flow_type fdir)
 {
     addr->ipver = 6;
-    if (FLOW_DIRECTION_C2S == fdir)
+    if (FLOW_TYPE_C2S == fdir)
     {
         memcpy(&addr->saddr6, &ip6h->ip6_src, sizeof(struct in6_addr));
         memcpy(&addr->daddr6, &ip6h->ip6_dst, sizeof(struct in6_addr));
@@ -281,7 +281,7 @@ void httpd_session_get_addr(const struct session *sess, struct httpd_session_add
     {
         return;
     }
-    enum flow_direction fdir = session_get_current_flow_direction(sess);
+    enum flow_type fdir = session_get_flow_type(sess);
     const struct packet *raw_pkt = session_get_first_packet(sess, fdir);
     if (NULL == raw_pkt)
     {
diff --git a/decoders/lpi/lpi_plugin.cpp b/decoders/lpi/lpi_plugin.cpp
index f927456..7591a90 100644
--- a/decoders/lpi/lpi_plugin.cpp
+++ b/decoders/lpi/lpi_plugin.cpp
@@ -152,8 +152,8 @@ static void get_host_order_port(struct session *sess __unused, unsigned short *s
 //get host order port from stellar session api
 
 	const struct packet *pkt = session_get0_current_packet(sess);
-	enum flow_direction flow_dir=session_get_current_flow_direction(sess);
-	if(pkt && (flow_dir==FLOW_DIRECTION_C2S || flow_dir==FLOW_DIRECTION_S2C))
+	enum flow_type flow_type=session_get_flow_type(sess);
+	if(pkt && (flow_type==FLOW_TYPE_C2S || flow_type==FLOW_TYPE_S2C))
 	{
 		int layer_cnt=packet_get_layer_count(pkt);
 		const struct layer *layer = packet_get_layer_by_idx(pkt, layer_cnt - 1);
@@ -168,7 +168,7 @@ static void get_host_order_port(struct session *sess __unused, unsigned short *s
 			*dport = ntohs(layer->hdr.udp->uh_dport);
 		}
 		//S2C, swap sport and dport
-        if(flow_dir == FLOW_DIRECTION_S2C)
+        if(flow_type == FLOW_TYPE_S2C)
         {
             unsigned short tmp = *sport;
             *sport = *dport;
@@ -539,10 +539,10 @@ static int lpi_detector(struct session *sess, struct traffic_context *context, s
 	struct l7_protocol_label *l7_protocol=NULL;
 	//const struct packet *raw_packet=session_get0_current_packet(sess);
 	//int cur_pkt_dir= packet_get_direction(raw_packet);  
-	int cur_pkt_dir=session_get_current_flow_direction(sess);
+	int cur_pkt_dir=session_get_flow_type(sess);
 	context->pkt_cnt++;
-	(cur_pkt_dir==FLOW_DIRECTION_C2S) ? (context->c2s_pkt++) : (context->s2c_pkt++);
-	int is_c2s_pkt=((cur_pkt_dir==FLOW_DIRECTION_C2S) ? 1 : 0);
+	(cur_pkt_dir==FLOW_TYPE_C2S) ? (context->c2s_pkt++) : (context->s2c_pkt++);
+	int is_c2s_pkt=((cur_pkt_dir==FLOW_TYPE_C2S) ? 1 : 0);
 	ret=lpi_update_dpkt(&(context->lpi_data), sess, scan_data, scan_data_len, l4_proto, is_c2s_pkt);
 	if(!ret)
 	{
@@ -560,7 +560,7 @@ static int lpi_detector(struct session *sess, struct traffic_context *context, s
 	{
 		ret=revise_lpi_result(sess, scan_data, scan_data_len, &modify_lpi_result, context, 
 							(l4_proto==6?1:0), 
-							(cur_pkt_dir==FLOW_DIRECTION_C2S?1:0));
+							(cur_pkt_dir==FLOW_TYPE_C2S?1:0));
 		if(ret==0)
 		{
 			return 1;
@@ -569,7 +569,7 @@ static int lpi_detector(struct session *sess, struct traffic_context *context, s
 		plpi_mod=&modify_lpi_result;
 	}
 
-	if (plpi_mod->protocol == LPI_PROTO_FTP_CONTROL && context->is_first_payload == 1 && cur_pkt_dir == FLOW_DIRECTION_S2C)
+	if (plpi_mod->protocol == LPI_PROTO_FTP_CONTROL && context->is_first_payload == 1 && cur_pkt_dir == FLOW_TYPE_S2C)
 	{
 		if ((((scan_data_len >= 4 && (memcmp(scan_data, "220-", 4) == 0)) || memcmp(scan_data, "220 ", 4) == 0)) &&
 			(((scan_data_len >= 7 && (memmem(scan_data, scan_data_len, " ESMTP ", 7) != NULL)) ||
@@ -585,7 +585,7 @@ static int lpi_detector(struct session *sess, struct traffic_context *context, s
 		}
 	}
 
-	if (plpi_mod->protocol == LPI_PROTO_SMTP && context->is_first_payload == 1 && cur_pkt_dir == FLOW_DIRECTION_S2C)
+	if (plpi_mod->protocol == LPI_PROTO_SMTP && context->is_first_payload == 1 && cur_pkt_dir == FLOW_TYPE_S2C)
 	{
 		if (
 			(scan_data_len >= 4) &&
diff --git a/include/stellar/session.h b/include/stellar/session.h
index 5a2567a..e8cfbc1 100644
--- a/include/stellar/session.h
+++ b/include/stellar/session.h
@@ -32,12 +32,12 @@ enum session_direction
     SESSION_DIRECTION_OUTBOUND = 1,
 };
 
-enum flow_direction
+enum flow_type
 {
-    FLOW_DIRECTION_NONE = -1,
-    FLOW_DIRECTION_C2S = 0,
-    FLOW_DIRECTION_S2C = 1,
-    MAX_FLOW_DIRECTION = 2,
+    FLOW_TYPE_NONE = -1,
+    FLOW_TYPE_C2S = 0,
+    FLOW_TYPE_S2C = 1,
+    MAX_FLOW_TYPE = 2,
 };
 
 enum closing_reason
@@ -135,11 +135,11 @@ const struct packet *session_get0_current_packet(const struct session *sess);
 
 enum closing_reason session_get_closing_reason(const struct session *sess);
 enum session_direction session_get_direction(const struct session *sess);
-enum flow_direction session_get_current_flow_direction(const struct session *sess);
-const struct packet *session_get_first_packet(const struct session *sess, enum flow_direction dir);
+enum flow_type session_get_flow_type(const struct session *sess);
+const struct packet *session_get_first_packet(const struct session *sess, enum flow_type type);
 uint64_t session_get_id(const struct session *sess);
 uint64_t session_get_timestamp(const struct session *sess, enum session_timestamp type);
-uint64_t session_get_stat(const struct session *sess, enum flow_direction dir, enum session_stat stat);
+uint64_t session_get_stat(const struct session *sess, enum flow_type type, enum session_stat stat);
 
 const char *session_get0_readable_addr(const struct session *sess);
 
diff --git a/infra/session_manager/session_manager.c b/infra/session_manager/session_manager.c
index 69418ea..ac78cd0 100644
--- a/infra/session_manager/session_manager.c
+++ b/infra/session_manager/session_manager.c
@@ -165,15 +165,15 @@ static uint64_t snowflake_generate(struct snowflake *sf, uint64_t now_sec)
 
 static void tcp_clean(struct session_manager *mgr, struct session *sess)
 {
-     struct tcp_reassembly *c2s_ssembler = sess->tcp_halfs[FLOW_DIRECTION_C2S].assembler;
-     struct tcp_reassembly *s2c_ssembler = sess->tcp_halfs[FLOW_DIRECTION_S2C].assembler;
+     struct tcp_reassembly *c2s_ssembler = sess->tcp_halfs[FLOW_TYPE_C2S].assembler;
+     struct tcp_reassembly *s2c_ssembler = sess->tcp_halfs[FLOW_TYPE_S2C].assembler;
      struct tcp_segment *seg;
      if (c2s_ssembler)
      {
           while ((seg = tcp_reassembly_expire(c2s_ssembler, UINT64_MAX)))
           {
-               session_inc_stat(sess, FLOW_DIRECTION_C2S, STAT_TCP_SEGMENTS_RELEASED, 1);
-               session_inc_stat(sess, FLOW_DIRECTION_C2S, STAT_TCP_PAYLOADS_RELEASED, seg->len);
+               session_inc_stat(sess, FLOW_TYPE_C2S, STAT_TCP_SEGMENTS_RELEASED, 1);
+               session_inc_stat(sess, FLOW_TYPE_C2S, STAT_TCP_PAYLOADS_RELEASED, seg->len);
                mgr->stat.tcp_segs_freed++;
                tcp_segment_free(seg);
           }
@@ -183,8 +183,8 @@ static void tcp_clean(struct session_manager *mgr, struct session *sess)
      {
           while ((seg = tcp_reassembly_expire(s2c_ssembler, UINT64_MAX)))
           {
-               session_inc_stat(sess, FLOW_DIRECTION_S2C, STAT_TCP_SEGMENTS_RELEASED, 1);
-               session_inc_stat(sess, FLOW_DIRECTION_S2C, STAT_TCP_PAYLOADS_RELEASED, seg->len);
+               session_inc_stat(sess, FLOW_TYPE_S2C, STAT_TCP_SEGMENTS_RELEASED, 1);
+               session_inc_stat(sess, FLOW_TYPE_S2C, STAT_TCP_PAYLOADS_RELEASED, seg->len);
                mgr->stat.tcp_segs_freed++;
                tcp_segment_free(seg);
           }
@@ -199,9 +199,9 @@ static int tcp_init(struct session_manager *mgr, struct session *sess)
           return 0;
      }
 
-     sess->tcp_halfs[FLOW_DIRECTION_C2S].assembler = tcp_reassembly_new(mgr->cfg.tcp_reassembly.timeout_ms, mgr->cfg.tcp_reassembly.buffered_segments_max);
-     sess->tcp_halfs[FLOW_DIRECTION_S2C].assembler = tcp_reassembly_new(mgr->cfg.tcp_reassembly.timeout_ms, mgr->cfg.tcp_reassembly.buffered_segments_max);
-     if (sess->tcp_halfs[FLOW_DIRECTION_C2S].assembler == NULL || sess->tcp_halfs[FLOW_DIRECTION_S2C].assembler == NULL)
+     sess->tcp_halfs[FLOW_TYPE_C2S].assembler = tcp_reassembly_new(mgr->cfg.tcp_reassembly.timeout_ms, mgr->cfg.tcp_reassembly.buffered_segments_max);
+     sess->tcp_halfs[FLOW_TYPE_S2C].assembler = tcp_reassembly_new(mgr->cfg.tcp_reassembly.timeout_ms, mgr->cfg.tcp_reassembly.buffered_segments_max);
+     if (sess->tcp_halfs[FLOW_TYPE_C2S].assembler == NULL || sess->tcp_halfs[FLOW_TYPE_S2C].assembler == NULL)
      {
           tcp_clean(mgr, sess);
           return -1;
@@ -209,17 +209,17 @@ static int tcp_init(struct session_manager *mgr, struct session *sess)
 
      SESSION_LOG_DEBUG("session %lu %s new c2s tcp assembler %p, s2c tcp assembler %p",
                        session_get_id(sess), session_get0_readable_addr(sess),
-                       sess->tcp_halfs[FLOW_DIRECTION_C2S].assembler,
-                       sess->tcp_halfs[FLOW_DIRECTION_S2C].assembler);
+                       sess->tcp_halfs[FLOW_TYPE_C2S].assembler,
+                       sess->tcp_halfs[FLOW_TYPE_S2C].assembler);
 
      return 0;
 }
 
-static void tcp_update(struct session_manager *mgr, struct session *sess, enum flow_direction dir, const struct layer_private *tcp_layer)
+static void tcp_update(struct session_manager *mgr, struct session *sess, enum flow_type type, const struct layer_private *tcp_layer)
 {
      struct tcp_segment *seg;
      struct tcphdr *hdr = (struct tcphdr *)tcp_layer->hdr_ptr;
-     struct tcp_half *half = &sess->tcp_halfs[dir];
+     struct tcp_half *half = &sess->tcp_halfs[type];
      uint8_t flags = tcp_hdr_get_flags(hdr);
      uint16_t len = tcp_layer->pld_len;
 
@@ -237,12 +237,12 @@ static void tcp_update(struct session_manager *mgr, struct session *sess, enum f
      {
           if (len)
           {
-               session_inc_stat(sess, dir, STAT_TCP_SEGMENTS_RECEIVED, 1);
-               session_inc_stat(sess, dir, STAT_TCP_PAYLOADS_RECEIVED, len);
+               session_inc_stat(sess, type, STAT_TCP_SEGMENTS_RECEIVED, 1);
+               session_inc_stat(sess, type, STAT_TCP_PAYLOADS_RECEIVED, len);
                mgr->stat.tcp_segs_input++;
 
-               session_inc_stat(sess, dir, STAT_TCP_SEGMENTS_INORDER, 1);
-               session_inc_stat(sess, dir, STAT_TCP_PAYLOADS_INORDER, len);
+               session_inc_stat(sess, type, STAT_TCP_SEGMENTS_INORDER, 1);
+               session_inc_stat(sess, type, STAT_TCP_PAYLOADS_INORDER, len);
                mgr->stat.tcp_segs_inorder++;
 
                half->in_order.data = tcp_layer->pld_ptr;
@@ -261,12 +261,12 @@ static void tcp_update(struct session_manager *mgr, struct session *sess, enum f
      seg = tcp_reassembly_expire(half->assembler, mgr->now_ms);
      if (seg)
      {
-          session_inc_stat(sess, dir, STAT_TCP_SEGMENTS_EXPIRED, 1);
-          session_inc_stat(sess, dir, STAT_TCP_PAYLOADS_EXPIRED, seg->len);
+          session_inc_stat(sess, type, STAT_TCP_SEGMENTS_EXPIRED, 1);
+          session_inc_stat(sess, type, STAT_TCP_PAYLOADS_EXPIRED, seg->len);
           mgr->stat.tcp_segs_timeout++;
 
-          session_inc_stat(sess, dir, STAT_TCP_SEGMENTS_RELEASED, 1);
-          session_inc_stat(sess, dir, STAT_TCP_PAYLOADS_RELEASED, seg->len);
+          session_inc_stat(sess, type, STAT_TCP_SEGMENTS_RELEASED, 1);
+          session_inc_stat(sess, type, STAT_TCP_PAYLOADS_RELEASED, seg->len);
           mgr->stat.tcp_segs_freed++;
 
           tcp_segment_free(seg);
@@ -274,16 +274,16 @@ static void tcp_update(struct session_manager *mgr, struct session *sess, enum f
 
      if (len)
      {
-          session_inc_stat(sess, dir, STAT_TCP_SEGMENTS_RECEIVED, 1);
-          session_inc_stat(sess, dir, STAT_TCP_PAYLOADS_RECEIVED, len);
+          session_inc_stat(sess, type, STAT_TCP_SEGMENTS_RECEIVED, 1);
+          session_inc_stat(sess, type, STAT_TCP_PAYLOADS_RECEIVED, len);
           mgr->stat.tcp_segs_input++;
 
           uint32_t rcv_nxt = tcp_reassembly_get_recv_next(half->assembler);
           // in order
           if (half->seq == rcv_nxt)
           {
-               session_inc_stat(sess, dir, STAT_TCP_SEGMENTS_INORDER, 1);
-               session_inc_stat(sess, dir, STAT_TCP_PAYLOADS_INORDER, len);
+               session_inc_stat(sess, type, STAT_TCP_SEGMENTS_INORDER, 1);
+               session_inc_stat(sess, type, STAT_TCP_PAYLOADS_INORDER, len);
                mgr->stat.tcp_segs_inorder++;
 
                half->in_order.data = tcp_layer->pld_ptr;
@@ -294,8 +294,8 @@ static void tcp_update(struct session_manager *mgr, struct session *sess, enum f
           // retransmission
           else if (uint32_before(uint32_add(half->seq, len), rcv_nxt))
           {
-               session_inc_stat(sess, dir, STAT_TCP_SEGMENTS_RETRANSMIT, 1);
-               session_inc_stat(sess, dir, STAT_TCP_PAYLOADS_RETRANSMIT, len);
+               session_inc_stat(sess, type, STAT_TCP_SEGMENTS_RETRANSMIT, 1);
+               session_inc_stat(sess, type, STAT_TCP_PAYLOADS_RETRANSMIT, len);
                mgr->stat.tcp_segs_retransmited++;
           }
           else if ((seg = tcp_segment_new(half->seq, tcp_layer->pld_ptr, len)))
@@ -303,29 +303,29 @@ static void tcp_update(struct session_manager *mgr, struct session *sess, enum f
                switch (tcp_reassembly_push(half->assembler, seg, mgr->now_ms))
                {
                case -2:
-                    session_inc_stat(sess, dir, STAT_TCP_SEGMENTS_RETRANSMIT, 1);
-                    session_inc_stat(sess, dir, STAT_TCP_PAYLOADS_RETRANSMIT, len);
+                    session_inc_stat(sess, type, STAT_TCP_SEGMENTS_RETRANSMIT, 1);
+                    session_inc_stat(sess, type, STAT_TCP_PAYLOADS_RETRANSMIT, len);
                     mgr->stat.tcp_segs_retransmited++;
                     tcp_segment_free(seg);
                     break;
                case -1:
-                    session_inc_stat(sess, dir, STAT_TCP_SEGMENTS_NOSPACE, 1);
-                    session_inc_stat(sess, dir, STAT_TCP_PAYLOADS_NOSPACE, len);
+                    session_inc_stat(sess, type, STAT_TCP_SEGMENTS_NOSPACE, 1);
+                    session_inc_stat(sess, type, STAT_TCP_PAYLOADS_NOSPACE, len);
                     mgr->stat.tcp_segs_omitted_too_many++;
                     tcp_segment_free(seg);
                     break;
                case 0:
-                    session_inc_stat(sess, dir, STAT_TCP_SEGMENTS_BUFFERED, 1);
-                    session_inc_stat(sess, dir, STAT_TCP_PAYLOADS_BUFFERED, len);
+                    session_inc_stat(sess, type, STAT_TCP_SEGMENTS_BUFFERED, 1);
+                    session_inc_stat(sess, type, STAT_TCP_PAYLOADS_BUFFERED, len);
                     mgr->stat.tcp_segs_buffered++;
                     break;
                case 1:
-                    session_inc_stat(sess, dir, STAT_TCP_SEGMENTS_OVERLAP, 1);
-                    session_inc_stat(sess, dir, STAT_TCP_PAYLOADS_OVERLAP, len);
+                    session_inc_stat(sess, type, STAT_TCP_SEGMENTS_OVERLAP, 1);
+                    session_inc_stat(sess, type, STAT_TCP_PAYLOADS_OVERLAP, len);
                     mgr->stat.tcp_segs_overlapped++;
 
-                    session_inc_stat(sess, dir, STAT_TCP_SEGMENTS_BUFFERED, 1);
-                    session_inc_stat(sess, dir, STAT_TCP_PAYLOADS_BUFFERED, len);
+                    session_inc_stat(sess, type, STAT_TCP_SEGMENTS_BUFFERED, 1);
+                    session_inc_stat(sess, type, STAT_TCP_PAYLOADS_BUFFERED, len);
                     mgr->stat.tcp_segs_buffered++;
                     break;
                default:
@@ -335,8 +335,8 @@ static void tcp_update(struct session_manager *mgr, struct session *sess, enum f
           }
           else
           {
-               session_inc_stat(sess, dir, STAT_TCP_SEGMENTS_NOSPACE, 1);
-               session_inc_stat(sess, dir, STAT_TCP_PAYLOADS_NOSPACE, len);
+               session_inc_stat(sess, type, STAT_TCP_SEGMENTS_NOSPACE, 1);
+               session_inc_stat(sess, type, STAT_TCP_PAYLOADS_NOSPACE, len);
                mgr->stat.tcp_segs_omitted_too_many++;
           }
      }
@@ -346,33 +346,33 @@ static void tcp_update(struct session_manager *mgr, struct session *sess, enum f
  * session direction identify
  ******************************************************************************/
 
-static enum flow_direction identify_direction_by_port(uint16_t src_port, uint16_t dst_port)
+static enum flow_type identify_flow_type_by_port(uint16_t src_port, uint16_t dst_port)
 {
      // big port is client
      if (src_port > dst_port)
      {
-          return FLOW_DIRECTION_C2S;
+          return FLOW_TYPE_C2S;
      }
      else if (src_port < dst_port)
      {
-          return FLOW_DIRECTION_S2C;
+          return FLOW_TYPE_S2C;
      }
      else
      {
           // if port is equal, first packet is C2S
-          return FLOW_DIRECTION_C2S;
+          return FLOW_TYPE_C2S;
      }
 }
 
-static enum flow_direction identify_direction_by_history(const struct session *sess, const struct tuple6 *key)
+static enum flow_type identify_flow_type_by_history(const struct session *sess, const struct tuple6 *key)
 {
      if (tuple6_cmp(session_get_tuple6(sess), key) == 0)
      {
-          return FLOW_DIRECTION_C2S;
+          return FLOW_TYPE_C2S;
      }
      else
      {
-          return FLOW_DIRECTION_S2C;
+          return FLOW_TYPE_S2C;
      }
 }
 
@@ -420,13 +420,13 @@ static int duplicated_packet_bypass(struct session_manager *mgr, struct session
           return 0;
      }
 
-     enum flow_direction dir = identify_direction_by_history(sess, key);
-     if (session_get_stat(sess, dir, STAT_RAW_PACKETS_RECEIVED) < 3 || session_has_duplicate_traffic(sess))
+     enum flow_type type = identify_flow_type_by_history(sess, key);
+     if (session_get_stat(sess, type, STAT_RAW_PACKETS_RECEIVED) < 3 || session_has_duplicate_traffic(sess))
      {
           if (packet_filter_lookup(mgr->dup_pkt_filter, pkt, mgr->now_ms))
           {
-               session_inc_stat(sess, dir, STAT_DUPLICATE_PACKETS_BYPASS, 1);
-               session_inc_stat(sess, dir, STAT_DUPLICATE_BYTES_BYPASS, packet_get_raw_len(pkt));
+               session_inc_stat(sess, type, STAT_DUPLICATE_PACKETS_BYPASS, 1);
+               session_inc_stat(sess, type, STAT_DUPLICATE_BYTES_BYPASS, packet_get_raw_len(pkt));
                switch (session_get_type(sess))
                {
                case SESSION_TYPE_TCP:
@@ -442,7 +442,7 @@ static int duplicated_packet_bypass(struct session_manager *mgr, struct session
                session_set_duplicate_traffic(sess);
 
                session_set_current_packet(sess, pkt);
-               session_set_current_flow_direction(sess, dir);
+               session_set_flow_type(sess, type);
                return 1;
           }
           else
@@ -459,14 +459,14 @@ static int duplicated_packet_bypass(struct session_manager *mgr, struct session
  * session manager utils
  ******************************************************************************/
 
-static void session_update(struct session_manager *mgr, struct session *sess, enum session_state next_state, const struct packet *pkt, const struct tuple6 *key, enum flow_direction dir)
+static void session_update(struct session_manager *mgr, struct session *sess, enum session_state next_state, const struct packet *pkt, const struct tuple6 *key, enum flow_type type)
 {
      if (session_get_current_state(sess) == SESSION_STATE_INIT)
      {
           uint64_t sess_id = snowflake_generate(mgr->sf, mgr->now_ms / 1000);
           session_set_id(sess, sess_id);
           enum packet_direction pkt_dir = packet_get_direction(pkt);
-          if (dir == FLOW_DIRECTION_C2S)
+          if (type == FLOW_TYPE_C2S)
           {
                session_set_tuple6(sess, key);
                if (pkt_dir == PACKET_DIRECTION_OUTGOING) // Internal -> External
@@ -510,18 +510,18 @@ static void session_update(struct session_manager *mgr, struct session *sess, en
           }
      }
 
-     session_inc_stat(sess, dir, STAT_RAW_PACKETS_RECEIVED, 1);
-     session_inc_stat(sess, dir, STAT_RAW_BYTES_RECEIVED, packet_get_raw_len(pkt));
+     session_inc_stat(sess, type, STAT_RAW_PACKETS_RECEIVED, 1);
+     session_inc_stat(sess, type, STAT_RAW_BYTES_RECEIVED, packet_get_raw_len(pkt));
 
-     if (!session_get_first_packet(sess, dir))
+     if (!session_get_first_packet(sess, type))
      {
-          session_set_first_packet(sess, dir, packet_dup(pkt));
-          session_set_route_ctx(sess, dir, packet_get_route_ctx(pkt));
-          session_set_sids(sess, dir, packet_get_sids(pkt));
+          session_set_first_packet(sess, type, packet_dup(pkt));
+          session_set_route_ctx(sess, type, packet_get_route_ctx(pkt));
+          session_set_sids(sess, type, packet_get_sids(pkt));
      }
 
      session_set_current_packet(sess, pkt);
-     session_set_current_flow_direction(sess, dir);
+     session_set_flow_type(sess, type);
      session_set_timestamp(sess, SESSION_TIMESTAMP_LAST, mgr->now_ms);
      session_set_current_state(sess, next_state);
 }
@@ -592,8 +592,8 @@ static struct session *session_manager_lookup_tcp_session(struct session_manager
           return sess;
      }
 
-     enum flow_direction dir = identify_direction_by_history(sess, key);
-     struct tcp_half *half = &sess->tcp_halfs[dir];
+     enum flow_type type = identify_flow_type_by_history(sess, key);
+     struct tcp_half *half = &sess->tcp_halfs[type];
      if ((half->isn && half->isn != tcp_hdr_get_seq(hdr)) ||     // recv SYN with different ISN
          ((half->history & TH_FIN) || (half->history & TH_RST))) // recv SYN after FIN or RST
      {
@@ -626,7 +626,7 @@ static struct session *session_manager_new_tcp_session(struct session_manager *m
           session_manager_evicte_session(mgr, evic_sess, LRU_EVICT);
      }
 
-     enum flow_direction dir = (flags & TH_ACK) ? FLOW_DIRECTION_S2C : FLOW_DIRECTION_C2S;
+     enum flow_type type = (flags & TH_ACK) ? FLOW_TYPE_S2C : FLOW_TYPE_C2S;
      struct session *sess = session_pool_pop(mgr->sess_pool);
      if (sess == NULL)
      {
@@ -638,7 +638,7 @@ static struct session *session_manager_new_tcp_session(struct session_manager *m
      sess->mgr_stat = &mgr->stat;
 
      enum session_state next_state = session_transition_run(SESSION_STATE_INIT, TCP_SYN);
-     session_update(mgr, sess, next_state, pkt, key, dir);
+     session_update(mgr, sess, next_state, pkt, key, type);
      session_transition_log(sess, SESSION_STATE_INIT, next_state, TCP_SYN);
 
      if (tcp_init(mgr, sess) == -1)
@@ -647,7 +647,7 @@ static struct session *session_manager_new_tcp_session(struct session_manager *m
           session_pool_push(mgr->sess_pool, sess);
           return NULL;
      }
-     tcp_update(mgr, sess, dir, tcp_layer);
+     tcp_update(mgr, sess, type, tcp_layer);
 
      uint64_t timeout = (flags & TH_ACK) ? mgr->cfg.tcp_timeout_ms.handshake : mgr->cfg.tcp_timeout_ms.init;
      session_timer_update(mgr->sess_timer, sess, mgr->now_ms + timeout);
@@ -684,9 +684,9 @@ static struct session *session_manager_new_udp_session(struct session_manager *m
      sess->mgr = mgr;
      sess->mgr_stat = &mgr->stat;
 
-     enum flow_direction dir = identify_direction_by_port(ntohs(key->src_port), ntohs(key->dst_port));
+     enum flow_type type = identify_flow_type_by_port(ntohs(key->src_port), ntohs(key->dst_port));
      enum session_state next_state = session_transition_run(SESSION_STATE_INIT, UDP_DATA);
-     session_update(mgr, sess, next_state, pkt, key, dir);
+     session_update(mgr, sess, next_state, pkt, key, type);
      session_transition_log(sess, SESSION_STATE_INIT, next_state, UDP_DATA);
 
      session_timer_update(mgr->sess_timer, sess, mgr->now_ms + mgr->cfg.udp_timeout_ms.data);
@@ -703,7 +703,7 @@ static int session_manager_update_tcp_session(struct session_manager *mgr, struc
 {
      const struct layer_private *tcp_layer = packet_get_innermost_layer(pkt, LAYER_PROTO_TCP);
      const struct tcphdr *hdr = (const struct tcphdr *)tcp_layer->hdr_ptr;
-     enum flow_direction dir = identify_direction_by_history(sess, key);
+     enum flow_type type = identify_flow_type_by_history(sess, key);
      uint8_t flags = tcp_hdr_get_flags(hdr);
      int inputs = 0;
      inputs |= (flags & TH_SYN) ? TCP_SYN : NONE;
@@ -716,28 +716,28 @@ static int session_manager_update_tcp_session(struct session_manager *mgr, struc
      enum session_state next_state = session_transition_run(curr_state, inputs);
 
      // update session
-     session_update(mgr, sess, next_state, pkt, key, dir);
+     session_update(mgr, sess, next_state, pkt, key, type);
      session_transition_log(sess, curr_state, next_state, inputs);
 
      // update tcp
-     tcp_update(mgr, sess, dir, tcp_layer);
+     tcp_update(mgr, sess, type, tcp_layer);
 
      // set closing reason
      if (next_state == SESSION_STATE_CLOSING && !session_get_closing_reason(sess))
      {
           if (flags & TH_FIN)
           {
-               session_set_closing_reason(sess, (dir == FLOW_DIRECTION_C2S ? CLOSING_BY_CLIENT_FIN : CLOSING_BY_SERVER_FIN));
+               session_set_closing_reason(sess, (type == FLOW_TYPE_C2S ? CLOSING_BY_CLIENT_FIN : CLOSING_BY_SERVER_FIN));
           }
           if (flags & TH_RST)
           {
-               session_set_closing_reason(sess, (dir == FLOW_DIRECTION_C2S ? CLOSING_BY_CLIENT_RST : CLOSING_BY_SERVER_RST));
+               session_set_closing_reason(sess, (type == FLOW_TYPE_C2S ? CLOSING_BY_CLIENT_RST : CLOSING_BY_SERVER_RST));
           }
      }
 
      // update timeout
-     struct tcp_half *curr = &sess->tcp_halfs[dir];
-     struct tcp_half *peer = &sess->tcp_halfs[(dir == FLOW_DIRECTION_C2S ? FLOW_DIRECTION_S2C : FLOW_DIRECTION_C2S)];
+     struct tcp_half *curr = &sess->tcp_halfs[type];
+     struct tcp_half *peer = &sess->tcp_halfs[(type == FLOW_TYPE_C2S ? FLOW_TYPE_S2C : FLOW_TYPE_C2S)];
      uint64_t timeout = 0;
      switch (next_state)
      {
@@ -786,10 +786,10 @@ static int session_manager_update_tcp_session(struct session_manager *mgr, struc
 
 static int session_manager_update_udp_session(struct session_manager *mgr, struct session *sess, const struct packet *pkt, const struct tuple6 *key)
 {
-     enum flow_direction dir = identify_direction_by_history(sess, key);
+     enum flow_type type = identify_flow_type_by_history(sess, key);
      enum session_state curr_state = session_get_current_state(sess);
      enum session_state next_state = session_transition_run(curr_state, UDP_DATA);
-     session_update(mgr, sess, next_state, pkt, key, dir);
+     session_update(mgr, sess, next_state, pkt, key, type);
      session_transition_log(sess, curr_state, next_state, UDP_DATA);
 
      if (session_get_current_state(sess) == SESSION_STATE_DISCARD)
@@ -1100,17 +1100,17 @@ void session_manager_free_session(struct session_manager *mgr, struct session *s
                break;
           }
 
-          packet_free((struct packet *)session_get_first_packet(sess, FLOW_DIRECTION_C2S));
-          packet_free((struct packet *)session_get_first_packet(sess, FLOW_DIRECTION_S2C));
-          session_set_first_packet(sess, FLOW_DIRECTION_C2S, NULL);
-          session_set_first_packet(sess, FLOW_DIRECTION_S2C, NULL);
-          session_clear_route_ctx(sess, FLOW_DIRECTION_C2S);
-          session_clear_route_ctx(sess, FLOW_DIRECTION_S2C);
-          session_clear_sids(sess, FLOW_DIRECTION_C2S);
-          session_clear_sids(sess, FLOW_DIRECTION_S2C);
+          packet_free((struct packet *)session_get_first_packet(sess, FLOW_TYPE_C2S));
+          packet_free((struct packet *)session_get_first_packet(sess, FLOW_TYPE_S2C));
+          session_set_first_packet(sess, FLOW_TYPE_C2S, NULL);
+          session_set_first_packet(sess, FLOW_TYPE_S2C, NULL);
+          session_clear_route_ctx(sess, FLOW_TYPE_C2S);
+          session_clear_route_ctx(sess, FLOW_TYPE_S2C);
+          session_clear_sids(sess, FLOW_TYPE_C2S);
+          session_clear_sids(sess, FLOW_TYPE_S2C);
           session_set_current_state(sess, SESSION_STATE_INIT);
           session_set_current_packet(sess, NULL);
-          session_set_current_flow_direction(sess, FLOW_DIRECTION_NONE);
+          session_set_flow_type(sess, FLOW_TYPE_NONE);
           session_pool_push(mgr->sess_pool, sess);
           sess = NULL;
      }
diff --git a/infra/session_manager/session_private.h b/infra/session_manager/session_private.h
index 2c1b746..f1486c9 100644
--- a/infra/session_manager/session_private.h
+++ b/infra/session_manager/session_private.h
@@ -47,9 +47,9 @@ struct tcp_half
 struct session
 {
     uint64_t id;
-    uint64_t stats[MAX_FLOW_DIRECTION][MAX_STAT];
+    uint64_t stats[MAX_FLOW_TYPE][MAX_STAT];
     uint64_t timestamps[MAX_TIMESTAMP]; // realtime msec
-    struct tcp_half tcp_halfs[MAX_FLOW_DIRECTION];
+    struct tcp_half tcp_halfs[MAX_FLOW_TYPE];
     struct timeout timeout;
     struct list_head lru;
     struct list_head free;
@@ -59,18 +59,17 @@ struct session
     UT_hash_handle hh3;
     struct tuple6 tuple;
     char tuple_str[TUPLE6_STR_SIZE];
-    struct sids sids[MAX_FLOW_DIRECTION];
-    struct route_ctx route_ctx[MAX_FLOW_DIRECTION];
-    const struct packet *first_pkt[MAX_FLOW_DIRECTION];
+    struct sids sids[MAX_FLOW_TYPE];
+    struct route_ctx route_ctx[MAX_FLOW_TYPE];
+    const struct packet *first_pkt[MAX_FLOW_TYPE];
     const struct packet *curr_pkt;
     void *ex_data[EX_DATA_MAX_COUNT];
     void *user_data;
     int is_symmetric;
     int dup;
     enum session_direction sess_dir;
-    enum flow_direction tuple_dir;
-    enum flow_direction flow_dir;
-    enum session_type type;
+    enum flow_type flow_type;
+    enum session_type sess_type;
     enum session_state state;
     enum closing_reason reason;
     struct session_manager *mgr;
@@ -89,8 +88,8 @@ const struct tuple6 *session_get_tuple6(const struct session *sess);
 void session_set_direction(struct session *sess, enum session_direction dir);
 enum session_direction session_get_direction(const struct session *sess);
 
-void session_set_current_flow_direction(struct session *sess, enum flow_direction dir);
-// enum flow_direction session_get_current_flow_direction(const struct session *sess);
+void session_set_flow_type(struct session *sess, enum flow_type type);
+// enum flow_type session_get_flow_type(const struct session *sess);
 
 void session_set_current_state(struct session *sess, enum session_state state);
 // enum session_state session_get_current_state(const struct session *sess);
@@ -104,22 +103,22 @@ void session_set_duplicate_traffic(struct session *sess);
 void session_set_closing_reason(struct session *sess, enum closing_reason reason);
 // enum closing_reason session_get_closing_reason(const struct session *sess);
 
-void session_inc_stat(struct session *sess, enum flow_direction dir, enum session_stat stat, uint64_t val);
-// uint64_t session_get_stat(const struct session *sess, enum flow_direction dir, enum session_stat stat);
+void session_inc_stat(struct session *sess, enum flow_type type, enum session_stat stat, uint64_t val);
+// uint64_t session_get_stat(const struct session *sess, enum flow_type dir, enum session_stat stat);
 
 void session_set_timestamp(struct session *sess, enum session_timestamp type, uint64_t value);
 // uint64_t session_get_timestamp(const struct session *sess, enum session_timestamp type);
 
-void session_clear_sids(struct session *sess, enum flow_direction dir);
-void session_set_sids(struct session *sess, enum flow_direction dir, const struct sids *sids);
-const struct sids *session_get_sids(const struct session *sess, enum flow_direction dir);
+void session_clear_sids(struct session *sess, enum flow_type type);
+void session_set_sids(struct session *sess, enum flow_type type, const struct sids *sids);
+const struct sids *session_get_sids(const struct session *sess, enum flow_type type);
 
-void session_clear_route_ctx(struct session *sess, enum flow_direction dir);
-void session_set_route_ctx(struct session *sess, enum flow_direction dir, const struct route_ctx *ctx);
-const struct route_ctx *session_get_route_ctx(const struct session *sess, enum flow_direction dir);
+void session_clear_route_ctx(struct session *sess, enum flow_type type);
+void session_set_route_ctx(struct session *sess, enum flow_type type, const struct route_ctx *ctx);
+const struct route_ctx *session_get_route_ctx(const struct session *sess, enum flow_type type);
 
-void session_set_first_packet(struct session *sess, enum flow_direction dir, const struct packet *pkt);
-// const struct packet *session_get_first_packet(const struct session *sess, enum flow_direction dir);
+void session_set_first_packet(struct session *sess, enum flow_type type, const struct packet *pkt);
+// const struct packet *session_get_first_packet(const struct session *sess, enum flow_type type);
 
 void session_set_current_packet(struct session *sess, const struct packet *pkt);
 // const struct packet *session_get0_current_packet(const struct session *sess);
@@ -139,7 +138,7 @@ void session_free_tcp_segment(struct session *sess, struct tcp_segment *seg);
 const char *closing_reason_to_str(enum closing_reason reason);
 const char *session_state_to_str(enum session_state state);
 const char *session_type_to_str(enum session_type type);
-const char *flow_direction_to_str(enum flow_direction dir);
+const char *flow_direction_to_str(enum flow_type type);
 
 // bref : 1, output session bref info
 // bref : 0, output session detail info
diff --git a/infra/session_manager/session_utils.c b/infra/session_manager/session_utils.c
index 528f1b2..74edbd8 100644
--- a/infra/session_manager/session_utils.c
+++ b/infra/session_manager/session_utils.c
@@ -41,14 +41,14 @@ enum session_direction session_get_direction(const struct session *sess)
     return sess->sess_dir;
 }
 
-void session_set_current_flow_direction(struct session *sess, enum flow_direction dir)
+void session_set_flow_type(struct session *sess, enum flow_type type)
 {
-    sess->flow_dir = dir;
+    sess->flow_type = type;
 }
 
-enum flow_direction session_get_current_flow_direction(const struct session *sess)
+enum flow_type session_get_flow_type(const struct session *sess)
 {
-    return sess->flow_dir;
+    return sess->flow_type;
 }
 
 void session_set_current_state(struct session *sess, enum session_state state)
@@ -63,12 +63,12 @@ enum session_state session_get_current_state(const struct session *sess)
 
 void session_set_type(struct session *sess, enum session_type type)
 {
-    sess->type = type;
+    sess->sess_type = type;
 }
 
 enum session_type session_get_type(const struct session *sess)
 {
-    return sess->type;
+    return sess->sess_type;
 }
 
 void session_set_duplicate_traffic(struct session *sess)
@@ -91,14 +91,14 @@ enum closing_reason session_get_closing_reason(const struct session *sess)
     return sess->reason;
 }
 
-void session_inc_stat(struct session *sess, enum flow_direction dir, enum session_stat stat, uint64_t val)
+void session_inc_stat(struct session *sess, enum flow_type type, enum session_stat stat, uint64_t val)
 {
-    sess->stats[dir][stat] += val;
+    sess->stats[type][stat] += val;
 }
 
-uint64_t session_get_stat(const struct session *sess, enum flow_direction dir, enum session_stat stat)
+uint64_t session_get_stat(const struct session *sess, enum flow_type type, enum session_stat stat)
 {
-    return sess->stats[dir][stat];
+    return sess->stats[type][stat];
 }
 
 void session_set_timestamp(struct session *sess, enum session_timestamp type, uint64_t value)
@@ -111,44 +111,44 @@ uint64_t session_get_timestamp(const struct session *sess, enum session_timestam
     return sess->timestamps[type];
 }
 
-void session_clear_sids(struct session *sess, enum flow_direction dir)
+void session_clear_sids(struct session *sess, enum flow_type type)
 {
-    memset(&sess->sids[dir], 0, sizeof(struct sids));
+    memset(&sess->sids[type], 0, sizeof(struct sids));
 }
 
-void session_set_sids(struct session *sess, enum flow_direction dir, const struct sids *sids)
+void session_set_sids(struct session *sess, enum flow_type type, const struct sids *sids)
 {
-    sess->sids[dir] = *sids;
+    sess->sids[type] = *sids;
 }
 
-const struct sids *session_get_sids(const struct session *sess, enum flow_direction dir)
+const struct sids *session_get_sids(const struct session *sess, enum flow_type type)
 {
-    return &sess->sids[dir];
+    return &sess->sids[type];
 }
 
-void session_clear_route_ctx(struct session *sess, enum flow_direction dir)
+void session_clear_route_ctx(struct session *sess, enum flow_type type)
 {
-    memset(&sess->route_ctx[dir], 0, sizeof(struct route_ctx));
+    memset(&sess->route_ctx[type], 0, sizeof(struct route_ctx));
 }
 
-void session_set_route_ctx(struct session *sess, enum flow_direction dir, const struct route_ctx *ctx)
+void session_set_route_ctx(struct session *sess, enum flow_type type, const struct route_ctx *ctx)
 {
-    sess->route_ctx[dir] = *ctx;
+    sess->route_ctx[type] = *ctx;
 }
 
-const struct route_ctx *session_get_route_ctx(const struct session *sess, enum flow_direction dir)
+const struct route_ctx *session_get_route_ctx(const struct session *sess, enum flow_type type)
 {
-    return &sess->route_ctx[dir];
+    return &sess->route_ctx[type];
 }
 
-void session_set_first_packet(struct session *sess, enum flow_direction dir, const struct packet *pkt)
+void session_set_first_packet(struct session *sess, enum flow_type type, const struct packet *pkt)
 {
-    sess->first_pkt[dir] = pkt;
+    sess->first_pkt[type] = pkt;
 }
 
-const struct packet *session_get_first_packet(const struct session *sess, enum flow_direction dir)
+const struct packet *session_get_first_packet(const struct session *sess, enum flow_type type)
 {
-    return sess->first_pkt[dir];
+    return sess->first_pkt[type];
 }
 
 void session_set_current_packet(struct session *sess, const struct packet *pkt)
@@ -164,7 +164,7 @@ const struct packet *session_get0_current_packet(const struct session *sess)
 int session_is_symmetric(const struct session *sess, unsigned char *flag)
 {
     int is_symmetric = 0;
-    if (sess->first_pkt[FLOW_DIRECTION_C2S] && sess->first_pkt[FLOW_DIRECTION_S2C])
+    if (sess->first_pkt[FLOW_TYPE_C2S] && sess->first_pkt[FLOW_TYPE_S2C])
     {
         if (flag)
         {
@@ -172,14 +172,14 @@ int session_is_symmetric(const struct session *sess, unsigned char *flag)
         }
         is_symmetric = 1;
     }
-    else if (sess->first_pkt[FLOW_DIRECTION_C2S])
+    else if (sess->first_pkt[FLOW_TYPE_C2S])
     {
         if (flag)
         {
             *flag = SESSION_SEEN_C2S_FLOW;
         }
     }
-    else if (sess->first_pkt[FLOW_DIRECTION_S2C])
+    else if (sess->first_pkt[FLOW_TYPE_S2C])
     {
         if (flag)
         {
@@ -201,8 +201,8 @@ void *session_get_user_data(const struct session *sess)
 
 struct tcp_segment *session_get_tcp_segment(struct session *sess)
 {
-    enum flow_direction dir = session_get_current_flow_direction(sess);
-    struct tcp_half *half = &sess->tcp_halfs[dir];
+    enum flow_type type = session_get_flow_type(sess);
+    struct tcp_half *half = &sess->tcp_halfs[type];
 
     if (half->in_order.data != NULL && half->in_order.len > 0 && half->in_order_ref == 0)
     {
@@ -215,8 +215,8 @@ struct tcp_segment *session_get_tcp_segment(struct session *sess)
         struct tcp_segment *seg = tcp_reassembly_pop(half->assembler);
         if (seg)
         {
-            session_inc_stat(sess, dir, STAT_TCP_SEGMENTS_REORDERED, 1);
-            session_inc_stat(sess, dir, STAT_TCP_PAYLOADS_REORDERED, seg->len);
+            session_inc_stat(sess, type, STAT_TCP_SEGMENTS_REORDERED, 1);
+            session_inc_stat(sess, type, STAT_TCP_PAYLOADS_REORDERED, seg->len);
 
             // TODO
             sess->mgr_stat->tcp_segs_consumed++;
@@ -233,8 +233,8 @@ void session_free_tcp_segment(struct session *sess, struct tcp_segment *seg)
         return;
     }
 
-    enum flow_direction dir = session_get_current_flow_direction(sess);
-    struct tcp_half *half = &sess->tcp_halfs[dir];
+    enum flow_type type = session_get_flow_type(sess);
+    struct tcp_half *half = &sess->tcp_halfs[type];
 
     if (seg == &half->in_order)
     {
@@ -244,8 +244,8 @@ void session_free_tcp_segment(struct session *sess, struct tcp_segment *seg)
     }
     else
     {
-        session_inc_stat(sess, dir, STAT_TCP_SEGMENTS_RELEASED, 1);
-        session_inc_stat(sess, dir, STAT_TCP_PAYLOADS_RELEASED, seg->len);
+        session_inc_stat(sess, type, STAT_TCP_SEGMENTS_RELEASED, 1);
+        session_inc_stat(sess, type, STAT_TCP_PAYLOADS_RELEASED, seg->len);
         sess->mgr_stat->tcp_segs_freed++;
 
         tcp_segment_free(seg);
@@ -309,13 +309,13 @@ const char *session_type_to_str(enum session_type type)
     }
 }
 
-const char *flow_direction_to_str(enum flow_direction dir)
+const char *flow_direction_to_str(enum flow_type type)
 {
-    switch (dir)
+    switch (type)
     {
-    case FLOW_DIRECTION_C2S:
+    case FLOW_TYPE_C2S:
         return "C2S";
-    case FLOW_DIRECTION_S2C:
+    case FLOW_TYPE_S2C:
         return "S2C";
     default:
         return "unknown";
@@ -357,9 +357,9 @@ int session_to_str(const struct session *sess, int bref, char *buff, int size)
                          session_get0_readable_addr(sess),
                          session_type_to_str(session_get_type(sess)),
                          session_state_to_str(session_get_current_state(sess)),
-                         flow_direction_to_str(session_get_current_flow_direction(sess)),
-                         session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED),
-                         session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED));
+                         flow_direction_to_str(session_get_flow_type(sess)),
+                         session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED),
+                         session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED));
     }
     else
     {
@@ -375,75 +375,75 @@ int session_to_str(const struct session *sess, int bref, char *buff, int size)
         used += snprintf(buff + used, size - used, "\"current_packet\":\"%p\",", session_get0_current_packet(sess));
 
         const char *str[] = {"c2s", "s2c"};
-        enum flow_direction dir[] = {FLOW_DIRECTION_C2S, FLOW_DIRECTION_S2C};
+        enum flow_type type[] = {FLOW_TYPE_C2S, FLOW_TYPE_S2C};
         for (int i = 0; i < 2; i++)
         {
             // raw packets
-            used += snprintf(buff + used, size - used, "\"%s_raw_packets_received\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_RAW_PACKETS_RECEIVED));
-            used += snprintf(buff + used, size - used, "\"%s_raw_bytes_received\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_RAW_BYTES_RECEIVED));
+            used += snprintf(buff + used, size - used, "\"%s_raw_packets_received\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_RAW_PACKETS_RECEIVED));
+            used += snprintf(buff + used, size - used, "\"%s_raw_bytes_received\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_RAW_BYTES_RECEIVED));
 
-            used += snprintf(buff + used, size - used, "\"%s_raw_packets_transmitted\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_RAW_PACKETS_TRANSMITTED));
-            used += snprintf(buff + used, size - used, "\"%s_raw_bytes_transmitted\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_RAW_BYTES_TRANSMITTED));
+            used += snprintf(buff + used, size - used, "\"%s_raw_packets_transmitted\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_RAW_PACKETS_TRANSMITTED));
+            used += snprintf(buff + used, size - used, "\"%s_raw_bytes_transmitted\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_RAW_BYTES_TRANSMITTED));
 
-            used += snprintf(buff + used, size - used, "\"%s_raw_packets_dropped\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_RAW_PACKETS_DROPPED));
-            used += snprintf(buff + used, size - used, "\"%s_raw_bytes_dropped\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_RAW_BYTES_DROPPED));
+            used += snprintf(buff + used, size - used, "\"%s_raw_packets_dropped\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_RAW_PACKETS_DROPPED));
+            used += snprintf(buff + used, size - used, "\"%s_raw_bytes_dropped\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_RAW_BYTES_DROPPED));
 
             // duplicate packets
-            used += snprintf(buff + used, size - used, "\"%s_duplicate_packets_bypass\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_DUPLICATE_PACKETS_BYPASS));
-            used += snprintf(buff + used, size - used, "\"%s_duplicate_bytes_bypass\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_DUPLICATE_BYTES_BYPASS));
+            used += snprintf(buff + used, size - used, "\"%s_duplicate_packets_bypass\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_DUPLICATE_PACKETS_BYPASS));
+            used += snprintf(buff + used, size - used, "\"%s_duplicate_bytes_bypass\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_DUPLICATE_BYTES_BYPASS));
 
             // injected packets
-            used += snprintf(buff + used, size - used, "\"%s_injected_packets_failed\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_INJECTED_PACKETS_FAILED));
-            used += snprintf(buff + used, size - used, "\"%s_injected_packets_success\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_INJECTED_PACKETS_SUCCESS));
-            used += snprintf(buff + used, size - used, "\"%s_injected_bytes_success\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_INJECTED_BYTES_SUCCESS));
+            used += snprintf(buff + used, size - used, "\"%s_injected_packets_failed\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_INJECTED_PACKETS_FAILED));
+            used += snprintf(buff + used, size - used, "\"%s_injected_packets_success\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_INJECTED_PACKETS_SUCCESS));
+            used += snprintf(buff + used, size - used, "\"%s_injected_bytes_success\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_INJECTED_BYTES_SUCCESS));
 
             // control packets
-            used += snprintf(buff + used, size - used, "\"%s_control_packets_received\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_CONTROL_PACKETS_RECEIVED));
-            used += snprintf(buff + used, size - used, "\"%s_control_bytes_received\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_CONTROL_BYTES_RECEIVED));
+            used += snprintf(buff + used, size - used, "\"%s_control_packets_received\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_CONTROL_PACKETS_RECEIVED));
+            used += snprintf(buff + used, size - used, "\"%s_control_bytes_received\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_CONTROL_BYTES_RECEIVED));
 
-            used += snprintf(buff + used, size - used, "\"%s_control_packets_transmitted\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_CONTROL_PACKETS_TRANSMITTED));
-            used += snprintf(buff + used, size - used, "\"%s_control_bytes_transmitted\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_CONTROL_BYTES_TRANSMITTED));
+            used += snprintf(buff + used, size - used, "\"%s_control_packets_transmitted\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_CONTROL_PACKETS_TRANSMITTED));
+            used += snprintf(buff + used, size - used, "\"%s_control_bytes_transmitted\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_CONTROL_BYTES_TRANSMITTED));
 
-            used += snprintf(buff + used, size - used, "\"%s_control_packets_dropped\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_CONTROL_PACKETS_DROPPED));
-            used += snprintf(buff + used, size - used, "\"%s_control_bytes_dropped\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_CONTROL_BYTES_DROPPED));
+            used += snprintf(buff + used, size - used, "\"%s_control_packets_dropped\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_CONTROL_PACKETS_DROPPED));
+            used += snprintf(buff + used, size - used, "\"%s_control_bytes_dropped\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_CONTROL_BYTES_DROPPED));
 
             if (session_get_type(sess) == SESSION_TYPE_TCP)
             {
-                used += snprintf(buff + used, size - used, "\"%s_tcp_last_seq\":%u,", str[i], sess->tcp_halfs[dir[i]].seq);
-                used += snprintf(buff + used, size - used, "\"%s_tcp_last_ack\":%u,", str[i], sess->tcp_halfs[dir[i]].ack);
+                used += snprintf(buff + used, size - used, "\"%s_tcp_last_seq\":%u,", str[i], sess->tcp_halfs[type[i]].seq);
+                used += snprintf(buff + used, size - used, "\"%s_tcp_last_ack\":%u,", str[i], sess->tcp_halfs[type[i]].ack);
                 memset(flags, 0, sizeof(flags));
-                tcp_flags_to_str(sess->tcp_halfs[dir[i]].flags, flags, sizeof(flags));
+                tcp_flags_to_str(sess->tcp_halfs[type[i]].flags, flags, sizeof(flags));
                 used += snprintf(buff + used, size - used, "\"%s_tcp_flags\":\"%s\",", str[i], flags);
 
-                used += snprintf(buff + used, size - used, "\"%s_tcp_segments_received\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_TCP_SEGMENTS_RECEIVED));
-                used += snprintf(buff + used, size - used, "\"%s_tcp_payloads_received\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_TCP_PAYLOADS_RECEIVED));
+                used += snprintf(buff + used, size - used, "\"%s_tcp_segments_received\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_TCP_SEGMENTS_RECEIVED));
+                used += snprintf(buff + used, size - used, "\"%s_tcp_payloads_received\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_TCP_PAYLOADS_RECEIVED));
 
-                used += snprintf(buff + used, size - used, "\"%s_tcp_segments_expired\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_TCP_SEGMENTS_EXPIRED));
-                used += snprintf(buff + used, size - used, "\"%s_tcp_payloads_expired\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_TCP_PAYLOADS_EXPIRED));
+                used += snprintf(buff + used, size - used, "\"%s_tcp_segments_expired\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_TCP_SEGMENTS_EXPIRED));
+                used += snprintf(buff + used, size - used, "\"%s_tcp_payloads_expired\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_TCP_PAYLOADS_EXPIRED));
 
-                used += snprintf(buff + used, size - used, "\"%s_tcp_segments_retransmit\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_TCP_SEGMENTS_RETRANSMIT));
-                used += snprintf(buff + used, size - used, "\"%s_tcp_payloads_retransmit\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_TCP_PAYLOADS_RETRANSMIT));
+                used += snprintf(buff + used, size - used, "\"%s_tcp_segments_retransmit\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_TCP_SEGMENTS_RETRANSMIT));
+                used += snprintf(buff + used, size - used, "\"%s_tcp_payloads_retransmit\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_TCP_PAYLOADS_RETRANSMIT));
 
-                used += snprintf(buff + used, size - used, "\"%s_tcp_segments_overlap\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_TCP_SEGMENTS_OVERLAP));
-                used += snprintf(buff + used, size - used, "\"%s_tcp_payloads_overlap\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_TCP_PAYLOADS_OVERLAP));
+                used += snprintf(buff + used, size - used, "\"%s_tcp_segments_overlap\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_TCP_SEGMENTS_OVERLAP));
+                used += snprintf(buff + used, size - used, "\"%s_tcp_payloads_overlap\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_TCP_PAYLOADS_OVERLAP));
 
-                used += snprintf(buff + used, size - used, "\"%s_tcp_segments_nospace\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_TCP_SEGMENTS_NOSPACE));
-                used += snprintf(buff + used, size - used, "\"%s_tcp_payloads_nospace\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_TCP_PAYLOADS_NOSPACE));
+                used += snprintf(buff + used, size - used, "\"%s_tcp_segments_nospace\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_TCP_SEGMENTS_NOSPACE));
+                used += snprintf(buff + used, size - used, "\"%s_tcp_payloads_nospace\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_TCP_PAYLOADS_NOSPACE));
 
-                used += snprintf(buff + used, size - used, "\"%s_tcp_segments_inorder\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_TCP_SEGMENTS_INORDER));
-                used += snprintf(buff + used, size - used, "\"%s_tcp_payloads_inorder\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_TCP_PAYLOADS_INORDER));
+                used += snprintf(buff + used, size - used, "\"%s_tcp_segments_inorder\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_TCP_SEGMENTS_INORDER));
+                used += snprintf(buff + used, size - used, "\"%s_tcp_payloads_inorder\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_TCP_PAYLOADS_INORDER));
 
-                used += snprintf(buff + used, size - used, "\"%s_tcp_segments_reordered\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_TCP_SEGMENTS_REORDERED));
-                used += snprintf(buff + used, size - used, "\"%s_tcp_payloads_reordered\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_TCP_PAYLOADS_REORDERED));
+                used += snprintf(buff + used, size - used, "\"%s_tcp_segments_reordered\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_TCP_SEGMENTS_REORDERED));
+                used += snprintf(buff + used, size - used, "\"%s_tcp_payloads_reordered\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_TCP_PAYLOADS_REORDERED));
 
-                used += snprintf(buff + used, size - used, "\"%s_tcp_segments_buffered\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_TCP_SEGMENTS_BUFFERED));
-                used += snprintf(buff + used, size - used, "\"%s_tcp_payloads_buffered\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_TCP_PAYLOADS_BUFFERED));
+                used += snprintf(buff + used, size - used, "\"%s_tcp_segments_buffered\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_TCP_SEGMENTS_BUFFERED));
+                used += snprintf(buff + used, size - used, "\"%s_tcp_payloads_buffered\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_TCP_PAYLOADS_BUFFERED));
 
-                used += snprintf(buff + used, size - used, "\"%s_tcp_segments_released\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_TCP_SEGMENTS_RELEASED));
-                used += snprintf(buff + used, size - used, "\"%s_tcp_payloads_released\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_TCP_PAYLOADS_RELEASED));
+                used += snprintf(buff + used, size - used, "\"%s_tcp_segments_released\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_TCP_SEGMENTS_RELEASED));
+                used += snprintf(buff + used, size - used, "\"%s_tcp_payloads_released\":%" PRIu64 ",", str[i], session_get_stat(sess, type[i], STAT_TCP_PAYLOADS_RELEASED));
             }
 
-            used += snprintf(buff + used, size - used, "\"%s_first_packet\":\"%p\"", str[i], session_get_first_packet(sess, dir[i]));
+            used += snprintf(buff + used, size - used, "\"%s_first_packet\":\"%p\"", str[i], session_get_first_packet(sess, type[i]));
             if (i == 0)
             {
                 used += snprintf(buff + used, size - used, ",");
diff --git a/infra/session_manager/test/gtest_case_tcp_fast_open.cpp b/infra/session_manager/test/gtest_case_tcp_fast_open.cpp
index 116ec67..22f5908 100644
--- a/infra/session_manager/test/gtest_case_tcp_fast_open.cpp
+++ b/infra/session_manager/test/gtest_case_tcp_fast_open.cpp
@@ -288,55 +288,55 @@ TEST(CASE, TCP_FAST_OPEN)
     EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
     EXPECT_TRUE(session_get_closing_reason(sess) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 280);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 1);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 0);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 280);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 0);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 1);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 0);
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
     EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
-    EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_C2S);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) == NULL);
+    EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_C2S);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) == NULL);
 
     // TCP Segment
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_TCP_SEGMENTS_RECEIVED) == 1);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_TCP_PAYLOADS_RECEIVED) == 166);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_TCP_SEGMENTS_EXPIRED) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_TCP_PAYLOADS_EXPIRED) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_TCP_SEGMENTS_RETRANSMIT) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_TCP_PAYLOADS_RETRANSMIT) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_TCP_SEGMENTS_OVERLAP) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_TCP_PAYLOADS_OVERLAP) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_TCP_SEGMENTS_NOSPACE) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_TCP_PAYLOADS_NOSPACE) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_TCP_SEGMENTS_INORDER) == 1);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_TCP_PAYLOADS_INORDER) == 166);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_TCP_SEGMENTS_REORDERED) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_TCP_PAYLOADS_REORDERED) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_TCP_SEGMENTS_BUFFERED) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_TCP_PAYLOADS_BUFFERED) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_TCP_SEGMENTS_RELEASED) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_TCP_PAYLOADS_RELEASED) == 0);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_TCP_SEGMENTS_RECEIVED) == 1);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_TCP_PAYLOADS_RECEIVED) == 166);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_TCP_SEGMENTS_EXPIRED) == 0);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_TCP_PAYLOADS_EXPIRED) == 0);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_TCP_SEGMENTS_RETRANSMIT) == 0);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_TCP_PAYLOADS_RETRANSMIT) == 0);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_TCP_SEGMENTS_OVERLAP) == 0);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_TCP_PAYLOADS_OVERLAP) == 0);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_TCP_SEGMENTS_NOSPACE) == 0);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_TCP_PAYLOADS_NOSPACE) == 0);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_TCP_SEGMENTS_INORDER) == 1);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_TCP_PAYLOADS_INORDER) == 166);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_TCP_SEGMENTS_REORDERED) == 0);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_TCP_PAYLOADS_REORDERED) == 0);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_TCP_SEGMENTS_BUFFERED) == 0);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_TCP_PAYLOADS_BUFFERED) == 0);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_TCP_SEGMENTS_RELEASED) == 0);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_TCP_PAYLOADS_RELEASED) == 0);
 
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_TCP_SEGMENTS_RECEIVED) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_TCP_PAYLOADS_RECEIVED) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_TCP_SEGMENTS_EXPIRED) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_TCP_PAYLOADS_EXPIRED) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_TCP_SEGMENTS_RETRANSMIT) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_TCP_PAYLOADS_RETRANSMIT) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_TCP_SEGMENTS_OVERLAP) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_TCP_PAYLOADS_OVERLAP) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_TCP_SEGMENTS_NOSPACE) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_TCP_PAYLOADS_NOSPACE) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_TCP_SEGMENTS_INORDER) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_TCP_PAYLOADS_INORDER) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_TCP_SEGMENTS_REORDERED) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_TCP_PAYLOADS_REORDERED) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_TCP_SEGMENTS_BUFFERED) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_TCP_PAYLOADS_BUFFERED) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_TCP_SEGMENTS_RELEASED) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_TCP_PAYLOADS_RELEASED) == 0);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_TCP_SEGMENTS_RECEIVED) == 0);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_TCP_PAYLOADS_RECEIVED) == 0);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_TCP_SEGMENTS_EXPIRED) == 0);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_TCP_PAYLOADS_EXPIRED) == 0);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_TCP_SEGMENTS_RETRANSMIT) == 0);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_TCP_PAYLOADS_RETRANSMIT) == 0);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_TCP_SEGMENTS_OVERLAP) == 0);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_TCP_PAYLOADS_OVERLAP) == 0);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_TCP_SEGMENTS_NOSPACE) == 0);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_TCP_PAYLOADS_NOSPACE) == 0);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_TCP_SEGMENTS_INORDER) == 0);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_TCP_PAYLOADS_INORDER) == 0);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_TCP_SEGMENTS_REORDERED) == 0);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_TCP_PAYLOADS_REORDERED) == 0);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_TCP_SEGMENTS_BUFFERED) == 0);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_TCP_PAYLOADS_BUFFERED) == 0);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_TCP_SEGMENTS_RELEASED) == 0);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_TCP_PAYLOADS_RELEASED) == 0);
 
     session_print(sess);
 
diff --git a/infra/session_manager/test/gtest_state_tcp_active_to_closing.cpp b/infra/session_manager/test/gtest_state_tcp_active_to_closing.cpp
index 190ed80..8e07351 100644
--- a/infra/session_manager/test/gtest_state_tcp_active_to_closing.cpp
+++ b/infra/session_manager/test/gtest_state_tcp_active_to_closing.cpp
@@ -87,16 +87,16 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_FIN_FIN)
     EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 145 + 66);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 66);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1 + 1);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 145 + 66);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 66);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1 + 1);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
     EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
-    EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_S2C);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL);
+    EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_S2C);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
     session_print(sess);
 
     // check stat
@@ -172,16 +172,16 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_RST)
     EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_RST);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 145 + 66);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1 + 1);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 0);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 145 + 66);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 0);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1 + 1);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 0);
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
     EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
-    EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_C2S);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) == NULL);
+    EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_C2S);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) == NULL);
     session_print(sess);
 
     // check stat
@@ -257,16 +257,16 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_RST)
     EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_RST);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 145);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 66);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 145);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 66);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
     EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
-    EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_S2C);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL);
+    EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_S2C);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
     session_print(sess);
 
     // check stat
@@ -383,16 +383,16 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_HALF_CLOSED_TIMEOUT)
     EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 145 + 66);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1 + 1);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 0);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 145 + 66);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 0);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1 + 1);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 0);
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
     EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
-    EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_C2S);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) == NULL);
+    EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_C2S);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) == NULL);
     session_print(sess);
 
     // check stat
@@ -462,16 +462,16 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_HALF_CLOSED_TIMEOUT)
     EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_FIN);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 145);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 66);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 145);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 66);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
     EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
-    EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_S2C);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL);
+    EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_S2C);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
     session_print(sess);
 
     // check stat
diff --git a/infra/session_manager/test/gtest_state_tcp_init_to_opening.cpp b/infra/session_manager/test/gtest_state_tcp_init_to_opening.cpp
index c8c3272..98f3be5 100644
--- a/infra/session_manager/test/gtest_state_tcp_init_to_opening.cpp
+++ b/infra/session_manager/test/gtest_state_tcp_init_to_opening.cpp
@@ -43,16 +43,16 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN)
     EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
     EXPECT_TRUE(session_get_closing_reason(sess) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 78);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 1);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 0);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 78);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 0);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 1);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 0);
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
     EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
-    EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_C2S);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) == NULL);
+    EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_C2S);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) == NULL);
     session_print(sess);
 
     // check stat
@@ -120,16 +120,16 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK)
     EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
     EXPECT_TRUE(session_get_closing_reason(sess) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 74);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 0);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 74);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 0);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
     EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
-    EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_S2C);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) == NULL);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL);
+    EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_S2C);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) == NULL);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
     session_print(sess);
 
     // check stat
@@ -209,16 +209,16 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK)
     EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
     EXPECT_TRUE(session_get_closing_reason(sess) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 78);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 74);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 1);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 78);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 74);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 1);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
     EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
-    EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_S2C);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL);
+    EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_S2C);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
     session_print(sess);
 
     // check stat
@@ -310,16 +310,16 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK_ACK)
     EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
     EXPECT_TRUE(session_get_closing_reason(sess) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 66);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 74);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 66);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 74);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
     EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
-    EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_C2S);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL);
+    EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_C2S);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
     session_print(sess);
 
     // check stat
@@ -406,16 +406,16 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_RETRANSMISSION)
     EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
     EXPECT_TRUE(session_get_closing_reason(sess) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 78);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 0);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 78);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 0);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 0);
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
     EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
-    EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_C2S);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) == NULL);
+    EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_C2S);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) == NULL);
     session_print(sess);
 
     // check stat
@@ -503,16 +503,16 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK_RETRANSMISSION)
     EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
     EXPECT_TRUE(session_get_closing_reason(sess) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 74 + 74);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 1 + 1);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 0);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 74 + 74);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 0);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 1 + 1);
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
     EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
-    EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_S2C);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) == NULL);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL);
+    EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_S2C);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) == NULL);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
     session_print(sess);
 
     // check stat
@@ -592,16 +592,16 @@ TEST(TCP_INIT_TO_OPENING, BY_C2S_ASMMETRIC)
     EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
     EXPECT_TRUE(session_get_closing_reason(sess) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 66);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 0);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 66);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 0);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 0);
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
     EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
-    EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_C2S);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) == NULL);
+    EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_C2S);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) == NULL);
     session_print(sess);
 
     // check stat
@@ -681,16 +681,16 @@ TEST(TCP_INIT_TO_OPENING, BY_S2C_ASMMETRIC)
     EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
     EXPECT_TRUE(session_get_closing_reason(sess) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 74 + 66);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 1 + 1);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 0);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 74 + 66);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 0);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 1 + 1);
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
     EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
-    EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_S2C);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) == NULL);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL);
+    EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_S2C);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) == NULL);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
     session_print(sess);
 
     // check stat
diff --git a/infra/session_manager/test/gtest_state_tcp_init_to_opening_to_active_to_closing_to_closed.cpp b/infra/session_manager/test/gtest_state_tcp_init_to_opening_to_active_to_closing_to_closed.cpp
index 5acba12..8335559 100644
--- a/infra/session_manager/test/gtest_state_tcp_init_to_opening_to_active_to_closing_to_closed.cpp
+++ b/infra/session_manager/test/gtest_state_tcp_init_to_opening_to_active_to_closing_to_closed.cpp
@@ -40,16 +40,16 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
     EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
     EXPECT_TRUE(session_get_closing_reason(sess) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 78);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 1);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 0);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 78);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 0);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 1);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 0);
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
     EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
-    EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_C2S);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) == NULL);
+    EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_C2S);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) == NULL);
 
     // S2C SYNACK Packet
     printf("\n=> Packet Parse: TCP S2C SYNACK packet\n");
@@ -71,16 +71,16 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
     EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
     EXPECT_TRUE(session_get_closing_reason(sess) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 78);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 74);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 1);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 78);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 74);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 1);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
     EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
-    EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_S2C);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL);
+    EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_S2C);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
 
     // C2S ACK Packet
     printf("\n=> Packet Parse: TCP C2S ACK packet\n");
@@ -102,16 +102,16 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
     EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
     EXPECT_TRUE(session_get_closing_reason(sess) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 66);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 74);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 66);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 74);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
     EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
-    EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_C2S);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL);
+    EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_C2S);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
 
     // C2S REQ Packet
     printf("\n=> Packet Parse: TCP C2S REQ packet\n");
@@ -133,16 +133,16 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
     EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
     EXPECT_TRUE(session_get_closing_reason(sess) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 66 + 145);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 74);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1 + 1);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 66 + 145);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 74);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1 + 1);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
     EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
-    EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_C2S);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL);
+    EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_C2S);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
 
     // S2C ACK Packet
     printf("\n=> Packet Parse: TCP S2C ACK packet\n");
@@ -164,16 +164,16 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
     EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
     EXPECT_TRUE(session_get_closing_reason(sess) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 66 + 145);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 74 + 66);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1 + 1);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 1 + 1);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 66 + 145);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 74 + 66);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1 + 1);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 1 + 1);
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
     EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
-    EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_S2C);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL);
+    EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_S2C);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
 
     // S2C HTTP Resp Packet1
     printf("\n=> Packet Parse: TCP S2C Resp packet1\n");
@@ -195,16 +195,16 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
     EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
     EXPECT_TRUE(session_get_closing_reason(sess) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 66 + 145);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 74 + 66 + 1354);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1 + 1);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 1 + 1 + 1);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 66 + 145);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 74 + 66 + 1354);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1 + 1);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 1 + 1 + 1);
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
     EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
-    EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_S2C);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL);
+    EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_S2C);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
 
     // S2C HTTP Resp Packet2
     printf("\n=> Packet Parse: TCP S2C Resp packet2\n");
@@ -226,16 +226,16 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
     EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
     EXPECT_TRUE(session_get_closing_reason(sess) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 66 + 145);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 74 + 66 + 1354 + 385);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1 + 1);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 1 + 1 + 1 + 1);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 66 + 145);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 74 + 66 + 1354 + 385);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1 + 1);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 1 + 1 + 1 + 1);
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
     EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
-    EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_S2C);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL);
+    EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_S2C);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
 
     // C2S ACK Packet
     printf("\n=> Packet Parse: TCP C2S ACK packet\n");
@@ -257,16 +257,16 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
     EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
     EXPECT_TRUE(session_get_closing_reason(sess) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 66 + 145 + 66);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 74 + 66 + 1354 + 385);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1 + 1 + 1);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 1 + 1 + 1 + 1);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 66 + 145 + 66);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 74 + 66 + 1354 + 385);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1 + 1 + 1);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 1 + 1 + 1 + 1);
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
     EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
-    EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_C2S);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL);
+    EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_C2S);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
 
     // C2S FIN Packet
     printf("\n=> Packet Parse: TCP C2S FIN packet\n");
@@ -288,16 +288,16 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
     EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 66 + 145 + 66 + 66);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 74 + 66 + 1354 + 385);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1 + 1 + 1 + 1);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 1 + 1 + 1 + 1);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 66 + 145 + 66 + 66);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 74 + 66 + 1354 + 385);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1 + 1 + 1 + 1);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 1 + 1 + 1 + 1);
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
     EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
-    EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_C2S);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL);
+    EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_C2S);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
 
     // S2C FIN Packet
     printf("\n=> Packet Parse: TCP S2C FIN packet\n");
@@ -319,16 +319,16 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
     EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 66 + 145 + 66 + 66);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 74 + 66 + 1354 + 385 + 66);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1 + 1 + 1 + 1);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 1 + 1 + 1 + 1 + 1);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 66 + 145 + 66 + 66);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 74 + 66 + 1354 + 385 + 66);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1 + 1 + 1 + 1);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 1 + 1 + 1 + 1 + 1);
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
     EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
-    EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_S2C);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL);
+    EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_S2C);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
 
     // C2S ACK Packet
     printf("\n=> Packet Parse: TCP C2S ACK packet\n");
@@ -350,16 +350,16 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
     EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 66 + 145 + 66 + 66 + 66);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 74 + 66 + 1354 + 385 + 66);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1 + 1 + 1 + 1 + 1);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 1 + 1 + 1 + 1 + 1);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 66 + 145 + 66 + 66 + 66);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 74 + 66 + 1354 + 385 + 66);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1 + 1 + 1 + 1 + 1);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 1 + 1 + 1 + 1 + 1);
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
     EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
-    EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_C2S);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL);
+    EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_C2S);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
 
     // check stat
     stat = session_manager_stat(mgr);
diff --git a/infra/session_manager/test/gtest_state_tcp_opening_to_active.cpp b/infra/session_manager/test/gtest_state_tcp_opening_to_active.cpp
index 7f2d540..7bf2a32 100644
--- a/infra/session_manager/test/gtest_state_tcp_opening_to_active.cpp
+++ b/infra/session_manager/test/gtest_state_tcp_opening_to_active.cpp
@@ -55,16 +55,16 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYN_C2S_DATA)
     EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
     EXPECT_TRUE(session_get_closing_reason(sess) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 145);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 0);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 145);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 0);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 0);
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
     EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
-    EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_C2S);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) == NULL);
+    EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_C2S);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) == NULL);
     session_print(sess);
 
     // check stat
@@ -144,16 +144,16 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYNACK_S2C_DATA)
     EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
     EXPECT_TRUE(session_get_closing_reason(sess) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 74 + 1354);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 1 + 1);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 0);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 74 + 1354);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 0);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 1 + 1);
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
     EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
-    EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_S2C);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) == NULL);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL);
+    EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_S2C);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) == NULL);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
     session_print(sess);
 
     // check stat
diff --git a/infra/session_manager/test/gtest_state_tcp_opening_to_closing.cpp b/infra/session_manager/test/gtest_state_tcp_opening_to_closing.cpp
index 11a537b..c7c1831 100644
--- a/infra/session_manager/test/gtest_state_tcp_opening_to_closing.cpp
+++ b/infra/session_manager/test/gtest_state_tcp_opening_to_closing.cpp
@@ -67,16 +67,16 @@ TEST(TCP_OPENING_TO_CLOSING, BY_FIN_FIN)
     EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 66);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 66);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 66);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 66);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
     EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
-    EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_S2C);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL);
+    EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_S2C);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
     session_print(sess);
 
     // check stat
@@ -161,16 +161,16 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_RST)
     EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_RST);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 66);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 0);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 66);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 0);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 0);
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
     EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
-    EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_C2S);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) == NULL);
+    EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_C2S);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) == NULL);
     session_print(sess);
 
     // check stat
@@ -255,16 +255,16 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_RST)
     EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_RST);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 78);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 66);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 1);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 78);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 66);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 1);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
     EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
-    EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_S2C);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL);
+    EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_S2C);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
     session_print(sess);
 
     // check stat
@@ -400,16 +400,16 @@ TEST(TCP_OPENING_TO_CLOSING, BY_HANDSHAKE_TIMEOUT)
     EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
     EXPECT_TRUE(session_get_closing_reason(sess) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 78);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 74);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 1);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 78);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 74);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 1);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
     EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
-    EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_S2C);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL);
+    EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_S2C);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
     session_print(sess);
 
     // check stat
@@ -501,16 +501,16 @@ TEST(TCP_OPENING_TO_CLOSING, BY_DATA_TIMEOUT)
     EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
     EXPECT_TRUE(session_get_closing_reason(sess) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 66);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 74);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 66);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 74);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
     EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
-    EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_C2S);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL);
+    EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_C2S);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
     session_print(sess);
 
     // check stat
@@ -590,16 +590,16 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_HALF_FIN)
     EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 66);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 0);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 78 + 66);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 0);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 1 + 1);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 0);
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
     EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
-    EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_C2S);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) == NULL);
+    EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_C2S);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) == NULL);
     session_print(sess);
 
     // check stat
@@ -678,16 +678,16 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_HALF_FIN)
     EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_FIN);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 78);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 66);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 1);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 78);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 66);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 1);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
     EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
-    EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_S2C);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL);
+    EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_S2C);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
     session_print(sess);
 
     // check stat
diff --git a/infra/session_manager/test/gtest_state_udp_init_to_opening_to_active_to_closing.cpp b/infra/session_manager/test/gtest_state_udp_init_to_opening_to_active_to_closing.cpp
index 8169f32..759e921 100644
--- a/infra/session_manager/test/gtest_state_udp_init_to_opening_to_active_to_closing.cpp
+++ b/infra/session_manager/test/gtest_state_udp_init_to_opening_to_active_to_closing.cpp
@@ -39,16 +39,16 @@ TEST(UDP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING, TEST)
     EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_UDP);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
     EXPECT_TRUE(session_get_closing_reason(sess) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 74);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 1);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 0);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 74);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 0);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 1);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 0);
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
     EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
-    EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_C2S);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) == NULL);
+    EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_C2S);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) == NULL);
 
     // S2C RESP Packet
     printf("\n=> Packet Parse: UDP S2C RESP packet\n");
@@ -69,16 +69,16 @@ TEST(UDP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING, TEST)
     EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_UDP);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
     EXPECT_TRUE(session_get_closing_reason(sess) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 74);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 550);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 1);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 74);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 550);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 1);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
     EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
-    EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_S2C);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL);
+    EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_S2C);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
     session_print(sess);
 
     // check stat
diff --git a/infra/session_manager/test/gtest_state_udp_init_to_opening_to_closing.cpp b/infra/session_manager/test/gtest_state_udp_init_to_opening_to_closing.cpp
index e38bfac..2387521 100644
--- a/infra/session_manager/test/gtest_state_udp_init_to_opening_to_closing.cpp
+++ b/infra/session_manager/test/gtest_state_udp_init_to_opening_to_closing.cpp
@@ -44,16 +44,16 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_C2S)
     EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_UDP);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
     EXPECT_TRUE(session_get_closing_reason(sess) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 74);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 1);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 0);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 74);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 0);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 1);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 0);
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
     EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
-    EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_C2S);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) != NULL);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) == NULL);
+    EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_C2S);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) != NULL);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) == NULL);
     session_print(sess);
 
     // check stat
@@ -122,16 +122,16 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_S2C)
     EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_UDP);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
     EXPECT_TRUE(session_get_closing_reason(sess) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_BYTES_RECEIVED) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_BYTES_RECEIVED) == 550);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) == 0);
-    EXPECT_TRUE(session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_BYTES_RECEIVED) == 0);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_BYTES_RECEIVED) == 550);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) == 0);
+    EXPECT_TRUE(session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) == 1);
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_START));
     EXPECT_TRUE(session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
     EXPECT_TRUE(session_get0_current_packet(sess) == &pkt);
-    EXPECT_TRUE(session_get_current_flow_direction(sess) == FLOW_DIRECTION_S2C);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_C2S) == NULL);
-    EXPECT_TRUE(session_get_first_packet(sess, FLOW_DIRECTION_S2C) != NULL);
+    EXPECT_TRUE(session_get_flow_type(sess) == FLOW_TYPE_S2C);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_C2S) == NULL);
+    EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
     session_print(sess);
 
     // check stat
diff --git a/infra/stellar_core.c b/infra/stellar_core.c
index 246c495..8ba2790 100644
--- a/infra/stellar_core.c
+++ b/infra/stellar_core.c
@@ -79,21 +79,21 @@ uint64_t stellar_generate_session_id(uint64_t now_sec);
  * Stellar Thread Main Loop
  ******************************************************************************/
 
-static void update_session_stat(struct session *sess, struct packet *pkt)
+static void update_stat(struct session *sess, struct packet *pkt)
 {
-    enum flow_direction dir = session_get_current_flow_direction(sess);
-    assert(dir != FLOW_DIRECTION_NONE);
+    enum flow_type type = session_get_flow_type(sess);
+    assert(type != FLOW_TYPE_NONE);
     int is_ctrl = packet_is_ctrl(pkt);
     uint16_t len = packet_get_raw_len(pkt);
     switch (packet_get_action(pkt))
     {
     case PACKET_ACTION_DROP:
-        session_inc_stat(sess, dir, (is_ctrl ? STAT_CONTROL_PACKETS_DROPPED : STAT_RAW_PACKETS_DROPPED), 1);
-        session_inc_stat(sess, dir, (is_ctrl ? STAT_CONTROL_BYTES_DROPPED : STAT_RAW_BYTES_DROPPED), len);
+        session_inc_stat(sess, type, (is_ctrl ? STAT_CONTROL_PACKETS_DROPPED : STAT_RAW_PACKETS_DROPPED), 1);
+        session_inc_stat(sess, type, (is_ctrl ? STAT_CONTROL_BYTES_DROPPED : STAT_RAW_BYTES_DROPPED), len);
         break;
     case PACKET_ACTION_FORWARD:
-        session_inc_stat(sess, dir, (is_ctrl ? STAT_CONTROL_PACKETS_TRANSMITTED : STAT_RAW_PACKETS_TRANSMITTED), 1);
-        session_inc_stat(sess, dir, (is_ctrl ? STAT_CONTROL_BYTES_TRANSMITTED : STAT_RAW_BYTES_TRANSMITTED), len);
+        session_inc_stat(sess, type, (is_ctrl ? STAT_CONTROL_PACKETS_TRANSMITTED : STAT_RAW_PACKETS_TRANSMITTED), 1);
+        session_inc_stat(sess, type, (is_ctrl ? STAT_CONTROL_BYTES_TRANSMITTED : STAT_RAW_BYTES_TRANSMITTED), len);
         break;
     default:
         assert(0);
@@ -242,9 +242,9 @@ static void *worker_thread(void *arg)
                     packet_set_action(pkt, PACKET_ACTION_DROP);
                 }
 
-                update_session_stat(sess, pkt);
+                update_stat(sess, pkt);
                 session_set_current_packet(sess, NULL);
-                session_set_current_flow_direction(sess, FLOW_DIRECTION_NONE);
+                session_set_flow_type(sess, FLOW_TYPE_NONE);
             }
 
             if (packet_get_action(pkt) == PACKET_ACTION_DROP)
diff --git a/infra/version.map b/infra/version.map
index 03ad01a..0488997 100644
--- a/infra/version.map
+++ b/infra/version.map
@@ -42,7 +42,7 @@ global:
 	session_get0_current_packet;
 	session_get_closing_reason;
 	session_get_direction;
-	session_get_current_flow_direction;
+	session_get_flow_type;
 	session_get_first_packet;
 	session_get_id;
 	session_get_timestamp;
diff --git a/test/debug_plugin/debug_plugin.c b/test/debug_plugin/debug_plugin.c
index 951eea6..50c8bc4 100644
--- a/test/debug_plugin/debug_plugin.c
+++ b/test/debug_plugin/debug_plugin.c
@@ -146,7 +146,7 @@ static void on_sess_udp_msg(struct session *sess, int topic_id, const void *msg,
     const struct timeval *tv = packet_get_timeval(pkt);
     struct plugin_ctx *ctx = (struct plugin_ctx *)plugin_ctx;
     struct session_exdata *exdata = (struct session_exdata *)session_exdata_get(sess, ctx->sess_exdata_idx);
-    if (session_get_current_flow_direction(sess) == FLOW_DIRECTION_C2S)
+    if (session_get_flow_type(sess) == FLOW_TYPE_C2S)
     {
         exdata->c2s_rx_pkts++;
         exdata->c2s_rx_bytes += packet_get_raw_len(pkt);
@@ -182,7 +182,7 @@ static void on_sess_tcp_msg(struct session *sess, int topic_id, const void *msg,
     const struct timeval *tv = packet_get_timeval(pkt);
     struct plugin_ctx *ctx = (struct plugin_ctx *)plugin_ctx;
     struct session_exdata *exdata = (struct session_exdata *)session_exdata_get(sess, ctx->sess_exdata_idx);
-    if (session_get_current_flow_direction(sess) == FLOW_DIRECTION_C2S)
+    if (session_get_flow_type(sess) == FLOW_TYPE_C2S)
     {
         exdata->c2s_rx_pkts++;
         exdata->c2s_rx_bytes += packet_get_raw_len(pkt);
@@ -225,7 +225,7 @@ static void on_sess_tcp_stream_msg(struct session *sess, int topic_id, const voi
     debug_plugin_log(ctx->fd, "debug plugin", "on TCP stream msg: %s", buff);
 
     pthread_spin_lock(&ctx->lock);
-    if (session_get_current_flow_direction(sess) == FLOW_DIRECTION_C2S)
+    if (session_get_flow_type(sess) == FLOW_TYPE_C2S)
     {
         debug_plugin_log(ctx->fd, "debug plugin", "rx C2S TCP segment: len: %d, data: %p", len, data);
         hexdump_to_fd(ctx->fd, exdata->c2s_rx_tcp_bytes, data, len);
diff --git a/test/decoders/http/http_test_plug.cpp b/test/decoders/http/http_test_plug.cpp
index 1370b70..d91b552 100644
--- a/test/decoders/http/http_test_plug.cpp
+++ b/test/decoders/http/http_test_plug.cpp
@@ -607,10 +607,10 @@ extern "C" void http_decoder_tunnel_entry(struct session *sess, int topic_id, co
 
     case HTTP_TUNNEL_ACTIVE:
     {
-        enum flow_direction curdir = session_get_current_flow_direction(sess);
+        enum flow_type curdir = session_get_flow_type(sess);
         hstring tunnel_payload = {};
         http_tunnel_message_get_payload((const struct http_tunnel_message *)raw_msg, &tunnel_payload);
-        if (FLOW_DIRECTION_C2S == curdir)
+        if (FLOW_TYPE_C2S == curdir)
         {
             req_payload_block++;
             req_payload_size += tunnel_payload.iov_len;
diff --git a/test/packet_inject/conf/inject_ipv4_based_tcp_payload_after_recv_c2s_first_payload.toml b/test/packet_inject/conf/inject_ipv4_based_tcp_payload_after_recv_c2s_first_payload.toml
index 3fd45b7..8f4a067 100644
--- a/test/packet_inject/conf/inject_ipv4_based_tcp_payload_after_recv_c2s_first_payload.toml
+++ b/test/packet_inject/conf/inject_ipv4_based_tcp_payload_after_recv_c2s_first_payload.toml
@@ -2,6 +2,6 @@
 [packet_inject]
 filter_ip = any           # eg: 2001:db8::1, 192.168.1.100, any
 filter_port = 0           # eg: 80, 443 (0 for any)
-filter_dir = C2S          # eg: C2S, S2C
+flow_type = C2S           # eg: C2S, S2C
 filter_pkts = 3           # can not be 0
 inject_type = TCP-PAYLOAD # eg: TCP-RST, TCP-FIN, TCP-PAYLOAD, TCP-PAYLOAD-FIN-RST, UDP-PAYLOAD, CTRL-MSG
diff --git a/test/packet_inject/conf/inject_ipv4_based_tcp_payload_after_recv_s2c_first_payload.toml b/test/packet_inject/conf/inject_ipv4_based_tcp_payload_after_recv_s2c_first_payload.toml
index 86858b3..62222df 100644
--- a/test/packet_inject/conf/inject_ipv4_based_tcp_payload_after_recv_s2c_first_payload.toml
+++ b/test/packet_inject/conf/inject_ipv4_based_tcp_payload_after_recv_s2c_first_payload.toml
@@ -2,6 +2,6 @@
 [packet_inject]
 filter_ip = any           # eg: 2001:db8::1, 192.168.1.100, any
 filter_port = 0           # eg: 80, 443 (0 for any)
-filter_dir = S2C          # eg: C2S, S2C
+flow_type = S2C           # eg: C2S, S2C
 filter_pkts = 3           # can not be 0
 inject_type = TCP-PAYLOAD # eg: TCP-RST, TCP-FIN, TCP-PAYLOAD, TCP-PAYLOAD-FIN-RST, UDP-PAYLOAD, CTRL-MSG
diff --git a/test/packet_inject/conf/inject_ipv4_based_tcp_payload_fin_rst_after_recv_c2s_first_payload.toml b/test/packet_inject/conf/inject_ipv4_based_tcp_payload_fin_rst_after_recv_c2s_first_payload.toml
index 6fa47ea..2933636 100644
--- a/test/packet_inject/conf/inject_ipv4_based_tcp_payload_fin_rst_after_recv_c2s_first_payload.toml
+++ b/test/packet_inject/conf/inject_ipv4_based_tcp_payload_fin_rst_after_recv_c2s_first_payload.toml
@@ -2,6 +2,6 @@
 [packet_inject]
 filter_ip = any                   # eg: 2001:db8::1, 192.168.1.100, any
 filter_port = 0                   # eg: 80, 443 (0 for any)
-filter_dir = C2S                  # eg: C2S, S2C
+flow_type = C2S                   # eg: C2S, S2C
 filter_pkts = 3                   # can not be 0
 inject_type = TCP-PAYLOAD-FIN-RST # eg: TCP-RST, TCP-FIN, TCP-PAYLOAD, TCP-PAYLOAD-FIN-RST, UDP-PAYLOAD, CTRL-MSG
diff --git a/test/packet_inject/conf/inject_ipv4_based_tcp_rst_after_recv_c2s_first_payload.toml b/test/packet_inject/conf/inject_ipv4_based_tcp_rst_after_recv_c2s_first_payload.toml
index 5b5f58b..5390f35 100644
--- a/test/packet_inject/conf/inject_ipv4_based_tcp_rst_after_recv_c2s_first_payload.toml
+++ b/test/packet_inject/conf/inject_ipv4_based_tcp_rst_after_recv_c2s_first_payload.toml
@@ -2,6 +2,6 @@
 [packet_inject]
 filter_ip = any       # eg: 2001:db8::1, 192.168.1.100, any
 filter_port = 0       # eg: 80, 443 (0 for any)
-filter_dir = C2S      # eg: C2S, S2C
+flow_type = C2S       # eg: C2S, S2C
 filter_pkts = 3       # can not be 0
 inject_type = TCP-RST # eg: TCP-RST, TCP-FIN, TCP-PAYLOAD, TCP-PAYLOAD-FIN-RST, UDP-PAYLOAD, CTRL-MSG
diff --git a/test/packet_inject/conf/inject_ipv4_based_tcp_rst_after_recv_s2c_first_payload.toml b/test/packet_inject/conf/inject_ipv4_based_tcp_rst_after_recv_s2c_first_payload.toml
index 5c7115a..238e230 100644
--- a/test/packet_inject/conf/inject_ipv4_based_tcp_rst_after_recv_s2c_first_payload.toml
+++ b/test/packet_inject/conf/inject_ipv4_based_tcp_rst_after_recv_s2c_first_payload.toml
@@ -2,6 +2,6 @@
 [packet_inject]
 filter_ip = any       # eg: 2001:db8::1, 192.168.1.100, any
 filter_port = 0       # eg: 80, 443 (0 for any)
-filter_dir = S2C      # eg: C2S, S2C
+flow_type = S2C       # eg: C2S, S2C
 filter_pkts = 3       # can not be 0
 inject_type = TCP-RST # eg: TCP-RST, TCP-FIN, TCP-PAYLOAD, TCP-PAYLOAD-FIN-RST, UDP-PAYLOAD, CTRL-MSG
diff --git a/test/packet_inject/conf/inject_ipv4_based_tcp_rst_after_recv_sub_ack.toml b/test/packet_inject/conf/inject_ipv4_based_tcp_rst_after_recv_sub_ack.toml
index 321bfbb..25263f6 100644
--- a/test/packet_inject/conf/inject_ipv4_based_tcp_rst_after_recv_sub_ack.toml
+++ b/test/packet_inject/conf/inject_ipv4_based_tcp_rst_after_recv_sub_ack.toml
@@ -2,6 +2,6 @@
 [packet_inject]
 filter_ip = any       # eg: 2001:db8::1, 192.168.1.100, any
 filter_port = 0       # eg: 80, 443 (0 for any)
-filter_dir = C2S      # eg: C2S, S2C
+flow_type = C2S       # eg: C2S, S2C
 filter_pkts = 2       # can not be 0
 inject_type = TCP-RST # eg: TCP-RST, TCP-FIN, TCP-PAYLOAD, TCP-PAYLOAD-FIN-RST, UDP-PAYLOAD, CTRL-MSG
diff --git a/test/packet_inject/conf/inject_ipv4_based_tcp_rst_after_recv_syn_ack.toml b/test/packet_inject/conf/inject_ipv4_based_tcp_rst_after_recv_syn_ack.toml
index 839b17b..3c7b20f 100644
--- a/test/packet_inject/conf/inject_ipv4_based_tcp_rst_after_recv_syn_ack.toml
+++ b/test/packet_inject/conf/inject_ipv4_based_tcp_rst_after_recv_syn_ack.toml
@@ -2,6 +2,6 @@
 [packet_inject]
 filter_ip = any       # eg: 2001:db8::1, 192.168.1.100, any
 filter_port = 0       # eg: 80, 443 (0 for any)
-filter_dir = S2C      # eg: C2S, S2C
+flow_type = S2C       # eg: C2S, S2C
 filter_pkts = 1       # can not be 0
 inject_type = TCP-RST # eg: TCP-RST, TCP-FIN, TCP-PAYLOAD, TCP-PAYLOAD-FIN-RST, UDP-PAYLOAD, CTRL-MSG
diff --git a/test/packet_inject/packet_inject.c b/test/packet_inject/packet_inject.c
index 6a24311..260babd 100644
--- a/test/packet_inject/packet_inject.c
+++ b/test/packet_inject/packet_inject.c
@@ -36,9 +36,9 @@ struct config
         struct sockaddr_in6 v6;
     } addr;
     uint16_t port;
-    uint64_t number; // inject packet after (C2S/S2C) direction receiving n packets
-    enum inject_type type;
-    enum flow_direction direction;
+    uint64_t number; // inject packet after (C2S/S2C) flow_type receiving n packets
+    enum inject_type inject_type;
+    enum flow_type flow_type;
 };
 
 struct inject_plugin_ctx
@@ -53,7 +53,7 @@ struct inject_plugin_ctx
 
 struct packet_exdata
 {
-    enum flow_direction flow_dir;
+    enum flow_type flow_type;
 
     union
     {
@@ -161,23 +161,23 @@ static int load_config(struct logger *logger, struct config *config, const char
     }
     config->port = atoi(ptr);
 
-    ptr = toml_raw_in(sub, "filter_dir");
+    ptr = toml_raw_in(sub, "flow_type");
     if (ptr == NULL)
     {
-        INJTECT_PLUGIN_LOG_ERROR(logger, "config file missing packet_inject->filter_dir");
+        INJTECT_PLUGIN_LOG_ERROR(logger, "config file missing packet_inject->flow_type");
         goto error_out;
     }
     if (strcmp(ptr, "C2S") == 0)
     {
-        config->direction = FLOW_DIRECTION_C2S;
+        config->flow_type = FLOW_TYPE_C2S;
     }
     else if (strcmp(ptr, "S2C") == 0)
     {
-        config->direction = FLOW_DIRECTION_S2C;
+        config->flow_type = FLOW_TYPE_S2C;
     }
     else
     {
-        INJTECT_PLUGIN_LOG_ERROR(logger, "parse packet_inject->filter_dir failed, invalid direction: %s", ptr);
+        INJTECT_PLUGIN_LOG_ERROR(logger, "parse packet_inject->flow_type failed, invalid flow_type: %s", ptr);
         goto error_out;
     }
 
@@ -202,31 +202,31 @@ static int load_config(struct logger *logger, struct config *config, const char
     }
     if (strcmp(ptr, "TCP-RST") == 0)
     {
-        config->type = INJECT_TCP_RST;
+        config->inject_type = INJECT_TCP_RST;
     }
     else if (strcmp(ptr, "TCP-FIN") == 0)
     {
-        config->type = INJECT_TCP_FIN;
+        config->inject_type = INJECT_TCP_FIN;
     }
     else if (strcmp(ptr, "TCP-PAYLOAD") == 0)
     {
-        config->type = INJECT_TCP_PAYLOAD;
+        config->inject_type = INJECT_TCP_PAYLOAD;
     }
     else if (strcmp(ptr, "TCP-PAYLOAD-FIN-RST") == 0)
     {
-        config->type = INJECT_TCP_PAYLOAD_FIN_RST;
+        config->inject_type = INJECT_TCP_PAYLOAD_FIN_RST;
     }
     else if (strcmp(ptr, "UDP-PAYLOAD") == 0)
     {
-        config->type = INJECT_UDP_PAYLOAD;
+        config->inject_type = INJECT_UDP_PAYLOAD;
     }
     else if (strcmp(ptr, "CTRL-MSG") == 0)
     {
-        config->type = INJECT_CTRL_MSG;
+        config->inject_type = INJECT_CTRL_MSG;
     }
     else
     {
-        INJTECT_PLUGIN_LOG_ERROR(logger, "parse packet_inject->inject_type failed, invalid inject type: %s", ptr);
+        INJTECT_PLUGIN_LOG_ERROR(logger, "parse packet_inject->inject_type failed, invalid inject_type: %s", ptr);
         goto error_out;
     }
 
@@ -265,20 +265,20 @@ static void print_config(struct logger *logger, const struct config *config)
 
     INJTECT_PLUGIN_LOG_INFO(logger, "config->filter_ip   : %s", addr_str);
     INJTECT_PLUGIN_LOG_INFO(logger, "config->filter_port : %d", config->port);
-    INJTECT_PLUGIN_LOG_INFO(logger, "config->filter_dir  : %s", config->direction == FLOW_DIRECTION_C2S ? "C2S" : "S2C");
+    INJTECT_PLUGIN_LOG_INFO(logger, "config->flow_type   : %s", config->flow_type == FLOW_TYPE_C2S ? "C2S" : "S2C");
     INJTECT_PLUGIN_LOG_INFO(logger, "config->filter_pkts : %lu", config->number);
-    INJTECT_PLUGIN_LOG_INFO(logger, "config->inject_type : %s", type_to_str(config->type));
+    INJTECT_PLUGIN_LOG_INFO(logger, "config->inject_type : %s", type_to_str(config->inject_type));
 }
 
 /******************************************************************************
  * Utils
  ******************************************************************************/
 
-static inline void packet_exdata_init(const struct packet *pkt, enum flow_direction dir, struct packet_exdata *pkt_exdata)
+static inline void packet_exdata_init(const struct packet *pkt, enum flow_type type, struct packet_exdata *pkt_exdata)
 {
     memset(pkt_exdata, 0, sizeof(struct packet_exdata));
 
-    pkt_exdata->flow_dir = dir;
+    pkt_exdata->flow_type = type;
 
     int get_inner_addr = 0;
     int count = packet_get_layer_count(pkt);
@@ -335,12 +335,12 @@ static inline uint32_t uint32_add(uint32_t seq, uint32_t inc)
 }
 
 static void build_and_send_udp_packet(struct inject_plugin_ctx *ctx, struct session *sess, struct packet_exdata *pkt_exdata,
-                                      enum flow_direction inject_dir, const char *udp_payload, uint16_t udp_payload_len)
+                                      enum flow_type type, const char *udp_payload, uint16_t udp_payload_len)
 {
-    const struct packet *origin_pkt = session_get_first_packet(sess, inject_dir);
+    const struct packet *origin_pkt = session_get_first_packet(sess, type);
     if (origin_pkt == NULL)
     {
-        INJTECT_PLUGIN_LOG_ERROR(ctx->logger, "build UDP packet failed, %s origin packet is NULL", inject_dir == FLOW_DIRECTION_C2S ? "C2S" : "S2C");
+        INJTECT_PLUGIN_LOG_ERROR(ctx->logger, "build UDP packet failed, %s origin packet is NULL", type == FLOW_TYPE_C2S ? "C2S" : "S2C");
         return;
     }
 
@@ -355,7 +355,7 @@ static void build_and_send_udp_packet(struct inject_plugin_ctx *ctx, struct sess
 }
 
 static void build_and_send_tcp_packet(struct inject_plugin_ctx *ctx, struct session *sess, struct packet_exdata *pkt_exdata,
-                                      enum flow_direction inject_dir, uint8_t tcp_flags, const char *tcp_payload, uint16_t tcp_payload_len)
+                                      enum flow_type type, uint8_t tcp_flags, const char *tcp_payload, uint16_t tcp_payload_len)
 {
     uint32_t tcp_seq = 0;
     uint32_t tcp_ack = 0;
@@ -369,11 +369,11 @@ static void build_and_send_tcp_packet(struct inject_plugin_ctx *ctx, struct sess
      *
      * for example: current packet is C2S
      *
-     * inject direction == current direction (inject C2S RST)
+     * inject flow_type == current flow_type (inject C2S RST)
      *      tcp_seq = current_packet_seq
      *      tcp_ack = current_packet_ack
      *
-     * inject direction != current direction (inject S2C RST)
+     * inject flow_type != current flow_type (inject S2C RST)
      *      tcp_seq = current_packet_ack
      *      tcp_ack = current_packet_seq + current_packet_payload_len
      *  or if current packet is a SYN-ACK packet
@@ -381,7 +381,7 @@ static void build_and_send_tcp_packet(struct inject_plugin_ctx *ctx, struct sess
      *      tcp_ack = current_packet_ack + current_packet_payload_len + 1
      */
 
-    if (inject_dir == pkt_exdata->flow_dir)
+    if (type == pkt_exdata->flow_type)
     {
         tcp_seq = uint32_add(pkt_exdata->tcp_seq, pkt_exdata->inc_seq);
         tcp_ack = pkt_exdata->tcp_ack;
@@ -398,10 +398,10 @@ static void build_and_send_tcp_packet(struct inject_plugin_ctx *ctx, struct sess
         pkt_exdata->inc_ack += (tcp_flags & TH_FIN) ? 1 : 0; // inject RST packer after FIN packer, ack should be increased by 1
     }
 
-    const struct packet *origin_pkt = session_get_first_packet(sess, inject_dir);
+    const struct packet *origin_pkt = session_get_first_packet(sess, type);
     if (origin_pkt == NULL)
     {
-        INJTECT_PLUGIN_LOG_ERROR(ctx->logger, "build TCP packet failed, %s origin packet is NULL", inject_dir == FLOW_DIRECTION_C2S ? "C2S" : "S2C");
+        INJTECT_PLUGIN_LOG_ERROR(ctx->logger, "build TCP packet failed, %s origin packet is NULL", type == FLOW_TYPE_C2S ? "C2S" : "S2C");
         return;
     }
 
@@ -443,14 +443,14 @@ static void on_sess_msg(struct session *sess, int topic_id, const void *msg, voi
     struct packet *pkt = (struct packet *)msg;
     struct inject_plugin_ctx *ctx = (struct inject_plugin_ctx *)plugin_ctx;
     struct config *config = &ctx->config;
-    enum flow_direction flow_dir = session_get_current_flow_direction(sess);
+    enum flow_type type = session_get_flow_type(sess);
     INJTECT_PLUGIN_LOG_INFO(ctx->logger, "handle session msg: %s (C2S received packets: %lu, S2C received packets: %lu)",
                             session_get0_readable_addr(sess),
-                            session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED),
-                            session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED));
+                            session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED),
+                            session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED));
 
     struct packet_exdata pkt_exdata;
-    packet_exdata_init(pkt, flow_dir, &pkt_exdata);
+    packet_exdata_init(pkt, type, &pkt_exdata);
 
     if (config->family == AF_INET &&
         memcmp(&config->addr.v4, &pkt_exdata.src_addr.v4, sizeof(struct in_addr)) != 0 &&
@@ -473,55 +473,55 @@ static void on_sess_msg(struct session *sess, int topic_id, const void *msg, voi
         return;
     }
 
-    if (session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_INJECTED_PACKETS_SUCCESS) > 0 ||
-        session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_INJECTED_PACKETS_SUCCESS) > 0)
+    if (session_get_stat(sess, FLOW_TYPE_C2S, STAT_INJECTED_PACKETS_SUCCESS) > 0 ||
+        session_get_stat(sess, FLOW_TYPE_S2C, STAT_INJECTED_PACKETS_SUCCESS) > 0)
     {
         return;
     }
 
-    if (config->direction == FLOW_DIRECTION_C2S && session_get_stat(sess, FLOW_DIRECTION_C2S, STAT_RAW_PACKETS_RECEIVED) != config->number)
+    if (config->flow_type == FLOW_TYPE_C2S && session_get_stat(sess, FLOW_TYPE_C2S, STAT_RAW_PACKETS_RECEIVED) != config->number)
     {
         return;
     }
 
-    if (config->direction == FLOW_DIRECTION_S2C && session_get_stat(sess, FLOW_DIRECTION_S2C, STAT_RAW_PACKETS_RECEIVED) != config->number)
+    if (config->flow_type == FLOW_TYPE_S2C && session_get_stat(sess, FLOW_TYPE_S2C, STAT_RAW_PACKETS_RECEIVED) != config->number)
     {
         return;
     }
 
-    switch (config->type)
+    switch (config->inject_type)
     {
     case INJECT_TCP_RST:
-        build_and_send_tcp_packet(ctx, sess, &pkt_exdata, FLOW_DIRECTION_C2S, TH_RST | TH_ACK, NULL, 0);
-        build_and_send_tcp_packet(ctx, sess, &pkt_exdata, FLOW_DIRECTION_S2C, TH_RST | TH_ACK, NULL, 0);
+        build_and_send_tcp_packet(ctx, sess, &pkt_exdata, FLOW_TYPE_C2S, TH_RST | TH_ACK, NULL, 0);
+        build_and_send_tcp_packet(ctx, sess, &pkt_exdata, FLOW_TYPE_S2C, TH_RST | TH_ACK, NULL, 0);
         session_set_discard(sess);
         break;
     case INJECT_TCP_FIN:
-        build_and_send_tcp_packet(ctx, sess, &pkt_exdata, FLOW_DIRECTION_C2S, TH_FIN | TH_ACK, NULL, 0);
-        build_and_send_tcp_packet(ctx, sess, &pkt_exdata, FLOW_DIRECTION_S2C, TH_FIN | TH_ACK, NULL, 0);
+        build_and_send_tcp_packet(ctx, sess, &pkt_exdata, FLOW_TYPE_C2S, TH_FIN | TH_ACK, NULL, 0);
+        build_and_send_tcp_packet(ctx, sess, &pkt_exdata, FLOW_TYPE_S2C, TH_FIN | TH_ACK, NULL, 0);
         session_set_discard(sess);
         break;
     case INJECT_TCP_PAYLOAD:
         snprintf(buffer, sizeof(buffer), "HTTP/1.1 200 OK\r\nContent-Length: %d\r\n\r\n%s", 5 + 5 + 2, "Hello");
-        build_and_send_tcp_packet(ctx, sess, &pkt_exdata, FLOW_DIRECTION_S2C, TH_ACK, buffer, strlen(buffer)); // inject payload to client
-        build_and_send_tcp_packet(ctx, sess, &pkt_exdata, FLOW_DIRECTION_S2C, TH_ACK, "World\r\n", 7);         // inject payload to client
-        build_and_send_tcp_packet(ctx, sess, &pkt_exdata, FLOW_DIRECTION_S2C, TH_RST | TH_ACK, NULL, 0);       // inject RST to client
-        build_and_send_tcp_packet(ctx, sess, &pkt_exdata, FLOW_DIRECTION_C2S, TH_RST | TH_ACK, NULL, 0);       // inject RST to server
+        build_and_send_tcp_packet(ctx, sess, &pkt_exdata, FLOW_TYPE_S2C, TH_ACK, buffer, strlen(buffer)); // inject payload to client
+        build_and_send_tcp_packet(ctx, sess, &pkt_exdata, FLOW_TYPE_S2C, TH_ACK, "World\r\n", 7);         // inject payload to client
+        build_and_send_tcp_packet(ctx, sess, &pkt_exdata, FLOW_TYPE_S2C, TH_RST | TH_ACK, NULL, 0);       // inject RST to client
+        build_and_send_tcp_packet(ctx, sess, &pkt_exdata, FLOW_TYPE_C2S, TH_RST | TH_ACK, NULL, 0);       // inject RST to server
         session_set_discard(sess);
         break;
     case INJECT_TCP_PAYLOAD_FIN_RST:
         snprintf(buffer, sizeof(buffer), "HTTP/1.1 200 OK\r\nContent-Length: %d\r\n\r\n%s", 5 + 5 + 2, "Hello");
-        build_and_send_tcp_packet(ctx, sess, &pkt_exdata, FLOW_DIRECTION_S2C, TH_ACK, buffer, strlen(buffer)); // inject payload to client
-        build_and_send_tcp_packet(ctx, sess, &pkt_exdata, FLOW_DIRECTION_S2C, TH_ACK, "World\r\n", 7);         // inject payload to client
-        build_and_send_tcp_packet(ctx, sess, &pkt_exdata, FLOW_DIRECTION_S2C, TH_FIN | TH_ACK, NULL, 0);       // inject FIN to client
-        build_and_send_tcp_packet(ctx, sess, &pkt_exdata, FLOW_DIRECTION_S2C, TH_RST | TH_ACK, NULL, 0);       // inject RST to client
-        build_and_send_tcp_packet(ctx, sess, &pkt_exdata, FLOW_DIRECTION_C2S, TH_FIN | TH_ACK, NULL, 0);       // inject FIN to server
-        build_and_send_tcp_packet(ctx, sess, &pkt_exdata, FLOW_DIRECTION_C2S, TH_RST | TH_ACK, NULL, 0);       // inject RST to server
+        build_and_send_tcp_packet(ctx, sess, &pkt_exdata, FLOW_TYPE_S2C, TH_ACK, buffer, strlen(buffer)); // inject payload to client
+        build_and_send_tcp_packet(ctx, sess, &pkt_exdata, FLOW_TYPE_S2C, TH_ACK, "World\r\n", 7);         // inject payload to client
+        build_and_send_tcp_packet(ctx, sess, &pkt_exdata, FLOW_TYPE_S2C, TH_FIN | TH_ACK, NULL, 0);       // inject FIN to client
+        build_and_send_tcp_packet(ctx, sess, &pkt_exdata, FLOW_TYPE_S2C, TH_RST | TH_ACK, NULL, 0);       // inject RST to client
+        build_and_send_tcp_packet(ctx, sess, &pkt_exdata, FLOW_TYPE_C2S, TH_FIN | TH_ACK, NULL, 0);       // inject FIN to server
+        build_and_send_tcp_packet(ctx, sess, &pkt_exdata, FLOW_TYPE_C2S, TH_RST | TH_ACK, NULL, 0);       // inject RST to server
         session_set_discard(sess);
         break;
     case INJECT_UDP_PAYLOAD:
-        build_and_send_udp_packet(ctx, sess, &pkt_exdata, FLOW_DIRECTION_C2S, "Hello Server", 12);
-        build_and_send_udp_packet(ctx, sess, &pkt_exdata, FLOW_DIRECTION_S2C, "Hello Client", 12);
+        build_and_send_udp_packet(ctx, sess, &pkt_exdata, FLOW_TYPE_C2S, "Hello Server", 12);
+        build_and_send_udp_packet(ctx, sess, &pkt_exdata, FLOW_TYPE_S2C, "Hello Client", 12);
         session_set_discard(sess);
         break;
     case INJECT_CTRL_MSG: