TSG-13684 tsg-service-chaining-engine使用VLAN封装Packet并执行Traffic Mirroringv1.2.0-20231101

11 files changed, 348 insertions, 529 deletions

diff --git a/common/CMakeLists.txt b/common/CMakeLists.txt
index 683eeef..6a2aebe 100644
--- a/common/CMakeLists.txt
+++ b/common/CMakeLists.txt
@@ -1,4 +1,4 @@
-add_library(common src/addr_tuple4.cpp src/session_table.cpp src/raw_packet.cpp src/ctrl_packet.cpp src/bfd.cpp src/utils.cpp src/g_vxlan.cpp src/log.cpp src/timestamp.cpp src/mpack.cpp)
+add_library(common src/addr_tuple4.cpp src/session_table.cpp src/data_packet.cpp src/control_packet.cpp src/bfd.cpp src/utils.cpp src/g_vxlan.cpp src/log.cpp src/timestamp.cpp src/mpack.cpp)
 target_link_libraries(common PUBLIC cjson)
 target_link_libraries(common PUBLIC MESA_handle_logger)
 
diff --git a/common/include/ctrl_packet.h b/common/include/control_packet.h
index 3203438..8db6eb1 100644
--- a/common/include/ctrl_packet.h
+++ b/common/include/control_packet.h
@@ -1,5 +1,5 @@
-#ifndef _CTRL_PACKET_H
-#define _CTRL_PACKET_H
+#ifndef _CONTROL_PACKET_H
+#define _CONTROL_PACKET_H
 
 #ifdef __cpluscplus
 extern "C"
@@ -16,7 +16,7 @@ enum session_state
     SESSION_STATE_RESETALL = 4,
 };
 
-struct ctrl_pkt_parser
+struct control_packet
 {
     char tsync[4];
     uint64_t session_id;
@@ -27,12 +27,11 @@ struct ctrl_pkt_parser
 };
 
 const char *session_state_to_string(enum session_state state);
-void ctrl_packet_parser_init(struct ctrl_pkt_parser *handler);
 
 // return  0 : success
 // return -1 : error
-int ctrl_packet_parser_parse(struct ctrl_pkt_parser *handler, const char *data, size_t length);
-void ctrl_packet_parser_dump(struct ctrl_pkt_parser *handler);
+int control_packet_parse(struct control_packet *handler, const char *data, size_t length);
+void control_packet_dump(struct control_packet *handler);
 
 #ifdef __cpluscplus
 }
diff --git a/common/include/raw_packet.h b/common/include/data_packet.h
index ee448af..fc0a8d4 100644
--- a/common/include/raw_packet.h
+++ b/common/include/data_packet.h
@@ -1,5 +1,5 @@
-#ifndef _RAW_PACKET_H
-#define _RAW_PACKET_H
+#ifndef _DATA_PACKET_H
+#define _DATA_PACKET_H
 
 #ifdef __cpluscplus
 extern "C"
@@ -67,30 +67,28 @@ struct layer_results
     uint16_t layers_size;
 };
 
-struct raw_pkt_parser
+struct data_packet
 {
-    enum layer_type expect_type;
     struct layer_results results;
 
-    const void *ptr_pkt_start;
-    uint64_t pkt_trace_id;
+    const void *data_ptr;
+    uint64_t trace_id;
 };
 
-void raw_packet_parser_init(struct raw_pkt_parser *handler, uint64_t pkt_trace_id, enum layer_type expect_type, uint16_t expect_results_num);
 // return most inner payload
-const void *raw_packet_parser_parse(struct raw_pkt_parser *handler, const void *data, size_t length);
+const void *data_packet_parse(struct data_packet *handler, const void *data, size_t length, uint64_t trace_id);
 
 // return  0 : success
 // return -1 : error
-int raw_packet_parser_get_most_inner_tuple4(struct raw_pkt_parser *handler, struct addr_tuple4 *addr);
-int raw_packet_parser_get_most_outer_tuple4(struct raw_pkt_parser *handler, struct addr_tuple4 *addr);
+int data_packet_get_innermost_tuple4(struct data_packet *handler, struct addr_tuple4 *addr);
+int data_packet_get_outermost_tuple4(struct data_packet *handler, struct addr_tuple4 *addr);
 
 // return  0 : success
 // return -1 : error
-int raw_packet_parser_get_most_inner_address(struct raw_pkt_parser *handler, struct addr_tuple4 *addr);
-int raw_packet_parser_get_most_outer_address(struct raw_pkt_parser *handler, struct addr_tuple4 *addr);
+int data_packet_get_innermost_address(struct data_packet *handler, struct addr_tuple4 *addr);
+int data_packet_get_outermost_address(struct data_packet *handler, struct addr_tuple4 *addr);
 
-uint64_t raw_packet_parser_get_hash_value(struct raw_pkt_parser *handler, enum ldbc_method method, int dir_is_i2e);
+uint64_t data_packet_get_hash(struct data_packet *handler, enum ldbc_method method, int dir_is_i2e);
 
 #ifdef __cpluscplus
 }
diff --git a/common/include/utils.h b/common/include/utils.h
index 7ad3749..8e114bb 100644
--- a/common/include/utils.h
+++ b/common/include/utils.h
@@ -11,7 +11,7 @@ extern "C"
 #define LOG_TAG_SCE           "SCE"
 #define LOG_TAG_POLICY        "POLICY"
 #define LOG_TAG_PKTIO         "PACKET_IO"
-#define LOG_TAG_RAWPKT        "RAW_PACKET"
+#define LOG_TAG_RAWPKT        "DATA_PACKET"
 #define LOG_TAG_CTRLPKT       "CTRL_PACKET"
 #define LOG_TAG_METRICS       "G_METRICS"
 #define LOG_TAG_SF_METRICS    "SF_METRICS"
@@ -36,23 +36,23 @@ extern "C"
 #include <netinet/in.h>
 
 /******************************************************************************
- * fixed_num_array
+ * mutable_array
  ******************************************************************************/
 
-struct fixed_num_array
+struct mutable_array
 {
     uint64_t elems[128];
     int num;
     int size;
 };
 
-void fixed_num_array_init(struct fixed_num_array *array);
-void fixed_num_array_add_elem(struct fixed_num_array *array, uint64_t elem);
-void fixed_num_array_del_elem(struct fixed_num_array *array, uint64_t elem);
-int fixed_num_array_is_full(struct fixed_num_array *array);
-int fixed_num_array_count_elem(struct fixed_num_array *array);
-int fixed_num_array_exist_elem(struct fixed_num_array *array, uint64_t elem);
-int fixed_num_array_index_elem(struct fixed_num_array *array, int index);
+void mutable_array_init(struct mutable_array *array);
+void mutable_array_add_elem(struct mutable_array *array, uint64_t elem);
+void mutable_array_del_elem(struct mutable_array *array, uint64_t elem);
+int mutable_array_is_full(struct mutable_array *array);
+int mutable_array_count_elem(struct mutable_array *array);
+int mutable_array_exist_elem(struct mutable_array *array, uint64_t elem);
+int mutable_array_index_elem(struct mutable_array *array, int index);
 
 /******************************************************************************
  * sids
diff --git a/common/src/ctrl_packet.cpp b/common/src/control_packet.cpp
index ef550eb..e67aa95 100644
--- a/common/src/ctrl_packet.cpp
+++ b/common/src/control_packet.cpp
@@ -6,7 +6,7 @@
 #include "log.h"
 #include "mpack.h"
 #include "utils.h"
-#include "ctrl_packet.h"
+#include "control_packet.h"
 
 const char *session_state_to_string(enum session_state state)
 {
@@ -25,15 +25,12 @@ const char *session_state_to_string(enum session_state state)
     }
 }
 
-void ctrl_packet_parser_init(struct ctrl_pkt_parser *handler)
-{
-    memset(handler, 0, sizeof(struct ctrl_pkt_parser));
-}
-
 // return  0 : success
 // return -1 : error
-int ctrl_packet_parser_mpack(struct ctrl_pkt_parser *handler, const char *data, size_t length)
+int control_packet_parse(struct control_packet *handler, const char *data, size_t length)
 {
+    memset(handler, 0, sizeof(struct control_packet));
+
     mpack_tree_t tree;
     mpack_node_t root;
     mpack_node_t temp;
@@ -174,139 +171,7 @@ error_out:
     return -1;
 }
 
-// return  0 : success
-// return -1 : error
-int ctrl_packet_parser_cjson(struct ctrl_pkt_parser *handler, const char *data, size_t length)
-{
-    int iter = 0;
-    cJSON *item = NULL;
-    cJSON *elem = NULL;
-    cJSON *json = NULL;
-
-    json = cJSON_Parse(data);
-    if (json == NULL)
-    {
-        LOG_ERROR("%s: unexpected control packet: (invalid json format) %s", LOG_TAG_CTRLPKT, data);
-        return -1;
-    }
-
-    // tsync
-    item = cJSON_GetObjectItem(json, "tsync");
-    if (!item || !cJSON_IsString(item))
-    {
-        LOG_ERROR("%s: unexpected control packet: (invalid tsync format) %s", LOG_TAG_CTRLPKT, data);
-        goto error_out;
-    }
-    memcpy(handler->tsync, item->valuestring, MIN(sizeof(handler->tsync), strlen(item->valuestring)));
-
-    // session_id
-    item = cJSON_GetObjectItem(json, "session_id");
-    if (!item || !cJSON_IsString(item))
-    {
-        LOG_ERROR("%s: unexpected control packet: (invalid session_id format) %s", LOG_TAG_CTRLPKT, data);
-        goto error_out;
-    }
-    handler->session_id = atoll(item->valuestring);
-
-    // state
-    item = cJSON_GetObjectItem(json, "state");
-    if (!item || !cJSON_IsString(item))
-    {
-        LOG_ERROR("%s: unexpected control packet: (invalid state format) %s", LOG_TAG_CTRLPKT, data);
-        goto error_out;
-    }
-
-    if (strcasecmp(item->valuestring, "opening") == 0)
-    {
-        handler->state = SESSION_STATE_OPENING;
-    }
-    else if (strcasecmp(item->valuestring, "active") == 0)
-    {
-        handler->state = SESSION_STATE_ACTIVE;
-    }
-    else if (strcasecmp(item->valuestring, "closing") == 0)
-    {
-        handler->state = SESSION_STATE_CLOSING;
-    }
-    else if (strcasecmp(item->valuestring, "resetall") == 0)
-    {
-        handler->state = SESSION_STATE_RESETALL;
-    }
-    else
-    {
-        LOG_ERROR("%s: unexpected control packet: (invalid state value) %s", LOG_TAG_CTRLPKT, data);
-        goto error_out;
-    }
-
-    if (handler->state != SESSION_STATE_ACTIVE)
-    {
-        goto success_out;
-    }
-
-    // method
-    item = cJSON_GetObjectItem(json, "method");
-    if (!item || !cJSON_IsString(item))
-    {
-        LOG_ERROR("%s: unexpected control packet: (invalid method format) %s", LOG_TAG_CTRLPKT, data);
-        goto error_out;
-    }
-    memcpy(handler->method, item->valuestring, MIN(sizeof(handler->method), strlen(item->valuestring)));
-    if (strcasecmp(item->valuestring, "policy_update") != 0)
-    {
-        LOG_ERROR("%s: unexpected control packet: (invalid method value) %s", LOG_TAG_CTRLPKT, data);
-        goto error_out;
-    }
-
-    // params
-    item = cJSON_GetObjectItem(json, "params");
-    if (!item || !cJSON_IsObject(item))
-    {
-        LOG_ERROR("%s: unexpected control packet: (invalid params format) %s", LOG_TAG_CTRLPKT, data);
-        goto error_out;
-    }
-
-    item = cJSON_GetObjectItem(item, "service_chaining");
-    if (!item || !cJSON_IsArray(item) || !cJSON_GetArraySize(item))
-    {
-        LOG_ERROR("%s: unexpected control packet: (invalid service_chaining format) %s", LOG_TAG_CTRLPKT, data);
-        goto error_out;
-    }
-
-    handler->rule_id_num = MIN(cJSON_GetArraySize(item), (int)(sizeof(handler->rule_ids) / sizeof(handler->rule_ids[0])));
-    cJSON_ArrayForEach(elem, item)
-    {
-        if (!cJSON_IsNumber(elem))
-        {
-            LOG_ERROR("%s: unexpected control packet: (invalid service_chaining value) %s", LOG_TAG_POLICY, data);
-            continue;
-        }
-        handler->rule_ids[iter] = elem->valueint;
-        iter++;
-
-        if (iter == handler->rule_id_num)
-        {
-            break;
-        }
-    }
-
-success_out:
-    cJSON_Delete(json);
-    return 0;
-
-error_out:
-    cJSON_Delete(json);
-    return -1;
-}
-
-// return  0 : success
-// return -1 : error
-int ctrl_packet_parser_parse(struct ctrl_pkt_parser *handler, const char *data, size_t length)
-{
-    // return ctrl_packet_parser_cjson(handler, data, length);
-    return ctrl_packet_parser_mpack(handler, data, length);
-}
-
-void ctrl_packet_parser_dump(struct ctrl_pkt_parser *handler)
+void control_packet_dump(struct control_packet *handler)
 {
     if (handler)
     {
diff --git a/common/src/raw_packet.cpp b/common/src/data_packet.cpp
index 3bff78a..cb18af5 100644
--- a/common/src/raw_packet.cpp
+++ b/common/src/data_packet.cpp
@@ -14,18 +14,12 @@
 #include "utils.h"
 #include "uthash.h"
 #include "addr_tuple4.h"
-#include "raw_packet.h"
+#include "data_packet.h"
 
 /******************************************************************************
  * Struct
  ******************************************************************************/
 
