🎈 perf: Optimize the classifier rule parsing process,HealthCheck configuration limit increased to 256v4.6.43-20230815

Optimize the classifier rule parsing process,HealthCheck configuration limit increased to 256

3 files changed, 391 insertions, 547 deletions

diff --git a/service/src/node_classifier.c b/service/src/node_classifier.c
index fc454cb..0b4ff50 100644
--- a/service/src/node_classifier.c
+++ b/service/src/node_classifier.c
@@ -107,7 +107,7 @@ enum
 {
     CLASSIFIER_TABLE_ADAPTER_EF = 0,
     CLASSIFIER_TABLE_ADAPTER_VWIRE,
-    CLASSIFIER_TABLE_ADAPTER_MAX
+    CLASSIFIER_TABLE_ADAPTER_ALL
 };
 
 /* IPv4 field index enum */
@@ -214,7 +214,9 @@ 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;
@@ -230,7 +232,7 @@ struct rule_parse
     struct in_addr dst_ip_addr_v4;
     uint32_t src_ip_addr_v6[4];
     uint32_t dst_ip_addr_v6[4];
-    uint16_t ip_version;
+    uint32_t adapter_id;
 };
 
 /* Match field for ipv4 */
@@ -656,7 +658,7 @@ static __rte_always_inline uint16_t classifier_node_process(struct rte_graph * g
         }
 
         /* all the ICMP packet, go direct to egress, not for nfs */
-        if(g_classifier_main->ignore_all_icmp_pkts)
+        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);
@@ -668,7 +670,7 @@ static __rte_always_inline uint16_t classifier_node_process(struct rte_graph * g
             }
         }
 
-        if(g_classifier_main->ignore_all_icmp6_pkts)
+        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);
@@ -964,11 +966,174 @@ int classifier_rule_check_v6(struct classifier_table_entity * _table_v6, struct
     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, uint32_t adapter_id, uint8_t adapter_type)
+                            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)
     {
@@ -1132,6 +1297,110 @@ int add_rule_for_adapter_id(struct classifier_management * _classifier_managemen
     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 *));
@@ -1714,9 +1983,6 @@ int parse_classifier_rule_remote(struct classifier_management * _classifier_mana
         return CLASSIFIER_RULE_ADD_RULE_ID_INVALID;
     }
 
-    /* Get rule id */
-    rule_parse.rule_id = *_out_rule_id = (uint32_t)cj_rule_id->valuedouble;
-
     /* Check necessary rule field: category */
     if (cj_category == NULL)
     {
@@ -1735,51 +2001,10 @@ int parse_classifier_rule_remote(struct classifier_management * _classifier_mana
         return CLASSIFIER_RULE_ADD_SID_INVALID;
     }
 
-    /* Check ef id and vwire id */
-    if ((cj_vwire_id != NULL) && (cj_ef_id != NULL))
-    {
-        snprintf(_str_error_reason, sz_error_reason,
-                 "Classifier rule add error,rule id '%u','ef_id' and 'vwire_id' only one can be configured .",
-                 rule_parse.rule_id);
-        MR_ERROR("%s", _str_error_reason);
-        return CLASSIFIER_RULE_ADD_ERR_VWIRE_AND_EF_ID_CONFICT;
-    }
-
-    /* Check ef id */
-    uint32_t ef_adapter_id = 0xFFFFFFFF;
-    if (cj_ef_id != NULL)
-    {
-        ef_adapter_id = cj_ef_id->valuedouble;
-        if (ef_adapter_id_check(ef_adapter_id) == RT_ERR)
-        {
-            snprintf(_str_error_reason, sz_error_reason,
-                     "Classifier rule add error,rule id '%u','ef_id = %u' is invalid.", rule_parse.rule_id,
-                     ef_adapter_id);
-            MR_ERROR("%s", _str_error_reason);
-            return CLASSIFIER_RULE_ADD_ERR_EF_ID_INVALID;
-        }
-    }
-
-    /* Check vwire id */
-    uint32_t vwire_adapter_id = 0xFFFFFFFF;
-    if (cj_vwire_id != NULL)
-    {
-        vwire_adapter_id = cj_vwire_id->valuedouble;
-        if (vwire_adapter_id_check(vwire_adapter_id) == RT_ERR)
-        {
-            snprintf(_str_error_reason, sz_error_reason,
-                     "Classifier rule add error,rule id '%u','vwire_id = %u' is invalid.", rule_parse.rule_id,
-                     vwire_adapter_id);
-            MR_ERROR("%s", _str_error_reason);
-            return CLASSIFIER_RULE_ADD_ERR_VWIRE_ID_INVALID;
-        }
-    }
-
-    /* Save the category */
-    rule_parse.category = (uint16_t)cj_category->valuedouble;
+    /******** Get rule id ********/
+    rule_parse.rule_id = *_out_rule_id = (uint32_t)cj_rule_id->valuedouble;
 
-    /******************* Parse src addr *******************/
-    /* Parse ip config */
+    /******** Get ipv4 src addr and mask ********/
     if (cj_src_ip_addr_v4 != NULL)
     {
         /* Parse src ip addr */
@@ -1798,23 +2023,12 @@ int parse_classifier_rule_remote(struct classifier_management * _classifier_mana
             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;
-
-        /* Check src mask and ip addr */
-        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);
-            MR_ERROR("%s", _str_error_reason);
-            return CLASSIFIER_RULE_ADD_SRC_IP_MASK_INVALID_V4;
-        }
     }
 
