optimize session manager config

18 files changed, 182 insertions, 853 deletions

diff --git a/infra/session_manager/test/default_config.h b/infra/session_manager/test/default_config.h
new file mode 100644
index 0000000..f949a8f
--- /dev/null
+++ b/infra/session_manager/test/default_config.h
@@ -0,0 +1,65 @@
+
+
+#pragma once
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#include "session_manager.h"
+
+static struct session_manager_config cfg = {
+    .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
diff --git a/infra/session_manager/test/gtest_case_tcp_fast_open.cpp b/infra/session_manager/test/gtest_case_tcp_fast_open.cpp
index 55ea792..1894b6b 100644
--- a/infra/session_manager/test/gtest_case_tcp_fast_open.cpp
+++ b/infra/session_manager/test/gtest_case_tcp_fast_open.cpp
@@ -4,51 +4,7 @@
 #include "packet_private.h"
 #include "packet_parser.h"
 #include "session_private.h"
-#include "session_manager.h"
-
-struct session_manager_config cfg = {
-    // max session number
-    .max_tcp_session_num = 256,
-    .max_udp_session_num = 256,
-
-    // session overload
-    .tcp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
-    .udp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
-
-    // tcp timeout
-    .tcp_init_timeout_ms = 1,
-    .tcp_handshake_timeout_ms = 2,
-    .tcp_data_timeout_ms = 3,
-    .tcp_half_closed_timeout_ms = 4,
-    .tcp_time_wait_timeout_ms = 5,
-    .tcp_discard_timeout_ms = 6,
-    .tcp_unverified_rst_timeout_ms = 7,
-
-    // udp timeout
-    .udp_data_timeout_ms = 8,
-    .udp_discard_timeout_ms = 0,
-
-    // limit
-    .session_expire_polling_interval_ms = 0,
-    .session_expire_polling_limit = 1024,
-
-    // duplicate packet filter
-    .duplicated_packet_filter_enable = 1,
-    .duplicated_packet_filter_capacity = 1000,
-    .duplicated_packet_filter_timeout_ms = 10,
-    .duplicated_packet_filter_error_rate = 0.0001,
-
-    // evicted session filter
-    .evicted_session_filter_enable = 1,
-    .evicted_session_filter_capacity = 1000,
-    .evicted_session_filter_timeout_ms = 10,
-    .evicted_session_filter_error_rate = 0.0001,
-
-    // TCP Reassembly
-    .tcp_reassembly_enable = 1,
-    .tcp_reassembly_max_timeout_ms = 60000,
-    .tcp_reassembly_max_segments = 16,
-};
+#include "default_config.h"
 
 static uint64_t session_id_generator(uint64_t now_ms __attribute__((unused)))
 {
@@ -406,8 +362,8 @@ TEST(CASE, TCP_FAST_OPEN)
     EXPECT_TRUE(stat->tcp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + cfg.tcp_init_timeout_ms) == NULL);             // opening -> closing
-    sess = session_manager_get_expired_session(mgr, 1 + cfg.tcp_init_timeout_ms + cfg.tcp_data_timeout_ms); // closing -> closed
+    EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + cfg.tcp_timeout_ms.init) == NULL);             // opening -> closing
+    sess = session_manager_get_expired_session(mgr, 1 + cfg.tcp_timeout_ms.init + 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);
diff --git a/infra/session_manager/test/gtest_filter_tcp_dupkt.cpp b/infra/session_manager/test/gtest_filter_tcp_dupkt.cpp
index 9bb3fa2..0c53a90 100644
--- a/infra/session_manager/test/gtest_filter_tcp_dupkt.cpp
+++ b/infra/session_manager/test/gtest_filter_tcp_dupkt.cpp
@@ -3,53 +3,9 @@
 #include "packet_private.h"
 #include "packet_parser.h"
 #include "session_private.h"
-#include "session_manager.h"
+#include "default_config.h"
 #include "test_packets.h"
 
-struct session_manager_config cfg = {
-    // max session number
-    .max_tcp_session_num = 256,
-    .max_udp_session_num = 256,
-
-    // session overload
-    .tcp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
-    .udp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
-
-    // tcp timeout
-    .tcp_init_timeout_ms = 1,
-    .tcp_handshake_timeout_ms = 2,
-    .tcp_data_timeout_ms = 3,
-    .tcp_half_closed_timeout_ms = 4,
-    .tcp_time_wait_timeout_ms = 5,
-    .tcp_discard_timeout_ms = 6,
-    .tcp_unverified_rst_timeout_ms = 7,
-
-    // udp timeout
-    .udp_data_timeout_ms = 8,
-    .udp_discard_timeout_ms = 0,
-
-    // limit
-    .session_expire_polling_interval_ms = 0,
-    .session_expire_polling_limit = 1024,
-
-    // duplicate packet filter
-    .duplicated_packet_filter_enable = 1,
-    .duplicated_packet_filter_capacity = 1000,
-    .duplicated_packet_filter_timeout_ms = 10,
-    .duplicated_packet_filter_error_rate = 0.0001,
-
-    // evicted session filter
-    .evicted_session_filter_enable = 1,
-    .evicted_session_filter_capacity = 1000,
-    .evicted_session_filter_timeout_ms = 10,
-    .evicted_session_filter_error_rate = 0.0001,
-
-    // TCP Reassembly
-    .tcp_reassembly_enable = 1,
-    .tcp_reassembly_max_timeout_ms = 60000,
-    .tcp_reassembly_max_segments = 16,
-};
-
 static uint64_t session_id_generator(uint64_t now_ms __attribute__((unused)))
 {
     static uint64_t count = 0;
@@ -292,7 +248,7 @@ TEST(TCP_DUPKT_FILTER_DISABLE, SYN_DUP)
     struct session_manager_stat *stat = NULL;
     struct session_manager_config _cfg;
     memcpy(&_cfg, &cfg, sizeof(struct session_manager_config));
-    _cfg.duplicated_packet_filter_enable = 0;
+    _cfg.duplicated_packet_bloom_filter.enable = 0;
 
     mgr = session_manager_new(&_cfg, 1);
     EXPECT_TRUE(mgr != NULL);
@@ -343,7 +299,7 @@ TEST(TCP_DUPKT_FILTER_DISABLE, SYNACK_DUP)
     struct session_manager_stat *stat = NULL;
     struct session_manager_config _cfg;
     memcpy(&_cfg, &cfg, sizeof(struct session_manager_config));
-    _cfg.duplicated_packet_filter_enable = 0;
+    _cfg.duplicated_packet_bloom_filter.enable = 0;
 
     mgr = session_manager_new(&_cfg, 1);
     EXPECT_TRUE(mgr != NULL);
diff --git a/infra/session_manager/test/gtest_overload_evict_tcp_sess.cpp b/infra/session_manager/test/gtest_overload_evict_tcp_sess.cpp
index 9dbfe2b..663ec24 100644
--- a/infra/session_manager/test/gtest_overload_evict_tcp_sess.cpp
+++ b/infra/session_manager/test/gtest_overload_evict_tcp_sess.cpp
@@ -4,53 +4,9 @@
 #include "packet_private.h"
 #include "packet_parser.h"
 #include "session_private.h"
-#include "session_manager.h"
+#include "default_config.h"
 #include "test_packets.h"
 
-struct session_manager_config cfg = {
-    // max session number
-    .max_tcp_session_num = RX_BURST_MAX * 2,
-    .max_udp_session_num = RX_BURST_MAX * 2,
-
-    // session overload
-    .tcp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
-    .udp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
-
-    // tcp timeout
-    .tcp_init_timeout_ms = 1,
-    .tcp_handshake_timeout_ms = 2,
-    .tcp_data_timeout_ms = 3,
-    .tcp_half_closed_timeout_ms = 4,
-    .tcp_time_wait_timeout_ms = 5,
-    .tcp_discard_timeout_ms = 6,
-    .tcp_unverified_rst_timeout_ms = 7,
-
-    // udp timeout
-    .udp_data_timeout_ms = 8,
-    .udp_discard_timeout_ms = 0,
-
-    // limit
-    .session_expire_polling_interval_ms = 0,
-    .session_expire_polling_limit = 1024,
-
-    // duplicate packet filter
-    .duplicated_packet_filter_enable = 1,
-    .duplicated_packet_filter_capacity = 1000,
-    .duplicated_packet_filter_timeout_ms = 10,
-    .duplicated_packet_filter_error_rate = 0.0001,
-
-    // evicted session filter
-    .evicted_session_filter_enable = 1,
-    .evicted_session_filter_capacity = 1000,
-    .evicted_session_filter_timeout_ms = 10,
-    .evicted_session_filter_error_rate = 0.0001,
-
-    // TCP Reassembly
-    .tcp_reassembly_enable = 1,
-    .tcp_reassembly_max_timeout_ms = 60000,
-    .tcp_reassembly_max_segments = 16,
-};
-
 static uint64_t session_id_generator(uint64_t now_ms __attribute__((unused)))
 {
     static uint64_t count = 0;
@@ -71,8 +27,12 @@ TEST(TCP_OVERLOAD, EVICT_OLD_SESS)
     struct packet pkt;
     struct session_manager *mgr = NULL;
     struct session_manager_stat *stat = NULL;
+    struct session_manager_config _cfg;
+    memcpy(&_cfg, &cfg, sizeof(struct session_manager_config));
+    _cfg.tcp_session_max = RX_BURST_MAX * 2;
+    _cfg.udp_session_max = RX_BURST_MAX * 2;
 
-    mgr = session_manager_new(&cfg, 1);
+    mgr = session_manager_new(&_cfg, 1);
     EXPECT_TRUE(mgr != NULL);
     session_manager_set_session_id_generator(mgr, session_id_generator);
 
@@ -83,15 +43,15 @@ TEST(TCP_OVERLOAD, EVICT_OLD_SESS)
     printf("<= Packet Parse: done\n\n");
 
     // new session
-    for (uint32_t i = 0; i < cfg.max_tcp_session_num; i++)
+    for (uint32_t i = 0; i < _cfg.tcp_session_max; i++)
     {
         packet_set_ip_src_addr(&pkt, i);
         EXPECT_TRUE(session_manager_new_session(mgr, &pkt, 1));
     }
-    printf("=> Session Manager: after add %lu new sessions\n", cfg.max_tcp_session_num);
+    printf("=> Session Manager: after add %lu new sessions\n", _cfg.tcp_session_max);
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess_used == cfg.max_tcp_session_num);
+    EXPECT_TRUE(stat->tcp_sess_used == _cfg.tcp_session_max);
     EXPECT_TRUE(stat->tcp_sess_opening == RX_BURST_MAX);
     EXPECT_TRUE(stat->tcp_sess_active == 0);
     EXPECT_TRUE(stat->tcp_sess_closing == 0);
@@ -112,7 +72,9 @@ TEST(TCP_OVERLOAD, EVICT_NEW_SESS)
     struct session_manager_stat *stat = NULL;
     struct session_manager_config _cfg;
     memcpy(&_cfg, &cfg, sizeof(struct session_manager_config));
-    _cfg.tcp_overload_evict_old_sess = 0;
+    _cfg.tcp_session_max = RX_BURST_MAX * 2;
+    _cfg.udp_session_max = RX_BURST_MAX * 2;
+    _cfg.evict_old_on_tcp_table_limit = 0;
 
     mgr = session_manager_new(&_cfg, 1);
     EXPECT_TRUE(mgr != NULL);
@@ -125,16 +87,16 @@ TEST(TCP_OVERLOAD, EVICT_NEW_SESS)
     printf("<= Packet Parse: done\n\n");
 
     // new session
-    for (uint32_t i = 0; i < cfg.max_tcp_session_num; i++)
+    for (uint32_t i = 0; i < _cfg.tcp_session_max; i++)
     {
         packet_set_ip_src_addr(&pkt, i);
         EXPECT_TRUE(session_manager_new_session(mgr, &pkt, 1));
     }
-    printf("=> Session Manager: after add %lu new sessions\n", cfg.max_tcp_session_num);
+    printf("=> Session Manager: after add %lu new sessions\n", _cfg.tcp_session_max);
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess_used == cfg.max_tcp_session_num);
-    EXPECT_TRUE(stat->tcp_sess_opening == cfg.max_tcp_session_num);
+    EXPECT_TRUE(stat->tcp_sess_used == _cfg.tcp_session_max);
+    EXPECT_TRUE(stat->tcp_sess_opening == _cfg.tcp_session_max);
     EXPECT_TRUE(stat->tcp_sess_active == 0);
     EXPECT_TRUE(stat->tcp_sess_closing == 0);
     EXPECT_TRUE(stat->tcp_sess_closed == 0);
