rename flow_direction to flow_type

11 files changed, 491 insertions, 492 deletions

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