-    /******************* Parse dst addr *******************/
-    /* Parsing IPv4 dst addr and mask */
+    /******** Get ipv4 dst addr and mask ********/
     if (cj_dst_ip_addr_v4 != NULL)
     {
-        /* Parse src ip addr */
+        /* 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))
         {
@@ -1825,25 +2039,14 @@ int parse_classifier_rule_remote(struct classifier_management * _classifier_mana
             return CLASSIFIER_RULE_ADD_DST_IP_INVALID_V4;
         }
 
-        /* Get Dst Addr Mask */
+        /* 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;
-
-        /* Check dst mask and ip addr */
-        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);
-            MR_ERROR("%s", _str_error_reason);
-            return CLASSIFIER_RULE_ADD_DST_IP_MASK_INVALID_V4;
-        }
     }
 
-    /******************* Parse src addr *******************/
-    /* Parsing IPv6 src addr and mask */
+    /******** Get ipv6 src addr and mask ********/
     if (cj_src_ip_addr_v6 != NULL)
     {
         /* Parse src ip addr */
@@ -1862,20 +2065,9 @@ int parse_classifier_rule_remote(struct classifier_management * _classifier_mana
             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;
-
-        /* Check src mask and ip addr */
-        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);
-            MR_ERROR("%s", _str_error_reason);
-            return CLASSIFIER_RULE_ADD_SRC_IP_MASK_INVALID_V6;
-        }
     }
 
-    /******************* Parse dst addr *******************/
-    /* Parsing IPv6 dst addr and mask */
+    /******** Get ipv6 dst addr and mask ********/
     if (cj_dst_ip_addr_v6 != NULL)
     {
         /* Parse dst ip addr */
@@ -1894,28 +2086,14 @@ int parse_classifier_rule_remote(struct classifier_management * _classifier_mana
             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;
-
-        /* Check dst mask and ip addr */
-        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);
-            MR_ERROR("%s", _str_error_reason);
-            return CLASSIFIER_RULE_ADD_DST_IP_MASK_INVALID_V6;
-        }
     }
 