@@ -145,15 +107,15 @@ 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.max_tcp_session_num + i);
+        packet_set_ip_src_addr(&pkt, _cfg.tcp_session_max + i);
         EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL);
         EXPECT_TRUE(session_manager_new_session(mgr, &pkt, 1) == NULL);
     }
     printf("=> Session Manager: after evicte new session\n");
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess_used == cfg.max_tcp_session_num);
-    EXPECT_TRUE(stat->tcp_sess_opening == cfg.max_tcp_session_num);
+    EXPECT_TRUE(stat->tcp_sess_used == _cfg.tcp_session_max);
+    EXPECT_TRUE(stat->tcp_sess_opening == _cfg.tcp_session_max);
     EXPECT_TRUE(stat->tcp_sess_active == 0);
     EXPECT_TRUE(stat->tcp_sess_closing == 0);
     EXPECT_TRUE(stat->tcp_sess_closed == 0);
diff --git a/infra/session_manager/test/gtest_overload_evict_udp_sess.cpp b/infra/session_manager/test/gtest_overload_evict_udp_sess.cpp
index 2f15528..1ccb723 100644
--- a/infra/session_manager/test/gtest_overload_evict_udp_sess.cpp
+++ b/infra/session_manager/test/gtest_overload_evict_udp_sess.cpp
@@ -4,53 +4,9 @@
 #include "packet_private.h"
 #include "packet_parser.h"
 #include "session_private.h"
-#include "session_manager.h"
+#include "default_config.h"
 #include "test_packets.h"
 
-struct session_manager_config cfg = {
-    // max session number
-    .max_tcp_session_num = RX_BURST_MAX * 2,
-    .max_udp_session_num = RX_BURST_MAX * 2,
-
-    // session overload
-    .tcp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
-    .udp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
-
-    // tcp timeout
-    .tcp_init_timeout_ms = 1,
-    .tcp_handshake_timeout_ms = 2,
-    .tcp_data_timeout_ms = 3,
-    .tcp_half_closed_timeout_ms = 4,
-    .tcp_time_wait_timeout_ms = 5,
-    .tcp_discard_timeout_ms = 6,
-    .tcp_unverified_rst_timeout_ms = 7,
-
-    // udp timeout
-    .udp_data_timeout_ms = 8,
-    .udp_discard_timeout_ms = 0,
-
-    // limit
-    .session_expire_polling_interval_ms = 0,
-    .session_expire_polling_limit = 1024,
-
-    // duplicate packet filter
-    .duplicated_packet_filter_enable = 1,
-    .duplicated_packet_filter_capacity = 1000,
-    .duplicated_packet_filter_timeout_ms = 10,
-    .duplicated_packet_filter_error_rate = 0.0001,
-
-    // evicted session filter
-    .evicted_session_filter_enable = 1,
-    .evicted_session_filter_capacity = 1000,
-    .evicted_session_filter_timeout_ms = 10,
-    .evicted_session_filter_error_rate = 0.0001,
-
-    // TCP Reassembly
-    .tcp_reassembly_enable = 1,
-    .tcp_reassembly_max_timeout_ms = 60000,
-    .tcp_reassembly_max_segments = 16,
-};
-
 static uint64_t session_id_generator(uint64_t now_ms __attribute__((unused)))
 {
     static uint64_t count = 0;
@@ -72,8 +28,12 @@ TEST(UDP_OVERLOAD, EVICT_OLD_SESS)
     struct session *sess = NULL;
     struct session_manager *mgr = NULL;
     struct session_manager_stat *stat = NULL;
+    struct session_manager_config _cfg;
+    memcpy(&_cfg, &cfg, sizeof(struct session_manager_config));
+    _cfg.tcp_session_max = RX_BURST_MAX * 2;
+    _cfg.udp_session_max = RX_BURST_MAX * 2;
 
-    mgr = session_manager_new(&cfg, 1);
+    mgr = session_manager_new(&_cfg, 1);
     EXPECT_TRUE(mgr != NULL);
     session_manager_set_session_id_generator(mgr, session_id_generator);
 
@@ -84,15 +44,15 @@ TEST(UDP_OVERLOAD, EVICT_OLD_SESS)
     printf("<= Packet Parse: done\n\n");
 
     // new session
-    for (uint32_t i = 0; i < cfg.max_udp_session_num; i++)
+    for (uint32_t i = 0; i < _cfg.udp_session_max; i++)
     {
         packet_set_ip_src_addr(&pkt, i);
         EXPECT_TRUE(session_manager_new_session(mgr, &pkt, 1));
     }
-    printf("=> Session Manager: after add %lu new sessions\n", cfg.max_udp_session_num);
+    printf("=> Session Manager: after add %lu new sessions\n", _cfg.udp_session_max);
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->udp_sess_used == cfg.max_udp_session_num);
+    EXPECT_TRUE(stat->udp_sess_used == _cfg.udp_session_max);
     EXPECT_TRUE(stat->udp_sess_opening == RX_BURST_MAX);
     EXPECT_TRUE(stat->udp_sess_active == 0);
     EXPECT_TRUE(stat->udp_sess_closing == 0);
