add session id generator

conf/stellar.toml

@@ -1,7 +1,11 @@
 [system]
 app_symbol = stellar
 dev_symbol = nf_0_fw
-nr_threads = 1
+
+device_base = 1   # [0, 31]
+device_offset = 2 # [0, 127]
+
+nr_threads = 1                         # [1, 256]
 cpu_mask = [5, 6, 7, 8, 9, 10, 11, 12]
 
 [session_manager]

src/CMakeLists.txt

@@ -2,6 +2,7 @@ add_subdirectory(log)
 add_subdirectory(timestamp)
 add_subdirectory(tuple)
 add_subdirectory(packet)
+add_subdirectory(id_generator)
 add_subdirectory(dupkt_filter)
 add_subdirectory(eviction_filter)
 add_subdirectory(session)

src/config/config.cpp

@@ -36,12 +36,33 @@ static int parse_system_section(struct config *cfg, toml_table_t *conf_file_hand
     }
     strncpy(cfg->sys_cfg.dev_symbol, ptr, sizeof(cfg->sys_cfg.dev_symbol) - 1);
 
+    ptr = toml_raw_in(system_table, "device_base");
+    if (ptr == NULL)
+    {
+        CONFIG_LOG_ERROR("config file missing system.device_base");
+        return -1;
+    }
+    cfg->sys_cfg.device_base = atoi(ptr);
+
+    ptr = toml_raw_in(system_table, "device_offset");
+    if (ptr == NULL)
+    {
+        CONFIG_LOG_ERROR("config file missing system.device_offset");
+        return -1;
+    }
+    cfg->sys_cfg.device_offset = atoi(ptr);
+
     ptr = toml_raw_in(system_table, "nr_threads");
     if (ptr == NULL)
     {
         CONFIG_LOG_ERROR("config file missing system.nr_threads");
         return -1;
     }
+    if (atoi(ptr) <= 0 || atoi(ptr) > MAX_THREAD_NUM)
+    {
+        CONFIG_LOG_ERROR("config file invalid system.nr_threads %d, range [1, %d]", atoi(ptr), MAX_THREAD_NUM);
+        return -1;
+    }
     cfg->sys_cfg.nr_threads = atoi(ptr);
 
     mask_array = toml_array_in(system_table, "cpu_mask");
@@ -50,7 +71,7 @@ static int parse_system_section(struct config *cfg, toml_table_t *conf_file_hand
         CONFIG_LOG_ERROR("config file missing system.cpu_mask");
         return -1;
     }
