为Packet Parser增加边界检查。v4.6.52-20230912

9 files changed, 386 insertions, 281 deletions

diff --git a/app/src/mrb.c b/app/src/mrb.c
index ed8a5af..eafd40a 100644
--- a/app/src/mrb.c
+++ b/app/src/mrb.c
@@ -213,7 +213,7 @@ void marsio_buff_do_rehash(struct mr_instance * mr_instance, marsio_buff_t * m)
     /* parse the packet again */
     struct pkt_parser pkt_parser;
     pkt_parser_init(&pkt_parser, &mrb_metadata->pkt_parser_result, LAYER_TYPE_ALL, MR_PKT_PARSER_LAYERS_MAX);
-    complex_parser_ether(&pkt_parser, rte_pktmbuf_mtod(mbuf, const char *));
+    pkt_parser_exec(&pkt_parser, mbuf);
 
     struct rte_mbuf * mbufs[1] = {mbuf};
     struct pkt_parser_result * parser_results[1] = {&mrb_metadata->pkt_parser_result};
diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt
index 3a59982..ebb434f 100644
--- a/examples/CMakeLists.txt
+++ b/examples/CMakeLists.txt
@@ -21,8 +21,8 @@ target_link_libraries(mrtest-vxlan-encap marsio pthread)
 add_executable(mrtest-vxlan-link-id-inject vxlan-virtual-link-id.cc)
 target_link_libraries(mrtest-vxlan-link-id-inject marsio pthread pcap)
 
-add_executable(mrtest-smartoffload smartoffload.cc)
-target_link_libraries(mrtest-smartoffload marsio pthread pcap)
+#add_executable(mrtest-smartoffload smartoffload.cc)
+#target_link_libraries(mrtest-smartoffload marsio pthread pcap)
 
 add_executable(mrtest-l2fwd-nf l2fwd-nf.c)
 target_link_libraries(mrtest-l2fwd-nf marsio pthread pcap)
diff --git a/infra/include/ldbc.h b/infra/include/ldbc.h
index df52856..c578b5c 100644
--- a/infra/include/ldbc.h
+++ b/infra/include/ldbc.h
@@ -121,7 +121,6 @@ struct pkt_parser
     unsigned int nr_expect_results;
 
     struct pkt_parser_result * result;
-    const void * ptr_pkt_start;
 };
 
 struct distributer
@@ -146,14 +145,13 @@ static inline void pkt_parser_init(struct pkt_parser * pkt_parser, struct pkt_pa
     pkt_parser->expect_layer_mask = expect_layer_type;
     pkt_parser->nr_expect_results = nr_expect_results;
     pkt_parser->result = result;
-    pkt_parser->ptr_pkt_start = NULL;
 
     /* clear the result array */
     result->nr_layers = 0;
     result->start_layers = 0;
 }
 
-const void * complex_parser_ether(struct pkt_parser * handler, const void * data);
+void pkt_parser_exec(struct pkt_parser * handler, const struct rte_mbuf * mbuf);
 
 struct distributer * distributer_create(enum e_dist_mode distmode, enum e_hash_mode hashmode, uint32_t orin_hash);
 
@@ -174,9 +172,8 @@ static inline int distributer_calculate(struct distributer * dist_object, struct
 
     for (unsigned int i = 0; i < nr_mbufs; i++)
     {
-        const char * ether_hdr = rte_pktmbuf_mtod(mbufs[i], const char *);
         pkt_parser_init(&parser_handlers[i], &parser_results[i], LAYER_TYPE_ALL, MR_PKT_PARSER_LAYERS_MAX);
-        complex_parser_ether(&parser_handlers[i], ether_hdr);
+        pkt_parser_exec(&parser_handlers[i], mbufs[i]);
     }
 
     struct pkt_parser_result * ptr_result[nr_mbufs];
diff --git a/infra/src/ldbc.c b/infra/src/ldbc.c
index 1f79e6e..db66d90 100644
--- a/infra/src/ldbc.c
+++ b/infra/src/ldbc.c
@@ -49,87 +49,69 @@ static inline int pkt_parser_push(struct pkt_parser * pkt_parser, enum complex_l
     return 0;
 }
 
-static inline int parser_stop_or_continue(struct pkt_parser * handler, const void * data,
-                                          enum complex_layer_type_mask this_layer_type)
+#define PARSE_CAN_STOP(_handle, type, offset)                                        \
+({                                                                                   \
+    int retval = PARSE_CONTINUE;                                                     \
+    if (type & handler->expect_layer_mask)                                           \
+    {                                                                                \
+        uint16_t this_layer_type_id = complex_layer_mask_to_id(type);                \
+        if (pkt_parser_push(handler, this_layer_type_id, offset) < 0)                \
+        {                                                                            \
+            retval = PARSE_STOP;                                                     \
+        }                                                                            \
+    }                                                                                \
+    retval;                                                                          \
+})                                                                                   \
+
+/* function declare for packet_parse_* */
+static void packet_parse_ether(struct pkt_parser * handler, const struct rte_mbuf * mbuf, unsigned int offset);
+static void packet_parse_vlan8021q(struct pkt_parser * handler, const struct rte_mbuf * mbuf, unsigned int offset);
+static void packet_parse_mpls_uc(struct pkt_parser * handler, const struct rte_mbuf * mbuf, unsigned int offset);
+static void packet_parse_pppoe_ses(struct pkt_parser * handler, const struct rte_mbuf * mbuf, unsigned int offset);
+static void packet_parse_hdlc(struct pkt_parser * handler, const struct rte_mbuf * mbuf, unsigned int offset);
+static void packet_parse_ppp(struct pkt_parser * handler, const struct rte_mbuf * mbuf, unsigned int offset);
+static void packet_parse_ipv4(struct pkt_parser * handler, const struct rte_mbuf * mbuf, unsigned int offset);
+static void packet_parse_ipv6(struct pkt_parser * handler, const struct rte_mbuf * mbuf, unsigned int offset);
+static void packet_parse_gre(struct pkt_parser * handler, const struct rte_mbuf * mbuf, unsigned int offset);
+static void packet_parse_udp(struct pkt_parser * handler, const struct rte_mbuf * mbuf, unsigned int offset);
+static void packet_parse_tcp(struct pkt_parser * handler, const struct rte_mbuf * mbuf, unsigned int offset);
+static void packet_parse_icmp(struct pkt_parser * handler, const struct rte_mbuf * mbuf, unsigned int offset);
+static void packet_parse_icmp6(struct pkt_parser * handler, const struct rte_mbuf * mbuf, unsigned int offset);
+static void packet_parse_gtpv1_u(struct pkt_parser * handler, const struct rte_mbuf * mbuf, unsigned int offset);
+static void packet_parse_ef_vxlan(struct pkt_parser * handler, const struct rte_mbuf * mbuf, unsigned int offset);
+
+static void packet_parse_ef_vxlan(struct pkt_parser * handler, const struct rte_mbuf * mbuf,
+                                  unsigned int offset)
 {
-    if (!(this_layer_type & handler->expect_layer_mask))
+    if (PARSE_CAN_STOP(handler, LAYER_TYPE_G_VXLAN, offset) == PARSE_STOP)
     {
-        return PARSE_CONTINUE;
+        return;
     }
 
-    /* convert the layer mask to id */
-    uint16_t this_layer_type_id = complex_layer_mask_to_id(this_layer_type);
-    uint16_t offset = RTE_PTR_DIFF(data, handler->ptr_pkt_start);
-
-    if (pkt_parser_push(handler, this_layer_type_id, offset) < 0)
+    struct g_vxlan_hdr ef_vxlan_hdr_copy;
+    const struct g_vxlan_hdr * ef_vxlan_hdr = rte_pktmbuf_read(mbuf, offset, sizeof(struct g_vxlan_hdr), &ef_vxlan_hdr_copy);
+    if (unlikely(ef_vxlan_hdr == NULL))
     {
-        return PARSE_STOP;
+        return;
     }
 
-    return PARSE_CONTINUE;
-}
-
-static const void * __complex_parser_g_vxlan(struct pkt_parser * handler, const void * data,
-                                             enum complex_layer_type_mask this_layer_type);
-
-static const void * __complex_parser_gtpv1_u(struct pkt_parser * handler, const void * data,
-                                             enum complex_layer_type_mask this_layer_type);
-
-static const void * __complex_parser_tcp(struct pkt_parser * handler, const void * data,
-                                         enum complex_layer_type_mask this_layer_type);
-
-static const void * __complex_parser_udp(struct pkt_parser * handler, const void * data,
-                                         enum complex_layer_type_mask this_layer_type);
-
-static const void * __complex_parser_icmp(struct pkt_parser * handler, const void * data,
-                                          enum complex_layer_type_mask this_layer_type);
-
-static const void * __complex_parser_ipv4(struct pkt_parser * handler, const void * data,
-                                          enum complex_layer_type_mask this_layer_type);
-
-static const void * __complex_parser_ipv6(struct pkt_parser * handler, const void * data,
-                                          enum complex_layer_type_mask this_layer_type);
-
-static const void * __complex_parser_pppoe_ses(struct pkt_parser * handler, const void * data,
-                                               enum complex_layer_type_mask this_layer_type);
-
-static const void * __complex_parser_mpls_uc(struct pkt_parser * handler, const void * data,
-                                             enum complex_layer_type_mask this_layer_type);
-
-static const void * __complex_parser_vlan8021q(struct pkt_parser * handler, const void * data,
-                                               enum complex_layer_type_mask this_layer_type);
-
-static const void * __complex_parser_hdlc(struct pkt_parser * handler, const void * data,
-                                          enum complex_layer_type_mask this_layer_type);
-
-static const void * __complex_parser_ppp(struct pkt_parser * handler, const void * data,
-                                         enum complex_layer_type_mask this_layer_type);
-
-static const void * __complex_parser_ether(struct pkt_parser * handler, const void * data,
-                                           enum complex_layer_type_mask this_layer_type);
-
-static const void * __complex_parser_g_vxlan(struct pkt_parser * handler, const void * data,
-                                             enum complex_layer_type_mask this_layer_type)
-{
-    if (parser_stop_or_continue(handler, data, this_layer_type) == PARSE_STOP)
-        return data;
-
-    struct g_vxlan_hdr * g_vxlan_hdr = (struct g_vxlan_hdr *)data;
-    void * data_next_layer = (void *)(g_vxlan_hdr + 1);
-
-    switch (g_vxlan_hdr->link_layer_type)
+    switch (ef_vxlan_hdr->link_layer_type)
     {
     case G_VXLAN_INNER_LINK_TYPE_ETH:
-        return __complex_parser_ether(handler, data_next_layer, LAYER_TYPE_ETHER);
+        packet_parse_ether(handler, mbuf, offset + sizeof(struct g_vxlan_hdr));
+        return;
 
     case G_VXLAN_INNER_LINK_TYPE_HDLC:
-        return __complex_parser_hdlc(handler, data_next_layer, LAYER_TYPE_HDLC);
+        packet_parse_hdlc(handler, mbuf, offset + sizeof(struct g_vxlan_hdr));
+        return;
 
     case G_VXLAN_INNER_LINK_TYPE_PPP:
-        return __complex_parser_ppp(handler, data_next_layer, LAYER_TYPE_PPP);
-    }
+        packet_parse_ppp(handler, mbuf, offset + sizeof(struct g_vxlan_hdr));
+        return;
 
-    return NULL;
+    default:
+        return;
+    }
 }
 
 /* FROM SAPP */
