perf: 优化data packet的解析v1.2.1-20231108

3 files changed, 133 insertions, 149 deletions

diff --git a/common/include/data_packet.h b/common/include/data_packet.h
index e902b5e..85b64c2 100644
--- a/common/include/data_packet.h
+++ b/common/include/data_packet.h
@@ -60,28 +60,23 @@ struct layer_result
     enum layer_type type;
 };
 
-struct layer_results
+struct data_packet
 {
     struct layer_result layers[16];
     uint16_t layers_used;
     uint16_t layers_size;
-};
-
-struct data_packet
-{
-    struct layer_results results;
 
     const void *data_ptr;
     uint64_t trace_id;
 };
 
-// return most inner payload
+// return innermost payload
 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 data_packet_get_innermost_tuple4(struct data_packet *handler, struct four_tuple *addr);
-int data_packet_get_outermost_tuple4(struct data_packet *handler, struct four_tuple *addr);
+int data_packet_get_innermost_four_tuple(struct data_packet *handler, struct four_tuple *addr);
+int data_packet_get_outermost_four_tuple(struct data_packet *handler, struct four_tuple *addr);
 
 // return  0 : success
 // return -1 : error
diff --git a/common/src/data_packet.cpp b/common/src/data_packet.cpp
index 1142e25..5d19cff 100644
--- a/common/src/data_packet.cpp
+++ b/common/src/data_packet.cpp
@@ -60,16 +60,13 @@ struct gtp_hdr
  * Static API
  ******************************************************************************/
 
-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);
-
-// parser utils
-static void set_addr_tuple4(const void *data, enum layer_type layer_type, struct four_tuple *addr);
-static const char *layer_type2str(enum layer_type this_type);
-static uint16_t parse_gtphdr_len(const struct gtp_hdr *gtph);
+static const char *layer_type_to_string(enum layer_type this_type);
+static int data_packet_push_layer(struct data_packet *handler, enum layer_type type, uint16_t offset);
+static void populate_four_tuple_from_layer(const void *data, enum layer_type layer_type, struct four_tuple *addr);
 
 // parser protocol
+static uint16_t parse_gtphdr_len(const struct gtp_hdr *gtph);
 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);