-enum parse_status
-{
-    PARSE_STATUS_CONTINUE,
-    PARSE_STATUS_STOP
-};
-
 struct vlan_hdr
 {
     uint16_t vlan_cfi;
@@ -66,8 +60,7 @@ struct gtp_hdr
  * Static API
  ******************************************************************************/
 
-static int raw_packet_parser_push(struct raw_pkt_parser *handler, enum layer_type type, uint16_t offset);
-static enum parse_status raw_packet_parser_status(struct raw_pkt_parser *handler, const void *data, enum layer_type this_type);
+static int data_packet_push_layer(struct data_packet *handler, enum layer_type type, uint16_t offset);
 
 static const char *ldbc_method_to_string(enum ldbc_method ldbc_method);
 
@@ -77,44 +70,38 @@ static const char *layer_type2str(enum layer_type this_type);
 static uint16_t parse_gtphdr_len(const struct gtp_hdr *gtph);
 
 // parser protocol
-static const void *parse_ether(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type);
-static const void *parse_ipv4(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type);
-static const void *parse_ipv6(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type);
-static const void *parse_tcp(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type);
-static const void *parse_udp(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type);
-static const void *parse_pppoe_ses(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type);
-static const void *parse_vxlan(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type);
-static const void *parse_vlan8021q(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type);
-static const void *parse_gtpv1_u(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type);
-static const void *parse_mpls(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type);
+static const void *parse_ether(struct data_packet *handler, const void *data, size_t length);
+static const void *parse_ipv4(struct data_packet *handler, const void *data, size_t length);
+static const void *parse_ipv6(struct data_packet *handler, const void *data, size_t length);
+static const void *parse_tcp(struct data_packet *handler, const void *data, size_t length);
+static const void *parse_udp(struct data_packet *handler, const void *data, size_t length);
+static const void *parse_pppoe_ses(struct data_packet *handler, const void *data, size_t length);
+static const void *parse_vxlan(struct data_packet *handler, const void *data, size_t length);
+static const void *parse_vlan8021q(struct data_packet *handler, const void *data, size_t length);
+static const void *parse_gtpv1_u(struct data_packet *handler, const void *data, size_t length);
+static const void *parse_mpls(struct data_packet *handler, const void *data, size_t length);
 
 /******************************************************************************
  * Public API
  ******************************************************************************/
 
-void raw_packet_parser_init(struct raw_pkt_parser *handler, uint64_t pkt_trace_id, enum layer_type expect_type, uint16_t expect_results_num)
+// return most inner payload
+const void *data_packet_parse(struct data_packet *handler, const void *data, size_t length, uint64_t trace_id)
 {
-    memset(handler, 0, sizeof(struct raw_pkt_parser));
+    memset(handler, 0, sizeof(struct data_packet));
 
-    handler->expect_type = expect_type;
     handler->results.layers_used = 0;
-    handler->results.layers_size = MIN(expect_results_num, (sizeof(handler->results.layers) / sizeof(handler->results.layers[0])));
-    handler->ptr_pkt_start = NULL;
-    handler->pkt_trace_id = pkt_trace_id;
-}
-
-// return most inner payload
-const void *raw_packet_parser_parse(struct raw_pkt_parser *handler, const void *data, size_t length)
-{
-    handler->ptr_pkt_start = data;
+    handler->results.layers_size = sizeof(handler->results.layers) / sizeof(handler->results.layers[0]);
+    handler->data_ptr = data;
+    handler->trace_id = trace_id;
 
     // TESTED
-    return parse_ether(handler, data, length, LAYER_TYPE_ETHER);
+    return parse_ether(handler, data, length);
 }
 
 // return  0 : success
 // return -1 : error
-int raw_packet_parser_get_most_inner_tuple4(struct raw_pkt_parser *handler, struct addr_tuple4 *addr)
+int data_packet_get_innermost_tuple4(struct data_packet *handler, struct addr_tuple4 *addr)
 {
     const char *l3_layer_data = NULL;
     const char *l4_layer_data = NULL;
@@ -128,7 +115,7 @@ int raw_packet_parser_get_most_inner_tuple4(struct raw_pkt_parser *handler, stru
         const struct layer_result *layer = &results->layers[i];
         enum layer_type type = layer->type;
 
-        LOG_DEBUG("%s: find most inner tuple4, pkt_trace_id: %lu, layer[%d/%d]: %s", LOG_TAG_RAWPKT, handler->pkt_trace_id, i, results->layers_size, layer_type2str(type));
+        LOG_DEBUG("%s: find most inner tuple4, trace_id: %lu, layer[%d/%d]: %s", LOG_TAG_RAWPKT, handler->trace_id, i, results->layers_size, layer_type2str(type));
 
         // first get L4 layer
         if (type & LAYER_TYPE_L4)
@@ -147,13 +134,13 @@ int raw_packet_parser_get_most_inner_tuple4(struct raw_pkt_parser *handler, stru
 
     if (l3_layer_result)
     {
-        l3_layer_data = (const char *)handler->ptr_pkt_start + l3_layer_result->offset;
+        l3_layer_data = (const char *)handler->data_ptr + l3_layer_result->offset;
         set_addr_tuple4(l3_layer_data, l3_layer_result->type, addr);
     }
 
     if (l4_layer_result)
     {
-        l4_layer_data = (const char *)handler->ptr_pkt_start + l4_layer_result->offset;
+        l4_layer_data = (const char *)handler->data_ptr + l4_layer_result->offset;
         set_addr_tuple4(l4_layer_data, l4_layer_result->type, addr);
     }
 
@@ -169,7 +156,7 @@ int raw_packet_parser_get_most_inner_tuple4(struct raw_pkt_parser *handler, stru
 
 // return  0 : success
 // return -1 : error
-int raw_packet_parser_get_most_outer_tuple4(struct raw_pkt_parser *handler, struct addr_tuple4 *addr)
+int data_packet_get_outermost_tuple4(struct data_packet *handler, struct addr_tuple4 *addr)
 {
     const char *l3_layer_data = NULL;
     const char *l4_layer_data = NULL;
@@ -183,7 +170,7 @@ int raw_packet_parser_get_most_outer_tuple4(struct raw_pkt_parser *handler, stru
         const struct layer_result *layer = &results->layers[i];
         enum layer_type type = layer->type;
 
-        LOG_DEBUG("%s: find most outer tuple4, pkt_trace_id: %lu, layer[%d/%d]: %s", LOG_TAG_RAWPKT, handler->pkt_trace_id, i, results->layers_size, layer_type2str(type));
+        LOG_DEBUG("%s: find most outer tuple4, trace_id: %lu, layer[%d/%d]: %s", LOG_TAG_RAWPKT, handler->trace_id, i, results->layers_size, layer_type2str(type));
 
         // first get L3 layer
         if (type & LAYER_TYPE_L3)
@@ -202,13 +189,13 @@ int raw_packet_parser_get_most_outer_tuple4(struct raw_pkt_parser *handler, stru
 
     if (l3_layer_result)
     {
-        l3_layer_data = (const char *)handler->ptr_pkt_start + l3_layer_result->offset;
+        l3_layer_data = (const char *)handler->data_ptr + l3_layer_result->offset;
         set_addr_tuple4(l3_layer_data, l3_layer_result->type, addr);
     }
 
     if (l4_layer_result)
     {
-        l4_layer_data = (const char *)handler->ptr_pkt_start + l4_layer_result->offset;
+        l4_layer_data = (const char *)handler->data_ptr + l4_layer_result->offset;
         set_addr_tuple4(l4_layer_data, l4_layer_result->type, addr);
     }
 
@@ -224,7 +211,7 @@ int raw_packet_parser_get_most_outer_tuple4(struct raw_pkt_parser *handler, stru
 
 // return  0 : success
 // return -1 : error
-int raw_packet_parser_get_most_inner_address(struct raw_pkt_parser *handler, struct addr_tuple4 *addr)
+int data_packet_get_innermost_address(struct data_packet *handler, struct addr_tuple4 *addr)
 {
     const char *l3_layer_data = NULL;
     struct layer_results *results = &handler->results;
@@ -235,10 +222,10 @@ int raw_packet_parser_get_most_inner_address(struct raw_pkt_parser *handler, str
         const struct layer_result *layer = &results->layers[i];
         enum layer_type type = layer->type;
 
-        LOG_DEBUG("%s: find most inner address, pkt_trace_id: %lu, layer[%d/%d]: %s", LOG_TAG_RAWPKT, handler->pkt_trace_id, i, results->layers_size, layer_type2str(type));
+        LOG_DEBUG("%s: find most inner address, trace_id: %lu, layer[%d/%d]: %s", LOG_TAG_RAWPKT, handler->trace_id, i, results->layers_size, layer_type2str(type));
         if (type & LAYER_TYPE_L3)
         {
-            l3_layer_data = (const char *)handler->ptr_pkt_start + layer->offset;
+            l3_layer_data = (const char *)handler->data_ptr + layer->offset;
             set_addr_tuple4(l3_layer_data, type, addr);
             return 0;
         }
@@ -249,7 +236,7 @@ int raw_packet_parser_get_most_inner_address(struct raw_pkt_parser *handler, str
 
 // return  0 : success
 // return -1 : error
-int raw_packet_parser_get_most_outer_address(struct raw_pkt_parser *handler, struct addr_tuple4 *addr)
+int data_packet_get_outermost_address(struct data_packet *handler, struct addr_tuple4 *addr)
 {
     const char *l3_layer_data = NULL;
     struct layer_results *results = &handler->results;
@@ -260,10 +247,10 @@ int raw_packet_parser_get_most_outer_address(struct raw_pkt_parser *handler, str
         const struct layer_result *layer = &results->layers[i];
         enum layer_type type = layer->type;
 
-        LOG_DEBUG("%s: find most outer address, pkt_trace_id: %lu, layer[%d/%d]: %s", LOG_TAG_RAWPKT, handler->pkt_trace_id, i, results->layers_size, layer_type2str(type));
+        LOG_DEBUG("%s: find most outer address, trace_id: %lu, layer[%d/%d]: %s", LOG_TAG_RAWPKT, handler->trace_id, i, results->layers_size, layer_type2str(type));
         if (type & LAYER_TYPE_L3)
         {
-            l3_layer_data = (const char *)handler->ptr_pkt_start + layer->offset;
+            l3_layer_data = (const char *)handler->data_ptr + layer->offset;
             set_addr_tuple4(l3_layer_data, type, addr);
             return 0;
         }
@@ -272,7 +259,7 @@ int raw_packet_parser_get_most_outer_address(struct raw_pkt_parser *handler, str
     return -1;
 }
 
-uint64_t raw_packet_parser_get_hash_value(struct raw_pkt_parser *handler, enum ldbc_method method, int dir_is_i2e)
+uint64_t data_packet_get_hash(struct data_packet *handler, enum ldbc_method method, int dir_is_i2e)
 {
     uint64_t temp = 0;
     uint64_t hash_value = 1;
@@ -294,12 +281,12 @@ uint64_t raw_packet_parser_get_hash_value(struct raw_pkt_parser *handler, enum l
         return hash_value;
     }
 
-    if (raw_packet_parser_get_most_inner_address(handler, &inner_addr) == -1)
+    if (data_packet_get_innermost_address(handler, &inner_addr) == -1)
     {
         return hash_value;
     }
 
-    if (raw_packet_parser_get_most_outer_address(handler, &outer_addr) == -1)
+    if (data_packet_get_outermost_address(handler, &outer_addr) == -1)
     {
         return hash_value;
     }
@@ -392,8 +379,8 @@ uint64_t raw_packet_parser_get_hash_value(struct raw_pkt_parser *handler, enum l
 
     char *inner_addr_str = addr_tuple4_to_str(&inner_addr);
     char *outer_addr_str = addr_tuple4_to_str(&outer_addr);
-    LOG_DEBUG("%s: pkt_trace_id: %lu, outer_addr: %s, inner_addr: %s, is_internal: %d, hash_method: %s, hash_value: %lu",
-              LOG_TAG_RAWPKT, handler->pkt_trace_id, outer_addr_str, inner_addr_str, dir_is_i2e, ldbc_method_to_string(method), hash_value);
+    LOG_DEBUG("%s: trace_id: %lu, outer_addr: %s, inner_addr: %s, is_internal: %d, hash_method: %s, hash_value: %lu",
+              LOG_TAG_RAWPKT, handler->trace_id, outer_addr_str, inner_addr_str, dir_is_i2e, ldbc_method_to_string(method), hash_value);
     free(inner_addr_str);
     free(outer_addr_str);
 
@@ -406,7 +393,7 @@ uint64_t raw_packet_parser_get_hash_value(struct raw_pkt_parser *handler, enum l
 
 // return       0 : success
 // return -ENOMEM : error
-static int raw_packet_parser_push(struct raw_pkt_parser *handler, enum layer_type type, uint16_t offset)
+static int data_packet_push_layer(struct data_packet *handler, enum layer_type type, uint16_t offset)
 {
     struct layer_results *result = &handler->results;
 
@@ -422,30 +409,6 @@ static int raw_packet_parser_push(struct raw_pkt_parser *handler, enum layer_typ
     return 0;
 }
 
-// return PARSE_STATUS_CONTINUE
-// return PARSE_STATUS_STOP
-static enum parse_status raw_packet_parser_status(struct raw_pkt_parser *handler, const void *data, enum layer_type this_type)
-{
-    /*
-     * only when this_type & handler->expect_type is true,
-     * the information of the current layer will be recorded in results.
-     */
-    if (!(this_type & handler->expect_type))
-    {
-        return PARSE_STATUS_CONTINUE;
-    }
-
-    uint16_t offset = (uintptr_t)data - (uintptr_t)(handler->ptr_pkt_start);
-    if (raw_packet_parser_push(handler, this_type, offset) < 0)
-    {
-        return PARSE_STATUS_STOP;
-    }
-    else
-    {
-        return PARSE_STATUS_CONTINUE;
-    }
-}
-
 static const char *ldbc_method_to_string(enum ldbc_method ldbc_method)
 {
     switch (ldbc_method)
@@ -583,15 +546,16 @@ static uint16_t parse_gtphdr_len(const struct gtp_hdr *gtph)
     return (char *)p_ext_hdr - (char *)gtph;
 }
 
-static const void *parse_ether(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type)
+static const void *parse_ether(struct data_packet *handler, const void *data, size_t length)
 {
     if (length < sizeof(struct ethhdr))
     {
-        LOG_ERROR("%s: pkt_trace_id: %lu, this_layer: %s, err: data not enough", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type));
+        LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_ETHER));
         return data;
     }
 
-    if (raw_packet_parser_status(handler, data, this_type) == PARSE_STATUS_STOP)
+    uint16_t offset = (uintptr_t)data - (uintptr_t)(handler->data_ptr);
+    if (data_packet_push_layer(handler, LAYER_TYPE_ETHER, offset) < 0)
     {
         return data;
     }
@@ -602,40 +566,41 @@ static const void *parse_ether(struct raw_pkt_parser *handler, const void *data,
     const void *data_next_layer = (const char *)data + hdr_len;
     size_t data_next_length = length - hdr_len;
 
-    LOG_DEBUG("%s: pkt_trace_id: %lu, this_layer: %s, payload_len: [%lu/%lu]", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type), data_next_length, length);
+    LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_ETHER), data_next_length, length);
     switch (next_proto)
     {
     case ETH_P_8021Q:
     case ETH_P_8021AD:
         // TESTED
-        return parse_vlan8021q(handler, data_next_layer, data_next_length, LAYER_TYPE_VLAN);
+        return parse_vlan8021q(handler, data_next_layer, data_next_length);
     case ETH_P_IP:
         // TESTED
-        return parse_ipv4(handler, data_next_layer, data_next_length, LAYER_TYPE_IPV4);
+        return parse_ipv4(handler, data_next_layer, data_next_length);
     case ETH_P_IPV6:
         // TESTED
-        return parse_ipv6(handler, data_next_layer, data_next_length, LAYER_TYPE_IPV6);
+        return parse_ipv6(handler, data_next_layer, data_next_length);
     case ETH_P_PPP_SES:
         // TODO
-        return parse_pppoe_ses(handler, data_next_layer, data_next_length, LAYER_TYPE_PPPOE);
+        return parse_pppoe_ses(handler, data_next_layer, data_next_length);
     case ETH_P_MPLS_UC:
         // TESTED
-        return parse_mpls(handler, data_next_layer, data_next_length, LAYER_TYPE_MPLS);
+        return parse_mpls(handler, data_next_layer, data_next_length);
     default:
-        LOG_ERROR("%s: pkt_trace_id: %lu, this_layer: %s, stop parse next protocol %d", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type), next_proto);
+        LOG_ERROR("%s: trace_id: %lu, %s, stop parse next protocol %d", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_ETHER), next_proto);
         return data_next_layer;
     }
 }
 
-static const void *parse_ipv4(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type)
+static const void *parse_ipv4(struct data_packet *handler, const void *data, size_t length)
 {
     if (length < sizeof(struct ip))
     {
-        LOG_ERROR("%s: pkt_trace_id: %lu, this_layer: %s, err: data not enough", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type));
+        LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_IPV4));
         return data;
     }
 
-    if (raw_packet_parser_status(handler, data, this_type) == PARSE_STATUS_STOP)
+    uint16_t offset = (uintptr_t)data - (uintptr_t)(handler->data_ptr);
+    if (data_packet_push_layer(handler, LAYER_TYPE_IPV4, offset) < 0)
     {
         return data;
     }
@@ -646,36 +611,37 @@ static const void *parse_ipv4(struct raw_pkt_parser *handler, const void *data,
     const void *data_next_layer = (const char *)data + hdr_len;
     size_t data_next_length = length - hdr_len;
 
-    LOG_DEBUG("%s: pkt_trace_id: %lu, this_layer: %s, payload_len: [%lu/%lu]", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type), data_next_length, length);
+    LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_IPV4), data_next_length, length);
     switch (next_proto)
     {
     case IPPROTO_TCP:
         // TESTED
-        return parse_tcp(handler, data_next_layer, data_next_length, LAYER_TYPE_TCP);
+        return parse_tcp(handler, data_next_layer, data_next_length);
     case IPPROTO_UDP:
         // TESTED
-        return parse_udp(handler, data_next_layer, data_next_length, LAYER_TYPE_UDP);
+        return parse_udp(handler, data_next_layer, data_next_length);
     case IPPROTO_IPIP:
         // TESTED
-        return parse_ipv4(handler, data_next_layer, data_next_length, LAYER_TYPE_IPV4);
+        return parse_ipv4(handler, data_next_layer, data_next_length);
     case IPPROTO_IPV6:
         // TESTED
-        return parse_ipv6(handler, data_next_layer, data_next_length, LAYER_TYPE_IPV6);
+        return parse_ipv6(handler, data_next_layer, data_next_length);
     default:
-        LOG_ERROR("%s: pkt_trace_id: %lu, this_layer: %s, stop parse next protocol %d", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type), next_proto);
+        LOG_ERROR("%s: trace_id: %lu, %s, stop parse next protocol %d", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_IPV4), next_proto);
         return data_next_layer;
     }
 }
 
-static const void *parse_ipv6(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type)
+static const void *parse_ipv6(struct data_packet *handler, const void *data, size_t length)
 {
     if (length < sizeof(struct ip6_hdr))
     {
-        LOG_ERROR("%s: pkt_trace_id: %lu, this_layer: %s, err: data not enough", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type));
+        LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_IPV6));
         return data;
     }
 
-    if (raw_packet_parser_status(handler, data, this_type) == PARSE_STATUS_STOP)
+    uint16_t offset = (uintptr_t)data - (uintptr_t)(handler->data_ptr);
+    if (data_packet_push_layer(handler, LAYER_TYPE_IPV6, offset) < 0)
     {
         return data;
     }
@@ -686,36 +652,37 @@ static const void *parse_ipv6(struct raw_pkt_parser *handler, const void *data,
     const void *data_next_layer = (const char *)data + hdr_len;
     size_t data_next_length = length - hdr_len;
 
-    LOG_DEBUG("%s: pkt_trace_id: %lu, this_layer: %s, payload_len: [%lu/%lu]", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type), data_next_length, length);
+    LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_IPV6), data_next_length, length);
     switch (next_proto)
     {
     case IPPROTO_TCP:
         // TESTED
-        return parse_tcp(handler, data_next_layer, data_next_length, LAYER_TYPE_TCP);
+        return parse_tcp(handler, data_next_layer, data_next_length);
     case IPPROTO_UDP:
         // TESTED
-        return parse_udp(handler, data_next_layer, data_next_length, LAYER_TYPE_UDP);
+        return parse_udp(handler, data_next_layer, data_next_length);
     case IPPROTO_IPIP:
         // TESTED
-        return parse_ipv4(handler, data_next_layer, data_next_length, LAYER_TYPE_IPV4);
+        return parse_ipv4(handler, data_next_layer, data_next_length);
     case IPPROTO_IPV6:
         // TESTED
-        return parse_ipv6(handler, data_next_layer, data_next_length, LAYER_TYPE_IPV6);
+        return parse_ipv6(handler, data_next_layer, data_next_length);
     default:
-        LOG_ERROR("%s: pkt_trace_id: %lu, this_layer: %s, stop parse next protocol %d", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type), next_proto);
+        LOG_ERROR("%s: trace_id: %lu, %s, stop parse next protocol %d", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_IPV6), next_proto);
         return data_next_layer;
     }
 }
 
