session manager support output fieldstat

infra/packet_io/pcap_io.c

@@ -333,7 +333,7 @@ static void *pcap_io_thread(void *arg)
             fclose(fp);
         }
     }
-    PCAP_IO_LOG_FATAL("pcap io thread read all pcap files");
+    PACKET_IO_LOG_FATAL("pcap io thread read all pcap files (files: %lu, pkts: %lu)", pcap_io->read_pcap_files, ATOMIC_READ(&pcap_io->read_pcap_pkts));
 
 erro_out:
     while (ATOMIC_READ(&pcap_io->io_thread_need_exit) == 0)
@@ -346,7 +346,7 @@ erro_out:
         usleep(1000); // 1ms
     }
 
-    PCAP_IO_LOG_FATAL("pcap io thread exit (read_pcap_files: %lu, read_pcap_pkts: %lu)", pcap_io->read_pcap_files, ATOMIC_READ(&pcap_io->read_pcap_pkts));
+    PACKET_IO_LOG_FATAL("pcap io thread exit");
     ATOMIC_SET(&pcap_io->io_thread_is_runing, 0);
 
     return NULL;

infra/packet_manager/packet_manager.c

@@ -36,6 +36,10 @@ struct packet_manager
     struct packet_manager_runtime *runtime[MAX_THREAD_NUM];
 };
 
+/******************************************************************************
+ * packet manager runtime
+ ******************************************************************************/
+
 const char *packet_stage_to_str(enum packet_stage stage)
 {
     switch (stage)

infra/session_manager/CMakeLists.txt

@@ -5,12 +5,14 @@ add_library(session_manager
     session_timer.c
     session_filter.c
     session_transition.c
-    session_manager_runtime.c
     session_manager.c
+    session_manager_cfg.c
+    session_manager_rte.c
+    session_manager_stat.c
 )
 target_include_directories(session_manager PUBLIC ${CMAKE_CURRENT_LIST_DIR})
 target_include_directories(session_manager PUBLIC ${CMAKE_SOURCE_DIR}/infra/)
 target_include_directories(session_manager PUBLIC ${CMAKE_SOURCE_DIR}/include)
-target_link_libraries(session_manager timeout packet_manager tcp_reassembly mq exdata)
+target_link_libraries(session_manager timeout packet_manager tcp_reassembly mq exdata fieldstat4)
 
 add_subdirectory(test)

infra/session_manager/session_filter.c

@@ -1,4 +1,3 @@
-#include "tuple.h"
 #include "dablooms.h"
 #include "session_filter.h"
 

infra/session_manager/session_filter.h

@@ -5,11 +5,10 @@ extern "C"
 {
 #endif
 
+#include "tuple.h"
+
 struct session_filter *session_filter_new(uint32_t capacity, uint32_t timeout, double error_rate, uint64_t now);
 void session_filter_free(struct session_filter *filter);
-
-// return 1: found
-// reutrn 0: no found
 int session_filter_lookup(struct session_filter *filter, const struct tuple6 *key, uint64_t now);
 void session_filter_add(struct session_filter *filter, const struct tuple6 *key, uint64_t now);
 

infra/session_manager/session_internal.h

@@ -10,9 +10,10 @@ extern "C"
 #include "tuple.h"
 #include "uthash.h"
 #include "timeout.h"
+#include "tcp_reassembly.h"
 #include "packet_internal.h"
 #include "stellar/session.h"
-#include "tcp_reassembly.h"
+#include "session_manager_stat.h"
 
 // output format: "${src_addr}:${src_port}-${dst_addr}:${dst_port}-${ip_proto}-${domain}"
 // output max len: (46 + 1 + 5) + 1 + (46 + 1 + 5) + 1 + 1 + 1 + 20 = 129
@@ -50,7 +51,7 @@ struct session
     struct tcp_segment empty_seg;
     TAILQ_ENTRY(session) lru_tqe;
     TAILQ_ENTRY(session) free_tqe;
-    TAILQ_ENTRY(session) evicte_tqe;
+    TAILQ_ENTRY(session) evc_tqe;
     UT_hash_handle hh1;
     UT_hash_handle hh2;
     UT_hash_handle hh3;
@@ -68,7 +69,7 @@ struct session
     enum session_type sess_type;
     enum session_state state;
     enum closing_reason reason;
-    struct session_manager_runtime *sess_mgr_rt;
+    struct session_manager_rte *sess_mgr_rte;
     struct session_manager_stat *sess_mgr_stat;
 };
 

infra/session_manager/session_manager_cfg.c

@@ -0,0 +1,128 @@
+#include "utils_internal.h"
+#include "session_manager_log.h"
+#include "session_manager_cfg.h"
+
+struct session_manager_cfg *session_manager_cfg_new(const char *toml_file)
+{
+    if (toml_file == NULL)
+    {
+        return NULL;
+    }
+
+    struct session_manager_cfg *sess_mgr_cfg = (struct session_manager_cfg *)calloc(1, sizeof(struct session_manager_cfg));
+    if (sess_mgr_cfg == NULL)
+    {
+        return NULL;
+    }
+
+    int ret = 0;
+    ret += load_toml_integer_config(toml_file, "instance.id", &sess_mgr_cfg->instance_id, 0, 4095);
+    ret += load_toml_integer_config(toml_file, "packet_io.thread_num", &sess_mgr_cfg->thread_num, 0, MAX_THREAD_NUM);
+
+    // max session number
+    ret += load_toml_integer_config(toml_file, "session_manager.tcp_session_max", &sess_mgr_cfg->tcp_session_max, RX_BURST_MAX * 2, UINT64_MAX);
+    ret += load_toml_integer_config(toml_file, "session_manager.udp_session_max", &sess_mgr_cfg->udp_session_max, RX_BURST_MAX * 2, UINT64_MAX);
+
+    // session overload
+    ret += load_toml_integer_config(toml_file, "session_manager.evict_old_on_tcp_table_limit", &sess_mgr_cfg->evict_old_on_tcp_table_limit, 0, 1);
+    ret += load_toml_integer_config(toml_file, "session_manager.evict_old_on_udp_table_limit", &sess_mgr_cfg->evict_old_on_udp_table_limit, 0, 1);
+
+    // limit
+    ret += load_toml_integer_config(toml_file, "session_manager.expire_period_ms", &sess_mgr_cfg->expire_period_ms, 0, 60000);
+    ret += load_toml_integer_config(toml_file, "session_manager.expire_batch_max", &sess_mgr_cfg->expire_batch_max, 1, 1024);
+
+    // TCP timeout
+    ret += load_toml_integer_config(toml_file, "session_manager.tcp_timeout_ms.init", &sess_mgr_cfg->tcp_timeout_ms.init, 1, 60000);
+    ret += load_toml_integer_config(toml_file, "session_manager.tcp_timeout_ms.handshake", &sess_mgr_cfg->tcp_timeout_ms.handshake, 1, 60000);
+    ret += load_toml_integer_config(toml_file, "session_manager.tcp_timeout_ms.data", &sess_mgr_cfg->tcp_timeout_ms.data, 1, 15999999000);
+    ret += load_toml_integer_config(toml_file, "session_manager.tcp_timeout_ms.half_closed", &sess_mgr_cfg->tcp_timeout_ms.half_closed, 1, 604800000);
+    ret += load_toml_integer_config(toml_file, "session_manager.tcp_timeout_ms.time_wait", &sess_mgr_cfg->tcp_timeout_ms.time_wait, 1, 60000);
+    ret += load_toml_integer_config(toml_file, "session_manager.tcp_timeout_ms.discard_default", &sess_mgr_cfg->tcp_timeout_ms.discard_default, 1, 15999999000);
+    ret += load_toml_integer_config(toml_file, "session_manager.tcp_timeout_ms.unverified_rst", &sess_mgr_cfg->tcp_timeout_ms.unverified_rst, 1, 60000);
+
+    // UDP timeout
+    ret += load_toml_integer_config(toml_file, "session_manager.udp_timeout_ms.data", &sess_mgr_cfg->udp_timeout_ms.data, 1, 15999999000);
+    ret += load_toml_integer_config(toml_file, "session_manager.udp_timeout_ms.discard_default", &sess_mgr_cfg->udp_timeout_ms.discard_default, 1, 15999999000);
+
+    // duplicated packet filter
+    ret += load_toml_integer_config(toml_file, "session_manager.duplicated_packet_bloom_filter.enable", &sess_mgr_cfg->duplicated_packet_bloom_filter.enable, 0, 1);
+    ret += load_toml_integer_config(toml_file, "session_manager.duplicated_packet_bloom_filter.capacity", &sess_mgr_cfg->duplicated_packet_bloom_filter.capacity, 1, 4294967295);
+    ret += load_toml_integer_config(toml_file, "session_manager.duplicated_packet_bloom_filter.time_window_ms", &sess_mgr_cfg->duplicated_packet_bloom_filter.time_window_ms, 1, 60000);
+    ret += load_toml_double_config(toml_file, "session_manager.duplicated_packet_bloom_filter.error_rate", (double *)&sess_mgr_cfg->duplicated_packet_bloom_filter.error_rate, 0.0, 1.0);
+
+    // eviction session filter
+    ret += load_toml_integer_config(toml_file, "session_manager.evicted_session_bloom_filter.enable", &sess_mgr_cfg->evicted_session_bloom_filter.enable, 0, 1);
+    ret += load_toml_integer_config(toml_file, "session_manager.evicted_session_bloom_filter.capacity", &sess_mgr_cfg->evicted_session_bloom_filter.capacity, 1, 4294967295);
+    ret += load_toml_integer_config(toml_file, "session_manager.evicted_session_bloom_filter.time_window_ms", &sess_mgr_cfg->evicted_session_bloom_filter.time_window_ms, 1, 60000);
+    ret += load_toml_double_config(toml_file, "session_manager.evicted_session_bloom_filter.error_rate", (double *)&sess_mgr_cfg->evicted_session_bloom_filter.error_rate, 0.0, 1.0);
+
+    // TCP reassembly
+    ret += load_toml_integer_config(toml_file, "session_manager.tcp_reassembly.enable", &sess_mgr_cfg->tcp_reassembly.enable, 0, 1);
+    ret += load_toml_integer_config(toml_file, "session_manager.tcp_reassembly.timeout_ms", &sess_mgr_cfg->tcp_reassembly.timeout_ms, 1, 60000);
+    ret += load_toml_integer_config(toml_file, "session_manager.tcp_reassembly.buffered_segments_max", &sess_mgr_cfg->tcp_reassembly.buffered_segments_max, 2, 4096);
+
+    if (ret != 0)
+    {
+        session_manager_cfg_free(sess_mgr_cfg);
+        return NULL;
+    }
+
+    return sess_mgr_cfg;
+}
+
+void session_manager_cfg_free(struct session_manager_cfg *sess_mgr_cfg)
+{
+    if (sess_mgr_cfg)
+    {
+        free(sess_mgr_cfg);
+        sess_mgr_cfg = NULL;
+    }
+}
+
+void session_manager_cfg_print(struct session_manager_cfg *sess_mgr_cfg)
+{
+    if (sess_mgr_cfg)
+    {
+        // max session number
+        SESSION_MANAGER_LOG_INFO("session_manager.tcp_session_max                               : %lu", sess_mgr_cfg->tcp_session_max);
+        SESSION_MANAGER_LOG_INFO("session_manager.udp_session_max                               : %lu", sess_mgr_cfg->udp_session_max);
+
+        // session overload
+        SESSION_MANAGER_LOG_INFO("session_manager.evict_old_on_tcp_table_limit                  : %d", sess_mgr_cfg->evict_old_on_tcp_table_limit);
+        SESSION_MANAGER_LOG_INFO("session_manager.evict_old_on_udp_table_limit                  : %d", sess_mgr_cfg->evict_old_on_udp_table_limit);
+
+        // limit
+        SESSION_MANAGER_LOG_INFO("session_manager.expire_period_ms                              : %lu", sess_mgr_cfg->expire_period_ms);
+        SESSION_MANAGER_LOG_INFO("session_manager.expire_batch_max                              : %lu", sess_mgr_cfg->expire_batch_max);
+
+        // TCP timeout
+        SESSION_MANAGER_LOG_INFO("session_manager.tcp_timeout_ms.init                           : %lu", sess_mgr_cfg->tcp_timeout_ms.init);
+        SESSION_MANAGER_LOG_INFO("session_manager.tcp_timeout_ms.handshake                      : %lu", sess_mgr_cfg->tcp_timeout_ms.handshake);
+        SESSION_MANAGER_LOG_INFO("session_manager.tcp_timeout_ms.data                           : %lu", sess_mgr_cfg->tcp_timeout_ms.data);
+        SESSION_MANAGER_LOG_INFO("session_manager.tcp_timeout_ms.half_closed                    : %lu", sess_mgr_cfg->tcp_timeout_ms.half_closed);
+        SESSION_MANAGER_LOG_INFO("session_manager.tcp_timeout_ms.time_wait                      : %lu", sess_mgr_cfg->tcp_timeout_ms.time_wait);
+        SESSION_MANAGER_LOG_INFO("session_manager.tcp_timeout_ms.discard_default                : %lu", sess_mgr_cfg->tcp_timeout_ms.discard_default);
+        SESSION_MANAGER_LOG_INFO("session_manager.tcp_timeout_ms.unverified_rst                 : %lu", sess_mgr_cfg->tcp_timeout_ms.unverified_rst);
+
+        // UDP timeout
+        SESSION_MANAGER_LOG_INFO("session_manager.udp_timeout_ms.data                           : %lu", sess_mgr_cfg->udp_timeout_ms.data);
+        SESSION_MANAGER_LOG_INFO("session_manager.udp_timeout_ms.discard_default                : %lu", sess_mgr_cfg->udp_timeout_ms.discard_default);
+
+        // duplicated packet filter
+        SESSION_MANAGER_LOG_INFO("session_manager.duplicated_packet_bloom_filter.enable         : %d", sess_mgr_cfg->duplicated_packet_bloom_filter.enable);
+        SESSION_MANAGER_LOG_INFO("session_manager.duplicated_packet_bloom_filter.capacity       : %lu", sess_mgr_cfg->duplicated_packet_bloom_filter.capacity);
+        SESSION_MANAGER_LOG_INFO("session_manager.duplicated_packet_bloom_filter.time_window_ms : %lu", sess_mgr_cfg->duplicated_packet_bloom_filter.time_window_ms);
+        SESSION_MANAGER_LOG_INFO("session_manager.duplicated_packet_bloom_filter.error_rate     : %f", sess_mgr_cfg->duplicated_packet_bloom_filter.error_rate);
+
+        // eviction session filter
+        SESSION_MANAGER_LOG_INFO("session_manager.evicted_session_bloom_filter.enable           : %d", sess_mgr_cfg->evicted_session_bloom_filter.enable);
+        SESSION_MANAGER_LOG_INFO("session_manager.evicted_session_bloom_filter.capacity         : %lu", sess_mgr_cfg->evicted_session_bloom_filter.capacity);
+        SESSION_MANAGER_LOG_INFO("session_manager.evicted_session_bloom_filter.time_window_ms   : %lu", sess_mgr_cfg->evicted_session_bloom_filter.time_window_ms);
+        SESSION_MANAGER_LOG_INFO("session_manager.evicted_session_bloom_filter.error_rate       : %f", sess_mgr_cfg->evicted_session_bloom_filter.error_rate);
+
+        // TCP reassembly
+        SESSION_MANAGER_LOG_INFO("session_manager.tcp_reassembly.enable                         : %d", sess_mgr_cfg->tcp_reassembly.enable);
+        SESSION_MANAGER_LOG_INFO("session_manager.tcp_reassembly.timeout_ms                     : %lu", sess_mgr_cfg->tcp_reassembly.timeout_ms);
+        SESSION_MANAGER_LOG_INFO("session_manager.tcp_reassembly.buffered_segments_max          : %lu", sess_mgr_cfg->tcp_reassembly.buffered_segments_max);
+    }
+}

infra/session_manager/session_manager_cfg.h

@@ -0,0 +1,72 @@
+#pragma once
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#include <stdint.h>
+
+struct session_manager_cfg
+{
+    uint64_t instance_id;
+    uint64_t thread_num;
+    uint64_t session_id_seed;
+
+    uint64_t tcp_session_max;
+    uint64_t udp_session_max;
+
+    uint64_t evict_old_on_tcp_table_limit; // range: [0, 1]
+    uint64_t evict_old_on_udp_table_limit; // range: [0, 1]
+
+    uint64_t expire_period_ms; // range: [0, 60000] (ms)
+    uint64_t expire_batch_max; // range: [1, 1024]
+
+    struct
+    {
+        uint64_t init;            // range: [1, 60000] (ms)
+        uint64_t handshake;       // range: [1, 60000] (ms)
+        uint64_t data;            // range: [1, 15999999000] (ms)
+        uint64_t half_closed;     // range: [1, 604800000] (ms)
+        uint64_t time_wait;       // range: [1, 600000] (ms)
+        uint64_t discard_default; // range: [1, 15999999000] (ms)
+        uint64_t unverified_rst;  // range: [1, 600000] (ms)
+    } tcp_timeout_ms;
+
+    struct
+    {
+        uint64_t data;            // range: [1, 15999999000] (ms)
+        uint64_t discard_default; // range: [1, 15999999000] (ms)
+    } udp_timeout_ms;
+
+    struct
+    {
+        uint64_t enable;          // range: [0, 1]
+        uint64_t capacity;       // range: [1, 4294967295]
+        uint64_t time_window_ms; // range: [1, 60000] (ms)
+        double error_rate;       // range: [0.0, 1.0]
+    } duplicated_packet_bloom_filter;
+
+    struct
+    {
+        uint64_t enable;          // range: [0, 1]
+        uint64_t capacity;       // range: [1, 4294967295]
+        uint64_t time_window_ms; // range: [1, 60000] (ms)
+        double error_rate;       // range: [0.0, 1.0]
+    } evicted_session_bloom_filter;
+
+    struct
+    {
+        uint64_t enable;                 // range: [0, 1]
+        uint64_t timeout_ms;            // range: [1, 60000] (ms)
+        uint64_t buffered_segments_max; // range: [2, 4096]
+    } tcp_reassembly;
+};
+
+struct session_manager_cfg *session_manager_cfg_new(const char *toml_file);
+void session_manager_cfg_free(struct session_manager_cfg *sess_mgr_cfg);
+void session_manager_cfg_print(struct session_manager_cfg *sess_mgr_cfg);
+
+#ifdef __cplusplus
+}
+#endif

