path: root/service/src/node_classifier.c

#include <MESA_prof_load.h>
#include <cJSON.h>
#include <common.h>
#include <ldbc.h>
#include <mrb_define.h>
#include <netinet/in.h>
#include <rpc.h>
#include <rte_acl.h>
#include <rte_graph.h>
#include <rte_graph_worker.h>
#include <rte_rcu_qsbr.h>
#include <sc_common.h>
#include <sc_node.h>
#include <sc_node_common.h>
#include <sc_vdev.h>
#include <stdio.h>
#include <sys/socket.h>

#define MR_CLASSIFIER_IPV4_TABLE_NAME_A "ipv4-table-a"
#define MR_CLASSIFIER_IPV4_TABLE_NAME_B "ipv4-table-b"
#define MR_CLASSIFIER_IPV6_TABLE_NAME_A "ipv6-table-a"
#define MR_CLASSIFIER_IPV6_TABLE_NAME_B "ipv6-table-b"
#define MR_CLASSIFIER_MAX_CATEGORIES 16
#define MR_CLASSIFIER_DEFAULT_SOCKET_ID 0
#define MR_CLASSIFIER_RULE_INVALID_FLAG 0
#define MR_CLASSIFIER_DEFAULT_STR_IP_ADDR_V4 "0.0.0.0"
#define MR_CLASSIFIER_DEFAULT_STR_IP_ADDR_V6 "::"
#define MR_CLASSIFIER_DEFAULT_IP_ADDR_V4 0
#define MR_CLASSIFIER_DEFAULT_IP_MASK_0 0
#define MR_CLASSIFIER_DEFAULT_IP_MASK_32 32
#define MR_CLASSIFIER_DEFAULT_IP_MASK_128 128
#define MR_CLASSIFIER_DEFAULT_PORT_START 0
#define MR_CLASSIFIER_DEFAULT_PORT_END 65535
#define MR_CLASSIFIER_DEFAULT_PROTO "any"
#define MR_CLASSIFIER_DEFAULT_PROTO_ANY 0
#define MR_CLASSIFIER_DEFAULT_PRIORITY RTE_ACL_MAX_PRIORITY
#define MR_CLASSIFIER_MIN_PRIORITY 1
#define MR_CLASSIFIER_DEFAULT_SI_MASK 0xffff
#define MR_CLASSIFIER_DEFAULT_IP_VERSION_MASK 0xffff
#define MR_CLASSIFIER_IP_VERSION_ANY_MASK 0x0000
#define MR_CLASSIFIER_IPV6_MASK 32
#define MR_CLASSIFIER_MAX_PORT 65535
#define MR_CLASSIFIER_MAX_PKT_BURST 4       // Multiple packet process num
#define MR_CLASSIFIER_RULE_ID_INVALID_NUM 1 // The valid classifier rule id start from 0
#define MR_CLASSIFIER_START_RULE_ID 1
#define SINGLE_TABLE_MAX_RULE_NUM 1024
#define MAX_RULE_NUM SINGLE_TABLE_MAX_RULE_NUM * 2
#define SINGLE_TABLE_MAX_RULE_ITEM_NUM                                                                                 \
    (SINGLE_TABLE_MAX_RULE_NUM + MR_CLASSIFIER_RULE_ID_INVALID_NUM) // id 0 is invalid

/* Dynamic classifier rule result */
#define MR_CLASSIFIER_RPC_RESULT "Result"
#define MR_CLASSIFIER_ERR_RULE_ID "ErrRuleId"
#define MR_CLASSIFIER_ERR_REASON "ErrReason"

/* Dynamic classifier rule field */
#define MR_CLASSIFIER_CJSON_KEY_RULE_ARRAY "RuleArray"
#define MR_CLASSIFIER_CJSON_KEY_RULE_ID "RuleId"
#define MR_CLASSIFIER_CJSON_KEY_SRC_IP_V4 "SrcIpV4"
#define MR_CLASSIFIER_CJSON_KEY_SRC_IP_V6 "SrcIpV6"
#define MR_CLASSIFIER_CJSON_KEY_SRC_IP_MASK "SrcIpMask"
#define MR_CLASSIFIER_CJSON_KEY_DST_IP_V4 "DstIpV4"
#define MR_CLASSIFIER_CJSON_KEY_DST_IP_V6 "DstIpV6"
#define MR_CLASSIFIER_CJSON_KEY_DST_IP_MASK "DstIpMask"
#define MR_CLASSIFIER_CJSON_KEY_SRC_PORT_LOW "SrcPortLow"
#define MR_CLASSIFIER_CJSON_KEY_SRC_PORT_HIGH "SrcPortHigh"
#define MR_CLASSIFIER_CJSON_KEY_DST_PORT_LOW "DstPortLow"
#define MR_CLASSIFIER_CJSON_KEY_DST_PORT_HIGH "DstPortHigh"
#define MR_CLASSIFIER_CJSON_KEY_PROTO "Proto"
#define MR_CLASSIFIER_CJSON_KEY_PRIORITY "Priority"
#define MR_CLASSIFIER_CJSON_KEY_CATEGORY "Category"
#define MR_CLASSIFIER_CJSON_KEY_SID "Sid"
#define MR_CLASSIFIER_CJSON_KEY_VWIRE_ID "VwireId"
#define MR_CLASSIFIER_CJSON_KEY_EF_ID "EfId"

#define CLASSIFIER_STAT_ADD(st, graph_id, counter, value)                                                              \
    do                                                                                                                 \
    {                                                                                                                  \
        st->stat_per_graph[graph_id].counter += value;                                                                 \
    } while (0)

#define CLASSIFIER_STAT_ADD_FOR_ID(st, graph_id, item_id, rule_id, value)                                              \
    do                                                                                                                 \
    {                                                                                                                  \
        st->stat_per_graph[graph_id].hits_pkts_for_rule_id.hits_pkts_for_item_id[item_id] += value;                    \
        st->stat_per_graph[graph_id].hits_pkts_for_rule_id.item_id_to_rule_id[item_id] = rule_id;                      \
    } while (0)

/* Table name flag */
enum
{
    CLASSIFIER_TABLE_A,
    CLASSIFIER_TABLE_B
};

/* Table type */
enum
{
    CLASSIFIER_TABLE_TYPE_V4 = 0,
    CLASSIFIER_TABLE_TYPE_V6,
    CLASSIFIER_TABLE_TYPE_MAX
};

/* Table adapter type */
enum
{
    CLASSIFIER_TABLE_ADAPTER_EF = 0,
    CLASSIFIER_TABLE_ADAPTER_VWIRE,
    CLASSIFIER_TABLE_ADAPTER_ALL
};

/* IPv4 field index enum */
enum
{
    CLASSIFIER_IPV4_FIELD_PROTO,
    CLASSIFIER_IPV4_FIELD_SRC_IP,
    CLASSIFIER_IPV4_FIELD_DST_IP,
    CLASSIFIER_IPV4_FIELD_SRC_PORT,
    CLASSIFIER_IPV4_FIELD_DST_PORT,
    CLASSIFIER_IPV4_FIELD_NUM
};

/* IPv6 field index enum */
enum
{
    CLASSIFIER_IPV6_FIELD_PROTO,
    CLASSIFIER_IPV6_FIELD_SRC_IP_1,
    CLASSIFIER_IPV6_FIELD_SRC_IP_2,
    CLASSIFIER_IPV6_FIELD_SRC_IP_3,
    CLASSIFIER_IPV6_FIELD_SRC_IP_4,
    CLASSIFIER_IPV6_FIELD_DST_IP_1,
    CLASSIFIER_IPV6_FIELD_DST_IP_2,
    CLASSIFIER_IPV6_FIELD_DST_IP_3,
    CLASSIFIER_IPV6_FIELD_DST_IP_4,
    CLASSIFIER_IPV6_FIELD_SRC_PORT,
    CLASSIFIER_IPV6_FIELD_DST_PORT,
    CLASSIFIER_IPV6_FIELD_NUM
};

/* Input index（group） enum for ipv4 */
enum
{
    CLASSIFIER_IPV4_GROUP_PROTO,
    CLASSIFIER_IPV4_GROUP_SRC_IP,
    CLASSIFIER_IPV4_GROUP_DST_IP,
    CLASSIFIER_IPV4_GROUP_PORTS,
    CLASSIFIER_IPV4_GROUP_NUM
};

/* Input index（group） enum for ipv6 */
enum
{
    CLASSIFIER_IPV6_GROUP_PROTO,
    CLASSIFIER_IPV6_GROUP_SRC_IP_1,
    CLASSIFIER_IPV6_GROUP_SRC_IP_2,
    CLASSIFIER_IPV6_GROUP_SRC_IP_3,
    CLASSIFIER_IPV6_GROUP_SRC_IP_4,
    CLASSIFIER_IPV6_GROUP_DST_IP_1,
    CLASSIFIER_IPV6_GROUP_DST_IP_2,
    CLASSIFIER_IPV6_GROUP_DST_IP_3,
    CLASSIFIER_IPV6_GROUP_DST_IP_4,
    CLASSIFIER_IPV6_GROUP_PORTS,
    CLASSIFIER_IPV6_GROUP_NUM
};

/* Classifier next node */
enum
{
    CLASSIFIER_NEXT_FORWARDER = 0,
    CLASSIFIER_NEXT_PKT_DROP,
    CLASSIFIER_NEXT_MAX
};

/* Dynamic classifier rule add deal result */
enum
{
    CLASSIFIER_RULE_ADD_SUCCESS = 0,
    CLASSIFIER_RULE_ADD_SRC_IP_INVALID_V4,
    CLASSIFIER_RULE_ADD_SRC_IP_MASK_INVALID_V4,
    CLASSIFIER_RULE_ADD_DST_IP_INVALID_V4,
    CLASSIFIER_RULE_ADD_DST_IP_MASK_INVALID_V4,
    CLASSIFIER_RULE_ADD_SRC_IP_INVALID_V6,
    CLASSIFIER_RULE_ADD_SRC_IP_MASK_INVALID_V6,
    CLASSIFIER_RULE_ADD_DST_IP_INVALID_V6,
    CLASSIFIER_RULE_ADD_DST_IP_MASK_INVALID_V6,
    CLASSIFIER_RULE_ADD_SRC_PORT_RANGE_START_INVALID,
    CLASSIFIER_RULE_ADD_SRC_PORT_RANGE_END_INVALID,
    CLASSIFIER_RULE_ADD_SRC_PORT_RANGE_START_THAN_END,
    CLASSIFIER_RULE_ADD_DST_PORT_RANGE_START_INVALID,
    CLASSIFIER_RULE_ADD_DST_PORT_RANGE_END_INVALID,
    CLASSIFIER_RULE_ADD_DST_PORT_RANGE_START_THAN_END,
    CLASSIFIER_RULE_ADD_PROTO_INVALID,
    CLASSIFIER_RULE_ADD_PRIORITY_INVALID,
    CLASSIFIER_RULE_ADD_CATEGORY_INVALID,
    CLASSIFIER_RULE_ADD_SID_INVALID,
    CLASSIFIER_RULE_ADD_RULE_ID_INVALID,
    CLASSIFIER_RULE_ADD_IPV4_IPV6_REPEAT,
    CLASSIFIER_RULE_ADD_ERR_RULE_ARRAY_IS_NULL,
    CLASSIFIER_RULE_ADD_ERR_CLASSIFIER_SETUP_ERR,
    CLASSIFIER_RULE_ADD_ERR_LOCAL_RULE_ERR,
    CLASSIFIER_RULE_ADD_ERR_TABLE_IS_NULL,
    CLASSIFIER_RULE_ADD_ERR_NO_FREE_RULE_ITEM_V4,
    CLASSIFIER_RULE_ADD_ERR_NO_FREE_RULE_ITEM_V6,
    CLASSIFIER_RULE_ADD_ERR_ALREADY_EXISTS_V4,
    CLASSIFIER_RULE_ADD_ERR_ALREADY_EXISTS_V6,
    CLASSIFIER_RULE_ADD_ERR_VWIRE_AND_EF_ID_CONFICT,
    CLASSIFIER_RULE_ADD_ERR_EF_ID_INVALID,
    CLASSIFIER_RULE_ADD_ERR_VWIRE_ID_INVALID,
};

/* Rule parse */
struct rule_parse
{
    uint8_t proto;
    uint8_t proto_mask;
    uint8_t adapter_type;
    uint16_t category;
    uint16_t ip_version;
    uint16_t src_port_range_start;
    uint16_t src_port_range_end;
    uint16_t dst_port_range_start;
    uint16_t dst_port_range_end;
    uint32_t sid;
    uint32_t priority;
    uint32_t rule_id;
    uint32_t src_ip_mask_v4;
    uint32_t dst_ip_mask_v4;
    uint32_t src_ip_mask_v6;
    uint32_t dst_ip_mask_v6;
    struct in_addr src_ip_addr_v4;
    struct in_addr dst_ip_addr_v4;
    uint32_t src_ip_addr_v6[4];
    uint32_t dst_ip_addr_v6[4];
    uint32_t adapter_id;
};

/* Match field for ipv4 */
struct match_field_v4
{
    /* Public match field */
    uint8_t next_proto_id;
    uint16_t src_port;
    uint16_t dst_port;
    /* IPv4 match field */
    uint32_t src_addr_ipv4;
    uint32_t dst_addr_ipv4;
};

/* Match field for ipv6 */
struct match_field_v6
{
    /* Public match field */
    uint8_t next_proto_id;
    uint16_t src_port;
    uint16_t dst_port;

    /* IPv6 match field */
    union {
        uint8_t u8_src_addr_ipv6[16];
        uint32_t u32_src_addr_ipv6[4];
    };
    union {
        uint8_t u8_dst_addr_ipv6[16];
        uint32_t u32_dst_addr_ipv6[4];
    };
};

/* Def struct for ipv4 classifier field */
struct rte_acl_field_def classifier_defs_v4[CLASSIFIER_IPV4_FIELD_NUM] = {
    {
        .type = RTE_ACL_FIELD_TYPE_BITMASK,
        .size = sizeof(uint8_t),
        .field_index = CLASSIFIER_IPV4_FIELD_PROTO,
        .input_index = CLASSIFIER_IPV4_GROUP_PROTO,
        .offset = offsetof(struct match_field_v4, next_proto_id),
    },
    {
        .type = RTE_ACL_FIELD_TYPE_MASK,
        .size = sizeof(uint32_t),
        .field_index = CLASSIFIER_IPV4_FIELD_SRC_IP,
        .input_index = CLASSIFIER_IPV4_GROUP_SRC_IP,
        .offset = offsetof(struct match_field_v4, src_addr_ipv4),
    },
    {
        .type = RTE_ACL_FIELD_TYPE_MASK,
        .size = sizeof(uint32_t),
        .field_index = CLASSIFIER_IPV4_FIELD_DST_IP,
        .input_index = CLASSIFIER_IPV4_GROUP_DST_IP,
        .offset = offsetof(struct match_field_v4, dst_addr_ipv4),
    },
    {
        .type = RTE_ACL_FIELD_TYPE_RANGE,
        .size = sizeof(uint16_t),
        .field_index = CLASSIFIER_IPV4_FIELD_SRC_PORT,
        .input_index = CLASSIFIER_IPV4_GROUP_PORTS,
        .offset = offsetof(struct match_field_v4, src_port),
    },
    {
        .type = RTE_ACL_FIELD_TYPE_RANGE,
        .size = sizeof(uint16_t),
        .field_index = CLASSIFIER_IPV4_FIELD_DST_PORT,
        .input_index = CLASSIFIER_IPV4_GROUP_PORTS,
        .offset = offsetof(struct match_field_v4, dst_port),
    },
};

/* Define struct classifier_rule_v4  */
RTE_ACL_RULE_DEF(classifier_rule_v4, RTE_DIM(classifier_defs_v4));