-static const void *parse_tcp(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type)
+static const void *parse_tcp(struct data_packet *handler, const void *data, size_t length)
 {
     if (length < sizeof(struct tcphdr))
     {
-        LOG_ERROR("%s: pkt_trace_id: %lu, this_layer: %s, err: data not enough", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type));
+        LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_TCP));
         return data;
     }
 
-    if (raw_packet_parser_status(handler, data, this_type) == PARSE_STATUS_STOP)
+    uint16_t offset = (uintptr_t)data - (uintptr_t)(handler->data_ptr);
+    if (data_packet_push_layer(handler, LAYER_TYPE_TCP, offset) < 0)
     {
         return data;
     }
@@ -725,20 +692,21 @@ static const void *parse_tcp(struct raw_pkt_parser *handler, const void *data, s
     const void *data_next_layer = (const char *)data + hdr_len;
     size_t data_next_length = length - hdr_len;
 
-    LOG_DEBUG("%s: pkt_trace_id: %lu, this_layer: %s, payload_len: [%lu/%lu]", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type), data_next_length, length);
+    LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_TCP), data_next_length, length);
 
     return data_next_layer;
 }
 
-static const void *parse_udp(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type)
+static const void *parse_udp(struct data_packet *handler, const void *data, size_t length)
 {
     if (length < sizeof(struct udp_hdr))
     {
-        LOG_ERROR("%s: pkt_trace_id: %lu, this_layer: %s, err: data not enough", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type));
+        LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_UDP));
         return data;
     }
 
-    if (raw_packet_parser_status(handler, data, this_type) == PARSE_STATUS_STOP)
+    uint16_t offset = (uintptr_t)data - (uintptr_t)(handler->data_ptr);
+    if (data_packet_push_layer(handler, LAYER_TYPE_UDP, offset) < 0)
     {
         return data;
     }
@@ -748,31 +716,32 @@ static const void *parse_udp(struct raw_pkt_parser *handler, const void *data, s
     const void *data_next_layer = (const char *)data + hdr_len;
     size_t data_next_length = length - hdr_len;
 
-    LOG_DEBUG("%s: pkt_trace_id: %lu, this_layer: %s, payload_len: [%lu/%lu]", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type), data_next_length, length);
+    LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_UDP), data_next_length, length);
     switch (ntohs(hdr->uh_dport))
     {
     // VXLAN_DPORT
     case 4789:
         // TESTED
-        return parse_vxlan(handler, data_next_layer, data_next_length, LAYER_TYPE_G_VXLAN);
+        return parse_vxlan(handler, data_next_layer, data_next_length);
     // GTP1U_PORT
     case 2152:
         // TESTED
-        return parse_gtpv1_u(handler, data_next_layer, data_next_length, LAYER_TYPE_GTPV1_U);
+        return parse_gtpv1_u(handler, data_next_layer, data_next_length);
     default:
         return data_next_layer;
     }
 }
 
-static const void *parse_pppoe_ses(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type)
+static const void *parse_pppoe_ses(struct data_packet *handler, const void *data, size_t length)
 {
     if (length < 8)
     {
-        LOG_ERROR("%s: pkt_trace_id: %lu, this_layer: %s, err: data not enough", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type));
+        LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_PPPOE));
         return data;
     }
 
-    if (raw_packet_parser_status(handler, data, this_type) == PARSE_STATUS_STOP)
+    uint16_t offset = (uintptr_t)data - (uintptr_t)(handler->data_ptr);
+    if (data_packet_push_layer(handler, LAYER_TYPE_PPPOE, offset) < 0)
     {
         return data;
     }
@@ -782,32 +751,33 @@ static const void *parse_pppoe_ses(struct raw_pkt_parser *handler, const void *d
     const void *data_next_layer = (const char *)data + hdr_len;
     size_t data_next_length = length - hdr_len;
 
-    LOG_DEBUG("%s: pkt_trace_id: %lu, this_layer: %s, payload_len: [%lu/%lu]", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type), data_next_length, length);
+    LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_PPPOE), data_next_length, length);
     switch (next_proto)
     {
         // PPPOE_TYPE_IPV4
     case 0x2100:
         // TESTED
-        return parse_ipv4(handler, data_next_layer, data_next_length, LAYER_TYPE_IPV4);
+        return parse_ipv4(handler, data_next_layer, data_next_length);
         // PPPOE_TYPE_IPV6
     case 0x5700:
         // TODO
-        return parse_ipv6(handler, data_next_layer, data_next_length, LAYER_TYPE_IPV6);
+        return parse_ipv6(handler, data_next_layer, data_next_length);
     default:
-        LOG_ERROR("%s: pkt_trace_id: %lu, this_layer: %s, stop parse next protocol %d", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type), next_proto);
+        LOG_ERROR("%s: trace_id: %lu, %s, stop parse next protocol %d", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_PPPOE), next_proto);
         return data_next_layer;
     }
 }
 
