Add packet utils to packet.h

include/packet.h

@@ -72,9 +72,36 @@ int packet_get_outermost_tuple6(const struct packet *pkt, struct tuple6 *tuple);
 const struct packet_layer *packet_get_innermost_layer(const struct packet *pkt, enum layer_type type);
 const struct packet_layer *packet_get_outermost_layer(const struct packet *pkt, enum layer_type type);
 
+/******************************************************************************
+ * Utils
+ ******************************************************************************/
+
 int8_t packet_get_layers(const struct packet *pkt);
 const struct packet_layer *packet_get_layer(const struct packet *pkt, int8_t idx);
 
+const char *packet_get_data(const struct packet *pkt);
+uint16_t packet_get_len(const struct packet *pkt);
+
+const char *packet_get_payload(const struct packet *pkt);
+uint16_t packet_get_payload_len(const struct packet *pkt);
+
+int packet_need_drop(const struct packet *pkt);
+void packet_set_drop(struct packet *pkt);
+
+void packet_set_ctrl(struct packet *pkt);
+int packet_is_ctrl(const struct packet *pkt);
+
+void packet_set_direction(struct packet *pkt, int dir);
+int packet_get_direction(const struct packet *pkt); // 1: E2I, 0: I2E
+
+void packet_set_session_id(struct packet *pkt, uint64_t sess_id);
+uint64_t packet_get_session_id(const struct packet *pkt);
+
+void packet_set_sid_list(struct packet *pkt, uint16_t *sid, int num);
+int packet_get_sid_list(const struct packet *pkt, uint16_t *sid, int num); // return number of sid
+void packet_prepend_sid_list(struct packet *pkt, uint16_t *sid, int num);
+void packet_append_sid_list(struct packet *pkt, uint16_t *sid, int num);
+
 /*
  ******************************************************************************
  * Example: getting the innermost TCP layer

src/duplicated_packet_filter/duplicated_packet_filter.h

@@ -9,7 +9,7 @@ extern "C"
 // Duplicated Packet Filter for IPv4 Packet
 
 #include "log.h"
-#include "packet_private.h"
+#include "packet.h"
 
 #define DUPLICATED_PACKET_FILTER_LOG_ERROR(format, ...) LOG_ERROR("duplicated packet filter", format, ##__VA_ARGS__)
 

src/duplicated_packet_filter/test/gtest_duplicated_packet_filter.cpp

@@ -1,6 +1,7 @@
 #include <gtest/gtest.h>
 
 #include "duplicated_packet_filter.h"
+#include "packet_private.h"
 
 /******************************************************************************
  * [Protocols in frame: eth:ethertype:ip:ipv6:tcp]

src/ip_reassembly/ip_reassembly.cpp

@@ -729,7 +729,7 @@ static struct packet *ip_frag_reassemble(struct ip_reassembly *assy, struct ip_f
 
     // create a new packet
     packet_parse(pkt, ptr, packet_len);
-    packet_set_action(pkt, PACKET_ACTION_DROP);
+    packet_set_drop(pkt);
 
     return pkt;
 

src/ip_reassembly/ip_reassembly.h

@@ -6,7 +6,7 @@ extern "C"
 {
 #endif
 
-#include "packet_private.h"
+#include "packet.h"
 #include "log.h"
 
 #define IP_REASSEMBLE_DEBUG(format, ...) LOG_DEBUG("ip_reassembly", format, ##__VA_ARGS__)

src/ip_reassembly/test/gtest_utils.h

@@ -13,6 +13,7 @@ extern "C"
 #include "ipv4_utils.h"
 #include "ipv6_utils.h"
 #include "ip_reassembly.h"
+#include "packet_private.h"
 
 static inline void packet_set_ipv4_src_addr(struct packet *pkt, uint32_t saddr)
 {

src/log/log.cpp

@@ -272,7 +272,7 @@ void log_print(enum log_level level, const char *module, const char *fmt, ...)
     }
 
     int nwrite;
-    char buf[2048] = {0};
+    char buf[4096] = {0};
     char *p = buf;
     char *end = buf + sizeof(buf);
     va_list args;

src/packet/CMakeLists.txt

@@ -1,7 +1,7 @@
-add_library(packet packet.cpp)
+add_library(packet packet.cpp packet_utils.cpp)
 target_include_directories(packet PUBLIC ${CMAKE_CURRENT_LIST_DIR})
 target_include_directories(packet PUBLIC ${CMAKE_SOURCE_DIR}/deps/uthash)
 target_include_directories(packet PUBLIC ${CMAKE_SOURCE_DIR}/include)
-target_link_libraries(packet tuple log)
+target_link_libraries(packet tuple log mrzcpd)
 
 add_subdirectory(test)

src/packet/packet.cpp

@@ -1131,7 +1131,6 @@ const char *packet_parse(struct packet *pkt, const char *data, uint16_t len)
     pkt->layers_size = PACKET_MAX_LAYERS;
     pkt->data_ptr = data;
     pkt->data_len = len;
-    memset(&pkt->meta, 0, sizeof(struct metadata));
 
     // TESTED
     return parse_ether(pkt, data, len);
@@ -1291,7 +1290,7 @@ int packet_get_innermost_tuple6(const struct packet *pkt, struct tuple6 *tuple)
     const struct packet_layer *layer_l3 = NULL;
     const struct packet_layer *layer_l4 = NULL;
     const struct packet_layer *layer = NULL;
-    const struct metadata *meta = &pkt->meta;
+    uint64_t domain = packet_get_domain(pkt);
 
     for (int8_t i = pkt->layers_used - 1; i >= 0; i--)
     {
@@ -1312,10 +1311,10 @@ int packet_get_innermost_tuple6(const struct packet *pkt, struct tuple6 *tuple)
         }
     }
 
-    if (layer_l3 && layer_l4)
+    if (layer_l3 && layer_l4 && layer_l4 - layer_l3 == 1)
     {
-        set_tuple6((const char *)pkt->data_ptr + layer_l3->hdr_offset, layer_l3->type, tuple, meta->domain);
+        set_tuple6((const char *)pkt->data_ptr + layer_l3->hdr_offset, layer_l3->type, tuple, domain);
-        set_tuple6((const char *)pkt->data_ptr + layer_l4->hdr_offset, layer_l4->type, tuple, meta->domain);
+        set_tuple6((const char *)pkt->data_ptr + layer_l4->hdr_offset, layer_l4->type, tuple, domain);
         return 0;
     }
     else
@@ -1332,7 +1331,7 @@ int packet_get_outermost_tuple6(const struct packet *pkt, struct tuple6 *tuple)
     const struct packet_layer *layer_l3 = NULL;
     const struct packet_layer *layer_l4 = NULL;
     const struct packet_layer *layer = NULL;
-    const struct metadata *meta = &pkt->meta;
+    uint64_t domain = packet_get_domain(pkt);
 
     for (int8_t i = 0; i < pkt->layers_used; i++)
     {
@@ -1353,10 +1352,10 @@ int packet_get_outermost_tuple6(const struct packet *pkt, struct tuple6 *tuple)
         }
     }
 
-    if (layer_l3 && layer_l4)
+    if (layer_l3 && layer_l4 && layer_l4 - layer_l3 == 1)
     {
-        set_tuple6((const char *)pkt->data_ptr + layer_l3->hdr_offset, layer_l3->type, tuple, meta->domain);
+        set_tuple6((const char *)pkt->data_ptr + layer_l3->hdr_offset, layer_l3->type, tuple, domain);
-        set_tuple6((const char *)pkt->data_ptr + layer_l4->hdr_offset, layer_l4->type, tuple, meta->domain);
+        set_tuple6((const char *)pkt->data_ptr + layer_l4->hdr_offset, layer_l4->type, tuple, domain);
         return 0;
     }
     else
@@ -1515,276 +1514,4 @@ uint64_t packet_get_hash(const struct packet *pkt, enum ldbc_method method, int
     }
 
     return hash_value;
-}
+}
-
-int8_t packet_get_layers(const struct packet *pkt)
-{
-    return pkt->layers_used;
-}
-
-const struct packet_layer *packet_get_layer(const struct packet *pkt, int8_t idx)
-{
-    if (idx < 0 || idx >= pkt->layers_used)
-    {
-        return NULL;
-    }
-    return &pkt->layers[idx];
-}
-
-/******************************************************************************
- * Packet Meta Data
- ******************************************************************************/
-
-// return  0 : success
-// return -1 : failed
-int packet_set_sid(struct packet *pkt, uint16_t *sid, int num)
-{
-    struct metadata *meta = &pkt->meta;
-
-    if (num > MAX_SID_NUM)
-    {
-        return -1;
-    }
-
-    meta->sid.used = num;
-    memcpy(meta->sid.list, sid, num * sizeof(uint16_t));
-    return 0;
-}
-
-// return number of sid
-int packet_get_sid(const struct packet *pkt, uint16_t *sid, int size)
-{
-    const struct metadata *meta = &pkt->meta;
-
-    if (size < meta->sid.used)
-    {
-        return 0;
-    }
-
-    memcpy(sid, meta->sid.list, meta->sid.used * sizeof(uint16_t));
-    return meta->sid.used;
-}
-
-// return  0 : success
-// return -1 : failed
-int packet_prepend_sid(struct packet *pkt, uint16_t sid)
-{
-    struct metadata *meta = &pkt->meta;
-
-    if (meta->sid.used >= MAX_SID_NUM)
-    {
-        return -1;
-    }
-    memmove(meta->sid.list + 1, meta->sid.list, meta->sid.used * sizeof(uint16_t));
-    meta->sid.list[0] = sid;
-    meta->sid.used++;
-    return 0;
-}
-
-// return  0 : success
-// return -1 : failed
-int packet_append_sid(struct packet *pkt, uint16_t sid)
-{
-    struct metadata *meta = &pkt->meta;
-
-    if (meta->sid.used >= MAX_SID_NUM)
-    {
-        return -1;
-    }
-    meta->sid.list[meta->sid.used] = sid;
-    meta->sid.used++;
-    return 0;
-}
-
-// return  0 : success
-// return -1 : failed
-int packet_set_route_ctx(struct packet *pkt, const char *route, int len)
-{
-    struct metadata *meta = &pkt->meta;
-
-    if (len > MAX_ROUTE_LEN)
-    {
-        return -1;
-    }
-
-    memcpy(meta->route.data, route, len);
-    meta->route.len = len;
-    return 0;
-}
-
-// return len of route ctx
-int packet_get_route_ctx(const struct packet *pkt, char *buff, int size)
-{
-    const struct metadata *meta = &pkt->meta;
-
-    if (meta->route.len > size)
-    {
-        return 0;
-    }
-    memcpy(buff, meta->route.data, meta->route.len);
-    return meta->route.len;
-}
-
-void packet_set_io_ctx(struct packet *pkt, void *ctx)
-{
-    struct metadata *meta = &pkt->meta;
-
-    meta->io_ctx = ctx;
-}
-
-void *packet_get_io_ctx(const struct packet *pkt)
-{
-    const struct metadata *meta = &pkt->meta;
-
-    return meta->io_ctx;
-}
-
-void packet_set_domain(struct packet *pkt, uint64_t domain)
-{
-    struct metadata *meta = &pkt->meta;
-
-    meta->domain = domain;
-}
-
-uint64_t packet_get_domain(const struct packet *pkt)
-{
-    const struct metadata *meta = &pkt->meta;
-
-    return meta->domain;
-}
-
-void packet_set_session_id(struct packet *pkt, uint64_t session_id)
-{
-    struct metadata *meta = &pkt->meta;
-
-    meta->session_id = session_id;
-}
-
-uint64_t packet_get_session_id(const struct packet *pkt)
-{
-    const struct metadata *meta = &pkt->meta;
-
-    return meta->session_id;
-}
-
-void packet_set_direction(struct packet *pkt, enum packet_direction direction)
-{
-    struct metadata *meta = &pkt->meta;
-
-    meta->direction = direction;
-}
-
-enum packet_direction packet_get_direction(const struct packet *pkt)
-{
-    const struct metadata *meta = &pkt->meta;
-
-    return meta->direction;
-}
-
-void packet_set_action(struct packet *pkt, enum packet_action action)
-{
-    struct metadata *meta = &pkt->meta;
-
-    meta->action = action;
-}
-
-enum packet_action packet_get_action(const struct packet *pkt)
-{
-    const struct metadata *meta = &pkt->meta;
-
-    return meta->action;
-}
-
-void packet_set_type(struct packet *pkt, enum packet_type type)
-{
-    struct metadata *meta = &pkt->meta;
-
-    meta->type = type;
-}
-
-enum packet_type packet_get_type(const struct packet *pkt)
-{
-    const struct metadata *meta = &pkt->meta;
-
-    return meta->type;
-}
-
-struct packet *packet_new(uint16_t pkt_len)
-{
-    struct packet *pkt = (struct packet *)calloc(1, sizeof(struct packet) + pkt_len);
-    if (pkt == NULL)
-    {
-        return NULL;
-    }
-    pkt->data_len = pkt_len;
-    pkt->data_ptr = (const char *)pkt + sizeof(struct packet);
-    pkt->need_free = true;
-
-    return pkt;
-}
-
-void packet_free(struct packet *pkt)
-{
-    if (pkt && pkt->need_free)
-    {
-        pkt->need_free = false;
-        free((void *)pkt);
-    }
-}
-
-struct packet *packet_dup(const struct packet *pkt)
-{
-    if (pkt == NULL)
-    {
-        return NULL;
-    }
-
-    struct packet *dup_pkt = packet_new(pkt->data_len);
-    if (dup_pkt == NULL)
-    {
-        return NULL;
-    }
-    memcpy(dup_pkt, pkt, sizeof(struct packet));
-    memcpy((char *)dup_pkt->data_ptr, pkt->data_ptr, pkt->data_len);
-    dup_pkt->need_free = true;
-
-    struct metadata *meta = &dup_pkt->meta;
-    meta->io_ctx = NULL;
-
-    // update layers
-    for (int8_t i = 0; i < pkt->layers_used; i++)
-    {
-        dup_pkt->layers[i].hdr_ptr = dup_pkt->data_ptr + pkt->layers[i].hdr_offset;
-        dup_pkt->layers[i].pld_ptr = dup_pkt->data_ptr + pkt->layers[i].hdr_offset + pkt->layers[i].hdr_len;
-    }
-
-    // update frag_layer
-    if (pkt->frag_layer)
-    {
-        dup_pkt->frag_layer = &dup_pkt->layers[pkt->frag_layer - pkt->layers];
-    }
-
-    return dup_pkt;
-}
-
-const char *packet_get_data(const struct packet *pkt)
-{
-    return pkt->data_ptr;
-}
-
-uint16_t packet_get_len(const struct packet *pkt)
-{
-    return pkt->data_len;
-}
-
-bool packet_is_fragment(const struct packet *pkt)
-{
-    if (pkt->frag_layer)
-    {
-        return true;
-    }
-    else
-    {
-        return false;
-    }
-}

