TSG-13630 tsg-service-chaining-engine使用mrzcpd捕获报文/回注报文

TSG-13685 tsg-service-chaining-engine使用VXLAN封装Steering/Mirroring的Package
2023-02-10 14:22:40 +08:00
parent 158e4e89e8
commit 737ca3d4be
23 changed files with 2397 additions and 358 deletions
--- a/common/src/raw_packet.cpp
+++ b/common/src/raw_packet.cpp
@@ -12,16 +12,21 @@
 #include <linux/ppp_defs.h>

 #include "log.h"
+#include "utils.h"
 #include "uthash.h"
 #include "addr_tuple4.h"
 #include "raw_packet.h"

-#define LOG_TAG "RAW_PACKET_PARSER"
-
 /******************************************************************************
- * Protocol Struct
+ * Struct
 ******************************************************************************/

+enum parse_status
+{
+    PARSE_STATUS_CONTINUE,
+    PARSE_STATUS_STOP
+};
+
 struct vlan_hdr
 {
    uint16_t vlan_cfi;
@@ -58,38 +63,13 @@ struct gtp_hdr
 #define GTP_HDR_FLAG_SEQ_NUM (0x02)
 #define GTP_HDR_FLAG_NEXT_EXT_HDR (0x04)

-/******************************************************************************
- * Parser Struct
- ******************************************************************************/
-
-static uint64_t packet_trace_id = 0;
-
-struct layer_result
-{
-    uint16_t offset;
-    enum layer_type type;
-};
-
-struct layer_result_array
-{
-    struct layer_result *layers;
-    uint16_t layers_used;
-    uint16_t layers_size;
-};
-
-struct raw_pkt_parser
-{
-    enum layer_type expect_type;
-    struct layer_result_array results;
-
-    const void *ptr_pkt_start;
-    uint64_t pkt_trace_id;
-};
-
 /******************************************************************************
 * 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 const char *ldbc_method_to_string(enum ldbc_method ldbc_method);

 // parser utils
@@ -115,82 +95,21 @@ static const void *parse_mpls(struct raw_pkt_parser *handler, const void *data,
 * Public API
 ******************************************************************************/

-struct raw_pkt_parser *raw_packet_parser_create(enum layer_type expect_type, uint16_t expect_results_num)
+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)
 {
-    struct raw_pkt_parser *handler = (struct raw_pkt_parser *)calloc(1, sizeof(struct raw_pkt_parser));
-    assert(handler);
+    memset(handler, 0, sizeof(struct raw_pkt_parser));

    handler->expect_type = expect_type;
-    handler->results.layers = (struct layer_result *)calloc(expect_results_num, sizeof(struct layer_result));
-    assert(handler->results.layers);
    handler->results.layers_used = 0;
-    handler->results.layers_size = expect_results_num;
-
-    return handler;
-}
-
-void raw_packet_parser_destory(struct raw_pkt_parser *handler)
-{
-    if (handler)
-    {
-        if (handler->results.layers)
-        {
-            free(handler->results.layers);
-            handler->results.layers = NULL;
-        }
-
-        free(handler);
-        handler = NULL;
-    }
-}
-
-// return       0 : success
-// return -ENOMEM : error
-int raw_packet_parser_push(struct raw_pkt_parser *handler, enum layer_type type, uint16_t offset)
-{
-    struct layer_result_array *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;
-}
-
-// return PARSE_STATUS_CONTINUE
-// return PARSE_STATUS_STOP
-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;
-    }
+    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->pkt_trace_id = __atomic_fetch_add(&packet_trace_id, 1, __ATOMIC_RELAXED);

    // TESTED
    return parse_ether(handler, data, length, LAYER_TYPE_ETHER);
@@ -204,7 +123,7 @@ int raw_packet_parser_get_most_inner_tuple4(struct raw_pkt_parser *handler, stru
    const char *l4_layer_data = NULL;
    const struct layer_result *l3_layer_result = NULL;
    const struct layer_result *l4_layer_result = NULL;
-    struct layer_result_array *results = &handler->results;
+    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--)
@@ -212,7 +131,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, handler->pkt_trace_id, i, results->layers_size, layer_type2str(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));

        // first get L4 layer
        if (type & LAYER_TYPE_L4)