@@ -136,7 +96,7 @@ TEST(UDP_OVERLOAD, EVICT_OLD_SESS)
     // evicted session timeout
     packet_set_ip_src_addr(&pkt, 0);
     EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL);
-    EXPECT_TRUE(session_manager_new_session(mgr, &pkt, 1 + cfg.evicted_session_filter_timeout_ms));
+    EXPECT_TRUE(session_manager_new_session(mgr, &pkt, 1 + _cfg.evicted_session_bloom_filter.time_window_ms));
     printf("=> Session Manager: after evicted session timeout\n");
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
@@ -161,7 +121,9 @@ TEST(UDP_OVERLOAD, EVICT_NEW_SESS)
     struct session_manager_stat *stat = NULL;
     struct session_manager_config _cfg;
     memcpy(&_cfg, &cfg, sizeof(struct session_manager_config));
-    _cfg.udp_overload_evict_old_sess = 0;
+    _cfg.tcp_session_max = RX_BURST_MAX * 2;
+    _cfg.udp_session_max = RX_BURST_MAX * 2;
+    _cfg.evict_old_on_udp_table_limit = 0;
 
     mgr = session_manager_new(&_cfg, 1);
     EXPECT_TRUE(mgr != NULL);
@@ -174,16 +136,16 @@ TEST(UDP_OVERLOAD, EVICT_NEW_SESS)
     printf("<= Packet Parse: done\n\n");
 
     // new session
-    for (uint32_t i = 0; i < cfg.max_udp_session_num; i++)
+    for (uint32_t i = 0; i < _cfg.udp_session_max; i++)
     {
         packet_set_ip_src_addr(&pkt, i);
         EXPECT_TRUE(session_manager_new_session(mgr, &pkt, 1));
     }
-    printf("=> Session Manager: after add %lu new sessions\n", cfg.max_udp_session_num);
+    printf("=> Session Manager: after add %lu new sessions\n", _cfg.udp_session_max);
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->udp_sess_used == cfg.max_udp_session_num);
-    EXPECT_TRUE(stat->udp_sess_opening == cfg.max_udp_session_num);
+    EXPECT_TRUE(stat->udp_sess_used == _cfg.udp_session_max);
+    EXPECT_TRUE(stat->udp_sess_opening == _cfg.udp_session_max);
     EXPECT_TRUE(stat->udp_sess_active == 0);
     EXPECT_TRUE(stat->udp_sess_closing == 0);
     EXPECT_TRUE(stat->udp_sess_closed == 0);
@@ -197,15 +159,15 @@ TEST(UDP_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.max_udp_session_num + i);
+        packet_set_ip_src_addr(&pkt, _cfg.udp_session_max + i);
         EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL);
         EXPECT_TRUE(session_manager_new_session(mgr, &pkt, 1) == NULL);
     }
     printf("=> Session Manager: after readd %d evicted session\n", RX_BURST_MAX);
     stat = session_manager_stat(mgr);
     EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->udp_sess_used == cfg.max_udp_session_num);
-    EXPECT_TRUE(stat->udp_sess_opening == cfg.max_udp_session_num);
+    EXPECT_TRUE(stat->udp_sess_used == _cfg.udp_session_max);
+    EXPECT_TRUE(stat->udp_sess_opening == _cfg.udp_session_max);
     EXPECT_TRUE(stat->udp_sess_active == 0);
     EXPECT_TRUE(stat->udp_sess_closing == 0);
     EXPECT_TRUE(stat->udp_sess_closed == 0);
diff --git a/infra/session_manager/test/gtest_sess_mgr_scan.cpp b/infra/session_manager/test/gtest_sess_mgr_scan.cpp
index 5d353db..36f241a 100644
--- a/infra/session_manager/test/gtest_sess_mgr_scan.cpp
+++ b/infra/session_manager/test/gtest_sess_mgr_scan.cpp
@@ -1,55 +1,11 @@
 #include <gtest/gtest.h>
 
 #include "session_private.h"
-#include "session_manager.h"
 #include "packet_private.h"
 #include "packet_parser.h"
+#include "default_config.h"
 #include "test_packets.h"
 