infra/session_manager/session_manager_log.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#include "log_internal.h"
+
+#define SESSION_MANAGER_LOG_FATAL(format, ...) STELLAR_LOG_FATAL(__thread_local_logger, "session manager", format, ##__VA_ARGS__)
+#define SESSION_MANAGER_LOG_ERROR(format, ...) STELLAR_LOG_ERROR(__thread_local_logger, "session manager", format, ##__VA_ARGS__)
+#define SESSION_MANAGER_LOG_DEBUG(format, ...) STELLAR_LOG_DEBUG(__thread_local_logger, "session manager", format, ##__VA_ARGS__)
+#define SESSION_MANAGER_LOG_INFO(format, ...) STELLAR_LOG_INFO(__thread_local_logger, "session manager", format, ##__VA_ARGS__)
+
+#ifdef __cplusplus
+}
+#endif

infra/session_manager/session_manager_rte.h

@@ -0,0 +1,67 @@
+#pragma once
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#include "tuple.h"
+#include "stellar/session.h"
+
+enum session_scan_flags
+{
+    SESSION_SCAN_TYPE = 1 << 0,
+    SESSION_SCAN_STATE = 1 << 1,
+    SESSION_SCAN_SIP = 1 << 2,
+    SESSION_SCAN_DIP = 1 << 3,
+    SESSION_SCAN_SPORT = 1 << 4,
+    SESSION_SCAN_DPORT = 1 << 5,
+    SESSION_SCAN_CREATE_TIME = 1 << 6,
+    SESSION_SCAN_LASPKT_TIME = 1 << 7,
+};
+
+struct session_scan_opts
+{
+    // required
+    uint32_t flags;
+    uint32_t cursor;
+    uint32_t count;
+
+    // optional
+    enum session_type type;
+    enum session_state state;
+
+    uint32_t addr_family;         // AF_INET or AF_INET6
+    union ip_address src_addr[2]; // network byte order
+    union ip_address dst_addr[2]; // network byte order
+    uint16_t src_port;            // network byte order
+    uint16_t dst_port;            // network byte order
+
+    uint64_t create_time_ms[2]; // session create time range
+    uint64_t laspkt_time_ms[2]; // last packet time range
+};
+
+struct session_manager_rte;
+struct session_manager_rte *session_manager_rte_new(const struct session_manager_cfg *sess_mgr_cfg, uint64_t now_ms);
+void session_manager_rte_free(struct session_manager_rte *sess_mgr_rte);
+
+struct session *session_manager_rte_new_session(struct session_manager_rte *sess_mgr_rte, const struct packet *pkt, uint64_t now_ms);
+void session_manager_rte_free_session(struct session_manager_rte *sess_mgr_rte, struct session *sess);
+
+struct session *session_manager_rte_lookup_session_by_packet(struct session_manager_rte *sess_mgr_rte, const struct packet *pkt);
+struct session *session_manager_rte_lookup_session_by_id(struct session_manager_rte *sess_mgr_rte, uint64_t sess_id);
+int session_manager_rte_update_session(struct session_manager_rte *sess_mgr_rte, struct session *sess, const struct packet *pkt, uint64_t now_ms);
+
+struct session *session_manager_rte_get_expired_session(struct session_manager_rte *sess_mgr_rte, uint64_t now_ms);
+struct session *session_manager_rte_get_evicted_session(struct session_manager_rte *sess_mgr_rte);
+
+uint64_t session_manager_rte_clean_session(struct session_manager_rte *sess_mgr_rte, uint64_t now_ms, struct session *cleaned_sess_ptr[], uint64_t array_size);
+uint64_t session_manager_rte_scan_session(struct session_manager_rte *sess_mgr_rte, const struct session_scan_opts *opts, uint64_t mached_sess_id[], uint64_t array_size);
+
+void session_manager_rte_record_duplicated_packet(struct session_manager_rte *sess_mgr_rte, const struct packet *pkt);
+
+struct session_manager_stat *session_manager_rte_get_stat(struct session_manager_rte *sess_mgr_rte);
+
+#ifdef __cplusplus
+}
+#endif

infra/session_manager/session_manager_runtime.h

@@ -1,184 +0,0 @@
-#pragma once
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-#include "tuple.h"
-#include "stellar/session.h"
-
-#define SESSION_MANAGER_LOG_FATAL(format, ...) STELLAR_LOG_FATAL(__thread_local_logger, "session manager", format, ##__VA_ARGS__)
-#define SESSION_MANAGER_LOG_ERROR(format, ...) STELLAR_LOG_ERROR(__thread_local_logger, "session manager", format, ##__VA_ARGS__)
-#define SESSION_MANAGER_LOG_DEBUG(format, ...) STELLAR_LOG_DEBUG(__thread_local_logger, "session manager", format, ##__VA_ARGS__)
-#define SESSION_MANAGER_LOG_INFO(format, ...) STELLAR_LOG_INFO(__thread_local_logger, "session manager", format, ##__VA_ARGS__)
-
-struct session_manager_config
-{
-    uint64_t instance_id;
-    uint16_t thread_num;
-    uint64_t session_id_seed;
-    uint64_t tcp_session_max;
-    uint64_t udp_session_max;
-
-    uint8_t evict_old_on_tcp_table_limit; // range: [0, 1]
-    uint8_t evict_old_on_udp_table_limit; // range: [0, 1]
-
-    uint64_t expire_period_ms; // range: [0, 60000] (ms)
-    uint64_t expire_batch_max; // range: [1, 1024]
-
-    struct
-    {
-        uint64_t init;            // range: [1, 60000] (ms)
-        uint64_t handshake;       // range: [1, 60000] (ms)
-        uint64_t data;            // range: [1, 15999999000] (ms)
-        uint64_t half_closed;     // range: [1, 604800000] (ms)
-        uint64_t time_wait;       // range: [1, 600000] (ms)
-        uint64_t discard_default; // range: [1, 15999999000] (ms)
-        uint64_t unverified_rst;  // range: [1, 600000] (ms)
-    } tcp_timeout_ms;
-
-    struct
-    {
-        uint64_t data;            // range: [1, 15999999000] (ms)
-        uint64_t discard_default; // range: [1, 15999999000] (ms)
-    } udp_timeout_ms;
-
-    struct
-    {
-        uint8_t enable;          // range: [0, 1]
-        uint32_t capacity;       // range: [1, 4294967295]
-        uint32_t time_window_ms; // range: [1, 60000] (ms)
-        double error_rate;       // range: [0.0, 1.0]
-    } duplicated_packet_bloom_filter;
-
-    struct
-    {
-        uint8_t enable;          // range: [0, 1]
-        uint32_t capacity;       // range: [1, 4294967295]
-        uint32_t time_window_ms; // range: [1, 60000] (ms)
-        double error_rate;       // range: [0.0, 1.0]
-    } evicted_session_bloom_filter;
-
-    struct
-    {
-        uint8_t enable;                 // range: [0, 1]
-        uint32_t timeout_ms;            // range: [1, 60000] (ms)
-        uint32_t buffered_segments_max; // range: [2, 4096]
-    } tcp_reassembly;
-};
-
-struct session_manager_stat
-{
-    // TCP session
-    uint64_t history_tcp_sessions;
-    uint64_t tcp_sess_used;
-    uint64_t tcp_sess_opening;
-    uint64_t tcp_sess_active;
-    uint64_t tcp_sess_closing;
-    uint64_t tcp_sess_discard;
-    uint64_t tcp_sess_closed;
-
-    // UDP session
-    uint64_t history_udp_sessions;
-    uint64_t udp_sess_used;
-    uint64_t udp_sess_opening;
-    uint64_t udp_sess_active;
-    uint64_t udp_sess_closing;
-    uint64_t udp_sess_discard;
-    uint64_t udp_sess_closed;
-
-    // Evicted session
-    uint64_t tcp_sess_evicted; // sum
-    uint64_t udp_sess_evicted; // sum
-
-    // Packet
-    uint64_t udp_pkts_bypass_table_full;        // sum
-    uint64_t tcp_pkts_bypass_table_full;        // sum
-    uint64_t tcp_pkts_bypass_session_not_found; // sum
-    uint64_t tcp_pkts_bypass_duplicated;        // sum
-    uint64_t udp_pkts_bypass_duplicated;        // sum
-    uint64_t udp_pkts_bypass_session_evicted;   // sum
-
-    // TCP segments
-    uint64_t tcp_segs_input;            // sum
-    uint64_t tcp_segs_consumed;         // sum
-    uint64_t tcp_segs_timeout;          // sum
-    uint64_t tcp_segs_retransmited;     // sum
-    uint64_t tcp_segs_overlapped;       // sum
-    uint64_t tcp_segs_omitted_too_many; // sum
-    uint64_t tcp_segs_inorder;          // sum
-    uint64_t tcp_segs_reordered;        // sum
-    uint64_t tcp_segs_buffered;         // sum
-    uint64_t tcp_segs_freed;            // sum
-} __attribute__((aligned(64)));
-
-enum session_scan_flags
-{
-    SESSION_SCAN_TYPE = 1 << 0,
-    SESSION_SCAN_STATE = 1 << 1,
-
-    SESSION_SCAN_SIP = 1 << 2,
-    SESSION_SCAN_DIP = 1 << 3,
-
-    SESSION_SCAN_SPORT = 1 << 4,
-    SESSION_SCAN_DPORT = 1 << 5,
-
-    SESSION_SCAN_CREATE_TIME = 1 << 6,
-    SESSION_SCAN_LAST_PKT_TIME = 1 << 7,
-};
-
-struct session_scan_opts
-{
-    // required
-    uint32_t flags;
-    uint32_t cursor;
-    uint32_t count;
-
-    // optional
-    enum session_type type;
-    enum session_state state;
-
-    uint32_t addr_family;         // AF_INET or AF_INET6
-    union ip_address src_addr[2]; // network byte order
-    union ip_address dst_addr[2]; // network byte order
-    uint16_t src_port;            // network byte order
-    uint16_t dst_port;            // network byte order
-
-    uint64_t create_time_ms[2];
-    uint64_t last_pkt_time_ms[2];
-};
-
-// new/free/print config
-struct session_manager_config *session_manager_config_new(const char *toml_file);
-void session_manager_config_free(struct session_manager_config *sess_mgr_cfg);
-void session_manager_config_print(struct session_manager_config *sess_mgr_cfg);
-
-// new/free runtime
-struct session_manager_runtime;
-struct session_manager_runtime *session_manager_runtime_new(const struct session_manager_config *sess_mgr_cfg, uint64_t now_ms);
-void session_manager_runtime_free(struct session_manager_runtime *sess_mgr_rt);
-
-// new/free/lookup/update/clean session
-struct session *session_manager_runtime_new_session(struct session_manager_runtime *sess_mgr_rt, const struct packet *pkt, uint64_t now_ms);
-void session_manager_runtime_free_session(struct session_manager_runtime *sess_mgr_rt, struct session *sess);
-struct session *session_manager_runtime_lookup_session_by_packet(struct session_manager_runtime *sess_mgr_rt, const struct packet *pkt);
-struct session *session_manager_runtime_lookup_session_by_id(struct session_manager_runtime *sess_mgr_rt, uint64_t sess_id);
-int session_manager_runtime_update_session(struct session_manager_runtime *sess_mgr_rt, struct session *sess, const struct packet *pkt, uint64_t now_ms);
-struct session *session_manager_runtime_get_expired_session(struct session_manager_runtime *sess_mgr_rt, uint64_t now_ms);
-struct session *session_manager_runtime_get_evicted_session(struct session_manager_runtime *sess_mgr_rt);
-uint64_t session_manager_runtime_clean_session(struct session_manager_runtime *sess_mgr_rt, uint64_t now_ms, struct session *cleaned_sess[], uint64_t array_size);
-
-// stat
-struct session_manager_stat *session_manager_runtime_get_stat(struct session_manager_runtime *sess_mgr_rt);
-void session_manager_runtime_print_stat(struct session_manager_runtime *sess_mgr_rt);
-
-// scan
-uint64_t session_manager_runtime_scan(const struct session_manager_runtime *sess_mgr_rt, const struct session_scan_opts *opts, uint64_t mached_sess_ids[], uint64_t array_size);
-
-// duplicated packet
-void session_manager_runtime_record_duplicated_packet(struct session_manager_runtime *sess_mgr_rt, const struct packet *pkt);
-
-#ifdef __cplusplus
-}
-#endif

infra/session_manager/session_manager_stat.c

@@ -0,0 +1,39 @@
+#include "session_manager_log.h"
+#include "session_manager_stat.h"
+
+uint64_t session_manager_stat_get(struct session_manager_stat *stat, enum sess_mgr_stat_type type)
+{
+    switch (type)
+    {
+#define XX(_type, _name) case _type: return stat->_name;
+    SESS_MGR_STAT_MAP(XX)
+#undef XX
+    default:
+        return 0;
+    }
+}
+
+void session_manager_stat_print(struct session_manager_stat *stat)
+{
+    // TCP session
+    SESSION_MANAGER_LOG_INFO("runtime: %p, TCP session stat => history: %lu, used: %lu, opening: %lu, active: %lu, closing: %lu, discard: %lu, closed: %lu",
+                             stat, stat->history_tcp_sessions, stat->tcp_sess_used, stat->tcp_sess_opening, stat->tcp_sess_active,
+                             stat->tcp_sess_closing, stat->tcp_sess_discard, stat->tcp_sess_closed);
+    // UDP session
+    SESSION_MANAGER_LOG_INFO("runtime: %p, UDP session stat => history: %lu, used: %lu, opening: %lu, active: %lu, closing: %lu, discard: %lu, closed: %lu",
+                             stat, stat->history_udp_sessions, stat->udp_sess_used, stat->udp_sess_opening, stat->udp_sess_active,
+                             stat->udp_sess_closing, stat->udp_sess_discard, stat->udp_sess_closed);
+    // Evicted session
+    SESSION_MANAGER_LOG_INFO("runtime: %p, evicted session stat => TCP: %lu, UDP: %lu",
+                             stat, stat->tcp_sess_evicted, stat->udp_sess_evicted);
+    // Bypassed packet
+    SESSION_MANAGER_LOG_INFO("runtime: %p, bypassed TCP packet stat => table_full: %lu, session_not_found: %lu, duplicated: %lu",
+                             stat, stat->tcp_pkts_bypass_table_full, stat->tcp_pkts_bypass_session_not_found, stat->tcp_pkts_bypass_duplicated);
+    SESSION_MANAGER_LOG_INFO("runtime: %p, bypassed UDP packet stat => table_full: %lu, session_evicted: %lu, duplicated: %lu",
+                             stat, stat->udp_pkts_bypass_table_full, stat->udp_pkts_bypass_session_evicted, stat->udp_pkts_bypass_duplicated);
+    // TCP segment
+    SESSION_MANAGER_LOG_INFO("runtime: %p, TCP segment stat => input: %lu, consumed: %lu, timeout: %lu, retransmited: %lu, overlapped: %lu, omitted_too_many: %lu, inorder: %lu, reordered: %lu, buffered: %lu, freed: %lu",
+                             stat, stat->tcp_segs_input, stat->tcp_segs_consumed, stat->tcp_segs_timeout, stat->tcp_segs_retransmited,
+                             stat->tcp_segs_overlapped, stat->tcp_segs_omitted_too_many, stat->tcp_segs_inorder, stat->tcp_segs_reordered,
+                             stat->tcp_segs_buffered, stat->tcp_segs_freed);
+}