@@ -259,7 +178,7 @@ int raw_packet_parser_get_most_outer_tuple4(struct raw_pkt_parser *handler, stru
    const char *l4_layer_data = NULL;
    const struct layer_result *l3_layer_result = NULL;
    const struct layer_result *l4_layer_result = NULL;
-    struct layer_result_array *results = &handler->results;
+    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++)
@@ -267,7 +186,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, handler->pkt_trace_id, i, results->layers_size, layer_type2str(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));

        // first get L3 layer
        if (type & LAYER_TYPE_L3)
@@ -311,7 +230,7 @@ int raw_packet_parser_get_most_outer_tuple4(struct raw_pkt_parser *handler, stru
 int raw_packet_parser_get_most_inner_address(struct raw_pkt_parser *handler, struct addr_tuple4 *addr)
 {
    const char *l3_layer_data = NULL;
-    struct layer_result_array *results = &handler->results;
+    struct layer_results *results = &handler->results;

    // search L3 layer in reverse order
    for (int8_t i = results->layers_used - 1; i >= 0; i--)
@@ -319,7 +238,7 @@ 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, handler->pkt_trace_id, i, results->layers_size, layer_type2str(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));
        if (type & LAYER_TYPE_L3)
        {
            l3_layer_data = (const char *)handler->ptr_pkt_start + layer->offset;
@@ -336,7 +255,7 @@ int raw_packet_parser_get_most_inner_address(struct raw_pkt_parser *handler, str
 int raw_packet_parser_get_most_outer_address(struct raw_pkt_parser *handler, struct addr_tuple4 *addr)
 {
    const char *l3_layer_data = NULL;
-    struct layer_result_array *results = &handler->results;
+    struct layer_results *results = &handler->results;

    // search L3 layer in order
    for (int8_t i = 0; i <= results->layers_used - 1; i++)
@@ -344,7 +263,7 @@ 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, handler->pkt_trace_id, i, results->layers_size, layer_type2str(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));
        if (type & LAYER_TYPE_L3)
        {
            l3_layer_data = (const char *)handler->ptr_pkt_start + layer->offset;
@@ -477,7 +396,7 @@ 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_ERROR("%s: pkt_trace_id: %lu, outer_addr: %s, inner_addr: %s, is_internal: %d, hash_method: %s, hash_value: %lu",
-              LOG_TAG, handler->pkt_trace_id, outer_addr_str, inner_addr_str, dir_is_internal, ldbc_method_to_string(method), hash_value);
+              LOG_TAG_RAWPKT, handler->pkt_trace_id, outer_addr_str, inner_addr_str, dir_is_internal, ldbc_method_to_string(method), hash_value);
    free(inner_addr_str);
    free(outer_addr_str);

@@ -488,6 +407,48 @@ uint64_t raw_packet_parser_get_hash_value(struct raw_pkt_parser *handler, enum l
 * Private API
 ******************************************************************************/

+// return       0 : success
+// return -ENOMEM : error
+static int raw_packet_parser_push(struct raw_pkt_parser *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;
+}
+
+// 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)
@@ -629,7 +590,7 @@ static const void *parse_ether(struct raw_pkt_parser *handler, const void *data,
 {
    if (length < sizeof(struct ethhdr))
    {
-        LOG_ERROR("%s: pkt_trace_id: %lu, this_layer: %s, err: data not enough", LOG_TAG, handler->pkt_trace_id, layer_type2str(this_type));
+        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));
        return data;
    }

@@ -644,7 +605,7 @@ 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, handler->pkt_trace_id, layer_type2str(this_type), data_next_length, length);
+    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);
    switch (next_proto)
    {
    case ETH_P_8021Q:
@@ -666,7 +627,7 @@ static const void *parse_ether(struct raw_pkt_parser *handler, const void *data,
        // TESTED
        return parse_mpls(handler, data_next_layer, data_next_length, LAYER_TYPE_MPLS);
    default:
-        LOG_ERROR("%s: pkt_trace_id: %lu, this_layer: %s, stop parse next protocol %d", LOG_TAG, handler->pkt_trace_id, layer_type2str(this_type), next_proto);
+        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);
        return data_next_layer;
    }
 }
@@ -675,7 +636,7 @@ static const void *parse_ipv4(struct raw_pkt_parser *handler, const void *data,
 {
    if (length < sizeof(struct ip))
    {
-        LOG_ERROR("%s: pkt_trace_id: %lu, this_layer: %s, err: data not enough", LOG_TAG, handler->pkt_trace_id, layer_type2str(this_type));
+        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));
        return data;
    }

@@ -690,7 +651,7 @@ 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, handler->pkt_trace_id, layer_type2str(this_type), data_next_length, length);
+    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);
    switch (next_proto)
    {
    case IPPROTO_TCP:
@@ -706,7 +667,7 @@ static const void *parse_ipv4(struct raw_pkt_parser *handler, const void *data,
        // TESTED
        return parse_ipv6(handler, data_next_layer, data_next_length, LAYER_TYPE_IPV6);
    default:
-        LOG_ERROR("%s: pkt_trace_id: %lu, this_layer: %s, stop parse next protocol %d", LOG_TAG, handler->pkt_trace_id, layer_type2str(this_type), next_proto);
+        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);
        return data_next_layer;
    }
 }