-    /* Parsing Src Port */
+    /******** 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))
     {
@@ -1930,275 +2108,77 @@ int parse_classifier_rule_remote(struct classifier_management * _classifier_mana
         rule_parse.src_port_range_start = rule_parse.src_port_range_end;
     }
 
-    /* Src port check */
-    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);
-        MR_ERROR("%s", _str_error_reason);
-        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);
-        MR_ERROR("%s", _str_error_reason);
-        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);
-        MR_ERROR("%s", _str_error_reason);
-        return CLASSIFIER_RULE_ADD_SRC_PORT_RANGE_START_THAN_END;
-    }
-
-    /* Parsing dst port */
+    /******** 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
+        /* 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 */
+        /* 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;
     }
 
-    /* dst port Check */
-    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);
-        MR_ERROR("%s", _str_error_reason);
-        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);
-        MR_ERROR("%s", _str_error_reason);
-        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);
-        MR_ERROR("%s", _str_error_reason);
-        return CLASSIFIER_RULE_ADD_DST_PORT_RANGE_START_THAN_END;
-    }
-
-    /* Parsing Proto */
+    /******** Get proto ********/
     if (cj_proto != NULL)
     {
         rule_parse.proto = (uint8_t)cj_proto->valuedouble;
         rule_parse.proto_mask = 0xff;
     }
 
-    /* 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);
-        MR_ERROR("%s", _str_error_reason);
-        return CLASSIFIER_RULE_ADD_PROTO_INVALID;
-    }
-
-    /* Parsing Priority */
+    /******** Get priority ********/
     if (cj_priority != NULL)
-    {
-        rule_parse.priority = (uint32_t)cj_priority->valuedouble;
-    }
+        rule_parse.priority = (uint8_t)cj_priority->valuedouble;
 
-    /* Check The Priority And Save The 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);
-        MR_ERROR("%s", _str_error_reason);
-        return CLASSIFIER_RULE_ADD_PRIORITY_INVALID;
-    }
+    /******** Get sid ********/
+    if (cj_sid != NULL)
+        rule_parse.sid = (uint32_t)cj_sid->valuedouble;
 
-    /* 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));
-        MR_ERROR("%s", _str_error_reason);
-        return CLASSIFIER_RULE_ADD_CATEGORY_INVALID;
-    }
+    /******** Get category ********/
+    if (cj_category != NULL)
+        rule_parse.category = (uint16_t)cj_category->valuedouble;
 
-    /* Check sid */
-    rule_parse.sid = (uint32_t)cj_sid->valuedouble;
-    if (sid_check(rule_parse.sid) == RT_ERR)
+    /******** Get adapter id ********/
+    if (cj_vwire_id != NULL)
     {
-        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);
-        MR_ERROR("%s", _str_error_reason);
-        return CLASSIFIER_RULE_ADD_SID_INVALID;
+        rule_parse.adapter_type = CLASSIFIER_TABLE_ADAPTER_VWIRE;
+        rule_parse.adapter_id = (uint32_t)cj_vwire_id->valuedouble;
     }
-
-    // ############################################################################
-    /* Add the rule fo ef tables */
-    if (cj_ef_id != NULL)
+    else if (cj_ef_id != NULL)
     {
-        /* Fill The rule field for adapter id */
-        int ret = add_rule_for_adapter_id(_classifier_management, "remote full update", &rule_parse, ef_adapter_id,
-                                          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", ef_adapter_id,
-                               rule_parse.rule_id);
-            switch (ret)
-            {
-            case CLASSIFIER_RULE_ADD_ERR_TABLE_IS_NULL:
-                snprintf(_str_error_reason + len, sz_error_reason - len, ",the classifier table is null.");
-                break;
-            case CLASSIFIER_RULE_ADD_ERR_NO_FREE_RULE_ITEM_V4:
-                snprintf(_str_error_reason + len, sz_error_reason - len, ",the ipv4 table already full .");
-                break;
-            case CLASSIFIER_RULE_ADD_ERR_NO_FREE_RULE_ITEM_V6:
-                snprintf(_str_error_reason + len, sz_error_reason - len, ",the ipv6 table already full .");
-                break;
-            case CLASSIFIER_RULE_ADD_ERR_ALREADY_EXISTS_V4:
-                snprintf(_str_error_reason + len, sz_error_reason - len, ",the ipv4 rule already exists .");
-                break;
-            case CLASSIFIER_RULE_ADD_ERR_ALREADY_EXISTS_V6:
-                snprintf(_str_error_reason + len, sz_error_reason - len, ",the ipv6 rule already exists .");
-                break;
-            }
-            return ret;
-        }
+        rule_parse.adapter_type = CLASSIFIER_TABLE_ADAPTER_EF;
+        rule_parse.adapter_id = (uint32_t)cj_ef_id->valuedouble;
     }