@@ -85,13 +82,13 @@ static const void *parse_mpls(struct data_packet *handler, const void *data, siz
  * Public API
  ******************************************************************************/
 
-// return most inner payload
+// return innermost 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 data_packet));
 
-    handler->results.layers_used = 0;
-    handler->results.layers_size = sizeof(handler->results.layers) / sizeof(handler->results.layers[0]);
+    handler->layers_used = 0;
+    handler->layers_size = sizeof(handler->layers) / sizeof(handler->layers[0]);
     handler->data_ptr = data;
     handler->trace_id = trace_id;
 
@@ -101,21 +98,20 @@ const void *data_packet_parse(struct data_packet *handler, const void *data, siz
 
 // return  0 : success
 // return -1 : error
-int data_packet_get_innermost_tuple4(struct data_packet *handler, struct four_tuple *addr)
+int data_packet_get_innermost_four_tuple(struct data_packet *handler, struct four_tuple *addr)
 {
     const char *l3_layer_data = NULL;
     const char *l4_layer_data = NULL;
     const struct layer_result *l3_layer_result = NULL;
     const struct layer_result *l4_layer_result = NULL;
-    struct layer_results *results = &handler->results;
 
     // search L4 layer and L3 layer in reverse order
-    for (int8_t i = results->layers_used - 1; i >= 0; i--)
+    for (int8_t i = handler->layers_used - 1; i >= 0; i--)
     {
-        const struct layer_result *layer = &results->layers[i];
+        const struct layer_result *layer = &handler->layers[i];
         enum layer_type type = layer->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));
+        LOG_DEBUG("%s: find innermost tuple4, trace_id: %lu, layer[%d/%d]: %s", LOG_TAG_RAWPKT, handler->trace_id, i, handler->layers_size, layer_type_to_string(type));
 
         // first get L4 layer
         if (type & LAYER_TYPE_L4)
@@ -135,13 +131,13 @@ int data_packet_get_innermost_tuple4(struct data_packet *handler, struct four_tu
     if (l3_layer_result)
     {
         l3_layer_data = (const char *)handler->data_ptr + l3_layer_result->offset;
-        set_addr_tuple4(l3_layer_data, l3_layer_result->type, addr);
+        populate_four_tuple_from_layer(l3_layer_data, l3_layer_result->type, addr);
     }
 
     if (l4_layer_result)
     {
         l4_layer_data = (const char *)handler->data_ptr + l4_layer_result->offset;
-        set_addr_tuple4(l4_layer_data, l4_layer_result->type, addr);
+        populate_four_tuple_from_layer(l4_layer_data, l4_layer_result->type, addr);
     }
 
     if (l3_layer_result && l4_layer_result)
@@ -156,21 +152,20 @@ int data_packet_get_innermost_tuple4(struct data_packet *handler, struct four_tu
 
 // return  0 : success
 // return -1 : error
-int data_packet_get_outermost_tuple4(struct data_packet *handler, struct four_tuple *addr)
+int data_packet_get_outermost_four_tuple(struct data_packet *handler, struct four_tuple *addr)
 {
     const char *l3_layer_data = NULL;
     const char *l4_layer_data = NULL;
     const struct layer_result *l3_layer_result = NULL;
     const struct layer_result *l4_layer_result = NULL;
-    struct layer_results *results = &handler->results;
 
     // search L3 layer and L4 layer in order
-    for (int8_t i = 0; i <= results->layers_used - 1; i++)
+    for (int8_t i = 0; i <= handler->layers_used - 1; i++)
     {
-        const struct layer_result *layer = &results->layers[i];
+        const struct layer_result *layer = &handler->layers[i];
         enum layer_type type = layer->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));
+        LOG_DEBUG("%s: find outermost tuple4, trace_id: %lu, layer[%d/%d]: %s", LOG_TAG_RAWPKT, handler->trace_id, i, handler->layers_size, layer_type_to_string(type));
 
         // first get L3 layer
         if (type & LAYER_TYPE_L3)
@@ -190,13 +185,13 @@ int data_packet_get_outermost_tuple4(struct data_packet *handler, struct four_tu
     if (l3_layer_result)
     {
         l3_layer_data = (const char *)handler->data_ptr + l3_layer_result->offset;
-        set_addr_tuple4(l3_layer_data, l3_layer_result->type, addr);
+        populate_four_tuple_from_layer(l3_layer_data, l3_layer_result->type, addr);
     }
 
     if (l4_layer_result)
     {
         l4_layer_data = (const char *)handler->data_ptr + l4_layer_result->offset;
-        set_addr_tuple4(l4_layer_data, l4_layer_result->type, addr);
+        populate_four_tuple_from_layer(l4_layer_data, l4_layer_result->type, addr);
     }
 
     if (l3_layer_result && l4_layer_result)
@@ -214,19 +209,18 @@ int data_packet_get_outermost_tuple4(struct data_packet *handler, struct four_tu
 int data_packet_get_innermost_address(struct data_packet *handler, struct four_tuple *addr)
 {
     const char *l3_layer_data = NULL;
-    struct layer_results *results = &handler->results;
 
     // search L3 layer in reverse order
-    for (int8_t i = results->layers_used - 1; i >= 0; i--)
+    for (int8_t i = handler->layers_used - 1; i >= 0; i--)
     {
-        const struct layer_result *layer = &results->layers[i];
+        const struct layer_result *layer = &handler->layers[i];
         enum layer_type type = layer->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));
+        LOG_DEBUG("%s: find innermost address, trace_id: %lu, layer[%d/%d]: %s", LOG_TAG_RAWPKT, handler->trace_id, i, handler->layers_size, layer_type_to_string(type));
         if (type & LAYER_TYPE_L3)
         {
             l3_layer_data = (const char *)handler->data_ptr + layer->offset;
-            set_addr_tuple4(l3_layer_data, type, addr);
+            populate_four_tuple_from_layer(l3_layer_data, type, addr);
             return 0;
         }
     }
@@ -239,19 +233,18 @@ int data_packet_get_innermost_address(struct data_packet *handler, struct four_t
 int data_packet_get_outermost_address(struct data_packet *handler, struct four_tuple *addr)
 {
     const char *l3_layer_data = NULL;
-    struct layer_results *results = &handler->results;
 
     // search L3 layer in order
-    for (int8_t i = 0; i <= results->layers_used - 1; i++)
+    for (int8_t i = 0; i <= handler->layers_used - 1; i++)
     {
-        const struct layer_result *layer = &results->layers[i];
+        const struct layer_result *layer = &handler->layers[i];
         enum layer_type type = layer->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));
+        LOG_DEBUG("%s: find outermost address, trace_id: %lu, layer[%d/%d]: %s", LOG_TAG_RAWPKT, handler->trace_id, i, handler->layers_size, layer_type_to_string(type));
         if (type & LAYER_TYPE_L3)
         {
             l3_layer_data = (const char *)handler->data_ptr + layer->offset;
-            set_addr_tuple4(l3_layer_data, type, addr);
+            populate_four_tuple_from_layer(l3_layer_data, type, addr);
             return 0;
         }
     }
@@ -391,24 +384,6 @@ uint64_t data_packet_get_hash(struct data_packet *handler, enum ldbc_method meth
  * Private API
  ******************************************************************************/
 
-// return       0 : success
-// return -ENOMEM : error
-static int data_packet_push_layer(struct data_packet *handler, enum layer_type type, uint16_t offset)
-{
-    struct layer_results *result = &handler->results;
-
-    if (result->layers_used >= result->layers_size)
-    {
-        return -ENOMEM;
-    }
-
-    result->layers[result->layers_used].offset = offset;
-    result->layers[result->layers_used].type = type;
-    result->layers_used++;
-
-    return 0;
-}
-
 static const char *ldbc_method_to_string(enum ldbc_method ldbc_method)
 {
     switch (ldbc_method)
@@ -428,7 +403,54 @@ static const char *ldbc_method_to_string(enum ldbc_method ldbc_method)
     }
 }
 
-static void set_addr_tuple4(const void *data, enum layer_type layer_type, struct four_tuple *addr)
+static const char *layer_type_to_string(enum layer_type this_type)
+{
+    switch (this_type)
+    {
+    case LAYER_TYPE_ETHER:
+        return "ETHER";
+    case LAYER_TYPE_PPP:
+        return "PPP";
+    case LAYER_TYPE_HDLC:
+        return "HDLC";
+    case LAYER_TYPE_VLAN:
+        return "VLAN";
+    case LAYER_TYPE_PPPOE:
+        return "PPPOE";
+    case LAYER_TYPE_MPLS:
+        return "MPLS";
+    case LAYER_TYPE_IPV4:
+        return "IPV4";
+    case LAYER_TYPE_IPV6:
+        return "IPV6";
+    case LAYER_TYPE_UDP:
+        return "UDP";
+    case LAYER_TYPE_TCP:
+        return "TCP";
+    case LAYER_TYPE_G_VXLAN:
+        return "G_VXLAN";
+    case LAYER_TYPE_GTPV1_U:
+        return "GTPV1_U";
+    default:
+        return "UNKNOWN";
+    }
+}
+
+static int data_packet_push_layer(struct data_packet *handler, enum layer_type type, uint16_t offset)
+{
+    if (handler->layers_used >= handler->layers_size)
+    {
+        return -ENOMEM;
+    }
+
+    handler->layers[handler->layers_used].offset = offset;
+    handler->layers[handler->layers_used].type = type;
+    handler->layers_used++;
+
+    return 0;
+}
+
+static void populate_four_tuple_from_layer(const void *data, enum layer_type layer_type, struct four_tuple *addr)
 {
     const struct tcphdr *tcp_hdr = NULL;
     const struct udp_hdr *udp_hdr = NULL;
@@ -464,39 +486,6 @@ static void set_addr_tuple4(const void *data, enum layer_type layer_type, struct
     }
 }
 
-static const char *layer_type2str(enum layer_type this_type)
-{
-    switch (this_type)
-    {
-    case LAYER_TYPE_ETHER:
-        return "ETHER";
-    case LAYER_TYPE_PPP:
-        return "PPP";
-    case LAYER_TYPE_HDLC:
-        return "HDLC";
-    case LAYER_TYPE_VLAN:
-        return "VLAN";
-    case LAYER_TYPE_PPPOE:
-        return "PPPOE";
-    case LAYER_TYPE_MPLS:
-        return "MPLS";
-    case LAYER_TYPE_IPV4:
-        return "IPV4";
-    case LAYER_TYPE_IPV6:
-        return "IPV6";
-    case LAYER_TYPE_UDP:
-        return "UDP";
-    case LAYER_TYPE_TCP:
-        return "TCP";
-    case LAYER_TYPE_G_VXLAN:
-        return "G_VXLAN";
-    case LAYER_TYPE_GTPV1_U:
-        return "GTPV1_U";
-    default:
-        return "UNKNOWN";
-    }
-}
-
 // FROM SAPP
 static uint16_t parse_gtphdr_len(const struct gtp_hdr *gtph)
 {
@@ -550,7 +539,7 @@ static const void *parse_ether(struct data_packet *handler, const void *data, si
 {
     if (length < sizeof(struct ethhdr))
     {
-        LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_ETHER));
+        LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_ETHER));
         return data;
     }
 
@@ -566,7 +555,7 @@ static const void *parse_ether(struct data_packet *handler, const void *data, si
     const void *data_next_layer = (const char *)data + hdr_len;
     size_t data_next_length = length - hdr_len;
 
-    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);
+    LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_ETHER), data_next_length, length);
     switch (next_proto)
     {
     case ETH_P_8021Q:
@@ -586,7 +575,7 @@ static const void *parse_ether(struct data_packet *handler, const void *data, si
         // TESTED
         return parse_mpls(handler, data_next_layer, data_next_length);
     default:
-        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);
+        LOG_ERROR("%s: trace_id: %lu, %s, stop parse next protocol %d", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_ETHER), next_proto);
         return data_next_layer;
     }
 }