/* Def struct for ipv6 classifier field */
struct rte_acl_field_def classifier_defs_v6[CLASSIFIER_IPV6_FIELD_NUM] = {
    {
        .type = RTE_ACL_FIELD_TYPE_BITMASK,
        .size = sizeof(uint8_t),
        .field_index = CLASSIFIER_IPV6_FIELD_PROTO,
        .input_index = CLASSIFIER_IPV6_GROUP_PROTO,
        .offset = offsetof(struct match_field_v6, next_proto_id),
    },
    {
        .type = RTE_ACL_FIELD_TYPE_MASK,
        .size = sizeof(uint32_t),
        .field_index = CLASSIFIER_IPV6_FIELD_SRC_IP_1,
        .input_index = CLASSIFIER_IPV6_GROUP_SRC_IP_1,
        .offset = offsetof(struct match_field_v6, u32_src_addr_ipv6[0]),
    },
    {
        .type = RTE_ACL_FIELD_TYPE_MASK,
        .size = sizeof(uint32_t),
        .field_index = CLASSIFIER_IPV6_FIELD_SRC_IP_2,
        .input_index = CLASSIFIER_IPV6_GROUP_SRC_IP_2,
        .offset = offsetof(struct match_field_v6, u32_src_addr_ipv6[1]),
    },
    {
        .type = RTE_ACL_FIELD_TYPE_MASK,
        .size = sizeof(uint32_t),
        .field_index = CLASSIFIER_IPV6_FIELD_SRC_IP_3,
        .input_index = CLASSIFIER_IPV6_GROUP_SRC_IP_3,
        .offset = offsetof(struct match_field_v6, u32_src_addr_ipv6[2]),
    },
    {
        .type = RTE_ACL_FIELD_TYPE_MASK,
        .size = sizeof(uint32_t),
        .field_index = CLASSIFIER_IPV6_FIELD_SRC_IP_4,
        .input_index = CLASSIFIER_IPV6_GROUP_SRC_IP_4,
        .offset = offsetof(struct match_field_v6, u32_src_addr_ipv6[3]),
    },
    {
        .type = RTE_ACL_FIELD_TYPE_MASK,
        .size = sizeof(uint32_t),
        .field_index = CLASSIFIER_IPV6_FIELD_DST_IP_1,
        .input_index = CLASSIFIER_IPV6_GROUP_DST_IP_1,
        .offset = offsetof(struct match_field_v6, u32_dst_addr_ipv6[0]),
    },
    {
        .type = RTE_ACL_FIELD_TYPE_MASK,
        .size = sizeof(uint32_t),
        .field_index = CLASSIFIER_IPV6_FIELD_DST_IP_2,
        .input_index = CLASSIFIER_IPV6_GROUP_DST_IP_2,
        .offset = offsetof(struct match_field_v6, u32_dst_addr_ipv6[1]),
    },
    {
        .type = RTE_ACL_FIELD_TYPE_MASK,
        .size = sizeof(uint32_t),
        .field_index = CLASSIFIER_IPV6_FIELD_DST_IP_3,
        .input_index = CLASSIFIER_IPV6_GROUP_DST_IP_3,
        .offset = offsetof(struct match_field_v6, u32_dst_addr_ipv6[2]),
    },
    {
        .type = RTE_ACL_FIELD_TYPE_MASK,
        .size = sizeof(uint32_t),
        .field_index = CLASSIFIER_IPV6_FIELD_DST_IP_4,
        .input_index = CLASSIFIER_IPV6_GROUP_DST_IP_4,
        .offset = offsetof(struct match_field_v6, u32_dst_addr_ipv6[3]),
    },
    {
        .type = RTE_ACL_FIELD_TYPE_RANGE,
        .size = sizeof(uint16_t),
        .field_index = CLASSIFIER_IPV6_FIELD_SRC_PORT,
        .input_index = CLASSIFIER_IPV6_GROUP_PORTS,
        .offset = offsetof(struct match_field_v6, src_port),
    },
    {
        .type = RTE_ACL_FIELD_TYPE_RANGE,
        .size = sizeof(uint16_t),
        .field_index = CLASSIFIER_IPV6_FIELD_DST_PORT,
        .input_index = CLASSIFIER_IPV6_GROUP_PORTS,
        .offset = offsetof(struct match_field_v6, dst_port),
    },
};

/* Define struct classifier_rule  */
RTE_ACL_RULE_DEF(classifier_rule_v6, RTE_DIM(classifier_defs_v6));

/* Classifier stat */
struct classifier_stat
{
    volatile uint64_t deal_pkts;
    volatile uint64_t hits;
    volatile uint64_t miss;
    volatile uint64_t fast_match;
    volatile uint64_t append_sid_err;
} __rte_cache_aligned;

/* Classifier rule action */
struct classifier_action
{
    uint16_t sid;
    uint32_t rule_id;
};

/* Classifier table entity */
struct classifier_table_entity
{
    uint8_t type;
    uint16_t fast_match;
    uint16_t nr_rules;
    struct rte_acl_ctx * acx;
    union {
        struct classifier_rule_v4 classifier_rules_v4[SINGLE_TABLE_MAX_RULE_ITEM_NUM];
        struct classifier_rule_v6 classifier_rules_v6[SINGLE_TABLE_MAX_RULE_ITEM_NUM];
    };
    union {
        struct classifier_action classifier_action_v4[SINGLE_TABLE_MAX_RULE_ITEM_NUM];
        struct classifier_action classifier_action_v6[SINGLE_TABLE_MAX_RULE_ITEM_NUM];
    };
};

/* Classifier table */
struct classifier_table
{
    uint16_t fast_match;
    struct classifier_table_entity table[CLASSIFIER_TABLE_TYPE_MAX];
};

/* Classifier management struct */
struct classifier_management
{
    uint32_t nr_local_rules;
    uint32_t nr_remote_rules;
    uint32_t nr_ef_tables;
    uint32_t nr_vwire_tables;
    struct classifier_table ** __ef_table;
    struct classifier_table ** __vwire_table;
};

/* Classifier node main struct */
struct node_classifier_main
{
    struct rte_rcu_qsbr * qsv;                             /* Quiescent state variable */
    struct classifier_management * _classifier_management; /* Classifier management */
    struct classifier_stat stat_per_graph[RTE_MAX_LCORE];  /* Classifier stat */

    /* options */
    unsigned int ignore_all_icmp_pkts;
    unsigned int ignore_all_icmp6_pkts;
};

/* Global classifier main */
static struct node_classifier_main * g_classifier_main = NULL;
static uint8_t table_name_flg = CLASSIFIER_TABLE_A;
extern int sid_check(uint32_t sid);
int parser_classifier_rule_local(struct sc_main * sc, struct classifier_management * _classifier_management);

/************************************** Classifier Node **************************************/
/* Insert sid */
int insert_sid(struct mrb_metadata * mrb_metadata, uint8_t nr_insert_sid, uint16_t sids[])
{
    /* Check nr_sid */
    if (unlikely(nr_insert_sid > (MR_NODE_COMMON_MAX_SID_NUM - mrb_metadata->nr_sid)))
        return RT_ERR;

    memmove(mrb_metadata->sids + nr_insert_sid, mrb_metadata->sids,
            sizeof(mrb_metadata->sids[0]) * mrb_metadata->nr_sid);

    /* Insert sid */
    if (mrb_metadata->dir == 0)
        memcpy(mrb_metadata->sids, sids, sizeof(mrb_metadata->sids[0]) * nr_insert_sid);
    else
    {
        for (int index = 0; index < nr_insert_sid; index++)
            mrb_metadata->sids[index] = sids[nr_insert_sid - index - 1];
    }

    mrb_metadata->nr_sid += nr_insert_sid;
    return RT_SUCCESS;
}

uint16_t get_outer_pkt_type(struct pkt_parser_result * result, uint16_t * out_pkt_layers)
{
    for (int i = result->start_layers; i < result->nr_layers; i++)
    {
        struct pkt_layer_result * layer_result = &result->layers[i];
        if (layer_result->type_id == LAYER_TYPE_ID_IPV4)
        {
            *out_pkt_layers = i;
            return LAYER_TYPE_ID_IPV4;
        }
        else if (layer_result->type_id == LAYER_TYPE_ID_IPV6)
        {
            *out_pkt_layers = i;
            return LAYER_TYPE_ID_IPV6;
        }
    }
    return 0;
}

/* Prepare match field date for v4 */
void prepare_match_field_data_v4(struct pkt_parser_result * result, const char * mbuf_data, uint16_t pkt_start_layers,
                                 struct match_field_v4 * out_match_field)
{
    unsigned int match_field_addr_set = 0;
    unsigned int match_field_port_set = 0;

    for (unsigned int i = pkt_start_layers; i < result->nr_layers; i++)
    {
        struct pkt_layer_result * layer_result = &result->layers[i];
        if ((layer_result->type_id == LAYER_TYPE_ID_IPV4) && match_field_addr_set == 0)
        {
            struct rte_ipv4_hdr * ipv4_hdr = (struct rte_ipv4_hdr *)(RTE_PTR_ADD(mbuf_data, layer_result->offset));
            out_match_field->src_addr_ipv4 = ipv4_hdr->src_addr;
            out_match_field->dst_addr_ipv4 = ipv4_hdr->dst_addr;
            out_match_field->next_proto_id = ipv4_hdr->next_proto_id;
            match_field_addr_set = 1;
            continue;
        }
        else if ((layer_result->type_id == LAYER_TYPE_ID_UDP) && match_field_port_set == 0)
        {
            struct rte_udp_hdr * udp_hdr = (struct rte_udp_hdr *)(RTE_PTR_ADD(mbuf_data, layer_result->offset));
            out_match_field->src_port = udp_hdr->src_port;
            out_match_field->dst_port = udp_hdr->dst_port;
            match_field_port_set = 1;
            continue;
        }
        else if ((layer_result->type_id == LAYER_TYPE_ID_TCP) && match_field_port_set == 0)
        {
            struct rte_tcp_hdr * tcp_hdr = (struct rte_tcp_hdr *)(RTE_PTR_ADD(mbuf_data, layer_result->offset));
            out_match_field->src_port = tcp_hdr->src_port;
            out_match_field->dst_port = tcp_hdr->dst_port;
            match_field_port_set = 1;
            continue;
        }
    }
}

/* Prepare match field date for v6 */
void prepare_match_field_data_v6(struct pkt_parser_result * result, const char * mbuf_data, uint16_t pkt_start_layers,
                                 struct match_field_v6 * out_match_field)
{
    unsigned int match_field_addr_set = 0;
    unsigned int match_field_port_set = 0;

    for (unsigned int i = result->start_layers; i < result->nr_layers; i++)
    {
        struct pkt_layer_result * layer_result = &result->layers[i];
        if ((layer_result->type_id == LAYER_TYPE_ID_IPV6) && match_field_addr_set == 0)
        {
            struct rte_ipv6_hdr * ipv6_hdr = (struct rte_ipv6_hdr *)(RTE_PTR_ADD(mbuf_data, layer_result->offset));
            memcpy(out_match_field->u8_src_addr_ipv6, ipv6_hdr->src_addr, sizeof(out_match_field->u8_src_addr_ipv6));
            memcpy(out_match_field->u8_dst_addr_ipv6, ipv6_hdr->dst_addr, sizeof(out_match_field->u8_dst_addr_ipv6));
            out_match_field->next_proto_id = ipv6_hdr->proto;
            match_field_addr_set = 1;
            continue;
        }
        else if ((layer_result->type_id == LAYER_TYPE_ID_UDP) && match_field_port_set == 0)
        {
            struct rte_udp_hdr * udp_hdr = (struct rte_udp_hdr *)(RTE_PTR_ADD(mbuf_data, layer_result->offset));
            out_match_field->src_port = udp_hdr->src_port;
            out_match_field->dst_port = udp_hdr->dst_port;
            match_field_port_set = 1;
            continue;
        }
        else if ((layer_result->type_id == LAYER_TYPE_ID_TCP) && match_field_port_set == 0)
        {
            struct rte_tcp_hdr * tcp_hdr = (struct rte_tcp_hdr *)(RTE_PTR_ADD(mbuf_data, layer_result->offset));
            out_match_field->src_port = tcp_hdr->src_port;
            out_match_field->dst_port = tcp_hdr->dst_port;
            match_field_port_set = 1;
            continue;
        }
    }
}

uint8_t parser_results(struct classifier_action actions[], uint32_t res_array[], uint16_t out_sids[])
{
    uint8_t nr_sid = 0;

    /* Get sids */
    for (int index = 0; index < MR_CLASSIFIER_MAX_CATEGORIES; index++)
    {
        if (res_array[index] == 0)
            continue;
        out_sids[nr_sid] = actions[res_array[index]].sid;
        nr_sid++;
    }
    return nr_sid;
}

/* Classifier node process function */
static __rte_always_inline uint16_t classifier_node_process(struct rte_graph * graph, struct rte_node * node,
                                                            void ** objs, uint16_t cnt)
{
    struct rte_mbuf ** mbufs = (struct rte_mbuf **)objs;
    unsigned int n_left_from = cnt;

    /* Set rcu thread online */
    struct rte_rcu_qsbr * qsv = g_classifier_main->qsv;
    uint32_t lcore_id = rte_lcore_id();
    rte_rcu_qsbr_thread_online(qsv, lcore_id);

    /* Get classifier table */
    struct classifier_table ** __ef_table = g_classifier_main->_classifier_management->__ef_table;
    struct classifier_table ** __vwire_table = g_classifier_main->_classifier_management->__vwire_table;
    struct classifier_table * _classifier_table = NULL;

    /* No initialization is required */
    uint16_t pkt_start_layers;
    uint16_t sids[MR_CLASSIFIER_MAX_CATEGORIES];
    uint32_t res_array[MR_CLASSIFIER_MAX_CATEGORIES];
    /* Initialization is required */
    uint8_t nr_sid = 0;
    struct classifier_stat stat = {};
    uint8_t adapter_type = 0;
    uint16_t adapter_id = 0xffff;
    uint16_t fast_match = 0;

    /* Single packet processing */
    while (n_left_from > 0)
    {
        struct rte_mbuf * mbuf0 = mbufs[0];
        mbufs += 1;
        n_left_from -= 1;

        /* Match classifier rule table */
        struct mrb_metadata * mrb_metadata = mrbuf_cz_data(mbuf0, MR_NODE_CTRLZONE_ID);
        struct pkt_parser_result * _pkt_parser_result = &mrb_metadata->pkt_parser_result;

        if ((adapter_type != mrb_metadata->adapter_type) || (adapter_id != mrb_metadata->adapter_id))
        {
            switch (mrb_metadata->adapter_type)
            {
            case ADAPTER_TYPE_EF:
                adapter_type = ADAPTER_TYPE_EF;
                adapter_id = mrb_metadata->adapter_id;
                _classifier_table = __ef_table[mrb_metadata->adapter_id];
                fast_match = _classifier_table->fast_match;
                break;
            case ADAPTER_TYPE_VWIRE:
                adapter_type = ADAPTER_TYPE_VWIRE;
                adapter_id = mrb_metadata->adapter_id;
                _classifier_table = __vwire_table[mrb_metadata->adapter_id];
                fast_match = _classifier_table->fast_match;
                break;
            default:
                assert(0);
                break;
            }
        }

        /* all the ICMP packet, go direct to egress, not for nfs */
        if (g_classifier_main->ignore_all_icmp_pkts)
        {
            void * icmp_start = complex_layer_jump_to_outermost(_pkt_parser_result, rte_pktmbuf_mtod(mbuf0, void *),
                                                                LAYER_TYPE_ID_ICMP);

            if (unlikely(icmp_start != NULL))
            {
                nr_sid = 0;
                goto append_sid;
            }
        }

        if (g_classifier_main->ignore_all_icmp6_pkts)
        {
            void * icmp6_start = complex_layer_jump_to_outermost(_pkt_parser_result, rte_pktmbuf_mtod(mbuf0, void *),
                                                                 LAYER_TYPE_ID_ICMP6);

            if (unlikely(icmp6_start != NULL))
            {
                nr_sid = 0;
                goto append_sid;
            }
        }

        /* Fast match */
        if (likely(fast_match))
        {
            nr_sid = 1;
            sids[0] = fast_match;
            stat.fast_match++;
            goto append_sid;
        }

        /* Get pkt type
         * On May 26, 2023, it was discussed and decided that the current default match is the outer layer packet
         */
        uint16_t outer_pkt_type = get_outer_pkt_type(_pkt_parser_result, &pkt_start_layers);

        if (outer_pkt_type == LAYER_TYPE_ID_IPV4)
        {
            /* Get ipv4 table */
            struct classifier_table_entity * _table_v4 = &_classifier_table->table[CLASSIFIER_TABLE_TYPE_V4];

            /* Fast match */
            if (likely(_table_v4->fast_match))
            {
                nr_sid = 1;
                sids[0] = _table_v4->fast_match;
            }
            else
            {
                /* Check ACX and match classifier table */
                struct rte_acl_ctx * acx_v4 = _table_v4->acx;
                if (likely(acx_v4 != NULL))
                {
                    /* Prepare match field Date */
                    struct match_field_v4 match_field_item = {};
                    const char * mbuf_data = rte_pktmbuf_mtod(mbuf0, const char *);
                    prepare_match_field_data_v4(_pkt_parser_result, mbuf_data, pkt_start_layers, &match_field_item);

                    /* Match classifier table */
                    const uint8_t * match_field_array[MR_CLASSIFIER_MAX_PKT_BURST] = {0};
                    match_field_array[0] = (const uint8_t *)&match_field_item;
                    rte_acl_classify(acx_v4, match_field_array, res_array, 1, MR_CLASSIFIER_MAX_CATEGORIES);

                    /* Parser results */
                    nr_sid = parser_results(_table_v4->classifier_action_v4, res_array, sids);
                }
            }
        }
        else if (outer_pkt_type == LAYER_TYPE_ID_IPV6)
        {
            /* Get ipv6 table */
            struct classifier_table_entity * _table_v6 = &_classifier_table->table[CLASSIFIER_TABLE_TYPE_V6];

            /* Fast match */
            if (likely(_table_v6->fast_match))
            {
                nr_sid = 1;
                sids[0] = _table_v6->fast_match;
            }
            else
            {
                /* Check ACX and match classifier table */
                struct rte_acl_ctx * acx_v6 = _table_v6->acx;
                if (likely(acx_v6 != NULL))
                {
                    /* Prepare match field Date */
                    struct match_field_v6 match_field_item = {};
                    const char * mbuf_data = rte_pktmbuf_mtod(mbuf0, const char *);
                    prepare_match_field_data_v6(_pkt_parser_result, mbuf_data, pkt_start_layers, &match_field_item);

                    /* Match classifier table */
                    const uint8_t * match_field_array[MR_CLASSIFIER_MAX_PKT_BURST] = {0};
                    match_field_array[0] = (const uint8_t *)&match_field_item;
                    rte_acl_classify(acx_v6, match_field_array, res_array, 1, MR_CLASSIFIER_MAX_CATEGORIES);

                    /* Parser results */
                    nr_sid = parser_results(_table_v6->classifier_action_v6, res_array, sids);
                }
            }
        }

    append_sid:
        /* Checks whether a rule is matched  */
        if (likely(nr_sid != 0))
        {
            stat.hits++;
            /* Insert sid */
            if (unlikely(insert_sid(mrb_metadata, nr_sid, sids) == RT_ERR))
                stat.append_sid_err++;
        }
        else
        {
            stat.miss++;
        }
    }

    /* to next node  */
    rte_node_next_stream_move(graph, node, CLASSIFIER_NEXT_FORWARDER);

    /* Update quiescent state counter and set offline */
    rte_rcu_qsbr_quiescent(qsv, lcore_id);
    rte_rcu_qsbr_thread_offline(qsv, lcore_id);

    /* Update graph stat */
    struct classifier_stat * graph_stat = &g_classifier_main->stat_per_graph[graph->id];
    graph_stat->deal_pkts += cnt;
    graph_stat->hits += stat.hits;
    graph_stat->miss += stat.miss;
    graph_stat->fast_match += stat.fast_match;
    graph_stat->append_sid_err += stat.append_sid_err;

    return cnt;
}