-struct session_manager_config cfg = {
-    // max session number
-    .max_tcp_session_num = 256,
-    .max_udp_session_num = 256,
-
-    // session overload
-    .tcp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
-    .udp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
-
-    // tcp timeout
-    .tcp_init_timeout_ms = 1,
-    .tcp_handshake_timeout_ms = 2,
-    .tcp_data_timeout_ms = 3,
-    .tcp_half_closed_timeout_ms = 4,
-    .tcp_time_wait_timeout_ms = 5,
-    .tcp_discard_timeout_ms = 6,
-    .tcp_unverified_rst_timeout_ms = 7,
-
-    // udp timeout
-    .udp_data_timeout_ms = 8,
-    .udp_discard_timeout_ms = 0,
-
-    // limit
-    .session_expire_polling_interval_ms = 0,
-    .session_expire_polling_limit = 1024,
-
-    // duplicate packet filter
-    .duplicated_packet_filter_enable = 1,
-    .duplicated_packet_filter_capacity = 1000,
-    .duplicated_packet_filter_timeout_ms = 10,
-    .duplicated_packet_filter_error_rate = 0.0001,
-
-    // evicted session filter
-    .evicted_session_filter_enable = 1,
-    .evicted_session_filter_capacity = 1000,
-    .evicted_session_filter_timeout_ms = 10,
-    .evicted_session_filter_error_rate = 0.0001,
-
-    // TCP Reassembly
-    .tcp_reassembly_enable = 1,
-    .tcp_reassembly_max_timeout_ms = 60000,
-    .tcp_reassembly_max_segments = 16,
-};
-
 static uint64_t session_id_generator(uint64_t now_ms __attribute__((unused)))
 {
     static uint64_t count = 0;
diff --git a/infra/session_manager/test/gtest_sess_mgr_tcp_reassembly.cpp b/infra/session_manager/test/gtest_sess_mgr_tcp_reassembly.cpp
index 952852b..03e3ec5 100644
--- a/infra/session_manager/test/gtest_sess_mgr_tcp_reassembly.cpp
+++ b/infra/session_manager/test/gtest_sess_mgr_tcp_reassembly.cpp
@@ -3,53 +3,9 @@
 #include "packet_private.h"
 #include "packet_parser.h"
 #include "session_private.h"
-#include "session_manager.h"
+#include "default_config.h"
 #include "test_packets.h"
 
-struct session_manager_config cfg = {
-    // max session number
-    .max_tcp_session_num = 256,
-    .max_udp_session_num = 256,
-
-    // session overload
-    .tcp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
-    .udp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
-
-    // tcp timeout
-    .tcp_init_timeout_ms = 1,
-    .tcp_handshake_timeout_ms = 2,
-    .tcp_data_timeout_ms = 3,
-    .tcp_half_closed_timeout_ms = 4,
-    .tcp_time_wait_timeout_ms = 5,
-    .tcp_discard_timeout_ms = 6,
-    .tcp_unverified_rst_timeout_ms = 7,
-
-    // udp timeout
-    .udp_data_timeout_ms = 8,
-    .udp_discard_timeout_ms = 0,
-
-    // limit
-    .session_expire_polling_interval_ms = 0,
-    .session_expire_polling_limit = 1024,
-
-    // duplicate packet filter
-    .duplicated_packet_filter_enable = 1,
-    .duplicated_packet_filter_capacity = 1000,
-    .duplicated_packet_filter_timeout_ms = 10,
-    .duplicated_packet_filter_error_rate = 0.0001,
-
-    // evicted session filter
-    .evicted_session_filter_enable = 1,
-    .evicted_session_filter_capacity = 1000,
-    .evicted_session_filter_timeout_ms = 10,
-    .evicted_session_filter_error_rate = 0.0001,
-
-    // TCP Reassembly
-    .tcp_reassembly_enable = 1,
-    .tcp_reassembly_max_timeout_ms = 60000,
-    .tcp_reassembly_max_segments = 16,
-};
-
 static uint64_t session_id_generator(uint64_t now_ms __attribute__((unused)))
 {
     static uint64_t count = 0;
@@ -249,8 +205,8 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
     session_free_tcp_segment(sess, seg);
 
     // expire session
-    EXPECT_TRUE(session_manager_get_expired_session(mgr, 7 + cfg.tcp_data_timeout_ms) == NULL);             // active -> closing
-    sess = session_manager_get_expired_session(mgr, 7 + cfg.tcp_data_timeout_ms + cfg.tcp_data_timeout_ms); // closing -> closed
+    EXPECT_TRUE(session_manager_get_expired_session(mgr, 7 + cfg.tcp_timeout_ms.data) == NULL);             // active -> closing
+    sess = session_manager_get_expired_session(mgr, 7 + cfg.tcp_timeout_ms.data + 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);
@@ -343,8 +299,8 @@ TEST(SESS_MGR_TCP_REASSEMBLY, SEQ_WRAPAROUND)
     session_free_tcp_segment(sess, seg);
 
     // expire session
-    EXPECT_TRUE(session_manager_get_expired_session(mgr, 4 + cfg.tcp_data_timeout_ms) == NULL);             // active -> closing
-    sess = session_manager_get_expired_session(mgr, 4 + cfg.tcp_data_timeout_ms + cfg.tcp_data_timeout_ms); // closing -> closed
+    EXPECT_TRUE(session_manager_get_expired_session(mgr, 4 + cfg.tcp_timeout_ms.data) == NULL);             // active -> closing
+    sess = session_manager_get_expired_session(mgr, 4 + cfg.tcp_timeout_ms.data + 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);
diff --git a/infra/session_manager/test/gtest_state_tcp_active_to_closing.cpp b/infra/session_manager/test/gtest_state_tcp_active_to_closing.cpp
index 60cbbbe..40e3f7d 100644
--- a/infra/session_manager/test/gtest_state_tcp_active_to_closing.cpp
+++ b/infra/session_manager/test/gtest_state_tcp_active_to_closing.cpp
@@ -5,53 +5,9 @@
 #include "packet_private.h"
 #include "packet_parser.h"
 #include "session_private.h"
-#include "session_manager.h"
+#include "default_config.h"
 #include "test_packets.h"
 
-struct session_manager_config cfg = {
-    // max session number
-    .max_tcp_session_num = 256,
-    .max_udp_session_num = 256,
-
-    // session overload
-    .tcp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
-    .udp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
-
-    // tcp timeout
-    .tcp_init_timeout_ms = 1,
-    .tcp_handshake_timeout_ms = 2,
-    .tcp_data_timeout_ms = 3,
-    .tcp_half_closed_timeout_ms = 4,
-    .tcp_time_wait_timeout_ms = 5,
-    .tcp_discard_timeout_ms = 6,
-    .tcp_unverified_rst_timeout_ms = 7,
-
-    // udp timeout
-    .udp_data_timeout_ms = 8,
-    .udp_discard_timeout_ms = 0,
-
-    // limit
-    .session_expire_polling_interval_ms = 0,
-    .session_expire_polling_limit = 1024,
-
-    // duplicate packet filter
-    .duplicated_packet_filter_enable = 1,
-    .duplicated_packet_filter_capacity = 1000,
-    .duplicated_packet_filter_timeout_ms = 10,
-    .duplicated_packet_filter_error_rate = 0.0001,
-
-    // evicted session filter
-    .evicted_session_filter_enable = 1,
-    .evicted_session_filter_capacity = 1000,
-    .evicted_session_filter_timeout_ms = 10,
-    .evicted_session_filter_error_rate = 0.0001,
-
-    // TCP Reassembly
-    .tcp_reassembly_enable = 1,
-    .tcp_reassembly_max_timeout_ms = 60000,
-    .tcp_reassembly_max_segments = 16,
-};
-
 static uint64_t session_id_generator(uint64_t now_ms __attribute__((unused)))
 {
     static uint64_t count = 0;
@@ -159,7 +115,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_FIN_FIN)
     EXPECT_TRUE(stat->tcp_sess_closing == 1);
 
     // expire session
-    sess = session_manager_get_expired_session(mgr, 3 + cfg.tcp_time_wait_timeout_ms);
+    sess = session_manager_get_expired_session(mgr, 3 + 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);
@@ -245,7 +201,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_RST)
     EXPECT_TRUE(stat->tcp_sess_closing == 1);
 
     // expire session
-    sess = session_manager_get_expired_session(mgr, 3 + cfg.tcp_unverified_rst_timeout_ms);
+    sess = session_manager_get_expired_session(mgr, 3 + 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);
@@ -331,7 +287,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_RST)
     EXPECT_TRUE(stat->tcp_sess_closing == 1);
 
     // expire session
-    sess = session_manager_get_expired_session(mgr, 3 + cfg.tcp_unverified_rst_timeout_ms);
+    sess = session_manager_get_expired_session(mgr, 3 + 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);
@@ -378,8 +334,8 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_DATA_TIMEOUT)
     EXPECT_TRUE(stat->tcp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_data_timeout_ms) == NULL);
-    sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_data_timeout_ms + cfg.tcp_data_timeout_ms);
+    EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.data) == NULL);
+    sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.data + 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);
@@ -459,7 +415,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_HALF_CLOSED_TIMEOUT)
     EXPECT_TRUE(stat->tcp_sess_closing == 1);
 
     // expire session
-    sess = session_manager_get_expired_session(mgr, 3 + cfg.tcp_half_closed_timeout_ms);
+    sess = session_manager_get_expired_session(mgr, 3 + 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);
@@ -539,7 +495,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_HALF_CLOSED_TIMEOUT)
     EXPECT_TRUE(stat->tcp_sess_closing == 1);
 
     // expire session
-    sess = session_manager_get_expired_session(mgr, 3 + cfg.tcp_half_closed_timeout_ms);
+    sess = session_manager_get_expired_session(mgr, 3 + 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);
diff --git a/infra/session_manager/test/gtest_state_tcp_init_to_opening.cpp b/infra/session_manager/test/gtest_state_tcp_init_to_opening.cpp
index 6434a3b..1395072 100644
--- a/infra/session_manager/test/gtest_state_tcp_init_to_opening.cpp
+++ b/infra/session_manager/test/gtest_state_tcp_init_to_opening.cpp
@@ -5,53 +5,9 @@
 #include "packet_private.h"
 #include "packet_parser.h"
 #include "session_private.h"
-#include "session_manager.h"
+#include "default_config.h"
 #include "test_packets.h"
 
-struct session_manager_config cfg = {
-    // max session number
-    .max_tcp_session_num = 256,
-    .max_udp_session_num = 256,
-
-    // session overload
-    .tcp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
-    .udp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
-
-    // tcp timeout
-    .tcp_init_timeout_ms = 1,
-    .tcp_handshake_timeout_ms = 2,
-    .tcp_data_timeout_ms = 3,
-    .tcp_half_closed_timeout_ms = 4,
-    .tcp_time_wait_timeout_ms = 5,
-    .tcp_discard_timeout_ms = 6,
-    .tcp_unverified_rst_timeout_ms = 7,
-
-    // udp timeout
-    .udp_data_timeout_ms = 8,
-    .udp_discard_timeout_ms = 0,
-
-    // limit
-    .session_expire_polling_interval_ms = 0,
-    .session_expire_polling_limit = 1024,
-
-    // duplicate packet filter
-    .duplicated_packet_filter_enable = 1,
-    .duplicated_packet_filter_capacity = 1000,
-    .duplicated_packet_filter_timeout_ms = 10,
-    .duplicated_packet_filter_error_rate = 0.0001,
-
-    // evicted session filter
-    .evicted_session_filter_enable = 1,
-    .evicted_session_filter_capacity = 1000,
-    .evicted_session_filter_timeout_ms = 10,
-    .evicted_session_filter_error_rate = 0.0001,
-
-    // TCP Reassembly
-    .tcp_reassembly_enable = 1,
-    .tcp_reassembly_max_timeout_ms = 60000,
-    .tcp_reassembly_max_segments = 16,
-};
-
 static uint64_t session_id_generator(uint64_t now_ms __attribute__((unused)))
 {
     static uint64_t count = 0;
@@ -115,8 +71,8 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN)
     EXPECT_TRUE(stat->tcp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + cfg.tcp_init_timeout_ms) == NULL);             // opening -> closing
