update session finite state machine & add tcp init -> opening test case

deps/dablooms/test/gtest_dablooms.cpp

@@ -25,7 +25,7 @@ struct config
     .enable = 1,
     .capacity = 1000000,
     .error_rate = 0.00001,
-    .expiry_time = 10,
+    .expiry_time = 3,
 };
 
 struct packet_idetify idetify = {
@@ -47,7 +47,7 @@ TEST(DABLOOMS, TEST)
     EXPECT_TRUE(expiry_dablooms_search(handle, (const char *)&idetify, sizeof(idetify), time(NULL)) != 1); // no exist
     EXPECT_TRUE(expiry_dablooms_add(handle, (const char *)&idetify, sizeof(idetify), time(NULL)) == 0);    // add
 
-    for (int i = 0; i < 15; i++)
+    for (int i = 0; i < 5; i++)
     {
         if (i < config.expiry_time)
         {

src/dupkt_filter/test/gtest_dupkt_filter.cpp

@@ -75,7 +75,7 @@ struct config
     .enable = 1,
     .capacity = 1000000,
     .error_rate = 0.00001,
-    .timeout_s = 10,
+    .timeout_s = 3,
 };
 
 TEST(DUPKT_FILTER, TEST)
@@ -91,7 +91,7 @@ TEST(DUPKT_FILTER, TEST)
     EXPECT_TRUE(dupkt_filter_lookup(filter, &pkt) == 0); // no found
     dupkt_filter_add(filter, &pkt);                      // add
 
-    for (int i = 0; i < 12; i++)
+    for (int i = 0; i < 5; i++)
     {
         timestamp_update();
 

src/eviction_filter/test/gtest_eviction_filter.cpp

@@ -124,7 +124,7 @@ struct config
     .enable = 1,
     .capacity = 1000000,
     .error_rate = 0.00001,
-    .timeout_s = 10,
+    .timeout_s = 3,
 };
 
 TEST(EVICTION_FILTER, TEST)
@@ -143,7 +143,7 @@ TEST(EVICTION_FILTER, TEST)
     EXPECT_TRUE(eviction_filter_lookup(filter, &s2c_pkt) == 0); // no found
     eviction_filter_add(filter, &c2s_pkt);                      // add
 
-    for (int i = 0; i < 12; i++)
+    for (int i = 0; i < 5; i++)
     {
         timestamp_update();
 

src/packet/ipv4_helpers.h

@@ -124,6 +124,11 @@ static inline const uint8_t *ipv4_hdr_get_opt_ptr(const struct ip *hdr)
     return (const uint8_t *)hdr + sizeof(struct ip);
 }
 
+static inline void ipv4_hdr_set_ipid(struct ip *hdr, uint16_t ipid)
+{
+    hdr->ip_id = htons(ipid);
+}
+
 #ifdef __cpluscplus
 }
 #endif

src/packet/packet_helpers.h

@@ -16,6 +16,7 @@ extern "C"
 
 struct metadata
 {
+    char data[64];
     // TODO
 };
 
@@ -120,6 +121,7 @@ static inline struct packet *packet_dup(const struct packet *pkt)
             pkt_dup->layers[i].pld_ptr = pkt_dup->data_ptr + pkt->layers[i].hdr_offset + pkt->layers[i].hdr_len;
         }
     }
+    packet_set0_metadata(pkt_dup, metadata_dup(packet_get0_metadata(pkt)));
 
     return pkt_dup;
 }