/* Classifier node base */
static struct rte_node_register classifier_node_base = {
    .process = classifier_node_process,
    .name = "classifier",
    .init = NULL,
    .nb_edges = CLASSIFIER_NEXT_MAX,
    .next_nodes =
        {
            [CLASSIFIER_NEXT_FORWARDER] = "forwarder",
            [CLASSIFIER_NEXT_PKT_DROP] = "pkt_drop",
        },
};

RTE_NODE_REGISTER(classifier_node_base);

/************************************** classifier rule Public Function **************************************/
/* Get free rule item id */
uint32_t get_free_rule_item_id(struct classifier_action actions[])
{
    for (uint32_t i = MR_CLASSIFIER_START_RULE_ID; i < SINGLE_TABLE_MAX_RULE_ITEM_NUM; i++)
    {
        if (actions[i].rule_id == MR_CLASSIFIER_RULE_INVALID_FLAG)
            return i;
    }
    return MR_CLASSIFIER_RULE_INVALID_FLAG;
}

/* IPv4 classifier rule check */
int classifier_rule_check_v4(struct classifier_table_entity * _table_v4, struct classifier_rule_v4 * rule,
                             struct classifier_action * action)
{
    for (uint32_t i = MR_CLASSIFIER_START_RULE_ID; i < SINGLE_TABLE_MAX_RULE_ITEM_NUM; i++)
    {
        struct classifier_rule_v4 * rule_item = &_table_v4->classifier_rules_v4[i];
        struct classifier_action * action_item = &_table_v4->classifier_action_v4[i];

        if (action_item->rule_id == MR_CLASSIFIER_RULE_INVALID_FLAG)
            continue;

        /* Compare rule field */
        if (rule_item->field[CLASSIFIER_IPV4_FIELD_SRC_IP].value.u32 !=
            rule->field[CLASSIFIER_IPV4_FIELD_SRC_IP].value.u32)
            continue;
        if (rule_item->field[CLASSIFIER_IPV4_FIELD_SRC_IP].mask_range.u32 !=
            rule->field[CLASSIFIER_IPV4_FIELD_SRC_IP].mask_range.u32)
            continue;
        if (rule_item->field[CLASSIFIER_IPV4_FIELD_DST_IP].value.u32 !=
            rule->field[CLASSIFIER_IPV4_FIELD_DST_IP].value.u32)
            continue;
        if (rule_item->field[CLASSIFIER_IPV4_FIELD_DST_IP].mask_range.u32 !=
            rule->field[CLASSIFIER_IPV4_FIELD_DST_IP].mask_range.u32)
            continue;
        if (rule_item->field[CLASSIFIER_IPV4_FIELD_SRC_PORT].value.u16 !=
            rule->field[CLASSIFIER_IPV4_FIELD_SRC_PORT].value.u16)
            continue;
        if (rule_item->field[CLASSIFIER_IPV4_FIELD_SRC_PORT].mask_range.u16 !=
            rule->field[CLASSIFIER_IPV4_FIELD_SRC_PORT].mask_range.u16)
            continue;
        if (rule_item->field[CLASSIFIER_IPV4_FIELD_DST_PORT].value.u16 !=
            rule->field[CLASSIFIER_IPV4_FIELD_DST_PORT].value.u16)
            continue;
        if (rule_item->field[CLASSIFIER_IPV4_FIELD_DST_PORT].mask_range.u16 !=
            rule->field[CLASSIFIER_IPV4_FIELD_DST_PORT].mask_range.u16)
            continue;
        if (rule_item->field[CLASSIFIER_IPV4_FIELD_PROTO].value.u8 != rule->field[CLASSIFIER_IPV4_FIELD_PROTO].value.u8)
            continue;
        if (rule_item->field[CLASSIFIER_IPV4_FIELD_PROTO].mask_range.u8 !=
            rule->field[CLASSIFIER_IPV4_FIELD_PROTO].mask_range.u8)
            continue;
        if (rule_item->data.category_mask != rule->data.category_mask)
            continue;
        if (rule_item->data.priority != rule->data.priority)
            continue;
        return RT_ERR;
    }
    return RT_SUCCESS;
}

/* IPv6 classifier rule check */
int classifier_rule_check_v6(struct classifier_table_entity * _table_v6, struct classifier_rule_v6 * rule,
                             struct classifier_action * action)
{
    for (uint32_t i = MR_CLASSIFIER_START_RULE_ID; i < SINGLE_TABLE_MAX_RULE_ITEM_NUM; i++)
    {
        struct classifier_rule_v6 * rule_item = &_table_v6->classifier_rules_v6[i];
        struct classifier_action * action_item = &_table_v6->classifier_action_v6[i];

        if (action_item->rule_id == MR_CLASSIFIER_RULE_INVALID_FLAG)
            continue;

        /* Compare rule field */
        /* Check ipv6 src */
        if (rule_item->field[CLASSIFIER_IPV6_FIELD_SRC_IP_1].value.u32 !=
            rule->field[CLASSIFIER_IPV6_FIELD_SRC_IP_1].value.u32)
            continue;
        if (rule_item->field[CLASSIFIER_IPV6_FIELD_SRC_IP_1].mask_range.u32 !=
            rule->field[CLASSIFIER_IPV6_FIELD_SRC_IP_1].mask_range.u32)
            continue;
        if (rule_item->field[CLASSIFIER_IPV6_FIELD_SRC_IP_2].value.u32 !=
            rule->field[CLASSIFIER_IPV6_FIELD_SRC_IP_2].value.u32)
            continue;
        if (rule_item->field[CLASSIFIER_IPV6_FIELD_SRC_IP_2].mask_range.u32 !=
            rule->field[CLASSIFIER_IPV6_FIELD_SRC_IP_2].mask_range.u32)
            continue;
        if (rule_item->field[CLASSIFIER_IPV6_FIELD_SRC_IP_3].value.u32 !=
            rule->field[CLASSIFIER_IPV6_FIELD_SRC_IP_3].value.u32)
            continue;
        if (rule_item->field[CLASSIFIER_IPV6_FIELD_SRC_IP_3].mask_range.u32 !=
            rule->field[CLASSIFIER_IPV6_FIELD_SRC_IP_3].mask_range.u32)
            continue;
        if (rule_item->field[CLASSIFIER_IPV6_FIELD_SRC_IP_4].value.u32 !=
            rule->field[CLASSIFIER_IPV6_FIELD_SRC_IP_4].value.u32)
            continue;
        if (rule_item->field[CLASSIFIER_IPV6_FIELD_SRC_IP_4].mask_range.u32 !=
            rule->field[CLASSIFIER_IPV6_FIELD_SRC_IP_4].mask_range.u32)
            continue;

        /* Check ipv6 dst */
        if (rule_item->field[CLASSIFIER_IPV6_FIELD_DST_IP_1].value.u32 !=
            rule->field[CLASSIFIER_IPV6_FIELD_DST_IP_1].value.u32)
            continue;
        if (rule_item->field[CLASSIFIER_IPV6_FIELD_DST_IP_1].mask_range.u32 !=
            rule->field[CLASSIFIER_IPV6_FIELD_DST_IP_1].mask_range.u32)
            continue;
        if (rule_item->field[CLASSIFIER_IPV6_FIELD_DST_IP_2].value.u32 !=
            rule->field[CLASSIFIER_IPV6_FIELD_DST_IP_2].value.u32)
            continue;
        if (rule_item->field[CLASSIFIER_IPV6_FIELD_DST_IP_2].mask_range.u32 !=
            rule->field[CLASSIFIER_IPV6_FIELD_DST_IP_2].mask_range.u32)
            continue;
        if (rule_item->field[CLASSIFIER_IPV6_FIELD_DST_IP_3].value.u32 !=
            rule->field[CLASSIFIER_IPV6_FIELD_DST_IP_3].value.u32)
            continue;
        if (rule_item->field[CLASSIFIER_IPV6_FIELD_DST_IP_3].mask_range.u32 !=
            rule->field[CLASSIFIER_IPV6_FIELD_DST_IP_3].mask_range.u32)
            continue;
        if (rule_item->field[CLASSIFIER_IPV6_FIELD_DST_IP_4].value.u32 !=
            rule->field[CLASSIFIER_IPV6_FIELD_DST_IP_4].value.u32)
            continue;
        if (rule_item->field[CLASSIFIER_IPV6_FIELD_DST_IP_4].mask_range.u32 !=
            rule->field[CLASSIFIER_IPV6_FIELD_DST_IP_4].mask_range.u32)
            continue;

        /* Port */
        if (rule_item->field[CLASSIFIER_IPV6_FIELD_SRC_PORT].value.u16 !=
            rule->field[CLASSIFIER_IPV6_FIELD_SRC_PORT].value.u16)
            continue;
        if (rule_item->field[CLASSIFIER_IPV6_FIELD_SRC_PORT].mask_range.u16 !=
            rule->field[CLASSIFIER_IPV6_FIELD_SRC_PORT].mask_range.u16)
            continue;
        if (rule_item->field[CLASSIFIER_IPV6_FIELD_DST_PORT].value.u16 !=
            rule->field[CLASSIFIER_IPV6_FIELD_DST_PORT].value.u16)
            continue;
        if (rule_item->field[CLASSIFIER_IPV6_FIELD_DST_PORT].mask_range.u16 !=
            rule->field[CLASSIFIER_IPV6_FIELD_DST_PORT].mask_range.u16)
            continue;
        if (rule_item->field[CLASSIFIER_IPV6_FIELD_PROTO].value.u8 != rule->field[CLASSIFIER_IPV6_FIELD_PROTO].value.u8)
            continue;
        if (rule_item->field[CLASSIFIER_IPV6_FIELD_PROTO].mask_range.u8 !=
            rule->field[CLASSIFIER_IPV6_FIELD_PROTO].mask_range.u8)
            continue;

        /* Category and priority */
        if (rule_item->data.category_mask != rule->data.category_mask)
            continue;
        if (rule_item->data.priority != rule->data.priority)
            continue;
        return RT_ERR;
    }
    return RT_SUCCESS;
}