src/packet/packet_private.h

@@ -15,7 +15,8 @@ extern "C"
 
 #define PACKET_MAX_LAYERS 32
 #define PACKET_LOG_ERROR(format, ...) LOG_ERROR("packet", format, ##__VA_ARGS__)
-#define PACKET_LOG_DEBUG(format, ...) LOG_DEBUG("packet", format, ##__VA_ARGS__)
+#define PACKET_LOG_DEBUG(format, ...) void(0)
+//#define PACKET_LOG_DEBUG(format, ...) LOG_DEBUG("packet", format, ##__VA_ARGS__)
 
 enum ldbc_method
 {
@@ -26,46 +27,11 @@ enum ldbc_method
     LDBC_METHOD_HASH_INNERMOST_EXT_IP = 5,
 };
 
-enum packet_direction
+enum packet_origin
 {
-    PACKET_DIRECTION_I2E = 0,
+    PACKET_ORIGIN_MARSIO = 0x1,
-    PACKET_DIRECTION_E2I = 1,
+    PACKET_ORIGIN_DUMPFILE = 0x2,
-};
+    PACKET_ORIGIN_USER = 0x3,
-
-enum packet_action
-{
-    PACKET_ACTION_FORWARD = 0,
-    PACKET_ACTION_DROP = 1,
-};
-
-enum packet_type
-{
-    PACKET_TYPE_DATA = 0,
-    PACKET_TYPE_CTRL = 1,
-};
-
-struct metadata
-{
-#define MAX_SID_NUM 8
-#define MAX_ROUTE_LEN 64
-
-    struct
-    {
-        uint16_t list[MAX_SID_NUM];
-        uint16_t used;
-    } sid;
-    struct
-    {
-        char data[MAX_ROUTE_LEN];
-        uint16_t len;
-    } route;
-
-    void *io_ctx;
-    uint64_t domain;
-    uint64_t session_id;
-    enum packet_direction direction;
-    enum packet_action action;
-    enum packet_type type;
 };
 
 struct packet
@@ -77,9 +43,10 @@ struct packet
 
     const char *data_ptr;
     uint16_t data_len;
-    bool need_free;
 
-    struct metadata meta;
+    int need_drop;
+    void *io_ctx;
+    enum packet_origin origin;
 };
 
 // return innermost payload
@@ -90,50 +57,27 @@ void packet_print(const struct packet *pkt);
 // direction 0: I2E
 uint64_t packet_get_hash(const struct packet *pkt, enum ldbc_method method, int direction);
 
-// return  0: success
+/******************************************************************************
-// return -1: failed
+ * Utils
-int packet_set_sid(struct packet *pkt, uint16_t *sid, int num);
+ ******************************************************************************/
-// return number of sid
-int packet_get_sid(const struct packet *pkt, uint16_t *sid, int size);
-// return  0: success
-// return -1: failed
-int packet_prepend_sid(struct packet *pkt, uint16_t sid);
-// return  0: success
-// return -1: failed
-int packet_append_sid(struct packet *pkt, uint16_t sid);
 
-// return  0: success
+void packet_set_origin(struct packet *pkt, enum packet_origin origin);
-// return -1: failed
+enum packet_origin packet_get_origin(const struct packet *pkt);
-int packet_set_route_ctx(struct packet *pkt, const char *route, int len);
-// return len of route ctx
-int packet_get_route_ctx(const struct packet *pkt, char *buff, int size);
 
 void packet_set_io_ctx(struct packet *pkt, void *ctx);
 void *packet_get_io_ctx(const struct packet *pkt);
 
-void packet_set_domain(struct packet *pkt, uint64_t domain);
+int packet_is_fragment(const struct packet *pkt);
-uint64_t packet_get_domain(const struct packet *pkt);
-
-void packet_set_session_id(struct packet *pkt, uint64_t session_id);
-uint64_t packet_get_session_id(const struct packet *pkt);
-
-void packet_set_direction(struct packet *pkt, enum packet_direction direction);
-enum packet_direction packet_get_direction(const struct packet *pkt);
-
-void packet_set_action(struct packet *pkt, enum packet_action action);
-enum packet_action packet_get_action(const struct packet *pkt);
-
-void packet_set_type(struct packet *pkt, enum packet_type type);
-enum packet_type packet_get_type(const struct packet *pkt);
 
 struct packet *packet_new(uint16_t pkt_len);
 void packet_free(struct packet *pkt);
 struct packet *packet_dup(const struct packet *pkt);
 