@@ -715,7 +676,7 @@ static const void *parse_ipv6(struct raw_pkt_parser *handler, const void *data,
 {
    if (length < sizeof(struct ip6_hdr))
    {
-        LOG_ERROR("%s: pkt_trace_id: %lu, this_layer: %s, err: data not enough", LOG_TAG, handler->pkt_trace_id, layer_type2str(this_type));
+        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));
        return data;
    }

@@ -730,7 +691,7 @@ 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, handler->pkt_trace_id, layer_type2str(this_type), data_next_length, length);
+    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);
    switch (next_proto)
    {
    case IPPROTO_TCP:
@@ -746,7 +707,7 @@ static const void *parse_ipv6(struct raw_pkt_parser *handler, const void *data,
        // TESTED
        return parse_ipv6(handler, data_next_layer, data_next_length, LAYER_TYPE_IPV6);
    default:
-        LOG_ERROR("%s: pkt_trace_id: %lu, this_layer: %s, stop parse next protocol %d", LOG_TAG, handler->pkt_trace_id, layer_type2str(this_type), next_proto);
+        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);
        return data_next_layer;
    }
 }
@@ -755,7 +716,7 @@ static const void *parse_tcp(struct raw_pkt_parser *handler, const void *data, s
 {
    if (length < sizeof(struct tcphdr))
    {
-        LOG_ERROR("%s: pkt_trace_id: %lu, this_layer: %s, err: data not enough", LOG_TAG, handler->pkt_trace_id, layer_type2str(this_type));
+        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));
        return data;
    }

@@ -769,7 +730,7 @@ 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, handler->pkt_trace_id, layer_type2str(this_type), data_next_length, length);
+    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);

    return data_next_layer;
 }
@@ -778,7 +739,7 @@ static const void *parse_udp(struct raw_pkt_parser *handler, const void *data, s
 {
    if (length < sizeof(struct udphdr))
    {
-        LOG_ERROR("%s: pkt_trace_id: %lu, this_layer: %s, err: data not enough", LOG_TAG, handler->pkt_trace_id, layer_type2str(this_type));
+        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));
        return data;
    }