/* Classifier rule check */
int classifier_rule_check(struct rule_parse * rule_parse, char * str_error_reason, unsigned int sz_error_reason)
{

    /* Check classifier rule id */
    if (rule_parse->rule_id < MR_CLASSIFIER_START_RULE_ID)
    {
        snprintf(str_error_reason, sz_error_reason,
                 "Classifier rule add error,the rule id (%u) invalid,the rule id range start from 1",
                 rule_parse->rule_id);
        return CLASSIFIER_RULE_ADD_RULE_ID_INVALID;
    }

    /* Check IPv4 src mask */
    if (rule_parse->src_ip_mask_v4 > MR_CLASSIFIER_DEFAULT_IP_MASK_32)
    {
        snprintf(str_error_reason, sz_error_reason,
                 "Classifier rule add error,rule id '%u',the src IPv4 mask '%u' invalid .", rule_parse->rule_id,
                 rule_parse->src_ip_mask_v4);

        return CLASSIFIER_RULE_ADD_SRC_IP_MASK_INVALID_V4;
    }

    /* Check IPv4 dst mask */
    if (rule_parse->dst_ip_mask_v4 > MR_CLASSIFIER_DEFAULT_IP_MASK_32)
    {
        snprintf(str_error_reason, sz_error_reason,
                 "Classifier rule add error,rule id '%u',the dst IPv4 mask '%u' invalid .", rule_parse->rule_id,
                 rule_parse->dst_ip_mask_v4);
        return CLASSIFIER_RULE_ADD_DST_IP_MASK_INVALID_V4;
    }

    /* Check IPv6 src mask */
    if (rule_parse->src_ip_mask_v6 > MR_CLASSIFIER_DEFAULT_IP_MASK_128)
    {
        snprintf(str_error_reason, sz_error_reason,
                 "Classifier rule add error,rule id '%u',the src IPv6 mask '%u' invalid .", rule_parse->rule_id,
                 rule_parse->src_ip_mask_v6);
        return CLASSIFIER_RULE_ADD_SRC_IP_MASK_INVALID_V6;
    }

    /* Check IPv6 dst mask */
    if (rule_parse->dst_ip_mask_v6 > MR_CLASSIFIER_DEFAULT_IP_MASK_128)
    {
        snprintf(str_error_reason, sz_error_reason,
                 "Classifier rule add error,rule id '%u',the dst IPv6 mask '%u' invalid .", rule_parse->rule_id,
                 rule_parse->dst_ip_mask_v6);
        return CLASSIFIER_RULE_ADD_DST_IP_MASK_INVALID_V6;
    }

    /* Check src port */
    if (rule_parse->src_port_range_start > MR_CLASSIFIER_MAX_PORT)
    {
        snprintf(str_error_reason, sz_error_reason,
                 "Classifier rule add error,rule id '%u',the src port range start:  %u out of max(65535) .",
                 rule_parse->rule_id, rule_parse->src_port_range_start);
        return CLASSIFIER_RULE_ADD_SRC_PORT_RANGE_START_INVALID;
    }

    if (rule_parse->src_port_range_end > MR_CLASSIFIER_MAX_PORT)
    {
        snprintf(str_error_reason, sz_error_reason,
                 "Classifier rule add error,rule id '%u',the src port range end:  %u out of max(65535) .",
                 rule_parse->rule_id, rule_parse->src_port_range_end);
        return CLASSIFIER_RULE_ADD_SRC_PORT_RANGE_END_INVALID;
    }

    if (rule_parse->src_port_range_start > rule_parse->src_port_range_end)
    {
        snprintf(str_error_reason, sz_error_reason,
                 "Classifier rule add error,rule id '%u',the src port range start : %u should less than src port range "
                 "end:  %u .",
                 rule_parse->rule_id, rule_parse->src_port_range_start, rule_parse->src_port_range_end);
        return CLASSIFIER_RULE_ADD_SRC_PORT_RANGE_START_THAN_END;
    }

    /* Check dst port */
    if (rule_parse->dst_port_range_start > MR_CLASSIFIER_MAX_PORT)
    {
        snprintf(str_error_reason, sz_error_reason,
                 "Classifier rule add error,rule id '%u',the dst port range start:  %u out of max(65535) .",
                 rule_parse->rule_id, rule_parse->dst_port_range_start);
        return CLASSIFIER_RULE_ADD_DST_PORT_RANGE_START_INVALID;
    }

    if (rule_parse->dst_port_range_end > MR_CLASSIFIER_MAX_PORT)
    {
        snprintf(str_error_reason, sz_error_reason,
                 "Classifier rule add error,rule id '%u',the dst port range end:  %u out of max(65535) .",
                 rule_parse->rule_id, rule_parse->dst_port_range_end);
        return CLASSIFIER_RULE_ADD_DST_PORT_RANGE_END_INVALID;
    }

    if (rule_parse->dst_port_range_start > rule_parse->dst_port_range_end)
    {
        snprintf(str_error_reason, sz_error_reason,
                 "Classifier rule add error,rule id '%u',the dst port range start : %u should less than dst port range "
                 "end:  %u .",
                 rule_parse->rule_id, rule_parse->dst_port_range_start, rule_parse->dst_port_range_end);
        return CLASSIFIER_RULE_ADD_DST_PORT_RANGE_START_THAN_END;
    }

    /* Check Proto */
    if ((rule_parse->proto != IPPROTO_TCP) && (rule_parse->proto != IPPROTO_UDP) &&
        (rule_parse->proto != MR_CLASSIFIER_DEFAULT_PROTO_ANY))
    {
        snprintf(str_error_reason, sz_error_reason, "Classifier rule add error,rule id '%u',the proto '%u' invalid .",
                 rule_parse->rule_id, rule_parse->proto);
        return CLASSIFIER_RULE_ADD_PROTO_INVALID;
    }

    /* Check priority */
    if ((rule_parse->priority < MR_CLASSIFIER_MIN_PRIORITY) || (rule_parse->priority > RTE_ACL_MAX_PRIORITY))
    {
        snprintf(str_error_reason, sz_error_reason,
                 "Classifier rule add error,rule id '%u',the priority is invalid: %d ,the valid range is from 1 To %u",
                 rule_parse->rule_id, rule_parse->priority, RTE_ACL_MAX_PRIORITY);
        return CLASSIFIER_RULE_ADD_PRIORITY_INVALID;
    }

    /* Check sid */
    if (sid_check(rule_parse->sid) == RT_ERR)
    {
        snprintf(str_error_reason, sz_error_reason, "Classifier rule add error,rule id '%u',sid=%u is invalid .",
                 rule_parse->rule_id, rule_parse->sid);
        return CLASSIFIER_RULE_ADD_SID_INVALID;
    }

    /* Check category */
    if (rule_parse->category >= MR_CLASSIFIER_MAX_CATEGORIES)
    {
        snprintf(str_error_reason, sz_error_reason,
                 "Classifier rule add error,rule id '%u',the 'category' is '%u' out of max 'category' is:%u .",
                 rule_parse->rule_id, rule_parse->category, (MR_CLASSIFIER_MAX_CATEGORIES - 1));
        return CLASSIFIER_RULE_ADD_CATEGORY_INVALID;
    }

    /* Check adapter id */
    if (rule_parse->adapter_type == CLASSIFIER_TABLE_ADAPTER_EF)
    {
        if (ef_adapter_id_check(rule_parse->adapter_id) == RT_ERR)
        {
            snprintf(str_error_reason, sz_error_reason,
                     "Classifier rule add error,rule id '%u',the adapter id '%u' invalid .", rule_parse->rule_id,
                     rule_parse->adapter_id);
            return CLASSIFIER_RULE_ADD_ERR_EF_ID_INVALID;
        }
    }
    else if (rule_parse->adapter_type == CLASSIFIER_TABLE_ADAPTER_VWIRE)
    {
        if (vwire_adapter_id_check(rule_parse->adapter_id) == RT_ERR)
        {
            snprintf(str_error_reason, sz_error_reason,
                     "Classifier rule add error,rule id '%u',the adapter id '%u' invalid .", rule_parse->rule_id,
                     rule_parse->adapter_id);
            return CLASSIFIER_RULE_ADD_ERR_VWIRE_ID_INVALID;
        }
    }

    return CLASSIFIER_RULE_ADD_SUCCESS;
}

/* Add rule for adapter id */
int add_rule_for_adapter_id(struct classifier_management * _classifier_management, char * _str_rule_name,
                            struct rule_parse * _rule_parse, uint8_t adapter_type)
{
    struct classifier_table * _classifier_table = NULL;
    uint32_t adapter_id = _rule_parse->adapter_id;

    switch (adapter_type)
    {
    case CLASSIFIER_TABLE_ADAPTER_EF:
        _classifier_table = _classifier_management->__ef_table[adapter_id];
        break;

    case CLASSIFIER_TABLE_ADAPTER_VWIRE:
        _classifier_table = _classifier_management->__vwire_table[adapter_id];
        break;
    }

    if (_classifier_table == NULL)
    {
        MR_ERROR(
            "The classifier rule name: %s, adapter type: %u, adapter id: %u, rule id: %u,the classifier table is null.",
            _str_rule_name, adapter_type, adapter_id, _rule_parse->rule_id);
        return CLASSIFIER_RULE_ADD_ERR_TABLE_IS_NULL;
    }

    if (_rule_parse->ip_version & MR_NODE_COMMON_IP_VERSION_V4)
    {
        /* Get IPv4 table */
        struct classifier_table_entity * _table_v4 = &_classifier_table->table[CLASSIFIER_TABLE_TYPE_V4];

        /* Get free rule item id */
        uint32_t rule_item_id = get_free_rule_item_id(_table_v4->classifier_action_v4);
        if (rule_item_id == MR_CLASSIFIER_RULE_INVALID_FLAG)
        {
            MR_ERROR("The classifier rule name: %s, adapter type: %u, adapter id: %u, rule id: %u, no free ipv4 rule "
                     "Item . ",
                     _str_rule_name, adapter_type, adapter_id, _rule_parse->rule_id);
            return CLASSIFIER_RULE_ADD_ERR_NO_FREE_RULE_ITEM_V4;
        }

        /* Init rule & action */
        struct classifier_action action_item;
        struct classifier_rule_v4 classifier_rule_item;
        struct classifier_action * action = &action_item;
        struct classifier_rule_v4 * rule = &classifier_rule_item;
        memset(rule, 0, sizeof(struct classifier_rule_v4));
        memset(action, 0, sizeof(struct classifier_action));

        /* Fill The rule field */
        rule->field[CLASSIFIER_IPV4_FIELD_SRC_IP].value.u32 = ntohl(_rule_parse->src_ip_addr_v4.s_addr);
        rule->field[CLASSIFIER_IPV4_FIELD_SRC_IP].mask_range.u32 = _rule_parse->src_ip_mask_v4;
        rule->field[CLASSIFIER_IPV4_FIELD_DST_IP].value.u32 = ntohl(_rule_parse->dst_ip_addr_v4.s_addr);
        rule->field[CLASSIFIER_IPV4_FIELD_DST_IP].mask_range.u32 = _rule_parse->dst_ip_mask_v4;
        rule->field[CLASSIFIER_IPV4_FIELD_SRC_PORT].value.u16 = (uint16_t)_rule_parse->src_port_range_start;
        rule->field[CLASSIFIER_IPV4_FIELD_SRC_PORT].mask_range.u16 = (uint16_t)_rule_parse->src_port_range_end;
        rule->field[CLASSIFIER_IPV4_FIELD_DST_PORT].value.u16 = (uint16_t)_rule_parse->dst_port_range_start;
        rule->field[CLASSIFIER_IPV4_FIELD_DST_PORT].mask_range.u16 = (uint16_t)_rule_parse->dst_port_range_end;
        rule->field[CLASSIFIER_IPV4_FIELD_PROTO].value.u8 = _rule_parse->proto;
        rule->field[CLASSIFIER_IPV4_FIELD_PROTO].mask_range.u8 = _rule_parse->proto_mask;

        /* Fill The rule Data */
        rule->data.priority = _rule_parse->priority;
        rule->data.userdata = rule_item_id;
        rule->data.category_mask = 1 << _rule_parse->category;

        /* Fill The action */
        action->sid = _rule_parse->sid;
        action->rule_id = _rule_parse->rule_id;

        /* Classifier rule Check */
        if (classifier_rule_check_v4(_table_v4, rule, action) == RT_ERR)
        {
            MR_ERROR(
                "The classifier rule name: %s, adapter type: %u, adapter id: %u, rule id: %u, the ipv4 rule already "
                "exists .",
                _str_rule_name, adapter_type, adapter_id, _rule_parse->rule_id);
            return CLASSIFIER_RULE_ADD_ERR_ALREADY_EXISTS_V4;
        }

        _table_v4->nr_rules++;
        memcpy(&_table_v4->classifier_rules_v4[rule_item_id], rule, sizeof(struct classifier_rule_v4));
        memcpy(&_table_v4->classifier_action_v4[rule_item_id], action, sizeof(struct classifier_action));
    }

    if (_rule_parse->ip_version & MR_NODE_COMMON_IP_VERSION_V6)
    {
        /* Get IPv6 table */
        struct classifier_table_entity * _table_v6 = &_classifier_table->table[CLASSIFIER_TABLE_TYPE_V6];

        /* Get ipv6 free rule item id */
        int32_t rule_item_id = get_free_rule_item_id(_table_v6->classifier_action_v6);
        if (rule_item_id == MR_CLASSIFIER_RULE_INVALID_FLAG)
        {
            MR_ERROR("The classifier rule name: %s, adapter type: %u, adapter id: %u, rule id: %u, no free ipv6 rule "
                     "Item . ",
                     _str_rule_name, adapter_type, adapter_id, _rule_parse->rule_id);
            return CLASSIFIER_RULE_ADD_ERR_NO_FREE_RULE_ITEM_V6;
        }

        /* Init rule & action */
        struct classifier_action action_item;
        struct classifier_rule_v6 classifier_rule_item;
        struct classifier_action * action = &action_item;
        struct classifier_rule_v6 * rule = &classifier_rule_item;
        memset(rule, 0, sizeof(struct classifier_rule_v6));
        memset(action, 0, sizeof(struct classifier_action));

        /* Fill ipv6 src addr */
        for (int index = 0; index < 4; index++)
        {
            if (_rule_parse->src_ip_mask_v6 > (index + 1) * MR_CLASSIFIER_IPV6_MASK)
                rule->field[CLASSIFIER_IPV6_FIELD_SRC_IP_1 + index].mask_range.u32 = MR_CLASSIFIER_IPV6_MASK;
            else
                rule->field[CLASSIFIER_IPV6_FIELD_SRC_IP_1 + index].mask_range.u32 =
                    _rule_parse->src_ip_mask_v6 > (index * MR_CLASSIFIER_IPV6_MASK)
                        ? _rule_parse->src_ip_mask_v6 - (index * MR_CLASSIFIER_IPV6_MASK)
                        : 0;
            rule->field[CLASSIFIER_IPV6_FIELD_SRC_IP_1 + index].value.u32 = ntohl(_rule_parse->src_ip_addr_v6[index]);
        }

        /* Fill ipv6 dst addr */
        for (int index = 0; index < 4; index++)
        {
            if (_rule_parse->dst_ip_mask_v6 > (index + 1) * MR_CLASSIFIER_IPV6_MASK)
                rule->field[CLASSIFIER_IPV6_FIELD_DST_IP_1 + index].mask_range.u32 = MR_CLASSIFIER_IPV6_MASK;
            else
                rule->field[CLASSIFIER_IPV6_FIELD_DST_IP_1 + index].mask_range.u32 =
                    _rule_parse->dst_ip_mask_v6 > (index * MR_CLASSIFIER_IPV6_MASK)
                        ? _rule_parse->dst_ip_mask_v6 - (index * MR_CLASSIFIER_IPV6_MASK)
                        : 0;
            rule->field[CLASSIFIER_IPV6_FIELD_DST_IP_1 + index].value.u32 = ntohl(_rule_parse->dst_ip_addr_v6[index]);
        }

        /* Fill the rule other field */
        rule->field[CLASSIFIER_IPV6_FIELD_SRC_PORT].value.u16 = (uint16_t)_rule_parse->src_port_range_start;
        rule->field[CLASSIFIER_IPV6_FIELD_SRC_PORT].mask_range.u16 = (uint16_t)_rule_parse->src_port_range_end;
        rule->field[CLASSIFIER_IPV6_FIELD_DST_PORT].value.u16 = (uint16_t)_rule_parse->dst_port_range_start;
        rule->field[CLASSIFIER_IPV6_FIELD_DST_PORT].mask_range.u16 = (uint16_t)_rule_parse->dst_port_range_end;
        rule->field[CLASSIFIER_IPV6_FIELD_PROTO].value.u8 = _rule_parse->proto;
        rule->field[CLASSIFIER_IPV6_FIELD_PROTO].mask_range.u8 = _rule_parse->proto_mask;

        /* Fill The rule Data */
        rule->data.priority = _rule_parse->priority;
        rule->data.userdata = rule_item_id;
        rule->data.category_mask = 1 << _rule_parse->category;

        /* Fill The action */
        action->sid = _rule_parse->sid;
        action->rule_id = _rule_parse->rule_id;

        /* Classifier rule Check */
        if (classifier_rule_check_v6(_table_v6, rule, action) == RT_ERR)
        {
            MR_ERROR(
                "The classifier rule name: %s, adapter type: %u, adapter id: %u, rule id: %u, the ipv6 rule already "
                "exists .",
                _str_rule_name, adapter_type, adapter_id, _rule_parse->rule_id);
            return CLASSIFIER_RULE_ADD_ERR_ALREADY_EXISTS_V6;
        }

        _table_v6->nr_rules++;
        memcpy(&_table_v6->classifier_rules_v6[rule_item_id], rule, sizeof(struct classifier_rule_v6));
        memcpy(&_table_v6->classifier_action_v6[rule_item_id], action, sizeof(struct classifier_action));
    }

    return CLASSIFIER_RULE_ADD_SUCCESS;
}

/* Get rule add error info */
void get_rule_add_err_info(char * str_error_reason, unsigned int sz_error_reason, int offset, int ret)
{
    switch (ret)
    {
    case CLASSIFIER_RULE_ADD_ERR_TABLE_IS_NULL:
        snprintf(str_error_reason + offset, sz_error_reason - offset, ",the classifier table is null.");
        break;
    case CLASSIFIER_RULE_ADD_ERR_NO_FREE_RULE_ITEM_V4:
        snprintf(str_error_reason + offset, sz_error_reason - offset, ",the ipv4 table already full .");
        break;
    case CLASSIFIER_RULE_ADD_ERR_NO_FREE_RULE_ITEM_V6:
        snprintf(str_error_reason + offset, sz_error_reason - offset, ",the ipv6 table already full .");
        break;
    case CLASSIFIER_RULE_ADD_ERR_ALREADY_EXISTS_V4:
        snprintf(str_error_reason + offset, sz_error_reason - offset, ",the ipv4 rule already exists .");
        break;
    case CLASSIFIER_RULE_ADD_ERR_ALREADY_EXISTS_V6:
        snprintf(str_error_reason + offset, sz_error_reason - offset, ",the ipv6 rule already exists .");
        break;
    }
}