-static const void *parse_vxlan(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type)
+static const void *parse_vxlan(struct data_packet *handler, const void *data, size_t length)
 {
     if (length < sizeof(struct vxlan_hdr))
     {
-        LOG_ERROR("%s: pkt_trace_id: %lu, this_layer: %s, err: data not enough", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type));
+        LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_G_VXLAN));
         return NULL;
     }
 
-    if (raw_packet_parser_status(handler, data, this_type) == PARSE_STATUS_STOP)
+    uint16_t offset = (uintptr_t)data - (uintptr_t)(handler->data_ptr);
+    if (data_packet_push_layer(handler, LAYER_TYPE_G_VXLAN, offset) < 0)
     {
         return data;
     }
@@ -817,20 +787,21 @@ static const void *parse_vxlan(struct raw_pkt_parser *handler, const void *data,
     const void *data_next_layer = (const char *)data + hdr_len;
     size_t data_next_length = length - hdr_len;
 
-    LOG_DEBUG("%s: pkt_trace_id: %lu, this_layer: %s, payload_len: [%lu/%lu]", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type), data_next_length, length);
+    LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_G_VXLAN), data_next_length, length);
     // TESTED
-    return parse_ether(handler, data_next_layer, data_next_length, LAYER_TYPE_ETHER);
+    return parse_ether(handler, data_next_layer, data_next_length);
 }
 
-static const void *parse_vlan8021q(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type)
+static const void *parse_vlan8021q(struct data_packet *handler, const void *data, size_t length)
 {
     if (length < sizeof(struct vlan_hdr))
     {
-        LOG_ERROR("%s: pkt_trace_id: %lu, this_layer: %s, err: data not enough", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type));
+        LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_VLAN));
         return NULL;
     }
 
-    if (raw_packet_parser_status(handler, data, this_type) == PARSE_STATUS_STOP)
+    uint16_t offset = (uintptr_t)data - (uintptr_t)(handler->data_ptr);
+    if (data_packet_push_layer(handler, LAYER_TYPE_VLAN, offset) < 0)
     {
         return data;
     }
@@ -841,35 +812,35 @@ static const void *parse_vlan8021q(struct raw_pkt_parser *handler, const void *d
     const void *data_next_layer = (const char *)data + hdr_len;
     size_t data_next_length = length - hdr_len;
 
-    LOG_DEBUG("%s: pkt_trace_id: %lu, this_layer: %s, payload_len: [%lu/%lu]", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type), data_next_length, length);
+    LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_VLAN), data_next_length, length);
     switch (next_proto)
     {
     case ETH_P_8021Q:
         // TESTED
-        return parse_vlan8021q(handler, data_next_layer, data_next_length, LAYER_TYPE_VLAN);
+        return parse_vlan8021q(handler, data_next_layer, data_next_length);
     case ETH_P_IP:
         // TESTED
-        return parse_ipv4(handler, data_next_layer, data_next_length, LAYER_TYPE_IPV4);
+        return parse_ipv4(handler, data_next_layer, data_next_length);
     case ETH_P_IPV6:
         // TODO
-        return parse_ipv6(handler, data_next_layer, data_next_length, LAYER_TYPE_IPV6);
+        return parse_ipv6(handler, data_next_layer, data_next_length);
     case ETH_P_PPP_SES:
         // TESTED
-        return parse_pppoe_ses(handler, data_next_layer, data_next_length, LAYER_TYPE_PPPOE);
+        return parse_pppoe_ses(handler, data_next_layer, data_next_length);
     case ETH_P_MPLS_UC:
         // TODO
-        return parse_mpls(handler, data_next_layer, data_next_length, LAYER_TYPE_MPLS);
+        return parse_mpls(handler, data_next_layer, data_next_length);
     default:
-        LOG_ERROR("%s: pkt_trace_id: %lu, this_layer: %s, stop parse next protocol %d", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type), next_proto);
+        LOG_ERROR("%s: trace_id: %lu, %s, stop parse next protocol %d", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_VLAN), next_proto);
         return data_next_layer;
     }
 }
 
-static const void *parse_gtpv1_u(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type)
+static const void *parse_gtpv1_u(struct data_packet *handler, const void *data, size_t length)
 {
     if (length < sizeof(struct gtp_hdr))
     {
-        LOG_ERROR("%s: pkt_trace_id: %lu, this_layer: %s, err: data not enough", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type));
+        LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_GTPV1_U));
         return NULL;
     }
 
@@ -879,7 +850,8 @@ static const void *parse_gtpv1_u(struct raw_pkt_parser *handler, const void *dat
         return data;
     }
 
-    if (raw_packet_parser_status(handler, data, this_type) == PARSE_STATUS_STOP)
+    uint16_t offset = (uintptr_t)data - (uintptr_t)(handler->data_ptr);
+    if (data_packet_push_layer(handler, LAYER_TYPE_GTPV1_U, offset) < 0)
     {
         return data;
     }
@@ -888,30 +860,31 @@ static const void *parse_gtpv1_u(struct raw_pkt_parser *handler, const void *dat
     const void *data_next_layer = (const char *)data + hdr_len;
     size_t data_next_length = length - hdr_len;
 
-    LOG_DEBUG("%s: pkt_trace_id: %lu, this_layer: %s, payload_len: [%lu/%lu]", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type), data_next_length, length);
+    LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_GTPV1_U), data_next_length, length);
     switch (next_proto)
     {
     case 4:
         // TESTED
-        return parse_ipv4(handler, data_next_layer, data_next_length, LAYER_TYPE_IPV4);
+        return parse_ipv4(handler, data_next_layer, data_next_length);
     case 6:
         // TESTED
-        return parse_ipv6(handler, data_next_layer, data_next_length, LAYER_TYPE_IPV6);
+        return parse_ipv6(handler, data_next_layer, data_next_length);
     default:
-        LOG_ERROR("%s: pkt_trace_id: %lu, this_layer: %s, stop parse next protocol %d", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type), next_proto);
+        LOG_ERROR("%s: trace_id: %lu, %s, stop parse next protocol %d", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_GTPV1_U), next_proto);
         return data_next_layer;
     }
 }
 
-static const void *parse_mpls(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type)
+static const void *parse_mpls(struct data_packet *handler, const void *data, size_t length)
 {
     if (length < 4)
     {
-        LOG_ERROR("%s: pkt_trace_id: %lu, this_layer: %s, err: data not enough", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type));
+        LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_MPLS));
         return data;
     }
 
-    if (raw_packet_parser_status(handler, data, this_type) == PARSE_STATUS_STOP)
+    uint16_t offset = (uintptr_t)data - (uintptr_t)(handler->data_ptr);
+    if (data_packet_push_layer(handler, LAYER_TYPE_MPLS, offset) < 0)
     {
         return data;
     }
@@ -961,33 +934,33 @@ static const void *parse_mpls(struct raw_pkt_parser *handler, const void *data,
             data_next_layer = (const char *)data_next_layer + 4;
             data_next_length = data_next_length - 4;
 
-            LOG_DEBUG("%s: pkt_trace_id: %lu, this_layer: %s, payload_len: [%lu/%lu]", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type), data_next_length, length);
+            LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_MPLS), data_next_length, length);
             // TESTED
-            return parse_ether(handler, data_next_layer, data_next_length, LAYER_TYPE_ETHER);
+            return parse_ether(handler, data_next_layer, data_next_length);
         }
         else if (ip_version == 4)
         {
-            LOG_DEBUG("%s: pkt_trace_id: %lu, this_layer: %s, payload_len: [%lu/%lu]", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type), data_next_length, length);
+            LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_MPLS), data_next_length, length);
             // TESTED
-            return parse_ipv4(handler, data_next_layer, data_next_length, LAYER_TYPE_IPV4);
+            return parse_ipv4(handler, data_next_layer, data_next_length);
         }
         else if (ip_version == 6)
         {
-            LOG_DEBUG("%s: pkt_trace_id: %lu, this_layer: %s, payload_len: [%lu/%lu]", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type), data_next_length, length);
+            LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_MPLS), data_next_length, length);
             // TODO
-            return parse_ipv6(handler, data_next_layer, data_next_length, LAYER_TYPE_IPV6);
+            return parse_ipv6(handler, data_next_layer, data_next_length);
         }
         else
         {
-            LOG_DEBUG("%s: pkt_trace_id: %lu, this_layer: %s, payload_len: [%lu/%lu]", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type), data_next_length, length);
+            LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_MPLS), data_next_length, length);
             // TODO
-            return parse_ether(handler, data_next_layer, data_next_length, LAYER_TYPE_ETHER);
+            return parse_ether(handler, data_next_layer, data_next_length);
         }
     }
     else
     {
-        LOG_DEBUG("%s: pkt_trace_id: %lu, this_layer: %s, payload_len: [%lu/%lu]", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type), data_next_length, length);
+        LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_MPLS), data_next_length, length);
         // TESTED
-        return parse_mpls(handler, data_next_layer, data_next_length, LAYER_TYPE_MPLS);
+        return parse_mpls(handler, data_next_layer, data_next_length);
     }
 }
\ No newline at end of file
diff --git a/common/src/utils.cpp b/common/src/utils.cpp
index 6eedc59..5a661a2 100644
--- a/common/src/utils.cpp
+++ b/common/src/utils.cpp
@@ -12,17 +12,17 @@
 #include "log.h"
 
 /******************************************************************************
- * fixed_num_array
+ * mutable_array
  ******************************************************************************/
 
-void fixed_num_array_init(struct fixed_num_array *array)
+void mutable_array_init(struct mutable_array *array)
 {
-    memset(array, 0, sizeof(fixed_num_array));
+    memset(array, 0, sizeof(mutable_array));
     array->num = 0;
     array->size = sizeof(array->elems) / sizeof(array->elems[0]);
 }
 
-void fixed_num_array_add_elem(struct fixed_num_array *array, uint64_t elem)
+void mutable_array_add_elem(struct mutable_array *array, uint64_t elem)
 {
     if (array->num < array->size)
     {
@@ -35,7 +35,7 @@ void fixed_num_array_add_elem(struct fixed_num_array *array, uint64_t elem)
     }
 }
 
-void fixed_num_array_del_elem(struct fixed_num_array *array, uint64_t elem)
+void mutable_array_del_elem(struct mutable_array *array, uint64_t elem)
 {
     for (int i = 0; i < array->num; i++)
     {
@@ -51,7 +51,7 @@ void fixed_num_array_del_elem(struct fixed_num_array *array, uint64_t elem)
     }
 }
 
-int fixed_num_array_is_full(struct fixed_num_array *array)
+int mutable_array_is_full(struct mutable_array *array)
 {
     if (array->num == array->size)
     {
@@ -63,7 +63,7 @@ int fixed_num_array_is_full(struct fixed_num_array *array)
     }
 }
 
-int fixed_num_array_count_elem(struct fixed_num_array *array)
+int mutable_array_count_elem(struct mutable_array *array)
 {
     if (array)
     {
@@ -75,7 +75,7 @@ int fixed_num_array_count_elem(struct fixed_num_array *array)
     }
 }
 