-    for (uint16_t i = 0; i < cfg->sys_cfg.nr_threads; i++)
+    for (uint8_t i = 0; i < cfg->sys_cfg.nr_threads; i++)
     {
         ptr = toml_raw_at(mask_array, i);
         if (ptr == NULL)
@@ -301,8 +322,10 @@ void config_dump(struct config *cfg)
 
     CONFIG_LOG_DEBUG("system.app_symbol       : %s", cfg->sys_cfg.app_symbol);
     CONFIG_LOG_DEBUG("system.dev_symbol       : %s", cfg->sys_cfg.dev_symbol);
+    CONFIG_LOG_DEBUG("system.device_base      : %d", cfg->sys_cfg.device_base);
+    CONFIG_LOG_DEBUG("system.device_offset    : %d", cfg->sys_cfg.device_offset);
     CONFIG_LOG_DEBUG("system.nr_threads       : %d", cfg->sys_cfg.nr_threads);
-    for (uint16_t i = 0; i < cfg->sys_cfg.nr_threads; i++)
+    for (uint8_t i = 0; i < cfg->sys_cfg.nr_threads; i++)
     {
         CONFIG_LOG_DEBUG("system.cpu_mask[%d]      : %d", i, cfg->sys_cfg.cpu_mask[i]);
     }

src/config/config.h

@@ -7,6 +7,7 @@ extern "C"
 #endif
 
 #include "session_manager.h"
+#include "stellar.h"
 
 #define CONFIG_LOG_ERROR(format, ...) LOG_ERROR("config", format, ##__VA_ARGS__)
 #ifndef CONFIG_LOG_ERROR
@@ -19,13 +20,15 @@ extern "C"
     fprintf(stderr, "DEBUG (config), " format "\n", ##__VA_ARGS__);
 #endif
 
-#define MAX_THREAD_NUM 256
-
 struct system_config
 {
     char app_symbol[64];
     char dev_symbol[64];
-    uint16_t nr_threads;
+
+    uint8_t device_base;
+    uint8_t device_offset;
+
+    uint8_t nr_threads;
     uint16_t cpu_mask[MAX_THREAD_NUM];
 };
 

src/id_generator/CMakeLists.txt

@@ -0,0 +1,8 @@
+###############################################################################
+# id_generator
+###############################################################################
+
+add_library(id_generator id_generator.cpp)
+target_include_directories(id_generator PUBLIC ${CMAKE_CURRENT_LIST_DIR})
+target_include_directories(id_generator PUBLIC ${CMAKE_SOURCE_DIR}/src/stellar)
+target_link_libraries(id_generator log timestamp)

src/id_generator/id_generator.cpp

@@ -0,0 +1,80 @@
+#include <string.h>
+
+#include "id_generator.h"
+#include "stellar.h"
+#include "timestamp.h"
+
+struct id_generator
+{
+    uint8_t device_base;   // 5bit  [0, 31]
+    uint8_t device_offset; // 7bit  [0, 127]
+    uint64_t device_id;    // 12bit [0, 4095] ( base << 7 | offset )
+    uint64_t thread_volatile[MAX_THREAD_NUM];
+};
+
+struct id_generator global_id_generator;
+
+/*
+ * device_base   (5bit)  : [0, 31]
+ * device_offset (7bit)  : [0, 127]
+ * device_id     (12bit) : (base << 7 | offset)
+ *
+ * return  0: success
+ * return -1: failed
+ */
+int id_generator_init(uint8_t device_base, uint8_t device_offset)
+{
+    memset(&global_id_generator, 0, sizeof(struct id_generator));
+
+    if (device_base > 31)
+    {
+        ID_GENERATOR_LOG_ERROR("device_base %u is invalid, range [0, 31]", device_base);
+        return -1;
+    }
+
+    if (device_offset > 127)
+    {
+        ID_GENERATOR_LOG_ERROR("device_offset %u is invalid, range [0, 127]", device_offset);
+        return -1;
+    }
+
+    global_id_generator.device_base = device_base;
+    global_id_generator.device_offset = device_offset;
+    global_id_generator.device_id = ((global_id_generator.device_base << 7) | global_id_generator.device_offset) & 0xFFF;
+
+    ID_GENERATOR_LOG_DEBUG("device_base: %u, device_offset: %u, device_id: %u",
+                           global_id_generator.device_base,
+                           global_id_generator.device_offset,
+                           global_id_generator.device_id);
+    return 0;
+}
+
+void id_generator_free()
+{
+    memset(&global_id_generator, 0, sizeof(struct id_generator));
+}
+
+/*
+ * 高位 --- 低位
+ *
+ * +------+------------------+----------------+------------------------+---------------------------+
+ * | 1bit |  12bit device_id | 8bit thread_id | 28bit timestamp in sec | 15bit sequence per thread |
+ * +------+------------------+----------------+------------------------+---------------------------+
+ */
+uint64_t id_generator_get()
+{
+#define MAX_ID_PER_THREAD (32768)
+#define MAX_ID_BASE_TIME (268435456L)
+
+    uint64_t global_id = 0;
+    uint64_t thread_index = stellar_get_current_thread_index();
+
+    uint64_t id_per_thread = (global_id_generator.thread_volatile[thread_index]++) % MAX_ID_PER_THREAD;
+    uint64_t id_base_time = timestamp_get_sec() % MAX_ID_BASE_TIME;
+    global_id = (global_id_generator.device_id << 51) |
+                (thread_index << 43) |
+                (id_base_time << 15) |
+                (id_per_thread);
+
+    return global_id;
+}

src/id_generator/id_generator.h

@@ -0,0 +1,32 @@
+#ifndef _ID_GENERATOR_H
+#define _ID_GENERATOR_H
+
+#ifdef __cpluscplus
+extern "C"
+{
+#endif
+
+#include <stdint.h>
+
+#include "log.h"
+
+#define ID_GENERATOR_LOG_ERROR(format, ...) LOG_ERROR("id generator", format, ##__VA_ARGS__)
+#define ID_GENERATOR_LOG_DEBUG(format, ...) LOG_DEBUG("id generator", format, ##__VA_ARGS__)
+
+/*
+ * device_base   (5bit)  : [0, 31]
+ * device_offset (7bit)  : [0, 127]
+ * device_id     (12bit) : (base << 7 | offset)
+ *
+ * return  0: success
+ * return -1: failed
+ */
+int id_generator_init(uint8_t device_base, uint8_t device_offset);
+void id_generator_free();
+uint64_t id_generator_get();
+
+#ifdef __cpluscplus
+}
+#endif
+
+#endif

src/log/log.cpp

@@ -6,6 +6,7 @@
 #include <stdarg.h>
 #include <time.h>
 #include <stdlib.h>
+#include <pthread.h>
 
 #include "log.h"
 #include "toml.h"
@@ -276,6 +277,8 @@ void log_print(enum log_level level, const char *module, const char *fmt, ...)
     // add time
     p += snprintf(p, end - p, "%s %s %d %02d:%02d:%02d %d ",
                   weekday_str[local.tm_wday], month_str[local.tm_mon], local.tm_mday, local.tm_hour, local.tm_min, local.tm_sec, local.tm_year + 1900);
+    // add tid
+    p += snprintf(p, end - p, "%lu ", pthread_self());
     // add level
     p += snprintf(p, end - p, "%s ", level_str[level]);
     // add module

src/session/CMakeLists.txt

@@ -11,6 +11,6 @@ add_library(session_manager
     session_manager.cpp
 )
 target_include_directories(session_manager PUBLIC ${CMAKE_CURRENT_LIST_DIR})
-target_link_libraries(session_manager timeout dupkt_filter eviction_filter log)
+target_link_libraries(session_manager timeout dupkt_filter eviction_filter log id_generator)
 
 add_subdirectory(test)

src/session/session.cpp

@@ -475,17 +475,17 @@ const char *session_closing_reasion_tostring(enum closing_reasion reasion)
     switch (reasion)
     {
     case CLOSING_BY_TIMEOUT:
-        return "closing_by_timeout";
+        return "CLOSING BY TIMEOUT";
     case CLOSING_BY_EVICTED:
-        return "closing_by_evicted";
+        return "CLOSING BY EVICTED";
     case CLOSING_BY_CLIENT_FIN:
-        return "closing_by_client_fin";
+        return "CLOSING BY CLIENT FIN";
     case CLOSING_BY_CLIENT_RST:
-        return "closing_by_client_rst";
+        return "CLOSING BY CLIENT RST";
     case CLOSING_BY_SERVER_FIN:
-        return "closing_by_server_fin";
+        return "CLOSING BY SERVER FIN";
     case CLOSING_BY_SERVER_RST:
-        return "closing_by_server_rst";
+        return "CLOSING BY SERVER RST";
     default:
         return "unknown";
     }

src/session/session_manager.cpp

@@ -13,6 +13,7 @@
 #include "packet_helpers.h"
 #include "dupkt_filter.h"
 #include "eviction_filter.h"
+#include "id_generator.h"
 
 struct session_manager
 {
@@ -58,54 +59,54 @@ struct session_manager
      uint64_t npkts_hit_udp_evicted; // fast forward
 };
 
-static void tcp_init_timeout_cb(struct session *sess, void *arg);
+static inline void tcp_init_timeout_cb(struct session *sess, void *arg);
-static void tcp_handshake_timeout_cb(struct session *sess, void *arg);
+static inline void tcp_handshake_timeout_cb(struct session *sess, void *arg);
-static void tcp_data_timeout_cb(struct session *sess, void *arg);
+static inline void tcp_data_timeout_cb(struct session *sess, void *arg);
-static void tcp_half_closed_timeout_cb(struct session *sess, void *arg);
+static inline void tcp_half_closed_timeout_cb(struct session *sess, void *arg);
-static void tcp_time_wait_timeout_cb(struct session *sess, void *arg);
+static inline void tcp_time_wait_timeout_cb(struct session *sess, void *arg);
-static void udp_data_timeout_cb(struct session *sess, void *arg);
+static inline void udp_data_timeout_cb(struct session *sess, void *arg);
 
-static int session_manager_check_config(struct session_manager_config *config);
+static inline int session_manager_check_config(struct session_manager_config *config);
-static uint64_t session_manager_alloc_session_id(void);
+static inline uint64_t session_manager_alloc_session_id(void);
-static int session_manager_update_tcp_filter(struct session_manager *mgr, struct session *sess, const struct packet *pkt, enum session_dir curr_dir);
+static inline int session_manager_update_tcp_filter(struct session_manager *mgr, struct session *sess, const struct packet *pkt, enum session_dir curr_dir);
 
-static enum session_dir judge_direction_by_tuple6(const struct tuple6 *key);
+static inline enum session_dir judge_direction_by_tuple6(const struct tuple6 *key);
-static enum session_dir judge_direction_by_session(const struct session *sess, const struct tuple6 *key);
+static inline enum session_dir judge_direction_by_session(const struct session *sess, const struct tuple6 *key);
 
-static void session_update_tcp_state(struct session *sess, const struct layer_record *tcp_layer, enum session_dir curr_dir);
+static inline void session_update_tcp_state(struct session *sess, const struct layer_record *tcp_layer, enum session_dir curr_dir);
-static void session_update_udp_state(struct session *sess, const struct layer_record *udp_layer, enum session_dir curr_dir);
+static inline void session_update_udp_state(struct session *sess, const struct layer_record *udp_layer, enum session_dir curr_dir);
 
-static void session_manager_update_session_state(struct session_manager *mgr, struct session *sess, enum session_state state);
+static inline void session_manager_update_session_state(struct session_manager *mgr, struct session *sess, enum session_state state);
-static void session_manager_update_session_timer(struct session_manager *mgr, struct session *sess, session_expire_cb expire_cb, uint64_t timeout_sec);
+static inline void session_manager_update_session_timer(struct session_manager *mgr, struct session *sess, session_expire_cb expire_cb, uint64_t timeout_sec);
-static void session_manager_update_session_base(struct session_manager *mgr, struct session *sess, const struct tuple6 *key, enum session_dir curr_dir);
+static inline void session_manager_update_session_base(struct session_manager *mgr, struct session *sess, const struct tuple6 *key, enum session_dir curr_dir);
-static void session_manager_update_session_packet(struct session_manager *mgr, struct session *sess, const struct packet *pkt, enum session_dir curr_dir);
+static inline void session_manager_update_session_packet(struct session_manager *mgr, struct session *sess, const struct packet *pkt, enum session_dir curr_dir);
 
-static void session_manager_update_udp_to_opening(struct session_manager *mgr, struct session *sess);
+static inline void session_manager_update_udp_to_opening(struct session_manager *mgr, struct session *sess);
-static void session_manager_update_udp_to_active(struct session_manager *mgr, struct session *sess);
+static inline void session_manager_update_udp_to_active(struct session_manager *mgr, struct session *sess);
-static void session_manager_update_udp_to_closing(struct session_manager *mgr, struct session *sess);
+static inline void session_manager_update_udp_to_closing(struct session_manager *mgr, struct session *sess);
-static void session_manager_update_tcp_to_opening(struct session_manager *mgr, struct session *sess, int opening_by_syn);
+static inline void session_manager_update_tcp_to_opening(struct session_manager *mgr, struct session *sess, int opening_by_syn);
-static void session_manager_update_tcp_to_active(struct session_manager *mgr, struct session *sess);
+static inline void session_manager_update_tcp_to_active(struct session_manager *mgr, struct session *sess);
-static void session_manager_update_tcp_to_closing(struct session_manager *mgr, struct session *sess, int enable_time_wait);
+static inline void session_manager_update_tcp_to_closing(struct session_manager *mgr, struct session *sess, int enable_time_wait);
-static void session_manager_update_session_to_closed(struct session_manager *mgr, struct session *sess);
+static inline void session_manager_update_session_to_closed(struct session_manager *mgr, struct session *sess);
 
-static void session_manager_handle_tcp_on_opening(struct session_manager *mgr, struct session *sess, enum tcp_state tcp_old_state, enum tcp_state tcp_curr_state);
+static inline void session_manager_handle_tcp_on_opening(struct session_manager *mgr, struct session *sess, enum tcp_state tcp_old_state, enum tcp_state tcp_curr_state);
-static void session_manager_handle_tcp_on_active(struct session_manager *mgr, struct session *sess, enum tcp_state tcp_old_state, enum tcp_state tcp_curr_state);
+static inline void session_manager_handle_tcp_on_active(struct session_manager *mgr, struct session *sess, enum tcp_state tcp_old_state, enum tcp_state tcp_curr_state);
-static void session_manager_handle_tcp_on_closing(struct session_manager *mgr, struct session *sess, enum tcp_state tcp_old_state, enum tcp_state tcp_curr_state);
+static inline void session_manager_handle_tcp_on_closing(struct session_manager *mgr, struct session *sess, enum tcp_state tcp_old_state, enum tcp_state tcp_curr_state);
 
-static struct session *session_manager_new_tcp_session(struct session_manager *mgr, const struct packet *pkt, const struct tuple6 *key);
+static inline struct session *session_manager_new_tcp_session(struct session_manager *mgr, const struct packet *pkt, const struct tuple6 *key);
-static struct session *session_manager_new_udp_session(struct session_manager *mgr, const struct packet *pkt, const struct tuple6 *key);
+static inline struct session *session_manager_new_udp_session(struct session_manager *mgr, const struct packet *pkt, const struct tuple6 *key);
-static struct session *session_manager_update_tcp_session(struct session_manager *mgr, struct session *sess, const struct packet *pkt, const struct tuple6 *key);
+static inline struct session *session_manager_update_tcp_session(struct session_manager *mgr, struct session *sess, const struct packet *pkt, const struct tuple6 *key);
-static struct session *session_manager_update_udp_session(struct session_manager *mgr, struct session *sess, const struct packet *pkt, const struct tuple6 *key);
+static inline struct session *session_manager_update_udp_session(struct session_manager *mgr, struct session *sess, const struct packet *pkt, const struct tuple6 *key);
 
-static void session_manager_free_session(struct session_manager *mgr, struct session *sess);
+static inline void session_manager_free_session(struct session_manager *mgr, struct session *sess);
-static void session_manager_recycle_session(struct session_manager *mgr);
+static inline void session_manager_recycle_session(struct session_manager *mgr);
-static void session_manager_evicte_session(struct session_manager *mgr, struct session *sess);
+static inline void session_manager_evicte_session(struct session_manager *mgr, struct session *sess);
 
 /******************************************************************************
  * Private API
  ******************************************************************************/
 
-static void tcp_init_timeout_cb(struct session *sess, void *arg)
+static inline void tcp_init_timeout_cb(struct session *sess, void *arg)
 {
      SESSION_LOG_DEBUG("run tcp_init_timeout_cb on session %lu", session_get_id(sess));
      struct session_manager *mgr = (struct session_manager *)arg;
@@ -118,7 +119,7 @@ static void tcp_init_timeout_cb(struct session *sess, void *arg)
      session_manager_update_tcp_to_closing(mgr, sess, 1);
 }
 
-static void tcp_handshake_timeout_cb(struct session *sess, void *arg)
+static inline void tcp_handshake_timeout_cb(struct session *sess, void *arg)
 {
      SESSION_LOG_DEBUG("run tcp_handshake_timeout_cb on session %lu", session_get_id(sess));
      struct session_manager *mgr = (struct session_manager *)arg;
@@ -131,7 +132,7 @@ static void tcp_handshake_timeout_cb(struct session *sess, void *arg)
      session_manager_update_tcp_to_closing(mgr, sess, 1);
 }
 
-static void tcp_data_timeout_cb(struct session *sess, void *arg)
+static inline void tcp_data_timeout_cb(struct session *sess, void *arg)
 {
      SESSION_LOG_DEBUG("run tcp_data_timeout_cb on session %lu", session_get_id(sess));
      struct session_manager *mgr = (struct session_manager *)arg;
@@ -144,7 +145,7 @@ static void tcp_data_timeout_cb(struct session *sess, void *arg)
      session_manager_update_tcp_to_closing(mgr, sess, 1);
 }
 
-static void tcp_half_closed_timeout_cb(struct session *sess, void *arg)
+static inline void tcp_half_closed_timeout_cb(struct session *sess, void *arg)
 {
      SESSION_LOG_DEBUG("run tcp_half_closed_timeout_cb on session %lu", session_get_id(sess));
      struct session_manager *mgr = (struct session_manager *)arg;
@@ -157,7 +158,7 @@ static void tcp_half_closed_timeout_cb(struct session *sess, void *arg)
      session_manager_update_tcp_to_closing(mgr, sess, 1);
 }
 
-static void tcp_time_wait_timeout_cb(struct session *sess, void *arg)
+static inline void tcp_time_wait_timeout_cb(struct session *sess, void *arg)
 {
      SESSION_LOG_DEBUG("run tcp_time_wait_timeout_cb on session %lu", session_get_id(sess));
      struct session_manager *mgr = (struct session_manager *)arg;
@@ -166,7 +167,7 @@ static void tcp_time_wait_timeout_cb(struct session *sess, void *arg)
      session_manager_free_session(mgr, sess);
 }
 
-static void udp_data_timeout_cb(struct session *sess, void *arg)
+static inline void udp_data_timeout_cb(struct session *sess, void *arg)
 {
      SESSION_LOG_DEBUG("run udp_data_timeout_cb on session %lu", session_get_id(sess));
      struct session_manager *mgr = (struct session_manager *)arg;
@@ -181,7 +182,7 @@ static void udp_data_timeout_cb(struct session *sess, void *arg)
 
 // return  0: success
 // return -1: invalid config
-static int session_manager_check_config(struct session_manager_config *config)
+static inline int session_manager_check_config(struct session_manager_config *config)
 {
      if (config == NULL)
      {
@@ -306,15 +307,14 @@ static int session_manager_check_config(struct session_manager_config *config)
      return 0;
 }
 
-// TODO
+static inline uint64_t session_manager_alloc_session_id(void)
-static uint64_t session_manager_alloc_session_id(void)
 {
-     return 0;
+     return id_generator_get();
 }
 
 // return 1: duplicate packet
 // return 0: not duplicate packet
-static int session_manager_update_tcp_filter(struct session_manager *mgr, struct session *sess, const struct packet *pkt, enum session_dir curr_dir)
+static inline int session_manager_update_tcp_filter(struct session_manager *mgr, struct session *sess, const struct packet *pkt, enum session_dir curr_dir)
 {
      if (curr_dir == SESSION_DIR_C2S)
      {
@@ -352,7 +352,7 @@ dupkt_fitler:
      }
 }
 
-static enum session_dir judge_direction_by_tuple6(const struct tuple6 *key)
+static inline enum session_dir judge_direction_by_tuple6(const struct tuple6 *key)
 {
      uint16_t src_port = ntohs(key->src_port);
      uint16_t dst_port = ntohs(key->dst_port);
@@ -374,7 +374,7 @@ static enum session_dir judge_direction_by_tuple6(const struct tuple6 *key)
      }
 }
 
-static enum session_dir judge_direction_by_session(const struct session *sess, const struct tuple6 *key)
+static inline enum session_dir judge_direction_by_session(const struct session *sess, const struct tuple6 *key)
 {
      if (tuple6_cmp(session_get0_key(sess), key) == 0)
      {
@@ -386,7 +386,7 @@ static enum session_dir judge_direction_by_session(const struct session *sess, c
      }
 }
 
-static void session_update_tcp_state(struct session *sess, const struct layer_record *tcp_layer, enum session_dir curr_dir)
+static inline void session_update_tcp_state(struct session *sess, const struct layer_record *tcp_layer, enum session_dir curr_dir)
 {
      const struct tcphdr *hdr = (const struct tcphdr *)tcp_layer->hdr_ptr;
      uint64_t state = session_get_tcp_state(sess);
@@ -445,7 +445,7 @@ static void session_update_tcp_state(struct session *sess, const struct layer_re
      session_set_tcp_state(sess, (enum tcp_state)state);
 }
 
-static void session_update_udp_state(struct session *sess, const struct layer_record *udp_layer, enum session_dir curr_dir)
+static inline void session_update_udp_state(struct session *sess, const struct layer_record *udp_layer, enum session_dir curr_dir)
 {
      uint64_t state = session_get_udp_state(sess);
      if (curr_dir == SESSION_DIR_C2S)
@@ -487,7 +487,7 @@ on closing update session
 [*] session_set_closing_reasion
 */
 
-static void session_manager_update_session_state(struct session_manager *mgr, struct session *sess, enum session_state state)
+static inline void session_manager_update_session_state(struct session_manager *mgr, struct session *sess, enum session_state state)
 {
      // session state not change
      if (session_get_state(sess) == state)
@@ -582,14 +582,14 @@ static void session_manager_update_session_state(struct session_manager *mgr, st
      session_set_state(sess, state);
 }
 
-static void session_manager_update_session_timer(struct session_manager *mgr, struct session *sess, session_expire_cb expire_cb, uint64_t timeout_sec)
+static inline void session_manager_update_session_timer(struct session_manager *mgr, struct session *sess, session_expire_cb expire_cb, uint64_t timeout_sec)
 {
      session_timer_del_session(mgr->sess_timer, sess);
      session_set_expirecb(sess, expire_cb, mgr, timestamp_get_sec() + timeout_sec);
      session_timer_add_session(mgr->sess_timer, sess);
 }
 
-static void session_manager_update_session_base(struct session_manager *mgr, struct session *sess, const struct tuple6 *key, enum session_dir curr_dir)
+static inline void session_manager_update_session_base(struct session_manager *mgr, struct session *sess, const struct tuple6 *key, enum session_dir curr_dir)
 {
      session_init(sess);
      session_set_id(sess, session_manager_alloc_session_id());
@@ -606,7 +606,7 @@ static void session_manager_update_session_base(struct session_manager *mgr, str
      session_set_create_time(sess, timestamp_get_sec());
 }
 
-static void session_manager_update_session_packet(struct session_manager *mgr, struct session *sess, const struct packet *pkt, enum session_dir curr_dir)
+static inline void session_manager_update_session_packet(struct session_manager *mgr, struct session *sess, const struct packet *pkt, enum session_dir curr_dir)
 {
      uint64_t len = packet_get_raw_len(pkt);
      if (curr_dir == SESSION_DIR_C2S)
@@ -630,19 +630,19 @@ static void session_manager_update_session_packet(struct session_manager *mgr, s
      session_set_last_time(sess, timestamp_get_sec());
 }
 
-static void session_manager_update_udp_to_opening(struct session_manager *mgr, struct session *sess)
+static inline void session_manager_update_udp_to_opening(struct session_manager *mgr, struct session *sess)
 {
      session_manager_update_session_state(mgr, sess, SESSION_STATE_OPENING);
      session_manager_update_session_timer(mgr, sess, udp_data_timeout_cb, mgr->config.udp_timeout_data);
 }
 
-static void session_manager_update_udp_to_active(struct session_manager *mgr, struct session *sess)
+static inline void session_manager_update_udp_to_active(struct session_manager *mgr, struct session *sess)
 {
      session_manager_update_session_state(mgr, sess, SESSION_STATE_ACTIVE);
      session_manager_update_session_timer(mgr, sess, udp_data_timeout_cb, mgr->config.udp_timeout_data);
 }
 
-static void session_manager_update_udp_to_closing(struct session_manager *mgr, struct session *sess)
+static inline void session_manager_update_udp_to_closing(struct session_manager *mgr, struct session *sess)
 {
      session_manager_update_session_state(mgr, sess, SESSION_STATE_CLOSING);
      session_timer_del_session(mgr->sess_timer, sess);
@@ -650,7 +650,7 @@ static void session_manager_update_udp_to_closing(struct session_manager *mgr, s
      eviction_filter_add(mgr->udp_eviction_filter, session_get0_1st_pkt(sess));
 }
 
-static void session_manager_update_tcp_to_opening(struct session_manager *mgr, struct session *sess, int opening_by_syn)
+static inline void session_manager_update_tcp_to_opening(struct session_manager *mgr, struct session *sess, int opening_by_syn)
 {
      session_manager_update_session_state(mgr, sess, SESSION_STATE_OPENING);
      if (opening_by_syn)
@@ -663,13 +663,13 @@ static void session_manager_update_tcp_to_opening(struct session_manager *mgr, s
      }
 }
 
-static void session_manager_update_tcp_to_active(struct session_manager *mgr, struct session *sess)
+static inline void session_manager_update_tcp_to_active(struct session_manager *mgr, struct session *sess)
 {
      session_manager_update_session_state(mgr, sess, SESSION_STATE_ACTIVE);
      session_manager_update_session_timer(mgr, sess, tcp_data_timeout_cb, mgr->config.tcp_timeout_data);
 }
 
-static void session_manager_update_tcp_to_closing(struct session_manager *mgr, struct session *sess, int enable_time_wait)
+static inline void session_manager_update_tcp_to_closing(struct session_manager *mgr, struct session *sess, int enable_time_wait)
 {
      session_manager_update_session_state(mgr, sess, SESSION_STATE_CLOSING);
      if (enable_time_wait)
@@ -682,7 +682,7 @@ static void session_manager_update_tcp_to_closing(struct session_manager *mgr, s
      }
 }
 
-static void session_manager_update_session_to_closed(struct session_manager *mgr, struct session *sess)
+static inline void session_manager_update_session_to_closed(struct session_manager *mgr, struct session *sess)
 {
      session_manager_update_session_state(mgr, sess, SESSION_STATE_CLOSED);
      session_timer_del_session(mgr->sess_timer, sess);
@@ -691,7 +691,7 @@ static void session_manager_update_session_to_closed(struct session_manager *mgr
 // opening -> opening
 // opening -> active
 // opening -> closing
-static void session_manager_handle_tcp_on_opening(struct session_manager *mgr, struct session *sess, enum tcp_state tcp_old_state, enum tcp_state tcp_curr_state)
+static inline void session_manager_handle_tcp_on_opening(struct session_manager *mgr, struct session *sess, enum tcp_state tcp_old_state, enum tcp_state tcp_curr_state)
 {
      uint64_t tcp_mod_state = tcp_curr_state & (~tcp_old_state);
 
@@ -760,7 +760,7 @@ static void session_manager_handle_tcp_on_opening(struct session_manager *mgr, s
 
 // active -> active
 // active -> closing
-static void session_manager_handle_tcp_on_active(struct session_manager *mgr, struct session *sess, enum tcp_state tcp_old_state, enum tcp_state tcp_curr_state)
+static inline void session_manager_handle_tcp_on_active(struct session_manager *mgr, struct session *sess, enum tcp_state tcp_old_state, enum tcp_state tcp_curr_state)
 {
      // active -> closing
      if ((tcp_curr_state & TCP_C2S_FIN_RECVED) && (tcp_curr_state & TCP_S2C_FIN_RECVED))
@@ -793,13 +793,13 @@ static void session_manager_handle_tcp_on_active(struct session_manager *mgr, st
 
 // closing -> closing
 // closing -> closed
-static void session_manager_handle_tcp_on_closing(struct session_manager *mgr, struct session *sess, enum tcp_state tcp_old_state, enum tcp_state tcp_curr_state)
+static inline void session_manager_handle_tcp_on_closing(struct session_manager *mgr, struct session *sess, enum tcp_state tcp_old_state, enum tcp_state tcp_curr_state)
 {
      // still closing
      session_manager_update_tcp_to_closing(mgr, sess, 1);
 }
 
-static struct session *session_manager_new_tcp_session(struct session_manager *mgr, const struct packet *pkt, const struct tuple6 *key)
+static inline struct session *session_manager_new_tcp_session(struct session_manager *mgr, const struct packet *pkt, const struct tuple6 *key)
 {
      const struct layer_record *tcp_layer = packet_get_innermost_layer(pkt, LAYER_TYPE_TCP);
      if (tcp_layer == NULL)
@@ -846,7 +846,11 @@ static struct session *session_manager_new_tcp_session(struct session_manager *m
      session_manager_update_session_packet(mgr, sess, pkt, curr_dir);
      session_update_tcp_state(sess, tcp_layer, curr_dir);
 
+     char buffer[128] = {0};
+     tuple6_tostring(session_get0_key(sess), buffer, sizeof(buffer));
+     SESSION_LOG_DEBUG("session new: %lu %s", session_get_id(sess), buffer);
      SESSION_LOG_DEBUG("TCP %s received, session %lu init -> opening", (curr_dir == SESSION_DIR_C2S ? "SYN" : "SYNACK"), session_get_id(sess));
+
      session_manager_update_tcp_to_opening(mgr, sess, curr_dir == SESSION_DIR_C2S);
      session_table_add_session(mgr->tcp_sess_table, key, sess);
      dupkt_filter_add(mgr->tcp_dupkt_filter, pkt);
@@ -854,7 +858,7 @@ static struct session *session_manager_new_tcp_session(struct session_manager *m
      return sess;
 }
 
-static struct session *session_manager_new_udp_session(struct session_manager *mgr, const struct packet *pkt, const struct tuple6 *key)
+static inline struct session *session_manager_new_udp_session(struct session_manager *mgr, const struct packet *pkt, const struct tuple6 *key)
 {
      if (eviction_filter_lookup(mgr->udp_eviction_filter, pkt))
      {
@@ -895,10 +899,15 @@ static struct session *session_manager_new_udp_session(struct session_manager *m
      session_manager_update_udp_to_opening(mgr, sess);
      session_table_add_session(mgr->udp_sess_table, key, sess);
 
+     char buffer[128] = {0};
+     tuple6_tostring(session_get0_key(sess), buffer, sizeof(buffer));
+     SESSION_LOG_DEBUG("session new: %lu %s", session_get_id(sess), buffer);
+     SESSION_LOG_DEBUG("UDP %s first packet received, session %lu init -> opening", (curr_dir == SESSION_DIR_C2S ? "C2S" : "S2C"), session_get_id(sess));
+
      return sess;
 }
 
-static struct session *session_manager_update_tcp_session(struct session_manager *mgr, struct session *sess, const struct packet *pkt, const struct tuple6 *key)
+static inline struct session *session_manager_update_tcp_session(struct session_manager *mgr, struct session *sess, const struct packet *pkt, const struct tuple6 *key)
 {
      const struct layer_record *tcp_layer = packet_get_innermost_layer(pkt, LAYER_TYPE_TCP);
      if (tcp_layer == NULL)
@@ -942,7 +951,7 @@ static struct session *session_manager_update_tcp_session(struct session_manager
      return sess;
 }
 
-static struct session *session_manager_update_udp_session(struct session_manager *mgr, struct session *sess, const struct packet *pkt, const struct tuple6 *key)
+static inline struct session *session_manager_update_udp_session(struct session_manager *mgr, struct session *sess, const struct packet *pkt, const struct tuple6 *key)
 {
      enum session_dir curr_dir = judge_direction_by_session(sess, key);
      session_manager_update_session_packet(mgr, sess, pkt, curr_dir);
@@ -968,7 +977,7 @@ static struct session *session_manager_update_udp_session(struct session_manager
      return sess;
 }
 
-static void session_manager_free_session(struct session_manager *mgr, struct session *sess)
+static inline void session_manager_free_session(struct session_manager *mgr, struct session *sess)
 {
      if (sess)
      {
@@ -990,7 +999,7 @@ static void session_manager_free_session(struct session_manager *mgr, struct ses
      }
 }
 
-static void session_manager_recycle_session(struct session_manager *mgr)
+static inline void session_manager_recycle_session(struct session_manager *mgr)
 {
      while (1)
      {
@@ -1003,7 +1012,7 @@ static void session_manager_recycle_session(struct session_manager *mgr)
      }
 }
 
-static void session_manager_evicte_session(struct session_manager *mgr, struct session *sess)
+static inline void session_manager_evicte_session(struct session_manager *mgr, struct session *sess)
 {
      session_set_closing_reasion(sess, CLOSING_BY_EVICTED);
      session_manager_update_session_state(mgr, sess, SESSION_STATE_CLOSING);
@@ -1091,8 +1100,32 @@ error:
 
 void session_manager_destroy(struct session_manager *mgr)
 {
+     struct session *sess;
      if (mgr)
      {
+          // move all evicted session to closed queue
+          while (mgr->sess_evicted_queue && session_manager_get_evicted_session(mgr))
+          {
+          }
+
+          // free all closed queue
+          if (mgr->sess_toclosed_queue)
+          {
+               session_manager_recycle_session(mgr);
+          }
+
+          // free all udp session which is not in closed state
+          while (mgr->udp_sess_table && (sess = session_table_find_least_recently_unused_session(mgr->udp_sess_table)))
+          {
+               session_manager_free_session(mgr, sess);
+          }
+
+          // free all tcp session which is not in closed state
+          while (mgr->tcp_sess_table && (sess = session_table_find_least_recently_unused_session(mgr->tcp_sess_table)))
+          {
+               session_manager_free_session(mgr, sess);
+          }
+
           eviction_filter_destroy(mgr->udp_eviction_filter);
           dupkt_filter_destroy(mgr->tcp_dupkt_filter);
           session_queue_destroy(mgr->sess_toclosed_queue);

src/session/test/gtest_state_tcp_active_to_closing.cpp

@@ -14,7 +14,7 @@ static void build_active_tcp_session(struct session_manager *mgr, struct session
     sess = session_manager_update_session(mgr, &pkt);
     EXPECT_TRUE(sess);
 
-    EXPECT_TRUE(session_get_id(sess) == 0);
+    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);
@@ -49,7 +49,7 @@ static void build_active_tcp_session(struct session_manager *mgr, struct session
     sess = session_manager_update_session(mgr, &pkt);
     EXPECT_TRUE(sess);
 
-    EXPECT_TRUE(session_get_id(sess) == 0);
+    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);
@@ -104,7 +104,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_FIN_FIN)
     sess = session_manager_update_session(mgr, &pkt);
     EXPECT_TRUE(sess);
 
-    EXPECT_TRUE(session_get_id(sess) == 0);
+    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);
@@ -138,7 +138,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_FIN_FIN)
     sess = session_manager_update_session(mgr, &pkt);
     EXPECT_TRUE(sess);
 
-    EXPECT_TRUE(session_get_id(sess) == 0);
+    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);
@@ -202,7 +202,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_RST)
     sess = session_manager_update_session(mgr, &pkt);
     EXPECT_TRUE(sess);
 
-    EXPECT_TRUE(session_get_id(sess) == 0);
+    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);
@@ -266,7 +266,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_RST)
     sess = session_manager_update_session(mgr, &pkt);
     EXPECT_TRUE(sess);
 
-    EXPECT_TRUE(session_get_id(sess) == 0);
+    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);
@@ -349,7 +349,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_HALF_CLOSED_TIMEOUT)
     sess = session_manager_update_session(mgr, &pkt);
     EXPECT_TRUE(sess);
 
-    EXPECT_TRUE(session_get_id(sess) == 0);
+    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);
@@ -406,7 +406,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_HALF_CLOSED_TIMEOUT)
     sess = session_manager_update_session(mgr, &pkt);
     EXPECT_TRUE(sess);
 
-    EXPECT_TRUE(session_get_id(sess) == 0);
+    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);

src/session/test/gtest_state_tcp_init_to_opening.cpp

@@ -26,7 +26,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN)
     sess = session_manager_update_session(mgr, &pkt);
     EXPECT_TRUE(sess);
 
-    EXPECT_TRUE(session_get_id(sess) == 0);
+    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);
@@ -81,7 +81,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK)
     sess = session_manager_update_session(mgr, &pkt);
     EXPECT_TRUE(sess);
 
-    EXPECT_TRUE(session_get_id(sess) == 0);
+    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);
@@ -136,7 +136,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK)
     sess = session_manager_update_session(mgr, &pkt);
     EXPECT_TRUE(sess);
 
-    EXPECT_TRUE(session_get_id(sess) == 0);
+    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);
@@ -171,7 +171,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK)
     sess = session_manager_update_session(mgr, &pkt);
     EXPECT_TRUE(sess);
 
-    EXPECT_TRUE(session_get_id(sess) == 0);
+    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);
@@ -226,7 +226,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK_ACK)
     sess = session_manager_update_session(mgr, &pkt);
     EXPECT_TRUE(sess);
 
-    EXPECT_TRUE(session_get_id(sess) == 0);
+    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);
@@ -261,7 +261,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK_ACK)
     sess = session_manager_update_session(mgr, &pkt);
     EXPECT_TRUE(sess);
 
-    EXPECT_TRUE(session_get_id(sess) == 0);
+    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);
@@ -296,7 +296,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK_ACK)
     sess = session_manager_update_session(mgr, &pkt);
     EXPECT_TRUE(sess);
 
-    EXPECT_TRUE(session_get_id(sess) == 0);
+    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);
@@ -352,7 +352,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_RETRANSMISSION)
     sess = session_manager_update_session(mgr, &pkt);
     EXPECT_TRUE(sess);
 