@@ -190,106 +172,130 @@ static int deal_gtp_calc_gtp_hdr_len(const struct gtp_hdr * gtph)
     return (char *)p_ext_hdr - (char *)gtph;
 }
 
-static const void * __complex_parser_gtpv1_u(struct pkt_parser * handler, const void * data,
-                                             enum complex_layer_type_mask this_layer_type)
+static void packet_parse_gtpv1_u(struct pkt_parser * handler, const struct rte_mbuf * mbuf, unsigned int offset)
 {
-    int hdrlen = deal_gtp_calc_gtp_hdr_len((const struct gtp_hdr *)data);
-    if (hdrlen < 0)
+    if (PARSE_CAN_STOP(handler, LAYER_TYPE_GTPV1_U, offset) == PARSE_STOP)
     {
-        return NULL;
+        return;
     }
 
-    const void * data_next_layer = (const void *)(data + hdrlen);
-    const uint8_t * __data_next_layer = (const uint8_t *)data_next_layer;
+    struct gtp_hdr gtp_hdr_copy;
+    const struct gtp_hdr * gtp_hdr = rte_pktmbuf_read(mbuf, offset, sizeof(struct gtp_hdr), &gtp_hdr_copy);
+    if (unlikely(gtp_hdr == NULL))
+    {
+        return;
+    }
+
+    int gtp_hdr_len = deal_gtp_calc_gtp_hdr_len(gtp_hdr);
+    if (unlikely(gtp_hdr_len < 0))
+    {
+        return;
+    }
+
+    /* get ip version */
+    uint8_t ip_version_ihl_copy;
+    const uint8_t * ip_version_ihl =
+        rte_pktmbuf_read(mbuf, offset + gtp_hdr_len, sizeof(uint8_t), &ip_version_ihl_copy);
+
+    if (unlikely(ip_version_ihl == NULL))
+    {
+        return;
+    }
 
-    uint8_t ip_version = (__data_next_layer[0]) >> 4;
+    uint8_t ip_version = (*ip_version_ihl) >> 4;
     if (ip_version == 4)
     {
-        return __complex_parser_ipv4(handler, data_next_layer, LAYER_TYPE_IPV4);
+        packet_parse_ipv4(handler, mbuf, offset + gtp_hdr_len);
+        return;
     }
     else if (ip_version == 6)
     {
-        return __complex_parser_ipv6(handler, data_next_layer, LAYER_TYPE_IPV6);
+        packet_parse_ipv6(handler, mbuf, offset + gtp_hdr_len);
+        return;
     }
-
-    return NULL;
 }
 
-static const void * __complex_parser_icmp(struct pkt_parser * handler, const void * data,
-                                          enum complex_layer_type_mask this_layer_type)
+static void packet_parse_icmp(struct pkt_parser * handler, const struct rte_mbuf * mbuf, unsigned int offset)
 {
-    if (parser_stop_or_continue(handler, data, this_layer_type) == PARSE_STOP)
-        return data;
-
-    return NULL;
+    if (PARSE_CAN_STOP(handler, LAYER_TYPE_ICMP, offset) == PARSE_STOP)
+    {
+        return;
+    }
 }
 
-static const void * __complex_parser_icmp6(struct pkt_parser * handler, const void * data,
-                                          enum complex_layer_type_mask this_layer_type)
+static void packet_parse_icmp6(struct pkt_parser * handler, const struct rte_mbuf * mbuf, unsigned int offset)
 {
-    if (parser_stop_or_continue(handler, data, this_layer_type) == PARSE_STOP)
-        return data;
-
-    return NULL;
+    if (PARSE_CAN_STOP(handler, LAYER_TYPE_ICMP6, offset) == PARSE_STOP)
+    {
+        return;
+    }
 }
 
-static const void * __complex_parser_tcp(struct pkt_parser * handler, const void * data,
-                                         enum complex_layer_type_mask this_layer_type)
+static void packet_parse_tcp(struct pkt_parser * handler, const struct rte_mbuf * mbuf, unsigned int offset)
 {
-    if (parser_stop_or_continue(handler, data, this_layer_type) == PARSE_STOP)
-        return data;
-
-    return NULL;
+    if (PARSE_CAN_STOP(handler, LAYER_TYPE_TCP, offset) == PARSE_STOP)
+    {
+        return;
+    }
 }
 