-int fixed_num_array_exist_elem(struct fixed_num_array *array, uint64_t elem)
+int mutable_array_exist_elem(struct mutable_array *array, uint64_t elem)
 {
     for (int i = 0; i < array->num; i++)
     {
@@ -88,7 +88,7 @@ int fixed_num_array_exist_elem(struct fixed_num_array *array, uint64_t elem)
     return 0;
 }
 
-int fixed_num_array_index_elem(struct fixed_num_array *array, int index)
+int mutable_array_index_elem(struct mutable_array *array, int index)
 {
     if (index >= array->num)
     {
diff --git a/common/test/CMakeLists.txt b/common/test/CMakeLists.txt
index 216d187..ff72650 100644
--- a/common/test/CMakeLists.txt
+++ b/common/test/CMakeLists.txt
@@ -15,20 +15,20 @@ target_include_directories(gtest_session_table PUBLIC ${CMAKE_SOURCE_DIR}/common
 target_link_libraries(gtest_session_table common gtest)
 
 ###############################################################################
-# gtest_raw_packet
+# gtest_data_packet
 ###############################################################################
 
-add_executable(gtest_raw_packet gtest_raw_packet.cpp)
-target_include_directories(gtest_raw_packet PUBLIC ${CMAKE_SOURCE_DIR}/common/include)
-target_link_libraries(gtest_raw_packet common gtest)
+add_executable(gtest_data_packet gtest_data_packet.cpp)
+target_include_directories(gtest_data_packet PUBLIC ${CMAKE_SOURCE_DIR}/common/include)
+target_link_libraries(gtest_data_packet common gtest)
 
 ###############################################################################
-# gtest_ctrl_packet
+# gtest_control_packet
 ###############################################################################
 
-add_executable(gtest_ctrl_packet gtest_ctrl_packet.cpp)
-target_include_directories(gtest_ctrl_packet PUBLIC ${CMAKE_SOURCE_DIR}/common/include)
-target_link_libraries(gtest_ctrl_packet common gtest)
+add_executable(gtest_control_packet gtest_control_packet.cpp)
+target_include_directories(gtest_control_packet PUBLIC ${CMAKE_SOURCE_DIR}/common/include)
+target_link_libraries(gtest_control_packet common gtest)
 
 ###############################################################################
 # gtest_utils
@@ -53,7 +53,7 @@ target_link_libraries(gtest_health_check_table common gtest platform)
 include(GoogleTest)
 gtest_discover_tests(gtest_addr_tuple4)
 gtest_discover_tests(gtest_session_table)
-gtest_discover_tests(gtest_raw_packet)
-gtest_discover_tests(gtest_ctrl_packet)
+gtest_discover_tests(gtest_data_packet)
+gtest_discover_tests(gtest_control_packet)
 gtest_discover_tests(gtest_utils)
 gtest_discover_tests(gtest_health_check_table)
diff --git a/common/test/gtest_ctrl_packet.cpp b/common/test/gtest_control_packet.cpp
index ab1f092..9ea09d9 100644
--- a/common/test/gtest_ctrl_packet.cpp
+++ b/common/test/gtest_control_packet.cpp
@@ -1,9 +1,9 @@
 #include <gtest/gtest.h>
 
 #include "mpack.h"
-#include "ctrl_packet.h"
+#include "control_packet.h"
 
-static u_char ctrl_pkt_active0[] = {
+static u_char control_packet_active0[] = {
 	0x85, 0xA5, 0x74, 0x73, 0x79, 0x6E, 0x63, 0xA3, 0x32, 0x2E, 0x30, 0xAA, 0x73, 0x65, 0x73, 0x73,
 	0x69, 0x6F, 0x6E, 0x5F, 0x69, 0x64, 0xCF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xA5,
 	0x73, 0x74, 0x61, 0x74, 0x65, 0xA6, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0xA6, 0x6D, 0x65, 0x74,
@@ -22,7 +22,7 @@ static u_char ctrl_pkt_active0[] = {
 	0x0A, 0x92, 0xCD, 0x15, 0xB3, 0xCD, 0x1A, 0x0A, 0x92, 0xCD, 0x15, 0xB3, 0xCD, 0x1A, 0x0A, 0x92,
 	0x01, 0x01, 0x92, 0x01, 0x01};
 
-static u_char ctrl_pkt_active1[] = {
+static u_char control_packet_active1[] = {
 	0x85, 0xA5, 0x74, 0x73, 0x79, 0x6E, 0x63, 0xA3, 0x32, 0x2E, 0x30, 0xAA, 0x73, 0x65, 0x73, 0x73,
 	0x69, 0x6F, 0x6E, 0x5F, 0x69, 0x64, 0xCF, 0x04, 0x08, 0x02, 0x1B, 0x68, 0x4C, 0x03, 0xE9, 0xA5,
 	0x73, 0x74, 0x61, 0x74, 0x65, 0xA6, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, 0xA6, 0x6D, 0x65, 0x74,
@@ -30,12 +30,12 @@ static u_char ctrl_pkt_active1[] = {
 	0x65, 0xA6, 0x70, 0x61, 0x72, 0x61, 0x6D, 0x73, 0x81, 0xA3, 0x73, 0x63, 0x65, 0x81, 0xA8, 0x72,
 	0x75, 0x6C, 0x65, 0x5F, 0x69, 0x64, 0x73, 0x91, 0xCE, 0x00, 0x0F, 0x2F, 0x7F};
 
-static u_char ctrl_pkt_opening[] = {
+static u_char control_packet_opening[] = {
 	0x83, 0xA5, 0x74, 0x73, 0x79, 0x6E, 0x63, 0xA3, 0x32, 0x2E, 0x30, 0xAA, 0x73, 0x65, 0x73, 0x73,
 	0x69, 0x6F, 0x6E, 0x5F, 0x69, 0x64, 0xCF, 0x04, 0x08, 0x02, 0x1B, 0x68, 0x4C, 0x03, 0xE9, 0xA5,
 	0x73, 0x74, 0x61, 0x74, 0x65, 0xA7, 0x6F, 0x70, 0x65, 0x6E, 0x69, 0x6E, 0x67};
 
-TEST(CTRL_PACKET, PACKAGE0)
+TEST(CONTROL_PACKET, PACKAGE0)
 {
 	char *data;
 	size_t size;
@@ -171,8 +171,8 @@ TEST(CTRL_PACKET, PACKAGE0)
 
 	// finish writing
 	EXPECT_TRUE(mpack_writer_destroy(&writer) == mpack_ok);
-	EXPECT_TRUE(size == sizeof(ctrl_pkt_active0));
-	EXPECT_TRUE(memcmp(data, ctrl_pkt_active0, size) == 0);
+	EXPECT_TRUE(size == sizeof(control_packet_active0));
+	EXPECT_TRUE(memcmp(data, control_packet_active0, size) == 0);
 
 	// data to hex
 	for (size_t i = 0; i < size; i++)
@@ -184,7 +184,7 @@ TEST(CTRL_PACKET, PACKAGE0)
 	free(data);
 }
 
-TEST(CTRL_PACKET, PACKAGE1)
+TEST(CONTROL_PACKET, PACKAGE1)
 {
 	char *data;
 	size_t size;
@@ -235,8 +235,8 @@ TEST(CTRL_PACKET, PACKAGE1)
 
 	// finish writing
 	EXPECT_TRUE(mpack_writer_destroy(&writer) == mpack_ok);
-	EXPECT_TRUE(size == sizeof(ctrl_pkt_active1));
-	EXPECT_TRUE(memcmp(data, ctrl_pkt_active1, size) == 0);
+	EXPECT_TRUE(size == sizeof(control_packet_active1));
+	EXPECT_TRUE(memcmp(data, control_packet_active1, size) == 0);
 
 	// data to hex
 	for (size_t i = 0; i < size; i++)
@@ -248,7 +248,7 @@ TEST(CTRL_PACKET, PACKAGE1)
 	free(data);
 }
 
-TEST(CTRL_PACKET, PACKAGE2)
+TEST(CONTROL_PACKET, PACKAGE2)
 {
 	char *data;
 	size_t size;
@@ -274,8 +274,8 @@ TEST(CTRL_PACKET, PACKAGE2)
 
 	// finish writing
 	EXPECT_TRUE(mpack_writer_destroy(&writer) == mpack_ok);
-	EXPECT_TRUE(size == sizeof(ctrl_pkt_opening));
-	EXPECT_TRUE(memcmp(data, ctrl_pkt_opening, size) == 0);
+	EXPECT_TRUE(size == sizeof(control_packet_opening));
+	EXPECT_TRUE(memcmp(data, control_packet_opening, size) == 0);
 
 	// data to hex
 	for (size_t i = 0; i < size; i++)
@@ -287,49 +287,46 @@ TEST(CTRL_PACKET, PACKAGE2)
 	free(data);
 }
 
-TEST(CTRL_PACKET, PARSE0)
+TEST(CONTROL_PACKET, PARSE0)
 {
-	struct ctrl_pkt_parser parser;
-	ctrl_packet_parser_init(&parser);
-	EXPECT_TRUE(ctrl_packet_parser_parse(&parser, (const char *)ctrl_pkt_active0, sizeof(ctrl_pkt_active0)) == 0);
-	ctrl_packet_parser_dump(&parser);
-
-	EXPECT_STREQ(parser.tsync, "2.0");
-	EXPECT_TRUE(parser.session_id == 18446744073709551615);
-	EXPECT_TRUE(parser.state == SESSION_STATE_ACTIVE);
-	EXPECT_STREQ(parser.method, "policy_update");
-	EXPECT_TRUE(parser.rule_id_num == 2);
-	EXPECT_TRUE(parser.rule_ids[0] == 1111);
-	EXPECT_TRUE(parser.rule_ids[1] == 2222);
+	struct control_packet handler;
+	EXPECT_TRUE(control_packet_parse(&handler, (const char *)control_packet_active0, sizeof(control_packet_active0)) == 0);
+	control_packet_dump(&handler);
+
+	EXPECT_STREQ(handler.tsync, "2.0");
+	EXPECT_TRUE(handler.session_id == 18446744073709551615);
+	EXPECT_TRUE(handler.state == SESSION_STATE_ACTIVE);
+	EXPECT_STREQ(handler.method, "policy_update");
+	EXPECT_TRUE(handler.rule_id_num == 2);
+	EXPECT_TRUE(handler.rule_ids[0] == 1111);
+	EXPECT_TRUE(handler.rule_ids[1] == 2222);
 }
 
-TEST(CTRL_PACKET, PARSE1)
+TEST(CONTROL_PACKET, PARSE1)
 {
-	struct ctrl_pkt_parser parser;
-	ctrl_packet_parser_init(&parser);
-	EXPECT_TRUE(ctrl_packet_parser_parse(&parser, (const char *)ctrl_pkt_active1, sizeof(ctrl_pkt_active1)) == 0);
-	ctrl_packet_parser_dump(&parser);
-
-	EXPECT_STREQ(parser.tsync, "2.0");
-	EXPECT_TRUE(parser.session_id == 290484492702581737);
-	EXPECT_TRUE(parser.state == SESSION_STATE_ACTIVE);
-	EXPECT_STREQ(parser.method, "policy_update");
-	EXPECT_TRUE(parser.rule_id_num == 1);
-	EXPECT_TRUE(parser.rule_ids[0] == 995199);
+	struct control_packet handler;
+	EXPECT_TRUE(control_packet_parse(&handler, (const char *)control_packet_active1, sizeof(control_packet_active1)) == 0);
+	control_packet_dump(&handler);
+
+	EXPECT_STREQ(handler.tsync, "2.0");
+	EXPECT_TRUE(handler.session_id == 290484492702581737);
+	EXPECT_TRUE(handler.state == SESSION_STATE_ACTIVE);
+	EXPECT_STREQ(handler.method, "policy_update");
+	EXPECT_TRUE(handler.rule_id_num == 1);
+	EXPECT_TRUE(handler.rule_ids[0] == 995199);
 }
 
-TEST(CTRL_PACKET, PARSE2)
+TEST(CONTROL_PACKET, PARSE2)
 {
-	struct ctrl_pkt_parser parser;
-	ctrl_packet_parser_init(&parser);
-	EXPECT_TRUE(ctrl_packet_parser_parse(&parser, (const char *)ctrl_pkt_opening, sizeof(ctrl_pkt_opening)) == 0);
-	ctrl_packet_parser_dump(&parser);
-
-	EXPECT_STREQ(parser.tsync, "2.0");
-	EXPECT_TRUE(parser.session_id == 290484492702581737);
-	EXPECT_TRUE(parser.state == SESSION_STATE_OPENING);
-	EXPECT_STREQ(parser.method, "");
-	EXPECT_TRUE(parser.rule_id_num == 0);
+	struct control_packet handler;
+	EXPECT_TRUE(control_packet_parse(&handler, (const char *)control_packet_opening, sizeof(control_packet_opening)) == 0);
+	control_packet_dump(&handler);
+
+	EXPECT_STREQ(handler.tsync, "2.0");
+	EXPECT_TRUE(handler.session_id == 290484492702581737);
+	EXPECT_TRUE(handler.state == SESSION_STATE_OPENING);
+	EXPECT_STREQ(handler.method, "");
+	EXPECT_TRUE(handler.rule_id_num == 0);
 }
 
 int main(int argc, char **argv)
diff --git a/common/test/gtest_raw_packet.cpp b/common/test/gtest_data_packet.cpp
index 47b4af6..e713f79 100644
--- a/common/test/gtest_raw_packet.cpp
+++ b/common/test/gtest_data_packet.cpp
@@ -1,7 +1,7 @@
 #include <gtest/gtest.h>
 #include <arpa/inet.h>
 
-#include "raw_packet.h"
+#include "data_packet.h"
 #include "addr_tuple4.h"
 
 /******************************************************************************
@@ -75,12 +75,11 @@ unsigned char data1[] = {
 	0xab, 0xcd, 0xab, 0xcd, 0xab, 0xcd, 0xab, 0xcd, 0xab, 0xcd, 0xab, 0xcd, 0xab, 0xcd, 0xab, 0xcd, 0xab, 0xcd, 0xab, 0xcd, 0xab, 0xcd, 0xab, 0xcd, 0xab, 0xcd,
 	0xab, 0xcd, 0xab, 0xcd, 0xab, 0xcd, 0xab, 0xcd, 0xab, 0xcd, 0xab, 0xcd, 0xab, 0xcd};
 
-TEST(RAW_PACKET, ETH_VLAN_VLAN_IP4_IP4_UDP)
+TEST(DATA_PACKET, ETH_VLAN_VLAN_IP4_IP4_UDP)
 {
-	struct raw_pkt_parser handler;
-	raw_packet_parser_init(&handler, 0, LAYER_TYPE_ALL, 8);
+	struct data_packet handler;
 
-	const void *payload = raw_packet_parser_parse(&handler, (const void *)data1, sizeof(data1));
+	const void *payload = data_packet_parse(&handler, (const void *)data1, sizeof(data1), 0);
 	EXPECT_TRUE(payload != nullptr);
 	EXPECT_TRUE((char *)payload - (char *)&data1 == 70);
 
@@ -91,8 +90,8 @@ TEST(RAW_PACKET, ETH_VLAN_VLAN_IP4_IP4_UDP)
 
 	memset(&inner_addr, 0, sizeof(inner_addr));
 	memset(&outer_addr, 0, sizeof(outer_addr));
-	EXPECT_TRUE(raw_packet_parser_get_most_inner_tuple4(&handler, &inner_addr) == 0);
-	EXPECT_TRUE(raw_packet_parser_get_most_outer_tuple4(&handler, &outer_addr) == 0);
+	EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0);
+	EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0);
 	inner_addr_str = addr_tuple4_to_str(&inner_addr);
 	outer_addr_str = addr_tuple4_to_str(&outer_addr);
 	EXPECT_STREQ(inner_addr_str, "10.10.100.25 62367 10.10.101.2 17000");
@@ -102,8 +101,8 @@ TEST(RAW_PACKET, ETH_VLAN_VLAN_IP4_IP4_UDP)
 
 	memset(&inner_addr, 0, sizeof(inner_addr));
 	memset(&outer_addr, 0, sizeof(outer_addr));
-	EXPECT_TRUE(raw_packet_parser_get_most_inner_address(&handler, &inner_addr) == 0);
-	EXPECT_TRUE(raw_packet_parser_get_most_outer_address(&handler, &outer_addr) == 0);
+	EXPECT_TRUE(data_packet_get_innermost_address(&handler, &inner_addr) == 0);
+	EXPECT_TRUE(data_packet_get_outermost_address(&handler, &outer_addr) == 0);
 	inner_addr_str = addr_tuple4_to_str(&inner_addr);
 	outer_addr_str = addr_tuple4_to_str(&outer_addr);
 	EXPECT_STREQ(inner_addr_str, "10.10.100.25 0 10.10.101.2 0");
@@ -206,12 +205,11 @@ unsigned char data2[] = {
 	0xef, 0x9e, 0x67, 0x7e, 0x1e, 0xb0, 0x2a, 0x7f, 0x97, 0xf3, 0x5a, 0xbc, 0x21, 0x8d, 0xf9, 0xc3, 0x30, 0x45, 0xfe, 0x72, 0x74, 0x04, 0x53, 0x99, 0xe7, 0xd1,
 	0x2b, 0xb6, 0x3a, 0x9c, 0x84, 0x0e, 0x15, 0x5e, 0x75, 0x3b, 0xc9, 0x0e, 0x94, 0xe6, 0x48, 0x0e, 0x37, 0x07, 0xf8, 0xd9, 0x59, 0x4b, 0x04, 0x50};
 
-TEST(RAW_PACKET, ETH_IP6_IP4_TCP_SSH)
+TEST(DATA_PACKET, ETH_IP6_IP4_TCP_SSH)
 {
-	struct raw_pkt_parser handler;
-	raw_packet_parser_init(&handler, 0, LAYER_TYPE_ALL, 8);
+	struct data_packet handler;
 
-	const void *payload = raw_packet_parser_parse(&handler, (const void *)data2, sizeof(data2));
+	const void *payload = data_packet_parse(&handler, (const void *)data2, sizeof(data2), 0);
 	EXPECT_TRUE(payload != nullptr);
 	EXPECT_TRUE((char *)payload - (char *)&data2 == 94);
 
@@ -222,8 +220,8 @@ TEST(RAW_PACKET, ETH_IP6_IP4_TCP_SSH)
 
 	memset(&inner_addr, 0, sizeof(inner_addr));
 	memset(&outer_addr, 0, sizeof(outer_addr));
-	EXPECT_TRUE(raw_packet_parser_get_most_inner_tuple4(&handler, &inner_addr) == 0);
-	EXPECT_TRUE(raw_packet_parser_get_most_outer_tuple4(&handler, &outer_addr) == 0);
+	EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0);
+	EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0);
 	inner_addr_str = addr_tuple4_to_str(&inner_addr);
 	outer_addr_str = addr_tuple4_to_str(&outer_addr);
 	EXPECT_STREQ(inner_addr_str, "1.1.1.1 57639 2.2.2.2 22");
@@ -233,8 +231,8 @@ TEST(RAW_PACKET, ETH_IP6_IP4_TCP_SSH)
 
 	memset(&inner_addr, 0, sizeof(inner_addr));
 	memset(&outer_addr, 0, sizeof(outer_addr));
-	EXPECT_TRUE(raw_packet_parser_get_most_inner_address(&handler, &inner_addr) == 0);
-	EXPECT_TRUE(raw_packet_parser_get_most_outer_address(&handler, &outer_addr) == 0);
+	EXPECT_TRUE(data_packet_get_innermost_address(&handler, &inner_addr) == 0);
+	EXPECT_TRUE(data_packet_get_outermost_address(&handler, &outer_addr) == 0);
 	inner_addr_str = addr_tuple4_to_str(&inner_addr);
 	outer_addr_str = addr_tuple4_to_str(&outer_addr);
 	EXPECT_STREQ(inner_addr_str, "1.1.1.1 0 2.2.2.2 0");
@@ -332,12 +330,11 @@ unsigned char data3[] = {
 	0x00, 0x00, 0x03, 0x84, 0x00, 0x09, 0x3a, 0x80, 0x00, 0x01, 0x51, 0x80};
 
 #if 0
-TEST(RAW_PACKET, ETH_VLAN_IP6_IP4_GRE_PPP_IP4_UDP_DNS)
+TEST(DATA_PACKET, ETH_VLAN_IP6_IP4_GRE_PPP_IP4_UDP_DNS)
 {
-	struct raw_pkt_parser handler;
-	raw_packet_parser_init(&handler, 0 , LAYER_TYPE_ALL, 8);
+	struct data_packet handler;
 
-	const void *payload = raw_packet_parser_parse(&handler, (const void *)data3, sizeof(data3));
+	const void *payload = data_packet_parse(&handler, (const void *)data3, sizeof(data3), 0);
 	EXPECT_TRUE(payload != nullptr);
 	EXPECT_TRUE((char *)payload - (char *)&data3 == 126);
 
@@ -348,8 +345,8 @@ TEST(RAW_PACKET, ETH_VLAN_IP6_IP4_GRE_PPP_IP4_UDP_DNS)
 
 	memset(&inner_addr, 0, sizeof(inner_addr));
 	memset(&outer_addr, 0, sizeof(outer_addr));
-	EXPECT_TRUE(raw_packet_parser_get_most_inner_tuple4(&handler, &inner_addr) == 0);
-	EXPECT_TRUE(raw_packet_parser_get_most_outer_tuple4(&handler, &outer_addr) == 0);
+	EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0);
+	EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0);
 	inner_addr_str = addr_tuple4_to_str(&inner_addr);
 	outer_addr_str = addr_tuple4_to_str(&outer_addr);
 	EXPECT_STREQ(inner_addr_str, "8.8.8.8 53 172.16.44.3 9879");
@@ -359,8 +356,8 @@ TEST(RAW_PACKET, ETH_VLAN_IP6_IP4_GRE_PPP_IP4_UDP_DNS)
 
 	memset(&inner_addr, 0, sizeof(inner_addr));
 	memset(&outer_addr, 0, sizeof(outer_addr));
-	EXPECT_TRUE(raw_packet_parser_get_most_inner_address(&handler, &inner_addr) == 0);
-	EXPECT_TRUE(raw_packet_parser_get_most_outer_address(&handler, &outer_addr) == 0);
+	EXPECT_TRUE(data_packet_get_innermost_address(&handler, &inner_addr) == 0);
+	EXPECT_TRUE(data_packet_get_outermost_address(&handler, &outer_addr) == 0);
 	inner_addr_str = addr_tuple4_to_str(&inner_addr);
 	outer_addr_str = addr_tuple4_to_str(&outer_addr);
 	EXPECT_STREQ(inner_addr_str, "8.8.8.8 0 172.16.44.3 0");
@@ -433,12 +430,11 @@ unsigned char data4[] = {
 	0x81, 0x80, 0x5c, 0x76, 0x00, 0x00, 0x00, 0x00, 0x80, 0x02, 0x20, 0x00, 0xf7, 0x57, 0x00, 0x00, 0x02, 0x04, 0x04, 0xc4, 0x01, 0x03, 0x03, 0x08, 0x01, 0x01,
 	0x04, 0x02};
 
-TEST(RAW_PACKET, ETH_IP4_IP6_TCP)
+TEST(DATA_PACKET, ETH_IP4_IP6_TCP)
 {
-	struct raw_pkt_parser handler;
-	raw_packet_parser_init(&handler, 0, LAYER_TYPE_ALL, 8);
+	struct data_packet handler;
 
-	const void *payload = raw_packet_parser_parse(&handler, (const void *)data4, sizeof(data4));
+	const void *payload = data_packet_parse(&handler, (const void *)data4, sizeof(data4), 0);
 	EXPECT_TRUE(payload != nullptr);
 	EXPECT_TRUE((char *)payload - (char *)&data4 == 106);
 
@@ -449,8 +445,8 @@ TEST(RAW_PACKET, ETH_IP4_IP6_TCP)
 
 	memset(&inner_addr, 0, sizeof(inner_addr));
 	memset(&outer_addr, 0, sizeof(outer_addr));
-	EXPECT_TRUE(raw_packet_parser_get_most_inner_tuple4(&handler, &inner_addr) == 0);
-	EXPECT_TRUE(raw_packet_parser_get_most_outer_tuple4(&handler, &outer_addr) == 0);
+	EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0);
+	EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0);
 	inner_addr_str = addr_tuple4_to_str(&inner_addr);
 	outer_addr_str = addr_tuple4_to_str(&outer_addr);
 	EXPECT_STREQ(inner_addr_str, "2001:da8:200:900e:200:5efe:d24d:58a3 52556 2600:140e:6::1702:1058 80");
@@ -460,8 +456,8 @@ TEST(RAW_PACKET, ETH_IP4_IP6_TCP)
 
 	memset(&inner_addr, 0, sizeof(inner_addr));
 	memset(&outer_addr, 0, sizeof(outer_addr));
-	EXPECT_TRUE(raw_packet_parser_get_most_inner_address(&handler, &inner_addr) == 0);
-	EXPECT_TRUE(raw_packet_parser_get_most_outer_address(&handler, &outer_addr) == 0);
+	EXPECT_TRUE(data_packet_get_innermost_address(&handler, &inner_addr) == 0);
+	EXPECT_TRUE(data_packet_get_outermost_address(&handler, &outer_addr) == 0);
 	inner_addr_str = addr_tuple4_to_str(&inner_addr);
 	outer_addr_str = addr_tuple4_to_str(&outer_addr);
 	EXPECT_STREQ(inner_addr_str, "2001:da8:200:900e:200:5efe:d24d:58a3 0 2600:140e:6::1702:1058 0");
@@ -519,12 +515,11 @@ unsigned char data5[] = {
 	0xca, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xba, 0xbe, 0x75, 0x30, 0x32, 0xc8, 0x00, 0x0c, 0x83, 0xd2, 0x58, 0x58,
 	0x58, 0x58};
 
-TEST(RAW_PACKET, ETH_IP6_IP6_UDP)
+TEST(DATA_PACKET, ETH_IP6_IP6_UDP)
 {
-	struct raw_pkt_parser handler;
-	raw_packet_parser_init(&handler, 0, LAYER_TYPE_ALL, 8);
+	struct data_packet handler;
 
-	const void *payload = raw_packet_parser_parse(&handler, (const void *)data5, sizeof(data5));
+	const void *payload = data_packet_parse(&handler, (const void *)data5, sizeof(data5), 0);
 	EXPECT_TRUE(payload != nullptr);
 	EXPECT_TRUE((char *)payload - (char *)&data5 == 102);
 
@@ -535,8 +530,8 @@ TEST(RAW_PACKET, ETH_IP6_IP6_UDP)
 
 	memset(&inner_addr, 0, sizeof(inner_addr));
 	memset(&outer_addr, 0, sizeof(outer_addr));
-	EXPECT_TRUE(raw_packet_parser_get_most_inner_tuple4(&handler, &inner_addr) == 0);
-	EXPECT_TRUE(raw_packet_parser_get_most_outer_tuple4(&handler, &outer_addr) == 0);
+	EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0);
+	EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0);
 	inner_addr_str = addr_tuple4_to_str(&inner_addr);
 	outer_addr_str = addr_tuple4_to_str(&outer_addr);
 	EXPECT_STREQ(inner_addr_str, "dead::beef 30000 cafe::babe 13000");
@@ -546,8 +541,8 @@ TEST(RAW_PACKET, ETH_IP6_IP6_UDP)
 
 	memset(&inner_addr, 0, sizeof(inner_addr));
 	memset(&outer_addr, 0, sizeof(outer_addr));
-	EXPECT_TRUE(raw_packet_parser_get_most_inner_address(&handler, &inner_addr) == 0);
-	EXPECT_TRUE(raw_packet_parser_get_most_outer_address(&handler, &outer_addr) == 0);
+	EXPECT_TRUE(data_packet_get_innermost_address(&handler, &inner_addr) == 0);
+	EXPECT_TRUE(data_packet_get_outermost_address(&handler, &outer_addr) == 0);
 	inner_addr_str = addr_tuple4_to_str(&inner_addr);
 	outer_addr_str = addr_tuple4_to_str(&outer_addr);
 	EXPECT_STREQ(inner_addr_str, "dead::beef 0 cafe::babe 0");
@@ -612,12 +607,11 @@ unsigned char data6[] = {
 	0x7e, 0x06, 0xc4, 0x42, 0x77, 0x28, 0x25, 0x41, 0x7b, 0x7d, 0x1d, 0xfa, 0xf1, 0x9d, 0x00, 0x50, 0x65, 0xf5, 0x19, 0xd5, 0x00, 0x00, 0x00, 0x00, 0x80, 0x02,
 	0x20, 0x00, 0xa7, 0x77, 0x00, 0x00, 0x02, 0x04, 0x05, 0xb4, 0x01, 0x03, 0x03, 0x08, 0x01, 0x01, 0x04, 0x02};
 
-TEST(RAW_PACKET, ETH_MPLS_IP4_TCP)
+TEST(DATA_PACKET, ETH_MPLS_IP4_TCP)
 {
-	struct raw_pkt_parser handler;
-	raw_packet_parser_init(&handler, 0, LAYER_TYPE_ALL, 8);
+	struct data_packet handler;
 
-	const void *payload = raw_packet_parser_parse(&handler, (const void *)data6, sizeof(data6));
+	const void *payload = data_packet_parse(&handler, (const void *)data6, sizeof(data6), 0);
 	EXPECT_TRUE(payload != nullptr);
 	EXPECT_TRUE((char *)payload - (char *)&data6 == 70);
 
@@ -628,8 +622,8 @@ TEST(RAW_PACKET, ETH_MPLS_IP4_TCP)
 
 	memset(&inner_addr, 0, sizeof(inner_addr));
 	memset(&outer_addr, 0, sizeof(outer_addr));
-	EXPECT_TRUE(raw_packet_parser_get_most_inner_tuple4(&handler, &inner_addr) == 0);
-	EXPECT_TRUE(raw_packet_parser_get_most_outer_tuple4(&handler, &outer_addr) == 0);
+	EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0);
+	EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0);
 	inner_addr_str = addr_tuple4_to_str(&inner_addr);
 	outer_addr_str = addr_tuple4_to_str(&outer_addr);
 	EXPECT_STREQ(inner_addr_str, "119.40.37.65 61853 123.125.29.250 80");
@@ -639,8 +633,8 @@ TEST(RAW_PACKET, ETH_MPLS_IP4_TCP)
 
 	memset(&inner_addr, 0, sizeof(inner_addr));
 	memset(&outer_addr, 0, sizeof(outer_addr));
-	EXPECT_TRUE(raw_packet_parser_get_most_inner_address(&handler, &inner_addr) == 0);
-	EXPECT_TRUE(raw_packet_parser_get_most_outer_address(&handler, &outer_addr) == 0);
+	EXPECT_TRUE(data_packet_get_innermost_address(&handler, &inner_addr) == 0);
+	EXPECT_TRUE(data_packet_get_outermost_address(&handler, &outer_addr) == 0);
 	inner_addr_str = addr_tuple4_to_str(&inner_addr);
 	outer_addr_str = addr_tuple4_to_str(&outer_addr);
 	EXPECT_STREQ(inner_addr_str, "119.40.37.65 0 123.125.29.250 0");
@@ -710,12 +704,11 @@ unsigned char data7[] = {
 	0x00, 0x00, 0x00, 0x00, 0xff, 0x06, 0xa6, 0xd9, 0x0a, 0x1f, 0x00, 0x01, 0x0a, 0x22, 0x00, 0x01, 0x2a, 0xf9, 0x00, 0x17, 0xcf, 0x84, 0x85, 0x39, 0x00, 0x00,
 	0x00, 0x00, 0x60, 0x02, 0x10, 0x20, 0xf7, 0x91, 0x00, 0x00, 0x02, 0x04, 0x02, 0x18};
 
-TEST(RAW_PACKET, ETH_MPLS_MPLS_IP4_TCP)
+TEST(DATA_PACKET, ETH_MPLS_MPLS_IP4_TCP)
 {
-	struct raw_pkt_parser handler;
-	raw_packet_parser_init(&handler, 0, LAYER_TYPE_ALL, 8);
+	struct data_packet handler;
 
-	const void *payload = raw_packet_parser_parse(&handler, (const void *)data7, sizeof(data7));
+	const void *payload = data_packet_parse(&handler, (const void *)data7, sizeof(data7), 0);
 	EXPECT_TRUE(payload != nullptr);
 	EXPECT_TRUE((char *)payload - (char *)&data7 == 66);
 
@@ -726,8 +719,8 @@ TEST(RAW_PACKET, ETH_MPLS_MPLS_IP4_TCP)
 
 	memset(&inner_addr, 0, sizeof(inner_addr));
 	memset(&outer_addr, 0, sizeof(outer_addr));
-	EXPECT_TRUE(raw_packet_parser_get_most_inner_tuple4(&handler, &inner_addr) == 0);
-	EXPECT_TRUE(raw_packet_parser_get_most_outer_tuple4(&handler, &outer_addr) == 0);
+	EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0);
+	EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0);
 	inner_addr_str = addr_tuple4_to_str(&inner_addr);
 	outer_addr_str = addr_tuple4_to_str(&outer_addr);
 	EXPECT_STREQ(inner_addr_str, "10.31.0.1 11001 10.34.0.1 23");
@@ -737,8 +730,8 @@ TEST(RAW_PACKET, ETH_MPLS_MPLS_IP4_TCP)
 
 	memset(&inner_addr, 0, sizeof(inner_addr));
 	memset(&outer_addr, 0, sizeof(outer_addr));
-	EXPECT_TRUE(raw_packet_parser_get_most_inner_address(&handler, &inner_addr) == 0);
-	EXPECT_TRUE(raw_packet_parser_get_most_outer_address(&handler, &outer_addr) == 0);
+	EXPECT_TRUE(data_packet_get_innermost_address(&handler, &inner_addr) == 0);
+	EXPECT_TRUE(data_packet_get_outermost_address(&handler, &outer_addr) == 0);
 	inner_addr_str = addr_tuple4_to_str(&inner_addr);
 	outer_addr_str = addr_tuple4_to_str(&outer_addr);
 	EXPECT_STREQ(inner_addr_str, "10.31.0.1 0 10.34.0.1 0");
@@ -813,12 +806,11 @@ unsigned char data8[] = {
 	0x45, 0x00, 0x00, 0x34, 0x4b, 0xa7, 0x40, 0x00, 0x3f, 0x06, 0xeb, 0x01, 0x64, 0x41, 0x37, 0x00, 0x5b, 0xb9, 0x0e, 0x21, 0x86, 0xe4, 0x01, 0xbb, 0xb6, 0xa5,
 	0xda, 0x72, 0x7c, 0x31, 0xf8, 0x20, 0x80, 0x10, 0x0f, 0xc0, 0xc3, 0x61, 0x00, 0x00, 0x01, 0x01, 0x08, 0x0a, 0x00, 0x6f, 0xab, 0xdf, 0x9c, 0x61, 0xc7, 0xc5};
 
-TEST(RAW_PACKET, ETH_VLAN_PPPOE_IP4_TCP)
+TEST(DATA_PACKET, ETH_VLAN_PPPOE_IP4_TCP)
 {
-	struct raw_pkt_parser handler;
-	raw_packet_parser_init(&handler, 0, LAYER_TYPE_ALL, 8);
+	struct data_packet handler;
 
-	const void *payload = raw_packet_parser_parse(&handler, (const void *)data8, sizeof(data8));
+	const void *payload = data_packet_parse(&handler, (const void *)data8, sizeof(data8), 0);
 	EXPECT_TRUE(payload != nullptr);
 	EXPECT_TRUE((char *)payload - (char *)&data8 == 78);
 
@@ -829,8 +821,8 @@ TEST(RAW_PACKET, ETH_VLAN_PPPOE_IP4_TCP)
 
 	memset(&inner_addr, 0, sizeof(inner_addr));
 	memset(&outer_addr, 0, sizeof(outer_addr));
-	EXPECT_TRUE(raw_packet_parser_get_most_inner_tuple4(&handler, &inner_addr) == 0);
-	EXPECT_TRUE(raw_packet_parser_get_most_outer_tuple4(&handler, &outer_addr) == 0);
+	EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0);
+	EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0);
 	inner_addr_str = addr_tuple4_to_str(&inner_addr);
 	outer_addr_str = addr_tuple4_to_str(&outer_addr);
 	EXPECT_STREQ(inner_addr_str, "100.65.55.0 34532 91.185.14.33 443");
@@ -840,8 +832,8 @@ TEST(RAW_PACKET, ETH_VLAN_PPPOE_IP4_TCP)
 
 	memset(&inner_addr, 0, sizeof(inner_addr));
 	memset(&outer_addr, 0, sizeof(outer_addr));
-	EXPECT_TRUE(raw_packet_parser_get_most_inner_address(&handler, &inner_addr) == 0);
-	EXPECT_TRUE(raw_packet_parser_get_most_outer_address(&handler, &outer_addr) == 0);
+	EXPECT_TRUE(data_packet_get_innermost_address(&handler, &inner_addr) == 0);
+	EXPECT_TRUE(data_packet_get_outermost_address(&handler, &outer_addr) == 0);
 	inner_addr_str = addr_tuple4_to_str(&inner_addr);
 	outer_addr_str = addr_tuple4_to_str(&outer_addr);
 	EXPECT_STREQ(inner_addr_str, "100.65.55.0 0 91.185.14.33 0");
@@ -975,12 +967,11 @@ unsigned char data9[] = {
 	0xb7, 0x9d, 0xd4, 0x4f, 0xe3, 0xac, 0x64, 0xdb, 0x6f, 0x1d, 0xdf, 0xd8, 0x41, 0xd7, 0xd9, 0x50, 0x55, 0x30, 0xeb, 0x4b, 0x19, 0xce, 0x78, 0x1f, 0xa8, 0x1e,
 	0x87, 0x9c, 0x8f, 0x93, 0x97, 0xd4, 0xa2, 0x28, 0x2c, 0x79, 0x22, 0xc8};
 
-TEST(RAW_PACKET, ETH_IP6_UDP_GTP_IP6_TCP_TLS)
+TEST(DATA_PACKET, ETH_IP6_UDP_GTP_IP6_TCP_TLS)
 {
-	struct raw_pkt_parser handler;
-	raw_packet_parser_init(&handler, 0, LAYER_TYPE_ALL, 8);
+	struct data_packet handler;
 
-	const void *payload = raw_packet_parser_parse(&handler, (const void *)data9, sizeof(data9));
+	const void *payload = data_packet_parse(&handler, (const void *)data9, sizeof(data9), 0);
 	EXPECT_TRUE(payload != nullptr);
 	EXPECT_TRUE((char *)payload - (char *)&data9 == 130);
 
@@ -991,8 +982,8 @@ TEST(RAW_PACKET, ETH_IP6_UDP_GTP_IP6_TCP_TLS)
 
 	memset(&inner_addr, 0, sizeof(inner_addr));
 	memset(&outer_addr, 0, sizeof(outer_addr));
-	EXPECT_TRUE(raw_packet_parser_get_most_inner_tuple4(&handler, &inner_addr) == 0);
-	EXPECT_TRUE(raw_packet_parser_get_most_outer_tuple4(&handler, &outer_addr) == 0);
+	EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0);
+	EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0);
 	inner_addr_str = addr_tuple4_to_str(&inner_addr);
 	outer_addr_str = addr_tuple4_to_str(&outer_addr);
 	EXPECT_STREQ(inner_addr_str, "2409:8c34:4400:700:0:4:0:3 443 2409:8934:5082:2100:ecad:e0e4:530a:c269 46582");
@@ -1002,8 +993,8 @@ TEST(RAW_PACKET, ETH_IP6_UDP_GTP_IP6_TCP_TLS)
 
 	memset(&inner_addr, 0, sizeof(inner_addr));
 	memset(&outer_addr, 0, sizeof(outer_addr));
-	EXPECT_TRUE(raw_packet_parser_get_most_inner_address(&handler, &inner_addr) == 0);
-	EXPECT_TRUE(raw_packet_parser_get_most_outer_address(&handler, &outer_addr) == 0);
+	EXPECT_TRUE(data_packet_get_innermost_address(&handler, &inner_addr) == 0);
+	EXPECT_TRUE(data_packet_get_outermost_address(&handler, &outer_addr) == 0);
 	inner_addr_str = addr_tuple4_to_str(&inner_addr);
 	outer_addr_str = addr_tuple4_to_str(&outer_addr);
 	EXPECT_STREQ(inner_addr_str, "2409:8c34:4400:700:0:4:0:3 0 2409:8934:5082:2100:ecad:e0e4:530a:c269 0");
@@ -1144,12 +1135,11 @@ unsigned char data10[] = {
 	0x0b, 0x4b, 0x21, 0xa2, 0x52, 0x86, 0x95, 0x4e, 0x18, 0xac, 0xa2, 0xaf, 0x29, 0x5b, 0xe7, 0x05, 0xa1, 0xc8, 0xe1, 0x80, 0xfa, 0xb6, 0x5a, 0xed, 0x94, 0x32,
 	0x4f, 0xe9, 0xf5, 0xf0, 0x61, 0x5d, 0x7f, 0xc4, 0xc4, 0xd1, 0x05, 0x54, 0x13, 0xdb};
 
-TEST(RAW_PACKET, ETH_IP6_UDP_GTP_IP4_TCP_TLS)
+TEST(DATA_PACKET, ETH_IP6_UDP_GTP_IP4_TCP_TLS)
 {
-	struct raw_pkt_parser handler;
-	raw_packet_parser_init(&handler, 0, LAYER_TYPE_ALL, 8);
+	struct data_packet handler;
 
-	const void *payload = raw_packet_parser_parse(&handler, (const void *)data10, sizeof(data10));
+	const void *payload = data_packet_parse(&handler, (const void *)data10, sizeof(data10), 0);
 	EXPECT_TRUE(payload != nullptr);
 	EXPECT_TRUE((char *)payload - (char *)&data10 == 122);
 
@@ -1160,8 +1150,8 @@ TEST(RAW_PACKET, ETH_IP6_UDP_GTP_IP4_TCP_TLS)
 
 	memset(&inner_addr, 0, sizeof(inner_addr));
 	memset(&outer_addr, 0, sizeof(outer_addr));
-	EXPECT_TRUE(raw_packet_parser_get_most_inner_tuple4(&handler, &inner_addr) == 0);
-	EXPECT_TRUE(raw_packet_parser_get_most_outer_tuple4(&handler, &outer_addr) == 0);
+	EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0);
+	EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0);
 	inner_addr_str = addr_tuple4_to_str(&inner_addr);
 	outer_addr_str = addr_tuple4_to_str(&outer_addr);
 	EXPECT_STREQ(inner_addr_str, "10.49.115.138 50081 121.196.250.66 443");
@@ -1171,8 +1161,8 @@ TEST(RAW_PACKET, ETH_IP6_UDP_GTP_IP4_TCP_TLS)
 
 	memset(&inner_addr, 0, sizeof(inner_addr));
 	memset(&outer_addr, 0, sizeof(outer_addr));
-	EXPECT_TRUE(raw_packet_parser_get_most_inner_address(&handler, &inner_addr) == 0);
-	EXPECT_TRUE(raw_packet_parser_get_most_outer_address(&handler, &outer_addr) == 0);
+	EXPECT_TRUE(data_packet_get_innermost_address(&handler, &inner_addr) == 0);
+	EXPECT_TRUE(data_packet_get_outermost_address(&handler, &outer_addr) == 0);
 	inner_addr_str = addr_tuple4_to_str(&inner_addr);
 	outer_addr_str = addr_tuple4_to_str(&outer_addr);
 	EXPECT_STREQ(inner_addr_str, "10.49.115.138 0 121.196.250.66 0");
@@ -1255,12 +1245,11 @@ unsigned char data11[] = {
 	0x0b, 0xc1, 0x72, 0x72, 0x72, 0x72, 0xff, 0x0a, 0x00, 0x35, 0x00, 0x28, 0x39, 0xe4, 0x86, 0x84, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 	0x03, 0x77, 0x77, 0x77, 0x06, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x03, 0x63, 0x6f, 0x6d, 0x00, 0x00, 0x01, 0x00, 0x01};
 
-TEST(RAW_PACKET, ETH_IP4_UDP_VXLAN_ETH_IP4_UDP_DNS)
+TEST(DATA_PACKET, ETH_IP4_UDP_VXLAN_ETH_IP4_UDP_DNS)
 {
-	struct raw_pkt_parser handler;
-	raw_packet_parser_init(&handler, 0, LAYER_TYPE_ALL, 8);
+	struct data_packet handler;
 
-	const void *payload = raw_packet_parser_parse(&handler, (const void *)data11, sizeof(data11));
+	const void *payload = data_packet_parse(&handler, (const void *)data11, sizeof(data11), 0);
 	EXPECT_TRUE(payload != nullptr);
 	EXPECT_TRUE((char *)payload - (char *)&data11 == 92);
 
@@ -1271,8 +1260,8 @@ TEST(RAW_PACKET, ETH_IP4_UDP_VXLAN_ETH_IP4_UDP_DNS)
 
 	memset(&inner_addr, 0, sizeof(inner_addr));
 	memset(&outer_addr, 0, sizeof(outer_addr));
-	EXPECT_TRUE(raw_packet_parser_get_most_inner_tuple4(&handler, &inner_addr) == 0);
-	EXPECT_TRUE(raw_packet_parser_get_most_outer_tuple4(&handler, &outer_addr) == 0);
+	EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0);
+	EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0);
 	inner_addr_str = addr_tuple4_to_str(&inner_addr);
 	outer_addr_str = addr_tuple4_to_str(&outer_addr);
 	EXPECT_STREQ(inner_addr_str, "192.168.11.193 65290 114.114.114.114 53");
@@ -1282,8 +1271,8 @@ TEST(RAW_PACKET, ETH_IP4_UDP_VXLAN_ETH_IP4_UDP_DNS)
 
 	memset(&inner_addr, 0, sizeof(inner_addr));
 	memset(&outer_addr, 0, sizeof(outer_addr));
-	EXPECT_TRUE(raw_packet_parser_get_most_inner_address(&handler, &inner_addr) == 0);
-	EXPECT_TRUE(raw_packet_parser_get_most_outer_address(&handler, &outer_addr) == 0);
+	EXPECT_TRUE(data_packet_get_innermost_address(&handler, &inner_addr) == 0);
+	EXPECT_TRUE(data_packet_get_outermost_address(&handler, &outer_addr) == 0);
 	inner_addr_str = addr_tuple4_to_str(&inner_addr);
 	outer_addr_str = addr_tuple4_to_str(&outer_addr);
 	EXPECT_STREQ(inner_addr_str, "192.168.11.193 0 114.114.114.114 0");
@@ -1328,42 +1317,40 @@ unsigned char data12[] = {
 	0x68, 0x00, 0xc0, 0xa8, 0x00, 0x0a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0xa8, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
 
-TEST(RAW_PACKET, ETH_MPLS_MPLS_PWETHCW_ETH_ARP)
+TEST(DATA_PACKET, ETH_MPLS_MPLS_PWETHCW_ETH_ARP)
 {
-	struct raw_pkt_parser handler;
-	raw_packet_parser_init(&handler, 0, LAYER_TYPE_ALL, 8);
+	struct data_packet handler;
 
-	const void *payload = raw_packet_parser_parse(&handler, (const void *)data12, sizeof(data12));
+	const void *payload = data_packet_parse(&handler, (const void *)data12, sizeof(data12), 0);
 	EXPECT_TRUE(payload != nullptr);
 	EXPECT_TRUE((char *)payload - (char *)&data12 == 40);
 
 	struct addr_tuple4 inner_addr;
 	struct addr_tuple4 outer_addr;
 
-	EXPECT_TRUE(raw_packet_parser_get_most_inner_tuple4(&handler, &inner_addr) == -1);
-	EXPECT_TRUE(raw_packet_parser_get_most_outer_tuple4(&handler, &outer_addr) == -1);
+	EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == -1);
+	EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == -1);
 
-	EXPECT_TRUE(raw_packet_parser_get_most_inner_address(&handler, &inner_addr) == -1);
-	EXPECT_TRUE(raw_packet_parser_get_most_outer_address(&handler, &outer_addr) == -1);
+	EXPECT_TRUE(data_packet_get_innermost_address(&handler, &inner_addr) == -1);
+	EXPECT_TRUE(data_packet_get_outermost_address(&handler, &outer_addr) == -1);
 }
 
-TEST(RAW_PACKET, GET_HASH_VALUE)
+TEST(DATA_PACKET, GET_HASH_VALUE)
 {
-	struct raw_pkt_parser handler;
-	raw_packet_parser_init(&handler, 0, LAYER_TYPE_ALL, 8);
+	struct data_packet handler;
 
-	const void *payload = raw_packet_parser_parse(&handler, (const void *)data4, sizeof(data4));
+	const void *payload = data_packet_parse(&handler, (const void *)data4, sizeof(data4), 0);
 	EXPECT_TRUE(payload != nullptr);
 	EXPECT_TRUE((char *)payload - (char *)&data4 == 106);
 
 	// inner_addr_str: "2001:da8:200:900e:200:5efe:d24d:58a3 0 2600:140e:6::1702:1058 0"
 	// outer_addr_str: "210.77.88.163 0 59.66.4.50 0"
 
-	EXPECT_TRUE(raw_packet_parser_get_hash_value(&handler, LDBC_METHOD_HASH_INT_IP, 1) == raw_packet_parser_get_hash_value(&handler, LDBC_METHOD_HASH_EXT_IP, 0));
-	EXPECT_TRUE(raw_packet_parser_get_hash_value(&handler, LDBC_METHOD_HASH_EXT_IP, 1) == raw_packet_parser_get_hash_value(&handler, LDBC_METHOD_HASH_INT_IP, 0));
+	EXPECT_TRUE(data_packet_get_hash(&handler, LDBC_METHOD_HASH_INT_IP, 1) == data_packet_get_hash(&handler, LDBC_METHOD_HASH_EXT_IP, 0));
+	EXPECT_TRUE(data_packet_get_hash(&handler, LDBC_METHOD_HASH_EXT_IP, 1) == data_packet_get_hash(&handler, LDBC_METHOD_HASH_INT_IP, 0));
 
-	EXPECT_TRUE(raw_packet_parser_get_hash_value(&handler, LDBC_METHOD_HASH_INT_IP_AND_EXT_IP, 1) == raw_packet_parser_get_hash_value(&handler, LDBC_METHOD_HASH_INT_IP_AND_EXT_IP, 0));
-	EXPECT_TRUE(raw_packet_parser_get_hash_value(&handler, LDBC_METHOD_HASH_INNERMOST_INT_IP, 1) == raw_packet_parser_get_hash_value(&handler, LDBC_METHOD_HASH_INNERMOST_EXT_IP, 0));
+	EXPECT_TRUE(data_packet_get_hash(&handler, LDBC_METHOD_HASH_INT_IP_AND_EXT_IP, 1) == data_packet_get_hash(&handler, LDBC_METHOD_HASH_INT_IP_AND_EXT_IP, 0));
+	EXPECT_TRUE(data_packet_get_hash(&handler, LDBC_METHOD_HASH_INNERMOST_INT_IP, 1) == data_packet_get_hash(&handler, LDBC_METHOD_HASH_INNERMOST_EXT_IP, 0));
 }
 
 int main(int argc, char **argv)
diff --git a/common/test/gtest_utils.cpp b/common/test/gtest_utils.cpp
index a4d8c7c..624330e 100644
--- a/common/test/gtest_utils.cpp
+++ b/common/test/gtest_utils.cpp
@@ -4,36 +4,36 @@
 
 TEST(UTILS, FIXED_NUM_ARRAY)
 {
-	struct fixed_num_array array;
-	fixed_num_array_init(&array);
-
-	fixed_num_array_add_elem(&array, 1);
-	fixed_num_array_add_elem(&array, 2);
-	fixed_num_array_add_elem(&array, 3);
-	fixed_num_array_add_elem(&array, 1);
-	fixed_num_array_add_elem(&array, 2);
-
-	EXPECT_TRUE(fixed_num_array_count_elem(&array) == 5);
-	EXPECT_TRUE(fixed_num_array_index_elem(&array, 0) == 1);
-	EXPECT_TRUE(fixed_num_array_index_elem(&array, 1) == 2);
-	EXPECT_TRUE(fixed_num_array_index_elem(&array, 2) == 3);
-	EXPECT_TRUE(fixed_num_array_index_elem(&array, 3) == 1);
-	EXPECT_TRUE(fixed_num_array_index_elem(&array, 4) == 2);
-
-	fixed_num_array_del_elem(&array, 3); // 1,2,1,2
-	EXPECT_TRUE(fixed_num_array_count_elem(&array) == 4);
-	EXPECT_TRUE(fixed_num_array_index_elem(&array, 0) == 1);
-	EXPECT_TRUE(fixed_num_array_index_elem(&array, 1) == 2);
-	EXPECT_TRUE(fixed_num_array_index_elem(&array, 2) == 1);
-	EXPECT_TRUE(fixed_num_array_index_elem(&array, 3) == 2);
-
-	fixed_num_array_del_elem(&array, 2); // 1,1
-	EXPECT_TRUE(fixed_num_array_count_elem(&array) == 2);
-	EXPECT_TRUE(fixed_num_array_index_elem(&array, 0) == 1);
-	EXPECT_TRUE(fixed_num_array_index_elem(&array, 1) == 1);
-
-	fixed_num_array_del_elem(&array, 1);
-	EXPECT_TRUE(fixed_num_array_count_elem(&array) == 0);
+	struct mutable_array array;
+	mutable_array_init(&array);
+
+	mutable_array_add_elem(&array, 1);
+	mutable_array_add_elem(&array, 2);
+	mutable_array_add_elem(&array, 3);
+	mutable_array_add_elem(&array, 1);
+	mutable_array_add_elem(&array, 2);
+
+	EXPECT_TRUE(mutable_array_count_elem(&array) == 5);
+	EXPECT_TRUE(mutable_array_index_elem(&array, 0) == 1);
+	EXPECT_TRUE(mutable_array_index_elem(&array, 1) == 2);
+	EXPECT_TRUE(mutable_array_index_elem(&array, 2) == 3);
+	EXPECT_TRUE(mutable_array_index_elem(&array, 3) == 1);
+	EXPECT_TRUE(mutable_array_index_elem(&array, 4) == 2);
+
+	mutable_array_del_elem(&array, 3); // 1,2,1,2
+	EXPECT_TRUE(mutable_array_count_elem(&array) == 4);
+	EXPECT_TRUE(mutable_array_index_elem(&array, 0) == 1);
+	EXPECT_TRUE(mutable_array_index_elem(&array, 1) == 2);
+	EXPECT_TRUE(mutable_array_index_elem(&array, 2) == 1);
+	EXPECT_TRUE(mutable_array_index_elem(&array, 3) == 2);
+
+	mutable_array_del_elem(&array, 2); // 1,1
+	EXPECT_TRUE(mutable_array_count_elem(&array) == 2);
+	EXPECT_TRUE(mutable_array_index_elem(&array, 0) == 1);
+	EXPECT_TRUE(mutable_array_index_elem(&array, 1) == 1);
+
+	mutable_array_del_elem(&array, 1);
+	EXPECT_TRUE(mutable_array_count_elem(&array) == 0);
 }
 
 TEST(UTILS, SIDS)