-    else if (cj_vwire_id != NULL)
+    else
     {
-        /* Fill The rule field for adapter id */
-        int ret = add_rule_for_adapter_id(_classifier_management, "remote full update", &rule_parse, vwire_adapter_id,
-                                          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",
-                               vwire_adapter_id, rule_parse.rule_id);
-            switch (ret)
-            {
-            case CLASSIFIER_RULE_ADD_ERR_TABLE_IS_NULL:
-                snprintf(_str_error_reason + len, sz_error_reason - len, ",the classifier table is null.");
-                break;
-            case CLASSIFIER_RULE_ADD_ERR_NO_FREE_RULE_ITEM_V4:
-                snprintf(_str_error_reason + len, sz_error_reason - len, ",the ipv4 table already full .");
-                break;
-            case CLASSIFIER_RULE_ADD_ERR_NO_FREE_RULE_ITEM_V6:
-                snprintf(_str_error_reason + len, sz_error_reason - len, ",the ipv6 table already full .");
-                break;
-            case CLASSIFIER_RULE_ADD_ERR_ALREADY_EXISTS_V4:
-                snprintf(_str_error_reason + len, sz_error_reason - len, ",the ipv4 rule already exists .");
-                break;
-            case CLASSIFIER_RULE_ADD_ERR_ALREADY_EXISTS_V6:
-                snprintf(_str_error_reason + len, sz_error_reason - len, ",the ipv6 rule already exists .");
-                break;
-            }
-            return ret;
-        }
+        rule_parse.adapter_type = CLASSIFIER_TABLE_ADAPTER_ALL;
+        rule_parse.adapter_id = 0xffffffff;
     }