infra/session_manager/session_manager_stat.h

@@ -0,0 +1,166 @@
+#pragma once
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#include <stdint.h>
+
+#define SESS_MGR_STAT_INC(stat, state, proto) \
+    {                                         \
+        switch ((state))                      \
+        {                                     \
+        case SESSION_STATE_OPENING:           \
+            (stat)->proto##_sess_opening++;   \
+            break;                            \
+        case SESSION_STATE_ACTIVE:            \
+            (stat)->proto##_sess_active++;    \
+            break;                            \
+        case SESSION_STATE_CLOSING:           \
+            (stat)->proto##_sess_closing++;   \
+            break;                            \
+        case SESSION_STATE_DISCARD:           \
+            (stat)->proto##_sess_discard++;   \
+            break;                            \
+        case SESSION_STATE_CLOSED:            \
+            (stat)->proto##_sess_closed++;    \
+            break;                            \
+        default:                              \
+            break;                            \
+        }                                     \
+    }
+
+#define SESS_MGR_STAT_DEC(stat, state, proto) \
+    {                                         \
+        switch ((state))                      \
+        {                                     \
+        case SESSION_STATE_OPENING:           \
+            (stat)->proto##_sess_opening--;   \
+            break;                            \
+        case SESSION_STATE_ACTIVE:            \
+            (stat)->proto##_sess_active--;    \
+            break;                            \
+        case SESSION_STATE_CLOSING:           \
+            (stat)->proto##_sess_closing--;   \
+            break;                            \
+        case SESSION_STATE_DISCARD:           \
+            (stat)->proto##_sess_discard--;   \
+            break;                            \
+        case SESSION_STATE_CLOSED:            \
+            (stat)->proto##_sess_closed--;    \
+            break;                            \
+        default:                              \
+            break;                            \
+        }                                     \
+    }
+
+#define SESS_MGR_STAT_UPDATE(stat, curr, next, proto) \
+    {                                                 \
+        if (curr != next)                             \
+        {                                             \
+            SESS_MGR_STAT_DEC(stat, curr, proto);     \
+            SESS_MGR_STAT_INC(stat, next, proto);     \
+        }                                             \
+    }
+
+struct session_manager_stat
+{
+    // TCP session
+    uint64_t history_tcp_sessions;
+    uint64_t tcp_sess_used;
+    uint64_t tcp_sess_opening;
+    uint64_t tcp_sess_active;
+    uint64_t tcp_sess_closing;
+    uint64_t tcp_sess_discard;
+    uint64_t tcp_sess_closed;
+
+    // UDP session
+    uint64_t history_udp_sessions;
+    uint64_t udp_sess_used;
+    uint64_t udp_sess_opening;
+    uint64_t udp_sess_active;
+    uint64_t udp_sess_closing;
+    uint64_t udp_sess_discard;
+    uint64_t udp_sess_closed;
+
+    // Evicted session
+    uint64_t tcp_sess_evicted; // sum
+    uint64_t udp_sess_evicted; // sum
+
+    // Packet
+    uint64_t udp_pkts_bypass_table_full;        // sum
+    uint64_t tcp_pkts_bypass_table_full;        // sum
+    uint64_t tcp_pkts_bypass_session_not_found; // sum
+    uint64_t tcp_pkts_bypass_duplicated;        // sum
+    uint64_t udp_pkts_bypass_duplicated;        // sum
+    uint64_t udp_pkts_bypass_session_evicted;   // sum
+
+    // TCP segments
+    uint64_t tcp_segs_input;            // sum
+    uint64_t tcp_segs_consumed;         // sum
+    uint64_t tcp_segs_timeout;          // sum
+    uint64_t tcp_segs_retransmited;     // sum
+    uint64_t tcp_segs_overlapped;       // sum
+    uint64_t tcp_segs_omitted_too_many; // sum
+    uint64_t tcp_segs_inorder;          // sum
+    uint64_t tcp_segs_reordered;        // sum
+    uint64_t tcp_segs_buffered;         // sum
+    uint64_t tcp_segs_freed;            // sum
+} __attribute__((aligned(64)));
+
+#define SESS_MGR_STAT_MAP(XX)                                                              \
+    XX(SESS_MGR_STAT_HISTORY_TCP_SESSIONS, history_tcp_sessions)                           \
+    XX(SESS_MGR_STAT_TCP_SESS_USED, tcp_sess_used)                                         \
+    XX(SESS_MGR_STAT_TCP_SESS_OPENING, tcp_sess_opening)                                   \
+    XX(SESS_MGR_STAT_TCP_SESS_ACTIVE, tcp_sess_active)                                     \
+    XX(SESS_MGR_STAT_TCP_SESS_CLOSING, tcp_sess_closing)                                   \
+    XX(SESS_MGR_STAT_TCP_SESS_DISCARD, tcp_sess_discard)                                   \
+    XX(SESS_MGR_STAT_TCP_SESS_CLOSED, tcp_sess_closed)                                     \
+    XX(SESS_MGR_STAT_HISTORY_UDP_SESSIONS, history_udp_sessions)                           \
+    XX(SESS_MGR_STAT_UDP_SESS_USED, udp_sess_used)                                         \
+    XX(SESS_MGR_STAT_UDP_SESS_OPENING, udp_sess_opening)                                   \
+    XX(SESS_MGR_STAT_UDP_SESS_ACTIVE, udp_sess_active)                                     \
+    XX(SESS_MGR_STAT_UDP_SESS_CLOSING, udp_sess_closing)                                   \
+    XX(SESS_MGR_STAT_UDP_SESS_DISCARD, udp_sess_discard)                                   \
+    XX(SESS_MGR_STAT_UDP_SESS_CLOSED, udp_sess_closed)                                     \
+    XX(SESS_MGR_STAT_TCP_SESS_EVICTED, tcp_sess_evicted)                                   \
+    XX(SESS_MGR_STAT_UDP_SESS_EVICTED, udp_sess_evicted)                                   \
+    XX(SESS_MGR_STAT_UDP_PKTS_BYPASS_TABLE_FULL, udp_pkts_bypass_table_full)               \
+    XX(SESS_MGR_STAT_TCP_PKTS_BYPASS_TABLE_FULL, tcp_pkts_bypass_table_full)               \
+    XX(SESS_MGR_STAT_TCP_PKTS_BYPASS_SESSION_NOT_FOUND, tcp_pkts_bypass_session_not_found) \
+    XX(SESS_MGR_STAT_TCP_PKTS_BYPASS_DUPLICATED, tcp_pkts_bypass_duplicated)               \
+    XX(SESS_MGR_STAT_UDP_PKTS_BYPASS_DUPLICATED, udp_pkts_bypass_duplicated)               \
+    XX(SESS_MGR_STAT_UDP_PKTS_BYPASS_SESSION_EVICTED, udp_pkts_bypass_session_evicted)     \
+    XX(SESS_MGR_STAT_TCP_SEGS_INPUT, tcp_segs_input)                                       \
+    XX(SESS_MGR_STAT_TCP_SEGS_CONSUMED, tcp_segs_consumed)                                 \
+    XX(SESS_MGR_STAT_TCP_SEGS_TIMEOUT, tcp_segs_timeout)                                   \
+    XX(SESS_MGR_STAT_TCP_SEGS_RETRANSMITED, tcp_segs_retransmited)                         \
+    XX(SESS_MGR_STAT_TCP_SEGS_OVERLAPPED, tcp_segs_overlapped)                             \
+    XX(SESS_MGR_STAT_TCP_SEGS_OMITTED_TOO_MANY, tcp_segs_omitted_too_many)                 \
+    XX(SESS_MGR_STAT_TCP_SEGS_INORDER, tcp_segs_inorder)                                   \
+    XX(SESS_MGR_STAT_TCP_SEGS_REORDERED, tcp_segs_reordered)                               \
+    XX(SESS_MGR_STAT_TCP_SEGS_BUFFERED, tcp_segs_buffered)                                 \
+    XX(SESS_MGR_STAT_TCP_SEGS_FREED, tcp_segs_freed)
+
+enum sess_mgr_stat_type
+{
+#define XX(type, name) type,
+    SESS_MGR_STAT_MAP(XX)
+#undef XX
+    SESS_MGR_STAT_MAX
+};
+
+__attribute__((unused)) static const char sess_mgr_stat_str[SESS_MGR_STAT_MAX][64] =
+{
+#define XX(type, name) #name,
+    SESS_MGR_STAT_MAP(XX)
+#undef XX
+};
+
+uint64_t session_manager_stat_get(struct session_manager_stat *stat, enum sess_mgr_stat_type type);
+void session_manager_stat_print(struct session_manager_stat *stat);
+
+#ifdef __cplusplus
+}
+#endif

infra/session_manager/session_table.h