-    sess = session_manager_get_expired_session(mgr, 1 + cfg.tcp_init_timeout_ms + cfg.tcp_data_timeout_ms); // closing -> closed
+    EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + cfg.tcp_timeout_ms.init) == NULL);             // opening -> closing
+    sess = session_manager_get_expired_session(mgr, 1 + cfg.tcp_timeout_ms.init + 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);
@@ -193,8 +149,8 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK)
     EXPECT_TRUE(stat->tcp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + cfg.tcp_handshake_timeout_ms) == NULL);
-    sess = session_manager_get_expired_session(mgr, 1 + cfg.tcp_handshake_timeout_ms + cfg.tcp_data_timeout_ms);
+    EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + cfg.tcp_timeout_ms.handshake) == NULL);
+    sess = session_manager_get_expired_session(mgr, 1 + cfg.tcp_timeout_ms.handshake + 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);
@@ -283,8 +239,8 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK)
     EXPECT_TRUE(stat->tcp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_handshake_timeout_ms) == NULL);
-    sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_handshake_timeout_ms + cfg.tcp_data_timeout_ms);
+    EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.handshake) == NULL);
+    sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.handshake + 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);
@@ -385,8 +341,8 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK_ACK)
     EXPECT_TRUE(stat->tcp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_get_expired_session(mgr, 3 + cfg.tcp_data_timeout_ms) == NULL);
-    sess = session_manager_get_expired_session(mgr, 3 + cfg.tcp_data_timeout_ms + cfg.tcp_data_timeout_ms);
+    EXPECT_TRUE(session_manager_get_expired_session(mgr, 3 + cfg.tcp_timeout_ms.data) == NULL);
+    sess = session_manager_get_expired_session(mgr, 3 + cfg.tcp_timeout_ms.data + 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);
@@ -482,8 +438,8 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_RETRANSMISSION)
     EXPECT_TRUE(stat->tcp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_init_timeout_ms) == NULL);
-    sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_init_timeout_ms + cfg.tcp_data_timeout_ms);
+    EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.init) == NULL);
+    sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.init + 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);
@@ -580,8 +536,8 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK_RETRANSMISSION)
     EXPECT_TRUE(stat->tcp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_handshake_timeout_ms) == NULL);
-    sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_handshake_timeout_ms + cfg.tcp_data_timeout_ms);
+    EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.handshake) == NULL);
+    sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.handshake + 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);
@@ -670,8 +626,8 @@ TEST(TCP_INIT_TO_OPENING, BY_C2S_ASMMETRIC)
     EXPECT_TRUE(stat->tcp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_data_timeout_ms) == NULL);
-    sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_data_timeout_ms + cfg.tcp_data_timeout_ms);
+    EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.data) == NULL);
+    sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.data + 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);
@@ -760,8 +716,8 @@ TEST(TCP_INIT_TO_OPENING, BY_S2C_ASMMETRIC)
     EXPECT_TRUE(stat->tcp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_data_timeout_ms) == NULL);
-    sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_data_timeout_ms + cfg.tcp_data_timeout_ms);
+    EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.data) == NULL);
+    sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.data + 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);
diff --git a/infra/session_manager/test/gtest_state_tcp_init_to_opening_to_active_to_closing_to_closed.cpp b/infra/session_manager/test/gtest_state_tcp_init_to_opening_to_active_to_closing_to_closed.cpp
index 4d569e7..61b0c70 100644
--- a/infra/session_manager/test/gtest_state_tcp_init_to_opening_to_active_to_closing_to_closed.cpp
+++ b/infra/session_manager/test/gtest_state_tcp_init_to_opening_to_active_to_closing_to_closed.cpp
@@ -5,53 +5,9 @@
 #include "packet_private.h"
 #include "packet_parser.h"
 #include "session_private.h"
-#include "session_manager.h"
+#include "default_config.h"
 #include "test_packets.h"
 
-struct session_manager_config cfg = {
-    // max session number
-    .max_tcp_session_num = 256,
-    .max_udp_session_num = 256,
-
-    // session overload
-    .tcp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
-    .udp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
-
-    // tcp timeout
-    .tcp_init_timeout_ms = 1,
-    .tcp_handshake_timeout_ms = 2,
-    .tcp_data_timeout_ms = 3,
-    .tcp_half_closed_timeout_ms = 4,
-    .tcp_time_wait_timeout_ms = 5,
-    .tcp_discard_timeout_ms = 6,
-    .tcp_unverified_rst_timeout_ms = 7,
-
-    // udp timeout
-    .udp_data_timeout_ms = 8,
-    .udp_discard_timeout_ms = 0,
-
-    // limit
-    .session_expire_polling_interval_ms = 0,
-    .session_expire_polling_limit = 1024,
-
-    // duplicate packet filter
-    .duplicated_packet_filter_enable = 1,
-    .duplicated_packet_filter_capacity = 1000,
-    .duplicated_packet_filter_timeout_ms = 10,
-    .duplicated_packet_filter_error_rate = 0.0001,
-
-    // evicted session filter
-    .evicted_session_filter_enable = 1,
-    .evicted_session_filter_capacity = 1000,
-    .evicted_session_filter_timeout_ms = 10,
-    .evicted_session_filter_error_rate = 0.0001,
-
-    // TCP Reassembly
-    .tcp_reassembly_enable = 1,
-    .tcp_reassembly_max_timeout_ms = 60000,
-    .tcp_reassembly_max_segments = 16,
-};
-
 static uint64_t session_id_generator(uint64_t now_ms __attribute__((unused)))
 {
     static uint64_t count = 0;
@@ -421,7 +377,7 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
     EXPECT_TRUE(stat->tcp_sess_closing == 1);
 
     // expire session
-    sess = session_manager_get_expired_session(mgr, 11 + cfg.tcp_time_wait_timeout_ms);
+    sess = session_manager_get_expired_session(mgr, 11 + 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);
diff --git a/infra/session_manager/test/gtest_state_tcp_opening_to_active.cpp b/infra/session_manager/test/gtest_state_tcp_opening_to_active.cpp
index 1e5f533..f12717e 100644
--- a/infra/session_manager/test/gtest_state_tcp_opening_to_active.cpp
+++ b/infra/session_manager/test/gtest_state_tcp_opening_to_active.cpp
@@ -5,53 +5,9 @@
 #include "packet_private.h"
 #include "packet_parser.h"
 #include "session_private.h"
-#include "session_manager.h"
+#include "default_config.h"
 #include "test_packets.h"
 
-struct session_manager_config cfg = {
-    // max session number
-    .max_tcp_session_num = 256,
-    .max_udp_session_num = 256,
-
-    // session overload
-    .tcp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
-    .udp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
-
-    // tcp timeout
-    .tcp_init_timeout_ms = 1,
-    .tcp_handshake_timeout_ms = 2,
-    .tcp_data_timeout_ms = 3,
-    .tcp_half_closed_timeout_ms = 4,
-    .tcp_time_wait_timeout_ms = 5,
-    .tcp_discard_timeout_ms = 6,
-    .tcp_unverified_rst_timeout_ms = 7,
-
-    // udp timeout
-    .udp_data_timeout_ms = 8,
-    .udp_discard_timeout_ms = 0,
-
-    // limit
-    .session_expire_polling_interval_ms = 0,
-    .session_expire_polling_limit = 1024,
-
-    // duplicate packet filter
-    .duplicated_packet_filter_enable = 1,
-    .duplicated_packet_filter_capacity = 1000,
-    .duplicated_packet_filter_timeout_ms = 10,
-    .duplicated_packet_filter_error_rate = 0.0001,
-
-    // evicted session filter
-    .evicted_session_filter_enable = 1,
-    .evicted_session_filter_capacity = 1000,
-    .evicted_session_filter_timeout_ms = 10,
-    .evicted_session_filter_error_rate = 0.0001,
-
-    // TCP Reassembly
-    .tcp_reassembly_enable = 1,
-    .tcp_reassembly_max_timeout_ms = 60000,
-    .tcp_reassembly_max_segments = 16,
-};
-
 static uint64_t session_id_generator(uint64_t now_ms __attribute__((unused)))
 {
     static uint64_t count = 0;
@@ -127,8 +83,8 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYN_C2S_DATA)
     EXPECT_TRUE(stat->tcp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_data_timeout_ms) == NULL);