-static const void * __complex_parser_udp(struct pkt_parser * handler, const void * data,
-                                         enum complex_layer_type_mask this_layer_type)
+static void packet_parse_udp(struct pkt_parser * handler, const struct rte_mbuf * mbuf, unsigned int offset)
 {
-    if (parser_stop_or_continue(handler, data, this_layer_type) == PARSE_STOP)
-        return data;
+    if (PARSE_CAN_STOP(handler, LAYER_TYPE_UDP, offset) == PARSE_STOP)
+    {
+        return;
+    }
 
-    struct rte_udp_hdr * udp_hdr = (struct rte_udp_hdr *)data;
-    void * data_next_layer = (void *)(udp_hdr + 1);
+    struct rte_udp_hdr udp_hdr_copy;
+    const struct rte_udp_hdr * udp_hdr = rte_pktmbuf_read(mbuf, offset, sizeof(struct rte_udp_hdr), &udp_hdr_copy);
 
     /* 专用设备VxLAN封装 */
     if (udp_hdr->dst_port == RTE_BE16(G_VXLAN_DPORT))
-        return __complex_parser_g_vxlan(handler, data_next_layer, LAYER_TYPE_G_VXLAN);
-    if (udp_hdr->dst_port == RTE_BE16(GTP1U_PORT))
-        return __complex_parser_gtpv1_u(handler, data_next_layer, LAYER_TYPE_GTPV1_U);
-
-    return NULL;
+    {
+        packet_parse_ef_vxlan(handler, mbuf, offset + sizeof(struct rte_udp_hdr));
+        return;
+    }
+    else if (udp_hdr->dst_port == RTE_BE16(GTP1U_PORT))
+    {
+        packet_parse_gtpv1_u(handler, mbuf, offset + sizeof(struct rte_udp_hdr));
+        return;
+    }
 }
 
-static const void * __complex_parser_gre(struct pkt_parser * handler, const void * data,
-                                         enum complex_layer_type_mask this_layer_type)
+static void packet_parse_gre(struct pkt_parser * handler, const struct rte_mbuf * mbuf, unsigned int offset)
 {
-    if (parser_stop_or_continue(handler, data, this_layer_type) == PARSE_STOP)
-        return data;
+    if (PARSE_CAN_STOP(handler, LAYER_TYPE_GRE, offset) == PARSE_STOP)
+    {
+        return;
+    }
 
     static const uint8_t opt_len[16] = {
         [0x0] = 4, [0x1] = 8, [0x2] = 8, [0x8] = 8, [0x3] = 12, [0x9] = 12, [0xa] = 12, [0xb] = 16,
     };
 
-    struct rte_gre_hdr * gre_hdr = (struct rte_gre_hdr *)data;
+    struct rte_gre_hdr gre_hdr_copy;
+    const struct rte_gre_hdr * gre_hdr = rte_pktmbuf_read(mbuf, offset, sizeof(struct rte_gre_hdr), &gre_hdr_copy);
+
     uint16_t flags = rte_be_to_cpu_16(*(const uint16_t *)gre_hdr);
     flags >>= 12;
 
     if (unlikely(opt_len[flags] == 0))
     {
-        return NULL;
+        return;
     }
 
-    void * data_next_layer = (void *)RTE_PTR_ADD(gre_hdr, opt_len[flags]);
     switch (gre_hdr->proto)
     {
     case RTE_BE16(ETH_P_IP):
-        return __complex_parser_ipv4(handler, data_next_layer, LAYER_TYPE_IPV4);
+        packet_parse_ipv4(handler, mbuf, offset + opt_len[flags]);
+        return;
 
     case RTE_BE16(ETH_P_IPV6):
-        return __complex_parser_ipv6(handler, data_next_layer, LAYER_TYPE_IPV6);
+        packet_parse_ipv6(handler, mbuf, offset + opt_len[flags]);
+        return;
 
     default:
-        return NULL;
+        return;
     }
 }
 
@@ -304,133 +310,173 @@ static int is_ipv4_fragment(const struct rte_ipv4_hdr *hdr)
     return ip_flag != 0 || ip_ofs  != 0;
 }
 
-static const void * __complex_parser_ipv4(struct pkt_parser * handler, const void * data,
-                                          enum complex_layer_type_mask this_layer_type)
+static void packet_parse_ipv4(struct pkt_parser * handler, const struct rte_mbuf * mbuf, unsigned int offset)
 {
-    if (parser_stop_or_continue(handler, data, this_layer_type) == PARSE_STOP)
-        return data;
+    if (PARSE_CAN_STOP(handler, LAYER_TYPE_IPV4, offset) == PARSE_STOP)
+    {
+        return;
+    }
 
-    struct rte_ipv4_hdr * ipv4_hdr = (struct rte_ipv4_hdr *)data;
-    unsigned int ipv4_hdr_len = (ipv4_hdr->version_ihl & 0xf) * 4u;
-    void * data_next_layer = (uint8_t *)data + ipv4_hdr_len;
+    struct rte_ipv4_hdr ipv4_hdr_copy;
+    const struct rte_ipv4_hdr * ipv4_hdr = rte_pktmbuf_read(mbuf, offset, sizeof(struct rte_ipv4_hdr), &ipv4_hdr_copy);
+    if (unlikely(ipv4_hdr == NULL))
+    {
+        return;
+    }
 
-    if (is_ipv4_fragment(ipv4_hdr))
+    if (unlikely(is_ipv4_fragment(ipv4_hdr)))
     {
-        return NULL;
+        return;
     }
 
+    unsigned int ipv4_hdr_len = rte_ipv4_hdr_len(ipv4_hdr);
     switch (ipv4_hdr->next_proto_id)
     {
     case IPPROTO_TCP:
-        return __complex_parser_tcp(handler, data_next_layer, LAYER_TYPE_TCP);
+        packet_parse_tcp(handler, mbuf, offset + ipv4_hdr_len);
+        return;
 
     case IPPROTO_UDP:
-        return __complex_parser_udp(handler, data_next_layer, LAYER_TYPE_UDP);
-
-    case IPPROTO_ICMP:
-        return __complex_parser_icmp(handler, data_next_layer, LAYER_TYPE_ICMP);
+        packet_parse_udp(handler, mbuf, offset + ipv4_hdr_len);
+        return;
 
     case IPPROTO_GRE:
-        return __complex_parser_gre(handler, data_next_layer, LAYER_TYPE_GRE);
+        packet_parse_gre(handler, mbuf, offset + ipv4_hdr_len);
+        return;
+
+    case IPPROTO_ICMP:
+        packet_parse_icmp(handler, mbuf, offset + ipv4_hdr_len);
+        return;
 
     default:
-        return NULL;
+        return;
     }
-
-    return NULL;
 }
 
-static const void * __complex_parser_ipv6(struct pkt_parser * handler, const void * data,
-                                          enum complex_layer_type_mask this_layer_type)
+static void packet_parse_ipv6(struct pkt_parser * handler, const struct rte_mbuf * mbuf, unsigned int offset)
 {
-    if (parser_stop_or_continue(handler, data, this_layer_type) == PARSE_STOP)
-        return data;
+    if (PARSE_CAN_STOP(handler, LAYER_TYPE_IPV6, offset) == PARSE_STOP)
+    {
+        return;
+    }
 
-    struct rte_ipv6_hdr * ipv6_hdr = (struct rte_ipv6_hdr *)data;
-    unsigned int ipv6_hdr_len = sizeof(struct rte_ipv6_hdr);
-    void * data_next_layer = (uint8_t *)data + ipv6_hdr_len;
+    struct rte_ipv6_hdr ipv6_hdr_copy;
+    const struct rte_ipv6_hdr * ipv6_hdr = rte_pktmbuf_read(mbuf, offset, sizeof(struct rte_ipv6_hdr), &ipv6_hdr_copy);
+
+    if (unlikely(ipv6_hdr == NULL))
+    {
+        return;
+    }
 
     switch (ipv6_hdr->proto)
     {
     case IPPROTO_TCP:
-        return __complex_parser_tcp(handler, data_next_layer, LAYER_TYPE_TCP);
+        packet_parse_tcp(handler, mbuf, offset + sizeof(struct rte_ipv6_hdr));
+        return;
 
     case IPPROTO_UDP:
-        return __complex_parser_udp(handler, data_next_layer, LAYER_TYPE_UDP);
+        packet_parse_udp(handler, mbuf, offset + sizeof(struct rte_ipv6_hdr));
+        return;
 
     case IPPROTO_ICMPV6:
-        return __complex_parser_icmp6(handler, data_next_layer, LAYER_TYPE_ICMP6);
+        packet_parse_icmp6(handler, mbuf, offset + sizeof(struct rte_ipv6_hdr));
+        return;
 
     default:
-        return NULL;
+        return;
     }
-
-    return NULL;
 }
 