-const char *packet_get_data(const struct packet *pkt);
+void packet_set_domain(struct packet *pkt, uint64_t domain);
-uint16_t packet_get_len(const struct packet *pkt);
+uint64_t packet_get_domain(const struct packet *pkt);
 
-bool packet_is_fragment(const struct packet *pkt);
+void packet_set_route_ctx(struct packet *pkt, const char *route, int len);
+int packet_get_route_ctx(const struct packet *pkt, char *buff, int size); // return len of route ctx
 
 #ifdef __cpluscplus
 }

src/packet/packet_utils.cpp

@@ -0,0 +1,310 @@
+#include <stdlib.h>
+#include <assert.h>
+#include <string.h>
+
+#include "packet_private.h"
+#include "marsio.h"
+
+/******************************************************************************
+ * set and get from struct packet
+ ******************************************************************************/
+
+void packet_set_origin(struct packet *pkt, enum packet_origin origin)
+{
+    pkt->origin = origin;
+}
+
+enum packet_origin packet_get_origin(const struct packet *pkt)
+{
+    return pkt->origin;
+}
+
+int8_t packet_get_layers(const struct packet *pkt)
+{
+    return pkt->layers_used;
+}
+
+const struct packet_layer *packet_get_layer(const struct packet *pkt, int8_t idx)
+{
+    if (idx < 0 || idx >= pkt->layers_used)
+    {
+        return NULL;
+    }
+    return &pkt->layers[idx];
+}
+
+const char *packet_get_data(const struct packet *pkt)
+{
+    return pkt->data_ptr;
+}
+
+uint16_t packet_get_len(const struct packet *pkt)
+{
+    return pkt->data_len;
+}
+
+const char *packet_get_payload(const struct packet *pkt)
+{
+    if (pkt->layers_used == 0)
+    {
+        return NULL;
+    }
+    return pkt->layers[pkt->layers_used - 1].pld_ptr;
+}
+
+uint16_t packet_get_payload_len(const struct packet *pkt)
+{
+    if (pkt->layers_used == 0)
+    {
+        return 0;
+    }
+    return pkt->layers[pkt->layers_used - 1].pld_len;
+}
+
+int packet_need_drop(const struct packet *pkt)
+{
+    return pkt->need_drop;
+}
+
+void packet_set_drop(struct packet *pkt)
+{
+    pkt->need_drop = 1;
+}
+
+void packet_set_io_ctx(struct packet *pkt, void *ctx)
+{
+    pkt->io_ctx = ctx;
+}
+
+void *packet_get_io_ctx(const struct packet *pkt)
+{
+    return pkt->io_ctx;
+}
+
+int packet_is_fragment(const struct packet *pkt)
+{
+    return (pkt->frag_layer) ? 1 : 0;
+}
+
+struct packet *packet_new(uint16_t pkt_len)
+{
+    struct packet *pkt = (struct packet *)calloc(1, sizeof(struct packet) + pkt_len);
+    if (pkt == NULL)
+    {
+        return NULL;
+    }
+    pkt->data_len = pkt_len;
+    pkt->data_ptr = (const char *)pkt + sizeof(struct packet);
+    pkt->origin = PACKET_ORIGIN_USER;
+
+    return pkt;
+}
+
+void packet_free(struct packet *pkt)
+{
+    if (pkt && pkt->origin == PACKET_ORIGIN_USER)
+    {
+        free((void *)pkt);
+    }
+}
+
+struct packet *packet_dup(const struct packet *pkt)
+{
+    if (pkt == NULL)
+    {
+        return NULL;
+    }
+
+    struct packet *dup_pkt = packet_new(pkt->data_len);
+    if (dup_pkt == NULL)
+    {
+        return NULL;
+    }
+    memcpy(dup_pkt, pkt, sizeof(struct packet));
+    memcpy((char *)dup_pkt->data_ptr, pkt->data_ptr, pkt->data_len);
+    dup_pkt->origin = PACKET_ORIGIN_USER;
+    dup_pkt->io_ctx = dup_pkt;
+
+    // update layers
+    for (int8_t i = 0; i < pkt->layers_used; i++)
+    {
+        dup_pkt->layers[i].hdr_ptr = dup_pkt->data_ptr + pkt->layers[i].hdr_offset;
+        dup_pkt->layers[i].pld_ptr = dup_pkt->data_ptr + pkt->layers[i].hdr_offset + pkt->layers[i].hdr_len;
+    }
+
+    // update frag_layer
+    if (pkt->frag_layer)
+    {
+        dup_pkt->frag_layer = &dup_pkt->layers[pkt->frag_layer - pkt->layers];
+    }
+
+    return dup_pkt;
+}
+
+/******************************************************************************
+ * set and get from mbuff
+ ******************************************************************************/
+
+void packet_set_ctrl(struct packet *pkt)
+{
+    if (packet_get_origin(pkt) == PACKET_ORIGIN_MARSIO)
+    {
+        marsio_buff_t *mbuff = (marsio_buff_t *)packet_get_io_ctx(pkt);
+        assert(mbuff != NULL);
+        marsio_buff_set_ctrlbuf(mbuff);
+    }
+}
+
+int packet_is_ctrl(const struct packet *pkt)
+{
+    if (packet_get_origin(pkt) == PACKET_ORIGIN_MARSIO)
+    {
+        marsio_buff_t *mbuff = (marsio_buff_t *)packet_get_io_ctx(pkt);
+        assert(mbuff != NULL);
+        return marsio_buff_is_ctrlbuf(mbuff);
+    }
+    else
+    {
+        return 0;
+    }
+}
+
+// 1: E2I, 0: I2E
+void packet_set_direction(struct packet *pkt, int dir)
+{
+    if (packet_get_origin(pkt) == PACKET_ORIGIN_MARSIO)
+    {
+        marsio_buff_t *mbuff = (marsio_buff_t *)packet_get_io_ctx(pkt);
+        assert(mbuff != NULL);
+        marsio_buff_set_metadata(mbuff, MR_BUFF_DIR, &dir, sizeof(dir));
+    }
+}
+
+// 1: E2I, 0: I2E
+int packet_get_direction(const struct packet *pkt)
+{
+    int direction = 0;
+    if (packet_get_origin(pkt) == PACKET_ORIGIN_MARSIO)
+    {
+        marsio_buff_t *mbuff = (marsio_buff_t *)packet_get_io_ctx(pkt);
+        assert(mbuff != NULL);
+        marsio_buff_get_metadata(mbuff, MR_BUFF_DIR, &direction, sizeof(direction));
+    }
+
+    return direction;
+}
+
+void packet_set_session_id(struct packet *pkt, uint64_t sess_id)
+{
+    if (packet_get_origin(pkt) == PACKET_ORIGIN_MARSIO)
+    {
+        marsio_buff_t *mbuff = (marsio_buff_t *)packet_get_io_ctx(pkt);
+        assert(mbuff != NULL);
+        marsio_buff_set_metadata(mbuff, MR_BUFF_SESSION_ID, &sess_id, sizeof(sess_id));
+    }
+}
+
+uint64_t packet_get_session_id(const struct packet *pkt)
+{
+    uint64_t sess_id = 0;
+    if (packet_get_origin(pkt) == PACKET_ORIGIN_MARSIO)
+    {
+        marsio_buff_t *mbuff = (marsio_buff_t *)packet_get_io_ctx(pkt);
+        assert(mbuff != NULL);
+        marsio_buff_get_metadata(mbuff, MR_BUFF_SESSION_ID, &sess_id, sizeof(sess_id));
+    }
+
+    return sess_id;
+}
+
+void packet_set_domain(struct packet *pkt, uint64_t domain)
+{
+    if (packet_get_origin(pkt) == PACKET_ORIGIN_MARSIO)
+    {
+        marsio_buff_t *mbuff = (marsio_buff_t *)packet_get_io_ctx(pkt);
+        assert(mbuff != NULL);
+        // TODO
+        // marsio_buff_set_metadata(mbuff, MR_BUFF_DOMAIN, &domain, sizeof(domain));
+    }
+}
+
+uint64_t packet_get_domain(const struct packet *pkt)
+{
+    uint64_t domain = 0;
+    if (packet_get_origin(pkt) == PACKET_ORIGIN_MARSIO)
+    {
+        marsio_buff_t *mbuff = (marsio_buff_t *)packet_get_io_ctx(pkt);
+        assert(mbuff != NULL);
+        // TODO
+        // marsio_buff_get_metadata(mbuff, MR_BUFF_DOMAIN, &domain, sizeof(domain));
+    }
+
+    return domain;
+}
+
+void packet_set_route_ctx(struct packet *pkt, const char *route, int len)
+{
+    if (packet_get_origin(pkt) == PACKET_ORIGIN_MARSIO)
+    {
+        marsio_buff_t *mbuff = (marsio_buff_t *)packet_get_io_ctx(pkt);
+        assert(mbuff != NULL);
+        marsio_buff_set_metadata(mbuff, MR_BUFF_ROUTE_CTX, (void *)route, len);
+    }
+}
+
+// return len of route ctx
+int packet_get_route_ctx(const struct packet *pkt, char *buff, int size)
+{
+    int len = 0;
+    if (packet_get_origin(pkt) == PACKET_ORIGIN_MARSIO)
+    {
+        marsio_buff_t *mbuff = (marsio_buff_t *)packet_get_io_ctx(pkt);
+        assert(mbuff != NULL);
+        len = marsio_buff_get_metadata(mbuff, MR_BUFF_ROUTE_CTX, buff, size);
+    }
+
+    return len;
+}
+
+void packet_set_sid_list(struct packet *pkt, uint16_t *sid, int num)
+{
+    if (packet_get_origin(pkt) == PACKET_ORIGIN_MARSIO)
+    {
+        marsio_buff_t *mbuff = (marsio_buff_t *)packet_get_io_ctx(pkt);
+        assert(mbuff != NULL);
+        marsio_buff_set_sid_list(mbuff, sid, num);
+    }
+}
+
+// return number of sid
+int packet_get_sid_list(const struct packet *pkt, uint16_t *sid, int num)
+{
+    if (packet_get_origin(pkt) == PACKET_ORIGIN_MARSIO)
+    {
+        marsio_buff_t *mbuff = (marsio_buff_t *)packet_get_io_ctx(pkt);
+        assert(mbuff != NULL);
+        return marsio_buff_get_sid_list(mbuff, sid, num);
+    }
+
+    return 0;
+}
+
+void packet_prepend_sid_list(struct packet *pkt, uint16_t *sid, int num)
+{
+    if (packet_get_origin(pkt) == PACKET_ORIGIN_MARSIO)
+    {
+        marsio_buff_t *mbuff = (marsio_buff_t *)packet_get_io_ctx(pkt);
+        assert(mbuff != NULL);
+        marsio_buff_prepend_sid_list(mbuff, sid, num);
+    }
+}
+
+void packet_append_sid_list(struct packet *pkt, uint16_t *sid, int num)
+{
+    if (packet_get_origin(pkt) == PACKET_ORIGIN_MARSIO)
+    {
+        marsio_buff_t *mbuff = (marsio_buff_t *)packet_get_io_ctx(pkt);
+        assert(mbuff != NULL);
+        marsio_buff_append_sid_list(mbuff, sid, num);
+    }
+}