-    EXPECT_TRUE(session_get_id(sess) == 0);
+    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);
@@ -393,7 +393,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_RETRANSMISSION)
     sess = session_manager_update_session(mgr, &pkt);
     EXPECT_TRUE(sess);
 
-    EXPECT_TRUE(session_get_id(sess) == 0);
+    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);
@@ -450,7 +450,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK_RETRANSMISSION)
     sess = session_manager_update_session(mgr, &pkt);
     EXPECT_TRUE(sess);
 
-    EXPECT_TRUE(session_get_id(sess) == 0);
+    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);
@@ -491,7 +491,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK_RETRANSMISSION)
     sess = session_manager_update_session(mgr, &pkt);
     EXPECT_TRUE(sess);
 
-    EXPECT_TRUE(session_get_id(sess) == 0);
+    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);
@@ -546,7 +546,7 @@ TEST(TCP_INIT_TO_OPENING, BY_C2S_ASMMETRIC)
     sess = session_manager_update_session(mgr, &pkt);
     EXPECT_TRUE(sess);
 
-    EXPECT_TRUE(session_get_id(sess) == 0);
+    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);
@@ -581,7 +581,7 @@ TEST(TCP_INIT_TO_OPENING, BY_C2S_ASMMETRIC)
     sess = session_manager_update_session(mgr, &pkt);
     EXPECT_TRUE(sess);
 