@@ -5,6 +5,8 @@ extern "C"
 {
 #endif
 
+#include "tuple.h"
+
 struct session_table;
 struct session_table *session_table_new();
 void session_table_free(struct session_table *table);

infra/session_manager/session_utils.c

@@ -1,6 +1,6 @@
 #include "stellar/exdata.h"
 #include "session_internal.h"
-#include "session_manager_runtime.h"
+#include "session_manager_stat.h"
 
 void session_init(struct session *sess)
 {

infra/session_manager/test/default_config.h

@@ -1,68 +0,0 @@
-
-
-#pragma once
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-#include "session_manager_runtime.h"
-
-static struct session_manager_config sess_mgr_cfg = {
-    .instance_id = 1,
-    .thread_num = 1,
-    .session_id_seed = 0xFFFFF,
-    .tcp_session_max = 256,
-    .udp_session_max = 256,
-
-    .evict_old_on_tcp_table_limit = 1,
-    .evict_old_on_udp_table_limit = 1,
-
-    .expire_period_ms = 0,
-    .expire_batch_max = 1024,
-
-    .tcp_timeout_ms =
-        {
-            .init = 1,
-            .handshake = 2,
-            .data = 3,
-            .half_closed = 4,
-            .time_wait = 5,
-            .discard_default = 6,
-            .unverified_rst = 7,
-        },
-
-    .udp_timeout_ms =
-        {
-            .data = 8,
-            .discard_default = 0,
-        },
-
-    .duplicated_packet_bloom_filter =
-        {
-            .enable = 1,
-            .capacity = 1000,
-            .time_window_ms = 10,
-            .error_rate = 0.0001,
-        },
-
-    .evicted_session_bloom_filter =
-        {
-            .enable = 1,
-            .capacity = 1000,
-            .time_window_ms = 10,
-            .error_rate = 0.0001,
-        },
-
-    .tcp_reassembly =
-        {
-            .enable = 1,
-            .timeout_ms = 1000,
-            .buffered_segments_max = 16,
-        },
-};
-
-#ifdef __cplusplus
-}
-#endif

infra/session_manager/test/gtest_case_tcp_fast_open.cpp

@@ -1,10 +1,4 @@
-#include <gtest/gtest.h>
+#include "test_utils.h"
-
-#include "tuple.h"
-#include "packet_internal.h"
-#include "packet_parser.h"
-#include "session_internal.h"
-#include "default_config.h"
 
 /******************************************************************************
  * case: TCP init -> opening (by TCP Fast Open)
@@ -263,11 +257,11 @@ TEST(CASE, TCP_FAST_OPEN)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S fast open packet\n");
@@ -276,9 +270,10 @@ TEST(CASE, TCP_FAST_OPEN)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
@@ -347,7 +342,7 @@ TEST(CASE, TCP_FAST_OPEN)
     session_free_tcp_segment(sess, seg);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1);
@@ -355,24 +350,25 @@ TEST(CASE, TCP_FAST_OPEN)
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.init) == NULL);                      // opening -> closing
+    EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.tcp_timeout_ms.init) == NULL);                      // opening -> closing
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.init + sess_mgr_cfg.tcp_timeout_ms.data); // closing -> closed
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.tcp_timeout_ms.init + sess_mgr_cfg.tcp_timeout_ms.data); // closing -> closed
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
     session_print(sess);
+
     // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
+    session_manager_rte_free_session(sess_mgr_rte, sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 

infra/session_manager/test/gtest_filter_tcp_dupkt.cpp

@@ -1,29 +1,15 @@
-#include <gtest/gtest.h>
+#include "test_utils.h"
-
-#include "packet_internal.h"
-#include "packet_parser.h"
-#include "session_internal.h"
-#include "default_config.h"
-#include "test_packets.h"
-
-static void packet_set_ip_id(struct packet *pkt, uint16_t ip_id)
-{
-    const struct layer_private *ipv4_layer = packet_get_innermost_layer(pkt, LAYER_PROTO_IPV4);
-    EXPECT_TRUE(ipv4_layer);
-    struct ip *hdr = (struct ip *)ipv4_layer->hdr_ptr;
-    hdr->ip_id = htons(ip_id);
-}
 
 #if 1
 TEST(TCP_DUPKT_FILTER_ENABLE, SYN_DUP)
 {
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -32,12 +18,15 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYN_DUP)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+
+    // check stat
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0);
 
@@ -48,12 +37,15 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYN_DUP)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == -1);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == -1);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 1);
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+
+    // check stat
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 1);
 
@@ -63,20 +55,23 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYN_DUP)
     memcpy(syn_retransmission, tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
     memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)syn_retransmission, sizeof(tcp_pkt1_c2s_syn));
-    packet_set_ip_id(&pkt, 0x1234);
+    packet_overwrite_ipid(&pkt, 0x1234);
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 3) == 0);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 1);
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+
+    // check stat
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 1);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
@@ -85,11 +80,11 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYNACK_DUP)
 {
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // S2C SYNACK Packet
     printf("\n=> Packet Parse: TCP S2C SYNACK packet\n");
@@ -98,12 +93,15 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYNACK_DUP)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+
+    // check stat
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0);
 
@@ -114,12 +112,15 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYNACK_DUP)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == -1);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == -1);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 1);
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+
+    // check stat
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 1);
 
@@ -129,20 +130,23 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYNACK_DUP)
     memcpy(synack_retransmission, tcp_pkt2_s2c_syn_ack, sizeof(tcp_pkt2_s2c_syn_ack));
     memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)synack_retransmission, sizeof(tcp_pkt2_s2c_syn_ack));
-    packet_set_ip_id(&pkt, 0x1234);
+    packet_overwrite_ipid(&pkt, 0x1234);
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 3) == 0);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 1);
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+
+    // check stat
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 1);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
@@ -151,12 +155,12 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SKIP)
 {
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
     char syn_retransmission[1500] = {0};
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -165,12 +169,15 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SKIP)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+
+    // check stat
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0);
 
@@ -179,16 +186,19 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SKIP)
     memcpy(syn_retransmission, tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
     memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)syn_retransmission, sizeof(tcp_pkt1_c2s_syn));
-    packet_set_ip_id(&pkt, 0x1234);
+    packet_overwrite_ipid(&pkt, 0x1234);
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+
+    // check stat
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0);
 
@@ -197,16 +207,19 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SKIP)
     memcpy(syn_retransmission, tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
     memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)syn_retransmission, sizeof(tcp_pkt1_c2s_syn));
-    packet_set_ip_id(&pkt, 0x1235);
+    packet_overwrite_ipid(&pkt, 0x1235);
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 3) == 0);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+
+    // check stat
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0);
 
@@ -217,16 +230,19 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SKIP)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 3) == 0);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+
+    // check stat
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
@@ -235,14 +251,14 @@ TEST(TCP_DUPKT_FILTER_DISABLE, SYN_DUP)
 {
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
-    struct session_manager_config _cfg;
+    struct session_manager_cfg _sess_mgr_cfg;
-    memcpy(&_cfg, &sess_mgr_cfg, sizeof(struct session_manager_config));
+    memcpy(&_sess_mgr_cfg, &sess_mgr_cfg, sizeof(struct session_manager_cfg));
-    _cfg.duplicated_packet_bloom_filter.enable = 0;
+    _sess_mgr_cfg.duplicated_packet_bloom_filter.enable = 0;
 
-    sess_mgr_rt = session_manager_runtime_new(&_cfg, 1);
+    sess_mgr_rte = session_manager_rte_new(&_sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -251,12 +267,15 @@ TEST(TCP_DUPKT_FILTER_DISABLE, SYN_DUP)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+
+    // check stat
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0);
 
@@ -267,16 +286,19 @@ TEST(TCP_DUPKT_FILTER_DISABLE, SYN_DUP)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+
+    // check stat
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
@@ -285,14 +307,14 @@ TEST(TCP_DUPKT_FILTER_DISABLE, SYNACK_DUP)
 {
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
-    struct session_manager_config _cfg;
+    struct session_manager_cfg _sess_mgr_cfg;
-    memcpy(&_cfg, &sess_mgr_cfg, sizeof(struct session_manager_config));
+    memcpy(&_sess_mgr_cfg, &sess_mgr_cfg, sizeof(struct session_manager_cfg));
-    _cfg.duplicated_packet_bloom_filter.enable = 0;
+    _sess_mgr_cfg.duplicated_packet_bloom_filter.enable = 0;
 
-    sess_mgr_rt = session_manager_runtime_new(&_cfg, 1);
+    sess_mgr_rte = session_manager_rte_new(&_sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // S2C SYNACK Packet
     printf("\n=> Packet Parse: TCP S2C SYNACK packet\n");
@@ -301,12 +323,15 @@ TEST(TCP_DUPKT_FILTER_DISABLE, SYNACK_DUP)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+
+    // check stat
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0);
 
@@ -317,16 +342,19 @@ TEST(TCP_DUPKT_FILTER_DISABLE, SYNACK_DUP)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+
+    // check stat
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 

infra/session_manager/test/gtest_overload_evict_tcp_sess.cpp

@@ -1,33 +1,18 @@
-#include <gtest/gtest.h>
+#include "test_utils.h"
-
-#include "utils_internal.h"
-#include "packet_internal.h"
-#include "packet_parser.h"
-#include "session_internal.h"
-#include "default_config.h"
-#include "test_packets.h"
-
-static void packet_set_ip_src_addr(struct packet *pkt, uint32_t addr)
-{
-    const struct layer_private *ipv4_layer = packet_get_innermost_layer(pkt, LAYER_PROTO_IPV4);
-    EXPECT_TRUE(ipv4_layer);
-    struct ip *hdr = (struct ip *)ipv4_layer->hdr_ptr;
-    hdr->ip_src.s_addr = htonl(addr);
-}
 
 #if 1
 TEST(TCP_OVERLOAD, EVICT_OLD_SESS)
 {
     struct packet pkt;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
-    struct session_manager_config _cfg;
+    struct session_manager_cfg _sess_mgr_cfg;
-    memcpy(&_cfg, &sess_mgr_cfg, sizeof(struct session_manager_config));
+    memcpy(&_sess_mgr_cfg, &sess_mgr_cfg, sizeof(struct session_manager_cfg));
-    _cfg.tcp_session_max = RX_BURST_MAX * 2;
+    _sess_mgr_cfg.tcp_session_max = RX_BURST_MAX * 2;
-    _cfg.udp_session_max = RX_BURST_MAX * 2;
+    _sess_mgr_cfg.udp_session_max = RX_BURST_MAX * 2;
 
-    sess_mgr_rt = session_manager_runtime_new(&_cfg, 1);
+    sess_mgr_rte = session_manager_rte_new(&_sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -36,15 +21,15 @@ TEST(TCP_OVERLOAD, EVICT_OLD_SESS)
     printf("<= Packet Parse: done\n\n");
 
     // new session
-    for (uint32_t i = 0; i < _cfg.tcp_session_max; i++)
+    for (uint32_t i = 0; i < _sess_mgr_cfg.tcp_session_max; i++)
     {
-        packet_set_ip_src_addr(&pkt, i);
+        packet_overwrite_v4_saddr(&pkt, (struct in_addr *)&i);
-        EXPECT_TRUE(session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1));
+        EXPECT_TRUE(session_manager_rte_new_session(sess_mgr_rte, &pkt, 1));
     }
-    printf("=> Session Manager: after add %lu new sessions\n", _cfg.tcp_session_max);
+    printf("=> Session Manager: after add %lu new sessions\n", _sess_mgr_cfg.tcp_session_max);
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
-    EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == _cfg.tcp_session_max);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == _sess_mgr_cfg.tcp_session_max);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == RX_BURST_MAX);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
@@ -53,7 +38,7 @@ TEST(TCP_OVERLOAD, EVICT_OLD_SESS)
     EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_table_full == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_session_not_found == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
@@ -61,16 +46,16 @@ TEST(TCP_OVERLOAD, EVICT_OLD_SESS)
 TEST(TCP_OVERLOAD, EVICT_NEW_SESS)
 {
     struct packet pkt;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
-    struct session_manager_config _cfg;
+    struct session_manager_cfg _sess_mgr_cfg;
-    memcpy(&_cfg, &sess_mgr_cfg, sizeof(struct session_manager_config));
+    memcpy(&_sess_mgr_cfg, &sess_mgr_cfg, sizeof(struct session_manager_cfg));
-    _cfg.tcp_session_max = RX_BURST_MAX * 2;
+    _sess_mgr_cfg.tcp_session_max = RX_BURST_MAX * 2;
-    _cfg.udp_session_max = RX_BURST_MAX * 2;
+    _sess_mgr_cfg.udp_session_max = RX_BURST_MAX * 2;
-    _cfg.evict_old_on_tcp_table_limit = 0;
+    _sess_mgr_cfg.evict_old_on_tcp_table_limit = 0;
 
-    sess_mgr_rt = session_manager_runtime_new(&_cfg, 1);
+    sess_mgr_rte = session_manager_rte_new(&_sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -79,16 +64,16 @@ TEST(TCP_OVERLOAD, EVICT_NEW_SESS)
     printf("<= Packet Parse: done\n\n");
 
     // new session
-    for (uint32_t i = 0; i < _cfg.tcp_session_max; i++)
+    for (uint32_t i = 0; i < _sess_mgr_cfg.tcp_session_max; i++)
     {
-        packet_set_ip_src_addr(&pkt, i);
+        packet_overwrite_v4_saddr(&pkt, (struct in_addr *)&i);
-        EXPECT_TRUE(session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1));
+        EXPECT_TRUE(session_manager_rte_new_session(sess_mgr_rte, &pkt, 1));
     }
-    printf("=> Session Manager: after add %lu new sessions\n", _cfg.tcp_session_max);
+    printf("=> Session Manager: after add %lu new sessions\n", _sess_mgr_cfg.tcp_session_max);
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
-    EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == _cfg.tcp_session_max);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == _sess_mgr_cfg.tcp_session_max);
-    EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == _cfg.tcp_session_max);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == _sess_mgr_cfg.tcp_session_max);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closed == 0);
@@ -99,15 +84,16 @@ TEST(TCP_OVERLOAD, EVICT_NEW_SESS)
     // table full, evict new session
     for (uint32_t i = 0; i < RX_BURST_MAX; i++)
     {
-        packet_set_ip_src_addr(&pkt, _cfg.tcp_session_max + i);
+        uint32_t idx = _sess_mgr_cfg.tcp_session_max + i;
-        EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+        packet_overwrite_v4_saddr(&pkt, (struct in_addr *)&idx);
-        EXPECT_TRUE(session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1) == NULL);
+        EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+        EXPECT_TRUE(session_manager_rte_new_session(sess_mgr_rte, &pkt, 1) == NULL);
     }
     printf("=> Session Manager: after evicte new session\n");
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
-    EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == _cfg.tcp_session_max);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == _sess_mgr_cfg.tcp_session_max);
-    EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == _cfg.tcp_session_max);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == _sess_mgr_cfg.tcp_session_max);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closed == 0);
@@ -115,7 +101,7 @@ TEST(TCP_OVERLOAD, EVICT_NEW_SESS)
     EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_table_full == RX_BURST_MAX);
     EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_session_not_found == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 

infra/session_manager/test/gtest_overload_evict_udp_sess.cpp

@@ -1,34 +1,19 @@
-#include <gtest/gtest.h>
+#include "test_utils.h"
-
-#include "utils_internal.h"
-#include "packet_internal.h"
-#include "packet_parser.h"
-#include "session_internal.h"
-#include "default_config.h"
-#include "test_packets.h"
-
-static void packet_set_ip_src_addr(struct packet *pkt, uint32_t addr)
-{
-    const struct layer_private *ipv4_layer = packet_get_innermost_layer(pkt, LAYER_PROTO_IPV4);
-    EXPECT_TRUE(ipv4_layer);
-    struct ip *hdr = (struct ip *)ipv4_layer->hdr_ptr;
-    hdr->ip_src.s_addr = htonl(addr);
-}
 
 #if 1
 TEST(UDP_OVERLOAD, EVICT_OLD_SESS)
 {
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
-    struct session_manager_config _cfg;
+    struct session_manager_cfg _sess_mgr_cfg;
-    memcpy(&_cfg, &sess_mgr_cfg, sizeof(struct session_manager_config));
+    memcpy(&_sess_mgr_cfg, &sess_mgr_cfg, sizeof(struct session_manager_cfg));
-    _cfg.tcp_session_max = RX_BURST_MAX * 2;
+    _sess_mgr_cfg.tcp_session_max = RX_BURST_MAX * 2;
-    _cfg.udp_session_max = RX_BURST_MAX * 2;
+    _sess_mgr_cfg.udp_session_max = RX_BURST_MAX * 2;
 
-    sess_mgr_rt = session_manager_runtime_new(&_cfg, 1);
+    sess_mgr_rte = session_manager_rte_new(&_sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S REQ Packet
     printf("\n=> Packet Parse: UDP C2S REQ packet\n");
@@ -37,15 +22,15 @@ TEST(UDP_OVERLOAD, EVICT_OLD_SESS)
     printf("<= Packet Parse: done\n\n");
 
     // new session
-    for (uint32_t i = 0; i < _cfg.udp_session_max; i++)
+    for (uint32_t i = 0; i < _sess_mgr_cfg.udp_session_max; i++)
     {
-        packet_set_ip_src_addr(&pkt, i);
+        packet_overwrite_v4_saddr(&pkt, (struct in_addr *)&i);
-        EXPECT_TRUE(session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1));
+        EXPECT_TRUE(session_manager_rte_new_session(sess_mgr_rte, &pkt, 1));
     }
-    printf("=> Session Manager: after add %lu new sessions\n", _cfg.udp_session_max);
+    printf("=> Session Manager: after add %lu new sessions\n", _sess_mgr_cfg.udp_session_max);
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
-    EXPECT_TRUE(sess_mgr_stat->udp_sess_used == _cfg.udp_session_max);
+    EXPECT_TRUE(sess_mgr_stat->udp_sess_used == _sess_mgr_cfg.udp_session_max);
     EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == RX_BURST_MAX);
     EXPECT_TRUE(sess_mgr_stat->udp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->udp_sess_closing == 0);
@@ -57,10 +42,10 @@ TEST(UDP_OVERLOAD, EVICT_OLD_SESS)
     // evicted session
     while (1)
     {
-        sess = session_manager_runtime_get_evicted_session(sess_mgr_rt);
+        sess = session_manager_rte_get_evicted_session(sess_mgr_rte);
         if (sess)
         {
-            session_manager_runtime_free_session(sess_mgr_rt, sess);
+            session_manager_rte_free_session(sess_mgr_rte, sess);
         }
         else
         {
@@ -70,12 +55,12 @@ TEST(UDP_OVERLOAD, EVICT_OLD_SESS)
 
     for (uint32_t i = 0; i < RX_BURST_MAX; i++)
     {
-        packet_set_ip_src_addr(&pkt, i);
+        packet_overwrite_v4_saddr(&pkt, (struct in_addr *)&i);
-        EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+        EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
-        EXPECT_TRUE(session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1) == NULL); // hit evicted session, can't renew session
+        EXPECT_TRUE(session_manager_rte_new_session(sess_mgr_rte, &pkt, 1) == NULL); // hit evicted session, can't renew session
     }
     printf("=> Session Manager: after readd %d evicted sessions\n", RX_BURST_MAX);
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->udp_sess_used == RX_BURST_MAX);
     EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == RX_BURST_MAX);
@@ -87,11 +72,12 @@ TEST(UDP_OVERLOAD, EVICT_OLD_SESS)
     EXPECT_TRUE(sess_mgr_stat->udp_pkts_bypass_session_evicted == RX_BURST_MAX);
 
     // evicted session timeout
-    packet_set_ip_src_addr(&pkt, 0);
+    uint32_t idx = 0;
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    packet_overwrite_v4_saddr(&pkt, (struct in_addr *)&idx);
-    EXPECT_TRUE(session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1 + _cfg.evicted_session_bloom_filter.time_window_ms));
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_new_session(sess_mgr_rte, &pkt, 1 + _sess_mgr_cfg.evicted_session_bloom_filter.time_window_ms));
     printf("=> Session Manager: after evicted session timeout\n");
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->udp_sess_used == RX_BURST_MAX + 1);
     EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == RX_BURST_MAX);
@@ -102,7 +88,7 @@ TEST(UDP_OVERLOAD, EVICT_OLD_SESS)
     EXPECT_TRUE(sess_mgr_stat->udp_pkts_bypass_table_full == 0);
     EXPECT_TRUE(sess_mgr_stat->udp_pkts_bypass_session_evicted == RX_BURST_MAX);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
@@ -110,16 +96,16 @@ TEST(UDP_OVERLOAD, EVICT_OLD_SESS)
 TEST(UDP_OVERLOAD, EVICT_NEW_SESS)
 {
     struct packet pkt;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
-    struct session_manager_config _cfg;
+    struct session_manager_cfg _sess_mgr_cfg;
-    memcpy(&_cfg, &sess_mgr_cfg, sizeof(struct session_manager_config));
+    memcpy(&_sess_mgr_cfg, &sess_mgr_cfg, sizeof(struct session_manager_cfg));
-    _cfg.tcp_session_max = RX_BURST_MAX * 2;
+    _sess_mgr_cfg.tcp_session_max = RX_BURST_MAX * 2;
-    _cfg.udp_session_max = RX_BURST_MAX * 2;
+    _sess_mgr_cfg.udp_session_max = RX_BURST_MAX * 2;
-    _cfg.evict_old_on_udp_table_limit = 0;
+    _sess_mgr_cfg.evict_old_on_udp_table_limit = 0;
 
-    sess_mgr_rt = session_manager_runtime_new(&_cfg, 1);
+    sess_mgr_rte = session_manager_rte_new(&_sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S REQ Packet
     printf("\n=> Packet Parse: UDP C2S REQ packet\n");
@@ -128,16 +114,16 @@ TEST(UDP_OVERLOAD, EVICT_NEW_SESS)
     printf("<= Packet Parse: done\n\n");
 
     // new session
-    for (uint32_t i = 0; i < _cfg.udp_session_max; i++)
+    for (uint32_t i = 0; i < _sess_mgr_cfg.udp_session_max; i++)
     {
-        packet_set_ip_src_addr(&pkt, i);
+        packet_overwrite_v4_saddr(&pkt, (struct in_addr *)&i);
-        EXPECT_TRUE(session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1));
+        EXPECT_TRUE(session_manager_rte_new_session(sess_mgr_rte, &pkt, 1));
     }
-    printf("=> Session Manager: after add %lu new sessions\n", _cfg.udp_session_max);
+    printf("=> Session Manager: after add %lu new sessions\n", _sess_mgr_cfg.udp_session_max);
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
-    EXPECT_TRUE(sess_mgr_stat->udp_sess_used == _cfg.udp_session_max);
+    EXPECT_TRUE(sess_mgr_stat->udp_sess_used == _sess_mgr_cfg.udp_session_max);
-    EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == _cfg.udp_session_max);
+    EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == _sess_mgr_cfg.udp_session_max);
     EXPECT_TRUE(sess_mgr_stat->udp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->udp_sess_closing == 0);
     EXPECT_TRUE(sess_mgr_stat->udp_sess_closed == 0);
@@ -146,20 +132,21 @@ TEST(UDP_OVERLOAD, EVICT_NEW_SESS)
     EXPECT_TRUE(sess_mgr_stat->udp_pkts_bypass_session_evicted == 0);
 
     // evicted session
-    EXPECT_TRUE(session_manager_runtime_get_evicted_session(sess_mgr_rt) == NULL);
+    EXPECT_TRUE(session_manager_rte_get_evicted_session(sess_mgr_rte) == NULL);
 
     // table full, evict new session
     for (uint32_t i = 0; i < RX_BURST_MAX; i++)
     {
-        packet_set_ip_src_addr(&pkt, _cfg.udp_session_max + i);
+        uint32_t idx = _sess_mgr_cfg.udp_session_max + i;
-        EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+        packet_overwrite_v4_saddr(&pkt, (struct in_addr *)&idx);
-        EXPECT_TRUE(session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1) == NULL);
+        EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+        EXPECT_TRUE(session_manager_rte_new_session(sess_mgr_rte, &pkt, 1) == NULL);
     }
     printf("=> Session Manager: after readd %d evicted session\n", RX_BURST_MAX);
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
-    EXPECT_TRUE(sess_mgr_stat->udp_sess_used == _cfg.udp_session_max);
+    EXPECT_TRUE(sess_mgr_stat->udp_sess_used == _sess_mgr_cfg.udp_session_max);
-    EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == _cfg.udp_session_max);
+    EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == _sess_mgr_cfg.udp_session_max);
     EXPECT_TRUE(sess_mgr_stat->udp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->udp_sess_closing == 0);
     EXPECT_TRUE(sess_mgr_stat->udp_sess_closed == 0);
@@ -167,7 +154,7 @@ TEST(UDP_OVERLOAD, EVICT_NEW_SESS)
     EXPECT_TRUE(sess_mgr_stat->udp_pkts_bypass_table_full == RX_BURST_MAX);
     EXPECT_TRUE(sess_mgr_stat->udp_pkts_bypass_session_evicted == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 

infra/session_manager/test/gtest_sess_mgr_scan.cpp

@@ -1,27 +1,13 @@
-#include <gtest/gtest.h>
+#include "test_utils.h"
 
-#include "session_internal.h"
+static inline void mached_session_print(const char *title, struct session_manager_rte *sess_mgr_rte, uint64_t mached_sess_id[], uint64_t mached_sess_num)
-#include "packet_internal.h"
-#include "packet_parser.h"
-#include "default_config.h"
-#include "test_packets.h"
-
-static inline void packet_overwrite_src_addr(struct packet *pkt, struct in_addr addr)
 {
-    const struct layer_private *ipv4_layer = packet_get_innermost_layer(pkt, LAYER_PROTO_IPV4);
-    struct ip *hdr = (struct ip *)ipv4_layer->hdr_ptr;
-    hdr->ip_src = addr;
-}
-
-static inline void mached_session_print(const char *title, struct session_manager_runtime *sess_mgr_rt, uint64_t mached_sess_ids[], uint64_t mached_sess_num)
-{
-    struct session *sess = NULL;
     printf("%-*s mached_sess_num: %lu\n", 40, title, mached_sess_num);
     for (uint64_t i = 0; i < mached_sess_num; i++)
     {
-        sess = session_manager_runtime_lookup_session_by_id(sess_mgr_rt, mached_sess_ids[i]);
+        struct session *sess = session_manager_rte_lookup_session_by_id(sess_mgr_rte, mached_sess_id[i]);
         printf("session id: %lu, addr: %s, type: %s, state: %s, start: %lu, last: %lu\n",
-               mached_sess_ids[i], session_get0_readable_addr(sess),
+               mached_sess_id[i], session_get0_readable_addr(sess),
                session_type_to_str(session_get_type(sess)),
                session_state_to_str(session_get_current_state(sess)),
                session_get_timestamp(sess, SESSION_TIMESTAMP_START),
@@ -34,10 +20,10 @@ TEST(SESS_MGR_SCAN, OPTS)
 {
     char buff[1500] = {0};
     uint64_t mached_sess_num = 0;
-    uint64_t mached_sess_ids[1460];
+    uint64_t mached_sess_id[1460];
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
 
     struct in_addr v4_src_addr1 = {};
     struct in_addr v4_src_addr2 = {};
@@ -85,91 +71,91 @@ TEST(SESS_MGR_SCAN, OPTS)
     inet_pton(AF_INET6, "cafe::0000", &v6_dst_subnet_beg);
     inet_pton(AF_INET6, "cafe::ffff", &v6_dst_subnet_end);
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // new session
     memset(&pkt, 0, sizeof(pkt));
     memcpy(buff, tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
     packet_parse(&pkt, (const char *)buff, sizeof(tcp_pkt1_c2s_syn));
-    packet_overwrite_src_addr(&pkt, v4_src_addr1);
+    packet_overwrite_v4_saddr(&pkt, &v4_src_addr1);
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
 
     // new session
     memset(&pkt, 0, sizeof(pkt));
     memcpy(buff, tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
     packet_parse(&pkt, (const char *)buff, sizeof(tcp_pkt1_c2s_syn));
-    packet_overwrite_src_addr(&pkt, v4_src_addr2);
+    packet_overwrite_v4_saddr(&pkt, &v4_src_addr2);
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 2);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 2);
     EXPECT_TRUE(sess);
 
     // new session
     memset(&pkt, 0, sizeof(pkt));
     memcpy(buff, tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
     packet_parse(&pkt, (const char *)buff, sizeof(tcp_pkt1_c2s_syn));
-    packet_overwrite_src_addr(&pkt, v4_src_addr3);
+    packet_overwrite_v4_saddr(&pkt, &v4_src_addr3);
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 3);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 3);
     EXPECT_TRUE(sess);
 
     // new session
     memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)ipv6_in_ipv6_udp, sizeof(ipv6_in_ipv6_udp));
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 4);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 4);
     EXPECT_TRUE(sess);
 
     struct session_scan_opts scan = {};
-    // scan.flags = SESSION_SCAN_TYPE | SESSION_SCAN_STATE | SESSION_SCAN_SIP | SESSION_SCAN_DIP | SESSION_SCAN_SPORT | SESSION_SCAN_DPORT | SESSION_SCAN_CREATE_TIME | SESSION_SCAN_LAST_PKT_TIME;
+    // scan.flags = SESSION_SCAN_TYPE | SESSION_SCAN_STATE | SESSION_SCAN_SIP | SESSION_SCAN_DIP | SESSION_SCAN_SPORT | SESSION_SCAN_DPORT | SESSION_SCAN_CREATE_TIME | SESSION_SCAN_LASPKT_TIME;
     scan.cursor = 0;
     scan.count = 1460;
 
-    scan.last_pkt_time_ms[0] = 0;
+    scan.laspkt_time_ms[0] = 0;
-    scan.last_pkt_time_ms[1] = UINT64_MAX;
+    scan.laspkt_time_ms[1] = UINT64_MAX;
 
     // SESSION_SCAN_TYPE
     scan.flags = SESSION_SCAN_TYPE;
 
     scan.type = SESSION_TYPE_TCP;
-    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
     EXPECT_TRUE(mached_sess_num == 3);
-    mached_session_print("SESSION_SCAN_TYPE: (TCP)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_TYPE: (TCP)", sess_mgr_rte, mached_sess_id, mached_sess_num);
 
     scan.type = SESSION_TYPE_UDP;
-    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
     EXPECT_TRUE(mached_sess_num == 1);
-    mached_session_print("SESSION_SCAN_TYPE: (UDP)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_TYPE: (UDP)", sess_mgr_rte, mached_sess_id, mached_sess_num);
 
     // SESSION_SCAN_STATE
     scan.flags = SESSION_SCAN_STATE;
 
     scan.state = SESSION_STATE_OPENING;
-    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
     EXPECT_TRUE(mached_sess_num == 4);
-    mached_session_print("SESSION_SCAN_STATE: (OPENING)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_STATE: (OPENING)", sess_mgr_rte, mached_sess_id, mached_sess_num);
 
     scan.state = SESSION_STATE_ACTIVE;
-    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
     EXPECT_TRUE(mached_sess_num == 0);
-    mached_session_print("SESSION_SCAN_STATE: (ACTIVE)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_STATE: (ACTIVE)", sess_mgr_rte, mached_sess_id, mached_sess_num);
 
     scan.state = SESSION_STATE_CLOSING;
-    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
     EXPECT_TRUE(mached_sess_num == 0);
-    mached_session_print("SESSION_SCAN_STATE: (CLOSING)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_STATE: (CLOSING)", sess_mgr_rte, mached_sess_id, mached_sess_num);
 
     scan.state = SESSION_STATE_DISCARD;
-    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
     EXPECT_TRUE(mached_sess_num == 0);
-    mached_session_print("SESSION_SCAN_STATE: (DISCARD)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_STATE: (DISCARD)", sess_mgr_rte, mached_sess_id, mached_sess_num);
 
     scan.state = SESSION_STATE_CLOSED;
-    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
     EXPECT_TRUE(mached_sess_num == 0);
-    mached_session_print("SESSION_SCAN_STATE: (CLOSED)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_STATE: (CLOSED)", sess_mgr_rte, mached_sess_id, mached_sess_num);
 
     // SESSION_SCAN_SIP
     scan.flags = SESSION_SCAN_SIP;
@@ -177,44 +163,44 @@ TEST(SESS_MGR_SCAN, OPTS)
     scan.addr_family = AF_INET;
     scan.src_addr[0].v4 = v4_src_addr1;
     scan.src_addr[1].v4 = v4_src_addr1;
-    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
     EXPECT_TRUE(mached_sess_num == 1);
-    mached_session_print("SESSION_SCAN_SIP: (IPv4)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_SIP: (IPv4)", sess_mgr_rte, mached_sess_id, mached_sess_num);
 
     scan.addr_family = AF_INET;
     scan.src_addr[0].v4 = v4_src_subnet_beg;
     scan.src_addr[1].v4 = v4_src_subnet_end;
-    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
     EXPECT_TRUE(mached_sess_num == 3);
-    mached_session_print("SESSION_SCAN_SIP: (IPv4 SUBNET)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_SIP: (IPv4 SUBNET)", sess_mgr_rte, mached_sess_id, mached_sess_num);
 
     scan.addr_family = AF_INET;
     scan.src_addr[0].v4 = v4_min_addr;
     scan.src_addr[1].v4 = v4_max_addr;
-    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
     EXPECT_TRUE(mached_sess_num == 3);
-    mached_session_print("SESSION_SCAN_SIP: (IPv4 MIN MAX)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_SIP: (IPv4 MIN MAX)", sess_mgr_rte, mached_sess_id, mached_sess_num);
 
     scan.addr_family = AF_INET6;
     memcpy(&scan.src_addr[0].v6, &v6_src_addr, sizeof(v6_src_addr));
     memcpy(&scan.src_addr[1].v6, &v6_src_addr, sizeof(v6_src_addr));
-    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
     EXPECT_TRUE(mached_sess_num == 1);
-    mached_session_print("SESSION_SCAN_SIP: (IPv6)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_SIP: (IPv6)", sess_mgr_rte, mached_sess_id, mached_sess_num);
 
     scan.addr_family = AF_INET6;
     memcpy(&scan.src_addr[0].v6, &v6_src_subnet_beg, sizeof(v6_src_subnet_beg));
     memcpy(&scan.src_addr[1].v6, &v6_src_subnet_end, sizeof(v6_src_subnet_end));
-    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
     EXPECT_TRUE(mached_sess_num == 1);
-    mached_session_print("SESSION_SCAN_SIP: (IPv6 SUBNET)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_SIP: (IPv6 SUBNET)", sess_mgr_rte, mached_sess_id, mached_sess_num);
 
     scan.addr_family = AF_INET6;
     memcpy(&scan.src_addr[0].v6, &v6_min_addr, sizeof(v6_min_addr));
     memcpy(&scan.src_addr[1].v6, &v6_max_addr, sizeof(v6_max_addr));
-    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
     EXPECT_TRUE(mached_sess_num == 1);
-    mached_session_print("SESSION_SCAN_SIP: (IPv6 MIN MAX)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_SIP: (IPv6 MIN MAX)", sess_mgr_rte, mached_sess_id, mached_sess_num);
 
     // SESSION_SCAN_DIP
     scan.flags = SESSION_SCAN_DIP;
@@ -222,126 +208,126 @@ TEST(SESS_MGR_SCAN, OPTS)
     scan.addr_family = AF_INET;
     scan.dst_addr[0].v4 = v4_dst_addr;
     scan.dst_addr[1].v4 = v4_dst_addr;
-    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
     EXPECT_TRUE(mached_sess_num == 3);
-    mached_session_print("SESSION_SCAN_DIP: (IPv4)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_DIP: (IPv4)", sess_mgr_rte, mached_sess_id, mached_sess_num);
 
     scan.addr_family = AF_INET;
     scan.dst_addr[0].v4 = v4_dst_subnet_beg;
     scan.dst_addr[1].v4 = v4_dst_subnet_end;
-    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
     EXPECT_TRUE(mached_sess_num == 3);
-    mached_session_print("SESSION_SCAN_DIP: (IPv4 SUBNET)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_DIP: (IPv4 SUBNET)", sess_mgr_rte, mached_sess_id, mached_sess_num);
 
     scan.addr_family = AF_INET;
     scan.dst_addr[0].v4 = v4_min_addr;
     scan.dst_addr[1].v4 = v4_max_addr;
-    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
     EXPECT_TRUE(mached_sess_num == 3);
-    mached_session_print("SESSION_SCAN_DIP: (IPv4 MIN MAX)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_DIP: (IPv4 MIN MAX)", sess_mgr_rte, mached_sess_id, mached_sess_num);
 
     scan.addr_family = AF_INET6;
     memcpy(&scan.dst_addr[0].v6, &v6_dst_addr, sizeof(v6_dst_addr));
     memcpy(&scan.dst_addr[1].v6, &v6_dst_addr, sizeof(v6_dst_addr));
-    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
     EXPECT_TRUE(mached_sess_num == 1);
-    mached_session_print("SESSION_SCAN_DIP: (IPv6)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_DIP: (IPv6)", sess_mgr_rte, mached_sess_id, mached_sess_num);
 
     scan.addr_family = AF_INET6;
     memcpy(&scan.dst_addr[0].v6, &v6_dst_subnet_beg, sizeof(v6_dst_subnet_beg));
     memcpy(&scan.dst_addr[1].v6, &v6_dst_subnet_end, sizeof(v6_dst_subnet_end));
-    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
     EXPECT_TRUE(mached_sess_num == 1);
-    mached_session_print("SESSION_SCAN_DIP: (IPv6 SUBNET)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_DIP: (IPv6 SUBNET)", sess_mgr_rte, mached_sess_id, mached_sess_num);
 
     scan.addr_family = AF_INET6;
     memcpy(&scan.dst_addr[0].v6, &v6_min_addr, sizeof(v6_min_addr));
     memcpy(&scan.dst_addr[1].v6, &v6_max_addr, sizeof(v6_max_addr));
-    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
     EXPECT_TRUE(mached_sess_num == 1);
-    mached_session_print("SESSION_SCAN_DIP: (IPv6 MIN MAX)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_DIP: (IPv6 MIN MAX)", sess_mgr_rte, mached_sess_id, mached_sess_num);
 
     // SESSION_SCAN_SPORT
     scan.flags = SESSION_SCAN_SPORT;
 
     scan.src_port = htons(60111);
-    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
     EXPECT_TRUE(mached_sess_num == 3);
-    mached_session_print("SESSION_SCAN_SPORT: (HIT)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_SPORT: (HIT)", sess_mgr_rte, mached_sess_id, mached_sess_num);
 
     scan.src_port = htons(60110);
-    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
     EXPECT_TRUE(mached_sess_num == 0);
-    mached_session_print("SESSION_SCAN_SPORT: (MISS)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_SPORT: (MISS)", sess_mgr_rte, mached_sess_id, mached_sess_num);
 
     // SESSION_SCAN_DPORT
     scan.flags = SESSION_SCAN_DPORT;
 
     scan.dst_port = htons(80);
-    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
     EXPECT_TRUE(mached_sess_num == 3);
-    mached_session_print("SESSION_SCAN_DPORT: (HIT)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_DPORT: (HIT)", sess_mgr_rte, mached_sess_id, mached_sess_num);
 
     scan.dst_port = htons(81);
-    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
     EXPECT_TRUE(mached_sess_num == 0);
-    mached_session_print("SESSION_SCAN_DPORT: (MISS)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_DPORT: (MISS)", sess_mgr_rte, mached_sess_id, mached_sess_num);
 
     // SESSION_SCAN_CREATE_TIME
     scan.flags = SESSION_SCAN_CREATE_TIME;
 
     scan.create_time_ms[0] = 0;
     scan.create_time_ms[1] = UINT64_MAX;
-    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
     EXPECT_TRUE(mached_sess_num == 4);
-    mached_session_print("SESSION_SCAN_CREATE_TIME: (HIT)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_CREATE_TIME: (HIT)", sess_mgr_rte, mached_sess_id, mached_sess_num);
 
     scan.create_time_ms[0] = 1;
     scan.create_time_ms[1] = 2;
-    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
     EXPECT_TRUE(mached_sess_num == 2);
-    mached_session_print("SESSION_SCAN_CREATE_TIME: (HIT)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_CREATE_TIME: (HIT)", sess_mgr_rte, mached_sess_id, mached_sess_num);
 
     scan.create_time_ms[0] = 0;
     scan.create_time_ms[1] = 0;
-    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
     EXPECT_TRUE(mached_sess_num == 0);
-    mached_session_print("SESSION_SCAN_CREATE_TIME: (MISS)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_CREATE_TIME: (MISS)", sess_mgr_rte, mached_sess_id, mached_sess_num);
 
     scan.create_time_ms[0] = UINT64_MAX;
     scan.create_time_ms[1] = UINT64_MAX;
-    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
     EXPECT_TRUE(mached_sess_num == 0);
-    mached_session_print("SESSION_SCAN_CREATE_TIME: (MISS)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_CREATE_TIME: (MISS)", sess_mgr_rte, mached_sess_id, mached_sess_num);
 
-    // SESSION_SCAN_LAST_PKT_TIME
+    // SESSION_SCAN_LASPKT_TIME
-    scan.flags = SESSION_SCAN_LAST_PKT_TIME;
+    scan.flags = SESSION_SCAN_LASPKT_TIME;
 
-    scan.last_pkt_time_ms[0] = 0;
+    scan.laspkt_time_ms[0] = 0;
-    scan.last_pkt_time_ms[1] = UINT64_MAX;
+    scan.laspkt_time_ms[1] = UINT64_MAX;
-    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
     EXPECT_TRUE(mached_sess_num == 4);
-    mached_session_print("SESSION_SCAN_LAST_PKT_TIME: (HIT)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_LASPKT_TIME: (HIT)", sess_mgr_rte, mached_sess_id, mached_sess_num);
 
-    scan.last_pkt_time_ms[0] = 1;
+    scan.laspkt_time_ms[0] = 1;
-    scan.last_pkt_time_ms[1] = 2;
+    scan.laspkt_time_ms[1] = 2;
-    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
     EXPECT_TRUE(mached_sess_num == 2);
-    mached_session_print("SESSION_SCAN_LAST_PKT_TIME: (HIT)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_LASPKT_TIME: (HIT)", sess_mgr_rte, mached_sess_id, mached_sess_num);
 
-    scan.last_pkt_time_ms[0] = 0;
+    scan.laspkt_time_ms[0] = 0;
-    scan.last_pkt_time_ms[1] = 0;
+    scan.laspkt_time_ms[1] = 0;
-    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
     EXPECT_TRUE(mached_sess_num == 0);
-    mached_session_print("SESSION_SCAN_LAST_PKT_TIME: (MISS)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_LASPKT_TIME: (MISS)", sess_mgr_rte, mached_sess_id, mached_sess_num);
 
-    scan.last_pkt_time_ms[0] = UINT64_MAX;
+    scan.laspkt_time_ms[0] = UINT64_MAX;
-    scan.last_pkt_time_ms[1] = UINT64_MAX;
+    scan.laspkt_time_ms[1] = UINT64_MAX;
-    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
     EXPECT_TRUE(mached_sess_num == 0);
-    mached_session_print("SESSION_SCAN_LAST_PKT_TIME: (MISS)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_LASPKT_TIME: (MISS)", sess_mgr_rte, mached_sess_id, mached_sess_num);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 

infra/session_manager/test/gtest_sess_mgr_tcp_reassembly.cpp

@@ -1,24 +1,4 @@
-#include <gtest/gtest.h>
+#include "test_utils.h"
-
-#include "packet_internal.h"
-#include "packet_parser.h"
-#include "session_internal.h"
-#include "default_config.h"
-#include "test_packets.h"
-
-static void hex_dump(const char *payload, uint32_t len)
-{
-    printf("Payload Length: %u\n", len);
-    for (uint32_t i = 0; i < len; i++)
-    {
-        if (i > 0 && i % 16 == 0)
-        {
-            printf("\n");
-        }
-        printf("%02x ", (uint8_t)payload[i]);
-    }
-    printf("\n");
-}
 
 #if 1
 TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
@@ -26,10 +6,10 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
     struct tcp_segment *seg;
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -38,9 +18,10 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
 
     seg = session_get_tcp_segment(sess);
@@ -53,10 +34,11 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
 
     seg = session_get_tcp_segment(sess);
     EXPECT_TRUE(seg == NULL);
@@ -68,10 +50,11 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 3) == 0);
 
     seg = session_get_tcp_segment(sess);
     EXPECT_TRUE(seg == NULL);
@@ -83,10 +66,11 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 4) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 4) == 0);
 
     seg = session_get_tcp_segment(sess);
     EXPECT_TRUE(seg == NULL);
@@ -98,10 +82,11 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 5) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 5) == 0);
 
     seg = session_get_tcp_segment(sess);
     EXPECT_TRUE(seg == NULL);
@@ -113,10 +98,11 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 6) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 6) == 0);
 
     seg = session_get_tcp_segment(sess);
     EXPECT_TRUE(seg == NULL);
@@ -128,10 +114,11 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 7) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 7) == 0);
 
     /*
      * 11111111111111111111111111111111111111111111111111111111111111
@@ -166,48 +153,49 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
     EXPECT_TRUE(seg != NULL);
     EXPECT_TRUE(seg->len == sizeof(payload1));
     EXPECT_TRUE(memcmp((void *)seg->data, payload1, sizeof(payload1)) == 0);
-    hex_dump((const char *)seg->data, seg->len);
+    hexdump_to_fd(STDOUT_FILENO, 0, (const char *)seg->data, seg->len);
     session_free_tcp_segment(sess, seg);
 
     seg = session_get_tcp_segment(sess);
     EXPECT_TRUE(seg != NULL);
     EXPECT_TRUE(seg->len == sizeof(payload2));
     EXPECT_TRUE(memcmp((void *)seg->data, payload2, sizeof(payload2)) == 0);
-    hex_dump((const char *)seg->data, seg->len);
+    hexdump_to_fd(STDOUT_FILENO, 0, (const char *)seg->data, seg->len);
     session_free_tcp_segment(sess, seg);
 
     seg = session_get_tcp_segment(sess);
     EXPECT_TRUE(seg != NULL);
     EXPECT_TRUE(seg->len == sizeof(payload3));
     EXPECT_TRUE(memcmp((void *)seg->data, payload3, sizeof(payload3)) == 0);
-    hex_dump((const char *)seg->data, seg->len);
+    hexdump_to_fd(STDOUT_FILENO, 0, (const char *)seg->data, seg->len);
     session_free_tcp_segment(sess, seg);
 
     seg = session_get_tcp_segment(sess);
     EXPECT_TRUE(seg != NULL);
     EXPECT_TRUE(seg->len == sizeof(payload4));
     EXPECT_TRUE(memcmp((void *)seg->data, payload4, sizeof(payload4)) == 0);
-    hex_dump((const char *)seg->data, seg->len);
+    hexdump_to_fd(STDOUT_FILENO, 0, (const char *)seg->data, seg->len);
     session_free_tcp_segment(sess, seg);
 
     seg = session_get_tcp_segment(sess);
     EXPECT_TRUE(seg != NULL);
     EXPECT_TRUE(seg->len == sizeof(payload5));
     EXPECT_TRUE(memcmp((void *)seg->data, payload5, sizeof(payload5)) == 0);
-    hex_dump((const char *)seg->data, seg->len);
+    hexdump_to_fd(STDOUT_FILENO, 0, (const char *)seg->data, seg->len);
     session_free_tcp_segment(sess, seg);
 
     // expire session
-    EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 7 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL);                      // active -> closing
+    EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 7 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL);                      // active -> closing
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 7 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data); // closing -> closed
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 7 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data); // closing -> closed
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
     session_print(sess);
-    // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    // free session
+    session_manager_rte_free_session(sess_mgr_rte, sess);
+
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
@@ -217,10 +205,10 @@ TEST(SESS_MGR_TCP_REASSEMBLY, SEQ_WRAPAROUND)
     struct tcp_segment *seg;
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -229,9 +217,10 @@ TEST(SESS_MGR_TCP_REASSEMBLY, SEQ_WRAPAROUND)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
 
     seg = session_get_tcp_segment(sess);
@@ -244,10 +233,11 @@ TEST(SESS_MGR_TCP_REASSEMBLY, SEQ_WRAPAROUND)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
 
     seg = session_get_tcp_segment(sess);
     EXPECT_TRUE(seg == NULL);
@@ -259,16 +249,17 @@ TEST(SESS_MGR_TCP_REASSEMBLY, SEQ_WRAPAROUND)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 3) == 0);
 
     seg = session_get_tcp_segment(sess);
     EXPECT_TRUE(seg != NULL);
     EXPECT_TRUE(seg->len == sizeof(tcp_seq_wraparound_pkt3_payload));
     EXPECT_TRUE(memcmp((void *)seg->data, tcp_seq_wraparound_pkt3_payload, sizeof(tcp_seq_wraparound_pkt3_payload)) == 0);
-    hex_dump((const char *)seg->data, seg->len);
+    hexdump_to_fd(STDOUT_FILENO, 0, (const char *)seg->data, seg->len);
     session_free_tcp_segment(sess, seg);
 
     // C2S Data Packet
@@ -278,29 +269,31 @@ TEST(SESS_MGR_TCP_REASSEMBLY, SEQ_WRAPAROUND)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 4) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 4) == 0);
 
     seg = session_get_tcp_segment(sess);
     EXPECT_TRUE(seg != NULL);
     EXPECT_TRUE(seg->len == sizeof(tcp_seq_wraparound_pkt4_payload));
     EXPECT_TRUE(memcmp((void *)seg->data, tcp_seq_wraparound_pkt4_payload, sizeof(tcp_seq_wraparound_pkt4_payload)) == 0);
-    hex_dump((const char *)seg->data, seg->len);
+    hexdump_to_fd(STDOUT_FILENO, 0, (const char *)seg->data, seg->len);
     session_free_tcp_segment(sess, seg);
 
     // expire session
-    EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 4 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL);                      // active -> closing
+    EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 4 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL);                      // active -> closing
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 4 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data); // closing -> closed
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 4 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data); // closing -> closed
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
     session_print(sess);
-    // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    // free session
+    session_manager_rte_free_session(sess_mgr_rte, sess);
+
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 

infra/session_manager/test/gtest_session_filter.cpp

@@ -1,7 +1,4 @@
-#include <gtest/gtest.h>
+#include "test_utils.h"
-
-#include "tuple.h"
-#include "session_filter.h"
 
 TEST(SESSION_FILTER, TEST)
 {

infra/session_manager/test/gtest_session_pool.cpp

@@ -1,6 +1,4 @@
-#include <gtest/gtest.h>
+#include "test_utils.h"
-
-#include "session_pool.h"
 
 TEST(SESSION_POOL, POP_PUSH)
 {

infra/session_manager/test/gtest_session_table.cpp

@@ -1,9 +1,4 @@
-#include <gtest/gtest.h>
+#include "test_utils.h"
-
-#include "tuple.h"
-#include "session_internal.h"
-#include "session_pool.h"
-#include "session_table.h"
 
 #define TUPLE6_SET_V4_TCP(t6)                               \
     {                                                       \

infra/session_manager/test/gtest_session_timer.cpp

@@ -1,7 +1,4 @@
-#include <gtest/gtest.h>
+#include "test_utils.h"
-
-#include "session_internal.h"
-#include "session_timer.h"
 
 TEST(SESSION_TIMER, EXPIRE)
 {

infra/session_manager/test/gtest_session_transition.cpp

@@ -1,6 +1,4 @@
-#include <gtest/gtest.h>
+#include "test_utils.h"
-
-#include "session_transition.h"
 
 TEST(SESSION_TRANSITION, RUN)
 {

infra/session_manager/test/gtest_state_tcp_active_to_closing.cpp

@@ -1,14 +1,7 @@
 // TCP state machine test: active -> closing
-#include <gtest/gtest.h>
+#include "test_utils.h"
 
-#include "tuple.h"
+static void build_active_tcp_session(struct session_manager_rte *sess_mgr_rte, struct session *sess)
-#include "packet_internal.h"
-#include "packet_parser.h"
-#include "session_internal.h"
-#include "default_config.h"
-#include "test_packets.h"
-
-static void build_active_tcp_session(struct session_manager_runtime *sess_mgr_rt, struct session *sess)
 {
     struct packet pkt;
 
@@ -19,9 +12,10 @@ static void build_active_tcp_session(struct session_manager_runtime *sess_mgr_rt
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
 
     // C2S DATA Packet
@@ -31,10 +25,11 @@ static void build_active_tcp_session(struct session_manager_runtime *sess_mgr_rt
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
 }
 
 /******************************************************************************
@@ -47,14 +42,14 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_FIN_FIN)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S SYN Packet & C2S DATA Packet
-    build_active_tcp_session(sess_mgr_rt, sess);
+    build_active_tcp_session(sess_mgr_rte, sess);
 
     // C2S FIN Packet
     printf("\n=> Packet Parse: TCP C2S FIN packet\n");
@@ -63,10 +58,11 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_FIN_FIN)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 3) == 0);
 
     // S2C FIN Packet
     printf("\n=> Packet Parse: TCP S2C FIN packet\n");
@@ -75,10 +71,11 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_FIN_FIN)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 3) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -100,7 +97,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_FIN_FIN)
     session_print(sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
@@ -108,23 +105,24 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_FIN_FIN)
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 1);
 
     // expire session
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 3 + sess_mgr_cfg.tcp_timeout_ms.time_wait);
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 3 + sess_mgr_cfg.tcp_timeout_ms.time_wait);
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
     session_print(sess);
+
     // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
+    session_manager_rte_free_session(sess_mgr_rte, sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
@@ -138,14 +136,14 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_RST)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S SYN Packet & C2S DATA Packet
-    build_active_tcp_session(sess_mgr_rt, sess);
+    build_active_tcp_session(sess_mgr_rte, sess);
 
     // C2S RST Packet
     printf("\n=> Packet Parse: TCP C2S RST packet\n");
@@ -160,10 +158,11 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_RST)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 3) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -185,7 +184,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_RST)
     session_print(sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
@@ -193,23 +192,24 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_RST)
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 1);
 
     // expire session
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 3 + sess_mgr_cfg.tcp_timeout_ms.unverified_rst);
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 3 + sess_mgr_cfg.tcp_timeout_ms.unverified_rst);
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_RST);
     session_print(sess);
+
     // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
+    session_manager_rte_free_session(sess_mgr_rte, sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
@@ -223,14 +223,14 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_RST)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S SYN Packet & C2S DATA Packet
-    build_active_tcp_session(sess_mgr_rt, sess);
+    build_active_tcp_session(sess_mgr_rte, sess);
 
     // S2C RST Packet
     printf("\n=> Packet Parse: TCP S2C RST packet\n");
@@ -245,10 +245,11 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_RST)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 3) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -270,7 +271,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_RST)
     session_print(sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
@@ -278,23 +279,24 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_RST)
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 1);
 
     // expire session
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 3 + sess_mgr_cfg.tcp_timeout_ms.unverified_rst);
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 3 + sess_mgr_cfg.tcp_timeout_ms.unverified_rst);
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_RST);
     session_print(sess);
+
     // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
+    session_manager_rte_free_session(sess_mgr_rte, sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
@@ -306,17 +308,17 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_RST)
 TEST(TCP_ACTIVE_TO_CLOSING, BY_DATA_TIMEOUT)
 {
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S SYN Packet & C2S DATA Packet
-    build_active_tcp_session(sess_mgr_rt, sess);
+    build_active_tcp_session(sess_mgr_rte, sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
@@ -324,24 +326,25 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_DATA_TIMEOUT)
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL);
+    EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL);
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data);
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data);
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
     session_print(sess);
+
     // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
+    session_manager_rte_free_session(sess_mgr_rte, sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
@@ -355,14 +358,14 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_HALF_CLOSED_TIMEOUT)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S SYN Packet & C2S DATA Packet
-    build_active_tcp_session(sess_mgr_rt, sess);
+    build_active_tcp_session(sess_mgr_rte, sess);
 
     // C2S FIN Packet
     printf("\n=> Packet Parse: TCP C2S FIN packet\n");
@@ -371,10 +374,11 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_HALF_CLOSED_TIMEOUT)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 3) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -396,7 +400,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_HALF_CLOSED_TIMEOUT)
     session_print(sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
@@ -404,23 +408,24 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_HALF_CLOSED_TIMEOUT)
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 1);
 
     // expire session
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 3 + sess_mgr_cfg.tcp_timeout_ms.half_closed);
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 3 + sess_mgr_cfg.tcp_timeout_ms.half_closed);
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
     session_print(sess);
+
     // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
+    session_manager_rte_free_session(sess_mgr_rte, sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
@@ -434,14 +439,14 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_HALF_CLOSED_TIMEOUT)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S SYN Packet & C2S DATA Packet
-    build_active_tcp_session(sess_mgr_rt, sess);
+    build_active_tcp_session(sess_mgr_rte, sess);
 
     // S2C FIN Packet
     printf("\n=> Packet Parse: TCP S2C FIN packet\n");
@@ -450,10 +455,11 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_HALF_CLOSED_TIMEOUT)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 3) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -475,7 +481,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_HALF_CLOSED_TIMEOUT)
     session_print(sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
@@ -483,23 +489,24 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_HALF_CLOSED_TIMEOUT)
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 1);
 
     // expire session
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 3 + sess_mgr_cfg.tcp_timeout_ms.half_closed);
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 3 + sess_mgr_cfg.tcp_timeout_ms.half_closed);
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_FIN);
     session_print(sess);
+
     // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
+    session_manager_rte_free_session(sess_mgr_rte, sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 

infra/session_manager/test/gtest_state_tcp_init_to_opening.cpp

@@ -1,12 +1,5 @@
 // TCP state machine test: init -> opening
-#include <gtest/gtest.h>
+#include "test_utils.h"
-
-#include "tuple.h"
-#include "packet_internal.h"
-#include "packet_parser.h"
-#include "session_internal.h"
-#include "default_config.h"
-#include "test_packets.h"
 
 /******************************************************************************
  * case: TCP init -> opening (by SYN)
@@ -18,11 +11,11 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -31,9 +24,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
@@ -56,7 +50,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN)
     session_print(sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1);
@@ -64,24 +58,25 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN)
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.init) == NULL);                      // opening -> closing
+    EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.tcp_timeout_ms.init) == NULL);                      // opening -> closing
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.init + sess_mgr_cfg.tcp_timeout_ms.data); // closing -> closed
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.tcp_timeout_ms.init + sess_mgr_cfg.tcp_timeout_ms.data); // closing -> closed
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
     session_print(sess);
+
     // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
+    session_manager_rte_free_session(sess_mgr_rte, sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
@@ -95,11 +90,11 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // S2C SYNACK Packet
     printf("\n=> Packet Parse: TCP S2C SYNACK packet\n");
@@ -108,9 +103,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
@@ -133,7 +129,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK)
     session_print(sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1);
@@ -141,24 +137,25 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK)
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.handshake) == NULL);
+    EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.tcp_timeout_ms.handshake) == NULL);
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.handshake + sess_mgr_cfg.tcp_timeout_ms.data);
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.tcp_timeout_ms.handshake + sess_mgr_cfg.tcp_timeout_ms.data);
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
     session_print(sess);
+
     // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
+    session_manager_rte_free_session(sess_mgr_rte, sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
@@ -172,11 +169,11 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -185,9 +182,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
 
     // S2C SYNACK Packet
@@ -197,10 +195,11 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -222,7 +221,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK)
     session_print(sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1);
@@ -230,24 +229,25 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK)
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.handshake) == NULL);
+    EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.handshake) == NULL);
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.handshake + sess_mgr_cfg.tcp_timeout_ms.data);
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.handshake + sess_mgr_cfg.tcp_timeout_ms.data);
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
     session_print(sess);
+
     // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
+    session_manager_rte_free_session(sess_mgr_rte, sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
@@ -261,11 +261,11 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK_ACK)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -274,9 +274,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK_ACK)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
 
     // S2C SYNACK Packet
@@ -286,10 +287,11 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK_ACK)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
 
     // C2S ACK Packet
     printf("\n=> Packet Parse: TCP C2S ACK packet\n");
@@ -298,10 +300,11 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK_ACK)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 3) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -323,7 +326,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK_ACK)
     session_print(sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1);
@@ -331,24 +334,25 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK_ACK)
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 3 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL);
+    EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 3 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL);
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 3 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data);
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 3 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data);
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
     session_print(sess);
+
     // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
+    session_manager_rte_free_session(sess_mgr_rte, sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
@@ -364,11 +368,11 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_RETRANSMISSION)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -377,9 +381,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_RETRANSMISSION)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
 
     // C2S SYN Packet retransmission
@@ -394,10 +399,11 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_RETRANSMISSION)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -419,7 +425,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_RETRANSMISSION)
     session_print(sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1);
@@ -427,24 +433,25 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_RETRANSMISSION)
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.init) == NULL);
+    EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.init) == NULL);
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.init + sess_mgr_cfg.tcp_timeout_ms.data);
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.init + sess_mgr_cfg.tcp_timeout_ms.data);
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
     session_print(sess);
+
     // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
+    session_manager_rte_free_session(sess_mgr_rte, sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
@@ -460,11 +467,11 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK_RETRANSMISSION)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // S2C SYNACK Packet
     printf("\n=> Packet Parse: TCP S2C SYNACK packet\n");
@@ -473,9 +480,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK_RETRANSMISSION)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
 
     // SYNACK Packet retransmission
@@ -491,10 +499,11 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK_RETRANSMISSION)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -516,7 +525,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK_RETRANSMISSION)
     session_print(sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1);
@@ -524,24 +533,25 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK_RETRANSMISSION)
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.handshake) == NULL);
+    EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.handshake) == NULL);
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.handshake + sess_mgr_cfg.tcp_timeout_ms.data);
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.handshake + sess_mgr_cfg.tcp_timeout_ms.data);
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
     session_print(sess);
+
     // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
+    session_manager_rte_free_session(sess_mgr_rte, sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
@@ -555,11 +565,11 @@ TEST(TCP_INIT_TO_OPENING, BY_C2S_ASMMETRIC)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -568,9 +578,10 @@ TEST(TCP_INIT_TO_OPENING, BY_C2S_ASMMETRIC)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
 
     // C2S ACK Packet
@@ -580,10 +591,11 @@ TEST(TCP_INIT_TO_OPENING, BY_C2S_ASMMETRIC)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -605,7 +617,7 @@ TEST(TCP_INIT_TO_OPENING, BY_C2S_ASMMETRIC)
     session_print(sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1);
@@ -613,24 +625,25 @@ TEST(TCP_INIT_TO_OPENING, BY_C2S_ASMMETRIC)
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL);
+    EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL);
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data);
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data);
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
     session_print(sess);
+
     // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
+    session_manager_rte_free_session(sess_mgr_rte, sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
@@ -644,11 +657,11 @@ TEST(TCP_INIT_TO_OPENING, BY_S2C_ASMMETRIC)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // S2C SYNACK Packet
     printf("\n=> Packet Parse: TCP S2C SYNACK packet\n");
@@ -657,9 +670,10 @@ TEST(TCP_INIT_TO_OPENING, BY_S2C_ASMMETRIC)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
 
     // S2C ACK Packet
@@ -669,10 +683,11 @@ TEST(TCP_INIT_TO_OPENING, BY_S2C_ASMMETRIC)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -694,7 +709,7 @@ TEST(TCP_INIT_TO_OPENING, BY_S2C_ASMMETRIC)
     session_print(sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1);
@@ -702,24 +717,25 @@ TEST(TCP_INIT_TO_OPENING, BY_S2C_ASMMETRIC)
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL);
+    EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL);
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data);
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data);
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
     session_print(sess);
+
     // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
+    session_manager_rte_free_session(sess_mgr_rte, sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 

infra/session_manager/test/gtest_state_tcp_init_to_opening_to_active_to_closing_to_closed.cpp

@@ -1,12 +1,5 @@
 // TCP state machine test: init -> opening -> active -> closing -> closed
-#include <gtest/gtest.h>
+#include "test_utils.h"
-
-#include "tuple.h"
-#include "packet_internal.h"
-#include "packet_parser.h"
-#include "session_internal.h"
-#include "default_config.h"
-#include "test_packets.h"
 
 #if 1
 TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
@@ -14,11 +7,11 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
     char buffer[1024];
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -27,9 +20,10 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
@@ -58,10 +52,11 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     memset(buffer, 0, sizeof(buffer));
@@ -89,10 +84,11 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 3) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     memset(buffer, 0, sizeof(buffer));
@@ -120,10 +116,11 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 4) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 4) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     memset(buffer, 0, sizeof(buffer));
@@ -151,10 +148,11 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 5) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 5) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     memset(buffer, 0, sizeof(buffer));
@@ -182,10 +180,11 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 6) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 6) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     memset(buffer, 0, sizeof(buffer));
@@ -213,10 +212,11 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 7) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 7) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     memset(buffer, 0, sizeof(buffer));
@@ -244,10 +244,11 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 8) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 8) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     memset(buffer, 0, sizeof(buffer));
@@ -275,10 +276,11 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 9) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 9) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     memset(buffer, 0, sizeof(buffer));
@@ -306,10 +308,11 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 10) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 10) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     memset(buffer, 0, sizeof(buffer));
@@ -337,10 +340,11 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 11) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 11) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     memset(buffer, 0, sizeof(buffer));
@@ -362,7 +366,7 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
     EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
@@ -370,23 +374,24 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 1);
 
     // expire session
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 11 + sess_mgr_cfg.tcp_timeout_ms.time_wait);
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 11 + sess_mgr_cfg.tcp_timeout_ms.time_wait);
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
     session_print(sess);
+
     // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
+    session_manager_rte_free_session(sess_mgr_rte, sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 

infra/session_manager/test/gtest_state_tcp_opening_to_active.cpp

@@ -1,12 +1,5 @@
 // TCP state machine test: opening -> active
-#include <gtest/gtest.h>
+#include "test_utils.h"
-
-#include "tuple.h"
-#include "packet_internal.h"
-#include "packet_parser.h"
-#include "session_internal.h"
-#include "default_config.h"
-#include "test_packets.h"
 
 /******************************************************************************
  * case: TCP opening -> active (by C2S DATA)
@@ -18,11 +11,11 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYN_C2S_DATA)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -31,9 +24,10 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYN_C2S_DATA)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
 
     // C2S DATA Packet
@@ -43,10 +37,11 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYN_C2S_DATA)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -68,7 +63,7 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYN_C2S_DATA)
     session_print(sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
@@ -76,24 +71,25 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYN_C2S_DATA)
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL);
+    EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL);
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data);
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data);
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
     session_print(sess);
+
     // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
+    session_manager_rte_free_session(sess_mgr_rte, sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
@@ -107,11 +103,11 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYNACK_S2C_DATA)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // S2C SYNACK Packet
     printf("\n=> Packet Parse: TCP S2C SYNACK packet\n");
@@ -120,9 +116,10 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYNACK_S2C_DATA)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
 
     // S2C DATA Packet
@@ -132,10 +129,11 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYNACK_S2C_DATA)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -157,7 +155,7 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYNACK_S2C_DATA)
     session_print(sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
@@ -165,24 +163,25 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYNACK_S2C_DATA)
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL);
+    EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL);
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data);
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data);
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
     session_print(sess);
+
     // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
+    session_manager_rte_free_session(sess_mgr_rte, sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 

infra/session_manager/test/gtest_state_tcp_opening_to_closing.cpp

@@ -1,12 +1,5 @@
 // TCP state machine test: opening -> closing
-#include <gtest/gtest.h>
+#include "test_utils.h"
-
-#include "tuple.h"
-#include "packet_internal.h"
-#include "packet_parser.h"
-#include "session_internal.h"
-#include "default_config.h"
-#include "test_packets.h"
 
 /******************************************************************************
  * case: TCP opening -> closing (by FIN-FIN)
@@ -18,11 +11,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_FIN_FIN)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -31,9 +24,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_FIN_FIN)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
 
     // C2S FIN Packet
@@ -43,10 +37,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_FIN_FIN)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
 
     // S2C FIN Packet
     printf("\n=> Packet Parse: TCP S2C FIN packet\n");
@@ -55,10 +50,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_FIN_FIN)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 3) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -80,7 +76,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_FIN_FIN)
     session_print(sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
@@ -88,23 +84,24 @@ TEST(TCP_OPENING_TO_CLOSING, BY_FIN_FIN)
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 1);
 
     // expire session
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 3 + sess_mgr_cfg.tcp_timeout_ms.time_wait);
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 3 + sess_mgr_cfg.tcp_timeout_ms.time_wait);
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
     session_print(sess);
+
     // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
+    session_manager_rte_free_session(sess_mgr_rte, sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
@@ -118,11 +115,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_RST)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -131,9 +128,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_RST)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
 
     // C2S RST Packet
@@ -149,10 +147,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_RST)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -174,7 +173,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_RST)
     session_print(sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
@@ -182,23 +181,24 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_RST)
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 1);
 
     // expire session
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.unverified_rst);
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.unverified_rst);
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_RST);
     session_print(sess);
+
     // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
+    session_manager_rte_free_session(sess_mgr_rte, sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
@@ -212,11 +212,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_RST)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -225,9 +225,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_RST)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
 
     // S2C RST Packet
@@ -243,10 +244,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_RST)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -268,7 +270,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_RST)
     session_print(sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
@@ -276,23 +278,24 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_RST)
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 1);
 
     // expire session
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.unverified_rst);
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.unverified_rst);
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_RST);
     session_print(sess);
+
     // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
+    session_manager_rte_free_session(sess_mgr_rte, sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
@@ -305,11 +308,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_INIT_TIMEOUT)
 {
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -318,13 +321,14 @@ TEST(TCP_OPENING_TO_CLOSING, BY_INIT_TIMEOUT)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1);
@@ -332,24 +336,25 @@ TEST(TCP_OPENING_TO_CLOSING, BY_INIT_TIMEOUT)
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.init) == NULL);
+    EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.tcp_timeout_ms.init) == NULL);
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.init + sess_mgr_cfg.tcp_timeout_ms.data);
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.tcp_timeout_ms.init + sess_mgr_cfg.tcp_timeout_ms.data);
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
     session_print(sess);
+
     // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
+    session_manager_rte_free_session(sess_mgr_rte, sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
@@ -363,11 +368,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_HANDSHAKE_TIMEOUT)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -376,9 +381,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_HANDSHAKE_TIMEOUT)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
 
     // S2C SYNACK Packet
@@ -388,10 +394,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_HANDSHAKE_TIMEOUT)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -413,7 +420,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_HANDSHAKE_TIMEOUT)
     session_print(sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1);
@@ -421,24 +428,25 @@ TEST(TCP_OPENING_TO_CLOSING, BY_HANDSHAKE_TIMEOUT)
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.handshake) == NULL);
+    EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.handshake) == NULL);
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.handshake + sess_mgr_cfg.tcp_timeout_ms.data);
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.handshake + sess_mgr_cfg.tcp_timeout_ms.data);
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
     session_print(sess);
+
     // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
+    session_manager_rte_free_session(sess_mgr_rte, sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
@@ -452,11 +460,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_DATA_TIMEOUT)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -465,9 +473,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_DATA_TIMEOUT)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
 
     // S2C SYNACK Packet
@@ -477,10 +486,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_DATA_TIMEOUT)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
 
     // C2S ACK Packet
     printf("\n=> Packet Parse: TCP C2S ACK packet\n");
@@ -489,10 +499,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_DATA_TIMEOUT)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 3) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -514,7 +525,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_DATA_TIMEOUT)
     session_print(sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1);
@@ -522,24 +533,25 @@ TEST(TCP_OPENING_TO_CLOSING, BY_DATA_TIMEOUT)
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 3 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL);
+    EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 3 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL);
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 3 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data);
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 3 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data);
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
     session_print(sess);
+
     // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
+    session_manager_rte_free_session(sess_mgr_rte, sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
@@ -553,11 +565,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_HALF_FIN)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -566,9 +578,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_HALF_FIN)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
 
     // C2S FIN Packet
@@ -578,10 +591,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_HALF_FIN)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -603,7 +617,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_HALF_FIN)
     session_print(sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
@@ -611,23 +625,24 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_HALF_FIN)
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 1);
 
     // expire session
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.half_closed);
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.half_closed);
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
     session_print(sess);
+
     // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
+    session_manager_rte_free_session(sess_mgr_rte, sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
@@ -641,11 +656,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_HALF_FIN)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -654,9 +669,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_HALF_FIN)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
 
     // S2C FIN Packet
@@ -666,10 +682,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_HALF_FIN)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -691,7 +708,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_HALF_FIN)
     session_print(sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
@@ -699,23 +716,24 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_HALF_FIN)
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 1);
 
     // expire session
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.half_closed);
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.half_closed);
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_FIN);
     session_print(sess);
+
     // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
+    session_manager_rte_free_session(sess_mgr_rte, sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 

infra/session_manager/test/gtest_state_udp_init_to_opening_to_active_to_closing.cpp

@@ -1,24 +1,16 @@
 // UDP state machine test: init -> opening -> active -> closing
-#include <gtest/gtest.h>
+#include "test_utils.h"
-
-#include "tuple.h"
-#include "packet_internal.h"
-#include "packet_parser.h"
-#include "session_internal.h"
-#include "default_config.h"
-#include "test_packets.h"
-
 #if 1
 TEST(UDP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING, TEST)
 {
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S REQ Packet
     printf("\n=> Packet Parse: UDP C2S REQ packet\n");
@@ -27,9 +19,10 @@ TEST(UDP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING, TEST)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
@@ -57,10 +50,11 @@ TEST(UDP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING, TEST)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -82,7 +76,7 @@ TEST(UDP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING, TEST)
     session_print(sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->udp_sess_used == 1);
     EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == 0);
@@ -90,24 +84,25 @@ TEST(UDP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING, TEST)
     EXPECT_TRUE(sess_mgr_stat->udp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.udp_timeout_ms.data) == NULL);                      // active -> closing
+    EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.udp_timeout_ms.data) == NULL);                      // active -> closing
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.udp_timeout_ms.data + sess_mgr_cfg.udp_timeout_ms.data); // closing -> closed
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.udp_timeout_ms.data + sess_mgr_cfg.udp_timeout_ms.data); // closing -> closed
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
     session_print(sess);
+
     // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
+    session_manager_rte_free_session(sess_mgr_rte, sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->udp_sess_used == 0);
     EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == 0);
     EXPECT_TRUE(sess_mgr_stat->udp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->udp_sess_closing == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 

infra/session_manager/test/gtest_state_udp_init_to_opening_to_closing.cpp

@@ -1,12 +1,5 @@
 // UDP state machine test: init -> opening -> closing
-#include <gtest/gtest.h>
+#include "test_utils.h"
-
-#include "tuple.h"
-#include "packet_internal.h"
-#include "packet_parser.h"
-#include "session_internal.h"
-#include "default_config.h"
-#include "test_packets.h"
 
 /******************************************************************************
  * case: UDP init -> opening (by C2S Packet)
@@ -19,11 +12,11 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_C2S)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S REQ Packet
     printf("\n=> Packet Parse: UDP C2S REQ packet\n");
@@ -32,9 +25,10 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_C2S)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
@@ -57,7 +51,7 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_C2S)
     session_print(sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->udp_sess_used == 1);
     EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == 1);
@@ -65,24 +59,25 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_C2S)
     EXPECT_TRUE(sess_mgr_stat->udp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.udp_timeout_ms.data) == NULL);                      // opening -> closing
+    EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.udp_timeout_ms.data) == NULL);                      // opening -> closing
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.udp_timeout_ms.data + sess_mgr_cfg.udp_timeout_ms.data); // closing -> closed
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.udp_timeout_ms.data + sess_mgr_cfg.udp_timeout_ms.data); // closing -> closed
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
     session_print(sess);
+
     // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
+    session_manager_rte_free_session(sess_mgr_rte, sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->udp_sess_used == 0);
     EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == 0);
     EXPECT_TRUE(sess_mgr_stat->udp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->udp_sess_closing == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
@@ -97,11 +92,11 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_S2C)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // S2C RESP Packet
     printf("\n=> Packet Parse: UDP S2C RESP packet\n");
@@ -110,9 +105,10 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_S2C)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
@@ -135,7 +131,7 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_S2C)
     session_print(sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->udp_sess_used == 1);
     EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == 1);
@@ -143,8 +139,8 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_S2C)
     EXPECT_TRUE(sess_mgr_stat->udp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.udp_timeout_ms.data) == NULL);                      // opening -> closing
+    EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.udp_timeout_ms.data) == NULL);                      // opening -> closing
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.udp_timeout_ms.data + sess_mgr_cfg.udp_timeout_ms.data); // closing -> closed
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.udp_timeout_ms.data + sess_mgr_cfg.udp_timeout_ms.data); // closing -> closed
     EXPECT_TRUE(sess);
 
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
@@ -152,17 +148,17 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_S2C)
     session_print(sess);
 
     // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
+    session_manager_rte_free_session(sess_mgr_rte, sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->udp_sess_used == 0);
     EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == 0);
     EXPECT_TRUE(sess_mgr_stat->udp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->udp_sess_closing == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 

infra/session_manager/test/gtest_timeout_tcp_data.cpp

@@ -1,21 +1,14 @@
-#include <gtest/gtest.h>
+#include "test_utils.h"
-
-#include "tuple.h"
-#include "packet_internal.h"
-#include "packet_parser.h"
-#include "session_internal.h"
-#include "default_config.h"
-#include "test_packets.h"
 
 #if 1
 TEST(TIMEOUT, TCP_TIMEOUT_DATA)
 {
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -24,9 +17,10 @@ TEST(TIMEOUT, TCP_TIMEOUT_DATA)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
 
     // C2S DATA Packet
@@ -36,22 +30,24 @@ TEST(TIMEOUT, TCP_TIMEOUT_DATA)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL);
+    EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL);
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data);
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data);
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
     session_print(sess);
-    // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    // free session
+    session_manager_rte_free_session(sess_mgr_rte, sess);
+
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 

infra/session_manager/test/gtest_timeout_tcp_handshake.cpp

@@ -1,21 +1,14 @@
-#include <gtest/gtest.h>
+#include "test_utils.h"
-
-#include "tuple.h"
-#include "packet_internal.h"
-#include "packet_parser.h"
-#include "session_internal.h"
-#include "default_config.h"
-#include "test_packets.h"
 
 #if 1
 TEST(TIMEOUT, TCP_TIMEOUT_HANDSHAKE)
 {
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // S2C SYNACK Packet
     printf("\n=> Packet Parse: TCP S2C SYNACK packet\n");
@@ -24,22 +17,24 @@ TEST(TIMEOUT, TCP_TIMEOUT_HANDSHAKE)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
 
     // expire session
-    EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.handshake) == NULL);
+    EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.tcp_timeout_ms.handshake) == NULL);
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.handshake + sess_mgr_cfg.tcp_timeout_ms.data);
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.tcp_timeout_ms.handshake + sess_mgr_cfg.tcp_timeout_ms.data);
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
     session_print(sess);
-    // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    // free session
+    session_manager_rte_free_session(sess_mgr_rte, sess);
+
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 

infra/session_manager/test/gtest_timeout_tcp_init.cpp

@@ -1,21 +1,14 @@
-#include <gtest/gtest.h>
+#include "test_utils.h"
-
-#include "tuple.h"
-#include "packet_internal.h"
-#include "packet_parser.h"
-#include "session_internal.h"
-#include "default_config.h"
-#include "test_packets.h"
 
 #if 1
 TEST(TIMEOUT, TCP_TIMEOUT_INIT)
 {
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -24,22 +17,24 @@ TEST(TIMEOUT, TCP_TIMEOUT_INIT)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
 
     // expire session
-    EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.init) == NULL);                      // opening -> closing
+    EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.tcp_timeout_ms.init) == NULL);                      // opening -> closing
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.init + sess_mgr_cfg.tcp_timeout_ms.data); // closing -> closed
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.tcp_timeout_ms.init + sess_mgr_cfg.tcp_timeout_ms.data); // closing -> closed
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
     session_print(sess);
-    // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    // free session
+    session_manager_rte_free_session(sess_mgr_rte, sess);
+
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 

infra/session_manager/test/gtest_timeout_udp_data.cpp

@@ -1,21 +1,14 @@
-#include <gtest/gtest.h>
+#include "test_utils.h"
-
-#include "tuple.h"
-#include "packet_internal.h"
-#include "packet_parser.h"
-#include "session_internal.h"
-#include "default_config.h"
-#include "test_packets.h"
 
 #if 1
 TEST(TIMEOUT, UDP_TIMEOUT_DATA1)
 {
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S REQ Packet
     printf("\n=> Packet Parse: UDP C2S REQ packet\n");
@@ -24,22 +17,24 @@ TEST(TIMEOUT, UDP_TIMEOUT_DATA1)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
 
     // expire session
-    EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.udp_timeout_ms.data) == NULL);                      // opening -> closing
+    EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.udp_timeout_ms.data) == NULL);                      // opening -> closing
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.udp_timeout_ms.data + sess_mgr_cfg.udp_timeout_ms.data); // closing -> closed
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.udp_timeout_ms.data + sess_mgr_cfg.udp_timeout_ms.data); // closing -> closed
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
     session_print(sess);
-    // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    // free session
+    session_manager_rte_free_session(sess_mgr_rte, sess);
+
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
@@ -48,10 +43,10 @@ TEST(TIMEOUT, UDP_TIMEOUT_DATA2)
 {
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S REQ Packet
     printf("\n=> Packet Parse: UDP C2S REQ packet\n");
@@ -60,9 +55,10 @@ TEST(TIMEOUT, UDP_TIMEOUT_DATA2)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
 
     // S2C RESP Packet
@@ -72,22 +68,24 @@ TEST(TIMEOUT, UDP_TIMEOUT_DATA2)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.udp_timeout_ms.data) == NULL);                      // active -> closing
+    EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.udp_timeout_ms.data) == NULL);                      // active -> closing
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.udp_timeout_ms.data + sess_mgr_cfg.udp_timeout_ms.data); // closing -> closed
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.udp_timeout_ms.data + sess_mgr_cfg.udp_timeout_ms.data); // closing -> closed
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
     session_print(sess);
-    // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    // free session
+    session_manager_rte_free_session(sess_mgr_rte, sess);
+
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 

infra/session_manager/test/test_utils.h

@@ -1,10 +1,97 @@
 #pragma once
 
+#include <gtest/gtest.h>
+
 #ifdef __cplusplus
 extern "C"
 {
 #endif
 
+#include "tuple.h"
+#include "packet_parser.h"
+#include "packet_internal.h"
+#include "utils_internal.h"
+
+#include "session_pool.h"
+#include "session_timer.h"
+#include "session_table.h"
+#include "session_filter.h"
+#include "session_internal.h"
+#include "session_transition.h"
+#include "session_manager_cfg.h"
+#include "session_manager_rte.h"
+
+__attribute__((unused)) static struct session_manager_cfg sess_mgr_cfg = {
+    .instance_id = 1,
+    .thread_num = 1,
+    .session_id_seed = 0xFFFFF,
+
+    .tcp_session_max = 256,
+    .udp_session_max = 256,
+
+    .evict_old_on_tcp_table_limit = 1,
+    .evict_old_on_udp_table_limit = 1,
+
+    .expire_period_ms = 0,
+    .expire_batch_max = 1024,
+
+    .tcp_timeout_ms =
+        {
+            .init = 1,
+            .handshake = 2,
+            .data = 3,
+            .half_closed = 4,
+            .time_wait = 5,
+            .discard_default = 6,
+            .unverified_rst = 7,
+        },
+
+    .udp_timeout_ms =
+        {
+            .data = 8,
+            .discard_default = 0,
+        },
+
+    .duplicated_packet_bloom_filter =
+        {
+            .enable = 1,
+            .capacity = 1000,
+            .time_window_ms = 10,
+            .error_rate = 0.0001,
+        },
+
+    .evicted_session_bloom_filter =
+        {
+            .enable = 1,
+            .capacity = 1000,
+            .time_window_ms = 10,
+            .error_rate = 0.0001,
+        },
+
+    .tcp_reassembly =
+        {
+            .enable = 1,
+            .timeout_ms = 1000,
+            .buffered_segments_max = 16,
+        },
+};
+
+static inline void packet_overwrite_ipid(struct packet *pkt, uint16_t ip_id)
+{
+    const struct layer_private *ipv4_layer = packet_get_innermost_layer(pkt, LAYER_PROTO_IPV4);
+    EXPECT_TRUE(ipv4_layer);
+    struct ip *hdr = (struct ip *)ipv4_layer->hdr_ptr;
+    hdr->ip_id = htons(ip_id);
+}
+
+static inline void packet_overwrite_v4_saddr(struct packet *pkt, struct in_addr *addr)
+{
+    const struct layer_private *ipv4_layer = packet_get_innermost_layer(pkt, LAYER_PROTO_IPV4);
+    EXPECT_TRUE(ipv4_layer);
+    struct ip *hdr = (struct ip *)ipv4_layer->hdr_ptr;
+    hdr->ip_src = *addr;
+}
+
 /******************************************************************************
  * test packet: HTTP www.example.com
  ******************************************************************************/

scripts/CMakeLists.txt

@@ -1,2 +1 @@
-install(FILES python_stat.sh DESTINATION ./ COMPONENT PROGRAM)
+install(FILES stat_format.sh DESTINATION ./ COMPONENT PROGRAM)
-install(FILES shell_stat.sh DESTINATION ./ COMPONENT PROGRAM)

scripts/python_stat.sh

@@ -1,3 +0,0 @@
-#!/bin/bash
-
-/opt/MESA/bin/fieldstat_exporter.py local -j /opt/tsg/stellar/log/stellar_fs4.json -l --clear-screen -e

scripts/shell_stat.sh

@@ -1,59 +0,0 @@
-#!/bin/bash +x
-
-#cat stellar_fs4.json |jq
-#[
-#  {
-#    "name": "stellar",
-#    "tags": {},
-#    "fields": {
-#      "aaaa": 1111111,
-#      "bbbb": 2222222,
-#    },
-#    "timestamp_ms": 1713053113549
-#  }
-#]
-
-calculate() {
-    local curr_data=$1
-    local prev_data=$2
-
-    local fields=($(echo "$curr_data" | jq -r '.[].fields | to_entries | .[] | .key' | grep -v timestamp_ms))
-    local curr_ts=$(echo "$curr_data" | jq -r '.[].timestamp_ms')
-    local prev_ts=$(echo "$prev_data" | jq -r '.[].timestamp_ms')
-    local diff_ts=$(($curr_ts - $prev_ts))
-    local seconds=$((curr_ts / 1000))
-    local buffer=()
-
-    local curr_fileds=$(echo "$curr_data" | jq -r '.[].fields' | grep -v timestamp_ms)
-    local prev_fileds=$(echo "$prev_data" | jq -r '.[].fields' | grep -v timestamp_ms)
-
-    buffer+=("====================================$(date -d "@$seconds" +"%Y-%m-%d %H:%M:%S")====================================\n")
-    buffer+=("$(printf "%-30s" Field)$(printf "%-20s" Sum)$(printf "%-20s" Speed)\n")
-    local result=()
-    for field in "${fields[@]}"; do
-        local curr_val=$(echo "$curr_fileds" | grep $field | awk '{print $2}' | sed 's/,//g')
-        local prev_val=$(echo "$prev_fileds" | grep $field | awk '{print $2}' | sed 's/,//g')
-        local diff_val=$((curr_val - prev_val))
-        local speed=0
-        if [ $diff_ts -eq 0 ]; then
-            speed=0
-        else
-            speed=$((diff_val * 1000 / diff_ts))
-        fi
-        buffer+=("$(printf "%-30s" $field)$(printf "%-20s" $curr_val)$(printf "%-20s" $speed)\n")
-    done
-    buffer+=("===========================================================================================\n")
-    clear
-    echo -e "${buffer[@]}"
-}
-
-prev_data=""
-
-while true; do
-    curr_data=$(cat /opt/tsg/stellar/log/stellar_fs4.json)
-    if [ ! -z "$prev_data" ]; then
-        calculate "$curr_data" "$prev_data"
-    fi
-    prev_data="$curr_data"
-    sleep 1
-done

scripts/stat_format.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+
+if [ $# -ne 1 ]; then
+    echo "Usage: $0 <f4_json_file>"
+    exit 1
+fi
+
+f4_json_file=$1
+/opt/MESA/bin/fieldstat_exporter.py local -j $f4_json_file -l --clear-screen