@@ -792,7 +753,7 @@ 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, handler->pkt_trace_id, layer_type2str(this_type), data_next_length, length);
+    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);
    switch (ntohs(hdr->uh_dport))
    {
    // VXLAN_DPORT
@@ -812,7 +773,7 @@ static const void *parse_ppp(struct raw_pkt_parser *handler, const void *data, s
 {
    if (length < PPP_HDRLEN)
    {
-        LOG_ERROR("%s: pkt_trace_id: %lu, this_layer: %s, err: data not enough", LOG_TAG, handler->pkt_trace_id, layer_type2str(this_type));
+        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));
        return data;
    }

@@ -826,7 +787,7 @@ static const void *parse_ppp(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, handler->pkt_trace_id, layer_type2str(this_type), data_next_length, length);
+    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);
    switch (next_proto)
    {
    case PPP_IP:
@@ -836,7 +797,7 @@ static const void *parse_ppp(struct raw_pkt_parser *handler, const void *data, s
        // TODO
        return parse_ipv6(handler, data_next_layer, data_next_length, LAYER_TYPE_IPV6);
    default:
-        LOG_ERROR("%s: pkt_trace_id: %lu, this_layer: %s, stop parse next protocol %d", LOG_TAG, handler->pkt_trace_id, layer_type2str(this_type), next_proto);
+        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);
        return data_next_layer;
    }
 }
@@ -845,7 +806,7 @@ static const void *parse_pppoe_ses(struct raw_pkt_parser *handler, const void *d
 {
    if (length < 8)
    {
-        LOG_ERROR("%s: pkt_trace_id: %lu, this_layer: %s, err: data not enough", LOG_TAG, handler->pkt_trace_id, layer_type2str(this_type));
+        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));
        return data;
    }

@@ -859,7 +820,7 @@ 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, handler->pkt_trace_id, layer_type2str(this_type), data_next_length, length);
+    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);
    switch (next_proto)
    {
        // PPPOE_TYPE_IPV4
@@ -871,7 +832,7 @@ static const void *parse_pppoe_ses(struct raw_pkt_parser *handler, const void *d
        // TODO
        return parse_ipv6(handler, data_next_layer, data_next_length, LAYER_TYPE_IPV6);
    default:
-        LOG_ERROR("%s: pkt_trace_id: %lu, this_layer: %s, stop parse next protocol %d", LOG_TAG, handler->pkt_trace_id, layer_type2str(this_type), next_proto);
+        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);
        return data_next_layer;
    }
 }
@@ -880,7 +841,7 @@ static const void *parse_hdlc(struct raw_pkt_parser *handler, const void *data,
 {
    if (length < 4)
    {
-        LOG_ERROR("%s: pkt_trace_id: %lu, this_layer: %s, err: data not enough", LOG_TAG, handler->pkt_trace_id, layer_type2str(this_type));
+        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));
        return data;
    }

@@ -894,7 +855,7 @@ static const void *parse_hdlc(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, handler->pkt_trace_id, layer_type2str(this_type), data_next_length, length);
+    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);
    // HDLC的协议字段与以太网的类似，对于IPv4，为0x0800
    switch (next_proto)
    {
@@ -907,7 +868,7 @@ static const void *parse_hdlc(struct raw_pkt_parser *handler, const void *data,
        // TODO
        return parse_ipv6(handler, data_next_layer, data_next_length, LAYER_TYPE_IPV6);
    default:
-        LOG_ERROR("%s: pkt_trace_id: %lu, this_layer: %s, stop parse next protocol %d", LOG_TAG, handler->pkt_trace_id, layer_type2str(this_type), next_proto);
+        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);
        return data_next_layer;
    }
 }
@@ -916,7 +877,7 @@ static const void *parse_vxlan(struct raw_pkt_parser *handler, const void *data,
 {
    if (length < sizeof(struct vxlan_hdr))
    {
-        LOG_ERROR("%s: pkt_trace_id: %lu, this_layer: %s, err: data not enough", LOG_TAG, handler->pkt_trace_id, layer_type2str(this_type));
+        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));
        return NULL;
    }

@@ -930,7 +891,7 @@ 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, handler->pkt_trace_id, layer_type2str(this_type), data_next_length, length);
+    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);
    // TESTED
    return parse_ether(handler, data_next_layer, data_next_length, LAYER_TYPE_ETHER);

@@ -942,7 +903,7 @@ static const void *parse_vlan8021q(struct raw_pkt_parser *handler, const void *d
 {
    if (length < sizeof(struct vlan_hdr))
    {
-        LOG_ERROR("%s: pkt_trace_id: %lu, this_layer: %s, err: data not enough", LOG_TAG, handler->pkt_trace_id, layer_type2str(this_type));
+        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));
        return NULL;
    }