src/packet_io/dumpfile_io.cpp

@@ -57,7 +57,17 @@ static void pcap_handle(u_char *user, const struct pcap_pkthdr *h, const u_char
 
     // push packet to queue
     struct lock_free_queue *queue = handle->queue[hash % handle->nr_threads];
-    lock_free_queue_push(queue, pcap_pkt);
+    while (lock_free_queue_push(queue, pcap_pkt) == -1)
+    {
+        if (ATOMIC_READ(&handle->io_thread_need_exit))
+        {
+            free(pcap_pkt);
+            PACKET_IO_LOG_STATE("dumpfile io thread need exit");
+            pcap_breakloop(handle->pcap);
+            break;
+        }
+        usleep(1000);
+    }
 
     if (ATOMIC_READ(&handle->io_thread_need_exit))
     {
@@ -89,7 +99,7 @@ static int dumpfile_handle(const char *file, void *arg)
     return 0;
 }
 
-static void *dumpfile_thread_cycle(void *arg)
+static void *dumpfile_thread(void *arg)
 {
     struct dumpfile_io *handle = (struct dumpfile_io *)arg;
 
@@ -104,7 +114,7 @@ static void *dumpfile_thread_cycle(void *arg)
         sleep(1);
     }
 
-    PACKET_IO_LOG_STATE("dumpfile io thread is exiting");
+    PACKET_IO_LOG_STATE("dumpfile io thread exit !!!");
     ATOMIC_SET(&handle->io_thread_is_runing, 0);
 
     return NULL;
@@ -125,7 +135,7 @@ struct dumpfile_io *dumpfile_io_new(const char *directory, uint8_t nr_threads)
     }
 
     handle->nr_threads = nr_threads;
-    strncpy(handle->directory, directory, strlen(directory));
+    strncpy(handle->directory, directory, MIN(strlen(directory), sizeof(handle->directory)));
 
     for (uint16_t i = 0; i < handle->nr_threads; i++)
     {
@@ -136,7 +146,7 @@ struct dumpfile_io *dumpfile_io_new(const char *directory, uint8_t nr_threads)
             goto error_out;
         }
     }
-    if (pthread_create(&tid, NULL, dumpfile_thread_cycle, (void *)handle) != 0)
+    if (pthread_create(&tid, NULL, dumpfile_thread, (void *)handle) != 0)
     {
         PACKET_IO_LOG_ERROR("unable to create packet io thread");
         goto error_out;
@@ -160,8 +170,22 @@ void dumpfile_io_free(struct dumpfile_io *handle)
             usleep(1000);
         }
 
+        struct pcap_pkt *pcap_pkt = NULL;
         for (uint16_t i = 0; i < handle->nr_threads; i++)
         {
+            while (1)
+            {
+                lock_free_queue_pop(handle->queue[i], (void **)&pcap_pkt);
+                if (pcap_pkt)
+                {
+                    free(pcap_pkt);
+                }
+                else
+                {
+                    break;
+                }
+            }
+
             lock_free_queue_free(handle->queue[i]);
         }
         free(handle);
@@ -183,6 +207,7 @@ int dumpfile_io_ingress(struct dumpfile_io *handle, uint16_t thr_idx, struct pac
 {
     struct lock_free_queue *queue = handle->queue[thr_idx];
     struct pcap_pkt *pcap_pkt = NULL;
+    struct packet *pkt;
     int nr_parsed = 0;
 
     for (int i = 0; i < nr_pkts; i++)
@@ -200,12 +225,12 @@ int dumpfile_io_ingress(struct dumpfile_io *handle, uint16_t thr_idx, struct pac
             ATOMIC_ADD(&handle->stat.raw_rx_pkts, 1);
             ATOMIC_ADD(&handle->stat.raw_rx_bytes, pcap_pkt->len);
 
-            struct packet *pkt = &pkts[nr_parsed++];
+            pkt = &pkts[nr_parsed];
             memset(pkt, 0, sizeof(struct packet));
             packet_parse(pkt, pcap_pkt->data, pcap_pkt->len);
             packet_set_io_ctx(pkt, pcap_pkt);
-            packet_set_type(pkt, PACKET_TYPE_DATA);
+            packet_set_origin(pkt, PACKET_ORIGIN_DUMPFILE);
-            packet_set_action(pkt, PACKET_ACTION_FORWARD);
+            nr_parsed++;
         }
     }
 

src/packet_io/lock_free_queue.cpp

@@ -44,12 +44,6 @@ void lock_free_queue_free(struct lock_free_queue *queue)
         return;
     }
 
-    // wait queue is empty
-    while (queue->head != queue->tail)
-    {
-        usleep(1000);
-    }
-
     if (queue->queue)
     {
         free(queue->queue);
@@ -59,19 +53,16 @@ void lock_free_queue_free(struct lock_free_queue *queue)
     free(queue);
 }
 
-void lock_free_queue_push(struct lock_free_queue *queue, void *data)
+int lock_free_queue_push(struct lock_free_queue *queue, void *data)
 {
-    uint64_t wait = 1000;
-retry:
     if (__sync_val_compare_and_swap(&queue->queue[queue->tail], 0, data) != 0)
     {
         LOCK_FREE_QUEUE_LOG_ERROR("lock free queue is full, retry later");
-        usleep(wait);
+        return -1;
-        wait *= 2;
-        goto retry;
     }
 
     queue->tail = (queue->tail + 1) % queue->size;
+    return 0;
 }
 
 void lock_free_queue_pop(struct lock_free_queue *queue, void **data)

src/packet_io/lock_free_queue.h

@@ -16,7 +16,7 @@ struct lock_free_queue;
 struct lock_free_queue *lock_free_queue_new(uint32_t size);
 void lock_free_queue_free(struct lock_free_queue *queue);
 
-void lock_free_queue_push(struct lock_free_queue *queue, void *data);
+int lock_free_queue_push(struct lock_free_queue *queue, void *data);
 void lock_free_queue_pop(struct lock_free_queue *queue, void **data);
 
 #ifdef __cpluscplus

src/packet_io/marsio_io.cpp

@@ -171,8 +171,16 @@ int marsio_io_ingress(struct marsio_io *handle, uint16_t thr_idx, struct packet
             continue;
         }
 
+        pkt = &pkts[nr_parsed];
+        memset(pkt, 0, sizeof(struct packet));
+        packet_parse(pkt, data, len);
+        packet_set_io_ctx(pkt, mbuff);
+        packet_set_origin(pkt, PACKET_ORIGIN_MARSIO);
+        nr_parsed++;
+
         if (marsio_buff_is_ctrlbuf(mbuff))
         {
+            packet_set_ctrl(pkt);
             ATOMIC_ADD(&handle->stat.ctrl_rx_pkts, 1);
             ATOMIC_ADD(&handle->stat.ctrl_rx_bytes, len);
         }
@@ -181,12 +189,6 @@ int marsio_io_ingress(struct marsio_io *handle, uint16_t thr_idx, struct packet
             ATOMIC_ADD(&handle->stat.raw_rx_pkts, 1);
             ATOMIC_ADD(&handle->stat.raw_rx_bytes, len);
         }
-
-        pkt = &pkts[nr_parsed];
-        packet_parse(pkt, data, len);
-        packet_set_io_ctx(pkt, mbuff);
-        packet_set_action(pkt, PACKET_ACTION_FORWARD);
-        nr_parsed++;
     }
 
     return nr_parsed;

src/plugin/plugin_manager.cpp

@@ -1,3 +1,4 @@
+#include <assert.h>
 #include "plugin_manager.h"
 #include "session_private.h"
 
@@ -9,18 +10,23 @@ struct plugin_manager
 void *plugin_manager_new_ctx(struct session *sess)
 {
     // TODO
-    return NULL;
+    return sess;
 }
 
 void plugin_manager_free_ctx(void *ctx)
 {
     // TODO
+    struct session *sess = (struct session *)ctx;
+    char buff[4096] = {0};
+    session_to_json(sess, buff, sizeof(buff));
+    PLUGIN_MANAGER_LOG_DEBUG("=> SESSION : %s", buff);
 }
 
 struct plugin_manager *plugin_manager_new(void)
 {
     // TODO
-    return NULL;
+    static struct plugin_manager mgr;
+    return &mgr;
 }
 
 void plugin_manager_free(struct plugin_manager *mgr)