-    EXPECT_TRUE(session_get_id(sess) == 0);
+    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);
@@ -636,7 +636,7 @@ TEST(TCP_INIT_TO_OPENING, BY_S2C_ASMMETRIC)
     sess = session_manager_update_session(mgr, &pkt);
     EXPECT_TRUE(sess);
 
-    EXPECT_TRUE(session_get_id(sess) == 0);
+    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);
@@ -671,7 +671,7 @@ TEST(TCP_INIT_TO_OPENING, BY_S2C_ASMMETRIC)
     sess = session_manager_update_session(mgr, &pkt);
     EXPECT_TRUE(sess);
 
-    EXPECT_TRUE(session_get_id(sess) == 0);
+    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);

src/session/test/gtest_state_tcp_init_to_opening_to_active_to_closing_to_closed.cpp

@@ -22,7 +22,7 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
     sess = session_manager_update_session(mgr, &pkt);
     EXPECT_TRUE(sess);
 
-    EXPECT_TRUE(session_get_id(sess) == 0);
+    EXPECT_TRUE(session_get_id(sess) != 0);
     memset(buffer, 0, sizeof(buffer));
     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");
@@ -58,7 +58,7 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
     sess = session_manager_update_session(mgr, &pkt);
     EXPECT_TRUE(sess);
 