-static const void * __complex_parser_pppoe_ses(struct pkt_parser * handler, const void * data,
-                                               enum complex_layer_type_mask this_layer_type)
+static void packet_parse_pppoe_ses(struct pkt_parser * handler, const struct rte_mbuf * mbuf,
+                                      unsigned int offset)
 {
-    if (parser_stop_or_continue(handler, data, this_layer_type) == PARSE_STOP)
-        return data;
+    if (PARSE_CAN_STOP(handler, LAYER_TYPE_PPPOE, offset) == PARSE_STOP)
+    {
+        return;
+    }
 
 #define PPPOE_TYPE_IPV4 0x2100
 #define PPPOE_TYPE_IPV6 0x5700
+#define PPPOE_SES_HEADER_LEN 8
 
-    uint16_t pppoe_type = *((uint16_t *)data + 3);
-    void * data_next_layer = (uint8_t *)data + 8;
+    char pppoe_header_copy[PPPOE_SES_HEADER_LEN];
+    const char * pppoe_header = rte_pktmbuf_read(mbuf, offset, 8, pppoe_header_copy);
+    if (unlikely(pppoe_header == NULL))
+    {
+        return;
+    }
 
+    uint16_t pppoe_type = *((uint16_t *)pppoe_header + 3);
     switch (pppoe_type)
     {
     case PPPOE_TYPE_IPV4:
-        return __complex_parser_ipv4(handler, data_next_layer, LAYER_TYPE_IPV4);
+        packet_parse_ipv4(handler, mbuf, offset + PPPOE_SES_HEADER_LEN);
+        return;
 
     case PPPOE_TYPE_IPV6:
-        return __complex_parser_ipv6(handler, data_next_layer, LAYER_TYPE_IPV6);
+        packet_parse_ipv6(handler, mbuf, offset + PPPOE_SES_HEADER_LEN);
+        return;
 
     default:
-        return NULL;
+        return;
     }
-
-    return NULL;
 }
 
-static const void * __complex_parser_mpls_uc(struct pkt_parser * handler, const void * data,
-                                             enum complex_layer_type_mask this_layer_type)
+static void packet_parse_mpls_uc(struct pkt_parser * handler, const struct rte_mbuf * mbuf, unsigned int offset)
 {
-    if (parser_stop_or_continue(handler, data, this_layer_type) == PARSE_STOP)
-        return data;
+    if (PARSE_CAN_STOP(handler, LAYER_TYPE_VLAN, offset) == PARSE_STOP)
+    {
+        return;
+    }
 
-    // 一个MPLS标签是32位的
-    uint32_t * _mpls_header = (uint32_t *)data;
+    uint32_t mpls_header_copy;
+    const uint32_t * mpls_header = rte_pktmbuf_read(mbuf, offset, sizeof(uint32_t), &mpls_header_copy);
+    if (unlikely(mpls_header == NULL))
+    {
+        return;
+    }
 
 #define MPLS_LABEL_MASK (0xFFFFF000)
 #define MPLS_EXP_MASK (0x00000E00)
 #define MPLS_BLS_MASK (0x00000100)
 #define MPLS_TTL_MASK (0x000000FF)
 
-    __rte_unused unsigned int mpls_label = (ntohl(*_mpls_header) & MPLS_LABEL_MASK) >> 12;
-    __rte_unused unsigned int mpls_exp = (ntohl(*_mpls_header) & MPLS_EXP_MASK) >> 9;
-    __rte_unused unsigned int mpls_ttl = (ntohl(*_mpls_header) & MPLS_TTL_MASK);
-    unsigned int mpls_bls = (ntohl(*_mpls_header) & MPLS_BLS_MASK) >> 8;
+    __rte_unused unsigned int mpls_label = (ntohl(*mpls_header) & MPLS_LABEL_MASK) >> 12;
+    __rte_unused unsigned int mpls_exp = (ntohl(*mpls_header) & MPLS_EXP_MASK) >> 9;
+    __rte_unused unsigned int mpls_ttl = (ntohl(*mpls_header) & MPLS_TTL_MASK);
+    unsigned int mpls_bls = (ntohl(*mpls_header) & MPLS_BLS_MASK) >> 8;
 
-    void * data_next_layer = _mpls_header + 1;
-    uint8_t * __data_next_layer = (uint8_t *)data_next_layer;
+    // Determine whether MPLS is the last one.
+    // If so, consider the next layer to be IPv4.
 
-    // 判断MPLS是否是最后一个，如果是，认为下一层是IPv4
-    // 下一层协议解析，参看Linux内核实现，直接判断IPv4/IPv6版本号。
-    // 现网中遇到了MPLS后是以太头的报文，不符合RFC。现直接判断是否为v4/v6，否则按以太报文处理。
+    // For next-level protocol analysis,
+    // refer to the Linux kernel implementation to directly determine the IPv4/IPv6 version number.
+    // In the current network, MPLS packets followed by Ethernet headers are encountered,
+    // which does not comply with RFC.
+    // Now directly determine whether it is v4/v6, otherwise it will be processed as an Ethernet message.
     // https://github.com/torvalds/linux/blob/9097a058d49e049925d8da72db07fffcee24efa0/drivers/net/tun.c#L1876
+
     if (mpls_bls == 1)
     {
-        uint8_t ip_version = (__data_next_layer[0]) >> 4;
+        uint8_t ip_version_ihl_copy;
+        const uint8_t * ip_version_ihl =
+            rte_pktmbuf_read(mbuf, offset + sizeof(uint32_t), sizeof(uint8_t), &ip_version_ihl_copy);
+
+        if (unlikely(ip_version_ihl == NULL))
+        {
+            return;
+        }
+
+        uint8_t ip_version = (*ip_version_ihl) >> 4;
         if (ip_version == 4)
         {
-            return __complex_parser_ipv4(handler, data_next_layer, LAYER_TYPE_IPV4);
+            packet_parse_ipv4(handler, mbuf, offset + sizeof(uint32_t));
+            return;
         }
         else if (ip_version == 6)
         {
-            return __complex_parser_ipv6(handler, data_next_layer, LAYER_TYPE_IPV6);
+            packet_parse_ipv6(handler, mbuf, offset + sizeof(uint32_t));
+            return;
         }
 
         /* PW Ethernet Control Word,
@@ -443,145 +489,173 @@ static const void * __complex_parser_mpls_uc(struct pkt_parser * handler, const
         */
         else if (ip_version == 0)
         {
-            return __complex_parser_ether(handler, data_next_layer + 4, LAYER_TYPE_ETHER);
+            packet_parse_ether(handler, mbuf, offset + sizeof(uint32_t) + sizeof(uint32_t));
+            return;
         }
         else
         {
-            return __complex_parser_ether(handler, data_next_layer, LAYER_TYPE_ETHER);
+            packet_parse_ether(handler, mbuf, offset + sizeof(uint32_t));
+            return;
         }
     }
 
-    // 如果不是，嵌套的MPLS标签，解下一个
+    /* next mpls label */
     else
     {
-        return __complex_parser_mpls_uc(handler, data_next_layer, LAYER_TYPE_MPLS);
+        packet_parse_mpls_uc(handler, mbuf, offset + sizeof(uint32_t));
+        return;
     }
 }
 