@@ -31,30 +37,42 @@ void plugin_manager_free(struct plugin_manager *mgr)
 void plugin_manager_dispatch_session(struct plugin_manager *mgr, struct session *sess, struct packet *pkt)
 {
     // TODO
+    // current implementation only for testing
 
-    PLUGIN_MANAGER_LOG_DEBUG("=> plugin dispatch session: %u %s\n", session_get_id(sess), session_get_tuple_str(sess));
+    struct tcp_segment *seg;
-    session_dump(sess);
+    enum session_state state = session_get_state(sess);
+    enum session_type type = session_get_type(sess);
+    PLUGIN_MANAGER_LOG_DEBUG("=> plugin dispatch session: %u %s %s %s", session_get_id(sess), session_get_tuple_str(sess), session_type_to_str(type), session_state_to_str(state));
 
-    if (session_get_type(sess) == SESSION_TYPE_TCP)
+    // session_print(sess);
+
+    if (packet_is_ctrl(pkt))
     {
-        // TODO Trigger TCP ALL MSG with (mgr, sess, pkt)
+        // trigger ctrl msg with (mgr, sess, pkt)
-
+        // dispatch_plugin()
-        do
-        {
-            struct tcp_segment *seg = session_get_tcp_segment(sess);
-            if (seg == NULL)
-            {
-                break;
-            }
-
-            // TODO Trigger TCP Stream MSG with (mgr, sess, seg->data, seg->len)
-
-            session_free_tcp_segment(sess, seg);
-        } while (1);
     }
     else
     {
-        // TODO Trigger UDP MSG
+        switch (type)
+        {
+        case SESSION_TYPE_TCP:
+            // trigger TCP msg with (mgr, sess, pkt)
+            // dispatch_plugin()
+            while ((seg = session_get_tcp_segment(sess)) != NULL)
+            {
+                // trigger TCP stream msg with (mgr, sess, seg->data, seg->len)
+                // dispatch_plugin()
+                session_free_tcp_segment(sess, seg);
+            }
+            break;
+        case SESSION_TYPE_UDP:
+            // trigger UDP msg with (mgr, sess, pkt)
+            // dispatch_plugin()
+            break;
+        default:
+            assert(0);
+            break;
+        }
     }
 }
 

src/session/session.cpp

@@ -410,74 +410,81 @@ static void tcp_flags_to_str(uint8_t flags, char *buffer, size_t len)
     }
 }
 
-void session_dump(struct session *sess)
+int session_to_json(struct session *sess, char *buff, int size)
 {
-    char buffer[1024] = {0};
+    memset(buff, 0, size);
-    tuple6_to_str(session_get_tuple(sess), buffer, sizeof(buffer));
+    char flags[64] = {0};
+    int used = 0;
 
-    printf("session id                 : %" PRIu64 "\n", session_get_id(sess));
+    used += snprintf(buff + used, size - used, "{");
-    printf("session timestamp          : %" PRIu64 " -> %" PRIu64 "\n", session_get_timestamp(sess, SESSION_TIMESTAMP_START), session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
+    used += snprintf(buff + used, size - used, "\"id\":%" PRIu64 ",", session_get_id(sess));
-    printf("session tuple              : %s (%s)\n", buffer, session_direction_to_str(session_get_tuple_direction(sess)));
+    used += snprintf(buff + used, size - used, "\"start_timestamp\":%" PRIu64 ",", session_get_timestamp(sess, SESSION_TIMESTAMP_START));
-    printf("session type               : %s\n", session_type_to_str(session_get_type(sess)));
+    used += snprintf(buff + used, size - used, "\"last_timestamp\":%" PRIu64 ",", session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
-    printf("session state              : %s\n", session_state_to_str(session_get_state(sess)));
+    used += snprintf(buff + used, size - used, "\"tuple\":\"%s\",", session_get_tuple_str(sess));
-    printf("session closing reason     : %s\n", closing_reason_to_str(session_get_closing_reason(sess)));
+    used += snprintf(buff + used, size - used, "\"type\":\"%s\",", session_type_to_str(session_get_type(sess)));
-    printf("session dup traffic        : %d\n", session_has_dup_traffic(sess));
+    used += snprintf(buff + used, size - used, "\"state\":\"%s\",", session_state_to_str(session_get_state(sess)));
-    printf("session C2S first packet   : %p\n", session_get_1st_packet(sess, SESSION_DIRECTION_C2S));
+    used += snprintf(buff + used, size - used, "\"closing_reason\":\"%s\",", closing_reason_to_str(session_get_closing_reason(sess)));
-    printf("session S2C first packet   : %p\n", session_get_1st_packet(sess, SESSION_DIRECTION_S2C));
+    used += snprintf(buff + used, size - used, "\"dup_traffic\":%d,", session_has_dup_traffic(sess));
-    printf("session current packet     : %p (%s)\n", session_get_current_packet(sess), session_direction_to_str(session_get_current_direction(sess)));
+    used += snprintf(buff + used, size - used, "\"current_packet\":\"%p\",", session_get_current_packet(sess));
-    if (session_get_type(sess) == SESSION_TYPE_TCP)
-    {
-        memset(buffer, 0, sizeof(buffer));
-        tcp_flags_to_str(sess->tcp_halfs[SESSION_DIRECTION_C2S].flags, buffer, sizeof(buffer));
-        printf("TCP C2S half: seq: %u, ack: %u, flags: %s\n", sess->tcp_halfs[SESSION_DIRECTION_C2S].seq, sess->tcp_halfs[SESSION_DIRECTION_C2S].ack, buffer);
 
-        memset(buffer, 0, sizeof(buffer));
+    const char *str[] = {"c2s", "s2c"};
-        tcp_flags_to_str(sess->tcp_halfs[SESSION_DIRECTION_S2C].flags, buffer, sizeof(buffer));
+    enum session_direction dir[] = {SESSION_DIRECTION_C2S, SESSION_DIRECTION_S2C};
-        printf("TCP S2C half: seq: %u, ack: %u, flags: %s\n", sess->tcp_halfs[SESSION_DIRECTION_S2C].seq, sess->tcp_halfs[SESSION_DIRECTION_S2C].ack, buffer);
+    for (int i = 0; i < 2; i++)
-    }
-    // exdata
-    printf("session exdata:\n");
-    for (uint8_t i = 0; i < g_ex_manager.count; i++)
     {
-        printf("    idx: %d, key: %s, data: %p\n", i, g_ex_manager.schemas[i].key, sess->ex_data[i]);
+        if (session_get_type(sess) == SESSION_TYPE_TCP)
+        {
+            used += snprintf(buff + used, size - used, "\"%s_tcp_last_seq\":%u,", str[i], sess->tcp_halfs[dir[i]].seq);
+            used += snprintf(buff + used, size - used, "\"%s_tcp_last_ack\":%u,", str[i], sess->tcp_halfs[dir[i]].ack);
+            memset(flags, 0, sizeof(flags));
+            tcp_flags_to_str(sess->tcp_halfs[dir[i]].flags, flags, sizeof(flags));
+            used += snprintf(buff + used, size - used, "\"%s_tcp_flags\":\"%s\",", str[i], flags);
+            used += snprintf(buff + used, size - used, "\"%s_tcp_segs_rx\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_TCP_SEGS_RX));
+            used += snprintf(buff + used, size - used, "\"%s_tcp_plds_rx\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_TCP_PLDS_RX));
+            used += snprintf(buff + used, size - used, "\"%s_tcp_segs_expired\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_TCP_SEGS_EXPIRED));
+            used += snprintf(buff + used, size - used, "\"%s_tcp_plds_expired\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_TCP_PLDS_EXPIRED));
+            used += snprintf(buff + used, size - used, "\"%s_tcp_segs_overlap\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_TCP_SEGS_OVERLAP));
+            used += snprintf(buff + used, size - used, "\"%s_tcp_plds_overlap\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_TCP_PLDS_OVERLAP));
+            used += snprintf(buff + used, size - used, "\"%s_tcp_segs_nospace\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_TCP_SEGS_NOSPACE));
+            used += snprintf(buff + used, size - used, "\"%s_tcp_plds_nospace\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_TCP_PLDS_NOSPACE));
+            used += snprintf(buff + used, size - used, "\"%s_tcp_segs_inorder\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_TCP_SEGS_INORDER));
+            used += snprintf(buff + used, size - used, "\"%s_tcp_plds_inorder\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_TCP_PLDS_INORDER));
+            used += snprintf(buff + used, size - used, "\"%s_tcp_segs_reordered\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_TCP_SEGS_REORDERED));
+            used += snprintf(buff + used, size - used, "\"%s_tcp_plds_reordered\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_TCP_PLDS_REORDERED));
+            used += snprintf(buff + used, size - used, "\"%s_tcp_segs_buffered\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_TCP_SEGS_BUFFERED));
+            used += snprintf(buff + used, size - used, "\"%s_tcp_plds_buffered\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_TCP_PLDS_BUFFERED));
+            used += snprintf(buff + used, size - used, "\"%s_tcp_segs_released\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_TCP_SEGS_RELEASED));
+            used += snprintf(buff + used, size - used, "\"%s_tcp_plds_released\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_TCP_PLDS_RELEASED));
+        }
+
+        used += snprintf(buff + used, size - used, "\"%s_1st_pkt\":\"%p\",", str[i], session_get_1st_packet(sess, dir[i]));
+        used += snprintf(buff + used, size - used, "\"%s_raw_pkts_rx\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_RAW_PKTS_RX));
+        used += snprintf(buff + used, size - used, "\"%s_raw_bytes_rx\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_RAW_BYTES_RX));
+        used += snprintf(buff + used, size - used, "\"%s_raw_pkts_tx\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_RAW_PKTS_TX));
+        used += snprintf(buff + used, size - used, "\"%s_raw_bytes_tx\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_RAW_BYTES_TX));
+        used += snprintf(buff + used, size - used, "\"%s_raw_pkts_drop\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_RAW_PKTS_DROP));
+        used += snprintf(buff + used, size - used, "\"%s_raw_bytes_drop\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_RAW_BYTES_DROP));
+        used += snprintf(buff + used, size - used, "\"%s_dup_pkts_bypass\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_DUP_PKTS_BYPASS));
+        used += snprintf(buff + used, size - used, "\"%s_dup_bytes_bypass\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_DUP_BYTES_BYPASS));
+        used += snprintf(buff + used, size - used, "\"%s_ctrl_pkts_rx\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_CTRL_PKTS_RX));
+        used += snprintf(buff + used, size - used, "\"%s_ctrl_bytes_rx\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_CTRL_BYTES_RX));
+        used += snprintf(buff + used, size - used, "\"%s_ctrl_pkts_tx\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_CTRL_PKTS_TX));
+        used += snprintf(buff + used, size - used, "\"%s_ctrl_bytes_tx\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_CTRL_BYTES_TX));
+        used += snprintf(buff + used, size - used, "\"%s_ctrl_pkts_drop\":%" PRIu64 ",", str[i], session_get_stat(sess, dir[i], STAT_CTRL_PKTS_DROP));
+        used += snprintf(buff + used, size - used, "\"%s_ctrl_bytes_drop\":%" PRIu64 "", str[i], session_get_stat(sess, dir[i], STAT_CTRL_BYTES_DROP));
+
+        if (i == 0)
+        {
+            used += snprintf(buff + used, size - used, ",");
+        }
     }
-    // stats
+    used += snprintf(buff + used, size - used, "}");
-    printf("session stats:\n");
+
-    printf("+------------------------------------------------+\n");
+    return used;
-    printf("| %-20s | %-10s | %-10s |\n", "stat", "C2S", "S2C");
-    printf("+------------------------------------------------+\n");
-    printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "RAW_PKTS_RX", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_RAW_PKTS_RX), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_RAW_PKTS_RX));
-    printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "RAW_BYTES_RX", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_RAW_BYTES_RX), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_RAW_BYTES_RX));
-    printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "RAW_PKTS_TX", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_RAW_PKTS_TX), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_RAW_PKTS_TX));
-    printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "RAW_BYTES_TX", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_RAW_BYTES_TX), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_RAW_BYTES_TX));
-    printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "RAW_PKTS_DROP", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_RAW_PKTS_DROP), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_RAW_PKTS_DROP));
-    printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "RAW_BYTES_DROP", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_RAW_BYTES_DROP), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_RAW_BYTES_DROP));
-    printf("+------------------------------------------------+\n");
-    printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "DUP_PKTS_BYPASS", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_DUP_PKTS_BYPASS), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_DUP_PKTS_BYPASS));
-    printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "DUP_BYTES_BYPASS", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_DUP_BYTES_BYPASS), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_DUP_BYTES_BYPASS));
-    printf("+------------------------------------------------+\n");
-    printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "CTRL_PKTS_RX", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_CTRL_PKTS_RX), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_CTRL_PKTS_RX));
-    printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "CTRL_BYTES_RX", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_CTRL_BYTES_RX), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_CTRL_BYTES_RX));
-    printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "CTRL_PKTS_TX", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_CTRL_PKTS_TX), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_CTRL_PKTS_TX));
-    printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "CTRL_BYTES_TX", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_CTRL_BYTES_TX), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_CTRL_BYTES_TX));
-    printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "CTRL_PKTS_DROP", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_CTRL_PKTS_DROP), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_CTRL_PKTS_DROP));
-    printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "CTRL_BYTES_DROP", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_CTRL_BYTES_DROP), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_CTRL_BYTES_DROP));
-    printf("+------------------------------------------------+\n");
-    printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "TCP_SEGS_RX", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_TCP_SEGS_RX), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_TCP_SEGS_RX));
-    printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "TCP_PLDS_RX", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_TCP_PLDS_RX), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_TCP_PLDS_RX));
-    printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "TCP_SEGS_EXPIRED", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_TCP_SEGS_EXPIRED), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_TCP_SEGS_EXPIRED));
-    printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "TCP_PLDS_EXPIRED", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_TCP_PLDS_EXPIRED), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_TCP_PLDS_EXPIRED));
-    printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "TCP_SEGS_OVERLAP", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_TCP_SEGS_OVERLAP), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_TCP_SEGS_OVERLAP));
-    printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "TCP_PLDS_OVERLAP", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_TCP_PLDS_OVERLAP), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_TCP_PLDS_OVERLAP));
-    printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "TCP_SEGS_NOSPACE", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_TCP_SEGS_NOSPACE), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_TCP_SEGS_NOSPACE));
-    printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "TCP_PLDS_NOSPACE", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_TCP_PLDS_NOSPACE), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_TCP_PLDS_NOSPACE));
-    printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "TCP_SEGS_INORDER", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_TCP_SEGS_INORDER), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_TCP_SEGS_INORDER));
-    printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "TCP_PLDS_INORDER", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_TCP_PLDS_INORDER), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_TCP_PLDS_INORDER));
-    printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "TCP_SEGS_REORDERED", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_TCP_SEGS_REORDERED), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_TCP_SEGS_REORDERED));
-    printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "TCP_PLDS_REORDERED", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_TCP_PLDS_REORDERED), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_TCP_PLDS_REORDERED));
-    printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "TCP_SEGS_BUFFERED", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_TCP_SEGS_BUFFERED), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_TCP_SEGS_BUFFERED));
-    printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "TCP_PLDS_BUFFERED", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_TCP_PLDS_BUFFERED), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_TCP_PLDS_BUFFERED));
-    printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "TCP_SEGS_RELEASED", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_TCP_SEGS_RELEASED), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_TCP_SEGS_RELEASED));
-    printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "TCP_PLDS_RELEASED", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_TCP_PLDS_RELEASED), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_TCP_PLDS_RELEASED));
-    printf("+------------------------------------------------+\n");
 }