@@ -595,7 +584,7 @@ static const void *parse_ipv4(struct data_packet *handler, const void *data, siz
 {
     if (length < sizeof(struct ip))
     {
-        LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_IPV4));
+        LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_IPV4));
         return data;
     }
 
@@ -611,7 +600,7 @@ static const void *parse_ipv4(struct data_packet *handler, const void *data, siz
     const void *data_next_layer = (const char *)data + hdr_len;
     size_t data_next_length = length - hdr_len;
 
-    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);
+    LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_IPV4), data_next_length, length);
     switch (next_proto)
     {
     case IPPROTO_TCP:
@@ -627,7 +616,7 @@ static const void *parse_ipv4(struct data_packet *handler, const void *data, siz
         // TESTED
         return parse_ipv6(handler, data_next_layer, data_next_length);
     default:
-        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);
+        LOG_ERROR("%s: trace_id: %lu, %s, stop parse next protocol %d", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_IPV4), next_proto);
         return data_next_layer;
     }
 }
@@ -636,7 +625,7 @@ static const void *parse_ipv6(struct data_packet *handler, const void *data, siz
 {
     if (length < sizeof(struct ip6_hdr))
     {
-        LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_IPV6));
+        LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_IPV6));
         return data;
     }
 
@@ -652,7 +641,7 @@ static const void *parse_ipv6(struct data_packet *handler, const void *data, siz
     const void *data_next_layer = (const char *)data + hdr_len;
     size_t data_next_length = length - hdr_len;
 
-    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);
+    LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_IPV6), data_next_length, length);
     switch (next_proto)
     {
     case IPPROTO_TCP:
@@ -668,7 +657,7 @@ static const void *parse_ipv6(struct data_packet *handler, const void *data, siz
         // TESTED
         return parse_ipv6(handler, data_next_layer, data_next_length);
     default:
-        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);
+        LOG_ERROR("%s: trace_id: %lu, %s, stop parse next protocol %d", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_IPV6), next_proto);
         return data_next_layer;
     }
 }