-    sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_data_timeout_ms + cfg.tcp_data_timeout_ms);
+    EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.data) == NULL);
+    sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.data + 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);
@@ -217,8 +173,8 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYNACK_S2C_DATA)
     EXPECT_TRUE(stat->tcp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_data_timeout_ms) == NULL);
-    sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_data_timeout_ms + cfg.tcp_data_timeout_ms);
+    EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.data) == NULL);
+    sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.data + 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);
diff --git a/infra/session_manager/test/gtest_state_tcp_opening_to_closing.cpp b/infra/session_manager/test/gtest_state_tcp_opening_to_closing.cpp
index a0951f8..06f8cbb 100644
--- a/infra/session_manager/test/gtest_state_tcp_opening_to_closing.cpp
+++ b/infra/session_manager/test/gtest_state_tcp_opening_to_closing.cpp
@@ -5,53 +5,9 @@
 #include "packet_private.h"
 #include "packet_parser.h"
 #include "session_private.h"
-#include "session_manager.h"
+#include "default_config.h"
 #include "test_packets.h"
 
-struct session_manager_config cfg = {
-    // max session number
-    .max_tcp_session_num = 256,
-    .max_udp_session_num = 256,
-
-    // session overload
-    .tcp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
-    .udp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
-
-    // tcp timeout
-    .tcp_init_timeout_ms = 1,
-    .tcp_handshake_timeout_ms = 2,
-    .tcp_data_timeout_ms = 3,
-    .tcp_half_closed_timeout_ms = 4,
-    .tcp_time_wait_timeout_ms = 5,
-    .tcp_discard_timeout_ms = 6,
-    .tcp_unverified_rst_timeout_ms = 7,
-
-    // udp timeout
-    .udp_data_timeout_ms = 8,
-    .udp_discard_timeout_ms = 0,
-
-    // limit
-    .session_expire_polling_interval_ms = 0,
-    .session_expire_polling_limit = 1024,
-
-    // duplicate packet filter
-    .duplicated_packet_filter_enable = 1,
-    .duplicated_packet_filter_capacity = 1000,
-    .duplicated_packet_filter_timeout_ms = 10,
-    .duplicated_packet_filter_error_rate = 0.0001,
-
-    // evicted session filter
-    .evicted_session_filter_enable = 1,
-    .evicted_session_filter_capacity = 1000,
-    .evicted_session_filter_timeout_ms = 10,
-    .evicted_session_filter_error_rate = 0.0001,
-
-    // TCP Reassembly
-    .tcp_reassembly_enable = 1,
-    .tcp_reassembly_max_timeout_ms = 60000,
-    .tcp_reassembly_max_segments = 16,
-};
-
 static uint64_t session_id_generator(uint64_t now_ms __attribute__((unused)))
 {
     static uint64_t count = 0;
@@ -139,7 +95,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_FIN_FIN)
     EXPECT_TRUE(stat->tcp_sess_closing == 1);
 
     // expire session
-    sess = session_manager_get_expired_session(mgr, 3 + cfg.tcp_time_wait_timeout_ms);
+    sess = session_manager_get_expired_session(mgr, 3 + 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);
@@ -234,7 +190,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_RST)
     EXPECT_TRUE(stat->tcp_sess_closing == 1);
 
     // expire session
-    sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_unverified_rst_timeout_ms);
+    sess = session_manager_get_expired_session(mgr, 2 + 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);
@@ -329,7 +285,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_RST)
     EXPECT_TRUE(stat->tcp_sess_closing == 1);
 
     // expire session
-    sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_unverified_rst_timeout_ms);
+    sess = session_manager_get_expired_session(mgr, 2 + 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);
@@ -386,8 +342,8 @@ TEST(TCP_OPENING_TO_CLOSING, BY_INIT_TIMEOUT)
     EXPECT_TRUE(stat->tcp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + cfg.tcp_init_timeout_ms) == NULL);
-    sess = session_manager_get_expired_session(mgr, 1 + cfg.tcp_init_timeout_ms + cfg.tcp_data_timeout_ms);
+    EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + cfg.tcp_timeout_ms.init) == NULL);
+    sess = session_manager_get_expired_session(mgr, 1 + cfg.tcp_timeout_ms.init + 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);
@@ -476,8 +432,8 @@ TEST(TCP_OPENING_TO_CLOSING, BY_HANDSHAKE_TIMEOUT)
     EXPECT_TRUE(stat->tcp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_handshake_timeout_ms) == NULL);
-    sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_handshake_timeout_ms + cfg.tcp_data_timeout_ms);
+    EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.handshake) == NULL);
+    sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.handshake + 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);
@@ -578,8 +534,8 @@ TEST(TCP_OPENING_TO_CLOSING, BY_DATA_TIMEOUT)
     EXPECT_TRUE(stat->tcp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_get_expired_session(mgr, 3 + cfg.tcp_data_timeout_ms) == NULL);
-    sess = session_manager_get_expired_session(mgr, 3 + cfg.tcp_data_timeout_ms + cfg.tcp_data_timeout_ms);
+    EXPECT_TRUE(session_manager_get_expired_session(mgr, 3 + cfg.tcp_timeout_ms.data) == NULL);
+    sess = session_manager_get_expired_session(mgr, 3 + cfg.tcp_timeout_ms.data + 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);
@@ -668,7 +624,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_HALF_FIN)
     EXPECT_TRUE(stat->tcp_sess_closing == 1);
 
     // expire session
-    sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_half_closed_timeout_ms);
+    sess = session_manager_get_expired_session(mgr, 2 + 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);
@@ -757,7 +713,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_HALF_FIN)
     EXPECT_TRUE(stat->tcp_sess_closing == 1);
 
     // expire session
-    sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_half_closed_timeout_ms);
+    sess = session_manager_get_expired_session(mgr, 2 + 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);
diff --git a/infra/session_manager/test/gtest_state_udp_init_to_opening_to_active_to_closing.cpp b/infra/session_manager/test/gtest_state_udp_init_to_opening_to_active_to_closing.cpp
index 41ee468..0ecd250 100644
--- a/infra/session_manager/test/gtest_state_udp_init_to_opening_to_active_to_closing.cpp
+++ b/infra/session_manager/test/gtest_state_udp_init_to_opening_to_active_to_closing.cpp
@@ -5,53 +5,9 @@
 #include "packet_private.h"
 #include "packet_parser.h"
 #include "session_private.h"
-#include "session_manager.h"
+#include "default_config.h"
 #include "test_packets.h"
 
-struct session_manager_config cfg = {
-    // max session number
-    .max_tcp_session_num = 256,
-    .max_udp_session_num = 256,
-
-    // session overload
-    .tcp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
-    .udp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
-
-    // tcp timeout
-    .tcp_init_timeout_ms = 1,
-    .tcp_handshake_timeout_ms = 2,
-    .tcp_data_timeout_ms = 3,
-    .tcp_half_closed_timeout_ms = 4,
-    .tcp_time_wait_timeout_ms = 5,
-    .tcp_discard_timeout_ms = 6,
-    .tcp_unverified_rst_timeout_ms = 7,
-
-    // udp timeout
-    .udp_data_timeout_ms = 8,
-    .udp_discard_timeout_ms = 0,
-
-    // limit
-    .session_expire_polling_interval_ms = 0,
-    .session_expire_polling_limit = 1024,
-
-    // duplicate packet filter
-    .duplicated_packet_filter_enable = 1,
-    .duplicated_packet_filter_capacity = 1000,
-    .duplicated_packet_filter_timeout_ms = 10,
-    .duplicated_packet_filter_error_rate = 0.0001,
-
-    // evicted session filter
-    .evicted_session_filter_enable = 1,
-    .evicted_session_filter_capacity = 1000,
-    .evicted_session_filter_timeout_ms = 10,
-    .evicted_session_filter_error_rate = 0.0001,
-
-    // TCP Reassembly
-    .tcp_reassembly_enable = 1,
-    .tcp_reassembly_max_timeout_ms = 60000,
-    .tcp_reassembly_max_segments = 16,
-};
-
 static uint64_t session_id_generator(uint64_t now_ms __attribute__((unused)))
 {
     static uint64_t count = 0;
@@ -141,8 +97,8 @@ TEST(UDP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING, TEST)
     EXPECT_TRUE(stat->udp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.udp_data_timeout_ms) == NULL);             // active -> closing
