Refactored packet API to support struct layer (using union to contain different types of encapsulation headers)

src/session/session.cpp

@@ -146,19 +146,19 @@ uint64_t session_get_timestamp(const struct session *sess, enum session_timestam
     return sess->timestamps[type];
 }
 
-void session_clear_sid_list(struct session *sess, enum flow_direction dir)
+void session_clear_sids(struct session *sess, enum flow_direction dir)
 {
-    memset(&sess->sids[dir], 0, sizeof(struct sid_list));
+    memset(&sess->sids[dir], 0, sizeof(struct sids));
 }
 
-void session_set_sid_list(struct session *sess, enum flow_direction dir, const struct sid_list *list)
+void session_set_sids(struct session *sess, enum flow_direction dir, const struct sids *sids)
 {
-    sess->sids[dir] = *list;
+    sess->sids[dir] = *sids;
 }
 
-void session_get_sid_list(const struct session *sess, enum flow_direction dir, struct sid_list *list)
+const struct sids *session_get_sids(const struct session *sess, enum flow_direction dir)
 {
-    *list = sess->sids[dir];
+    return &sess->sids[dir];
 }
 
 void session_clear_route_ctx(struct session *sess, enum flow_direction dir)
@@ -171,9 +171,9 @@ void session_set_route_ctx(struct session *sess, enum flow_direction dir, const
     sess->route_ctx[dir] = *ctx;
 }
 
-void session_get_route_ctx(const struct session *sess, enum flow_direction dir, struct route_ctx *ctx)
+const struct route_ctx *session_get_route_ctx(const struct session *sess, enum flow_direction dir)
 {
-    *ctx = sess->route_ctx[dir];
+    return &sess->route_ctx[dir];
 }
 
 void session_set_first_packet(struct session *sess, enum flow_direction dir, const struct packet *pkt)
@@ -196,7 +196,7 @@ const struct packet *session_get0_current_packet(const struct session *sess)
     return sess->curr_pkt;
 }
 