@@ -128,6 +130,9 @@ static inline void packet_free(struct packet *pkt)
 {
     if (pkt)
     {
+        metadata_free((struct metadata *)packet_get0_metadata(pkt));
+        packet_set0_metadata(pkt, NULL);
+
         if (pkt->data_ptr)
         {
             free((char *)pkt->data_ptr);

src/session/session.cpp

@@ -1,6 +1,7 @@
 #include <assert.h>
 
 #include "session_private.h"
+#include "packet_helpers.h"
 
 #define EX_KEY_MAX_LEN 64
 
@@ -18,12 +19,6 @@ struct ex_manager
 };
 
 static struct ex_manager g_ex_manager = {0};
-uint8_t tcp_builtin_ex = 0; // built-in ex_data index
-uint8_t udp_builtin_ex = 0; // built-in ex_data index
-uint8_t c2s_1st_md_ex = 0;  // built-in ex_data index
-uint8_t s2c_1st_md_ex = 0;  // built-in ex_data index
-uint8_t c2s_1st_pkt_ex = 0; // built-in ex_data index
-uint8_t s2c_1st_pkt_ex = 0; // built-in ex_data index
 
 /******************************************************************************
  * session
@@ -46,22 +41,22 @@ uint64_t session_get_id(const struct session *sess)
 }
 
 // session tuple6
-void session_set_tuple6(struct session *sess, const struct tuple6 *tuple)
+void session_set_key(struct session *sess, const struct tuple6 *tuple)
 {
     memcpy(&sess->tuple, tuple, sizeof(struct tuple6));
 }
 
-const struct tuple6 *session_get0_tuple6(const struct session *sess)
+const struct tuple6 *session_get0_key(const struct session *sess)
 {
     return &sess->tuple;
 }
 
-void session_set_tuple6_dir(struct session *sess, enum session_dir dir)
+void session_set_key_dir(struct session *sess, enum session_dir dir)
 {
     sess->tuple_dir = dir;
 }
 
-enum session_dir session_get_tuple6_dir(const struct session *sess)
+enum session_dir session_get_key_dir(const struct session *sess)
 {
     return sess->tuple_dir;
 }
@@ -164,18 +159,50 @@ uint64_t session_get_last_time(const struct session *sess)
     return sess->last_time;
 }
 
+// session tcp state
+void session_set_tcp_state(struct session *sess, enum tcp_state state)
+{
+    sess->tcp_state = state;
+}
+
+enum tcp_state session_get_tcp_state(const struct session *sess)
+{
+    return sess->tcp_state;
+}
+
+// session udp state
+void session_set_udp_state(struct session *sess, enum udp_state state)
+{
+    sess->udp_state = state;
+}
+
+enum udp_state session_get_udp_state(const struct session *sess)
+{
+    return sess->udp_state;
+}
+
 /******************************************************************************
  * session packet
  ******************************************************************************/
 
+void session_set_c2s_1st_pkt(struct session *sess, const struct packet *pkt)
+{
+    sess->c2s_1st_pkt = packet_dup(pkt);
+}
+
+void session_set_s2c_1st_pkt(struct session *sess, const struct packet *pkt)
+{
+    sess->s2c_1st_pkt = packet_dup(pkt);
+}
+
 const struct packet *session_get0_c2s_1st_pkt(const struct session *sess)
 {
-    return (const struct packet *)session_get0_ex_data(sess, c2s_1st_pkt_ex);
+    return sess->c2s_1st_pkt;
 }
 
 const struct packet *session_get0_s2c_1st_pkt(const struct session *sess)
 {
-    return (const struct packet *)session_get0_ex_data(sess, s2c_1st_pkt_ex);
+    return sess->s2c_1st_pkt;
 }
 
 const struct packet *session_get0_1st_pkt(const struct session *sess)
@@ -304,6 +331,29 @@ void session_free_ex_data(struct session *sess, uint8_t idx)
     sess->ex_data[idx] = NULL;
 }
 
+void session_free(struct session *sess)
+{
+    if (sess)
+    {
+        for (uint8_t i = 0; i < g_ex_manager.count; i++)
+        {
+            session_free_ex_data(sess, i);
+        }
+
+        if (sess->c2s_1st_pkt)
+        {
+            packet_free(sess->c2s_1st_pkt);
+            sess->c2s_1st_pkt = NULL;
+        }
+
+        if (sess->s2c_1st_pkt)
+        {
+            packet_free(sess->s2c_1st_pkt);
+            sess->s2c_1st_pkt = NULL;
+        }
+    }
+}
+
 /******************************************************************************
  * session expire
  ******************************************************************************/
@@ -342,69 +392,79 @@ void session_run_expirecb(struct session *sess)
  * session dump
  ******************************************************************************/
 
-static void tcp_ex_data_tostring(uint64_t ex_data, char *buffer, size_t buffer_len)
+static void tcp_state_tostring(enum tcp_state state, char *buffer, size_t buffer_len)
 {
-    if (ex_data == 0)
+    if (state == 0)
     {
         return;
     }
 
     int nused = 0;
-    if (ex_data & TCP_SYN_RECVED)
+    if (state & TCP_SYN_RECVED)
     {
         nused += snprintf(buffer + nused, buffer_len - nused, "TCP_SYN_RECVED ");
     }
 
-    if (ex_data & TCP_SYNACK_RECVED)
+    if (state & TCP_SYNACK_RECVED)
     {
         nused += snprintf(buffer + nused, buffer_len - nused, "TCP_SYNACK_RECVED ");
     }
 
-    if (ex_data & TCP_C2S_DATA_RECVED)
+    if (state & TCP_C2S_ACK_RECVED)
+    {
+        nused += snprintf(buffer + nused, buffer_len - nused, "TCP_C2S_ACK_RECVED ");
+    }
+
+    if (state & TCP_S2C_ACK_RECVED)
+    {
+        nused += snprintf(buffer + nused, buffer_len - nused, "TCP_S2C_ACK_RECVED ");
+    }
+
+    if (state & TCP_C2S_DATA_RECVED)
     {
         nused += snprintf(buffer + nused, buffer_len - nused, "TCP_C2S_DATA_RECVED ");
     }
 
-    if (ex_data & TCP_S2C_DATA_RECVED)
+    if (state & TCP_S2C_DATA_RECVED)
     {
         nused += snprintf(buffer + nused, buffer_len - nused, "TCP_S2C_DATA_RECVED ");
     }
 
-    if (ex_data & TCP_C2S_FIN_RECVED)
+    if (state & TCP_C2S_FIN_RECVED)
     {
         nused += snprintf(buffer + nused, buffer_len - nused, "TCP_C2S_FIN_RECVED ");
     }
 
-    if (ex_data & TCP_S2C_FIN_RECVED)
+    if (state & TCP_S2C_FIN_RECVED)
     {
         nused += snprintf(buffer + nused, buffer_len - nused, "TCP_S2C_FIN_RECVED ");
     }
 
-    if (ex_data & TCP_C2S_RST_RECVED)
+    if (state & TCP_C2S_RST_RECVED)
     {
         nused += snprintf(buffer + nused, buffer_len - nused, "TCP_C2S_RST_RECVED ");
     }
 
-    if (ex_data & TCP_S2C_RST_RECVED)
+    if (state & TCP_S2C_RST_RECVED)
     {
         nused += snprintf(buffer + nused, buffer_len - nused, "TCP_S2C_RST_RECVED ");
     }
 }
 
-static void udp_ex_data_tostring(uint64_t ex_data, char *buffer, size_t buffer_len)
+static void udp_state_tostring(enum udp_state state, char *buffer, size_t buffer_len)
 {
-    if (ex_data == 0)
+    if (state == 0)
     {
         return;
     }
 
     int nused = 0;
-    if (ex_data & UDP_C2S_RECVED)
+    if (state & UDP_C2S_RECVED)
     {
         snprintf(buffer + nused, buffer_len - nused, "UDP_C2S_RECVED ");
     }
 
-    if (ex_data & UDP_S2C_RECVED)
+    if (state & UDP_S2C_RECVED)
     {
         snprintf(buffer + nused, buffer_len - nused, "UDP_S2C_RECVED ");
     }
@@ -453,9 +513,9 @@ const char *session_type_tostring(enum session_type type)
     switch (type)
     {
     case SESSION_TYPE_TCP:
-        return "tcp";
+        return "TCP";
     case SESSION_TYPE_UDP:
-        return "udp";
+        return "UDP";
     default:
         return "unknown";
     }
@@ -466,9 +526,22 @@ const char *session_dir_tostring(enum session_dir dir)
     switch (dir)
     {
     case SESSION_DIR_C2S:
-        return "c2s";
+        return "C2S";
     case SESSION_DIR_S2C:
-        return "s2c";
+        return "S2C";
+    default:
+        return "unknown";
+    }
+}
+
+const char *dup_traffic_flag_tostring(enum dup_traffic_flag flag)
+{
+    switch (flag)
+    {
+    case DUP_TRAFFIC_YES:
+        return "YES";
+    case DUP_TRAFFIC_NO:
+        return "NO";
     default:
         return "unknown";
     }
@@ -477,13 +550,14 @@ const char *session_dir_tostring(enum session_dir dir)
 void session_dump(struct session *sess)
 {
     char buffer[128] = {0};
-    tuple6_tostring(session_get0_tuple6(sess), buffer, sizeof(buffer));
+    tuple6_tostring(session_get0_key(sess), buffer, sizeof(buffer));
 
     printf("session id                 : %" PRIu64 "\n", session_get_id(sess));
-    printf("session tuple6 key         : %s\n", buffer);
+    printf("session key                : %s\n", buffer);
-    printf("session tuple6 dir         : %s\n", session_dir_tostring(session_get_tuple6_dir(sess)));
+    printf("session key dir            : %s\n", session_dir_tostring(session_get_key_dir(sess)));
     printf("session state              : %s\n", session_state_tostring(session_get_state(sess)));
     printf("session type               : %s\n", session_type_tostring(session_get_type(sess)));
+    printf("session dup traffic flag   : %s\n", dup_traffic_flag_tostring(session_get_dup_traffic_flag(sess)));
     printf("session closing reasion    : %s\n", session_closing_reasion_tostring(session_get_closing_reasion(sess)));
     printf("session c2s packets        : %" PRIu64 "\n", session_get_c2s_packets(sess));
     printf("session c2s bytes          : %" PRIu64 "\n", session_get_c2s_bytes(sess));
@@ -491,26 +565,23 @@ void session_dump(struct session *sess)
     printf("session s2c bytes          : %" PRIu64 "\n", session_get_s2c_bytes(sess));
     printf("session create time        : %" PRIu64 "\n", session_get_create_time(sess));
     printf("session last time          : %" PRIu64 "\n", session_get_last_time(sess));
+    if (session_get_type(sess) == SESSION_TYPE_TCP)
+    {
+        memset(buffer, 0, sizeof(buffer));
+        tcp_state_tostring(session_get_tcp_state(sess), buffer, sizeof(buffer));
+        printf("session tcp state          : %s\n", buffer);
+    }
+    else if (session_get_type(sess) == SESSION_TYPE_UDP)
+    {
+        memset(buffer, 0, sizeof(buffer));
+        udp_state_tostring(session_get_udp_state(sess), buffer, sizeof(buffer));
+        printf("session udp state          : %s\n", buffer);
+    }
     printf("session current packet ptr : %p\n", (void *)session_get0_cur_pkt(sess));
     printf("session current packet dir : %s\n", session_dir_tostring(session_get_cur_dir(sess)));
     printf("session ex data: \n");
     for (uint8_t i = 0; i < g_ex_manager.count; i++)
     {
-        if (i == tcp_builtin_ex)
+        printf("    ex_idx: %d, ex_key: %s, ex_data: %p\n", i, g_ex_manager.schemas[i].key, sess->ex_data[i]);
-        {
-            memset(buffer, 0, sizeof(buffer));
-            tcp_ex_data_tostring((uint64_t)sess->ex_data[i], buffer, sizeof(buffer));
-            printf("    ex_idx: %d, ex_key: %s, ex_val: %s\n", i, g_ex_manager.schemas[i].key, buffer);
-        }
-        else if (i == udp_builtin_ex)
-        {
-            memset(buffer, 0, sizeof(buffer));
-            udp_ex_data_tostring((uint64_t)sess->ex_data[i], buffer, sizeof(buffer));
-            printf("    ex_idx: %d, ex_key: %s, ex_val: %s\n", i, g_ex_manager.schemas[i].key, buffer);
-        }
-        else
-        {
-            printf("    ex_idx: %d, ex_key: %s, ex_val: %p\n", i, g_ex_manager.schemas[i].key, sess->ex_data[i]);
-        }
     }
 }

src/session/session.h

@@ -11,6 +11,30 @@ extern "C"
 #include "tuple.h"
 #include "packet.h"
 
+enum tcp_state
+{
+    // HANDSHAKE
+    TCP_SYN_RECVED = 1 << 0,
+    TCP_SYNACK_RECVED = 1 << 1,
+    TCP_C2S_ACK_RECVED = 1 << 2,
+    TCP_S2C_ACK_RECVED = 1 << 3,
+    // ESTABLISHED
+    TCP_C2S_DATA_RECVED = 1 << 4,
+    TCP_S2C_DATA_RECVED = 1 << 5,
+    // FIN
+    TCP_C2S_FIN_RECVED = 1 << 6,
+    TCP_S2C_FIN_RECVED = 1 << 7,
+    // RST
+    TCP_C2S_RST_RECVED = 1 << 8,
+    TCP_S2C_RST_RECVED = 1 << 9,
+};
+
+enum udp_state
+{
+    UDP_C2S_RECVED = 1 << 0,
+    UDP_S2C_RECVED = 1 << 1,
+};
+
 enum session_state
 {
     SESSION_STATE_OPENING = 0x1,
@@ -61,10 +85,10 @@ void session_set_id(struct session *sess, uint64_t id);
 uint64_t session_get_id(const struct session *sess);
 
 // session key
-void session_set_tuple6(struct session *sess, const struct tuple6 *tuple);
+void session_set_key(struct session *sess, const struct tuple6 *tuple);
-const struct tuple6 *session_get0_tuple6(const struct session *sess);
+const struct tuple6 *session_get0_key(const struct session *sess);
-void session_set_tuple6_dir(struct session *sess, enum session_dir dir);
+void session_set_key_dir(struct session *sess, enum session_dir dir);
-enum session_dir session_get_tuple6_dir(const struct session *sess);
+enum session_dir session_get_key_dir(const struct session *sess);
 
 // session state
 void session_set_state(struct session *sess, enum session_state state);
@@ -96,10 +120,20 @@ void session_set_last_time(struct session *sess, uint64_t timestamp);
 uint64_t session_get_create_time(const struct session *sess);
 uint64_t session_get_last_time(const struct session *sess);
 
+// session tcp state
+void session_set_tcp_state(struct session *sess, enum tcp_state state);
+enum tcp_state session_get_tcp_state(const struct session *sess);
+
+// session udp state
+void session_set_udp_state(struct session *sess, enum udp_state state);
+enum udp_state session_get_udp_state(const struct session *sess);
+
 /******************************************************************************
  * session packet
  ******************************************************************************/
 
+void session_set_c2s_1st_pkt(struct session *sess, const struct packet *pkt);
+void session_set_s2c_1st_pkt(struct session *sess, const struct packet *pkt);
 const struct packet *session_get0_c2s_1st_pkt(const struct session *sess);
 const struct packet *session_get0_s2c_1st_pkt(const struct session *sess);
 const struct packet *session_get0_1st_pkt(const struct session *sess);
@@ -141,6 +175,7 @@ void *session_get0_ex_data(const struct session *sess, uint8_t idx);
  * if user want to free ex_data, should use session_free_ex_data.
  */
 void session_free_ex_data(struct session *sess, uint8_t idx);
+void session_free(struct session *sess);
 
 /******************************************************************************
  * session expire

src/session/session_manager.h

@@ -28,6 +28,7 @@ struct session_manager_config
     uint64_t tcp_timeout_handshake;   // seconds, Range: 1-60
     uint64_t tcp_timeout_data;        // seconds, Range: 1-15,999,999
     uint64_t tcp_timeout_half_closed; // seconds, Range: 1-604,800
+    uint64_t tcp_timeout_time_wait;   // seconds, Range: 1-600
     uint64_t tcp_timeout_discard;     // seconds, Range: 1-15,999,999
 
     // UDP timeout
@@ -68,6 +69,8 @@ struct session *session_manager_get_evicted_session(struct session_manager *mgr)
 uint64_t session_manager_get_expire_interval(struct session_manager *mgr);
 uint64_t session_manager_get_session_number(struct session_manager *mgr, enum session_type type, enum session_state state);
 
+void session_manager_print_status(struct session_manager *mgr);
+
 #ifdef __cpluscplus
 }
 #endif

src/session/session_private.h

@@ -16,28 +16,6 @@ extern "C"
 
 #define EX_DATA_MAX_COUNT 128
 
-enum tcp_ex_data
-{
-    // HANDSHAKE
-    TCP_SYN_RECVED = 1 << 0,
-    TCP_SYNACK_RECVED = 1 << 1,
-    // ESTABLISHED
-    TCP_C2S_DATA_RECVED = 1 << 2,
-    TCP_S2C_DATA_RECVED = 1 << 3,
-    // FIN
-    TCP_C2S_FIN_RECVED = 1 << 4,
-    TCP_S2C_FIN_RECVED = 1 << 5,
-    // RST
-    TCP_C2S_RST_RECVED = 1 << 6,
-    TCP_S2C_RST_RECVED = 1 << 7,
-};
-
-enum udp_ex_data
-{
-    UDP_C2S_RECVED = 1 << 0,
-    UDP_S2C_RECVED = 1 << 1,
-};
-
 struct session
 {
     // session id
@@ -65,6 +43,14 @@ struct session
     uint64_t create_time;
     uint64_t last_time;
 
+    // session l4 state
+    enum tcp_state tcp_state;
+    enum udp_state udp_state;
+
+    // session packet
+    struct packet *c2s_1st_pkt;
+    struct packet *s2c_1st_pkt;
+
     /******************************
      * Session Current Packet
      ******************************/
@@ -117,13 +103,6 @@ struct session
     struct session *next_ready_ptr;
 };
 
-extern uint8_t tcp_builtin_ex;
-extern uint8_t udp_builtin_ex;
-extern uint8_t c2s_1st_md_ex;
-extern uint8_t s2c_1st_md_ex;
-extern uint8_t c2s_1st_pkt_ex;
-extern uint8_t s2c_1st_pkt_ex;
-
 #ifdef __cpluscplus
 }
 #endif

src/session/session_table.cpp

@@ -203,6 +203,13 @@ struct session *session_table_find_session(struct session_table *table, const st
 
     struct session *sess = NULL;
     HASH_FIND(hh, table->root, tuple, sizeof(struct tuple6), sess);
+    if (sess == NULL)
+    {
+        struct tuple6 out;
+        memset(&out, 0, sizeof(struct tuple6));
+        tuple6_reverse(tuple, &out);
+        HASH_FIND(hh, table->root, &out, sizeof(struct tuple6), sess);
+    }
 
     if (sess)
     {

src/session/test/CMakeLists.txt

@@ -17,8 +17,8 @@ target_link_libraries(gtest_session_timer session_manager gtest)
 add_executable(gtest_session_queue gtest_session_queue.cpp)
 target_link_libraries(gtest_session_queue session_manager gtest)
 
-add_executable(gtest_session_manager gtest_session_manager.cpp)
+add_executable(gtest_tcp_init_to_opening gtest_tcp_init_to_opening.cpp)
-target_link_libraries(gtest_session_manager session_manager gtest)
+target_link_libraries(gtest_tcp_init_to_opening session_manager gtest)
 
 include(GoogleTest)
 gtest_discover_tests(gtest_session)
@@ -26,4 +26,4 @@ gtest_discover_tests(gtest_session_pool)
 gtest_discover_tests(gtest_session_table)
 gtest_discover_tests(gtest_session_timer)
 gtest_discover_tests(gtest_session_queue)
-gtest_discover_tests(gtest_session_manager)
+gtest_discover_tests(gtest_tcp_init_to_opening)

src/session/test/gtest_session_table.cpp

@@ -77,17 +77,17 @@ TEST(SESSION_TABLE, OP_SESSION)
     sess1 = session_pool_alloc(sess_pool);
     EXPECT_TRUE(sess1 != NULL);
     session_set_id(sess1, 1);
-    session_set_tuple6(sess1, &tuple_1);
+    session_set_key(sess1, &tuple_1);
 
     sess2 = session_pool_alloc(sess_pool);
     EXPECT_TRUE(sess2 != NULL);
     session_set_id(sess2, 2);
-    session_set_tuple6(sess2, &tuple_2);
+    session_set_key(sess2, &tuple_2);
 
     sess3 = session_pool_alloc(sess_pool);
     EXPECT_TRUE(sess3 != NULL);
     session_set_id(sess3, 3);
-    session_set_tuple6(sess3, &tuple_3);
+    session_set_key(sess3, &tuple_3);
 
     EXPECT_TRUE(session_table_add_session(sess_table, &tuple_1, sess1) == 0);
     EXPECT_TRUE(session_table_get_count(sess_table) == 1);
@@ -153,7 +153,7 @@ TEST(SESSION_TABLE, FIND_OLDEST_NEWEST)
     sess1 = session_pool_alloc(sess_pool);
     EXPECT_TRUE(sess1 != NULL);
     session_set_id(sess1, 1);
-    session_set_tuple6(sess1, &tuple_1);
+    session_set_key(sess1, &tuple_1);
     EXPECT_TRUE(session_table_add_session(sess_table, &tuple_1, sess1) == 0);
     EXPECT_TRUE(session_table_find_least_recently_unused_session(sess_table) == sess1);
     EXPECT_TRUE(session_table_find_least_recently_used_session(sess_table) == sess1);
@@ -161,7 +161,7 @@ TEST(SESSION_TABLE, FIND_OLDEST_NEWEST)
     sess2 = session_pool_alloc(sess_pool);
     EXPECT_TRUE(sess2 != NULL);
     session_set_id(sess2, 2);
-    session_set_tuple6(sess2, &tuple_2);
+    session_set_key(sess2, &tuple_2);
     EXPECT_TRUE(session_table_add_session(sess_table, &tuple_2, sess2) == 0);
     EXPECT_TRUE(session_table_find_least_recently_unused_session(sess_table) == sess1);
     EXPECT_TRUE(session_table_find_least_recently_used_session(sess_table) == sess2);
@@ -169,7 +169,7 @@ TEST(SESSION_TABLE, FIND_OLDEST_NEWEST)
     sess3 = session_pool_alloc(sess_pool);
     EXPECT_TRUE(sess3 != NULL);
     session_set_id(sess3, 3);
-    session_set_tuple6(sess3, &tuple_3);
+    session_set_key(sess3, &tuple_3);
     EXPECT_TRUE(session_table_add_session(sess_table, &tuple_3, sess3) == 0);
     EXPECT_TRUE(session_table_find_least_recently_unused_session(sess_table) == sess1);
     EXPECT_TRUE(session_table_find_least_recently_used_session(sess_table) == sess3);

src/session/test/gtest_tcp_init_to_opening.cpp

@@ -0,0 +1,933 @@
+// TCP state machine test: init -> opening
+// TODO
+
+#include <gtest/gtest.h>
+
+#include "session_private.h"
+#include "timestamp.h"
+#include "session_manager.h"
+#include "ipv4_helpers.h"
+#include "test_packets.h"
+
+struct session_manager_config config = {
+    // max session number
+    .max_tcp_session_num = 3,
+    .max_udp_session_num = 3,
+
+    // tcp timeout
+    .tcp_timeout_init = 2,
+    .tcp_timeout_handshake = 2,
+    .tcp_timeout_data = 2,
+    .tcp_timeout_half_closed = 2,
+    .tcp_timeout_time_wait = 2,
+    .tcp_timeout_discard = 2,
+
+    // udp timeout
+    .udp_timeout_data = 1,
+
+    // tcp duplicate packet filter
+    .tcp_dupkt_filter_enable = 1,
+    .tcp_dupkt_filter_capacity = 1000,
+    .tcp_dupkt_filter_timeout = 10,
+    .tcp_dupkt_filter_error_rate = 0.0001,
+
+    // udp eviction filter
+    .udp_eviction_filter_enable = 1,
+    .udp_eviction_filter_capacity = 1000,
+    .udp_eviction_filter_timeout = 10,
+    .udp_eviction_filter_error_rate = 0.0001,
+};
+
+static void __session_dispatch(struct session *sess)
+{
+    if (sess == NULL)
+    {
+        return;
+    }
+
+    printf("\n");
+    printf("=> session dispatch: %p\n", sess);
+    session_dump(sess);
+    printf("<= session dispatch\n");
+    printf("\n");
+
+    session_set0_cur_pkt(sess, NULL);
+    session_set_cur_dir(sess, SESSION_DIR_NONE);
+}
+
+/******************************************************************************
+ * case: TCP init -> opening (by SYN)
+ ******************************************************************************/
+
+#if 1
+TEST(TCP_INIT_TO_OPENING, BY_SYN)
+{
+    char buffer[1024] = {0};
+    struct packet pkt;
+    struct session *sess = NULL;
+    struct session_manager *mgr = NULL;
+
+    timestamp_update();
+
+    mgr = session_manager_create(&config);
+    EXPECT_TRUE(mgr != NULL);
+
+    // SYN Packet
+    printf("=> packet parse: TCP C2S SYN packet\n");
+    packet_parse(&pkt, (const char *)tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
+    printf("<= packet parse\n\n");
+    sess = session_manager_update_session(mgr, &pkt);
+    EXPECT_TRUE(sess);
+
+    EXPECT_TRUE(session_get_id(sess) == 0);
+    tuple6_tostring(session_get0_key(sess), buffer, sizeof(buffer));
+    EXPECT_STREQ(buffer, "192.168.38.105:60111 -> 93.184.216.34:80, proto: 6, domain: 0");
+    EXPECT_TRUE(session_get_key_dir(sess) == SESSION_DIR_C2S);
+    EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_OPENING);
+    EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
+    EXPECT_TRUE(session_get_dup_traffic_flag(sess) == 0);
+    EXPECT_TRUE(session_get_closing_reasion(sess) == 0);
+    EXPECT_TRUE(session_get_c2s_bytes(sess) == 78);
+    EXPECT_TRUE(session_get_s2c_bytes(sess) == 0);
+    EXPECT_TRUE(session_get_c2s_packets(sess) == 1);
+    EXPECT_TRUE(session_get_s2c_packets(sess) == 0);
+    EXPECT_TRUE(session_get_create_time(sess) == timestamp_get_msec());
+    EXPECT_TRUE(session_get_last_time(sess) == timestamp_get_msec());
+    EXPECT_TRUE(session_get0_cur_pkt(sess) == &pkt);
+    EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_C2S);
+    EXPECT_TRUE(session_get_tcp_state(sess) == TCP_SYN_RECVED);
+    EXPECT_TRUE(session_get0_c2s_1st_pkt(sess) != NULL);
+    EXPECT_TRUE(session_get0_s2c_1st_pkt(sess) == NULL);
+    EXPECT_TRUE(session_get0_1st_pkt(sess) == session_get0_c2s_1st_pkt(sess));
+
+    __session_dispatch(sess);
+
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_OPENING) == 1);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_CLOSING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_ACTIVE) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_OPENING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_CLOSING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_ACTIVE) == 0);
+
+    for (int i = 0; i < 3; i++)
+    {
+        timestamp_update();
+        __session_dispatch(session_manager_get_expired_session(mgr));
+        __session_dispatch(session_manager_get_evicted_session(mgr));
+        sleep(1);
+    }
+
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_OPENING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_CLOSING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_ACTIVE) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_OPENING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_CLOSING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_ACTIVE) == 0);
+
+    session_manager_destroy(mgr);
+}
+#endif
+
+/******************************************************************************
+ * case: TCP init -> opening (by SYNACK)
+ ******************************************************************************/
+
+#if 1
+TEST(TCP_INIT_TO_OPENING, BY_SYNACK)
+{
+    char buffer[1024] = {0};
+    struct packet pkt;
+    struct session *sess = NULL;
+    struct session_manager *mgr = NULL;
+
+    timestamp_update();
+
+    mgr = session_manager_create(&config);
+    EXPECT_TRUE(mgr != NULL);
+
+    // SYNACK Packet
+    printf("=> packet parse: TCP S2C SYNACK packet\n");
+    packet_parse(&pkt, (const char *)tcp_pkt2_s2c_syn_ack, sizeof(tcp_pkt2_s2c_syn_ack));
+    printf("<= packet parse\n\n");
+    sess = session_manager_update_session(mgr, &pkt);
+    EXPECT_TRUE(sess);
+
+    EXPECT_TRUE(session_get_id(sess) == 0);
+    tuple6_tostring(session_get0_key(sess), buffer, sizeof(buffer));
+    EXPECT_STREQ(buffer, "93.184.216.34:80 -> 192.168.38.105:60111, proto: 6, domain: 0");
+    EXPECT_TRUE(session_get_key_dir(sess) == SESSION_DIR_S2C);
+    EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_OPENING);
+    EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
+    EXPECT_TRUE(session_get_dup_traffic_flag(sess) == 0);
+    EXPECT_TRUE(session_get_closing_reasion(sess) == 0);
+    EXPECT_TRUE(session_get_c2s_bytes(sess) == 0);
+    EXPECT_TRUE(session_get_s2c_bytes(sess) == 74);
+    EXPECT_TRUE(session_get_c2s_packets(sess) == 0);
+    EXPECT_TRUE(session_get_s2c_packets(sess) == 1);
+    EXPECT_TRUE(session_get_create_time(sess) == timestamp_get_msec());
+    EXPECT_TRUE(session_get_last_time(sess) == timestamp_get_msec());
+    EXPECT_TRUE(session_get0_cur_pkt(sess) == &pkt);
+    EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_S2C);
+    EXPECT_TRUE(session_get_tcp_state(sess) == TCP_SYNACK_RECVED);
+    EXPECT_TRUE(session_get0_c2s_1st_pkt(sess) == NULL);
+    EXPECT_TRUE(session_get0_s2c_1st_pkt(sess) != NULL);
+    EXPECT_TRUE(session_get0_1st_pkt(sess) == session_get0_s2c_1st_pkt(sess));
+
+    __session_dispatch(sess);
+
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_OPENING) == 1);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_CLOSING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_ACTIVE) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_OPENING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_CLOSING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_ACTIVE) == 0);
+
+    for (int i = 0; i < 3; i++)
+    {
+        timestamp_update();
+        __session_dispatch(session_manager_get_expired_session(mgr));
+        __session_dispatch(session_manager_get_evicted_session(mgr));
+        sleep(1);
+    }
+
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_OPENING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_CLOSING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_ACTIVE) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_OPENING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_CLOSING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_ACTIVE) == 0);
+
+    session_manager_destroy(mgr);
+}
+#endif
+
+/******************************************************************************
+ * case: TCP init -> opening (by SYN + SYNACK)
+ ******************************************************************************/
+
+#if 1
+TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK)
+{
+    char buffer[1024] = {0};
+    struct packet pkt;
+    struct session *sess = NULL;
+    struct session_manager *mgr = NULL;
+
+    timestamp_update();
+
+    mgr = session_manager_create(&config);
+    EXPECT_TRUE(mgr != NULL);
+
+    // SYN Packet
+    printf("=> packet parse: TCP C2S SYN packet\n");
+    packet_parse(&pkt, (const char *)tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
+    printf("<= packet parse\n\n");
+    sess = session_manager_update_session(mgr, &pkt);
+    EXPECT_TRUE(sess);
+
+    EXPECT_TRUE(session_get_id(sess) == 0);
+    tuple6_tostring(session_get0_key(sess), buffer, sizeof(buffer));
+    EXPECT_STREQ(buffer, "192.168.38.105:60111 -> 93.184.216.34:80, proto: 6, domain: 0");
+    EXPECT_TRUE(session_get_key_dir(sess) == SESSION_DIR_C2S);
+    EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_OPENING);
+    EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
+    EXPECT_TRUE(session_get_dup_traffic_flag(sess) == 0);
+    EXPECT_TRUE(session_get_closing_reasion(sess) == 0);
+    EXPECT_TRUE(session_get_c2s_bytes(sess) == 78);
+    EXPECT_TRUE(session_get_s2c_bytes(sess) == 0);
+    EXPECT_TRUE(session_get_c2s_packets(sess) == 1);
+    EXPECT_TRUE(session_get_s2c_packets(sess) == 0);
+    EXPECT_TRUE(session_get_create_time(sess) == timestamp_get_msec());
+    EXPECT_TRUE(session_get_last_time(sess) == timestamp_get_msec());
+    EXPECT_TRUE(session_get0_cur_pkt(sess) == &pkt);
+    EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_C2S);
+    EXPECT_TRUE(session_get_tcp_state(sess) == TCP_SYN_RECVED);
+    EXPECT_TRUE(session_get0_c2s_1st_pkt(sess) != NULL);
+    EXPECT_TRUE(session_get0_s2c_1st_pkt(sess) == NULL);
+    EXPECT_TRUE(session_get0_1st_pkt(sess) == session_get0_c2s_1st_pkt(sess));
+
+    __session_dispatch(sess);
+
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_OPENING) == 1);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_CLOSING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_ACTIVE) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_OPENING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_CLOSING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_ACTIVE) == 0);
+
+    sleep(1);
+    timestamp_update();
+
+    // SYNACK Packet
+    printf("=> packet parse: TCP S2C SYNACK packet\n");
+    packet_parse(&pkt, (const char *)tcp_pkt2_s2c_syn_ack, sizeof(tcp_pkt2_s2c_syn_ack));
+    printf("<= packet parse\n\n");
+    sess = session_manager_update_session(mgr, &pkt);
+    EXPECT_TRUE(sess);
+
+    EXPECT_TRUE(session_get_id(sess) == 0);
+    tuple6_tostring(session_get0_key(sess), buffer, sizeof(buffer));
+    EXPECT_STREQ(buffer, "192.168.38.105:60111 -> 93.184.216.34:80, proto: 6, domain: 0");
+    EXPECT_TRUE(session_get_key_dir(sess) == SESSION_DIR_C2S);
+    EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_OPENING);
+    EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
+    EXPECT_TRUE(session_get_dup_traffic_flag(sess) == 0);
+    EXPECT_TRUE(session_get_closing_reasion(sess) == 0);
+    EXPECT_TRUE(session_get_c2s_bytes(sess) == 78);
+    EXPECT_TRUE(session_get_s2c_bytes(sess) == 74);
+    EXPECT_TRUE(session_get_c2s_packets(sess) == 1);
+    EXPECT_TRUE(session_get_s2c_packets(sess) == 1);
+    EXPECT_TRUE(session_get_create_time(sess) < timestamp_get_msec());
+    EXPECT_TRUE(session_get_last_time(sess) == timestamp_get_msec());
+    EXPECT_TRUE(session_get0_cur_pkt(sess) == &pkt);
+    EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_S2C);
+    EXPECT_TRUE(session_get_tcp_state(sess) == (TCP_SYN_RECVED | TCP_SYNACK_RECVED));
+    EXPECT_TRUE(session_get0_c2s_1st_pkt(sess) != NULL);
+    EXPECT_TRUE(session_get0_s2c_1st_pkt(sess) != NULL);
+    EXPECT_TRUE(session_get0_1st_pkt(sess) == session_get0_c2s_1st_pkt(sess));
+
+    __session_dispatch(sess);
+
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_OPENING) == 1);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_CLOSING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_ACTIVE) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_OPENING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_CLOSING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_ACTIVE) == 0);
+
+    for (int i = 0; i < 3; i++)
+    {
+        timestamp_update();
+        __session_dispatch(session_manager_get_expired_session(mgr));
+        __session_dispatch(session_manager_get_evicted_session(mgr));
+        sleep(1);
+    }
+
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_OPENING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_CLOSING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_ACTIVE) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_OPENING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_CLOSING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_ACTIVE) == 0);
+
+    session_manager_destroy(mgr);
+}
+#endif
+
+/******************************************************************************
+ * case: TCP init -> opening (by SYN + SYNACK + ACK)
+ ******************************************************************************/
+
+#if 1
+TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK_ACK)
+{
+    char buffer[1024] = {0};
+    struct packet pkt;
+    struct session *sess = NULL;
+    struct session_manager *mgr = NULL;
+
+    timestamp_update();
+
+    mgr = session_manager_create(&config);
+    EXPECT_TRUE(mgr != NULL);
+
+    // SYN Packet
+    printf("=> packet parse: TCP C2S SYN packet\n");
+    packet_parse(&pkt, (const char *)tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
+    printf("<= packet parse\n\n");
+    sess = session_manager_update_session(mgr, &pkt);
+    EXPECT_TRUE(sess);
+
+    EXPECT_TRUE(session_get_id(sess) == 0);
+    tuple6_tostring(session_get0_key(sess), buffer, sizeof(buffer));
+    EXPECT_STREQ(buffer, "192.168.38.105:60111 -> 93.184.216.34:80, proto: 6, domain: 0");
+    EXPECT_TRUE(session_get_key_dir(sess) == SESSION_DIR_C2S);
+    EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_OPENING);
+    EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
+    EXPECT_TRUE(session_get_dup_traffic_flag(sess) == 0);
+    EXPECT_TRUE(session_get_closing_reasion(sess) == 0);
+    EXPECT_TRUE(session_get_c2s_bytes(sess) == 78);
+    EXPECT_TRUE(session_get_s2c_bytes(sess) == 0);
+    EXPECT_TRUE(session_get_c2s_packets(sess) == 1);
+    EXPECT_TRUE(session_get_s2c_packets(sess) == 0);
+    EXPECT_TRUE(session_get_create_time(sess) == timestamp_get_msec());
+    EXPECT_TRUE(session_get_last_time(sess) == timestamp_get_msec());
+    EXPECT_TRUE(session_get0_cur_pkt(sess) == &pkt);
+    EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_C2S);
+    EXPECT_TRUE(session_get_tcp_state(sess) == TCP_SYN_RECVED);
+    EXPECT_TRUE(session_get0_c2s_1st_pkt(sess) != NULL);
+    EXPECT_TRUE(session_get0_s2c_1st_pkt(sess) == NULL);
+    EXPECT_TRUE(session_get0_1st_pkt(sess) == session_get0_c2s_1st_pkt(sess));
+
+    __session_dispatch(sess);
+
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_OPENING) == 1);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_CLOSING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_ACTIVE) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_OPENING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_CLOSING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_ACTIVE) == 0);
+
+    sleep(1);
+    timestamp_update();
+
+    // SYNACK Packet
+    printf("=> packet parse: TCP S2C SYNACK packet\n");
+    packet_parse(&pkt, (const char *)tcp_pkt2_s2c_syn_ack, sizeof(tcp_pkt2_s2c_syn_ack));
+    printf("<= packet parse\n\n");
+    sess = session_manager_update_session(mgr, &pkt);
+    EXPECT_TRUE(sess);
+
+    EXPECT_TRUE(session_get_id(sess) == 0);
+    tuple6_tostring(session_get0_key(sess), buffer, sizeof(buffer));
+    EXPECT_STREQ(buffer, "192.168.38.105:60111 -> 93.184.216.34:80, proto: 6, domain: 0");
+    EXPECT_TRUE(session_get_key_dir(sess) == SESSION_DIR_C2S);
+    EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_OPENING);
+    EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
+    EXPECT_TRUE(session_get_dup_traffic_flag(sess) == 0);
+    EXPECT_TRUE(session_get_closing_reasion(sess) == 0);
+    EXPECT_TRUE(session_get_c2s_bytes(sess) == 78);
+    EXPECT_TRUE(session_get_s2c_bytes(sess) == 74);
+    EXPECT_TRUE(session_get_c2s_packets(sess) == 1);
+    EXPECT_TRUE(session_get_s2c_packets(sess) == 1);
+    EXPECT_TRUE(session_get_create_time(sess) < timestamp_get_msec());
+    EXPECT_TRUE(session_get_last_time(sess) == timestamp_get_msec());
+    EXPECT_TRUE(session_get0_cur_pkt(sess) == &pkt);
+    EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_S2C);
+    EXPECT_TRUE(session_get_tcp_state(sess) == (TCP_SYN_RECVED | TCP_SYNACK_RECVED));
+    EXPECT_TRUE(session_get0_c2s_1st_pkt(sess) != NULL);
+    EXPECT_TRUE(session_get0_s2c_1st_pkt(sess) != NULL);
+    EXPECT_TRUE(session_get0_1st_pkt(sess) == session_get0_c2s_1st_pkt(sess));
+
+    __session_dispatch(sess);
+
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_OPENING) == 1);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_CLOSING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_ACTIVE) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_OPENING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_CLOSING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_ACTIVE) == 0);
+
+    sleep(1);
+    timestamp_update();
+
+    // ACK Packet
+    printf("=> packet parse: TCP C2S ACK packet\n");
+    packet_parse(&pkt, (const char *)tcp_pkt3_c2s_ack, sizeof(tcp_pkt3_c2s_ack));
+    printf("<= packet parse\n\n");
+    sess = session_manager_update_session(mgr, &pkt);
+    EXPECT_TRUE(sess);
+
+    EXPECT_TRUE(session_get_id(sess) == 0);
+    tuple6_tostring(session_get0_key(sess), buffer, sizeof(buffer));
+    EXPECT_STREQ(buffer, "192.168.38.105:60111 -> 93.184.216.34:80, proto: 6, domain: 0");
+    EXPECT_TRUE(session_get_key_dir(sess) == SESSION_DIR_C2S);
+    EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_OPENING);
+    EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
+    EXPECT_TRUE(session_get_dup_traffic_flag(sess) == 0);
+    EXPECT_TRUE(session_get_closing_reasion(sess) == 0);
+    EXPECT_TRUE(session_get_c2s_bytes(sess) == 78 + 66);
+    EXPECT_TRUE(session_get_s2c_bytes(sess) == 74);
+    EXPECT_TRUE(session_get_c2s_packets(sess) == 1 + 1);
+    EXPECT_TRUE(session_get_s2c_packets(sess) == 1);
+    EXPECT_TRUE(session_get_create_time(sess) < timestamp_get_msec());
+    EXPECT_TRUE(session_get_last_time(sess) == timestamp_get_msec());
+    EXPECT_TRUE(session_get0_cur_pkt(sess) == &pkt);
+    EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_C2S);
+    EXPECT_TRUE(session_get_tcp_state(sess) == (TCP_SYN_RECVED | TCP_SYNACK_RECVED | TCP_C2S_ACK_RECVED));
+    EXPECT_TRUE(session_get0_c2s_1st_pkt(sess) != NULL);
+    EXPECT_TRUE(session_get0_s2c_1st_pkt(sess) != NULL);
+
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_OPENING) == 1);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_CLOSING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_ACTIVE) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_OPENING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_CLOSING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_ACTIVE) == 0);
+
+    for (int i = 0; i < 3; i++)
+    {
+        timestamp_update();
+        __session_dispatch(session_manager_get_expired_session(mgr));
+        __session_dispatch(session_manager_get_evicted_session(mgr));
+        sleep(1);
+    }
+
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_OPENING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_CLOSING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_ACTIVE) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_OPENING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_CLOSING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_ACTIVE) == 0);
+
+    session_manager_destroy(mgr);
+}
+#endif
+
+/******************************************************************************
+ * case: TCP init -> opening (by SYN retransmission)
+ ******************************************************************************/
+
+// overwrited ipid to build SYN retransmission
+
+#if 1
+TEST(TCP_INIT_TO_OPENING, BY_SYN_RETRANSMISSION)
+{
+    char buffer[1024] = {0};
+    struct packet pkt;
+    struct session *sess = NULL;
+    struct session_manager *mgr = NULL;
+
+    timestamp_update();
+
+    mgr = session_manager_create(&config);
+    EXPECT_TRUE(mgr != NULL);
+
+    // SYN Packet
+    printf("=> packet parse: TCP C2S SYN packet\n");
+    packet_parse(&pkt, (const char *)tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
+    printf("<= packet parse\n\n");
+    sess = session_manager_update_session(mgr, &pkt);
+    EXPECT_TRUE(sess);
+
+    EXPECT_TRUE(session_get_id(sess) == 0);
+    tuple6_tostring(session_get0_key(sess), buffer, sizeof(buffer));
+    EXPECT_STREQ(buffer, "192.168.38.105:60111 -> 93.184.216.34:80, proto: 6, domain: 0");
+    EXPECT_TRUE(session_get_key_dir(sess) == SESSION_DIR_C2S);
+    EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_OPENING);
+    EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
+    EXPECT_TRUE(session_get_dup_traffic_flag(sess) == 0);
+    EXPECT_TRUE(session_get_closing_reasion(sess) == 0);
+    EXPECT_TRUE(session_get_c2s_bytes(sess) == 78);
+    EXPECT_TRUE(session_get_s2c_bytes(sess) == 0);
+    EXPECT_TRUE(session_get_c2s_packets(sess) == 1);
+    EXPECT_TRUE(session_get_s2c_packets(sess) == 0);
+    EXPECT_TRUE(session_get_create_time(sess) == timestamp_get_msec());
+    EXPECT_TRUE(session_get_last_time(sess) == timestamp_get_msec());
+    EXPECT_TRUE(session_get0_cur_pkt(sess) == &pkt);
+    EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_C2S);
+    EXPECT_TRUE(session_get_tcp_state(sess) == TCP_SYN_RECVED);
+    EXPECT_TRUE(session_get0_c2s_1st_pkt(sess) != NULL);
+    EXPECT_TRUE(session_get0_s2c_1st_pkt(sess) == NULL);
+    EXPECT_TRUE(session_get0_1st_pkt(sess) == session_get0_c2s_1st_pkt(sess));
+
+    __session_dispatch(sess);
+
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_OPENING) == 1);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_CLOSING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_ACTIVE) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_OPENING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_CLOSING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_ACTIVE) == 0);
+
+    sleep(1);
+    timestamp_update();
+
+    // SYN Packet retransmission
+    printf("=> packet parse: TCP C2S SYN retransmission packet\n");
+    packet_parse(&pkt, (const char *)tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
+    const struct layer_record *ipv4_layer = packet_get_innermost_layer(&pkt, LAYER_TYPE_IPV4);
+    EXPECT_TRUE(ipv4_layer);
+    const struct ip *hdr = (const struct ip *)ipv4_layer->hdr_ptr;
+    ipv4_hdr_set_ipid((struct ip *)hdr, 0x1234);
+    printf("<= packet parse\n\n");
+    sess = session_manager_update_session(mgr, &pkt);
+    EXPECT_TRUE(sess);
+
+    EXPECT_TRUE(session_get_id(sess) == 0);
+    tuple6_tostring(session_get0_key(sess), buffer, sizeof(buffer));
+    EXPECT_STREQ(buffer, "192.168.38.105:60111 -> 93.184.216.34:80, proto: 6, domain: 0");
+    EXPECT_TRUE(session_get_key_dir(sess) == SESSION_DIR_C2S);
+    EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_OPENING);
+    EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
+    EXPECT_TRUE(session_get_dup_traffic_flag(sess) == 0);
+    EXPECT_TRUE(session_get_closing_reasion(sess) == 0);
+    EXPECT_TRUE(session_get_c2s_bytes(sess) == 78 + 78);
+    EXPECT_TRUE(session_get_s2c_bytes(sess) == 0);
+    EXPECT_TRUE(session_get_c2s_packets(sess) == 1 + 1);
+    EXPECT_TRUE(session_get_s2c_packets(sess) == 0);
+    EXPECT_TRUE(session_get_create_time(sess) < timestamp_get_msec());
+    EXPECT_TRUE(session_get_last_time(sess) == timestamp_get_msec());
+    EXPECT_TRUE(session_get0_cur_pkt(sess) == &pkt);
+    EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_C2S);
+    EXPECT_TRUE(session_get_tcp_state(sess) == TCP_SYN_RECVED);
+    EXPECT_TRUE(session_get0_c2s_1st_pkt(sess) != NULL);
+    EXPECT_TRUE(session_get0_s2c_1st_pkt(sess) == NULL);
+    EXPECT_TRUE(session_get0_1st_pkt(sess) == session_get0_c2s_1st_pkt(sess));
+
+    __session_dispatch(sess);
+
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_OPENING) == 1);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_CLOSING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_ACTIVE) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_OPENING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_CLOSING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_ACTIVE) == 0);
+
+    for (int i = 0; i < 3; i++)
+    {
+        timestamp_update();
+        __session_dispatch(session_manager_get_expired_session(mgr));
+        __session_dispatch(session_manager_get_evicted_session(mgr));
+        sleep(1);
+    }
+
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_OPENING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_CLOSING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_ACTIVE) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_OPENING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_CLOSING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_ACTIVE) == 0);
+
+    session_manager_destroy(mgr);
+}
+#endif
+
+/******************************************************************************
+ * case: TCP init -> opening (by SYNACK retransmission)
+ ******************************************************************************/
+
+// overwrited ipid to build SYNACK retransmission
+
+#if 1
+TEST(TCP_INIT_TO_OPENING, BY_SYNACK_RETRANSMISSION)
+{
+    char buffer[1024] = {0};
+    struct packet pkt;
+    struct session *sess = NULL;
+    struct session_manager *mgr = NULL;
+
+    timestamp_update();
+
+    mgr = session_manager_create(&config);
+    EXPECT_TRUE(mgr != NULL);
+
+    // SYNACK Packet
+    printf("=> packet parse: TCP S2C SYNACK packet\n");
+    packet_parse(&pkt, (const char *)tcp_pkt2_s2c_syn_ack, sizeof(tcp_pkt2_s2c_syn_ack));
+    printf("<= packet parse\n\n");
+    sess = session_manager_update_session(mgr, &pkt);
+    EXPECT_TRUE(sess);
+
+    EXPECT_TRUE(session_get_id(sess) == 0);
+    tuple6_tostring(session_get0_key(sess), buffer, sizeof(buffer));
+    EXPECT_STREQ(buffer, "93.184.216.34:80 -> 192.168.38.105:60111, proto: 6, domain: 0");
+    EXPECT_TRUE(session_get_key_dir(sess) == SESSION_DIR_S2C);
+    EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_OPENING);
+    EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
+    EXPECT_TRUE(session_get_dup_traffic_flag(sess) == 0);
+    EXPECT_TRUE(session_get_closing_reasion(sess) == 0);
+    EXPECT_TRUE(session_get_c2s_bytes(sess) == 0);
+    EXPECT_TRUE(session_get_s2c_bytes(sess) == 74);
+    EXPECT_TRUE(session_get_c2s_packets(sess) == 0);
+    EXPECT_TRUE(session_get_s2c_packets(sess) == 1);
+    EXPECT_TRUE(session_get_create_time(sess) == timestamp_get_msec());
+    EXPECT_TRUE(session_get_last_time(sess) == timestamp_get_msec());
+    EXPECT_TRUE(session_get0_cur_pkt(sess) == &pkt);
+    EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_S2C);
+    EXPECT_TRUE(session_get_tcp_state(sess) == TCP_SYNACK_RECVED);
+    EXPECT_TRUE(session_get0_c2s_1st_pkt(sess) == NULL);
+    EXPECT_TRUE(session_get0_s2c_1st_pkt(sess) != NULL);
+    EXPECT_TRUE(session_get0_1st_pkt(sess) == session_get0_s2c_1st_pkt(sess));
+
+    __session_dispatch(sess);
+
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_OPENING) == 1);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_CLOSING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_ACTIVE) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_OPENING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_CLOSING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_ACTIVE) == 0);
+
+    sleep(1);
+    timestamp_update();
+
+    // SYNACK Packet retransmission
+    printf("=> packet parse: TCP S2C SYNACK retransmission packet\n");
+    packet_parse(&pkt, (const char *)tcp_pkt2_s2c_syn_ack, sizeof(tcp_pkt2_s2c_syn_ack));
+    const struct layer_record *ipv4_layer = packet_get_innermost_layer(&pkt, LAYER_TYPE_IPV4);
+    EXPECT_TRUE(ipv4_layer);
+    const struct ip *hdr = (const struct ip *)ipv4_layer->hdr_ptr;
+    ipv4_hdr_set_ipid((struct ip *)hdr, 0x1234);
+    printf("<= packet parse\n\n");
+    sess = session_manager_update_session(mgr, &pkt);
+    EXPECT_TRUE(sess);
+
+    EXPECT_TRUE(session_get_id(sess) == 0);
+    tuple6_tostring(session_get0_key(sess), buffer, sizeof(buffer));
+    EXPECT_STREQ(buffer, "93.184.216.34:80 -> 192.168.38.105:60111, proto: 6, domain: 0");
+    EXPECT_TRUE(session_get_key_dir(sess) == SESSION_DIR_S2C);
+    EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_OPENING);
+    EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
+    EXPECT_TRUE(session_get_dup_traffic_flag(sess) == 0);
+    EXPECT_TRUE(session_get_closing_reasion(sess) == 0);
+    EXPECT_TRUE(session_get_c2s_bytes(sess) == 0);
+    EXPECT_TRUE(session_get_s2c_bytes(sess) == 74 + 74);
+    EXPECT_TRUE(session_get_c2s_packets(sess) == 0);
+    EXPECT_TRUE(session_get_s2c_packets(sess) == 1 + 1);
+    EXPECT_TRUE(session_get_create_time(sess) < timestamp_get_msec());
+    EXPECT_TRUE(session_get_last_time(sess) == timestamp_get_msec());
+    EXPECT_TRUE(session_get0_cur_pkt(sess) == &pkt);
+    EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_S2C);
+    EXPECT_TRUE(session_get_tcp_state(sess) == TCP_SYNACK_RECVED);
+    EXPECT_TRUE(session_get0_c2s_1st_pkt(sess) == NULL);
+    EXPECT_TRUE(session_get0_s2c_1st_pkt(sess) != NULL);
+    EXPECT_TRUE(session_get0_1st_pkt(sess) == session_get0_s2c_1st_pkt(sess));
+
+    __session_dispatch(sess);
+
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_OPENING) == 1);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_CLOSING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_ACTIVE) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_OPENING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_CLOSING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_ACTIVE) == 0);
+
+    for (int i = 0; i < 3; i++)
+    {
+        timestamp_update();
+        __session_dispatch(session_manager_get_expired_session(mgr));
+        __session_dispatch(session_manager_get_evicted_session(mgr));
+        sleep(1);
+    }
+
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_OPENING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_CLOSING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_ACTIVE) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_OPENING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_CLOSING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_ACTIVE) == 0);
+
+    session_manager_destroy(mgr);
+}
+#endif
+
+/******************************************************************************
+ * case: TCP init -> opening (by C2S asymmetric)
+ ******************************************************************************/
+
+#if 1
+TEST(TCP_INIT_TO_OPENING, BY_C2S_ASMMETRIC)
+{
+    char buffer[1024] = {0};
+    struct packet pkt;
+    struct session *sess = NULL;
+    struct session_manager *mgr = NULL;
+
+    timestamp_update();
+
+    mgr = session_manager_create(&config);
+    EXPECT_TRUE(mgr != NULL);
+
+    // SYN Packet
+    printf("=> packet parse: TCP C2S SYN packet\n");
+    packet_parse(&pkt, (const char *)tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
+    printf("<= packet parse\n\n");
+    sess = session_manager_update_session(mgr, &pkt);
+    EXPECT_TRUE(sess);
+
+    EXPECT_TRUE(session_get_id(sess) == 0);
+    tuple6_tostring(session_get0_key(sess), buffer, sizeof(buffer));
+    EXPECT_STREQ(buffer, "192.168.38.105:60111 -> 93.184.216.34:80, proto: 6, domain: 0");
+    EXPECT_TRUE(session_get_key_dir(sess) == SESSION_DIR_C2S);
+    EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_OPENING);
+    EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
+    EXPECT_TRUE(session_get_dup_traffic_flag(sess) == 0);
+    EXPECT_TRUE(session_get_closing_reasion(sess) == 0);
+    EXPECT_TRUE(session_get_c2s_bytes(sess) == 78);
+    EXPECT_TRUE(session_get_s2c_bytes(sess) == 0);
+    EXPECT_TRUE(session_get_c2s_packets(sess) == 1);
+    EXPECT_TRUE(session_get_s2c_packets(sess) == 0);
+    EXPECT_TRUE(session_get_create_time(sess) == timestamp_get_msec());
+    EXPECT_TRUE(session_get_last_time(sess) == timestamp_get_msec());
+    EXPECT_TRUE(session_get0_cur_pkt(sess) == &pkt);
+    EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_C2S);
+    EXPECT_TRUE(session_get_tcp_state(sess) == TCP_SYN_RECVED);
+    EXPECT_TRUE(session_get0_c2s_1st_pkt(sess) != NULL);
+    EXPECT_TRUE(session_get0_s2c_1st_pkt(sess) == NULL);
+    EXPECT_TRUE(session_get0_1st_pkt(sess) == session_get0_c2s_1st_pkt(sess));
+
+    __session_dispatch(sess);
+
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_OPENING) == 1);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_CLOSING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_ACTIVE) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_OPENING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_CLOSING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_ACTIVE) == 0);
+
+    sleep(1);
+    timestamp_update();
+
+    // ACK Packet
+    printf("=> packet parse: TCP C2S ACK packet\n");
+    packet_parse(&pkt, (const char *)tcp_pkt3_c2s_ack, sizeof(tcp_pkt3_c2s_ack));
+    printf("<= packet parse\n\n");
+    sess = session_manager_update_session(mgr, &pkt);
+    EXPECT_TRUE(sess);
+
+    EXPECT_TRUE(session_get_id(sess) == 0);
+    tuple6_tostring(session_get0_key(sess), buffer, sizeof(buffer));
+    EXPECT_STREQ(buffer, "192.168.38.105:60111 -> 93.184.216.34:80, proto: 6, domain: 0");
+    EXPECT_TRUE(session_get_key_dir(sess) == SESSION_DIR_C2S);
+    EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_OPENING);
+    EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
+    EXPECT_TRUE(session_get_dup_traffic_flag(sess) == 0);
+    EXPECT_TRUE(session_get_closing_reasion(sess) == 0);
+    EXPECT_TRUE(session_get_c2s_bytes(sess) == 78 + 66);
+    EXPECT_TRUE(session_get_s2c_bytes(sess) == 0);
+    EXPECT_TRUE(session_get_c2s_packets(sess) == 1 + 1);
+    EXPECT_TRUE(session_get_s2c_packets(sess) == 0);
+    EXPECT_TRUE(session_get_create_time(sess) < timestamp_get_msec());
+    EXPECT_TRUE(session_get_last_time(sess) == timestamp_get_msec());
+    EXPECT_TRUE(session_get0_cur_pkt(sess) == &pkt);
+    EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_C2S);
+    EXPECT_TRUE(session_get_tcp_state(sess) == (TCP_SYN_RECVED | TCP_C2S_ACK_RECVED));
+    EXPECT_TRUE(session_get0_c2s_1st_pkt(sess) != NULL);
+    EXPECT_TRUE(session_get0_s2c_1st_pkt(sess) == NULL);
+    EXPECT_TRUE(session_get0_1st_pkt(sess) == session_get0_c2s_1st_pkt(sess));
+
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_OPENING) == 1);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_CLOSING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_ACTIVE) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_OPENING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_CLOSING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_ACTIVE) == 0);
+
+    for (int i = 0; i < 3; i++)
+    {
+        timestamp_update();
+        __session_dispatch(session_manager_get_expired_session(mgr));
+        __session_dispatch(session_manager_get_evicted_session(mgr));
+        sleep(1);
+    }
+
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_OPENING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_CLOSING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_ACTIVE) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_OPENING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_CLOSING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_ACTIVE) == 0);
+
+    session_manager_destroy(mgr);
+}
+#endif
+
+/******************************************************************************
+ * case: TCP init -> opening (by S2C asymmetric)
+ ******************************************************************************/
+
+#if 1
+TEST(TCP_INIT_TO_OPENING, BY_S2C_ASMMETRIC)
+{
+    char buffer[1024] = {0};
+    struct packet pkt;
+    struct session *sess = NULL;
+    struct session_manager *mgr = NULL;
+
+    timestamp_update();
+
+    mgr = session_manager_create(&config);
+    EXPECT_TRUE(mgr != NULL);
+
+    // SYNACK Packet
+    printf("=> packet parse: TCP S2C SYNACK packet\n");
+    packet_parse(&pkt, (const char *)tcp_pkt2_s2c_syn_ack, sizeof(tcp_pkt2_s2c_syn_ack));
+    printf("<= packet parse\n\n");
+    sess = session_manager_update_session(mgr, &pkt);
+    EXPECT_TRUE(sess);
+
+    EXPECT_TRUE(session_get_id(sess) == 0);
+    tuple6_tostring(session_get0_key(sess), buffer, sizeof(buffer));
+    EXPECT_STREQ(buffer, "93.184.216.34:80 -> 192.168.38.105:60111, proto: 6, domain: 0");
+    EXPECT_TRUE(session_get_key_dir(sess) == SESSION_DIR_S2C);
+    EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_OPENING);
+    EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
+    EXPECT_TRUE(session_get_dup_traffic_flag(sess) == 0);
+    EXPECT_TRUE(session_get_closing_reasion(sess) == 0);
+    EXPECT_TRUE(session_get_c2s_bytes(sess) == 0);
+    EXPECT_TRUE(session_get_s2c_bytes(sess) == 74);
+    EXPECT_TRUE(session_get_c2s_packets(sess) == 0);
+    EXPECT_TRUE(session_get_s2c_packets(sess) == 1);
+    EXPECT_TRUE(session_get_create_time(sess) == timestamp_get_msec());
+    EXPECT_TRUE(session_get_last_time(sess) == timestamp_get_msec());
+    EXPECT_TRUE(session_get0_cur_pkt(sess) == &pkt);
+    EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_S2C);
+    EXPECT_TRUE(session_get_tcp_state(sess) == TCP_SYNACK_RECVED);
+    EXPECT_TRUE(session_get0_c2s_1st_pkt(sess) == NULL);
+    EXPECT_TRUE(session_get0_s2c_1st_pkt(sess) != NULL);
+    EXPECT_TRUE(session_get0_1st_pkt(sess) == session_get0_s2c_1st_pkt(sess));
+
+    __session_dispatch(sess);
+
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_OPENING) == 1);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_CLOSING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_ACTIVE) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_OPENING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_CLOSING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_ACTIVE) == 0);
+
+    sleep(1);
+    timestamp_update();
+
+    // ACK Packet
+    printf("=> packet parse: TCP S2C ACK packet\n");
+    packet_parse(&pkt, (const char *)tcp_pkt5_s2c_ack, sizeof(tcp_pkt5_s2c_ack));
+    printf("<= packet parse\n\n");
+    sess = session_manager_update_session(mgr, &pkt);
+    EXPECT_TRUE(sess);
+
+    EXPECT_TRUE(session_get_id(sess) == 0);
+    tuple6_tostring(session_get0_key(sess), buffer, sizeof(buffer));
+    EXPECT_STREQ(buffer, "93.184.216.34:80 -> 192.168.38.105:60111, proto: 6, domain: 0");
+    EXPECT_TRUE(session_get_key_dir(sess) == SESSION_DIR_S2C);
+    EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_OPENING);
+    EXPECT_TRUE(session_get_type(sess) == SESSION_TYPE_TCP);
+    EXPECT_TRUE(session_get_dup_traffic_flag(sess) == 0);
+    EXPECT_TRUE(session_get_closing_reasion(sess) == 0);
+    EXPECT_TRUE(session_get_c2s_bytes(sess) == 0);
+    EXPECT_TRUE(session_get_s2c_bytes(sess) == 74 + 66);
+    EXPECT_TRUE(session_get_c2s_packets(sess) == 0);
+    EXPECT_TRUE(session_get_s2c_packets(sess) == 1 + 1);
+    EXPECT_TRUE(session_get_create_time(sess) < timestamp_get_msec());
+    EXPECT_TRUE(session_get_last_time(sess) == timestamp_get_msec());
+    EXPECT_TRUE(session_get0_cur_pkt(sess) == &pkt);
+    EXPECT_TRUE(session_get_cur_dir(sess) == SESSION_DIR_S2C);
+    EXPECT_TRUE(session_get_tcp_state(sess) == (TCP_SYNACK_RECVED | TCP_S2C_ACK_RECVED));
+    EXPECT_TRUE(session_get0_c2s_1st_pkt(sess) == NULL);
+    EXPECT_TRUE(session_get0_s2c_1st_pkt(sess) != NULL);
+    EXPECT_TRUE(session_get0_1st_pkt(sess) == session_get0_s2c_1st_pkt(sess));
+
+    __session_dispatch(sess);
+
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_OPENING) == 1);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_CLOSING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_ACTIVE) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_OPENING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_CLOSING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_ACTIVE) == 0);
+
+    for (int i = 0; i < 3; i++)
+    {
+        timestamp_update();
+        __session_dispatch(session_manager_get_expired_session(mgr));
+        __session_dispatch(session_manager_get_evicted_session(mgr));
+        sleep(1);
+    }
+
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_OPENING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_CLOSING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_TCP, SESSION_STATE_ACTIVE) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_OPENING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_CLOSING) == 0);
+    EXPECT_TRUE(session_manager_get_session_number(mgr, SESSION_TYPE_UDP, SESSION_STATE_ACTIVE) == 0);
+
+    session_manager_destroy(mgr);
+}
+#endif
+
+int main(int argc, char **argv)
+{
+    ::testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+}