+
+void session_print(struct session *sess)
+{
+    char buff[4096];
+    session_to_json(sess, buff, sizeof(buff));
+    printf("%s\n", buff);
+}

src/session/session_private.h

@@ -118,7 +118,8 @@ void session_free_all_ex_data(struct session *sess);
  * debug
  ******************************************************************************/
 
-void session_dump(struct session *sess);
+void session_print(struct session *sess);
+int session_to_json(struct session *sess, char *buff, int size);
 
 #ifdef __cpluscplus
 }

src/session/test/gtest_sess_mgr_tcp_reassembly.cpp

@@ -235,7 +235,7 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
-    session_dump(sess);
+    session_print(sess);
     // free session
     session_manager_free_session(mgr, sess);
 
@@ -324,7 +324,7 @@ TEST(SESS_MGR_TCP_REASSEMBLY, SEQ_WRAPAROUND)
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
-    session_dump(sess);
+    session_print(sess);
     // free session
     session_manager_free_session(mgr, sess);
 

src/session/test/gtest_state_tcp_active_to_closing.cpp

@@ -132,7 +132,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_FIN_FIN)
     EXPECT_TRUE(session_get_current_direction(sess) == SESSION_DIRECTION_S2C);
     EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_C2S) != NULL);
     EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_S2C) != NULL);
-    session_dump(sess);
+    session_print(sess);
 
     // check stat
     session_manager_print_stat(mgr);
@@ -148,7 +148,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_FIN_FIN)
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
-    session_dump(sess);
+    session_print(sess);
     // free session
     session_manager_free_session(mgr, sess);
 
@@ -220,7 +220,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_RST)
     EXPECT_TRUE(session_get_current_direction(sess) == SESSION_DIRECTION_C2S);
     EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_C2S) != NULL);
     EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_S2C) == NULL);
-    session_dump(sess);
+    session_print(sess);
 
     // check stat
     session_manager_print_stat(mgr);
@@ -236,7 +236,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_RST)
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_RST);
-    session_dump(sess);
+    session_print(sess);
     // free session
     session_manager_free_session(mgr, sess);
 
@@ -308,7 +308,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_RST)
     EXPECT_TRUE(session_get_current_direction(sess) == SESSION_DIRECTION_S2C);
     EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_C2S) != NULL);
     EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_S2C) != NULL);
-    session_dump(sess);
+    session_print(sess);
 
     // check stat
     session_manager_print_stat(mgr);
@@ -324,7 +324,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_RST)
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_RST);
-    session_dump(sess);
+    session_print(sess);
     // free session
     session_manager_free_session(mgr, sess);
 
@@ -373,7 +373,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_DATA_TIMEOUT)
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
-    session_dump(sess);
+    session_print(sess);
     // free session
     session_manager_free_session(mgr, sess);
 
@@ -438,7 +438,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_HALF_CLOSED_TIMEOUT)
     EXPECT_TRUE(session_get_current_direction(sess) == SESSION_DIRECTION_C2S);
     EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_C2S) != NULL);
     EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_S2C) == NULL);
-    session_dump(sess);
+    session_print(sess);
 
     // check stat
     session_manager_print_stat(mgr);
@@ -454,7 +454,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_HALF_CLOSED_TIMEOUT)
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
-    session_dump(sess);
+    session_print(sess);
     // free session
     session_manager_free_session(mgr, sess);
 
@@ -519,7 +519,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_HALF_CLOSED_TIMEOUT)
     EXPECT_TRUE(session_get_current_direction(sess) == SESSION_DIRECTION_S2C);
     EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_C2S) != NULL);
     EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_S2C) != NULL);
-    session_dump(sess);
+    session_print(sess);
 
     // check stat
     session_manager_print_stat(mgr);
@@ -535,7 +535,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_HALF_CLOSED_TIMEOUT)
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_FIN);
-    session_dump(sess);
+    session_print(sess);
     // free session
     session_manager_free_session(mgr, sess);
 