-    EXPECT_TRUE(session_get_id(sess) == 0);
+    EXPECT_TRUE(session_get_id(sess) != 0);
     memset(buffer, 0, sizeof(buffer));
     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");
@@ -93,7 +93,7 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
     sess = session_manager_update_session(mgr, &pkt);
     EXPECT_TRUE(sess);
 
-    EXPECT_TRUE(session_get_id(sess) == 0);
+    EXPECT_TRUE(session_get_id(sess) != 0);
     memset(buffer, 0, sizeof(buffer));
     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");
@@ -128,7 +128,7 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
     sess = session_manager_update_session(mgr, &pkt);
     EXPECT_TRUE(sess);
 
-    EXPECT_TRUE(session_get_id(sess) == 0);
+    EXPECT_TRUE(session_get_id(sess) != 0);
     memset(buffer, 0, sizeof(buffer));
     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");
@@ -163,7 +163,7 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
     sess = session_manager_update_session(mgr, &pkt);
     EXPECT_TRUE(sess);
 
-    EXPECT_TRUE(session_get_id(sess) == 0);
+    EXPECT_TRUE(session_get_id(sess) != 0);
     memset(buffer, 0, sizeof(buffer));
     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");
@@ -198,7 +198,7 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
     sess = session_manager_update_session(mgr, &pkt);
     EXPECT_TRUE(sess);
 