/* Add classifier rule */
int classifier_rule_add(struct classifier_management * _classifier_management, struct rule_parse * rule_parse,
                        char * str_rule_name, char * str_error_reason, unsigned int sz_error_reason)
{
    int ret = 0;
    if (rule_parse->adapter_type == CLASSIFIER_TABLE_ADAPTER_EF)
    {
        /* Fill The rule field for adapter id */
        ret = add_rule_for_adapter_id(_classifier_management, str_rule_name, rule_parse, CLASSIFIER_TABLE_ADAPTER_EF);
        if (ret != CLASSIFIER_RULE_ADD_SUCCESS)
        {
            int len = snprintf(str_error_reason, sz_error_reason,
                               "Classifier rule add error, adapter_type:ef, adapter_id:%u, rule_id:%u",
                               rule_parse->adapter_id, rule_parse->rule_id);

            get_rule_add_err_info(str_error_reason, sz_error_reason, len, ret);
            return ret;
        }
    }
    else if (rule_parse->adapter_type == CLASSIFIER_TABLE_ADAPTER_VWIRE)
    {
        /* Fill The rule field for adapter id */
        ret =
            add_rule_for_adapter_id(_classifier_management, str_rule_name, rule_parse, CLASSIFIER_TABLE_ADAPTER_VWIRE);
        if (ret != CLASSIFIER_RULE_ADD_SUCCESS)
        {
            int len = snprintf(str_error_reason, sz_error_reason,
                               "Classifier rule add error, adapter_type:vwire, adapter_id:%u, rule_id:%u",
                               rule_parse->adapter_id, rule_parse->rule_id);

            get_rule_add_err_info(str_error_reason, sz_error_reason, len, ret);
            return ret;
        }
    }
    else
    {
        /* Add the rule for all table */
        /* Add the rule for all ef tables */
        for (uint32_t adapter_id = 0; adapter_id < _classifier_management->nr_ef_tables; adapter_id++)
        {
            if (ef_adapter_id_check(adapter_id) == RT_ERR)
                continue;
            /* Fill The rule field for adapter id */
            rule_parse->adapter_id = adapter_id;
            ret =
                add_rule_for_adapter_id(_classifier_management, str_rule_name, rule_parse, CLASSIFIER_TABLE_ADAPTER_EF);
            if (ret != CLASSIFIER_RULE_ADD_SUCCESS)
            {
                int len = snprintf(str_error_reason, sz_error_reason,
                                   "Classifier rule add error, adapter_type:ef, adapter_id:%u, rule_id:%u", adapter_id,
                                   rule_parse->rule_id);

                get_rule_add_err_info(str_error_reason, sz_error_reason, len, ret);
                return ret;
            }
        }

        /* Add the rule for all vwire tables */
        for (uint32_t adapter_id = 0; adapter_id < _classifier_management->nr_vwire_tables; adapter_id++)
        {
            if (vwire_adapter_id_check(adapter_id) == RT_ERR)
                continue;
            /* Fill The rule field for adapter id */
            rule_parse->adapter_id = adapter_id;
            ret = add_rule_for_adapter_id(_classifier_management, str_rule_name, rule_parse,
                                          CLASSIFIER_TABLE_ADAPTER_VWIRE);
            if (ret != CLASSIFIER_RULE_ADD_SUCCESS)
            {
                int len = snprintf(str_error_reason, sz_error_reason,
                                   "Classifier rule add error, adapter_type:vwire, adapter_id:%u, rule_id:%u",
                                   adapter_id, rule_parse->rule_id);

                get_rule_add_err_info(str_error_reason, sz_error_reason, len, ret);
                return ret;
            }
        }
    }

    return CLASSIFIER_RULE_ADD_SUCCESS;
}

struct classifier_management * create_classifier_management()
{
    struct classifier_management * _classifier_management = ZMALLOC(sizeof(struct classifier_management *));
    MR_VERIFY_MALLOC(_classifier_management);

    uint32_t nr_ef_tables = ef_get_max_rule_num();
    uint32_t nr_vwire_tables = vwire_get_max_rule_num();
    _classifier_management->nr_ef_tables = nr_ef_tables;
    _classifier_management->nr_vwire_tables = nr_vwire_tables;
    _classifier_management->__ef_table = ZMALLOC(sizeof(struct classifier_table *) * nr_ef_tables);
    _classifier_management->__vwire_table = ZMALLOC(sizeof(struct classifier_table *) * nr_vwire_tables);
    MR_VERIFY_MALLOC(_classifier_management->__ef_table);
    MR_VERIFY_MALLOC(_classifier_management->__vwire_table);

    /* Malloc etherfabric table */
    for (uint32_t ef_adapter_id = 0; ef_adapter_id < nr_ef_tables; ef_adapter_id++)
    {
        if (ef_adapter_id_check(ef_adapter_id) == RT_ERR)
            continue;
        _classifier_management->__ef_table[ef_adapter_id] = ZMALLOC(sizeof(struct classifier_table));
        MR_VERIFY_MALLOC(_classifier_management->__ef_table[ef_adapter_id]);
    }

    /* Malloc vwire table */
    for (uint32_t vwire_adapter_id = 0; vwire_adapter_id < nr_vwire_tables; vwire_adapter_id++)
    {
        if (vwire_adapter_id_check(vwire_adapter_id) == RT_ERR)
            continue;
        _classifier_management->__vwire_table[vwire_adapter_id] = ZMALLOC(sizeof(struct classifier_table));
        MR_VERIFY_MALLOC(_classifier_management->__vwire_table[vwire_adapter_id]);
    }
    return _classifier_management;
}

/* Free management */
void free_classifier_management(struct classifier_management * _classifier_management)
{
    for (uint32_t adapter_id = 0; adapter_id < _classifier_management->nr_ef_tables; adapter_id++)
    {
        struct classifier_table * _ef_table = _classifier_management->__ef_table[adapter_id];
        if (_ef_table == NULL)
            continue;
        /* Free acx */
        if (_ef_table->table[CLASSIFIER_TABLE_TYPE_V4].acx != NULL)
            rte_acl_free(_ef_table->table[CLASSIFIER_TABLE_TYPE_V4].acx);
        if (_ef_table->table[CLASSIFIER_TABLE_TYPE_V6].acx != NULL)
            rte_acl_free(_ef_table->table[CLASSIFIER_TABLE_TYPE_V6].acx);
        FREE(_ef_table);
    }

    for (uint32_t adapter_id = 0; adapter_id < _classifier_management->nr_vwire_tables; adapter_id++)
    {
        struct classifier_table * _vwire_table = _classifier_management->__vwire_table[adapter_id];
        if (_vwire_table == NULL)
            continue;
        /* Free acx */
        if (_vwire_table->table[CLASSIFIER_TABLE_TYPE_V4].acx != NULL)
            rte_acl_free(_vwire_table->table[CLASSIFIER_TABLE_TYPE_V4].acx);
        if (_vwire_table->table[CLASSIFIER_TABLE_TYPE_V6].acx != NULL)
            rte_acl_free(_vwire_table->table[CLASSIFIER_TABLE_TYPE_V6].acx);
        FREE(_vwire_table);
    }

    FREE(_classifier_management->__ef_table);
    FREE(_classifier_management->__vwire_table);
    FREE(_classifier_management);
}

/* From category_mask get category */
int get_category(uint32_t category_mask)
{
    int category = 0;
    for (int index = 0; index < MR_CLASSIFIER_MAX_CATEGORIES; index++)
    {
        if (category_mask & (1 << index))
        {
            category = index;
            break;
        }
    }
    return category;
}

/* Dump single ipv4 classifier rule */
void dump_classifier_rule_v4(struct classifier_rule_v4 * rule, struct classifier_action * action, char * _adapter_type,
                             uint32_t adapter_id)
{
    char str_rule_info[2048] = {};
    struct in_addr src_addr, dst_addr;
    src_addr.s_addr = htonl(rule->field[CLASSIFIER_IPV4_FIELD_SRC_IP].value.u32);
    dst_addr.s_addr = htonl(rule->field[CLASSIFIER_IPV4_FIELD_DST_IP].value.u32);

    int len = 0;
    len = snprintf(str_rule_info, sizeof(str_rule_info), "Classifier %s:%u, ipv4 rule, id=%u", _adapter_type,
                   adapter_id, action->rule_id);
    len += snprintf(str_rule_info + len, sizeof(str_rule_info) - len - len, ", item_index=%u", rule->data.userdata);
    len += snprintf(str_rule_info + len, sizeof(str_rule_info) - len - len, ", priority=%u", rule->data.priority);
    len += snprintf(str_rule_info + len, sizeof(str_rule_info) - len - len, ", category=%u",
                    get_category(rule->data.category_mask));
    len += snprintf(str_rule_info + len, sizeof(str_rule_info) - len - len, ", sip=%s/%u", inet_ntoa(src_addr),
                    rule->field[CLASSIFIER_IPV4_FIELD_SRC_IP].mask_range.u32);
    len += snprintf(str_rule_info + len, sizeof(str_rule_info) - len - len, ", dip=%s/%u", inet_ntoa(dst_addr),
                    rule->field[CLASSIFIER_IPV4_FIELD_DST_IP].mask_range.u32);
    len += snprintf(str_rule_info + len, sizeof(str_rule_info) - len - len, ", sport=%u-%u",
                    rule->field[CLASSIFIER_IPV4_FIELD_SRC_PORT].value.u16,
                    rule->field[CLASSIFIER_IPV4_FIELD_SRC_PORT].mask_range.u16);
    len += snprintf(str_rule_info + len, sizeof(str_rule_info) - len - len, ", dport=%u-%u",
                    rule->field[CLASSIFIER_IPV4_FIELD_DST_PORT].value.u16,
                    rule->field[CLASSIFIER_IPV4_FIELD_DST_PORT].mask_range.u16);

    switch (rule->field[CLASSIFIER_IPV4_FIELD_PROTO].value.u8)
    {
    case IPPROTO_TCP:
        len += snprintf(str_rule_info + len, sizeof(str_rule_info) - len - len, ", proto=tcp");
        break;
    case IPPROTO_UDP:
        len += snprintf(str_rule_info + len, sizeof(str_rule_info) - len - len, ", proto=udp");
        break;
    default:
        len += snprintf(str_rule_info + len, sizeof(str_rule_info) - len, ", proto=any");
        break;
    }

    len += snprintf(str_rule_info + len, sizeof(str_rule_info) - len, ", sid=%u", action->sid);
    MR_INFO("%s", str_rule_info);
}

/* Dump single ipv6 classifier rule */
void dump_classifier_rule_v6(struct classifier_rule_v6 * rule, struct classifier_action * action, char * _adapter_type,
                             uint32_t adapter_id)
{
    char str_rule_info[2048] = {};

    int len = 0;
    len = snprintf(str_rule_info, sizeof(str_rule_info), "Classifier %s:%u, ipv6 rule, id=%u", _adapter_type,
                   adapter_id, action->rule_id);
    len += snprintf(str_rule_info + len, sizeof(str_rule_info) - len, ", item_index=%u", rule->data.userdata);
    len += snprintf(str_rule_info + len, sizeof(str_rule_info) - len, ", priority=%u", rule->data.priority);
    len += snprintf(str_rule_info + len, sizeof(str_rule_info) - len, ", category=%u",
                    get_category(rule->data.category_mask));

    uint32_t src_ip_addr_v6[4] = {}, dst_ip_addr_v6[4] = {}, src_ip_mask_v6 = 0, dst_ip_mask_v6 = 0;
    char str_ipv6_src[INET6_ADDRSTRLEN] = {0}, str_ipv6_dst[INET6_ADDRSTRLEN] = {0};
    src_ip_addr_v6[0] = htonl(rule->field[CLASSIFIER_IPV6_FIELD_SRC_IP_1].value.u32);
    src_ip_addr_v6[1] = htonl(rule->field[CLASSIFIER_IPV6_FIELD_SRC_IP_2].value.u32);
    src_ip_addr_v6[2] = htonl(rule->field[CLASSIFIER_IPV6_FIELD_SRC_IP_3].value.u32);
    src_ip_addr_v6[3] = htonl(rule->field[CLASSIFIER_IPV6_FIELD_SRC_IP_4].value.u32);
    dst_ip_addr_v6[0] = htonl(rule->field[CLASSIFIER_IPV6_FIELD_DST_IP_1].value.u32);
    dst_ip_addr_v6[1] = htonl(rule->field[CLASSIFIER_IPV6_FIELD_DST_IP_2].value.u32);
    dst_ip_addr_v6[2] = htonl(rule->field[CLASSIFIER_IPV6_FIELD_DST_IP_3].value.u32);
    dst_ip_addr_v6[3] = htonl(rule->field[CLASSIFIER_IPV6_FIELD_DST_IP_4].value.u32);
    inet_ntop(AF_INET6, src_ip_addr_v6, str_ipv6_src, INET6_ADDRSTRLEN);
    inet_ntop(AF_INET6, dst_ip_addr_v6, str_ipv6_dst, INET6_ADDRSTRLEN);
    src_ip_mask_v6 = rule->field[CLASSIFIER_IPV6_FIELD_SRC_IP_1].mask_range.u32 +
                     rule->field[CLASSIFIER_IPV6_FIELD_SRC_IP_2].mask_range.u32 +
                     rule->field[CLASSIFIER_IPV6_FIELD_SRC_IP_3].mask_range.u32 +
                     rule->field[CLASSIFIER_IPV6_FIELD_SRC_IP_4].mask_range.u32;
    dst_ip_mask_v6 = rule->field[CLASSIFIER_IPV6_FIELD_DST_IP_1].mask_range.u32 +
                     rule->field[CLASSIFIER_IPV6_FIELD_DST_IP_2].mask_range.u32 +
                     rule->field[CLASSIFIER_IPV6_FIELD_DST_IP_3].mask_range.u32 +
                     rule->field[CLASSIFIER_IPV6_FIELD_DST_IP_4].mask_range.u32;

    len += snprintf(str_rule_info + len, sizeof(str_rule_info) - len, ", sip='%s/%u'", str_ipv6_src, src_ip_mask_v6);
    len += snprintf(str_rule_info + len, sizeof(str_rule_info) - len, ", dip='%s/%u'", str_ipv6_dst, dst_ip_mask_v6);
    len += snprintf(str_rule_info + len, sizeof(str_rule_info) - len, ", sport=%u-%u",
                    rule->field[CLASSIFIER_IPV6_FIELD_SRC_PORT].value.u16,
                    rule->field[CLASSIFIER_IPV6_FIELD_SRC_PORT].mask_range.u16);
    len += snprintf(str_rule_info + len, sizeof(str_rule_info) - len, ", dport=%u-%u",
                    rule->field[CLASSIFIER_IPV6_FIELD_DST_PORT].value.u16,
                    rule->field[CLASSIFIER_IPV6_FIELD_DST_PORT].mask_range.u16);

    switch (rule->field[CLASSIFIER_IPV6_FIELD_PROTO].value.u8)
    {
    case IPPROTO_TCP:
        len += snprintf(str_rule_info + len, sizeof(str_rule_info) - len, ", proto=tcp");
        break;
    case IPPROTO_UDP:
        len += snprintf(str_rule_info + len, sizeof(str_rule_info) - len, ", proto=udp");
        break;
    default:
        len += snprintf(str_rule_info + len, sizeof(str_rule_info) - len, ", proto=any");
        break;
    }

    len += snprintf(str_rule_info + len, sizeof(str_rule_info) - len, ", sid=%u", action->sid);
    MR_INFO("%s", str_rule_info);
}

/* Check fast match condition */
void check_fast_match_condition(struct classifier_table * _table)
{
    struct classifier_table_entity * _table_v4 = &_table->table[CLASSIFIER_TABLE_TYPE_V4];
    if (_table_v4->nr_rules == 1)
    {
        for (uint16_t i = MR_CLASSIFIER_START_RULE_ID; i < SINGLE_TABLE_MAX_RULE_ITEM_NUM; i++)
        {
            struct classifier_action * action = &_table_v4->classifier_action_v4[i];
            if (action->rule_id == MR_CLASSIFIER_RULE_INVALID_FLAG)
                continue;

            struct classifier_rule_v4 * rule = &_table_v4->classifier_rules_v4[i];
            if (rule->field[CLASSIFIER_IPV4_FIELD_SRC_IP].mask_range.u32 != 0)
                break;
            if (rule->field[CLASSIFIER_IPV4_FIELD_DST_IP].mask_range.u32 != 0)
                break;
            if (rule->field[CLASSIFIER_IPV4_FIELD_SRC_PORT].mask_range.u16 != MR_CLASSIFIER_DEFAULT_PORT_END)
                break;
            if (rule->field[CLASSIFIER_IPV4_FIELD_DST_PORT].mask_range.u16 != MR_CLASSIFIER_DEFAULT_PORT_END)
                break;
            if (rule->field[CLASSIFIER_IPV4_FIELD_PROTO].mask_range.u8 != 0)
                break;
            _table_v4->fast_match = action->sid;
        }
    }

    struct classifier_table_entity * _table_v6 = &_table->table[CLASSIFIER_TABLE_TYPE_V6];
    if (_table_v6->nr_rules == 1)
    {

        for (uint32_t i = MR_CLASSIFIER_START_RULE_ID; i < SINGLE_TABLE_MAX_RULE_ITEM_NUM; i++)
        {
            struct classifier_action * action = &_table_v6->classifier_action_v6[i];
            if (action->rule_id == MR_CLASSIFIER_RULE_INVALID_FLAG)
                continue;

            struct classifier_rule_v6 * rule = &_table_v6->classifier_rules_v6[i];

            if (rule->field[CLASSIFIER_IPV6_FIELD_SRC_IP_1].mask_range.u32 != 0)
                break;
            if (rule->field[CLASSIFIER_IPV6_FIELD_SRC_IP_2].mask_range.u32 != 0)
                break;
            if (rule->field[CLASSIFIER_IPV6_FIELD_SRC_IP_3].mask_range.u32 != 0)
                break;
            if (rule->field[CLASSIFIER_IPV6_FIELD_SRC_IP_4].mask_range.u32 != 0)
                break;
            if (rule->field[CLASSIFIER_IPV6_FIELD_DST_IP_1].mask_range.u32 != 0)
                break;
            if (rule->field[CLASSIFIER_IPV6_FIELD_DST_IP_2].mask_range.u32 != 0)
                break;
            if (rule->field[CLASSIFIER_IPV6_FIELD_DST_IP_3].mask_range.u32 != 0)
                break;
            if (rule->field[CLASSIFIER_IPV6_FIELD_DST_IP_4].mask_range.u32 != 0)
                break;
            if (rule->field[CLASSIFIER_IPV6_FIELD_SRC_PORT].mask_range.u16 != MR_CLASSIFIER_DEFAULT_PORT_END)
                break;
            if (rule->field[CLASSIFIER_IPV6_FIELD_DST_PORT].mask_range.u16 != MR_CLASSIFIER_DEFAULT_PORT_END)
                break;
            if (rule->field[CLASSIFIER_IPV6_FIELD_PROTO].mask_range.u8 != 0)
                break;
            _table_v6->fast_match = action->sid;
        }
    }

    if (_table_v4->fast_match == _table_v6->fast_match)
    {
        _table->fast_match = _table_v4->fast_match;
    }
}