@@ -677,7 +666,7 @@ static const void *parse_tcp(struct data_packet *handler, const void *data, size
 {
     if (length < sizeof(struct tcphdr))
     {
-        LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_TCP));
+        LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_TCP));
         return data;
     }
 
@@ -692,7 +681,7 @@ static const void *parse_tcp(struct data_packet *handler, const void *data, size
     const void *data_next_layer = (const char *)data + hdr_len;
     size_t data_next_length = length - hdr_len;
 
-    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);
+    LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_TCP), data_next_length, length);
 
     return data_next_layer;
 }
@@ -701,7 +690,7 @@ static const void *parse_udp(struct data_packet *handler, const void *data, size
 {
     if (length < sizeof(struct udp_hdr))
     {
-        LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_UDP));
+        LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_UDP));
         return data;
     }
 
@@ -716,7 +705,7 @@ static const void *parse_udp(struct data_packet *handler, const void *data, size
     const void *data_next_layer = (const char *)data + hdr_len;
     size_t data_next_length = length - hdr_len;
 
-    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);
+    LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_UDP), data_next_length, length);
     switch (ntohs(hdr->uh_dport))
     {
     // VXLAN_DPORT
@@ -736,7 +725,7 @@ static const void *parse_pppoe_ses(struct data_packet *handler, const void *data
 {
     if (length < 8)
     {
-        LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_PPPOE));
+        LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_PPPOE));
         return data;
     }
 