-    EXPECT_TRUE(session_get_id(sess) == 0);
+    EXPECT_TRUE(session_get_id(sess) != 0);
     memset(buffer, 0, sizeof(buffer));
     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");
@@ -233,7 +233,7 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
     sess = session_manager_update_session(mgr, &pkt);
     EXPECT_TRUE(sess);
 
-    EXPECT_TRUE(session_get_id(sess) == 0);
+    EXPECT_TRUE(session_get_id(sess) != 0);
     memset(buffer, 0, sizeof(buffer));
     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");
@@ -268,7 +268,7 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
     sess = session_manager_update_session(mgr, &pkt);
     EXPECT_TRUE(sess);
 
-    EXPECT_TRUE(session_get_id(sess) == 0);
+    EXPECT_TRUE(session_get_id(sess) != 0);
     memset(buffer, 0, sizeof(buffer));
     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");
@@ -303,7 +303,7 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
     sess = session_manager_update_session(mgr, &pkt);
     EXPECT_TRUE(sess);
 
-    EXPECT_TRUE(session_get_id(sess) == 0);
+    EXPECT_TRUE(session_get_id(sess) != 0);
     memset(buffer, 0, sizeof(buffer));
     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");
@@ -338,7 +338,7 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
     sess = session_manager_update_session(mgr, &pkt);
     EXPECT_TRUE(sess);
 
-    EXPECT_TRUE(session_get_id(sess) == 0);
+    EXPECT_TRUE(session_get_id(sess) != 0);
     memset(buffer, 0, sizeof(buffer));
     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");
@@ -373,7 +373,7 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
     sess = session_manager_update_session(mgr, &pkt);
     EXPECT_TRUE(sess);
 
-    EXPECT_TRUE(session_get_id(sess) == 0);
+    EXPECT_TRUE(session_get_id(sess) != 0);
     memset(buffer, 0, sizeof(buffer));
     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");

src/session/test/gtest_state_tcp_opening_to_active.cpp

@@ -26,7 +26,7 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYN_C2S_DATA)
     sess = session_manager_update_session(mgr, &pkt);
     EXPECT_TRUE(sess);
 