void classifier_fast_match_check(struct classifier_management * _classifier_management)
{
    /* Check all table for ef adapter  */
    for (uint32_t ef_adapter_id = 0; ef_adapter_id < _classifier_management->nr_ef_tables; ef_adapter_id++)
    {
        struct classifier_table * _ef_table = _classifier_management->__ef_table[ef_adapter_id];
        if (_ef_table == NULL)
            continue;
        check_fast_match_condition(_ef_table);
    }

    /* Check all table forvwire adapter  */
    for (uint32_t vwire_adapter_id = 0; vwire_adapter_id < _classifier_management->nr_ef_tables; vwire_adapter_id++)
    {
        struct classifier_table * _vwire_table = _classifier_management->__vwire_table[vwire_adapter_id];
        if (_vwire_table == NULL)
            continue;
        check_fast_match_condition(_vwire_table);
    }
}

/* Dump all classifier rule table */
void dump_classifier_tables(struct classifier_management * _classifier_management)
{
    for (uint32_t adapter_id = 0; adapter_id < _classifier_management->nr_ef_tables; adapter_id++)
    {
        struct classifier_table * _ef_table = _classifier_management->__ef_table[adapter_id];
        if (_ef_table == NULL)
            continue;

        struct classifier_table_entity * _table_v4 = &_ef_table->table[CLASSIFIER_TABLE_TYPE_V4];
        for (uint32_t i = MR_CLASSIFIER_START_RULE_ID; i < SINGLE_TABLE_MAX_RULE_ITEM_NUM; i++)
        {
            if (_table_v4->classifier_action_v4[i].rule_id != MR_CLASSIFIER_RULE_INVALID_FLAG)
                dump_classifier_rule_v4(&_table_v4->classifier_rules_v4[i], &_table_v4->classifier_action_v4[i], "ef",
                                        adapter_id);
        }

        struct classifier_table_entity * _table_v6 = &_ef_table->table[CLASSIFIER_TABLE_TYPE_V6];
        for (uint32_t i = MR_CLASSIFIER_START_RULE_ID; i < SINGLE_TABLE_MAX_RULE_ITEM_NUM; i++)
        {
            if (_table_v6->classifier_action_v6[i].rule_id != MR_CLASSIFIER_RULE_INVALID_FLAG)
                dump_classifier_rule_v6(&_table_v6->classifier_rules_v6[i], &_table_v6->classifier_action_v6[i], "ef",
                                        adapter_id);
        }
    }

    for (uint32_t adapter_id = 0; adapter_id < _classifier_management->nr_vwire_tables; adapter_id++)
    {
        struct classifier_table * _vwire_table = _classifier_management->__vwire_table[adapter_id];
        if (_vwire_table == NULL)
            continue;

        struct classifier_table_entity * _table_v4 = &_vwire_table->table[CLASSIFIER_TABLE_TYPE_V4];
        for (uint32_t i = MR_CLASSIFIER_START_RULE_ID; i < SINGLE_TABLE_MAX_RULE_ITEM_NUM; i++)
        {
            if (_table_v4->classifier_action_v4[i].rule_id != MR_CLASSIFIER_RULE_INVALID_FLAG)
                dump_classifier_rule_v4(&_table_v4->classifier_rules_v4[i], &_table_v4->classifier_action_v4[i],
                                        "vwire", adapter_id);
        }

        struct classifier_table_entity * _table_v6 = &_vwire_table->table[CLASSIFIER_TABLE_TYPE_V6];
        for (uint32_t i = MR_CLASSIFIER_START_RULE_ID; i < SINGLE_TABLE_MAX_RULE_ITEM_NUM; i++)
        {
            if (_table_v6->classifier_action_v6[i].rule_id != MR_CLASSIFIER_RULE_INVALID_FLAG)
                dump_classifier_rule_v6(&_table_v6->classifier_rules_v6[i], &_table_v6->classifier_action_v6[i],
                                        "vwire", adapter_id);
        }
    }
}

/* Build classifier rule table */
struct rte_acl_ctx * build_classifier(char * table_name, uint64_t rule_num, char * classifier_rule,
                                      struct classifier_action * classifier_action, int table_type)
{
    int ret = 0, dim = 0;
    uint64_t def_size = 0, offset_unit = 0;
    struct rte_acl_field_def * defs = NULL;

    if (table_type == CLASSIFIER_TABLE_TYPE_V4)
    {
        dim = RTE_DIM(classifier_defs_v4);
        defs = classifier_defs_v4;
        def_size = sizeof(classifier_defs_v4);
        offset_unit = sizeof(struct classifier_rule_v4);
    }
    else
    {
        dim = RTE_DIM(classifier_defs_v6);
        defs = classifier_defs_v6;
        def_size = sizeof(classifier_defs_v6);
        offset_unit = sizeof(struct classifier_rule_v6);
    }

    /* Fill create the classifier contexts need struct "classifier_param" */
    struct rte_acl_param classifier_param = {};
    classifier_param.name = table_name;
    classifier_param.socket_id = MR_CLASSIFIER_DEFAULT_SOCKET_ID; // Current no suppport multi socket
    classifier_param.rule_size = RTE_ACL_RULE_SZ(dim);
    classifier_param.max_rule_num = SINGLE_TABLE_MAX_RULE_NUM;

    /* Create classifier context */
    struct rte_acl_ctx * context = rte_acl_create(&classifier_param);
    if (context == NULL)
    {
        MR_ERROR("Classifier table '%s' context create fail . ", table_name);
        return NULL;
    }

    /* Current use the default alg config,So no need call "rte_acl_set_ctx_classify" */
    /* Add classifier rule */
    uint64_t add_rule_num = 0, rule_item_id = 0;
    for (uint32_t i = 0; i < rule_num; i++)
    {
        while (rule_item_id < SINGLE_TABLE_MAX_RULE_NUM)
        {
            if (classifier_action[rule_item_id].rule_id == MR_CLASSIFIER_RULE_INVALID_FLAG)
            {
                rule_item_id++;
                continue;
            }

            struct rte_acl_rule * rule_item = (struct rte_acl_rule *)(classifier_rule + (offset_unit * rule_item_id));
            ret = rte_acl_add_rules(context, rule_item, 1);
            if (ret < 0)
            {
                MR_ERROR("Set classifier table '%s' add rules fail,rule id: %u  rule item id: %lu ", table_name,
                         classifier_action[rule_item_id].rule_id, rule_item_id);
                goto setup_err;
            }

            add_rule_num++;
            rule_item_id++;
            break;
        }
    }

    /* Check add rule num */
    if (add_rule_num != rule_num)
    {
        MR_ERROR("Classifier table '%s' add rule number error . ", table_name);
        goto setup_err;
    }

    /* Prepare for build */
    struct rte_acl_config classifier_build_param;
    memset(&classifier_build_param, 0, sizeof(classifier_build_param));
    classifier_build_param.num_categories = MR_CLASSIFIER_MAX_CATEGORIES;
    classifier_build_param.num_fields = dim;
    memcpy(&classifier_build_param.defs, defs, def_size);

    /* Classifier build */
    ret = rte_acl_build(context, &classifier_build_param);
    if (ret != 0)
    {
        MR_ERROR("Classifier table '%s' build fail . ", table_name);
        goto setup_err;
    }

    /* Dump the context */
    rte_acl_dump(context);
    return context;

setup_err:
    rte_acl_free(context);
    return NULL;
}

/* Setup classifier table */
int setup_classifier_table_for_adapter(struct classifier_table * _ef_table, char * _str_adapter, uint32_t adapter_id,
                                       uint8_t table_name_flg)
{
    /* Get table name */
    char table_name_v4[MR_STRING_MAX] = {};
    char table_name_v6[MR_STRING_MAX] = {};
    if (table_name_flg == CLASSIFIER_TABLE_A)
    {
        snprintf(table_name_v4, sizeof(table_name_v4), "classifier-%s-%u-%s", _str_adapter, adapter_id,
                 MR_CLASSIFIER_IPV4_TABLE_NAME_A);
        snprintf(table_name_v6, sizeof(table_name_v6), "classifier-%s-%u-%s", _str_adapter, adapter_id,
                 MR_CLASSIFIER_IPV6_TABLE_NAME_A);
    }
    else
    {
        snprintf(table_name_v4, sizeof(table_name_v4), "classifier-%s-%u-%s", _str_adapter, adapter_id,
                 MR_CLASSIFIER_IPV4_TABLE_NAME_B);
        snprintf(table_name_v6, sizeof(table_name_v6), "classifier-%s-%u-%s", _str_adapter, adapter_id,
                 MR_CLASSIFIER_IPV6_TABLE_NAME_B);
    }

    struct rte_acl_ctx * acx_v4 = NULL;
    struct classifier_table_entity * _table_v4 = &_ef_table->table[CLASSIFIER_TABLE_TYPE_V4];
    if (_table_v4->nr_rules)
    {
        acx_v4 = build_classifier(table_name_v4, _table_v4->nr_rules, (char *)(_table_v4->classifier_rules_v4 + 1),
                                  (_table_v4->classifier_action_v4 + 1), CLASSIFIER_TABLE_TYPE_V4);
        if (acx_v4 == NULL)
            return RT_ERR;
    }

    struct rte_acl_ctx * acx_v6 = NULL;
    struct classifier_table_entity * _table_v6 = &_ef_table->table[CLASSIFIER_TABLE_TYPE_V6];
    if (_table_v6->nr_rules)
    {
        acx_v6 = build_classifier(table_name_v6, _table_v6->nr_rules, (char *)(_table_v6->classifier_rules_v6 + 1),
                                  (_table_v6->classifier_action_v6 + 1), CLASSIFIER_TABLE_TYPE_V6);
        if (acx_v6 == NULL)
            return RT_ERR;
    }

    _table_v4->acx = acx_v4;
    _table_v6->acx = acx_v6;
    return RT_SUCCESS;
}

int setup_all_classifier_table(struct classifier_management * _classifier_management)
{

    /* Setup all classifier table for ef adapter  */
    for (uint32_t ef_adapter_id = 0; ef_adapter_id < _classifier_management->nr_ef_tables; ef_adapter_id++)
    {
        struct classifier_table * _ef_table = _classifier_management->__ef_table[ef_adapter_id];
        if (_ef_table == NULL)
            continue;
        if (setup_classifier_table_for_adapter(_ef_table, "ef", ef_adapter_id, table_name_flg) == RT_ERR)
            return RT_ERR;
    }

    /* Setup all classifier table for vwire adapter  */
    for (uint32_t vwire_adapter_id = 0; vwire_adapter_id < _classifier_management->nr_ef_tables; vwire_adapter_id++)
    {
        struct classifier_table * _vwire_table = _classifier_management->__vwire_table[vwire_adapter_id];
        if (_vwire_table == NULL)
            continue;
        if (setup_classifier_table_for_adapter(_vwire_table, "vwire", vwire_adapter_id, table_name_flg) == RT_ERR)
            return RT_ERR;
    }

    table_name_flg = (table_name_flg == CLASSIFIER_TABLE_A) ? CLASSIFIER_TABLE_B : CLASSIFIER_TABLE_A;
    return RT_SUCCESS;
}

/************************************** Classifier Dynamic classifier rule Deal **************************************/
/* Parse classifier rule ip version */
int parse_ip_version(cJSON * c_rule, uint16_t * ip_version)
{
    cJSON * cj_src_ip_addr_v4 = cJSON_GetObjectItem(c_rule, MR_CLASSIFIER_CJSON_KEY_SRC_IP_V4);
    cJSON * cj_dst_ip_addr_v4 = cJSON_GetObjectItem(c_rule, MR_CLASSIFIER_CJSON_KEY_DST_IP_V4);
    cJSON * cj_src_ip_v6 = cJSON_GetObjectItem(c_rule, MR_CLASSIFIER_CJSON_KEY_SRC_IP_V6);
    cJSON * cj_dst_ip_v6 = cJSON_GetObjectItem(c_rule, MR_CLASSIFIER_CJSON_KEY_DST_IP_V6);

    if (((cj_src_ip_addr_v4 != NULL) || (cj_dst_ip_addr_v4 != NULL)) &&
        ((cj_src_ip_v6 != NULL) || (cj_dst_ip_v6 != NULL)))
        return RT_ERR;

    if ((cj_src_ip_addr_v4 != NULL) || (cj_dst_ip_addr_v4 != NULL))
        *ip_version = MR_NODE_COMMON_IP_VERSION_V4;
    else if ((cj_src_ip_v6 != NULL) || (cj_dst_ip_v6 != NULL))
        *ip_version = MR_NODE_COMMON_IP_VERSION_V6;

    return RT_SUCCESS;
}