@@ -751,7 +740,7 @@ static const void *parse_pppoe_ses(struct data_packet *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: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_PPPOE), data_next_length, length);
+    LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_PPPOE), data_next_length, length);
     switch (next_proto)
     {
         // PPPOE_TYPE_IPV4
@@ -763,7 +752,7 @@ static const void *parse_pppoe_ses(struct data_packet *handler, const void *data
         // TODO
         return parse_ipv6(handler, data_next_layer, data_next_length);
     default:
-        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);
+        LOG_ERROR("%s: trace_id: %lu, %s, stop parse next protocol %d", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_PPPOE), next_proto);
         return data_next_layer;
     }
 }
@@ -772,7 +761,7 @@ static const void *parse_vxlan(struct data_packet *handler, const void *data, si
 {
     if (length < sizeof(struct vxlan_hdr))
     {
-        LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_G_VXLAN));
+        LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_G_VXLAN));
         return NULL;
     }
 
@@ -787,7 +776,7 @@ static const void *parse_vxlan(struct data_packet *handler, const void *data, si
     const void *data_next_layer = (const char *)data + hdr_len;
     size_t data_next_length = length - hdr_len;
 
-    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);
+    LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_G_VXLAN), data_next_length, length);
     // TESTED
     return parse_ether(handler, data_next_layer, data_next_length);
 }
@@ -796,7 +785,7 @@ static const void *parse_vlan8021q(struct data_packet *handler, const void *data
 {
     if (length < sizeof(struct vlan_hdr))
     {
-        LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_VLAN));
+        LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_VLAN));
         return NULL;
     }
 