src/stellar/stellar.cpp

@@ -43,9 +43,34 @@ struct stellar_ctx
 } g_stellar_ctx = {
     .need_exit = 0,
     .max_worker_num = 1,
+    .sess_mgr_cfg = {
+        // max session number
+        .max_tcp_session_num = 3,
+        .max_udp_session_num = 3,
 
-    // TODO session manager config
+        // tcp timeout
-};
+        .tcp_timeout_init = 2,
+        .tcp_timeout_handshake = 2,
+        .tcp_timeout_data = 2,
+        .tcp_timeout_half_closed = 2,
+        .tcp_timeout_time_wait = 2,
+        .tcp_timeout_discard = 2,
+
+        // udp timeout
+        .udp_timeout_data = 1,
+
+        // tcp duplicate packet filter
+        .tcp_dupkt_filter_enable = 1,
+        .tcp_dupkt_filter_capacity = 1000,
+        .tcp_dupkt_filter_timeout = 10,
+        .tcp_dupkt_filter_error_rate = 0.0001,
+
+        // udp eviction filter
+        .udp_eviction_filter_enable = 1,
+        .udp_eviction_filter_capacity = 1000,
+        .udp_eviction_filter_timeout = 10,
+        .udp_eviction_filter_error_rate = 0.0001,
+    }};
 
 static int recv_packet(const char **data)
 {
@@ -90,13 +115,13 @@ static void __session_dispatch(struct session *sess)
     printf("\n");
     printf("=> session dispatch: %p\n", sess);
     session_dump(sess);
-    printf("<= session dispatch\n");
+    printf("<= session dispatch\n\n");
 
     session_set0_cur_pkt(sess, NULL);
     session_set_cur_dir(sess, SESSION_DIR_NONE);
 }
 
-static void thread_ctx_init(struct stellar_ctx *ctx)
+static int thread_ctx_init(struct stellar_ctx *ctx)
 {
     for (uint16_t i = 0; i < ctx->max_worker_num; i++)
     {
@@ -106,8 +131,14 @@ static void thread_ctx_init(struct stellar_ctx *ctx)
         thd_ctx->is_runing = 0;
 
         thd_ctx->sess_mgr = session_manager_create(&ctx->sess_mgr_cfg);
-        assert(thd_ctx->sess_mgr != NULL);
+        if (thd_ctx->sess_mgr == NULL)
+        {
+            STELLAR_LOG_ERROR("unable to create session manager");
+            return -1;
+        }
     }
+
+    return 0;
 }
 
 static void thread_ctx_free(struct stellar_ctx *ctx)
@@ -193,7 +224,11 @@ int main(int argc, char **argv)
 
     timestamp_update();
 
-    thread_ctx_init(&g_stellar_ctx);
+    if (thread_ctx_init(&g_stellar_ctx) != 0)
+    {
+        STELLAR_LOG_ERROR("unable to init thread context");
+        goto error_out;
+    }
 
     for (uint16_t i = 0; i < g_stellar_ctx.max_worker_num; i++)
     {