/* Parse classifier rules from remote */
int parse_classifier_rule_remote(struct classifier_management * _classifier_management, cJSON * c_rule,
                                 uint32_t * _out_rule_id, char * _str_error_reason, unsigned int sz_error_reason)
{
    struct rule_parse rule_parse = {};
    rule_parse.src_ip_addr_v4.s_addr = MR_CLASSIFIER_DEFAULT_IP_ADDR_V4;
    rule_parse.dst_ip_addr_v4.s_addr = MR_CLASSIFIER_DEFAULT_IP_ADDR_V4;
    rule_parse.proto = MR_CLASSIFIER_DEFAULT_PROTO_ANY;
    rule_parse.ip_version = MR_NODE_COMMON_IP_VERSION_ANY;
    rule_parse.src_port_range_start = MR_CLASSIFIER_DEFAULT_PORT_START;
    rule_parse.src_port_range_end = MR_CLASSIFIER_DEFAULT_PORT_END;
    rule_parse.dst_port_range_start = MR_CLASSIFIER_DEFAULT_PORT_START;
    rule_parse.dst_port_range_end = MR_CLASSIFIER_DEFAULT_PORT_END;

    /* Get IP Version */
    int ret = parse_ip_version(c_rule, &rule_parse.ip_version);
    if (ret != RT_SUCCESS)
    {
        snprintf(_str_error_reason, sz_error_reason,
                 "Classifier rule add error,IPv4 and IPv6 config at the same time .");
        MR_ERROR("%s", _str_error_reason);
        return CLASSIFIER_RULE_ADD_IPV4_IPV6_REPEAT;
    }

    /* rule id */
    cJSON * cj_rule_id = cJSON_GetObjectItem(c_rule, MR_CLASSIFIER_CJSON_KEY_RULE_ID);
    /* IP */
    cJSON * cj_src_ip_addr_v4 = cJSON_GetObjectItem(c_rule, MR_CLASSIFIER_CJSON_KEY_SRC_IP_V4);
    cJSON * cj_dst_ip_addr_v4 = cJSON_GetObjectItem(c_rule, MR_CLASSIFIER_CJSON_KEY_DST_IP_V4);
    cJSON * cj_src_ip_addr_v6 = cJSON_GetObjectItem(c_rule, MR_CLASSIFIER_CJSON_KEY_SRC_IP_V6);
    cJSON * cj_dst_ip_addr_v6 = cJSON_GetObjectItem(c_rule, MR_CLASSIFIER_CJSON_KEY_DST_IP_V6);
    /* IP Mask */
    cJSON * cj_src_ip_mask = cJSON_GetObjectItem(c_rule, MR_CLASSIFIER_CJSON_KEY_SRC_IP_MASK);
    cJSON * cj_dst_ip_mask = cJSON_GetObjectItem(c_rule, MR_CLASSIFIER_CJSON_KEY_DST_IP_MASK);
    /* Port */
    cJSON * cj_src_port_range_start = cJSON_GetObjectItem(c_rule, MR_CLASSIFIER_CJSON_KEY_SRC_PORT_LOW);
    cJSON * cj_src_port_range_end = cJSON_GetObjectItem(c_rule, MR_CLASSIFIER_CJSON_KEY_SRC_PORT_HIGH);
    cJSON * cj_dst_port_range_start = cJSON_GetObjectItem(c_rule, MR_CLASSIFIER_CJSON_KEY_DST_PORT_LOW);
    cJSON * cj_dst_port_range_end = cJSON_GetObjectItem(c_rule, MR_CLASSIFIER_CJSON_KEY_DST_PORT_HIGH);
    /* Proto */
    cJSON * cj_proto = cJSON_GetObjectItem(c_rule, MR_CLASSIFIER_CJSON_KEY_PROTO);
    /* Priority */
    cJSON * cj_priority = cJSON_GetObjectItem(c_rule, MR_CLASSIFIER_CJSON_KEY_PRIORITY);
    /* Category */
    cJSON * cj_category = cJSON_GetObjectItem(c_rule, MR_CLASSIFIER_CJSON_KEY_CATEGORY);
    /* Sid */
    cJSON * cj_sid = cJSON_GetObjectItem(c_rule, MR_CLASSIFIER_CJSON_KEY_SID);
    /* Vwire id */
    cJSON * cj_vwire_id = cJSON_GetObjectItem(c_rule, MR_CLASSIFIER_CJSON_KEY_VWIRE_ID);
    /* Ef id */
    cJSON * cj_ef_id = cJSON_GetObjectItem(c_rule, MR_CLASSIFIER_CJSON_KEY_EF_ID);

    /* Check necessary rule field: rule id */
    if (cj_rule_id == NULL)
    {
        snprintf(_str_error_reason, sz_error_reason, "Classifier rule add error,no config rule id .");
        MR_ERROR("%s", _str_error_reason);
        return CLASSIFIER_RULE_ADD_RULE_ID_INVALID;
    }

    /* Check necessary rule field: category */
    if (cj_category == NULL)
    {
        snprintf(_str_error_reason, sz_error_reason, "Classifier rule add error,rule id '%u',no config 'category' .",
                 rule_parse.rule_id);
        MR_ERROR("%s", _str_error_reason);
        return CLASSIFIER_RULE_ADD_CATEGORY_INVALID;
    }

    /* Check necessary rule field: sid */
    if (cj_sid == NULL)
    {
        snprintf(_str_error_reason, sz_error_reason, "Classifier rule add error,rule id '%u',no config 'sid' .",
                 rule_parse.rule_id);
        MR_ERROR("%s", _str_error_reason);
        return CLASSIFIER_RULE_ADD_SID_INVALID;
    }

    /******** Get rule id ********/
    rule_parse.rule_id = *_out_rule_id = (uint32_t)cj_rule_id->valuedouble;

    /******** Get ipv4 src addr and mask ********/
    if (cj_src_ip_addr_v4 != NULL)
    {
        /* Parse src ip addr */
        ret = inet_pton(AF_INET, cj_src_ip_addr_v4->valuestring, &rule_parse.src_ip_addr_v4);
        if ((!ret) && (strcmp(cj_src_ip_addr_v4->valuestring, MR_CLASSIFIER_DEFAULT_STR_IP_ADDR_V4) != 0))
        {
            snprintf(_str_error_reason, sz_error_reason,
                     "Classifier rule add error,rule id '%u',the IPv4 src addr '%s' invalid .", rule_parse.rule_id,
                     cj_src_ip_addr_v4->valuestring);
            MR_ERROR("%s", _str_error_reason);
            return CLASSIFIER_RULE_ADD_SRC_IP_INVALID_V4;
        }

        /* Get src addr mask */
        if (cj_src_ip_mask != NULL)
            rule_parse.src_ip_mask_v4 = (uint32_t)cj_src_ip_mask->valuedouble;
        else
            rule_parse.src_ip_mask_v4 = MR_CLASSIFIER_DEFAULT_IP_MASK_32;
    }

    /******** Get ipv4 dst addr and mask ********/
    if (cj_dst_ip_addr_v4 != NULL)
    {
        /* Parse dst ip addr */
        ret = inet_pton(AF_INET, cj_dst_ip_addr_v4->valuestring, &rule_parse.dst_ip_addr_v4);
        if ((!ret) && (strcmp(cj_dst_ip_addr_v4->valuestring, MR_CLASSIFIER_DEFAULT_STR_IP_ADDR_V4) != 0))
        {
            snprintf(_str_error_reason, sz_error_reason,
                     "Classifier rule add error,rule id '%u',the IPv4 dst addr '%s' invalid .", rule_parse.rule_id,
                     cj_dst_ip_addr_v4->valuestring);
            MR_ERROR("%s", _str_error_reason);
            return CLASSIFIER_RULE_ADD_DST_IP_INVALID_V4;
        }

        /* Get dst addr mask */
        if (cj_dst_ip_mask != NULL)
            rule_parse.dst_ip_mask_v4 = (uint32_t)cj_dst_ip_mask->valuedouble;
        else
            rule_parse.dst_ip_mask_v4 = MR_CLASSIFIER_DEFAULT_IP_MASK_32;
    }

    /******** Get ipv6 src addr and mask ********/
    if (cj_src_ip_addr_v6 != NULL)
    {
        /* Parse src ip addr */
        ret = inet_pton(AF_INET6, cj_src_ip_addr_v6->valuestring, &rule_parse.src_ip_addr_v6);
        if ((!ret) && (strcmp(cj_src_ip_addr_v6->valuestring, MR_CLASSIFIER_DEFAULT_STR_IP_ADDR_V6) != 0))
        {
            snprintf(_str_error_reason, sz_error_reason,
                     "Classifier rule add error,rule id '%u',the IPv6 src addr '%s' invalid .", rule_parse.rule_id,
                     cj_src_ip_addr_v6->valuestring);
            MR_ERROR("%s", _str_error_reason);
            return CLASSIFIER_RULE_ADD_SRC_IP_INVALID_V6;
        }

        /* Get src addr mask */
        if (cj_src_ip_mask != NULL)
            rule_parse.src_ip_mask_v6 = (uint32_t)cj_src_ip_mask->valuedouble;
        else
            rule_parse.src_ip_mask_v6 = MR_CLASSIFIER_DEFAULT_IP_MASK_128;
    }

    /******** Get ipv6 dst addr and mask ********/
    if (cj_dst_ip_addr_v6 != NULL)
    {
        /* Parse dst ip addr */
        ret = inet_pton(AF_INET6, cj_dst_ip_addr_v6->valuestring, &rule_parse.dst_ip_addr_v6);
        if ((!ret) && (strcmp(cj_dst_ip_addr_v6->valuestring, MR_CLASSIFIER_DEFAULT_STR_IP_ADDR_V6) != 0))
        {
            snprintf(_str_error_reason, sz_error_reason,
                     "Classifier rule add error,rule id '%u',the IPv6 dst addr '%s' invalid .", rule_parse.rule_id,
                     cj_dst_ip_addr_v6->valuestring);
            MR_ERROR("%s", _str_error_reason);
            return CLASSIFIER_RULE_ADD_DST_IP_INVALID_V6;
        }

        /* Get dst addr mask */
        if (cj_dst_ip_mask != NULL)
            rule_parse.dst_ip_mask_v6 = (uint32_t)cj_dst_ip_mask->valuedouble;
        else
            rule_parse.dst_ip_mask_v6 = MR_CLASSIFIER_DEFAULT_IP_MASK_128;
    }

    /******** Get src port range start and end ********/
    if (cj_src_port_range_start != NULL)
        rule_parse.src_port_range_start = (uint16_t)cj_src_port_range_start->valuedouble;

    if (cj_src_port_range_end != NULL)
        rule_parse.src_port_range_end = (uint16_t)cj_src_port_range_end->valuedouble;

    if ((cj_src_port_range_start != NULL) && (cj_src_port_range_end == NULL))
    {
        /* No config src range end port but already config src range start port,default set range end port = range start
         * Port */
        rule_parse.src_port_range_end = rule_parse.src_port_range_start;
    }
    else if ((cj_src_port_range_start == NULL) && (cj_src_port_range_end != NULL))
    {
        /* No config src range start port but already config src range end port,default set range start port = range end
         * port */
        rule_parse.src_port_range_start = rule_parse.src_port_range_end;
    }

    /******** Get dst port range start and end ********/
    if (cj_dst_port_range_start != NULL)
        rule_parse.dst_port_range_start = (uint16_t)cj_dst_port_range_start->valuedouble;

    if (cj_dst_port_range_end != NULL)
        rule_parse.dst_port_range_end = (uint16_t)cj_dst_port_range_end->valuedouble;

    if ((cj_dst_port_range_start != NULL) && (cj_dst_port_range_end == NULL))
    {
        /* No config dst range end port but already config dst range start port,default set range end port = range start
         * Port */
        rule_parse.dst_port_range_end = rule_parse.dst_port_range_start;
    }
    else if ((cj_dst_port_range_start == NULL) && (cj_dst_port_range_end != NULL))
    {
        /* No config dst range start port but already config dst range end port,default set range start port = range end
         * port */
        rule_parse.dst_port_range_start = rule_parse.dst_port_range_end;
    }

    /******** Get proto ********/
    if (cj_proto != NULL)
    {
        rule_parse.proto = (uint8_t)cj_proto->valuedouble;
        rule_parse.proto_mask = 0xff;
    }

    /******** Get priority ********/
    if (cj_priority != NULL)
        rule_parse.priority = (uint8_t)cj_priority->valuedouble;

    /******** Get sid ********/
    if (cj_sid != NULL)
        rule_parse.sid = (uint32_t)cj_sid->valuedouble;

    /******** Get category ********/
    if (cj_category != NULL)
        rule_parse.category = (uint16_t)cj_category->valuedouble;

    /******** Get adapter id ********/
    if (cj_vwire_id != NULL)
    {
        rule_parse.adapter_type = CLASSIFIER_TABLE_ADAPTER_VWIRE;
        rule_parse.adapter_id = (uint32_t)cj_vwire_id->valuedouble;
    }
    else if (cj_ef_id != NULL)
    {
        rule_parse.adapter_type = CLASSIFIER_TABLE_ADAPTER_EF;
        rule_parse.adapter_id = (uint32_t)cj_ef_id->valuedouble;
    }
    else
    {
        rule_parse.adapter_type = CLASSIFIER_TABLE_ADAPTER_ALL;
        rule_parse.adapter_id = 0xffffffff;
    }

    /******** Check rule ********/
    ret = classifier_rule_check(&rule_parse, _str_error_reason, sz_error_reason);
    if (ret != CLASSIFIER_RULE_ADD_SUCCESS)
    {
        MR_ERROR("Classifier remote full update,the rule check err: %s", _str_error_reason);
        return ret;
    }

    /******** Save rule ********/
    ret = classifier_rule_add(_classifier_management, &rule_parse, "remote full update", _str_error_reason,
                              sz_error_reason);
    if (ret != CLASSIFIER_RULE_ADD_SUCCESS)
    {
        MR_ERROR("Classifier remote full update,the rule add err: %s", _str_error_reason);
        return ret;
    }

    return CLASSIFIER_RULE_ADD_SUCCESS;
}

/* classifier rule full update Callback */
int classifier_rule_full_update(struct sc_main * sc, cJSON * c_rule, uint32_t * rule_id, char * _str_error_reason,
                                unsigned int sz_error_reason)
{
    struct rte_rcu_qsbr * qsv = g_classifier_main->qsv;
    struct classifier_management * _old_rule_management = g_classifier_main->_classifier_management;

    /* Get rule Array */
    cJSON * cj_rule_array = cJSON_GetObjectItem(c_rule, MR_CLASSIFIER_CJSON_KEY_RULE_ARRAY);
    if (cj_rule_array == NULL)
    {
        snprintf(_str_error_reason, sz_error_reason, "Classifier rule full update error, rule array is null .");
        MR_ERROR("%s", _str_error_reason);
        return CLASSIFIER_RULE_ADD_ERR_RULE_ARRAY_IS_NULL;
    }

    /* Create A New classifier rule management */
    struct classifier_management * _new_rule_management = create_classifier_management();

    /* Parsing local classifier rule */
    int ret = parser_classifier_rule_local(sc, _new_rule_management);
    if (ret == RT_ERR)
    {
        snprintf(_str_error_reason, sz_error_reason, "Classifier rule full update error, parsed local rule error .");
        MR_ERROR("%s", _str_error_reason);
        ret = CLASSIFIER_RULE_ADD_ERR_LOCAL_RULE_ERR;
        goto add_err;
    }

    /* Get rule Num,Parsing Remote full update rule */
    int update_rule_num = cJSON_GetArraySize(cj_rule_array);
    for (int rule_index = 0; rule_index < update_rule_num; rule_index++)
    {
        cJSON * cj_rule_item = cJSON_GetArrayItem(cj_rule_array, rule_index);
        ret = parse_classifier_rule_remote(_new_rule_management, cj_rule_item, rule_id, _str_error_reason,
                                           sz_error_reason);
        if (ret != CLASSIFIER_RULE_ADD_SUCCESS)
            goto add_err;
        _new_rule_management->nr_remote_rules++;
    }

    /* Setup Classifier */
    ret = setup_all_classifier_table(_new_rule_management);
    if (ret == RT_ERR)
    {
        snprintf(_str_error_reason, sz_error_reason, "Classifier rule full update error,setup classifier error .");
        MR_ERROR("%s", _str_error_reason);
        ret = CLASSIFIER_RULE_ADD_ERR_CLASSIFIER_SETUP_ERR;
        goto add_err;
    }

    /* Check fast match condition */
    classifier_fast_match_check(_new_rule_management);

    /* Update Classifier management */
    g_classifier_main->_classifier_management = _new_rule_management;

    /* Classifier rules dump */
    dump_classifier_tables(_new_rule_management);

    /* Wait All Thread Quiescent state */
    rte_rcu_qsbr_synchronize(qsv, RTE_QSBR_THRID_INVALID);

    /* Free Old Classifier management */
    free_classifier_management(_old_rule_management);

    MR_INFO(
        "Classifier rule full update success,total rule num : '%u',remote full update rule num : '%u',local rule num : "
        "'%u'. ",
        _new_rule_management->nr_remote_rules + _new_rule_management->nr_local_rules,
        _new_rule_management->nr_remote_rules, _new_rule_management->nr_local_rules);
    goto add_success;

add_err:
    free_classifier_management(_new_rule_management);
add_success:
    return ret;
}

/* classifier rule full update Request Handler */
static int __classifier_rule_full_update_request_handler(cJSON * req, cJSON ** rsp, void * arg)
{
    uint32_t rule_id = 65535;
    char str_error_reason[MR_STRING_MAX] = {};
    struct sc_main * sc = (struct sc_main *)arg;
    cJSON * response = cJSON_CreateObject();

    int ret = classifier_rule_full_update(sc, req, &rule_id, str_error_reason, sizeof(str_error_reason));
    cJSON_AddNumberToObject(response, MR_CLASSIFIER_RPC_RESULT, ret);
    if (ret != CLASSIFIER_RULE_ADD_SUCCESS)
    {
        cJSON_AddNumberToObject(response, MR_CLASSIFIER_ERR_RULE_ID, rule_id);
        cJSON_AddStringToObject(response, MR_CLASSIFIER_ERR_REASON, str_error_reason);
    }
    *rsp = response;
    return 0;
}