@@ -812,7 +801,7 @@ static const void *parse_vlan8021q(struct data_packet *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: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_VLAN), data_next_length, length);
+    LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_VLAN), data_next_length, length);
     switch (next_proto)
     {
     case ETH_P_8021Q:
@@ -831,7 +820,7 @@ static const void *parse_vlan8021q(struct data_packet *handler, const void *data
         // TODO
         return parse_mpls(handler, data_next_layer, data_next_length);
     default:
-        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);
+        LOG_ERROR("%s: trace_id: %lu, %s, stop parse next protocol %d", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_VLAN), next_proto);
         return data_next_layer;
     }
 }
@@ -840,7 +829,7 @@ static const void *parse_gtpv1_u(struct data_packet *handler, const void *data,
 {
     if (length < sizeof(struct gtp_hdr))
     {
-        LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_GTPV1_U));
+        LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_GTPV1_U));
         return NULL;
     }
 
@@ -860,7 +849,7 @@ static const void *parse_gtpv1_u(struct data_packet *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: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_GTPV1_U), data_next_length, length);
+    LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_GTPV1_U), data_next_length, length);
     switch (next_proto)
     {
     case 4:
@@ -870,7 +859,7 @@ static const void *parse_gtpv1_u(struct data_packet *handler, const void *data,
         // TESTED
         return parse_ipv6(handler, data_next_layer, data_next_length);
     default:
-        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);
+        LOG_ERROR("%s: trace_id: %lu, %s, stop parse next protocol %d", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_GTPV1_U), next_proto);
         return data_next_layer;
     }
 }
@@ -879,7 +868,7 @@ static const void *parse_mpls(struct data_packet *handler, const void *data, siz
 {
     if (length < 4)
     {
-        LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_MPLS));
+        LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_MPLS));
         return data;
     }
 
@@ -934,32 +923,32 @@ static const void *parse_mpls(struct data_packet *handler, const void *data, siz
             data_next_layer = (const char *)data_next_layer + 4;
             data_next_length = data_next_length - 4;
 
-            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);
+            LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_MPLS), data_next_length, length);
             // TESTED
             return parse_ether(handler, data_next_layer, data_next_length);
         }
         else if (ip_version == 4)
         {
-            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);
+            LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_MPLS), data_next_length, length);
             // TESTED
             return parse_ipv4(handler, data_next_layer, data_next_length);
         }
         else if (ip_version == 6)
         {
-            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);
+            LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_MPLS), data_next_length, length);
             // TODO
             return parse_ipv6(handler, data_next_layer, data_next_length);
         }
         else
         {
-            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);
+            LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_MPLS), data_next_length, length);
             // TODO
             return parse_ether(handler, data_next_layer, data_next_length);
         }
     }
     else
     {
-        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);
+        LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_MPLS), data_next_length, length);
         // TESTED
         return parse_mpls(handler, data_next_layer, data_next_length);
     }
diff --git a/common/test/gtest_data_packet.cpp b/common/test/gtest_data_packet.cpp
index bd34c57..133b357 100644
--- a/common/test/gtest_data_packet.cpp
+++ b/common/test/gtest_data_packet.cpp
@@ -90,8 +90,8 @@ TEST(DATA_PACKET, ETH_VLAN_VLAN_IP4_IP4_UDP)
 
 	memset(&inner_addr, 0, sizeof(inner_addr));
 	memset(&outer_addr, 0, sizeof(outer_addr));
-	EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0);
-	EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0);
+	EXPECT_TRUE(data_packet_get_innermost_four_tuple(&handler, &inner_addr) == 0);
+	EXPECT_TRUE(data_packet_get_outermost_four_tuple(&handler, &outer_addr) == 0);
 	inner_addr_str = four_tuple_to_string(&inner_addr);
 	outer_addr_str = four_tuple_to_string(&outer_addr);
 	EXPECT_STREQ(inner_addr_str, "10.10.100.25 62367 10.10.101.2 17000");