-static const void * __complex_parser_vlan8021q(struct pkt_parser * handler, const void * data,
-                                               enum complex_layer_type_mask this_layer_type)
+static void packet_parse_vlan8021q(struct pkt_parser * handler, const struct rte_mbuf * mbuf, unsigned int offset)
 {
-    if (parser_stop_or_continue(handler, data, this_layer_type) == PARSE_STOP)
-        return data;
+    if (PARSE_CAN_STOP(handler, LAYER_TYPE_VLAN, offset) == PARSE_STOP)
+    {
+        return;
+    }
+
+    struct rte_vlan_hdr vlan_hdr_copy;
 
-    struct rte_vlan_hdr * vlan_hdr = (struct rte_vlan_hdr *)data;
-    uint16_t eth_proto = ntohs(vlan_hdr->eth_proto);
-    void * data_next_layer = vlan_hdr + 1;
+    const struct rte_vlan_hdr * vlan_hdr_ptr =
+        rte_pktmbuf_read(mbuf, offset, sizeof(struct rte_vlan_hdr), &vlan_hdr_copy);
 
-    switch (eth_proto)
+    if (unlikely(vlan_hdr_ptr == NULL))
     {
-    case ETH_P_8021Q:
-        return __complex_parser_vlan8021q(handler, data_next_layer, LAYER_TYPE_VLAN);
+        return;
+    }
+
+    switch (vlan_hdr_ptr->eth_proto)
+    {
+    case RTE_BE16(ETH_P_8021Q):
+        packet_parse_vlan8021q(handler, mbuf, offset + sizeof(struct rte_vlan_hdr));
+        return;
 
-    case ETH_P_IP:
-        return __complex_parser_ipv4(handler, data_next_layer, LAYER_TYPE_IPV4);
+    case RTE_BE16(ETH_P_IP):
+        packet_parse_ipv4(handler, mbuf, offset + sizeof(struct rte_vlan_hdr));
+        return;
 
-    case ETH_P_IPV6:
-        return __complex_parser_ipv6(handler, data_next_layer, LAYER_TYPE_IPV6);
+    case RTE_BE16(ETH_P_IPV6):
+        packet_parse_ipv6(handler, mbuf, offset + sizeof(struct rte_vlan_hdr));
+        return;
 
-    case ETH_P_PPP_SES:
-        return __complex_parser_pppoe_ses(handler, data_next_layer, LAYER_TYPE_PPPOE);
+    case RTE_BE16(ETH_P_PPP_SES):
+        packet_parse_pppoe_ses(handler, mbuf, offset + sizeof(struct rte_vlan_hdr));
+        return;
+
+    case RTE_BE16(ETH_P_MPLS_UC):
+        packet_parse_mpls_uc(handler, mbuf, offset + sizeof(struct rte_vlan_hdr));
+        return;
 
-    case ETH_P_MPLS_UC:
-        return __complex_parser_mpls_uc(handler, data_next_layer, LAYER_TYPE_MPLS);
     default:
         break;
     }
-
-    return NULL;
 }
 
-static const void * __complex_parser_hdlc(struct pkt_parser * handler, const void * data,
-                                          enum complex_layer_type_mask this_layer_type)
+static void packet_parse_hdlc(struct pkt_parser * handler, const struct rte_mbuf * mbuf, unsigned int offset)
 {
-    if (parser_stop_or_continue(handler, data, this_layer_type) == PARSE_STOP)
-        return data;
+    if (PARSE_CAN_STOP(handler, LAYER_TYPE_HDLC, offset) == PARSE_STOP)
+    {
+        return;
+    }
 
-    uint16_t hdlc_proto = *(const uint16_t *)(data + 2);
-    const void * data_next_layer = (const char *)data + 4;
+    char hdlc_header_copy[4];
+    const char * hdlc_header = rte_pktmbuf_read(mbuf, offset, 4, hdlc_header_copy);
+    if (unlikely(hdlc_header == NULL))
+    {
+        return;
+    }
 
-    /* HDLC的协议字段与以太网的类似，对于IPv4，为0x0800 */
+    uint16_t hdlc_proto = *(const uint16_t *)(hdlc_header + 2);
     switch (ntohs(hdlc_proto))
     {
     case RTE_ETHER_TYPE_IPV4:
-        return __complex_parser_ipv4(handler, data_next_layer, LAYER_TYPE_IPV4);
+        packet_parse_ipv4(handler, mbuf, offset + 4);
+        return;
 
     case RTE_ETHER_TYPE_IPV6:
-        return __complex_parser_ipv6(handler, data_next_layer, LAYER_TYPE_IPV6);
+        packet_parse_ipv6(handler, mbuf, offset + 4);
+        return;
 
     default:
         break;
     }
-
-    return NULL;
 }
 
-static const void * __complex_parser_ppp(struct pkt_parser * handler, const void * data,
-                                         enum complex_layer_type_mask this_layer_type)
+static void packet_parse_ppp(struct pkt_parser * handler, const struct rte_mbuf * mbuf, unsigned int offset)
 {
-    if (parser_stop_or_continue(handler, data, this_layer_type) == PARSE_STOP)
-        return data;
+    if (PARSE_CAN_STOP(handler, LAYER_TYPE_PPP, offset) == PARSE_STOP)
+    {
+        return;
+    }
 
-    const void * data_next_layer = (const char *)data + PPP_HDRLEN;
+    char ppp_hdr_copy[PPP_HDRLEN];
+    const char * ppp_hdr = rte_pktmbuf_read(mbuf, offset, PPP_HDRLEN, ppp_hdr_copy);
+    if (unlikely(ppp_hdr == NULL))
+    {
+        return;
+    }
 
-    switch (PPP_PROTOCOL(data))
+    switch (PPP_PROTOCOL(ppp_hdr))
     {
     case PPP_IP:
-        return __complex_parser_ipv4(handler, data_next_layer, LAYER_TYPE_IPV4);
-        break;
+        packet_parse_ipv4(handler, mbuf, offset + PPP_HDRLEN);
+        return;
 
     case PPP_IPV6:
-        return __complex_parser_ipv6(handler, data_next_layer, LAYER_TYPE_IPV6);
-        break;
+        packet_parse_ipv6(handler, mbuf, offset + PPP_HDRLEN);
+        return;
 
     default:
         break;
     }
-
-    return NULL;
 }
 
-static const void * __complex_parser_ether(struct pkt_parser * handler, const void * data,
-                                           enum complex_layer_type_mask this_layer_type)
+static void packet_parse_ether(struct pkt_parser * handler, const struct rte_mbuf * mbuf, unsigned int offset)
 {
-    if (parser_stop_or_continue(handler, data, this_layer_type) == PARSE_STOP)
-        return data;
+    if (PARSE_CAN_STOP(handler, LAYER_TYPE_ETHER, offset) == PARSE_STOP)
+    {
+        return;
+    }
 
-    struct ethhdr * ether_hdr = (struct ethhdr *)data;
-    uint16_t eth_type = ether_hdr->h_proto;
-    void * data_next_layer = ether_hdr + 1;
+    struct rte_ether_hdr ether_hdr_copy;
+    const struct rte_ether_hdr * ether_hdr_ptr = rte_pktmbuf_read(mbuf, offset, sizeof(struct ethhdr), &ether_hdr_copy);
 
-    switch (eth_type)
+    if (unlikely(ether_hdr_ptr == NULL))
     {
-    case RTE_BE16(ETH_P_8021Q):
-        return __complex_parser_vlan8021q(handler, data_next_layer, LAYER_TYPE_VLAN);
+        return;
+    }
 
+    switch (ether_hdr_ptr->ether_type)
+    {
+    case RTE_BE16(ETH_P_8021Q):
     case RTE_BE16(ETH_P_8021AD):
-        return __complex_parser_ether(handler, data_next_layer, LAYER_TYPE_ETHER);
+        packet_parse_vlan8021q(handler, mbuf, offset + sizeof(struct rte_ether_hdr));
+        return;
 
     case RTE_BE16(ETH_P_IP):
-        return __complex_parser_ipv4(handler, data_next_layer, LAYER_TYPE_IPV4);
+        packet_parse_ipv4(handler, mbuf, offset + sizeof(struct rte_ether_hdr));
+        return;
 
     case RTE_BE16(ETH_P_IPV6):
-        return __complex_parser_ipv6(handler, data_next_layer, LAYER_TYPE_IPV6);
+        packet_parse_ipv6(handler, mbuf, offset + sizeof(struct rte_ether_hdr));
+        return;
 
     case RTE_BE16(ETH_P_PPP_SES):
-        return __complex_parser_pppoe_ses(handler, data_next_layer, LAYER_TYPE_PPPOE);
+        packet_parse_pppoe_ses(handler, mbuf, offset + sizeof(struct rte_ether_hdr));
+        return;
 
     case RTE_BE16(ETH_P_MPLS_UC):
-        return __complex_parser_mpls_uc(handler, data_next_layer, LAYER_TYPE_MPLS);
+        packet_parse_mpls_uc(handler, mbuf, offset + sizeof(struct rte_ether_hdr));
+        return;
 
     default:
         break;
     }
-
-    return NULL;
 }
 