-    else
+
+    /******** Check rule ********/
+    ret = classifier_rule_check(&rule_parse, _str_error_reason, sz_error_reason);
+    if (ret != CLASSIFIER_RULE_ADD_SUCCESS)
     {
-        /* 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 */
-            int ret = add_rule_for_adapter_id(_classifier_management, "remote full update", &rule_parse, adapter_id,
-                                              CLASSIFIER_TABLE_ADAPTER_EF);
-            if (ret == CLASSIFIER_RULE_ADD_SUCCESS)
-                continue;
-            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);
-            switch (ret)
-            {
-            case CLASSIFIER_RULE_ADD_ERR_TABLE_IS_NULL:
-                snprintf(_str_error_reason + len, sz_error_reason - len, ",the classifier table is null.");
-                break;
-            case CLASSIFIER_RULE_ADD_ERR_NO_FREE_RULE_ITEM_V4:
-                snprintf(_str_error_reason + len, sz_error_reason - len, ",the ipv4 table already full .");
-                break;
-            case CLASSIFIER_RULE_ADD_ERR_NO_FREE_RULE_ITEM_V6:
-                snprintf(_str_error_reason + len, sz_error_reason - len, ",the ipv6 table already full .");
-                break;
-            case CLASSIFIER_RULE_ADD_ERR_ALREADY_EXISTS_V4:
-                snprintf(_str_error_reason + len, sz_error_reason - len, ",the ipv4 rule already exists .");
-                break;
-            case CLASSIFIER_RULE_ADD_ERR_ALREADY_EXISTS_V6:
-                snprintf(_str_error_reason + len, sz_error_reason - len, ",the ipv6 rule already exists .");
-                break;
-            }
-            return ret;
-        }
+        MR_ERROR("Classifier remote full update,the rule check err: %s", _str_error_reason);
+        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 */
-            int ret = add_rule_for_adapter_id(_classifier_management, "remote full update", &rule_parse, adapter_id,
-                                              CLASSIFIER_TABLE_ADAPTER_VWIRE);
-            if (ret == CLASSIFIER_RULE_ADD_SUCCESS)
-                continue;
-            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);
-            switch (ret)
-            {
-            case CLASSIFIER_RULE_ADD_ERR_TABLE_IS_NULL:
-                snprintf(_str_error_reason + len, sz_error_reason - len, ",the classifier table is null.");
-                break;
-            case CLASSIFIER_RULE_ADD_ERR_NO_FREE_RULE_ITEM_V4:
-                snprintf(_str_error_reason + len, sz_error_reason - len, ",the ipv4 table already full .");
-                break;
-            case CLASSIFIER_RULE_ADD_ERR_NO_FREE_RULE_ITEM_V6:
-                snprintf(_str_error_reason + len, sz_error_reason - len, ",the ipv6 table already full .");
-                break;
-            case CLASSIFIER_RULE_ADD_ERR_ALREADY_EXISTS_V4:
-                snprintf(_str_error_reason + len, sz_error_reason - len, ",the ipv4 rule already exists .");
-                break;
-            case CLASSIFIER_RULE_ADD_ERR_ALREADY_EXISTS_V6:
-                snprintf(_str_error_reason + len, sz_error_reason - len, ",the ipv6 rule already exists .");
-                break;
-            }
-            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;
@@ -2306,6 +2286,7 @@ static int __classifier_rule_full_update_request_handler(cJSON * req, cJSON ** r
 /* 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++)
     {
@@ -2322,72 +2303,57 @@ int parser_classifier_rule_local(struct sc_main * sc, struct classifier_manageme
         /******** Get rule id ********/
         char str_section[MR_SYMBOL_MAX] = {};
         snprintf(str_section, sizeof(str_section), "classifier_rule:%d", rule_index);
-        int ret = MESA_load_profile_uint_nodef(sc->local_cfgfile, str_section, "rule_id", &rule_parse.rule_id);
+        ret = MESA_load_profile_uint_nodef(sc->local_cfgfile, str_section, "rule_id", &rule_parse.rule_id);
         if (ret < 0)
             continue;
 
-        /* Check classifier rule id */
-        if ((rule_parse.rule_id < MR_CLASSIFIER_START_RULE_ID) || (rule_parse.rule_id > MAX_RULE_NUM))
+        /******** 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 rule id range from 1 to %u. ", str_section,
-                     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 ********/
+        /******** 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;
-            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);
-
-            /* Check Src Mask And Ip Addr */
-            if (rule_parse.src_ip_mask_v4 > MR_CLASSIFIER_DEFAULT_IP_MASK_32)
-            {
-                MR_ERROR("The IPv4 classifier rule name : %s ,config the src ip addr mask :  %u  is invalid .",
-                         str_section, rule_parse.src_ip_mask_v4);
-                return RT_ERR;
-            }
 
-            /* Parse src ip addr */
-            int ret = inet_pton(AF_INET, str_src_ip_addr_v4, &rule_parse.src_ip_addr_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 ********/
+        /******** 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;
-            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);
 
-            /* Check Dst Mask And Ip Addr */
-            if (rule_parse.dst_ip_mask_v4 > MR_CLASSIFIER_DEFAULT_IP_MASK_32)
-            {
-                MR_ERROR("The IPv4 classifier rule name : %s ,config the dst ip addr mask :  %u is invalid .",
-                         str_section, rule_parse.dst_ip_mask_v4);
-                return RT_ERR;
-            }
-
-            int ret = inet_pton(AF_INET, str_dst_ip_addr_v4, &rule_parse.dst_ip_addr_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 ********/
+        /******** 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)
@@ -2399,22 +2365,8 @@ int parser_classifier_rule_local(struct sc_main * sc, struct classifier_manageme
                 return RT_ERR;
             }
 
-            /* Fill ip version */
             rule_parse.ip_version = MR_NODE_COMMON_IP_VERSION_V6;
 
-            /* Get ip mask */
-            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);
-
-            /* Check mask and ip */
-            if (rule_parse.src_ip_mask_v6 > MR_CLASSIFIER_DEFAULT_IP_MASK_128)
-            {
-                MR_ERROR("The IPv6 classifier rule name : %s ,config the src ip addr mask :  %u is invalid .",
-                         str_section, rule_parse.src_ip_mask_v6);
-                return RT_ERR;
-            }
-
-            /* Parse src ip */
             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))
             {
@@ -2422,9 +2374,12 @@ int parser_classifier_rule_local(struct sc_main * sc, struct classifier_manageme
                          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 ********/
+        /******** 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)
@@ -2436,22 +2391,8 @@ int parser_classifier_rule_local(struct sc_main * sc, struct classifier_manageme
                 return RT_ERR;
             }
 
-            /* Fill ip version */
             rule_parse.ip_version = MR_NODE_COMMON_IP_VERSION_V6;
 
-            /* Get ip mask */
-            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);
-
-            /* Check mask and ip */
-            if (rule_parse.dst_ip_mask_v6 > MR_CLASSIFIER_DEFAULT_IP_MASK_128)
-            {
-                MR_ERROR("The IPv6 classifier rule name : %s ,config the dst ip addr mask :  %u is invalid .",
-                         str_section, rule_parse.dst_ip_mask_v6);
-                return RT_ERR;
-            }
-
-            /* Parse dst ip addr */
             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))
             {
@@ -2459,15 +2400,17 @@ int parser_classifier_rule_local(struct sc_main * sc, struct classifier_manageme
                          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 ********/
+        /******** 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
@@ -2481,33 +2424,10 @@ int parser_classifier_rule_local(struct sc_main * sc, struct classifier_manageme
             src_port_range_start = src_port_range_end;
         }
 
-        /* Src port check */
-        if (src_port_range_start > MR_CLASSIFIER_MAX_PORT)
-        {
-            MR_ERROR("The classifier rule name : %s ,config the src port range start:  %u  is invalid .", str_section,
-                     src_port_range_start);
-            return RT_ERR;
-        }
-
-        if (src_port_range_end > MR_CLASSIFIER_MAX_PORT)
-        {
-            MR_ERROR("The classifier rule name : %s ,config the src port range end:  %u  is invalid .", str_section,
-                     src_port_range_end);
-            return RT_ERR;
-        }
-
-        if (src_port_range_start > src_port_range_end)
-        {
-            MR_ERROR(
-                "The classifier rule name : %s ,the src port range start : %u should less than src port range end: "
-                " %u .",
-                str_section, src_port_range_start, src_port_range_end);
-            return RT_ERR;
-        }
         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 ********/
+        /******** 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);
@@ -2515,44 +2435,21 @@ int parser_classifier_rule_local(struct sc_main * sc, struct classifier_manageme
                                              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
+            /* 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
+            /* 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;
         }
 
-        /* Dest port check */
-        if (dst_port_range_start > MR_CLASSIFIER_MAX_PORT)
-        {
-            MR_ERROR("The classifier rule name : %s ,config the dst port range start:  %u  is invalid .", str_section,
-                     dst_port_range_start);
-            return RT_ERR;
-        }
-
-        if (dst_port_range_end > MR_CLASSIFIER_MAX_PORT)
-        {
-            MR_ERROR("The classifier rule name : %s ,config the dst port Range end:  %u  is invalid .", str_section,
-                     dst_port_range_end);
-            return RT_ERR;
-        }
-
-        if (dst_port_range_start > dst_port_range_end)
-        {
-            MR_ERROR(
-                "The classifier rule name : %s ,the dst port range start : %u should less than dst port range end: "
-                " %u  is invalid .",
-                str_section, dst_port_range_start, dst_port_range_end);
-            return RT_ERR;
-        }
         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 ********/
+        /******** 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);
@@ -2575,15 +2472,8 @@ int parser_classifier_rule_local(struct sc_main * sc, struct classifier_manageme
         /******** Get priority ********/
         MESA_load_profile_uint_def(sc->local_cfgfile, str_section, "priority", &rule_parse.priority,
                                    MR_CLASSIFIER_DEFAULT_PRIORITY);
-        /* Check The Priority And Save The Priority */
-        if ((rule_parse.priority < MR_CLASSIFIER_MIN_PRIORITY) || (rule_parse.priority > RTE_ACL_MAX_PRIORITY))
-        {
-            MR_ERROR("The classifier rule name : %s ,priority is invalid: %d ,the valid range is from 1 to %u",
-                     str_section, rule_parse.priority, RTE_ACL_MAX_PRIORITY);
-            return RT_ERR;
-        }
 
-        /******** Get Sid ********/
+        /******** Get sid ********/
         ret = MESA_load_profile_uint_nodef(sc->local_cfgfile, str_section, "sid", &rule_parse.sid);
         if (ret < 0)
         {
@@ -2591,14 +2481,7 @@ int parser_classifier_rule_local(struct sc_main * sc, struct classifier_manageme
             return RT_ERR;
         }
 
-        /* Check sid */
-        if (sid_check(rule_parse.sid) == RT_ERR)
-        {
-            MR_ERROR("The classifier rule name : %s 'sid' is invalid: %u ", str_section, rule_parse.sid);
-            return RT_ERR;
-        }
-
-        /* Get category  */
+        /******** Get category ********/
         uint32_t category = 0;
         ret = MESA_load_profile_uint_nodef(sc->local_cfgfile, str_section, "category", &category);
         if (ret < 0)
@@ -2607,100 +2490,55 @@ int parser_classifier_rule_local(struct sc_main * sc, struct classifier_manageme
             return RT_ERR;
         }
 
-        /* Check category*/
-        if (category >= MR_CLASSIFIER_MAX_CATEGORIES)
-        {
-            MR_ERROR("The classifier rule name : %s ,'category' invalid:%u max 'category' Is:%u", str_section, category,
-                     (MR_CLASSIFIER_MAX_CATEGORIES - 1));
-            return RT_ERR;
-        }
         rule_parse.category = (uint16_t)category;
 
-        /* Get etherfabric adapter id  */
-        uint32_t ef_adapter_id = 0xFFFFFFFF;
-        int ef_adapter_ret = MESA_load_profile_uint_nodef(sc->local_cfgfile, str_section, "ef_id", &ef_adapter_id);
+        /******** Get adapter id ********/
+        uint32_t ef_adapter_id = 0xffffffff;
+        uint32_t vwire_adapter_id = 0xffffffff;
 
-        /* Get etherfabric adapter id  */
-        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_adapter_id' and 'vwire_adapter_id' only one can be configured",
-                     str_section);
+            MR_ERROR("The classifier rule name : %s ,'ef_id' and 'vwire_id' only one can be configured", str_section);
             return RT_ERR;
         }
-
-        if (ef_adapter_ret >= 0)
+        else if (ef_adapter_ret >= 0)
         {
-            if (ef_adapter_id_check(ef_adapter_id) == RT_ERR)
-            {
-                MR_ERROR("The classifier rule name : %s ,ef_adapter_id = %u is invalid.", str_section, ef_adapter_id);
-                return RT_ERR;
-            }
-
-            /* Fill The rule field for adapter id */
-            int ret = add_rule_for_adapter_id(_classifier_management, str_section, &rule_parse, ef_adapter_id,
-                                              CLASSIFIER_TABLE_ADAPTER_EF);
-            if (ret != CLASSIFIER_RULE_ADD_SUCCESS)
-            {
-                MR_ERROR("The classifier rule name : %s ,add rule err.", str_section);
-                return RT_ERR;
-            }
+            rule_parse.adapter_type = CLASSIFIER_TABLE_ADAPTER_EF;
+            rule_parse.adapter_id = ef_adapter_id;
         }
         else if (vwire_adapter_ret >= 0)
         {
-            if (vwire_adapter_id_check(vwire_adapter_id) == RT_ERR)
-            {
-                MR_ERROR("The classifier rule name : %s ,vwire_adapter_id = %u is invalid.", str_section,
-                         vwire_adapter_id);
-                return RT_ERR;
-            }
-
-            /* Fill The rule field for adapter id */
-            int ret = add_rule_for_adapter_id(_classifier_management, str_section, &rule_parse, vwire_adapter_id,
-                                              CLASSIFIER_TABLE_ADAPTER_VWIRE);
-            if (ret != CLASSIFIER_RULE_ADD_SUCCESS)
-            {
-                MR_ERROR("The classifier rule name : %s ,add rule err.", str_section);
-                return RT_ERR;
-            }
+            rule_parse.adapter_type = CLASSIFIER_TABLE_ADAPTER_VWIRE;
+            rule_parse.adapter_id = vwire_adapter_id;
         }
         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 */
-                int ret = add_rule_for_adapter_id(_classifier_management, str_section, &rule_parse, adapter_id,
-                                                  CLASSIFIER_TABLE_ADAPTER_EF);
-                if (ret != CLASSIFIER_RULE_ADD_SUCCESS)
-                {
-                    MR_ERROR("The classifier rule name : %s,adapter type is:%u, adapter id is :%u, add rule err.",
-                             str_section, CLASSIFIER_TABLE_ADAPTER_EF, adapter_id);
-                    return RT_ERR;
-                }
-            }
+            rule_parse.adapter_type = CLASSIFIER_TABLE_ADAPTER_ALL;
+            rule_parse.adapter_id = 0xffffffff;
+        }
 