-    sess = session_manager_get_expired_session(mgr, 2 + cfg.udp_data_timeout_ms + cfg.udp_data_timeout_ms); // closing -> closed
+    EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.udp_timeout_ms.data) == NULL);             // active -> closing
+    sess = session_manager_get_expired_session(mgr, 2 + cfg.udp_timeout_ms.data + 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);
diff --git a/infra/session_manager/test/gtest_state_udp_init_to_opening_to_closing.cpp b/infra/session_manager/test/gtest_state_udp_init_to_opening_to_closing.cpp
index 06dae39..6b513cd 100644
--- a/infra/session_manager/test/gtest_state_udp_init_to_opening_to_closing.cpp
+++ b/infra/session_manager/test/gtest_state_udp_init_to_opening_to_closing.cpp
@@ -5,53 +5,9 @@
 #include "packet_private.h"
 #include "packet_parser.h"
 #include "session_private.h"
-#include "session_manager.h"
+#include "default_config.h"
 #include "test_packets.h"
 
-struct session_manager_config cfg = {
-    // max session number
-    .max_tcp_session_num = 256,
-    .max_udp_session_num = 256,
-
-    // session overload
-    .tcp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
-    .udp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
-
-    // tcp timeout
-    .tcp_init_timeout_ms = 1,
-    .tcp_handshake_timeout_ms = 2,
-    .tcp_data_timeout_ms = 3,
-    .tcp_half_closed_timeout_ms = 4,
-    .tcp_time_wait_timeout_ms = 5,
-    .tcp_discard_timeout_ms = 6,
-    .tcp_unverified_rst_timeout_ms = 7,
-
-    // udp timeout
-    .udp_data_timeout_ms = 8,
-    .udp_discard_timeout_ms = 0,
-
-    // limit
-    .session_expire_polling_interval_ms = 0,
-    .session_expire_polling_limit = 1024,
-
-    // duplicate packet filter
-    .duplicated_packet_filter_enable = 1,
-    .duplicated_packet_filter_capacity = 1000,
-    .duplicated_packet_filter_timeout_ms = 10,
-    .duplicated_packet_filter_error_rate = 0.0001,
-
-    // evicted session filter
-    .evicted_session_filter_enable = 1,
-    .evicted_session_filter_capacity = 1000,
-    .evicted_session_filter_timeout_ms = 10,
-    .evicted_session_filter_error_rate = 0.0001,
-
-    // TCP Reassembly
-    .tcp_reassembly_enable = 1,
-    .tcp_reassembly_max_timeout_ms = 60000,
-    .tcp_reassembly_max_segments = 16,
-};
-
 static uint64_t session_id_generator(uint64_t now_ms __attribute__((unused)))
 {
     static uint64_t count = 0;
@@ -116,8 +72,8 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_C2S)
     EXPECT_TRUE(stat->udp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + cfg.udp_data_timeout_ms) == NULL);             // opening -> closing
-    sess = session_manager_get_expired_session(mgr, 1 + cfg.udp_data_timeout_ms + cfg.udp_data_timeout_ms); // closing -> closed
+    EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + cfg.udp_timeout_ms.data) == NULL);             // opening -> closing
+    sess = session_manager_get_expired_session(mgr, 1 + cfg.udp_timeout_ms.data + 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);
@@ -195,8 +151,8 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_S2C)
     EXPECT_TRUE(stat->udp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + cfg.udp_data_timeout_ms) == NULL);             // opening -> closing
-    sess = session_manager_get_expired_session(mgr, 1 + cfg.udp_data_timeout_ms + cfg.udp_data_timeout_ms); // closing -> closed
+    EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + cfg.udp_timeout_ms.data) == NULL);             // opening -> closing
+    sess = session_manager_get_expired_session(mgr, 1 + cfg.udp_timeout_ms.data + cfg.udp_timeout_ms.data); // closing -> closed
     EXPECT_TRUE(sess);
 
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
diff --git a/infra/session_manager/test/gtest_timeout_tcp_data.cpp b/infra/session_manager/test/gtest_timeout_tcp_data.cpp
index 0582b7b..c337bc1 100644
--- a/infra/session_manager/test/gtest_timeout_tcp_data.cpp
+++ b/infra/session_manager/test/gtest_timeout_tcp_data.cpp
@@ -4,53 +4,9 @@
 #include "packet_private.h"
 #include "packet_parser.h"
 #include "session_private.h"
-#include "session_manager.h"
+#include "default_config.h"
 #include "test_packets.h"
 
-struct session_manager_config cfg = {
-    // max session number
-    .max_tcp_session_num = 256,
-    .max_udp_session_num = 256,
-
-    // session overload
-    .tcp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
-    .udp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
-
-    // tcp timeout
-    .tcp_init_timeout_ms = 1,
-    .tcp_handshake_timeout_ms = 2,
-    .tcp_data_timeout_ms = 3,
-    .tcp_half_closed_timeout_ms = 4,
-    .tcp_time_wait_timeout_ms = 5,
-    .tcp_discard_timeout_ms = 6,
-    .tcp_unverified_rst_timeout_ms = 7,
-
-    // udp timeout
-    .udp_data_timeout_ms = 8,
-    .udp_discard_timeout_ms = 0,
-
-    // limit
-    .session_expire_polling_interval_ms = 0,
-    .session_expire_polling_limit = 1024,
-
-    // duplicate packet filter
-    .duplicated_packet_filter_enable = 1,
-    .duplicated_packet_filter_capacity = 1000,
-    .duplicated_packet_filter_timeout_ms = 10,
-    .duplicated_packet_filter_error_rate = 0.0001,
-
-    // evicted session filter
-    .evicted_session_filter_enable = 1,
-    .evicted_session_filter_capacity = 1000,
-    .evicted_session_filter_timeout_ms = 10,
-    .evicted_session_filter_error_rate = 0.0001,
-
-    // TCP Reassembly
-    .tcp_reassembly_enable = 1,
-    .tcp_reassembly_max_timeout_ms = 60000,
-    .tcp_reassembly_max_segments = 16,
-};
-
 static uint64_t session_id_generator(uint64_t now_ms __attribute__((unused)))
 {
     static uint64_t count = 0;
@@ -93,8 +49,8 @@ TEST(TIMEOUT, TCP_TIMEOUT_DATA)
     EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_data_timeout_ms) == NULL);
-    sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_data_timeout_ms + cfg.tcp_data_timeout_ms);
+    EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.data) == NULL);
+    sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.data + 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);
diff --git a/infra/session_manager/test/gtest_timeout_tcp_handshake.cpp b/infra/session_manager/test/gtest_timeout_tcp_handshake.cpp
index 4ea2e62..74c3edd 100644
--- a/infra/session_manager/test/gtest_timeout_tcp_handshake.cpp
+++ b/infra/session_manager/test/gtest_timeout_tcp_handshake.cpp
@@ -4,53 +4,9 @@
 #include "packet_private.h"
 #include "packet_parser.h"
 #include "session_private.h"
-#include "session_manager.h"
+#include "default_config.h"
 #include "test_packets.h"
 