-const char *session_get0_current_payload(const struct session *sess, size_t *payload_len)
+const char *session_get0_current_payload(const struct session *sess, uint16_t *payload_len)
 {
     const struct packet *pkt = session_get0_current_packet(sess);
     if (pkt)

src/session/session_manager.cpp

@@ -488,7 +488,7 @@ static int duplicated_packet_bypass(struct session_manager *mgr, struct session
           if (duplicated_packet_filter_lookup(mgr->dup_pkt_filter, pkt, now))
           {
                session_inc_stat(sess, dir, STAT_DUPLICATE_PACKETS_BYPASS, 1);
-               session_inc_stat(sess, dir, STAT_DUPLICATE_BYTES_BYPASS, packet_get_len(pkt));
+               session_inc_stat(sess, dir, STAT_DUPLICATE_BYTES_BYPASS, packet_get_raw_len(pkt));
                switch (session_get_type(sess))
                {
                case SESSION_TYPE_TCP:
@@ -572,18 +572,13 @@ static void session_update(struct session *sess, enum session_state next_state,
      }
 
      session_inc_stat(sess, dir, STAT_RAW_PACKETS_RECEIVED, 1);
-     session_inc_stat(sess, dir, STAT_RAW_BYTES_RECEIVED, packet_get_len(pkt));
+     session_inc_stat(sess, dir, STAT_RAW_BYTES_RECEIVED, packet_get_raw_len(pkt));
 
      if (!session_get_first_packet(sess, dir))
      {
-          struct route_ctx ctx = {0};
-          struct sid_list list = {0};
-          packet_get_route_ctx(pkt, &ctx);
-          packet_get_sid_list(pkt, &list);
-
           session_set_first_packet(sess, dir, packet_dup(pkt));
-          session_set_route_ctx(sess, dir, &ctx);
-          session_set_sid_list(sess, dir, &list);
+          session_set_route_ctx(sess, dir, packet_get_route_ctx(pkt));
+          session_set_sids(sess, dir, packet_get_sids(pkt));
      }
 
      session_set_current_packet(sess, pkt);
@@ -1044,8 +1039,8 @@ void session_manager_free_session(struct session_manager *mgr, struct session *s
           session_set_first_packet(sess, FLOW_DIRECTION_S2C, NULL);
           session_clear_route_ctx(sess, FLOW_DIRECTION_C2S);
           session_clear_route_ctx(sess, FLOW_DIRECTION_S2C);
-          session_clear_sid_list(sess, FLOW_DIRECTION_C2S);
-          session_clear_sid_list(sess, FLOW_DIRECTION_S2C);
+          session_clear_sids(sess, FLOW_DIRECTION_C2S);
+          session_clear_sids(sess, FLOW_DIRECTION_S2C);
           session_set_current_packet(sess, NULL);
           session_set_current_flow_direction(sess, FLOW_DIRECTION_NONE);
           session_pool_push(mgr->sess_pool, sess);

src/session/session_priv.h

@@ -8,6 +8,7 @@ extern "C"
 
 #include "list.h"
 #include "packet_priv.h"
+#include "packet_utils.h"
 #include "timeout.h"
 #include "uthash.h"
 #include "tuple.h"
@@ -62,7 +63,7 @@ struct session
     UT_hash_handle hh3;
     struct tuple6 tuple;
     char tuple_str[TUPLE6_STR_SIZE];
-    struct sid_list sids[MAX_FLOW_DIRECTION];
+    struct sids sids[MAX_FLOW_DIRECTION];
     struct route_ctx route_ctx[MAX_FLOW_DIRECTION];
     const struct packet *first_pkt[MAX_FLOW_DIRECTION];
     const struct packet *curr_pkt;
@@ -98,13 +99,13 @@ void session_set_closing_reason(struct session *sess, enum closing_reason reason
 void session_inc_stat(struct session *sess, enum flow_direction dir, enum session_stat stat, uint64_t val);
 void session_set_timestamp(struct session *sess, enum session_timestamp type, uint64_t value);
 
-void session_clear_sid_list(struct session *sess, enum flow_direction dir);
-void session_set_sid_list(struct session *sess, enum flow_direction dir, const struct sid_list *list);
-void session_get_sid_list(const struct session *sess, enum flow_direction dir, struct sid_list *list);
+void session_clear_sids(struct session *sess, enum flow_direction dir);
+void session_set_sids(struct session *sess, enum flow_direction dir, const struct sids *sids);
+const struct sids *session_get_sids(const struct session *sess, enum flow_direction dir);
 
 void session_clear_route_ctx(struct session *sess, enum flow_direction dir);
 void session_set_route_ctx(struct session *sess, enum flow_direction dir, const struct route_ctx *ctx);
-void session_get_route_ctx(const struct session *sess, enum flow_direction dir, struct route_ctx *ctx);
+const struct route_ctx *session_get_route_ctx(const struct session *sess, enum flow_direction dir);
 
 void session_set_first_packet(struct session *sess, enum flow_direction dir, const struct packet *pkt);
 void session_set_current_packet(struct session *sess, const struct packet *pkt);

src/session/test/gtest_case_tcp_fast_open.cpp

@@ -309,6 +309,7 @@ TEST(CASE, TCP_FAST_OPEN)
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S fast open packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_fast_open_pkt, sizeof(tcp_fast_open_pkt));
     printf("<= Packet Parse: done\n\n");
 

src/session/test/gtest_filter_tcp_dupkt.cpp

@@ -66,6 +66,7 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYN_DUP)
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
     printf("<= Packet Parse: done\n\n");
 
@@ -81,6 +82,7 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYN_DUP)
 
     // C2S SYN dup Packet
     printf("\n=> Packet Parse: TCP C2S SYN dup packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
     printf("<= Packet Parse: done\n\n");
 
@@ -98,6 +100,7 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYN_DUP)
     printf("\n=> Packet Parse: TCP C2S SYN retransmission packet\n");
     char syn_retransmission[1500] = {0};
     memcpy(syn_retransmission, tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)syn_retransmission, sizeof(tcp_pkt1_c2s_syn));
     packet_set_ip_id(&pkt, 0x1234);
     printf("<= Packet Parse: done\n\n");
@@ -129,6 +132,7 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYNACK_DUP)
 
     // S2C SYNACK Packet
     printf("\n=> Packet Parse: TCP S2C SYNACK packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt2_s2c_syn_ack, sizeof(tcp_pkt2_s2c_syn_ack));
     printf("<= Packet Parse: done\n\n");
 
@@ -144,6 +148,7 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYNACK_DUP)
 
     // S2C SYNACK dup Packet
     printf("\n=> Packet Parse: TCP S2C SYNACK dup packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt2_s2c_syn_ack, sizeof(tcp_pkt2_s2c_syn_ack));
     printf("<= Packet Parse: done\n\n");
 
@@ -161,6 +166,7 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYNACK_DUP)
     printf("\n=> Packet Parse: TCP S2C SYNACK retransmission packet\n");
     char synack_retransmission[1500] = {0};
     memcpy(synack_retransmission, tcp_pkt2_s2c_syn_ack, sizeof(tcp_pkt2_s2c_syn_ack));
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)synack_retransmission, sizeof(tcp_pkt2_s2c_syn_ack));
     packet_set_ip_id(&pkt, 0x1234);
     printf("<= Packet Parse: done\n\n");