src/session/test/gtest_state_tcp_init_to_opening.cpp

@@ -91,7 +91,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN)
     EXPECT_TRUE(session_get_current_direction(sess) == SESSION_DIRECTION_C2S);
     EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_C2S) != NULL);
     EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_S2C) == NULL);
-    session_dump(sess);
+    session_print(sess);
 
     // check stat
     session_manager_print_stat(mgr);
@@ -108,7 +108,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN)
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
-    session_dump(sess);
+    session_print(sess);
     // free session
     session_manager_free_session(mgr, sess);
 
@@ -170,7 +170,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK)
     EXPECT_TRUE(session_get_current_direction(sess) == SESSION_DIRECTION_S2C);
     EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_C2S) == NULL);
     EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_S2C) != NULL);
-    session_dump(sess);
+    session_print(sess);
 
     // check stat
     session_manager_print_stat(mgr);
@@ -187,7 +187,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK)
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
-    session_dump(sess);
+    session_print(sess);
     // free session
     session_manager_free_session(mgr, sess);
 
@@ -260,7 +260,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK)
     EXPECT_TRUE(session_get_current_direction(sess) == SESSION_DIRECTION_S2C);
     EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_C2S) != NULL);
     EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_S2C) != NULL);
-    session_dump(sess);
+    session_print(sess);
 
     // check stat
     session_manager_print_stat(mgr);
@@ -277,7 +277,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK)
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
-    session_dump(sess);
+    session_print(sess);
     // free session
     session_manager_free_session(mgr, sess);
 
@@ -361,7 +361,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK_ACK)
     EXPECT_TRUE(session_get_current_direction(sess) == SESSION_DIRECTION_C2S);
     EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_C2S) != NULL);
     EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_S2C) != NULL);
-    session_dump(sess);
+    session_print(sess);
 
     // check stat
     session_manager_print_stat(mgr);
@@ -378,7 +378,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK_ACK)
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
-    session_dump(sess);
+    session_print(sess);
     // free session
     session_manager_free_session(mgr, sess);
 
@@ -458,7 +458,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_RETRANSMISSION)
     EXPECT_TRUE(session_get_current_direction(sess) == SESSION_DIRECTION_C2S);
     EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_C2S) != NULL);
     EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_S2C) == NULL);
-    session_dump(sess);
+    session_print(sess);
 
     // check stat
     session_manager_print_stat(mgr);
@@ -475,7 +475,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_RETRANSMISSION)
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
-    session_dump(sess);
+    session_print(sess);
     // free session
     session_manager_free_session(mgr, sess);
 
@@ -556,7 +556,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK_RETRANSMISSION)
     EXPECT_TRUE(session_get_current_direction(sess) == SESSION_DIRECTION_S2C);
     EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_C2S) == NULL);
     EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_S2C) != NULL);
-    session_dump(sess);
+    session_print(sess);
 
     // check stat
     session_manager_print_stat(mgr);
@@ -573,7 +573,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK_RETRANSMISSION)
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
-    session_dump(sess);
+    session_print(sess);
     // free session
     session_manager_free_session(mgr, sess);
 
@@ -646,7 +646,7 @@ TEST(TCP_INIT_TO_OPENING, BY_C2S_ASMMETRIC)
     EXPECT_TRUE(session_get_current_direction(sess) == SESSION_DIRECTION_C2S);
     EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_C2S) != NULL);
     EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_S2C) == NULL);
-    session_dump(sess);
+    session_print(sess);
 
     // check stat
     session_manager_print_stat(mgr);
@@ -663,7 +663,7 @@ TEST(TCP_INIT_TO_OPENING, BY_C2S_ASMMETRIC)
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
-    session_dump(sess);
+    session_print(sess);
     // free session
     session_manager_free_session(mgr, sess);
 
@@ -736,7 +736,7 @@ TEST(TCP_INIT_TO_OPENING, BY_S2C_ASMMETRIC)
     EXPECT_TRUE(session_get_current_direction(sess) == SESSION_DIRECTION_S2C);
     EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_C2S) == NULL);
     EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_S2C) != NULL);
-    session_dump(sess);
+    session_print(sess);
 
     // check stat
     session_manager_print_stat(mgr);
@@ -753,7 +753,7 @@ TEST(TCP_INIT_TO_OPENING, BY_S2C_ASMMETRIC)
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
-    session_dump(sess);
+    session_print(sess);
     // free session
     session_manager_free_session(mgr, sess);
 

src/session/test/gtest_state_tcp_init_to_opening_to_active_to_closing_to_closed.cpp

@@ -412,7 +412,7 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
-    session_dump(sess);
+    session_print(sess);
     // free session
     session_manager_free_session(mgr, sess);
 

src/session/test/gtest_state_tcp_opening_to_active.cpp

@@ -101,7 +101,7 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYN_C2S_DATA)
     EXPECT_TRUE(session_get_current_direction(sess) == SESSION_DIRECTION_C2S);
     EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_C2S) != NULL);
     EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_S2C) == NULL);
-    session_dump(sess);
+    session_print(sess);
 
     // check stat
     session_manager_print_stat(mgr);
@@ -118,7 +118,7 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYN_C2S_DATA)
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
-    session_dump(sess);
+    session_print(sess);
     // free session
     session_manager_free_session(mgr, sess);
 
@@ -191,7 +191,7 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYNACK_S2C_DATA)
     EXPECT_TRUE(session_get_current_direction(sess) == SESSION_DIRECTION_S2C);
     EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_C2S) == NULL);
     EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_S2C) != NULL);
-    session_dump(sess);
+    session_print(sess);
 
     // check stat
     session_manager_print_stat(mgr);
@@ -208,7 +208,7 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYNACK_S2C_DATA)
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
-    session_dump(sess);
+    session_print(sess);
     // free session
     session_manager_free_session(mgr, sess);
 

src/session/test/gtest_state_tcp_opening_to_closing.cpp

@@ -113,7 +113,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_FIN_FIN)
     EXPECT_TRUE(session_get_current_direction(sess) == SESSION_DIRECTION_S2C);
     EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_C2S) != NULL);
     EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_S2C) != NULL);
-    session_dump(sess);
+    session_print(sess);
 
     // check stat
     session_manager_print_stat(mgr);
@@ -129,7 +129,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_FIN_FIN)
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
-    session_dump(sess);
+    session_print(sess);
     // free session
     session_manager_free_session(mgr, sess);
 
@@ -209,7 +209,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_RST)
     EXPECT_TRUE(session_get_current_direction(sess) == SESSION_DIRECTION_C2S);
     EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_C2S) != NULL);
     EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_S2C) == NULL);
-    session_dump(sess);
+    session_print(sess);
 
     // check stat
     session_manager_print_stat(mgr);
@@ -225,7 +225,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_RST)
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_RST);
-    session_dump(sess);
+    session_print(sess);
     // free session
     session_manager_free_session(mgr, sess);
 
@@ -305,7 +305,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_RST)
     EXPECT_TRUE(session_get_current_direction(sess) == SESSION_DIRECTION_S2C);
     EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_C2S) != NULL);
     EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_S2C) != NULL);
-    session_dump(sess);
+    session_print(sess);
 
     // check stat
     session_manager_print_stat(mgr);
@@ -321,7 +321,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_RST)
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_RST);
-    session_dump(sess);
+    session_print(sess);
     // free session
     session_manager_free_session(mgr, sess);
 
@@ -379,7 +379,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_INIT_TIMEOUT)
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
-    session_dump(sess);
+    session_print(sess);
     // free session
     session_manager_free_session(mgr, sess);
 
@@ -452,7 +452,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_HANDSHAKE_TIMEOUT)
     EXPECT_TRUE(session_get_current_direction(sess) == SESSION_DIRECTION_S2C);
     EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_C2S) != NULL);
     EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_S2C) != NULL);
-    session_dump(sess);
+    session_print(sess);
 
     // check stat
     session_manager_print_stat(mgr);
@@ -469,7 +469,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_HANDSHAKE_TIMEOUT)
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
-    session_dump(sess);
+    session_print(sess);
     // free session
     session_manager_free_session(mgr, sess);
 
@@ -553,7 +553,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_DATA_TIMEOUT)
     EXPECT_TRUE(session_get_current_direction(sess) == SESSION_DIRECTION_C2S);
     EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_C2S) != NULL);
     EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_S2C) != NULL);
-    session_dump(sess);
+    session_print(sess);
 
     // check stat
     session_manager_print_stat(mgr);
@@ -570,7 +570,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_DATA_TIMEOUT)
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
-    session_dump(sess);
+    session_print(sess);
     // free session
     session_manager_free_session(mgr, sess);
 
@@ -643,7 +643,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_HALF_FIN)
     EXPECT_TRUE(session_get_current_direction(sess) == SESSION_DIRECTION_C2S);
     EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_C2S) != NULL);
     EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_S2C) == NULL);
-    session_dump(sess);
+    session_print(sess);
 
     // check stat
     session_manager_print_stat(mgr);
@@ -659,7 +659,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_HALF_FIN)
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
-    session_dump(sess);
+    session_print(sess);
     // free session
     session_manager_free_session(mgr, sess);
 
@@ -732,7 +732,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_HALF_FIN)
     EXPECT_TRUE(session_get_current_direction(sess) == SESSION_DIRECTION_S2C);
     EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_C2S) != NULL);
     EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_S2C) != NULL);
-    session_dump(sess);
+    session_print(sess);
 
     // check stat
     session_manager_print_stat(mgr);
@@ -748,7 +748,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_HALF_FIN)
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_FIN);
-    session_dump(sess);
+    session_print(sess);
     // free session
     session_manager_free_session(mgr, sess);
 

src/session/test/gtest_state_udp_init_to_opening_to_active_to_closing.cpp