-struct session_manager_config cfg = {
-    // max session number
-    .max_tcp_session_num = 256,
-    .max_udp_session_num = 256,
-
-    // session overload
-    .tcp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
-    .udp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
-
-    // tcp timeout
-    .tcp_init_timeout_ms = 1,
-    .tcp_handshake_timeout_ms = 2,
-    .tcp_data_timeout_ms = 3,
-    .tcp_half_closed_timeout_ms = 4,
-    .tcp_time_wait_timeout_ms = 5,
-    .tcp_discard_timeout_ms = 6,
-    .tcp_unverified_rst_timeout_ms = 7,
-
-    // udp timeout
-    .udp_data_timeout_ms = 8,
-    .udp_discard_timeout_ms = 0,
-
-    // limit
-    .session_expire_polling_interval_ms = 0,
-    .session_expire_polling_limit = 1024,
-
-    // duplicate packet filter
-    .duplicated_packet_filter_enable = 1,
-    .duplicated_packet_filter_capacity = 1000,
-    .duplicated_packet_filter_timeout_ms = 10,
-    .duplicated_packet_filter_error_rate = 0.0001,
-
-    // evicted session filter
-    .evicted_session_filter_enable = 1,
-    .evicted_session_filter_capacity = 1000,
-    .evicted_session_filter_timeout_ms = 10,
-    .evicted_session_filter_error_rate = 0.0001,
-
-    // TCP Reassembly
-    .tcp_reassembly_enable = 1,
-    .tcp_reassembly_max_timeout_ms = 60000,
-    .tcp_reassembly_max_segments = 16,
-};
-
 static uint64_t session_id_generator(uint64_t now_ms __attribute__((unused)))
 {
     static uint64_t count = 0;
@@ -81,8 +37,8 @@ TEST(TIMEOUT, TCP_TIMEOUT_HANDSHAKE)
     EXPECT_TRUE(sess);
 
     // expire session
-    EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + cfg.tcp_handshake_timeout_ms) == NULL);
-    sess = session_manager_get_expired_session(mgr, 1 + cfg.tcp_handshake_timeout_ms + cfg.tcp_data_timeout_ms);
+    EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + cfg.tcp_timeout_ms.handshake) == NULL);
+    sess = session_manager_get_expired_session(mgr, 1 + cfg.tcp_timeout_ms.handshake + 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);
diff --git a/infra/session_manager/test/gtest_timeout_tcp_init.cpp b/infra/session_manager/test/gtest_timeout_tcp_init.cpp
index f0136a2..c5e83e2 100644
--- a/infra/session_manager/test/gtest_timeout_tcp_init.cpp
+++ b/infra/session_manager/test/gtest_timeout_tcp_init.cpp
@@ -4,53 +4,9 @@
 #include "packet_private.h"
 #include "packet_parser.h"
 #include "session_private.h"
-#include "session_manager.h"
+#include "default_config.h"
 #include "test_packets.h"
 
-struct session_manager_config cfg = {
-    // max session number
-    .max_tcp_session_num = 256,
-    .max_udp_session_num = 256,
-
-    // session overload
-    .tcp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
-    .udp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
-
-    // tcp timeout
-    .tcp_init_timeout_ms = 1,
-    .tcp_handshake_timeout_ms = 2,
-    .tcp_data_timeout_ms = 3,
-    .tcp_half_closed_timeout_ms = 4,
-    .tcp_time_wait_timeout_ms = 5,
-    .tcp_discard_timeout_ms = 6,
-    .tcp_unverified_rst_timeout_ms = 7,
-
-    // udp timeout
-    .udp_data_timeout_ms = 8,
-    .udp_discard_timeout_ms = 0,
-
-    // limit
-    .session_expire_polling_interval_ms = 0,
-    .session_expire_polling_limit = 1024,
-
-    // duplicate packet filter
-    .duplicated_packet_filter_enable = 1,
-    .duplicated_packet_filter_capacity = 1000,
-    .duplicated_packet_filter_timeout_ms = 10,
-    .duplicated_packet_filter_error_rate = 0.0001,
-
-    // evicted session filter
-    .evicted_session_filter_enable = 1,
-    .evicted_session_filter_capacity = 1000,
-    .evicted_session_filter_timeout_ms = 10,
-    .evicted_session_filter_error_rate = 0.0001,
-
-    // TCP Reassembly
-    .tcp_reassembly_enable = 1,
-    .tcp_reassembly_max_timeout_ms = 60000,
-    .tcp_reassembly_max_segments = 16,
-};
-
 static uint64_t session_id_generator(uint64_t now_ms __attribute__((unused)))
 {
     static uint64_t count = 0;
@@ -81,8 +37,8 @@ TEST(TIMEOUT, TCP_TIMEOUT_INIT)
     EXPECT_TRUE(sess);
 
     // expire session
-    EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + cfg.tcp_init_timeout_ms) == NULL);             // opening -> closing
-    sess = session_manager_get_expired_session(mgr, 1 + cfg.tcp_init_timeout_ms + cfg.tcp_data_timeout_ms); // closing -> closed
+    EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + cfg.tcp_timeout_ms.init) == NULL);             // opening -> closing
+    sess = session_manager_get_expired_session(mgr, 1 + cfg.tcp_timeout_ms.init + 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);
diff --git a/infra/session_manager/test/gtest_timeout_udp_data.cpp b/infra/session_manager/test/gtest_timeout_udp_data.cpp
index 94c8e13..78645a1 100644
--- a/infra/session_manager/test/gtest_timeout_udp_data.cpp
+++ b/infra/session_manager/test/gtest_timeout_udp_data.cpp
@@ -4,53 +4,9 @@
 #include "packet_private.h"
 #include "packet_parser.h"
 #include "session_private.h"
-#include "session_manager.h"
+#include "default_config.h"
 #include "test_packets.h"
 
-struct session_manager_config cfg = {
-    // max session number
-    .max_tcp_session_num = 256,
-    .max_udp_session_num = 256,
-
-    // session overload
-    .tcp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
-    .udp_overload_evict_old_sess = 1, // 1: evict old session, 0: bypass new session
-
-    // tcp timeout
-    .tcp_init_timeout_ms = 1,
-    .tcp_handshake_timeout_ms = 2,
-    .tcp_data_timeout_ms = 3,
-    .tcp_half_closed_timeout_ms = 4,
-    .tcp_time_wait_timeout_ms = 5,
-    .tcp_discard_timeout_ms = 6,
-    .tcp_unverified_rst_timeout_ms = 7,
-
-    // udp timeout
-    .udp_data_timeout_ms = 8,
-    .udp_discard_timeout_ms = 0,
-
-    // limit
-    .session_expire_polling_interval_ms = 0,
-    .session_expire_polling_limit = 1024,
-
-    // duplicate packet filter
-    .duplicated_packet_filter_enable = 1,
-    .duplicated_packet_filter_capacity = 1000,
-    .duplicated_packet_filter_timeout_ms = 10,
-    .duplicated_packet_filter_error_rate = 0.0001,
-
-    // evicted session filter
-    .evicted_session_filter_enable = 1,
-    .evicted_session_filter_capacity = 1000,
-    .evicted_session_filter_timeout_ms = 10,
-    .evicted_session_filter_error_rate = 0.0001,
-
-    // TCP Reassembly
-    .tcp_reassembly_enable = 1,
-    .tcp_reassembly_max_timeout_ms = 60000,
-    .tcp_reassembly_max_segments = 16,
-};
-
 static uint64_t session_id_generator(uint64_t now_ms __attribute__((unused)))
 {
     static uint64_t count = 0;
@@ -81,8 +37,8 @@ TEST(TIMEOUT, UDP_TIMEOUT_DATA1)
     EXPECT_TRUE(sess);
 
     // expire session
-    EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + cfg.udp_data_timeout_ms) == NULL);             // opening -> closing
-    sess = session_manager_get_expired_session(mgr, 1 + cfg.udp_data_timeout_ms + cfg.udp_data_timeout_ms); // closing -> closed
+    EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + cfg.udp_timeout_ms.data) == NULL);             // opening -> closing
+    sess = session_manager_get_expired_session(mgr, 1 + cfg.udp_timeout_ms.data + 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);
@@ -130,8 +86,8 @@ TEST(TIMEOUT, UDP_TIMEOUT_DATA2)
     EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.udp_data_timeout_ms) == NULL);             // active -> closing
-    sess = session_manager_get_expired_session(mgr, 2 + cfg.udp_data_timeout_ms + cfg.udp_data_timeout_ms); // closing -> closed
+    EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.udp_timeout_ms.data) == NULL);             // active -> closing
+    sess = session_manager_get_expired_session(mgr, 2 + cfg.udp_timeout_ms.data + 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);