/************************************* Classifier classifier rule **************************************/
/* from classifier rule Config Parser Classifier Rules */
int parser_classifier_rule_local(struct sc_main * sc, struct classifier_management * _classifier_management)
{
    int ret = 0;
    /* Circulation parsing all classifier rule */
    for (int rule_index = 0; rule_index < MAX_RULE_NUM; rule_index++)
    {
        struct rule_parse rule_parse = {};
        rule_parse.src_ip_addr_v4.s_addr = MR_CLASSIFIER_DEFAULT_IP_ADDR_V4;
        rule_parse.dst_ip_addr_v4.s_addr = MR_CLASSIFIER_DEFAULT_IP_ADDR_V4;
        rule_parse.proto = MR_CLASSIFIER_DEFAULT_PROTO_ANY;
        rule_parse.ip_version = MR_NODE_COMMON_IP_VERSION_ANY;
        rule_parse.src_port_range_start = MR_CLASSIFIER_DEFAULT_PORT_START;
        rule_parse.src_port_range_end = MR_CLASSIFIER_DEFAULT_PORT_END;
        rule_parse.dst_port_range_start = MR_CLASSIFIER_DEFAULT_PORT_START;
        rule_parse.dst_port_range_end = MR_CLASSIFIER_DEFAULT_PORT_END;

        /******** Get rule id ********/
        char str_section[MR_SYMBOL_MAX] = {};
        snprintf(str_section, sizeof(str_section), "classifier_rule:%d", rule_index);
        ret = MESA_load_profile_uint_nodef(sc->local_cfgfile, str_section, "rule_id", &rule_parse.rule_id);
        if (ret < 0)
            continue;

        /******** Check local rule id for max ********/
        if (rule_parse.rule_id >= MAX_RULE_NUM)
        {
            MR_ERROR("The classifier rule name : %s 'rule_id' invalid,the local rule id range from 1 to %u. ",
                     str_section, MAX_RULE_NUM);
            return RT_ERR;
        }

        /******** Get ipv4 src addr and mask ********/
        char str_src_ip_addr_v4[MR_SYMBOL_MAX] = {};
        if (MESA_load_profile_string_nodef(sc->local_cfgfile, str_section, "src_ip_addr_v4", str_src_ip_addr_v4,
                                           sizeof(str_src_ip_addr_v4)) > 0)
        {
            rule_parse.ip_version = MR_NODE_COMMON_IP_VERSION_V4;

            ret = inet_pton(AF_INET, str_src_ip_addr_v4, &rule_parse.src_ip_addr_v4);
            if ((!ret) && (strcmp(str_src_ip_addr_v4, MR_CLASSIFIER_DEFAULT_STR_IP_ADDR_V4) != 0))
            {
                MR_ERROR("The IPv4 classifier rule name : %s ,src ip addr is invalid:  %s", str_section,
                         str_src_ip_addr_v4);
                return RT_ERR;
            }

            MESA_load_profile_uint_def(sc->local_cfgfile, str_section, "src_ip_mask_v4", &rule_parse.src_ip_mask_v4,
                                       MR_CLASSIFIER_DEFAULT_IP_MASK_32);
        }

        /******** Get ipv4 dst addr and mask ********/
        char str_dst_ip_addr_v4[MR_SYMBOL_MAX] = {};
        if (MESA_load_profile_string_nodef(sc->local_cfgfile, str_section, "dst_ip_addr_v4", str_dst_ip_addr_v4,
                                           sizeof(str_dst_ip_addr_v4)) > 0)
        {
            rule_parse.ip_version = MR_NODE_COMMON_IP_VERSION_V4;

            ret = inet_pton(AF_INET, str_dst_ip_addr_v4, &rule_parse.dst_ip_addr_v4);
            if ((!ret) && (strcmp(str_dst_ip_addr_v4, MR_CLASSIFIER_DEFAULT_STR_IP_ADDR_V4) != 0))
            {
                MR_ERROR("The IPv4 classifier rule name : %s ,dst ip addr is invalid:  %s", str_section,
                         str_dst_ip_addr_v4);
                return RT_ERR;
            }

            MESA_load_profile_uint_def(sc->local_cfgfile, str_section, "dst_ip_mask_v4", &rule_parse.dst_ip_mask_v4,
                                       MR_CLASSIFIER_DEFAULT_IP_MASK_32);
        }

        /******** Get ipv6 src addr and mask ********/
        char str_src_ip_addr_v6[MR_SYMBOL_MAX] = {};
        if (MESA_load_profile_string_nodef(sc->local_cfgfile, str_section, "src_ip_addr_v6", str_src_ip_addr_v6,
                                           sizeof(str_src_ip_addr_v6)) > 0)
        {
            /* Check ip version */
            if (rule_parse.ip_version == MR_NODE_COMMON_IP_VERSION_V4)
            {
                MR_ERROR("The classifier rule name : %s ,IPv4 or IPv6 only one can be configured .", str_section);
                return RT_ERR;
            }

            rule_parse.ip_version = MR_NODE_COMMON_IP_VERSION_V6;

            ret = inet_pton(AF_INET6, str_src_ip_addr_v6, &rule_parse.src_ip_addr_v6);
            if ((!ret) && (strcmp(str_src_ip_addr_v6, MR_CLASSIFIER_DEFAULT_STR_IP_ADDR_V6) != 0))
            {
                MR_ERROR("The IPv6 classifier rule name : %s ,src ip addr is invalid:  %s", str_section,
                         str_src_ip_addr_v6);
                return RT_ERR;
            }

            MESA_load_profile_uint_def(sc->local_cfgfile, str_section, "src_ip_mask_v6", &rule_parse.src_ip_mask_v6,
                                       MR_CLASSIFIER_DEFAULT_IP_MASK_128);
        }

        /******** Get ipv6 dst addr and mask ********/
        char str_dst_ip_addr_v6[MR_SYMBOL_MAX] = {};
        if (MESA_load_profile_string_nodef(sc->local_cfgfile, str_section, "dst_ip_addr_v6", str_dst_ip_addr_v6,
                                           sizeof(str_dst_ip_addr_v6)) > 0)
        {
            /* Check ip version */
            if (rule_parse.ip_version == MR_NODE_COMMON_IP_VERSION_V4)
            {
                MR_ERROR("The classifier rule name : %s ,IPv4 or IPv6 only one can be configured .", str_section);
                return RT_ERR;
            }

            rule_parse.ip_version = MR_NODE_COMMON_IP_VERSION_V6;

            ret = inet_pton(AF_INET6, str_dst_ip_addr_v6, &rule_parse.dst_ip_addr_v6);
            if ((!ret) && (strcmp(str_dst_ip_addr_v6, MR_CLASSIFIER_DEFAULT_STR_IP_ADDR_V6) != 0))
            {
                MR_ERROR("The IPv6 classifier rule name : %s ,dst ip addr is invalid:  %s", str_section,
                         str_dst_ip_addr_v6);
                return RT_ERR;
            }

            MESA_load_profile_uint_def(sc->local_cfgfile, str_section, "dst_ip_mask_v6", &rule_parse.dst_ip_mask_v6,
                                       MR_CLASSIFIER_DEFAULT_IP_MASK_128);
        }

        /******** Get src port range start and end ********/
        uint32_t src_port_range_start = 0, src_port_range_end = 0;
        int ret_start = MESA_load_profile_uint_def(sc->local_cfgfile, str_section, "src_port_range_start",
                                                   &src_port_range_start, MR_CLASSIFIER_DEFAULT_PORT_START);
        int ret_end = MESA_load_profile_uint_def(sc->local_cfgfile, str_section, "src_port_range_end",
                                                 &src_port_range_end, MR_CLASSIFIER_DEFAULT_PORT_END);
        if ((ret_start >= 0) && (ret_end < 0))
        {
            /* No config src range end Port But Already Config src range Start Port,Default Set Range end Port = Range
             * Start Port */
            src_port_range_end = src_port_range_start;
        }
        else if ((ret_start < 0) && (ret_end >= 0))
        {
            /* No config src range Start Port But Already Config src range end Port,Default Set range start Port = Range
             * end Port */
            src_port_range_start = src_port_range_end;
        }

        rule_parse.src_port_range_start = (uint16_t)src_port_range_start;
        rule_parse.src_port_range_end = (uint16_t)src_port_range_end;

        /******** Get dst port range start and end ********/
        uint32_t dst_port_range_start = 0, dst_port_range_end = 0;
        ret_start = MESA_load_profile_uint_def(sc->local_cfgfile, str_section, "dst_port_range_start",
                                               &dst_port_range_start, MR_CLASSIFIER_DEFAULT_PORT_START);
        ret_end = MESA_load_profile_uint_def(sc->local_cfgfile, str_section, "dst_port_range_end", &dst_port_range_end,
                                             MR_CLASSIFIER_DEFAULT_PORT_END);
        if ((ret_start >= 0) && (ret_end < 0))
        {
            /* No config dst range end Port But Already Config dst range Start Port,Default Set Range end Port = Range
             * Start Port */
            dst_port_range_end = dst_port_range_start;
        }
        else if ((ret_start < 0) && (ret_end >= 0))
        {
            /* No config dst range Start Port But Already Config dst range end Port,Default Set range start Port = Range
             * end Port */
            dst_port_range_start = dst_port_range_end;
        }

        rule_parse.dst_port_range_start = (uint16_t)dst_port_range_start;
        rule_parse.dst_port_range_end = (uint16_t)dst_port_range_end;

        /******** Get proto ********/
        char str_proto[MR_SYMBOL_MAX] = {};
        MESA_load_profile_string_def(sc->local_cfgfile, str_section, "proto", str_proto, sizeof(str_proto),
                                     MR_CLASSIFIER_DEFAULT_PROTO);
        if (strcmp(str_proto, "tcp") == 0)
        {
            rule_parse.proto = IPPROTO_TCP;
            rule_parse.proto_mask = 0xff;
        }
        else if (strcmp(str_proto, "udp") == 0)
        {
            rule_parse.proto = IPPROTO_UDP;
            rule_parse.proto_mask = 0xff;
        }
        else
        {
            rule_parse.proto = MR_CLASSIFIER_DEFAULT_PROTO_ANY;
            rule_parse.proto_mask = 0;
        }

        /******** Get priority ********/
        MESA_load_profile_uint_def(sc->local_cfgfile, str_section, "priority", &rule_parse.priority,
                                   MR_CLASSIFIER_DEFAULT_PRIORITY);

        /******** Get sid ********/
        ret = MESA_load_profile_uint_nodef(sc->local_cfgfile, str_section, "sid", &rule_parse.sid);
        if (ret < 0)
        {
            MR_ERROR("The classifier rule name : %s ,no config the 'sid' .", str_section);
            return RT_ERR;
        }

        /******** Get category ********/
        uint32_t category = 0;
        ret = MESA_load_profile_uint_nodef(sc->local_cfgfile, str_section, "category", &category);
        if (ret < 0)
        {
            MR_ERROR("The classifier rule name : %s ,must config the 'category' .", str_section);
            return RT_ERR;
        }

        rule_parse.category = (uint16_t)category;

        /******** Get adapter id ********/
        uint32_t ef_adapter_id = 0xffffffff;
        uint32_t vwire_adapter_id = 0xffffffff;

        int ef_adapter_ret = MESA_load_profile_uint_nodef(sc->local_cfgfile, str_section, "ef_id", &ef_adapter_id);
        int vwire_adapter_ret =
            MESA_load_profile_uint_nodef(sc->local_cfgfile, str_section, "vwire_id", &vwire_adapter_id);

        if ((ef_adapter_ret >= 0) && (vwire_adapter_ret >= 0))
        {
            MR_ERROR("The classifier rule name : %s ,'ef_id' and 'vwire_id' only one can be configured", str_section);
            return RT_ERR;
        }
        else if (ef_adapter_ret >= 0)
        {
            rule_parse.adapter_type = CLASSIFIER_TABLE_ADAPTER_EF;
            rule_parse.adapter_id = ef_adapter_id;
        }
        else if (vwire_adapter_ret >= 0)
        {
            rule_parse.adapter_type = CLASSIFIER_TABLE_ADAPTER_VWIRE;
            rule_parse.adapter_id = vwire_adapter_id;
        }
        else
        {
            rule_parse.adapter_type = CLASSIFIER_TABLE_ADAPTER_ALL;
            rule_parse.adapter_id = 0xffffffff;
        }

        /******** Check rule ********/
        char str_error_reason[MR_STRING_MAX] = {};
        ret = classifier_rule_check(&rule_parse, str_error_reason, sizeof(str_error_reason));
        if (ret != CLASSIFIER_RULE_ADD_SUCCESS)
        {
            MR_ERROR("The classifier rule name : %s ,check err: %s", str_section, str_error_reason);
            return RT_ERR;
        }

        /******** Save rule ********/
        ret = classifier_rule_add(_classifier_management, &rule_parse, str_section, str_error_reason,
                                  sizeof(str_error_reason));
        if (ret != CLASSIFIER_RULE_ADD_SUCCESS)
        {
            MR_ERROR("The classifier rule name : %s ,add err: %s", str_section, str_error_reason);
            return RT_ERR;
        }

        _classifier_management->nr_local_rules++;
    }

    return RT_SUCCESS;
}

/* Init classifier classifier table */
int classifier_init(struct sc_main * sc)
{
    /* Register IPv4 classifier rule full update Request Handler */
    if (rpc_server_recv_request_register(sc->rpc_srv_handler, MR_CLASSIFIER_TOPIC_FULL_UPDATE,
                                         __classifier_rule_full_update_request_handler, sc) != 0)
    {
        MR_ERROR("The '%s' Request Register Failed . ", MR_CLASSIFIER_TOPIC_FULL_UPDATE);
        return RT_ERR;
    }

    /* Malloc classifier main */
    struct node_classifier_main * classifier_main = ZMALLOC(sizeof(struct node_classifier_main));
    MR_VERIFY_MALLOC(classifier_main);
    g_classifier_main = classifier_main;
    sc->classifier_node_main = classifier_main;

    /* Create classifier management */
    struct classifier_management * _classifier_management = create_classifier_management();
    classifier_main->_classifier_management = _classifier_management;

    /* Init Classifier Rcu */
    size_t sz = rte_rcu_qsbr_get_memsize(RTE_MAX_LCORE);
    classifier_main->qsv = (struct rte_rcu_qsbr *)rte_zmalloc(NULL, sz, RTE_CACHE_LINE_SIZE);
    rte_rcu_qsbr_init(classifier_main->qsv, RTE_MAX_LCORE);
    for (uint32_t worker_id = 0; worker_id < sc->nr_io_thread; worker_id++)
    {
        uint32_t lcore_id = cpu_set_location(&sc->cpu_set_io, worker_id);
        rte_rcu_qsbr_thread_register(classifier_main->qsv, lcore_id);
    }

    /* load to ignore icmp and icmpv6 options */
    MESA_load_profile_uint_def(sc->local_cfgfile, "classifiers", "ignore_all_icmp_pkts",
                               &classifier_main->ignore_all_icmp_pkts, 0);
    MESA_load_profile_uint_def(sc->local_cfgfile, "classifiers", "ignore_all_icmp6_pkts",
                               &classifier_main->ignore_all_icmp6_pkts, 0);

    /* Parser The Classifier Rules */
    int ret = parser_classifier_rule_local(sc, _classifier_management);
    if (ret == RT_ERR)
        return RT_ERR;

    /* Set up classifier table  */
    ret = setup_all_classifier_table(_classifier_management);
    if (ret == RT_ERR)
        return RT_ERR;

    /* Classifier fast match check */
    classifier_fast_match_check(_classifier_management);

    /* Dump all classifier rules */
    dump_classifier_tables(_classifier_management);

    return RT_SUCCESS;
}

/************************************** Classifier Statistics **************************************/
cJSON * classifier_node_monit_loop(struct sc_main * sc)
{
    unsigned int nr_graph_total = sc->nr_io_thread;
    struct node_classifier_main * classifier_main = sc->classifier_node_main;

    cJSON * json_root = cJSON_CreateObject();

    for (uint32_t graph_id = 0; graph_id < nr_graph_total; graph_id++)
    {
        struct classifier_stat * _stat_per_graph = &classifier_main->stat_per_graph[graph_id];

        if (_stat_per_graph->deal_pkts == 0)
            continue;

        cJSON * graph_obj = cJSON_CreateObject();
        cJSON_AddNumberToObject(graph_obj, "deal_pkts", _stat_per_graph->deal_pkts);
        cJSON_AddNumberToObject(graph_obj, "hits", _stat_per_graph->hits);
        cJSON_AddNumberToObject(graph_obj, "miss", _stat_per_graph->miss);
        cJSON_AddNumberToObject(graph_obj, "fast_match", _stat_per_graph->fast_match);
        cJSON_AddNumberToObject(graph_obj, "append_sid_err", _stat_per_graph->append_sid_err);

        char graph_index[MR_STRING_MAX] = {};
        snprintf(graph_index, sizeof(graph_index), "graph-%u", graph_id);
        cJSON_AddItemToObject(json_root, graph_index, graph_obj);
    }

    cJSON_AddNumberToObject(json_root, "total_graph_num", nr_graph_total);
    return json_root;
}