-    EXPECT_TRUE(session_get_id(sess) == 0);
+    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);
@@ -61,7 +61,7 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYN_C2S_DATA)
     sess = session_manager_update_session(mgr, &pkt);
     EXPECT_TRUE(sess);
 
-    EXPECT_TRUE(session_get_id(sess) == 0);
+    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);
@@ -115,7 +115,7 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYNACK_S2C_DATA)
     sess = session_manager_update_session(mgr, &pkt);
     EXPECT_TRUE(sess);
 
-    EXPECT_TRUE(session_get_id(sess) == 0);
+    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);
@@ -150,7 +150,7 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYNACK_S2C_DATA)
     sess = session_manager_update_session(mgr, &pkt);
     EXPECT_TRUE(sess);
 
-    EXPECT_TRUE(session_get_id(sess) == 0);
+    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);

src/session/test/gtest_state_tcp_opening_to_closing.cpp

@@ -14,7 +14,7 @@ static void build_opening_tcp_session(struct session_manager *mgr, struct sessio
     sess = session_manager_update_session(mgr, &pkt);
     EXPECT_TRUE(sess);
 
-    EXPECT_TRUE(session_get_id(sess) == 0);
+    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);
@@ -70,7 +70,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_FIN_FIN)
     sess = session_manager_update_session(mgr, &pkt);
     EXPECT_TRUE(sess);
 
-    EXPECT_TRUE(session_get_id(sess) == 0);
+    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);
@@ -104,7 +104,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_FIN_FIN)
     sess = session_manager_update_session(mgr, &pkt);
     EXPECT_TRUE(sess);
 
-    EXPECT_TRUE(session_get_id(sess) == 0);
+    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);
@@ -168,7 +168,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_RST)
     sess = session_manager_update_session(mgr, &pkt);
     EXPECT_TRUE(sess);
 
-    EXPECT_TRUE(session_get_id(sess) == 0);
+    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);
@@ -232,7 +232,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_RST)
     sess = session_manager_update_session(mgr, &pkt);
     EXPECT_TRUE(sess);
 
-    EXPECT_TRUE(session_get_id(sess) == 0);
+    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);
@@ -315,7 +315,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_HANDSHAKE_TIMEOUT)
     sess = session_manager_update_session(mgr, &pkt);
     EXPECT_TRUE(sess);
 
-    EXPECT_TRUE(session_get_id(sess) == 0);
+    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);
@@ -373,7 +373,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_DATA_TIMEOUT)
     sess = session_manager_update_session(mgr, &pkt);
     EXPECT_TRUE(sess);
 
-    EXPECT_TRUE(session_get_id(sess) == 0);
+    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);
@@ -408,7 +408,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_DATA_TIMEOUT)
     sess = session_manager_update_session(mgr, &pkt);
     EXPECT_TRUE(sess);
 
-    EXPECT_TRUE(session_get_id(sess) == 0);
+    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);
@@ -465,7 +465,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_HALF_CLOSED_TIMEOUT)
     sess = session_manager_update_session(mgr, &pkt);
     EXPECT_TRUE(sess);
 
-    EXPECT_TRUE(session_get_id(sess) == 0);
+    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);
@@ -522,7 +522,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_HALF_CLOSED_TIMEOUT)
     sess = session_manager_update_session(mgr, &pkt);
     EXPECT_TRUE(sess);
 
-    EXPECT_TRUE(session_get_id(sess) == 0);
+    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);

src/session/test/gtest_state_udp_init_to_opening_to_active_to_closing.cpp

@@ -30,7 +30,7 @@ TEST(UDP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING, TEST)
     sess = session_manager_update_session(mgr, &pkt);
     EXPECT_TRUE(sess);
 
-    EXPECT_TRUE(session_get_id(sess) == 0);
+    EXPECT_TRUE(session_get_id(sess) != 0);
     tuple6_tostring(session_get0_key(sess), buffer, sizeof(buffer));
     EXPECT_STREQ(buffer, "192.168.38.105:61099 -> 121.14.154.93:53, proto: 17, domain: 0");
     EXPECT_TRUE(session_get_key_dir(sess) == SESSION_DIR_C2S);
@@ -65,7 +65,7 @@ TEST(UDP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING, TEST)
     sess = session_manager_update_session(mgr, &pkt);
     EXPECT_TRUE(sess);
 
-    EXPECT_TRUE(session_get_id(sess) == 0);
+    EXPECT_TRUE(session_get_id(sess) != 0);
     tuple6_tostring(session_get0_key(sess), buffer, sizeof(buffer));
     EXPECT_STREQ(buffer, "192.168.38.105:61099 -> 121.14.154.93:53, proto: 17, domain: 0");
     EXPECT_TRUE(session_get_key_dir(sess) == SESSION_DIR_C2S);

src/session/test/gtest_state_udp_init_to_opening_to_closing.cpp

@@ -28,7 +28,7 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_C2S)
     sess = session_manager_update_session(mgr, &pkt);
     EXPECT_TRUE(sess);
 
-    EXPECT_TRUE(session_get_id(sess) == 0);
+    EXPECT_TRUE(session_get_id(sess) != 0);
     tuple6_tostring(session_get0_key(sess), buffer, sizeof(buffer));
     EXPECT_STREQ(buffer, "192.168.38.105:61099 -> 121.14.154.93:53, proto: 17, domain: 0");
     EXPECT_TRUE(session_get_key_dir(sess) == SESSION_DIR_C2S);
@@ -85,7 +85,7 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_S2C)
     sess = session_manager_update_session(mgr, &pkt);
     EXPECT_TRUE(sess);
 
-    EXPECT_TRUE(session_get_id(sess) == 0);
+    EXPECT_TRUE(session_get_id(sess) != 0);
     tuple6_tostring(session_get0_key(sess), buffer, sizeof(buffer));
     EXPECT_STREQ(buffer, "121.14.154.93:53 -> 192.168.38.105:61099, proto: 17, domain: 0");
     EXPECT_TRUE(session_get_key_dir(sess) == SESSION_DIR_S2C);

src/stellar/CMakeLists.txt

@@ -1,4 +1,4 @@
 add_executable(stellar stellar.cpp)
-target_link_libraries(stellar session_manager pthread config mrzcpd)
+target_link_libraries(stellar id_generator session_manager pthread config mrzcpd)
 
 install(TARGETS stellar RUNTIME DESTINATION bin COMPONENT Program)

src/stellar/stellar.cpp

@@ -10,17 +10,13 @@
 #include <netinet/ether.h>
 
 #include "logo.h"
+#include "stellar.h"
 #include "marsio.h"
 #include "config.h"
 #include "packet.h"
 #include "timestamp.h"
 #include "session_manager.h"
-
+#include "id_generator.h"
-#ifdef STELLAR_GIT_VERSION
-static __attribute__((__used__)) const char *__stellar_version = STELLAR_GIT_VERSION;
-#else
-static __attribute__((__used__)) const char *__stellar_version = "Unknown";
-#endif
 
 #define STELLAR_LOG_STATE(format, ...) LOG_STATE("stellar", format, ##__VA_ARGS__)
 #define STELLAR_LOG_ERROR(format, ...) LOG_ERROR("stellar", format, ##__VA_ARGS__)
@@ -29,8 +25,6 @@ static __attribute__((__used__)) const char *__stellar_version = "Unknown";
 #define ATOMIC_SET(x, y) __atomic_store_n(x, y, __ATOMIC_RELAXED)
 #define ATOMIC_READ(x) __atomic_load_n(x, __ATOMIC_RELAXED)
 
-#define RX_BURST_MAX 128
-
 struct packet_io
 {
     struct mr_instance *mr_ins;
@@ -73,9 +67,8 @@ static void __packet_plugin_dispatch_example(const struct packet *pkt)
         return;
     }
 
-    printf("\n");
     printf("=> packet dispatch: %p\n", pkt);