@@ -957,7 +918,7 @@ 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, handler->pkt_trace_id, layer_type2str(this_type), data_next_length, length);
+    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);
    switch (next_proto)
    {
    case ETH_P_8021Q:
@@ -976,7 +937,7 @@ static const void *parse_vlan8021q(struct raw_pkt_parser *handler, const void *d
        // TODO
        return parse_mpls(handler, data_next_layer, data_next_length, LAYER_TYPE_MPLS);
    default:
-        LOG_ERROR("%s: pkt_trace_id: %lu, this_layer: %s, stop parse next protocol %d", LOG_TAG, handler->pkt_trace_id, layer_type2str(this_type), next_proto);
+        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);
        return data_next_layer;
    }
 }
@@ -985,7 +946,7 @@ static const void *parse_gtpv1_u(struct raw_pkt_parser *handler, const void *dat
 {
    if (length < sizeof(struct gtp_hdr))
    {
-        LOG_ERROR("%s: pkt_trace_id: %lu, this_layer: %s, err: data not enough", LOG_TAG, handler->pkt_trace_id, layer_type2str(this_type));
+        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));
        return NULL;
    }

@@ -1004,7 +965,7 @@ 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, handler->pkt_trace_id, layer_type2str(this_type), data_next_length, length);
+    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);
    switch (next_proto)
    {
    case 4:
@@ -1014,7 +975,7 @@ static const void *parse_gtpv1_u(struct raw_pkt_parser *handler, const void *dat
        // TESTED
        return parse_ipv6(handler, data_next_layer, data_next_length, LAYER_TYPE_IPV6);
    default:
-        LOG_ERROR("%s: pkt_trace_id: %lu, this_layer: %s, stop parse next protocol %d", LOG_TAG, handler->pkt_trace_id, layer_type2str(this_type), next_proto);
+        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);
        return data_next_layer;
    }
 }
@@ -1023,7 +984,7 @@ static const void *parse_mpls(struct raw_pkt_parser *handler, const void *data,
 {
    if (length < 4)
    {
-        LOG_ERROR("%s: pkt_trace_id: %lu, this_layer: %s, err: data not enough", LOG_TAG, handler->pkt_trace_id, layer_type2str(this_type));
+        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));
        return data;
    }

@@ -1077,32 +1038,32 @@ 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, handler->pkt_trace_id, layer_type2str(this_type), data_next_length, length);
+            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);
            // TESTED
            return parse_ether(handler, data_next_layer, data_next_length, LAYER_TYPE_ETHER);
        }
        else if (ip_version == 4)
        {
-            LOG_DEBUG("%s: pkt_trace_id: %lu, this_layer: %s, payload_len: [%lu/%lu]", LOG_TAG, handler->pkt_trace_id, layer_type2str(this_type), data_next_length, length);
+            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);
            // TESTED
            return parse_ipv4(handler, data_next_layer, data_next_length, LAYER_TYPE_IPV4);
        }
        else if (ip_version == 6)
        {
-            LOG_DEBUG("%s: pkt_trace_id: %lu, this_layer: %s, payload_len: [%lu/%lu]", LOG_TAG, handler->pkt_trace_id, layer_type2str(this_type), data_next_length, length);
+            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);
            // TODO
            return parse_ipv6(handler, data_next_layer, data_next_length, LAYER_TYPE_IPV6);
        }
        else
        {
-            LOG_DEBUG("%s: pkt_trace_id: %lu, this_layer: %s, payload_len: [%lu/%lu]", LOG_TAG, handler->pkt_trace_id, layer_type2str(this_type), data_next_length, length);
+            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);
            // TODO
            return parse_ether(handler, data_next_layer, data_next_length, LAYER_TYPE_ETHER);
        }
    }
    else
    {
-        LOG_DEBUG("%s: pkt_trace_id: %lu, this_layer: %s, payload_len: [%lu/%lu]", LOG_TAG, handler->pkt_trace_id, layer_type2str(this_type), data_next_length, length);
+        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);
        // TESTED
        return parse_mpls(handler, data_next_layer, data_next_length, LAYER_TYPE_MPLS);
    }