-const void * complex_parser_ether(struct pkt_parser * handler, const void * data)
+void pkt_parser_exec(struct pkt_parser * handler, const struct rte_mbuf * mbuf)
 {
-    handler->ptr_pkt_start = data;
-    return __complex_parser_ether(handler, data, LAYER_TYPE_ETHER);
+    packet_parse_ether(handler, mbuf, 0);
 }
 
 static inline uint32_t hash_sym_crc(struct distributer * dist, const void * data, uint16_t layer_type,
diff --git a/infra/test/TestDistributer.cc b/infra/test/TestDistributer.cc
index 9364682..dec1227 100644
--- a/infra/test/TestDistributer.cc
+++ b/infra/test/TestDistributer.cc
@@ -156,9 +156,7 @@ TEST_P(TestFixtureDistributer, TestDistHashResult)
         struct pkt_parser _pkt_parser_handle;
         struct pkt_parser_result _pkt_parser_result;
         pkt_parser_init(&_pkt_parser_handle, &_pkt_parser_result, LAYER_TYPE_ALL, MR_PKT_PARSER_LAYERS_MAX);
-
-        const char * ether_hdr = rte_pktmbuf_mtod(__mbuf, const char *);
-        complex_parser_ether(&_pkt_parser_handle, ether_hdr);
+        pkt_parser_exec(&_pkt_parser_handle, __mbuf);
 
         struct rte_mbuf * mbufs[1] = {__mbuf};
         struct pkt_parser_result * pkt_parser_results[1] = {&_pkt_parser_result};
diff --git a/infra/test/TestPacketParser.cc b/infra/test/TestPacketParser.cc
index 553d2fa..1e7a596 100644
--- a/infra/test/TestPacketParser.cc
+++ b/infra/test/TestPacketParser.cc
@@ -404,13 +404,29 @@ do {																				\
 
 #define TO_PKT_PARSER_RESULT(_handler)      (&_handler.result)
 
+std::unique_ptr<struct rte_mbuf> mock_rte_mbuf_create(const char * pkt, unsigned int pktlen)
+{
+    auto mock_mbuf = std::unique_ptr<struct rte_mbuf>(new struct rte_mbuf);
+    mock_mbuf->buf_addr = (void *)pkt;
+    mock_mbuf->buf_len = pktlen;
+    mock_mbuf->data_off = 0;
+    mock_mbuf->data_len = pktlen;
+    mock_mbuf->pkt_len = pktlen;
+    mock_mbuf->nb_segs = 1;
+    mock_mbuf->next = nullptr;
+
+    return mock_mbuf;
+}
+
 TEST(PacketParseOuterL3, EtherIPv4)
 {
     struct pkt_parser _pkt_031_handler;
     struct pkt_parser_result _pkt_031_result;
 
+    /* will delete when go outside the function */
+    auto mock_mbuf_ptr = mock_rte_mbuf_create((const char *)pkt_031, sizeof(pkt_031));
     pkt_parser_init(&_pkt_031_handler, &_pkt_031_result, LAYER_TYPE_L3, 1);
-    ASSERT_TRUE(complex_parser_ether(&_pkt_031_handler, pkt_031) != nullptr);
+    pkt_parser_exec(&_pkt_031_handler, mock_mbuf_ptr.get());
 
     EXPECT_EQ(_pkt_031_result.nr_layers, 1);
 
@@ -426,8 +442,9 @@ TEST(PacketParseOuterL3, EtherIPv6)
     struct pkt_parser _pkt_016_handler;
     struct pkt_parser_result _pkt_016_result;
 
+    auto mock_mbuf_ptr = mock_rte_mbuf_create((const char *)pkt_16, sizeof(pkt_16));
     pkt_parser_init(&_pkt_016_handler, &_pkt_016_result, LAYER_TYPE_L3, 1);
-    ASSERT_TRUE(complex_parser_ether(&_pkt_016_handler, pkt_16) != nullptr);
+    pkt_parser_exec(&_pkt_016_handler, mock_mbuf_ptr.get());
 
     struct pkt_parser_result * parser_result = &_pkt_016_result;
     EXPECT_EQ(parser_result->nr_layers, 1);
@@ -443,9 +460,10 @@ TEST(PacketParserOuterL3, EthernetOverMPLSWithPW)
 {
     struct pkt_parser _pkt_mpls_handler;
     struct pkt_parser_result _pkt_mpls_result;
-    pkt_parser_init(&_pkt_mpls_handler, &_pkt_mpls_result, LAYER_TYPE_L3, 1);
 
-    ASSERT_TRUE(complex_parser_ether(&_pkt_mpls_handler, pkt_mpls_pw) != nullptr);
+    auto mock_mbuf_ptr = mock_rte_mbuf_create((const char *)pkt_mpls_pw, sizeof(pkt_mpls_pw));
+    pkt_parser_init(&_pkt_mpls_handler, &_pkt_mpls_result, LAYER_TYPE_L3, 1);
+    pkt_parser_exec(&_pkt_mpls_handler, mock_mbuf_ptr.get());
 
     struct pkt_parser_result * parser_result = &_pkt_mpls_result;
     EXPECT_EQ(parser_result->nr_layers, 1);
@@ -463,8 +481,9 @@ TEST(PacketParserOuterL3, EthernetOverMPLSWithoutPW)
     struct pkt_parser _pkt_mpls_handler;
     struct pkt_parser_result _pkt_mpls_result;
 
+    auto mock_mbuf_ptr = mock_rte_mbuf_create((const char *)pkt_mpls_eth, sizeof(pkt_mpls_eth));
     pkt_parser_init(&_pkt_mpls_handler, &_pkt_mpls_result, LAYER_TYPE_L3, 1);
-    ASSERT_TRUE(complex_parser_ether(&_pkt_mpls_handler, pkt_mpls_eth) != nullptr);
+    pkt_parser_exec(&_pkt_mpls_handler, mock_mbuf_ptr.get());
 
     struct pkt_parser_result * parser_result = &_pkt_mpls_result;
     EXPECT_EQ(parser_result->nr_layers, 1);
@@ -482,8 +501,9 @@ TEST(PacketParseOuterL4, EtherIPv4TCP)
     struct pkt_parser _pkt_031_handler;
     struct pkt_parser_result _pkt_031_result;
 
+    auto mock_mbuf_ptr = mock_rte_mbuf_create((const char *)pkt_031, sizeof(pkt_031));
     pkt_parser_init(&_pkt_031_handler, &_pkt_031_result, LAYER_TYPE_TCP, 1);
-    ASSERT_TRUE(complex_parser_ether(&_pkt_031_handler, pkt_031) != nullptr);
+    pkt_parser_exec(&_pkt_031_handler, mock_mbuf_ptr.get());
 
     struct pkt_parser_result * parser_result = &_pkt_031_result;
     EXPECT_EQ(parser_result->nr_layers, 1);
@@ -501,8 +521,9 @@ TEST(PacketParseOuterL4, EtherIPv4UDP)
     struct pkt_parser _pkt_30_handler;
     struct pkt_parser_result _pkt_30_result;
 
+    auto mock_mbuf_ptr = mock_rte_mbuf_create((const char *)pkt30, sizeof(pkt30));
     pkt_parser_init(&_pkt_30_handler, &_pkt_30_result, LAYER_TYPE_UDP, 1);
-    ASSERT_TRUE(complex_parser_ether(&_pkt_30_handler, pkt30) != nullptr);
+    pkt_parser_exec(&_pkt_30_handler, mock_mbuf_ptr.get());
 
     struct pkt_parser_result * parser_result = &_pkt_30_result;
     EXPECT_EQ(parser_result->nr_layers, 1);
@@ -520,8 +541,9 @@ TEST(PacketParseInnerL3, EtherIPv4UDPVxlanEther)
 	struct pkt_parser _pkt_73_handler;
     struct pkt_parser_result _pkt_73_result;
 
+    auto mock_mbuf_ptr = mock_rte_mbuf_create((const char *)pkt73, sizeof(pkt73));
     pkt_parser_init(&_pkt_73_handler, &_pkt_73_result, LAYER_TYPE_L3, 2);
-	ASSERT_TRUE(complex_parser_ether(&_pkt_73_handler, pkt73) != nullptr);
+    pkt_parser_exec(&_pkt_73_handler, mock_mbuf_ptr.get());
 
     struct pkt_parser_result * parser_result = &_pkt_73_result;
     EXPECT_EQ(parser_result->nr_layers, 2);
@@ -548,8 +570,9 @@ TEST(PacketParseInnerL4, EtherIPv4UDPVxlanEther)
 	struct pkt_parser _pkt_73_handler;
     struct pkt_parser_result _pkt_73_result;
 
+    auto mock_mbuf_ptr = mock_rte_mbuf_create((const char *)pkt73, sizeof(pkt73));
     pkt_parser_init(&_pkt_73_handler, &_pkt_73_result, LAYER_TYPE_L4, 2);
-	ASSERT_TRUE(complex_parser_ether(&_pkt_73_handler, pkt73) != nullptr);
+    pkt_parser_exec(&_pkt_73_handler, mock_mbuf_ptr.get());
 
     struct pkt_parser_result * parser_result = &_pkt_73_result;
     EXPECT_EQ(parser_result->nr_layers, 2);
@@ -576,8 +599,9 @@ TEST(PacketParseInnerL3, EtherIPv4UDPVxlanCHDLC)
     struct pkt_parser _pkt_47_handler;
     struct pkt_parser_result _pkt_47_result;
 
+    auto mock_mbuf_ptr = mock_rte_mbuf_create((const char *)pkt47, sizeof(pkt47));
     pkt_parser_init(&_pkt_47_handler, &_pkt_47_result, LAYER_TYPE_L3, 2);
-    ASSERT_TRUE(complex_parser_ether(&_pkt_47_handler, pkt47) != nullptr);
+    pkt_parser_exec(&_pkt_47_handler, mock_mbuf_ptr.get());
 
     struct pkt_parser_result * parser_result = &_pkt_47_result;
     EXPECT_EQ(parser_result->nr_layers, 2);
@@ -604,8 +628,9 @@ TEST(PacketParserInnerL4, EtherIPv4UDPVxlanCHDLC)
     struct pkt_parser _pkt_47_handler;
     struct pkt_parser_result _pkt_47_result;
 
+    auto mock_mbuf_ptr = mock_rte_mbuf_create((const char *)pkt47, sizeof(pkt47));
     pkt_parser_init(&_pkt_47_handler, &_pkt_47_result, LAYER_TYPE_L4, 2);
-    ASSERT_TRUE(complex_parser_ether(&_pkt_47_handler, pkt47) != nullptr);
+    pkt_parser_exec(&_pkt_47_handler, mock_mbuf_ptr.get());
 
     struct pkt_parser_result * parser_result = &_pkt_47_result;
     EXPECT_EQ(parser_result->nr_layers, 2);
@@ -632,8 +657,9 @@ TEST(PacketParseInnerL3, EtherIPv4UDPVxlanPPP)
     struct pkt_parser _pkt_94_handler;
     struct pkt_parser_result _pkt_94_result;
 
+    auto mock_mbuf_ptr = mock_rte_mbuf_create((const char *)pkt94, sizeof(pkt94));
     pkt_parser_init(&_pkt_94_handler, &_pkt_94_result, LAYER_TYPE_L3, 2);
-    ASSERT_TRUE(complex_parser_ether(&_pkt_94_handler, pkt94) != nullptr);
+    pkt_parser_exec(&_pkt_94_handler, mock_mbuf_ptr.get());
 
     struct pkt_parser_result * parser_result = &_pkt_94_result;
     EXPECT_EQ(parser_result->nr_layers, 2);
@@ -660,8 +686,9 @@ TEST(PacketParserInnerL4, EtherIPv4UDPVxlanPPP)
     struct pkt_parser _pkt_94_handler;
     struct pkt_parser_result _pkt_94_result;
 
+    auto mock_mbuf_ptr = mock_rte_mbuf_create((const char *)pkt94, sizeof(pkt94));
     pkt_parser_init(&_pkt_94_handler, &_pkt_94_result, LAYER_TYPE_L4, 2);
-    ASSERT_TRUE(complex_parser_ether(&_pkt_94_handler, pkt94) != nullptr);
+    pkt_parser_exec(&_pkt_94_handler, mock_mbuf_ptr.get());
 
     struct pkt_parser_result * parser_result = &_pkt_94_result;
     EXPECT_EQ(parser_result->nr_layers, 2);
@@ -712,8 +739,9 @@ TEST(PacketParseInnerL3, EtherIPv4UDPGTPv1)
 	struct pkt_parser _pkt_83_handler;
     struct pkt_parser_result _pkt_83_result;
 
+    auto mock_mbuf_ptr = mock_rte_mbuf_create((const char *)pkt83, sizeof(pkt83));
     pkt_parser_init(&_pkt_83_handler, &_pkt_83_result, LAYER_TYPE_L3, 2);
-	ASSERT_TRUE(complex_parser_ether(&_pkt_83_handler, pkt83) != nullptr);
+    pkt_parser_exec(&_pkt_83_handler, mock_mbuf_ptr.get());
 
     struct pkt_parser_result * parser_result = &_pkt_83_result;
     EXPECT_EQ(parser_result->nr_layers, 2);
@@ -740,8 +768,9 @@ TEST(PacketParseInnerL3, EtherIPv6UDPGTPv1EXTIPv4)
     struct pkt_parser _pkt_gtp_u_ext_v6_v4_handler;
     struct pkt_parser_result _pkt_gtp_u_ext_v6_v4_result;
 
+    auto mock_mbuf_ptr = mock_rte_mbuf_create((const char *)pkt_gtp_u_ext_v6_v4, sizeof(pkt_gtp_u_ext_v6_v4));
     pkt_parser_init(&_pkt_gtp_u_ext_v6_v4_handler, &_pkt_gtp_u_ext_v6_v4_result, LAYER_TYPE_L3, 2);
-    ASSERT_TRUE(complex_parser_ether(&_pkt_gtp_u_ext_v6_v4_handler, pkt_gtp_u_ext_v6_v4) != nullptr);
+    pkt_parser_exec(&_pkt_gtp_u_ext_v6_v4_handler, mock_mbuf_ptr.get());
 
     struct pkt_parser_result * parser_result = &_pkt_gtp_u_ext_v6_v4_result;
     EXPECT_EQ(parser_result->nr_layers, 2);
@@ -768,8 +797,9 @@ TEST(PacketParseInnerL3, EtherIPv6UDPGTPv1EXTIPv6)
     struct pkt_parser _pkt_gtp_u_ext_v6_v6_handler;
     struct pkt_parser_result _pkt_gtp_u_ext_v6_v6_result;
 
+    auto mock_mbuf_ptr = mock_rte_mbuf_create((const char *)pkt_gtp_u_ext_v6_v6, sizeof(pkt_gtp_u_ext_v6_v6));
     pkt_parser_init(&_pkt_gtp_u_ext_v6_v6_handler, &_pkt_gtp_u_ext_v6_v6_result, LAYER_TYPE_L3, 2);
-    ASSERT_TRUE(complex_parser_ether(&_pkt_gtp_u_ext_v6_v6_handler, pkt_gtp_u_ext_v6_v6) != nullptr);
+    pkt_parser_exec(&_pkt_gtp_u_ext_v6_v6_handler, mock_mbuf_ptr.get());
 
     struct pkt_parser_result * parser_result = &_pkt_gtp_u_ext_v6_v6_result;
     EXPECT_EQ(parser_result->nr_layers, 2);
@@ -854,8 +884,9 @@ TEST(PacketParseOuterL3, EtherVxlanGTPIPv4TCP)
     struct pkt_parser _pkt_gtp_u_over_vxlan_tls_1_handler;
     struct pkt_parser_result _pkt_gtp_u_over_vxlan_tls_1_result;
 
+    auto mock_mbuf_ptr = mock_rte_mbuf_create((const char *)_pkt_gtp_u_over_vxlan_tls_1, sizeof(_pkt_gtp_u_over_vxlan_tls_1));
     pkt_parser_init(&_pkt_gtp_u_over_vxlan_tls_1_handler, &_pkt_gtp_u_over_vxlan_tls_1_result, LAYER_TYPE_L3, 1);
-    complex_parser_ether(&_pkt_gtp_u_over_vxlan_tls_1_handler, _pkt_gtp_u_over_vxlan_tls_1);
+    pkt_parser_exec(&_pkt_gtp_u_over_vxlan_tls_1_handler, mock_mbuf_ptr.get());
 
     struct pkt_parser_result * parser_result = &_pkt_gtp_u_over_vxlan_tls_1_result;
     EXPECT_EQ(parser_result->nr_layers, 1);
@@ -873,8 +904,9 @@ TEST(PacketParseInnerL3, EtherVxlanGTPIPv4TCP)
     struct pkt_parser _pkt_gtp_u_over_vxlan_tls_1_handler;
     struct pkt_parser_result _pkt_gtp_u_over_vxlan_tls_1_result;
 
+    auto mock_mbuf_ptr = mock_rte_mbuf_create((const char *)_pkt_gtp_u_over_vxlan_tls_1, sizeof(_pkt_gtp_u_over_vxlan_tls_1));
     pkt_parser_init(&_pkt_gtp_u_over_vxlan_tls_1_handler, &_pkt_gtp_u_over_vxlan_tls_1_result, LAYER_TYPE_L3, 4);
-    complex_parser_ether(&_pkt_gtp_u_over_vxlan_tls_1_handler, _pkt_gtp_u_over_vxlan_tls_1);
+    pkt_parser_exec(&_pkt_gtp_u_over_vxlan_tls_1_handler, mock_mbuf_ptr.get());
 
     struct pkt_parser_result * parser_result = &_pkt_gtp_u_over_vxlan_tls_1_result;
     EXPECT_EQ(parser_result->nr_layers, 3);
@@ -1049,8 +1081,9 @@ TEST(PacketParseOuterL3, EtherIPv4GREIPv4)
     struct pkt_parser _pkt_eth_ipv4_gre_1_handler;
     struct pkt_parser_result _pkt_eth_ipv4_gre_1_result;
 
+    auto mock_mbuf_ptr = mock_rte_mbuf_create((const char *)_dns_over_gre_1, sizeof(_dns_over_gre_1));
     pkt_parser_init(&_pkt_eth_ipv4_gre_1_handler, &_pkt_eth_ipv4_gre_1_result, LAYER_TYPE_L3, 1);
-    complex_parser_ether(&_pkt_eth_ipv4_gre_1_handler, _dns_over_gre_1);
+    pkt_parser_exec(&_pkt_eth_ipv4_gre_1_handler, mock_mbuf_ptr.get());
 
     struct pkt_parser_result * parser_result = &_pkt_eth_ipv4_gre_1_result;
     EXPECT_EQ(parser_result->nr_layers, 1);
@@ -1068,8 +1101,9 @@ TEST(PacketParseInnerL3, EtherIPv4GREIPv4)
     struct pkt_parser _pkt_eth_ipv4_gre_1_handler;
     struct pkt_parser_result _pkt_eth_ipv4_gre_1_result;
 
+    auto mock_mbuf_ptr = mock_rte_mbuf_create((const char *)_dns_over_gre_1, sizeof(_dns_over_gre_1));
     pkt_parser_init(&_pkt_eth_ipv4_gre_1_handler, &_pkt_eth_ipv4_gre_1_result, LAYER_TYPE_L3, 4);
-    complex_parser_ether(&_pkt_eth_ipv4_gre_1_handler, _dns_over_gre_1);
+    pkt_parser_exec(&_pkt_eth_ipv4_gre_1_handler, mock_mbuf_ptr.get());
 
     struct pkt_parser_result * parser_result = &_pkt_eth_ipv4_gre_1_result;
     EXPECT_EQ(parser_result->nr_layers, 2);
@@ -1292,8 +1326,9 @@ TEST(PacketParseOuterL3, EtherIPv4GREIPv4Frag)
     struct pkt_parser _pkt_eth_ipv4_gre_ipv4_frag_1_handler;
     struct pkt_parser_result _pkt_eth_ipv4_gre_ipv4_frag_1_result;
 
+    auto mock_mbuf_ptr = mock_rte_mbuf_create((const char *)_ip_frag_over_gre, sizeof(_ip_frag_over_gre));
     pkt_parser_init(&_pkt_eth_ipv4_gre_ipv4_frag_1_handler, &_pkt_eth_ipv4_gre_ipv4_frag_1_result, LAYER_TYPE_L3, 1);
-    complex_parser_ether(&_pkt_eth_ipv4_gre_ipv4_frag_1_handler, _ip_frag_over_gre);
+    pkt_parser_exec(&_pkt_eth_ipv4_gre_ipv4_frag_1_handler, mock_mbuf_ptr.get());
 
     struct pkt_parser_result * parser_result = &_pkt_eth_ipv4_gre_ipv4_frag_1_result;
     EXPECT_EQ(parser_result->nr_layers, 1);
@@ -1311,8 +1346,9 @@ TEST(PacketParseInnerL3, EtherIPv4GREIPv4Frag)
     struct pkt_parser _pkt_eth_ipv4_gre_ipv4_frag_1_handler;
     struct pkt_parser_result _pkt_eth_ipv4_gre_ipv4_frag_1_result;
 
+    auto mock_mbuf_ptr = mock_rte_mbuf_create((const char *)_ip_frag_over_gre, sizeof(_ip_frag_over_gre));
     pkt_parser_init(&_pkt_eth_ipv4_gre_ipv4_frag_1_handler, &_pkt_eth_ipv4_gre_ipv4_frag_1_result, LAYER_TYPE_L3, 4);
-    complex_parser_ether(&_pkt_eth_ipv4_gre_ipv4_frag_1_handler, _ip_frag_over_gre);
+    pkt_parser_exec(&_pkt_eth_ipv4_gre_ipv4_frag_1_handler, mock_mbuf_ptr.get());
 
     struct pkt_parser_result * parser_result = &_pkt_eth_ipv4_gre_ipv4_frag_1_result;
     EXPECT_EQ(parser_result->nr_layers, 2);
diff --git a/service/src/node_health_check.c b/service/src/node_health_check.c
index a677575..70b6a15 100644
--- a/service/src/node_health_check.c
+++ b/service/src/node_health_check.c
@@ -239,7 +239,7 @@ int private_ask_func(struct health_check_main * _health_check_main, struct healt
 
     struct pkt_parser pkt_parser;
     pkt_parser_init(&pkt_parser, &private_ctrlzone->pkt_parser_result, LAYER_TYPE_ALL, MR_PKT_PARSER_LAYERS_MAX);
-    complex_parser_ether(&pkt_parser, rte_pktmbuf_mtod(mbuf, const char *));
+    pkt_parser_exec(&pkt_parser, mbuf);
 
     /* Fill mbuf */
     pkts[mbuf_index] = mbuf;
diff --git a/service/src/node_phydev.c b/service/src/node_phydev.c
index db038b2..7706252 100644
--- a/service/src/node_phydev.c
+++ b/service/src/node_phydev.c
@@ -281,7 +281,7 @@ static __rte_always_inline uint16_t dpdk_dev_rx_node_process(struct rte_graph *
         /* Parser Pkt */
         struct pkt_parser pkt_parser;
         pkt_parser_init(&pkt_parser, &mrb_meta->pkt_parser_result, LAYER_TYPE_ALL, MR_PKT_PARSER_LAYERS_MAX);
-        complex_parser_ether(&pkt_parser, rte_pktmbuf_mtod(mbuf, const char *));
+        pkt_parser_exec(&pkt_parser, mbuf);
 
         parser_results[i] = &mrb_meta->pkt_parser_result;
 
diff --git a/service/src/node_shmdev.c b/service/src/node_shmdev.c
index fa1e996..434922e 100644
--- a/service/src/node_shmdev.c
+++ b/service/src/node_shmdev.c
@@ -99,7 +99,7 @@ uint16_t shmdev_rx_node_process(struct rte_graph * graph, struct rte_node * node
             pkt_parser_init(&pkt_parser, &mrb_meta->pkt_parser_result, LAYER_TYPE_ALL, MR_PKT_PARSER_LAYERS_MAX);
 
             /* parse the packet, and copy the result to the private zone */
-            complex_parser_ether(&pkt_parser, rte_pktmbuf_mtod(mbuf0, const char *));
+            pkt_parser_exec(&pkt_parser, mbuf0);
             mbuf_alloc_at_nf++;
         }