-            /* 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 */
-                int ret = add_rule_for_adapter_id(_classifier_management, str_section, &rule_parse, adapter_id,
-                                                  CLASSIFIER_TABLE_ADAPTER_VWIRE);
-                if (ret != CLASSIFIER_RULE_ADD_SUCCESS)
-                {
-                    MR_ERROR("The classifier rule name : %s,adapter type is:%u, adapter id is :%u, add rule err.",
-                             str_section, CLASSIFIER_TABLE_ADAPTER_VWIRE, adapter_id);
-                    return RT_ERR;
-                }
-            }
+        /******** 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++;
     }
 
@@ -2739,8 +2577,10 @@ int classifier_init(struct sc_main * sc)
     }
 
     /* 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);
+    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);
diff --git a/service/src/node_forwarder.c b/service/src/node_forwarder.c
index 84fff2e..5c697d3 100644
--- a/service/src/node_forwarder.c
+++ b/service/src/node_forwarder.c
@@ -59,8 +59,12 @@ struct forwarder_main * global_forwarder_main = &forwarder_main;
 /* Sid check */
 int sid_check(uint32_t sid)
 {
+    if (sid >= FORWARDER_MAX_SID_NM)
+        return RT_ERR;
+
     if (global_forwarder_main->forwarder_table[sid] == 0)
         return RT_ERR;
+
     return RT_SUCCESS;
 }
 
diff --git a/service/src/node_health_check.c b/service/src/node_health_check.c
index 61a6f2b..a677575 100644
--- a/service/src/node_health_check.c
+++ b/service/src/node_health_check.c
@@ -15,7 +15,7 @@
 #include <string.h>
 #include <unistd.h>
 
-#define MAX_HEALTH_CHECK_CONFIG_NUM 64
+#define MAX_HEALTH_CHECK_CONFIG_NUM 256
 #define MAX_HEALTH_CHECK_SESSION_NUM 256
 #define DEFAULT_PRIVATE_MULTIPLIER 3
 #define DEFAULT_PRIVATE_INTERVAL 200