-    printf("<= packet dispatch\n\n");
+    printf("<= packet dispatch\n");
 }
 
 static void __session_plugin_dispatch_example(struct session *sess)
@@ -85,10 +78,9 @@ static void __session_plugin_dispatch_example(struct session *sess)
         return;
     }
 
-    printf("\n");
     printf("=> session dispatch: %p\n", sess);
     session_dump(sess);
-    printf("<= session dispatch\n\n");
+    printf("<= session dispatch\n");
 
     // after session dispatch, we should reset session current packet and direction
     session_set0_cur_pkt(sess, NULL);
@@ -103,25 +95,25 @@ static void signal_handler(int signo)
 {
     if (signo == SIGINT)
     {
-        STELLAR_LOG_DEBUG("recv SIGINT, exit !!!");
+        STELLAR_LOG_STATE("SIGINT received, exit !!!");
         ATOMIC_SET(&stellar_ctx_ptr->need_exit, 1);
     }
 
     if (signo == SIGQUIT)
     {
-        STELLAR_LOG_DEBUG("recv SIGQUIT, exit !!!");
+        STELLAR_LOG_STATE("SIGQUIT received, exit !!!");
         ATOMIC_SET(&stellar_ctx_ptr->need_exit, 1);
     }
 
     if (signo == SIGTERM)
     {
-        STELLAR_LOG_DEBUG("recv SIGTERM, exit !!!");
+        STELLAR_LOG_STATE("SIGTERM received, exit !!!");
         ATOMIC_SET(&stellar_ctx_ptr->need_exit, 1);
     }
 
     if (signo == SIGHUP)
     {
-        STELLAR_LOG_DEBUG("recv SIGHUP, reload log config file !!!");
+        STELLAR_LOG_STATE("SIGHUP received, reload log level !!!");
         log_reload_level(log_config_file);
     }
 }
@@ -187,7 +179,7 @@ static void *main_loop(void *arg)
 
     ATOMIC_SET(&threads_ctx->is_runing, 1);
     thread_set_name("stellar", thd_idx);
-    STELLAR_LOG_DEBUG("worker thread %d runing\n", thd_idx);
+    STELLAR_LOG_DEBUG("worker thread %d runing", thd_idx);
 
     while (ATOMIC_READ(&threads_ctx->need_exit) == 0)
     {
@@ -238,7 +230,7 @@ static void *main_loop(void *arg)
     }
 
     ATOMIC_SET(&threads_ctx->is_runing, 0);
-    STELLAR_LOG_DEBUG("worker thread %d exit\n", thd_idx);
+    STELLAR_LOG_DEBUG("worker thread %d stop", thd_idx);
 
     return NULL;
 }
@@ -248,7 +240,7 @@ static int thread_context_init(struct stellar_context *ctx)
     struct system_config *sys_cfg = &ctx->config.sys_cfg;
     struct session_manager_config *sess_mgr_cfg = &ctx->config.sess_mgr_cfg;
 
-    for (uint16_t i = 0; i < sys_cfg->nr_threads; i++)
+    for (uint8_t i = 0; i < sys_cfg->nr_threads; i++)
     {
         struct thread_context *threads_ctx = &ctx->threads_ctx[i];
         threads_ctx->index = i;
@@ -270,19 +262,20 @@ static void thread_context_free(struct stellar_context *ctx)
 {
     struct system_config *sys_cfg = &ctx->config.sys_cfg;
 
-    for (uint16_t i = 0; i < sys_cfg->nr_threads; i++)
+    for (uint8_t i = 0; i < sys_cfg->nr_threads; i++)
     {
         struct thread_context *threads_ctx = &ctx->threads_ctx[i];
         if (ATOMIC_READ(&threads_ctx->is_runing) == 0)
         {
+            STELLAR_LOG_STATE("wait worker thread %d free context", i);
             session_manager_destroy(threads_ctx->sess_mgr);
         }
     }
 }
 
-static int thread_create(struct thread_context threads_ctx[], uint16_t nr_threads)
+static int thread_create(struct thread_context threads_ctx[], uint8_t nr_threads)
 {
-    for (uint16_t i = 0; i < nr_threads; i++)
+    for (uint8_t i = 0; i < nr_threads; i++)
     {
         struct thread_context *ctx = &threads_ctx[i];
         if (pthread_create(&ctx->tid, NULL, main_loop, (void *)ctx) < 0)
@@ -295,14 +288,15 @@ static int thread_create(struct thread_context threads_ctx[], uint16_t nr_thread
     return 0;
 }
 
-static void thread_destroy(struct thread_context threads_ctx[], uint16_t nr_threads)
+static void thread_destroy(struct thread_context threads_ctx[], uint8_t nr_threads)
 {
-    for (uint16_t i = 0; i < nr_threads; i++)
+    for (uint8_t i = 0; i < nr_threads; i++)
     {
         struct thread_context *ctx = &threads_ctx[i];
         ATOMIC_SET(&ctx->need_exit, 1);
         while (ATOMIC_READ(&ctx->is_runing) == 1)
         {
+            STELLAR_LOG_STATE("wait worker thread %d stop", i);
             sleep(1);
         }
     }
@@ -350,7 +344,7 @@ struct packet_io *packet_io_create(struct system_config *sys_cfg)
     int opt = 1;
     cpu_set_t coremask;
     CPU_ZERO(&coremask);
-    for (int i = 0; i < sys_cfg->nr_threads; i++)
+    for (uint8_t i = 0; i < sys_cfg->nr_threads; i++)
     {
         CPU_SET(sys_cfg->cpu_mask[i], &coremask);
     }
@@ -397,8 +391,14 @@ int main(int argc, char **argv)
     memset(stellar_ctx_ptr, 0, sizeof(struct stellar_context));
     timestamp_update();
 
+    signal(SIGINT, signal_handler);
+    signal(SIGQUIT, signal_handler);
+    signal(SIGTERM, signal_handler);
+    signal(SIGHUP, signal_handler);
+
     if (log_init(log_config_file) != 0)
     {
+        STELLAR_LOG_ERROR("unable to init log");
         return -1;
     }
 
@@ -406,19 +406,21 @@ int main(int argc, char **argv)
 
     if (config_load(&stellar_ctx_ptr->config, stellar_config_file) != 0)
     {
+        STELLAR_LOG_ERROR("unable to load config file");
         return -1;
     }
 
     config_dump(&stellar_ctx_ptr->config);
     struct system_config *sys_cfg = &stellar_ctx_ptr->config.sys_cfg;
-    uint16_t nr_threads = sys_cfg->nr_threads;
+    uint8_t nr_threads = sys_cfg->nr_threads;
 
-    // TODO init plugin
+    if (id_generator_init(sys_cfg->device_base, sys_cfg->device_offset) != 0)
+    {
+        STELLAR_LOG_ERROR("unable to init id generator");
+        return -1;
+    }
 
-    signal(SIGINT, signal_handler);
+    // TODO load plugin
-    signal(SIGQUIT, signal_handler);
-    signal(SIGTERM, signal_handler);
-    signal(SIGHUP, signal_handler);
 
     stellar_ctx_ptr->pkt_io = packet_io_create(sys_cfg);
     if (stellar_ctx_ptr->pkt_io == NULL)
@@ -454,6 +456,8 @@ error_out:
 
     // TODO free plugin
 
+    id_generator_free();
+
     log_free();
 
     return 0;

src/stellar/stellar.h

@@ -0,0 +1,27 @@
+#ifndef _STELLAR_H
+#define _STELLAR_H
+
+#ifdef __cpluscplus
+extern "C"
+{
+#endif
+
+#define MAX_THREAD_NUM 256
+#define RX_BURST_MAX 128
+
+#ifdef STELLAR_GIT_VERSION
+static __attribute__((__used__)) const char *__stellar_version = STELLAR_GIT_VERSION;
+#else
+static __attribute__((__used__)) const char *__stellar_version = "Unknown";
+#endif
+
+static inline uint8_t stellar_get_current_thread_index()
+{
+    return 0;
+}
+
+#ifdef __cpluscplus
+}
+#endif
+
+#endif