@@ -220,8 +220,8 @@ TEST(DATA_PACKET, ETH_IP6_IP4_TCP_SSH)
 
 	memset(&inner_addr, 0, sizeof(inner_addr));
 	memset(&outer_addr, 0, sizeof(outer_addr));
-	EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0);
-	EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0);
+	EXPECT_TRUE(data_packet_get_innermost_four_tuple(&handler, &inner_addr) == 0);
+	EXPECT_TRUE(data_packet_get_outermost_four_tuple(&handler, &outer_addr) == 0);
 	inner_addr_str = four_tuple_to_string(&inner_addr);
 	outer_addr_str = four_tuple_to_string(&outer_addr);
 	EXPECT_STREQ(inner_addr_str, "1.1.1.1 57639 2.2.2.2 22");
@@ -345,8 +345,8 @@ TEST(DATA_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(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0);
-	EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0);
+	EXPECT_TRUE(data_packet_get_innermost_four_tuple(&handler, &inner_addr) == 0);
+	EXPECT_TRUE(data_packet_get_outermost_four_tuple(&handler, &outer_addr) == 0);
 	inner_addr_str = four_tuple_to_string(&inner_addr);
 	outer_addr_str = four_tuple_to_string(&outer_addr);
 	EXPECT_STREQ(inner_addr_str, "8.8.8.8 53 172.16.44.3 9879");
@@ -445,8 +445,8 @@ TEST(DATA_PACKET, ETH_IP4_IP6_TCP)
 
 	memset(&inner_addr, 0, sizeof(inner_addr));
 	memset(&outer_addr, 0, sizeof(outer_addr));
-	EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0);
-	EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0);
+	EXPECT_TRUE(data_packet_get_innermost_four_tuple(&handler, &inner_addr) == 0);
+	EXPECT_TRUE(data_packet_get_outermost_four_tuple(&handler, &outer_addr) == 0);
 	inner_addr_str = four_tuple_to_string(&inner_addr);
 	outer_addr_str = four_tuple_to_string(&outer_addr);
 	EXPECT_STREQ(inner_addr_str, "2001:da8:200:900e:200:5efe:d24d:58a3 52556 2600:140e:6::1702:1058 80");
@@ -530,8 +530,8 @@ TEST(DATA_PACKET, ETH_IP6_IP6_UDP)
 
 	memset(&inner_addr, 0, sizeof(inner_addr));
 	memset(&outer_addr, 0, sizeof(outer_addr));
-	EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0);
-	EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0);
+	EXPECT_TRUE(data_packet_get_innermost_four_tuple(&handler, &inner_addr) == 0);
+	EXPECT_TRUE(data_packet_get_outermost_four_tuple(&handler, &outer_addr) == 0);
 	inner_addr_str = four_tuple_to_string(&inner_addr);
 	outer_addr_str = four_tuple_to_string(&outer_addr);
 	EXPECT_STREQ(inner_addr_str, "dead::beef 30000 cafe::babe 13000");
@@ -622,8 +622,8 @@ TEST(DATA_PACKET, ETH_MPLS_IP4_TCP)
 
 	memset(&inner_addr, 0, sizeof(inner_addr));
 	memset(&outer_addr, 0, sizeof(outer_addr));
-	EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0);
-	EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0);
+	EXPECT_TRUE(data_packet_get_innermost_four_tuple(&handler, &inner_addr) == 0);
+	EXPECT_TRUE(data_packet_get_outermost_four_tuple(&handler, &outer_addr) == 0);
 	inner_addr_str = four_tuple_to_string(&inner_addr);
 	outer_addr_str = four_tuple_to_string(&outer_addr);
 	EXPECT_STREQ(inner_addr_str, "119.40.37.65 61853 123.125.29.250 80");
@@ -719,8 +719,8 @@ TEST(DATA_PACKET, ETH_MPLS_MPLS_IP4_TCP)
 
 	memset(&inner_addr, 0, sizeof(inner_addr));
 	memset(&outer_addr, 0, sizeof(outer_addr));