@@ -193,6 +199,7 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SKIP)
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
     printf("<= Packet Parse: done\n\n");
 
@@ -209,6 +216,7 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SKIP)
     // C2S SYN retransmission Packet
     printf("\n=> Packet Parse: TCP C2S SYN retransmission packet\n");
     memcpy(syn_retransmission, tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)syn_retransmission, sizeof(tcp_pkt1_c2s_syn));
     packet_set_ip_id(&pkt, 0x1234);
     printf("<= Packet Parse: done\n\n");
@@ -226,6 +234,7 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SKIP)
     // C2S SYN retransmission Packet
     printf("\n=> Packet Parse: TCP C2S SYN retransmission packet\n");
     memcpy(syn_retransmission, tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)syn_retransmission, sizeof(tcp_pkt1_c2s_syn));
     packet_set_ip_id(&pkt, 0x1235);
     printf("<= Packet Parse: done\n\n");
@@ -242,6 +251,7 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SKIP)
 
     // C2S SYN dup Packet
     printf("\n=> Packet Parse: TCP C2S SYN dup packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
     printf("<= Packet Parse: done\n\n");
 
@@ -275,6 +285,7 @@ TEST(TCP_DUPKT_FILTER_DISABLE, SYN_DUP)
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
     printf("<= Packet Parse: done\n\n");
 
@@ -290,6 +301,7 @@ TEST(TCP_DUPKT_FILTER_DISABLE, SYN_DUP)
 
     // C2S SYN dup Packet
     printf("\n=> Packet Parse: TCP C2S SYN dup packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
     printf("<= Packet Parse: done\n\n");
 
@@ -323,6 +335,7 @@ TEST(TCP_DUPKT_FILTER_DISABLE, SYNACK_DUP)
 
     // S2C SYNACK Packet
     printf("\n=> Packet Parse: TCP S2C SYNACK packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt2_s2c_syn_ack, sizeof(tcp_pkt2_s2c_syn_ack));
     printf("<= Packet Parse: done\n\n");
 
@@ -338,6 +351,7 @@ TEST(TCP_DUPKT_FILTER_DISABLE, SYNACK_DUP)
 
     // S2C SYNACK dup Packet
     printf("\n=> Packet Parse: TCP S2C SYNACK dup packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt2_s2c_syn_ack, sizeof(tcp_pkt2_s2c_syn_ack));
     printf("<= Packet Parse: done\n\n");
 

src/session/test/gtest_overload_evict_tcp_sess.cpp

@@ -67,6 +67,7 @@ TEST(TCP_OVERLOAD, EVICT_OLD_SESS)
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
     printf("<= Packet Parse: done\n\n");
 
@@ -107,6 +108,7 @@ TEST(TCP_OVERLOAD, EVICT_NEW_SESS)
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
     printf("<= Packet Parse: done\n\n");
 

src/session/test/gtest_overload_evict_udp_sess.cpp

@@ -68,6 +68,7 @@ TEST(UDP_OVERLOAD, EVICT_OLD_SESS)
 
     // C2S REQ Packet
     printf("\n=> Packet Parse: UDP C2S REQ packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)udp_pkt1_dns_req, sizeof(udp_pkt1_dns_req));
     printf("<= Packet Parse: done\n\n");
 
@@ -156,6 +157,7 @@ TEST(UDP_OVERLOAD, EVICT_NEW_SESS)
 
     // C2S REQ Packet
     printf("\n=> Packet Parse: UDP C2S REQ packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)udp_pkt1_dns_req, sizeof(udp_pkt1_dns_req));
     printf("<= Packet Parse: done\n\n");
 

src/session/test/gtest_sess_mgr_tcp_reassembly.cpp

@@ -72,6 +72,7 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_out_of_order_pkt1, sizeof(tcp_out_of_order_pkt1));
     printf("<= Packet Parse: done\n\n");
 
@@ -86,6 +87,7 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
 
     // C2S ACK Packet
     printf("\n=> Packet Parse: TCP C2S ACK packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_out_of_order_pkt2, sizeof(tcp_out_of_order_pkt2));
     printf("<= Packet Parse: done\n\n");
 
@@ -100,6 +102,7 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
 
     // C2S Data Packet 2222
     printf("\n=> Packet Parse: TCP C2S Data packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_out_of_order_pkt3, sizeof(tcp_out_of_order_pkt3));
     printf("<= Packet Parse: done\n\n");
 
@@ -114,6 +117,7 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
 
     // C2S Data Packet 3333
     printf("\n=> Packet Parse: TCP C2S Data packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_out_of_order_pkt4, sizeof(tcp_out_of_order_pkt4));
     printf("<= Packet Parse: done\n\n");
 
@@ -128,6 +132,7 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
 
     // C2S Data Packet 4444
     printf("\n=> Packet Parse: TCP C2S Data packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_out_of_order_pkt5, sizeof(tcp_out_of_order_pkt5));
     printf("<= Packet Parse: done\n\n");
 
@@ -142,6 +147,7 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
 
     // C2S Data Packet 5555
     printf("\n=> Packet Parse: TCP C2S Data packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_out_of_order_pkt6, sizeof(tcp_out_of_order_pkt6));
     printf("<= Packet Parse: done\n\n");
 
@@ -156,6 +162,7 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
 
     // C2S Data Packet 1111
     printf("\n=> Packet Parse: TCP C2S Data packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_out_of_order_pkt7, sizeof(tcp_out_of_order_pkt7));
     printf("<= Packet Parse: done\n\n");
 
@@ -256,6 +263,7 @@ TEST(SESS_MGR_TCP_REASSEMBLY, SEQ_WRAPAROUND)
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_seq_wraparound_pkt1, sizeof(tcp_seq_wraparound_pkt1));
     printf("<= Packet Parse: done\n\n");
 
@@ -270,6 +278,7 @@ TEST(SESS_MGR_TCP_REASSEMBLY, SEQ_WRAPAROUND)
 
     // C2S ACK Packet
     printf("\n=> Packet Parse: TCP C2S ACK packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_seq_wraparound_pkt2, sizeof(tcp_seq_wraparound_pkt2));
     printf("<= Packet Parse: done\n\n");
 
@@ -284,6 +293,7 @@ TEST(SESS_MGR_TCP_REASSEMBLY, SEQ_WRAPAROUND)
 
     // C2S Data Packet
     printf("\n=> Packet Parse: TCP C2S Data packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_seq_wraparound_pkt3, sizeof(tcp_seq_wraparound_pkt3));
     printf("<= Packet Parse: done\n\n");
 
@@ -302,6 +312,7 @@ TEST(SESS_MGR_TCP_REASSEMBLY, SEQ_WRAPAROUND)
 
     // C2S Data Packet
     printf("\n=> Packet Parse: TCP C2S Data packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_seq_wraparound_pkt4, sizeof(tcp_seq_wraparound_pkt4));
     printf("<= Packet Parse: done\n\n");
 

src/session/test/gtest_state_tcp_active_to_closing.cpp

@@ -53,6 +53,7 @@ static void build_active_tcp_session(struct session_manager *mgr, struct session
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
     printf("<= Packet Parse: done\n\n");
 
@@ -64,6 +65,7 @@ static void build_active_tcp_session(struct session_manager *mgr, struct session
 
     // C2S DATA Packet
     printf("\n=> Packet Parse: TCP C2S DATA packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt4_c2s_http_req, sizeof(tcp_pkt4_c2s_http_req));
     printf("<= Packet Parse: done\n\n");
 
@@ -96,6 +98,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_FIN_FIN)
 
     // C2S FIN Packet
     printf("\n=> Packet Parse: TCP C2S FIN packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt9_c2s_fin, sizeof(tcp_pkt9_c2s_fin));
     printf("<= Packet Parse: done\n\n");
 
@@ -107,6 +110,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_FIN_FIN)
 
     // S2C FIN Packet
     printf("\n=> Packet Parse: TCP S2C FIN packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt10_s2c_fin, sizeof(tcp_pkt10_s2c_fin));
     printf("<= Packet Parse: done\n\n");
 
@@ -189,6 +193,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_RST)
     printf("\n=> Packet Parse: TCP C2S RST packet\n");
     char tcp_pkt_c2s_rst[1500] = {0};
     memcpy(tcp_pkt_c2s_rst, tcp_pkt9_c2s_fin, sizeof(tcp_pkt9_c2s_fin));
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt_c2s_rst, sizeof(tcp_pkt9_c2s_fin));
     const struct raw_layer *tcp_layer = packet_get_innermost_raw_layer(&pkt, LAYER_PROTO_TCP);
     EXPECT_TRUE(tcp_layer);
@@ -276,6 +281,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_RST)
     printf("\n=> Packet Parse: TCP S2C RST packet\n");
     char tcp_pkt_s2c_rst[1500] = {0};
     memcpy(tcp_pkt_s2c_rst, tcp_pkt10_s2c_fin, sizeof(tcp_pkt10_s2c_fin));
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt_s2c_rst, sizeof(tcp_pkt10_s2c_fin));
     const struct raw_layer *tcp_layer = packet_get_innermost_raw_layer(&pkt, LAYER_PROTO_TCP);
     EXPECT_TRUE(tcp_layer);
@@ -409,6 +415,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_HALF_CLOSED_TIMEOUT)
 
     // C2S FIN Packet
     printf("\n=> Packet Parse: TCP C2S FIN packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt9_c2s_fin, sizeof(tcp_pkt9_c2s_fin));
     printf("<= Packet Parse: done\n\n");
 
@@ -489,6 +496,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_HALF_CLOSED_TIMEOUT)
 
     // S2C FIN Packet
     printf("\n=> Packet Parse: TCP S2C FIN packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt10_s2c_fin, sizeof(tcp_pkt10_s2c_fin));
     printf("<= Packet Parse: done\n\n");
 

src/session/test/gtest_state_tcp_init_to_opening.cpp

@@ -66,6 +66,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN)
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
     printf("<= Packet Parse: done\n\n");
 
@@ -144,6 +145,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK)
 
     // S2C SYNACK Packet
     printf("\n=> Packet Parse: TCP S2C SYNACK packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt2_s2c_syn_ack, sizeof(tcp_pkt2_s2c_syn_ack));
     printf("<= Packet Parse: done\n\n");
 
@@ -222,6 +224,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK)
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
     printf("<= Packet Parse: done\n\n");
 
@@ -233,6 +236,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK)
 
     // S2C SYNACK Packet
     printf("\n=> Packet Parse: TCP S2C SYNACK packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt2_s2c_syn_ack, sizeof(tcp_pkt2_s2c_syn_ack));
     printf("<= Packet Parse: done\n\n");
 
@@ -311,6 +315,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK_ACK)
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
     printf("<= Packet Parse: done\n\n");
 
@@ -322,6 +327,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK_ACK)
 
     // S2C SYNACK Packet
     printf("\n=> Packet Parse: TCP S2C SYNACK packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt2_s2c_syn_ack, sizeof(tcp_pkt2_s2c_syn_ack));
     printf("<= Packet Parse: done\n\n");
 
@@ -333,6 +339,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK_ACK)
 
     // C2S ACK Packet
     printf("\n=> Packet Parse: TCP C2S ACK packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt3_c2s_ack, sizeof(tcp_pkt3_c2s_ack));
     printf("<= Packet Parse: done\n\n");
 
@@ -413,6 +420,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_RETRANSMISSION)
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
     printf("<= Packet Parse: done\n\n");
 
@@ -426,6 +434,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_RETRANSMISSION)
     printf("\n=> Packet Parse: TCP C2S SYN retransmission packet\n");
     char syn_retransmission[1500] = {0};
     memcpy(syn_retransmission, tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)syn_retransmission, sizeof(tcp_pkt1_c2s_syn));
     const struct raw_layer *ipv4_layer = packet_get_innermost_raw_layer(&pkt, LAYER_PROTO_IPV4);
     struct ip *hdr = (struct ip *)ipv4_layer->hdr_ptr;
@@ -509,6 +518,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK_RETRANSMISSION)
 
     // S2C SYNACK Packet
     printf("\n=> Packet Parse: TCP S2C SYNACK packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt2_s2c_syn_ack, sizeof(tcp_pkt2_s2c_syn_ack));
     printf("<= Packet Parse: done\n\n");
 
@@ -522,6 +532,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK_RETRANSMISSION)
     printf("\n=> Packet Parse: TCP S2C SYNACK retransmission packet\n");
     char tcp_pkt_s2c_synack_retransmission[1500] = {0};
     memcpy(tcp_pkt_s2c_synack_retransmission, tcp_pkt2_s2c_syn_ack, sizeof(tcp_pkt2_s2c_syn_ack));
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt_s2c_synack_retransmission, sizeof(tcp_pkt2_s2c_syn_ack));
     const struct raw_layer *ipv4_layer = packet_get_innermost_raw_layer(&pkt, LAYER_PROTO_IPV4);
     EXPECT_TRUE(ipv4_layer);
@@ -604,6 +615,7 @@ TEST(TCP_INIT_TO_OPENING, BY_C2S_ASMMETRIC)
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
     printf("<= Packet Parse: done\n\n");
 
@@ -615,6 +627,7 @@ TEST(TCP_INIT_TO_OPENING, BY_C2S_ASMMETRIC)
 
     // C2S ACK Packet
     printf("\n=> Packet Parse: TCP C2S ACK packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt3_c2s_ack, sizeof(tcp_pkt3_c2s_ack));
     printf("<= Packet Parse: done\n\n");
 
@@ -693,6 +706,7 @@ TEST(TCP_INIT_TO_OPENING, BY_S2C_ASMMETRIC)
 
     // S2C SYNACK Packet
     printf("\n=> Packet Parse: TCP S2C SYNACK packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt2_s2c_syn_ack, sizeof(tcp_pkt2_s2c_syn_ack));
     printf("<= Packet Parse: done\n\n");
 
@@ -704,6 +718,7 @@ TEST(TCP_INIT_TO_OPENING, BY_S2C_ASMMETRIC)
 
     // S2C ACK Packet
     printf("\n=> Packet Parse: TCP S2C ACK packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt5_s2c_ack, sizeof(tcp_pkt5_s2c_ack));
     printf("<= Packet Parse: done\n\n");
 

src/session/test/gtest_state_tcp_init_to_opening_to_active_to_closing_to_closed.cpp

@@ -61,6 +61,7 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
     printf("<= Packet Parse: done\n\n");
 
@@ -92,6 +93,7 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
 
     // S2C SYNACK Packet
     printf("\n=> Packet Parse: TCP S2C SYNACK packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt2_s2c_syn_ack, sizeof(tcp_pkt2_s2c_syn_ack));
     printf("<= Packet Parse: done\n\n");
 
@@ -123,6 +125,7 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
 
     // C2S ACK Packet
     printf("\n=> Packet Parse: TCP C2S ACK packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt3_c2s_ack, sizeof(tcp_pkt3_c2s_ack));
     printf("<= Packet Parse: done\n\n");
 
@@ -154,6 +157,7 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
 
     // C2S REQ Packet
     printf("\n=> Packet Parse: TCP C2S REQ packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt4_c2s_http_req, sizeof(tcp_pkt4_c2s_http_req));
     printf("<= Packet Parse: done\n\n");
 
@@ -185,6 +189,7 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
 
     // S2C ACK Packet
     printf("\n=> Packet Parse: TCP S2C ACK packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt5_s2c_ack, sizeof(tcp_pkt5_s2c_ack));
     printf("<= Packet Parse: done\n\n");
 
@@ -216,6 +221,7 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
 
     // S2C HTTP Resp Packet1
     printf("\n=> Packet Parse: TCP S2C Resp packet1\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt6_s2c_http_resq_1, sizeof(tcp_pkt6_s2c_http_resq_1));
     printf("<= Packet Parse: done\n\n");
 
@@ -247,6 +253,7 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
 
     // S2C HTTP Resp Packet2
     printf("\n=> Packet Parse: TCP S2C Resp packet2\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt7_s2c_http_resp_2, sizeof(tcp_pkt7_s2c_http_resp_2));
     printf("<= Packet Parse: done\n\n");
 
@@ -278,6 +285,7 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
 
     // C2S ACK Packet
     printf("\n=> Packet Parse: TCP C2S ACK packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt8_c2s_ack, sizeof(tcp_pkt8_c2s_ack));
     printf("<= Packet Parse: done\n\n");
 
@@ -309,6 +317,7 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
 
     // C2S FIN Packet
     printf("\n=> Packet Parse: TCP C2S FIN packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt9_c2s_fin, sizeof(tcp_pkt9_c2s_fin));
     printf("<= Packet Parse: done\n\n");
 
@@ -340,6 +349,7 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
 
     // S2C FIN Packet
     printf("\n=> Packet Parse: TCP S2C FIN packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt10_s2c_fin, sizeof(tcp_pkt10_s2c_fin));
     printf("<= Packet Parse: done\n\n");
 
@@ -371,6 +381,7 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
 
     // C2S ACK Packet
     printf("\n=> Packet Parse: TCP C2S ACK packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt11_c2s_ack, sizeof(tcp_pkt11_c2s_ack));
     printf("<= Packet Parse: done\n\n");
 

src/session/test/gtest_state_tcp_opening_to_active.cpp

@@ -65,6 +65,7 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYN_C2S_DATA)
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
     printf("<= Packet Parse: done\n\n");
 
@@ -76,6 +77,7 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYN_C2S_DATA)
 
     // C2S DATA Packet
     printf("\n=> Packet Parse: TCP C2S DATA packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt4_c2s_http_req, sizeof(tcp_pkt4_c2s_http_req));
     printf("<= Packet Parse: done\n\n");
 
@@ -154,6 +156,7 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYNACK_S2C_DATA)
 
     // S2C SYNACK Packet
     printf("\n=> Packet Parse: TCP S2C SYNACK packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt2_s2c_syn_ack, sizeof(tcp_pkt2_s2c_syn_ack));
     printf("<= Packet Parse: done\n\n");
 
@@ -165,6 +168,7 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYNACK_S2C_DATA)
 
     // S2C DATA Packet
     printf("\n=> Packet Parse: TCP S2C DATA packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt6_s2c_http_resq_1, sizeof(tcp_pkt6_s2c_http_resq_1));
     printf("<= Packet Parse: done\n\n");
 

src/session/test/gtest_state_tcp_opening_to_closing.cpp

@@ -66,6 +66,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_FIN_FIN)
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
     printf("<= Packet Parse: done\n\n");
 
@@ -77,6 +78,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_FIN_FIN)
 
     // C2S FIN Packet
     printf("\n=> Packet Parse: TCP C2S FIN packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt9_c2s_fin, sizeof(tcp_pkt9_c2s_fin));
     printf("<= Packet Parse: done\n\n");
 
@@ -88,6 +90,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_FIN_FIN)
 
     // S2C FIN Packet
     printf("\n=> Packet Parse: TCP S2C FIN packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt10_s2c_fin, sizeof(tcp_pkt10_s2c_fin));
     printf("<= Packet Parse: done\n\n");
 
@@ -165,6 +168,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_RST)
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
     printf("<= Packet Parse: done\n\n");
 
@@ -178,6 +182,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_RST)
     printf("\n=> Packet Parse: TCP C2S RST packet\n");
     char tcp_pkt_c2s_rst[1500] = {0};
     memcpy(tcp_pkt_c2s_rst, tcp_pkt9_c2s_fin, sizeof(tcp_pkt9_c2s_fin));
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt_c2s_rst, sizeof(tcp_pkt9_c2s_fin));
     const struct raw_layer *tcp_layer = packet_get_innermost_raw_layer(&pkt, LAYER_PROTO_TCP);
     EXPECT_TRUE(tcp_layer);
@@ -260,6 +265,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_RST)
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
     printf("<= Packet Parse: done\n\n");
 
@@ -273,6 +279,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_RST)
     printf("\n=> Packet Parse: TCP S2C RST packet\n");
     char tcp_pkt_s2c_rst[1500] = {0};
     memcpy(tcp_pkt_s2c_rst, tcp_pkt10_s2c_fin, sizeof(tcp_pkt10_s2c_fin));
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt_s2c_rst, sizeof(tcp_pkt10_s2c_fin));
     const struct raw_layer *tcp_layer = packet_get_innermost_raw_layer(&pkt, LAYER_PROTO_TCP);
     EXPECT_TRUE(tcp_layer);
@@ -354,6 +361,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_INIT_TIMEOUT)
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
     printf("<= Packet Parse: done\n\n");
 
@@ -412,6 +420,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_HANDSHAKE_TIMEOUT)
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
     printf("<= Packet Parse: done\n\n");
 
@@ -423,6 +432,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_HANDSHAKE_TIMEOUT)
 
     // S2C SYNACK Packet
     printf("\n=> Packet Parse: TCP S2C SYNACK packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt2_s2c_syn_ack, sizeof(tcp_pkt2_s2c_syn_ack));
     printf("<= Packet Parse: done\n\n");
 
@@ -501,6 +511,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_DATA_TIMEOUT)
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
     printf("<= Packet Parse: done\n\n");
 
@@ -512,6 +523,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_DATA_TIMEOUT)
 
     // S2C SYNACK Packet
     printf("\n=> Packet Parse: TCP S2C SYNACK packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt2_s2c_syn_ack, sizeof(tcp_pkt2_s2c_syn_ack));
     printf("<= Packet Parse: done\n\n");
 
@@ -523,6 +535,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_DATA_TIMEOUT)
 
     // C2S ACK Packet
     printf("\n=> Packet Parse: TCP C2S ACK packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt3_c2s_ack, sizeof(tcp_pkt3_c2s_ack));
     printf("<= Packet Parse: done\n\n");
 
@@ -601,6 +614,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_HALF_FIN)
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
     printf("<= Packet Parse: done\n\n");
 
@@ -612,6 +626,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_HALF_FIN)
 
     // C2S FIN Packet
     printf("\n=> Packet Parse: TCP C2S FIN packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt9_c2s_fin, sizeof(tcp_pkt9_c2s_fin));
     printf("<= Packet Parse: done\n\n");
 
@@ -689,6 +704,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_HALF_FIN)
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
     printf("<= Packet Parse: done\n\n");
 
@@ -700,6 +716,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_HALF_FIN)
 
     // S2C FIN Packet
     printf("\n=> Packet Parse: TCP S2C FIN packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt10_s2c_fin, sizeof(tcp_pkt10_s2c_fin));
     printf("<= Packet Parse: done\n\n");
 

src/session/test/gtest_state_udp_init_to_opening_to_active_to_closing.cpp

@@ -61,6 +61,7 @@ TEST(UDP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING, TEST)
 
     // C2S REQ Packet
     printf("\n=> Packet Parse: UDP C2S REQ packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)udp_pkt1_dns_req, sizeof(udp_pkt1_dns_req));
     printf("<= Packet Parse: done\n\n");
 
@@ -91,6 +92,7 @@ TEST(UDP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING, TEST)
 
     // S2C RESP Packet
     printf("\n=> Packet Parse: UDP S2C RESP packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)udp_pkt2_dns_resp, sizeof(udp_pkt2_dns_resp));
     printf("<= Packet Parse: done\n\n");
 

src/session/test/gtest_state_udp_init_to_opening_to_closing.cpp

@@ -66,6 +66,7 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_C2S)
 
     // C2S REQ Packet
     printf("\n=> Packet Parse: UDP C2S REQ packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)udp_pkt1_dns_req, sizeof(udp_pkt1_dns_req));
     printf("<= Packet Parse: done\n\n");
 
@@ -145,6 +146,7 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_S2C)
 
     // S2C RESP Packet
     printf("\n=> Packet Parse: UDP S2C RESP packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)udp_pkt2_dns_resp, sizeof(udp_pkt2_dns_resp));
     printf("<= Packet Parse: done\n\n");
 

src/session/test/gtest_timeout_tcp_data.cpp

@@ -58,6 +58,7 @@ TEST(TIMEOUT, TCP_TIMEOUT_DATA)
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
     printf("<= Packet Parse: done\n\n");
 
@@ -69,6 +70,7 @@ TEST(TIMEOUT, TCP_TIMEOUT_DATA)
 
     // C2S DATA Packet
     printf("\n=> Packet Parse: TCP C2S DATA packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt4_c2s_http_req, sizeof(tcp_pkt4_c2s_http_req));
     printf("<= Packet Parse: done\n\n");
 

src/session/test/gtest_timeout_tcp_handshake.cpp

@@ -59,6 +59,7 @@ TEST(TIMEOUT, TCP_TIMEOUT_HANDSHAKE)
 
     // S2C SYNACK Packet
     printf("\n=> Packet Parse: TCP S2C SYNACK packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt2_s2c_syn_ack, sizeof(tcp_pkt2_s2c_syn_ack));
     printf("<= Packet Parse: done\n\n");
 

src/session/test/gtest_timeout_tcp_init.cpp

@@ -59,6 +59,7 @@ TEST(TIMEOUT, TCP_TIMEOUT_INIT)
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
     printf("<= Packet Parse: done\n\n");
 

src/session/test/gtest_timeout_udp_data.cpp

@@ -58,6 +58,7 @@ TEST(TIMEOUT, UDP_TIMEOUT_DATA1)
 
     // C2S REQ Packet
     printf("\n=> Packet Parse: UDP C2S REQ packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)udp_pkt1_dns_req, sizeof(udp_pkt1_dns_req));
     printf("<= Packet Parse: done\n\n");
 
@@ -94,6 +95,7 @@ TEST(TIMEOUT, UDP_TIMEOUT_DATA2)
 
     // C2S REQ Packet
     printf("\n=> Packet Parse: UDP C2S REQ packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)udp_pkt1_dns_req, sizeof(udp_pkt1_dns_req));
     printf("<= Packet Parse: done\n\n");
 
@@ -105,6 +107,7 @@ TEST(TIMEOUT, UDP_TIMEOUT_DATA2)
 
     // S2C RESP Packet
     printf("\n=> Packet Parse: UDP S2C RESP packet\n");
+    memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)udp_pkt2_dns_resp, sizeof(udp_pkt2_dns_resp));
     printf("<= Packet Parse: done\n\n");