@@ -116,7 +116,7 @@ TEST(UDP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING, TEST)
     EXPECT_TRUE(session_get_current_direction(sess) == SESSION_DIRECTION_S2C);
     EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_C2S) != NULL);
     EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_S2C) != NULL);
-    session_dump(sess);
+    session_print(sess);
 
     // check stat
     session_manager_print_stat(mgr);
@@ -133,7 +133,7 @@ TEST(UDP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING, TEST)
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
-    session_dump(sess);
+    session_print(sess);
     // free session
     session_manager_free_session(mgr, sess);
 

src/session/test/gtest_state_udp_init_to_opening_to_closing.cpp

@@ -91,7 +91,7 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_C2S)
     EXPECT_TRUE(session_get_current_direction(sess) == SESSION_DIRECTION_C2S);
     EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_C2S) != NULL);
     EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_S2C) == NULL);
-    session_dump(sess);
+    session_print(sess);
 
     // check stat
     session_manager_print_stat(mgr);
@@ -108,7 +108,7 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_C2S)
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
-    session_dump(sess);
+    session_print(sess);
     // free session
     session_manager_free_session(mgr, sess);
 
@@ -171,7 +171,7 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_S2C)
     EXPECT_TRUE(session_get_current_direction(sess) == SESSION_DIRECTION_S2C);
     EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_C2S) == NULL);
     EXPECT_TRUE(session_get_1st_packet(sess, SESSION_DIRECTION_S2C) != NULL);
-    session_dump(sess);
+    session_print(sess);
 
     // check stat
     session_manager_print_stat(mgr);
@@ -189,7 +189,7 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_S2C)
 
     EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
-    session_dump(sess);
+    session_print(sess);
 
     // free session
     session_manager_free_session(mgr, sess);

src/session/test/gtest_timeout_tcp_data.cpp

@@ -82,7 +82,7 @@ TEST(TIMEOUT, TCP_TIMEOUT_DATA)
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
-    session_dump(sess);
+    session_print(sess);
     // free session
     session_manager_free_session(mgr, sess);
 

src/session/test/gtest_timeout_tcp_handshake.cpp

@@ -72,7 +72,7 @@ TEST(TIMEOUT, TCP_TIMEOUT_HANDSHAKE)
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
-    session_dump(sess);
+    session_print(sess);
     // free session
     session_manager_free_session(mgr, sess);
 

src/session/test/gtest_timeout_tcp_init.cpp

@@ -72,7 +72,7 @@ TEST(TIMEOUT, TCP_TIMEOUT_INIT)
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
-    session_dump(sess);
+    session_print(sess);
     // free session
     session_manager_free_session(mgr, sess);
 

src/session/test/gtest_timeout_udp_data.cpp

@@ -71,7 +71,7 @@ TEST(TIMEOUT, UDP_TIMEOUT_DATA1)
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
-    session_dump(sess);
+    session_print(sess);
     // free session
     session_manager_free_session(mgr, sess);
 
@@ -117,7 +117,7 @@ TEST(TIMEOUT, UDP_TIMEOUT_DATA2)
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
-    session_dump(sess);
+    session_print(sess);
     // free session
     session_manager_free_session(mgr, sess);
 

src/stellar/stellar.cpp

@@ -59,19 +59,19 @@ static void signal_handler(int signo)
 {
     if (signo == SIGINT)
     {
-        STELLAR_LOG_STATE("SIGINT received, exit !!!");
+        STELLAR_LOG_STATE("SIGINT received, notify threads to exit !!!");
         ATOMIC_SET(&runtime->need_exit, 1);
     }
 
     if (signo == SIGQUIT)
     {
-        STELLAR_LOG_STATE("SIGQUIT received, exit !!!");
+        STELLAR_LOG_STATE("SIGQUIT received, notify threads to exit !!!");
         ATOMIC_SET(&runtime->need_exit, 1);
     }
 
     if (signo == SIGTERM)
     {
-        STELLAR_LOG_STATE("SIGTERM received, exit !!!");
+        STELLAR_LOG_STATE("SIGTERM received, notify threads to exit !!!");
         ATOMIC_SET(&runtime->need_exit, 1);
     }
 
@@ -84,22 +84,22 @@ static void signal_handler(int signo)
 
 static void execute_packet_action(struct packet_io *packet_io, struct session *sess, struct packet *pkt, uint16_t thr_idx)
 {
-    enum packet_action action = packet_get_action(pkt);
+    int is_ctrl = packet_is_ctrl(pkt);
-    enum packet_type type = packet_get_type(pkt);
+    int need_drop = packet_need_drop(pkt);
 
-    if (sess)
+    if (sess != NULL)
     {
         enum session_stat stat_pkt;
         enum session_stat stat_byte;
-        if (action == PACKET_ACTION_DROP)
+        if (need_drop)
         {
-            stat_pkt = (type == PACKET_TYPE_CTRL) ? STAT_CTRL_PKTS_DROP : STAT_RAW_PKTS_DROP;
+            stat_pkt = is_ctrl ? STAT_CTRL_PKTS_DROP : STAT_RAW_PKTS_DROP;
-            stat_byte = (type == PACKET_TYPE_CTRL) ? STAT_CTRL_BYTES_DROP : STAT_RAW_BYTES_DROP;
+            stat_byte = is_ctrl ? STAT_CTRL_BYTES_DROP : STAT_RAW_BYTES_DROP;
         }
         else
         {
-            stat_pkt = (type == PACKET_TYPE_CTRL) ? STAT_CTRL_PKTS_TX : STAT_RAW_PKTS_TX;
+            stat_pkt = is_ctrl ? STAT_CTRL_PKTS_TX : STAT_RAW_PKTS_TX;
-            stat_byte = (type == PACKET_TYPE_CTRL) ? STAT_CTRL_BYTES_TX : STAT_RAW_BYTES_TX;
+            stat_byte = is_ctrl ? STAT_CTRL_BYTES_TX : STAT_RAW_BYTES_TX;
         }
 
         session_inc_stat(sess, session_get_current_direction(sess), stat_pkt, 1);
@@ -108,7 +108,7 @@ static void execute_packet_action(struct packet_io *packet_io, struct session *s
         session_set_current_direction(sess, SESSION_DIRECTION_NONE);
     }
 
-    if (action == PACKET_ACTION_DROP)
+    if (need_drop)
     {
         packet_io_drop(packet_io, thr_idx, pkt, 1);
     }
@@ -168,6 +168,7 @@ static void *work_thread(void *arg)
 
         for (int i = 0; i < nr_recv; i++)
         {
+            sess = NULL;
             pkt = &packets[i];
 
             plugin_manager_dispatch_packet(plug_mgr, pkt);
@@ -237,7 +238,7 @@ static void *work_thread(void *arg)
     }
 
     ATOMIC_SET(&thr_ctx->is_runing, 0);
-    STELLAR_LOG_STATE("worker thread %d stop", thr_idx);
+    STELLAR_LOG_STATE("worker thread %d exit !!!", thr_idx);
 
     return NULL;
 }
@@ -315,7 +316,9 @@ static void stellar_thread_join(struct stellar_runtime *ctx, uint8_t nr_threads)
 
 int main(int argc, char **argv)
 {
+    uint8_t nr_threads;
     memset(runtime, 0, sizeof(struct stellar_runtime));
+    memset(config, 0, sizeof(struct stellar_config));
     timestamp_update();
 
     signal(SIGINT, signal_handler);
@@ -326,31 +329,31 @@ int main(int argc, char **argv)
     if (log_init(log_config_file) != 0)
     {
         STELLAR_LOG_ERROR("unable to init log");
-        return -1;
+        goto error_out;
     }
-    STELLAR_LOG_STATE("Start Stellar (version: %s)\n %s", __stellar_version, logo_str);
+    STELLAR_LOG_STATE("start stellar (version: %s)\n %s", __stellar_version, logo_str);
 
     if (stellar_config_load(stellar_config_file, config) != 0)
     {
         STELLAR_LOG_ERROR("unable to load config file");
-        return -1;
+        goto error_out;
     }
     stellar_config_print(config);
 
     if (id_generator_init(config->dev_opts.base, config->dev_opts.offset) != 0)
     {
         STELLAR_LOG_ERROR("unable to init id generator");
-        return -1;
+        goto error_out;
     }
 
     runtime->plug_mgr = plugin_manager_new();
     if (runtime->plug_mgr == NULL)
     {
         STELLAR_LOG_ERROR("unable to create plugin manager");
-        return -1;
+        goto error_out;
     }
 
-    uint8_t nr_threads = config->io_opts.nr_threads;
+    nr_threads = config->io_opts.nr_threads;
     runtime->packet_io = packet_io_new(&config->io_opts);
     if (runtime->packet_io == NULL)
     {
@@ -373,7 +376,7 @@ int main(int argc, char **argv)
     while (!ATOMIC_READ(&runtime->need_exit))
     {
         timestamp_update();
-        sleep(1);
+        usleep(5 * 1000);
     }
 
 error_out:
@@ -381,7 +384,7 @@ error_out:
     stellar_thread_clean(runtime, nr_threads);
     packet_io_free(runtime->packet_io);
     plugin_manager_free(runtime->plug_mgr);
-
+    STELLAR_LOG_STATE("stellar exit !!!\n");
     log_free();
 
     return 0;

src/tcp_reassembly/tcp_reassembly.cpp

@@ -130,7 +130,7 @@ struct tcp_segment *tcp_reassembly_pop(struct tcp_reassembly *assembler)
     }
 
     uint64_t min_id = UINT64_MAX;
-    struct tcp_segment_private *oldest;
+    struct tcp_segment_private *oldest = NULL;
     while (node)
     {
         struct tcp_segment_private *p = container_of(node, struct tcp_segment_private, node);