-	EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0);
-	EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0);
+	EXPECT_TRUE(data_packet_get_innermost_four_tuple(&handler, &inner_addr) == 0);
+	EXPECT_TRUE(data_packet_get_outermost_four_tuple(&handler, &outer_addr) == 0);
 	inner_addr_str = four_tuple_to_string(&inner_addr);
 	outer_addr_str = four_tuple_to_string(&outer_addr);
 	EXPECT_STREQ(inner_addr_str, "10.31.0.1 11001 10.34.0.1 23");
@@ -821,8 +821,8 @@ TEST(DATA_PACKET, ETH_VLAN_PPPOE_IP4_TCP)
 
 	memset(&inner_addr, 0, sizeof(inner_addr));
 	memset(&outer_addr, 0, sizeof(outer_addr));
-	EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0);
-	EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0);
+	EXPECT_TRUE(data_packet_get_innermost_four_tuple(&handler, &inner_addr) == 0);
+	EXPECT_TRUE(data_packet_get_outermost_four_tuple(&handler, &outer_addr) == 0);
 	inner_addr_str = four_tuple_to_string(&inner_addr);
 	outer_addr_str = four_tuple_to_string(&outer_addr);
 	EXPECT_STREQ(inner_addr_str, "100.65.55.0 34532 91.185.14.33 443");
@@ -982,8 +982,8 @@ TEST(DATA_PACKET, ETH_IP6_UDP_GTP_IP6_TCP_TLS)
 
 	memset(&inner_addr, 0, sizeof(inner_addr));
 	memset(&outer_addr, 0, sizeof(outer_addr));
-	EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0);
-	EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0);
+	EXPECT_TRUE(data_packet_get_innermost_four_tuple(&handler, &inner_addr) == 0);
+	EXPECT_TRUE(data_packet_get_outermost_four_tuple(&handler, &outer_addr) == 0);
 	inner_addr_str = four_tuple_to_string(&inner_addr);
 	outer_addr_str = four_tuple_to_string(&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");
@@ -1150,8 +1150,8 @@ TEST(DATA_PACKET, ETH_IP6_UDP_GTP_IP4_TCP_TLS)
 
 	memset(&inner_addr, 0, sizeof(inner_addr));
 	memset(&outer_addr, 0, sizeof(outer_addr));
-	EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0);
-	EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0);
+	EXPECT_TRUE(data_packet_get_innermost_four_tuple(&handler, &inner_addr) == 0);
+	EXPECT_TRUE(data_packet_get_outermost_four_tuple(&handler, &outer_addr) == 0);
 	inner_addr_str = four_tuple_to_string(&inner_addr);
 	outer_addr_str = four_tuple_to_string(&outer_addr);
 	EXPECT_STREQ(inner_addr_str, "10.49.115.138 50081 121.196.250.66 443");
@@ -1260,8 +1260,8 @@ TEST(DATA_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(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0);
-	EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0);
+	EXPECT_TRUE(data_packet_get_innermost_four_tuple(&handler, &inner_addr) == 0);
+	EXPECT_TRUE(data_packet_get_outermost_four_tuple(&handler, &outer_addr) == 0);
 	inner_addr_str = four_tuple_to_string(&inner_addr);
 	outer_addr_str = four_tuple_to_string(&outer_addr);
 	EXPECT_STREQ(inner_addr_str, "192.168.11.193 65290 114.114.114.114 53");
@@ -1328,8 +1328,8 @@ TEST(DATA_PACKET, ETH_MPLS_MPLS_PWETHCW_ETH_ARP)
 	struct four_tuple inner_addr;
 	struct four_tuple outer_addr;
 
-	EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == -1);
-	EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == -1);
+	EXPECT_TRUE(data_packet_get_innermost_four_tuple(&handler, &inner_addr) == -1);
+	EXPECT_TRUE(data_packet_get_outermost_four_tuple(&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);