🎈 perf(TSG-10188): 模块名修改为Flow

模块名修改为Flow

TSG-10188

1 files changed, 152 insertions, 152 deletions

diff --git a/tools/mrctl/mrctl.c b/tools/mrctl/mrctl.c
index 4b2d501..47e4aa8 100644
--- a/tools/mrctl/mrctl.c
+++ b/tools/mrctl/mrctl.c
@@ -17,7 +17,7 @@
 #define MR_CLI_ARG_LIST                             "hcsdg:iep:"
 #define MR_CLI_RESPONSE_DISABLE                     0
 #define MR_CLI_RESPONSE_ENABLE                      1
-#define MR_CLI_CLOSE_DELAY                          10
+#define MR_CLI_CLOSE_DELAY                          100
 
 /* Cli Arg List */
 enum mr_cli_arg
@@ -66,7 +66,7 @@ enum mr_cli_arg
 };
 
 /* Rule Flg */
-enum mr_cli_rule_flg
+enum mr_cli_rule_flag
 {
     MR_RULE_TYPE_ENABLE = 1 << 0,
     MR_RULE_ITEM_ENABLE = 1 << 1,
@@ -154,16 +154,16 @@ void ether_format_addr(char *buf, uint16_t size,
 }
 
 /* Rule Check */
-int rule_check(struct mrctl_offload_rule * rule_item)
+int rule_check(struct mrctl_flow_rule * rule_item)
 {
-    struct mr_offload_item_ether * ether_item = NULL;
-    struct mr_offload_item_ipv4 * ipv4_item = NULL;
-    struct mr_offload_item_udp * udp_item = NULL;
-    struct mr_offload_item_tcp * tcp_item = NULL;
-    struct mr_offload_item_vxlan * vxlan_item = NULL;
-    struct mr_offload_action_count * count_action = NULL;
-    struct mr_offload_action_queue * queue_action = NULL;
-    struct mr_offload_action_set_mac * set_src_mac_action = NULL, * set_dst_mac_action = NULL;
+    struct mr_flow_item_ether * ether_item = NULL;
+    struct mr_flow_item_ipv4 * ipv4_item = NULL;
+    struct mr_flow_item_udp * udp_item = NULL;
+    struct mr_flow_item_tcp * tcp_item = NULL;
+    struct mr_flow_item_vxlan * vxlan_item = NULL;
+    struct mr_flow_action_count * count_action = NULL;
+    struct mr_flow_action_queue * queue_action = NULL;
+    struct mr_flow_action_set_mac * set_src_mac_action = NULL, * set_dst_mac_action = NULL;
 
     ether_item = &rule_item->items[MR_RULE_FLOW_ITEM_ETHER].ether_item;
     ipv4_item = &rule_item->items[MR_RULE_FLOW_ITEM_IPV4].ipv4_item;
@@ -184,14 +184,14 @@ int rule_check(struct mrctl_offload_rule * rule_item)
     }
 
     /* 1.2 Check Direction */
-    if ((!(rule_item->attrs.arg_flg & MR_RULE_FLOW_ATTR_ARG_INGRESS_ENABLE)) && (!(rule_item->attrs.arg_flg & MR_RULE_FLOW_ATTR_ARG_INGRESS_ENABLE)) )
+    if ((!(rule_item->attrs.arg_flag & MR_RULE_FLOW_ATTR_ARG_INGRESS_ENABLE)) && (!(rule_item->attrs.arg_flag & MR_RULE_FLOW_ATTR_ARG_INGRESS_ENABLE)) )
     {
         printf("ERROR : Direction Need Must Choose \n");
         return RT_ERR;
     }
 
     /* 1.3 Check PortName */
-    if (!(rule_item->attrs.arg_flg & MR_RULE_FLOW_ATTR_ARG_PORTNAME_ENABLE) )
+    if (!(rule_item->attrs.arg_flag & MR_RULE_FLOW_ATTR_ARG_PORTNAME_ENABLE) )
     {
         printf("ERROR : Portname Need Must Set \n");
         return RT_ERR;
@@ -206,34 +206,34 @@ int rule_check(struct mrctl_offload_rule * rule_item)
     }
 
     /* 2.2 Check Ether Item */
-    if ((rule_item->item_list & MR_RULE_FLOW_ITEM_LIST_ETHER) && (ether_item->arg_flg == MR_RULE_FLOW_ETHER_ARG_NOT_SET))
+    if ((rule_item->item_list & MR_RULE_FLOW_ITEM_LIST_ETHER) && (ether_item->arg_flag == MR_RULE_FLOW_ETHER_ARG_NOT_SET))
     {
         printf("ERROR : Set At Least One Ether Arg \n");
         return RT_ERR;
     }
     /* 2.3 Check IPv4 Item */
-    if ((rule_item->item_list & MR_RULE_FLOW_ITEM_LIST_IPV4) && (ipv4_item->arg_flg == MR_RULE_FLOW_IPV4_ARG_NOT_SET))
+    if ((rule_item->item_list & MR_RULE_FLOW_ITEM_LIST_IPV4) && (ipv4_item->arg_flag == MR_RULE_FLOW_IPV4_ARG_NOT_SET))
     {
         printf("ERROR : Set At Least One IPv4 Arg \n");
         return RT_ERR;
     }
 
     /* 2.4 Check UDP Item */
-    if ((rule_item->item_list & MR_RULE_FLOW_ITEM_LIST_UDP) && (udp_item->arg_flg == MR_RULE_FLOW_UDP_ARG_NOT_SET))
+    if ((rule_item->item_list & MR_RULE_FLOW_ITEM_LIST_UDP) && (udp_item->arg_flag == MR_RULE_FLOW_UDP_ARG_NOT_SET))
     {
         printf("ERROR : Set At Least One UDP Arg \n");
         return RT_ERR;
     }
 
     /* 2.5 Check TCP Item */
-    if ((rule_item->item_list & MR_RULE_FLOW_ITEM_LIST_TCP) && (tcp_item->arg_flg == MR_RULE_FLOW_TCP_ARG_NOT_SET))
+    if ((rule_item->item_list & MR_RULE_FLOW_ITEM_LIST_TCP) && (tcp_item->arg_flag == MR_RULE_FLOW_TCP_ARG_NOT_SET))
     {
         printf("ERROR : Set At Least One TCP Arg \n");
         return RT_ERR;
     }
 
     /* 2.6 Check VXLAN Item */
-    if ((rule_item->item_list & MR_RULE_FLOW_ITEM_LIST_VXLAN) && (vxlan_item->arg_flg == MR_RULE_FLOW_VXLAN_ARG_NOT_SET))
+    if ((rule_item->item_list & MR_RULE_FLOW_ITEM_LIST_VXLAN) && (vxlan_item->arg_flag == MR_RULE_FLOW_VXLAN_ARG_NOT_SET))
     {
         printf("ERROR : Set At Least One VXLAN Arg \n");
         return RT_ERR;
@@ -248,28 +248,28 @@ int rule_check(struct mrctl_offload_rule * rule_item)
     }
 
     /* 3.2 Check Count Action */
-    if ((rule_item->action_list & MR_RULE_FLOW_ACTION_LIST_COUNT) && (count_action->arg_flg == MR_RULE_FLOW_COUNT_ARG_NOT_SET))
+    if ((rule_item->action_list & MR_RULE_FLOW_ACTION_LIST_COUNT) && (count_action->arg_flag == MR_RULE_FLOW_COUNT_ARG_NOT_SET))
     {
         printf("ERROR : Set At Least One Count Arg \n");
         return RT_ERR;
     }
 
     /* 3.3 Check Queue Action */
-    if ((rule_item->action_list & MR_RULE_FLOW_ACTION_LIST_QUEUE) && (queue_action->arg_flg == MR_RULE_FLOW_QUEUE_ARG_NOT_SET))
+    if ((rule_item->action_list & MR_RULE_FLOW_ACTION_LIST_QUEUE) && (queue_action->arg_flag == MR_RULE_FLOW_QUEUE_ARG_NOT_SET))
     {
         printf("ERROR : Set At Least One Queue Arg \n");
         return RT_ERR;
     }
 
     /* 3.4 Check Set Src Mac Action */
-    if ((rule_item->action_list & MR_RULE_FLOW_ACTION_LIST_SET_SRC_MAC) && (set_src_mac_action->arg_flg == MR_RULE_FLOW_SET_SRC_MAC_ARG_NOT_SET))
+    if ((rule_item->action_list & MR_RULE_FLOW_ACTION_LIST_SET_SRC_MAC) && (set_src_mac_action->arg_flag == MR_RULE_FLOW_SET_SRC_MAC_ARG_NOT_SET))
     {
         printf("ERROR : Set At Least One Set Src Mac Arg \n");
         return RT_ERR;
     }
 
     /* 3.5 Check Set Dst Mac Action */
-    if ((rule_item->action_list & MR_RULE_FLOW_ACTION_LIST_SET_DST_MAC) && (set_dst_mac_action->arg_flg == MR_RULE_FLOW_SET_DST_MAC_ARG_NOT_SET))
+    if ((rule_item->action_list & MR_RULE_FLOW_ACTION_LIST_SET_DST_MAC) && (set_dst_mac_action->arg_flag == MR_RULE_FLOW_SET_DST_MAC_ARG_NOT_SET))
     {
         printf("ERROR : Set At Least One Set Dst Mac Arg \n");
         return RT_ERR;
@@ -325,20 +325,20 @@ static int __conn_close_handler(struct ctrlmsg_handler * ct_hand,
     exit(EXIT_FAILURE);
 }
 
-/* Offload create response */
-static int __offload_create_response_handler(struct ctrlmsg_handler * ct_hand, struct ctrlmsg_conn * ct_conn, struct ctrl_msg_header * msg, void * arg)
+/* Flow create response */
+static int __flow_create_response_handler(struct ctrlmsg_handler * ct_hand, struct ctrlmsg_conn * ct_conn, struct ctrl_msg_header * msg, void * arg)
 {
     cJSON* cjson_error = NULL;
-    struct ctrl_msg_offload_response * rep_msg = (struct ctrl_msg_offload_response *)msg;
+    struct ctrl_msg_flow_response * rep_msg = (struct ctrl_msg_flow_response *)msg;
     struct mrctl_instance * mrctl_instance = (struct mrctl_instance *)arg;
 
     if (rep_msg->msg_err.errcode == RT_SUCCESS)
     {
-        printf("The Offload Rule Create Sucess.\n");
+        printf("The Flow Rule Create Sucess.\n");
     }
     else
     {
-        printf("The Offload Rule Create Error.\n");
+        printf("The Flow Rule Create Error.\n");
         cjson_error = cJSON_Parse((char *)rep_msg->msg_err.strerr);
         if (cjson_error == NULL)
         {
@@ -357,11 +357,11 @@ static int __offload_create_response_handler(struct ctrlmsg_handler * ct_hand, s
     return RT_SUCCESS;
 }
 
-/* Offload Search Response */
-static int __offload_search_response_handler(struct ctrlmsg_handler * ct_hand, struct ctrlmsg_conn * ct_conn, struct ctrl_msg_header * msg, void * arg)
+/* Flow Search Response */
+static int __flow_search_response_handler(struct ctrlmsg_handler * ct_hand, struct ctrlmsg_conn * ct_conn, struct ctrl_msg_header * msg, void * arg)
 {
     cJSON* cjson_search_response = NULL;
-    struct ctrl_msg_offload_response * rep_msg = (struct ctrl_msg_offload_response *)msg;
+    struct ctrl_msg_flow_response * rep_msg = (struct ctrl_msg_flow_response *)msg;
     struct mrctl_instance * mrctl_instance = (struct mrctl_instance *)arg;
 
     if (rep_msg->msg_err.errcode == RT_SUCCESS)
@@ -662,7 +662,7 @@ static int __offload_search_response_handler(struct ctrlmsg_handler * ct_hand, s
                         {
                             printf("\t\t  Vxlan [");
                             /* Get Vxlan Item Arg Flg */
-                            cJSON * cj_vxlan_item_arg_flag = cJSON_GetObjectItem(cj_vxlan_item,MR_CJSON_KEY_ARG_FLG);
+                            cJSON * cj_vxlan_item_arg_flag = cJSON_GetObjectItem(cj_vxlan_item,MR_CJSON_KEY_ARG_FLAG);
                             if (cj_vxlan_item_arg_flag != NULL)
                             {
                                 printf("  Flags: %u",(uint16_t)cj_vxlan_item_arg_flag->valuedouble);
@@ -783,21 +783,21 @@ static int __offload_search_response_handler(struct ctrlmsg_handler * ct_hand, s
     }
     else
     {
-        printf("The Offload Rule Search Error.\n");
+        printf("The Flow Rule Search Error.\n");
     }
     return RT_SUCCESS;
 }
 
 /* Send Request Msg */
-int send_create_request_msg(struct mrctl_instance * instance, struct mrctl_offload_rule * rule_item)
+int send_create_request_msg(struct mrctl_instance * instance, struct mrctl_flow_rule * rule_item)
 {
     cJSON *cjson_rule = NULL,*cjson_attr = NULL;
     cJSON *cjson_item = NULL,*cjson_ether_item = NULL,*cjson_ipv4_item = NULL,*cjson_udp_item = NULL,*cjson_tcp_item = NULL,*cjson_vxlan_item = NULL;
     cJSON *cjson_action = NULL,*cjson_action_count = NULL,*cjson_action_drop = NULL,*cjson_action_queue = NULL,*cjson_action_set_src_mac = NULL,*cjson_action_set_dst_mac = NULL;
-    struct ctrl_msg_offload_request req_msg;
+    struct ctrl_msg_flow_request req_msg;
 
     memset(&req_msg, 0, sizeof(req_msg));
-    ctrl_msg_header_construct(&req_msg.msg_header, sizeof(req_msg), CTRL_MSG_TYPE_REQUEST, CTRLMSG_TOPIC_OFFLOAD_CREATE);
+    ctrl_msg_header_construct(&req_msg.msg_header, sizeof(req_msg), CTRL_MSG_TYPE_REQUEST, CTRLMSG_TOPIC_FLOW_CREATE);
 
     cjson_rule = cJSON_CreateObject();
     cjson_attr = cJSON_CreateObject();
@@ -820,23 +820,23 @@ int send_create_request_msg(struct mrctl_instance * instance, struct mrctl_offlo
     cJSON_AddNumberToObject(cjson_rule, MR_CJSON_KEY_RULE_TYPE, rule_item->rule_type);
 
     /* Attr */
-    cJSON_AddNumberToObject(cjson_attr, MR_CJSON_KEY_ARG_FLG, rule_item->attrs.arg_flg);
+    cJSON_AddNumberToObject(cjson_attr, MR_CJSON_KEY_ARG_FLAG, rule_item->attrs.arg_flag);
 
-    if(rule_item->attrs.arg_flg & MR_RULE_FLOW_ATTR_ARG_GROUP_ENABLE)
+    if(rule_item->attrs.arg_flag & MR_RULE_FLOW_ATTR_ARG_GROUP_ENABLE)
     {
         cJSON_AddNumberToObject(cjson_attr, MR_CJSON_KEY_ATTR_GROUP, rule_item->attrs.attr.group);
     }
 
-    if(rule_item->attrs.arg_flg & MR_RULE_FLOW_ATTR_ARG_PRIORITY_ENABLE)
+    if(rule_item->attrs.arg_flag & MR_RULE_FLOW_ATTR_ARG_PRIORITY_ENABLE)
     {
         cJSON_AddNumberToObject(cjson_attr, MR_CJSON_KEY_ATTR_PRIORITY, rule_item->attrs.attr.priority);
     }
 
-    if(rule_item->attrs.arg_flg & MR_RULE_FLOW_ATTR_ARG_INGRESS_ENABLE)
+    if(rule_item->attrs.arg_flag & MR_RULE_FLOW_ATTR_ARG_INGRESS_ENABLE)
     {
         cJSON_AddNumberToObject(cjson_attr, MR_CJSON_KEY_ATTR_INGRESS, MR_RULE_ARG_ENABLE);
     }
-    if(rule_item->attrs.arg_flg & MR_RULE_FLOW_ATTR_ARG_EGRESS_ENABLE)
+    if(rule_item->attrs.arg_flag & MR_RULE_FLOW_ATTR_ARG_EGRESS_ENABLE)
     {
         cJSON_AddNumberToObject(cjson_attr, MR_CJSON_KEY_ATTR_EGRESS, MR_RULE_ARG_ENABLE);
     }
@@ -849,43 +849,43 @@ int send_create_request_msg(struct mrctl_instance * instance, struct mrctl_offlo
     /* Ether Item */
     if(rule_item->item_list & MR_RULE_FLOW_ITEM_LIST_ETHER)
     {
-        struct mr_offload_item_ether * ether_item = &rule_item->items[MR_RULE_FLOW_ITEM_ETHER].ether_item;
+        struct mr_flow_item_ether * ether_item = &rule_item->items[MR_RULE_FLOW_ITEM_ETHER].ether_item;
 
-        cJSON_AddNumberToObject(cjson_ether_item, MR_CJSON_KEY_ARG_FLG, ether_item->arg_flg);
-        if(ether_item->arg_flg & MR_RULE_FLOW_ETHER_ARG_HAS_VLAN_ENABLE)
+        cJSON_AddNumberToObject(cjson_ether_item, MR_CJSON_KEY_ARG_FLAG, ether_item->arg_flag);
+        if(ether_item->arg_flag & MR_RULE_FLOW_ETHER_ARG_HAS_VLAN_ENABLE)
         {
             cJSON_AddNumberToObject(cjson_ether_item, MR_CJSON_KEY_ETHER_HASVLAN, ether_item->has_vlan);
         }
 
-        if (ether_item->arg_flg & MR_RULE_FLOW_ETHER_ARG_SMAC_ENABLE)
+        if (ether_item->arg_flag & MR_RULE_FLOW_ETHER_ARG_SMAC_ENABLE)
         {
             char mac_addr[MR_RULE_MAC_ADDR_LEN];
             ether_format_addr(mac_addr, sizeof(mac_addr), &ether_item->ether_hdr.s_addr);
             cJSON_AddStringToObject(cjson_ether_item, MR_CJSON_KEY_ETHER_SMAC, mac_addr);
         }
 
-        if (ether_item->arg_flg & MR_RULE_FLOW_ETHER_ARG_DMAC_ENABLE)
+        if (ether_item->arg_flag & MR_RULE_FLOW_ETHER_ARG_DMAC_ENABLE)
         {
             char mac_addr[MR_RULE_MAC_ADDR_LEN];
             ether_format_addr(mac_addr, sizeof(mac_addr), &ether_item->ether_hdr.d_addr);
             cJSON_AddStringToObject(cjson_ether_item, MR_CJSON_KEY_ETHER_DMAC, mac_addr);
         }
 
-        if (ether_item->arg_flg & MR_RULE_FLOW_ETHER_ARG_SMAC_MASK_ENABLE)
+        if (ether_item->arg_flag & MR_RULE_FLOW_ETHER_ARG_SMAC_MASK_ENABLE)
         {
             char mac_mask[MR_RULE_MAC_ADDR_LEN];
             ether_format_addr(mac_mask, sizeof(mac_mask), &ether_item->smac_mask);
             cJSON_AddStringToObject(cjson_ether_item, MR_CJSON_KEY_ETHER_SMAC_MASK, mac_mask);
         }
 
-        if (ether_item->arg_flg & MR_RULE_FLOW_ETHER_ARG_DMAC_MASK_ENABLE)
+        if (ether_item->arg_flag & MR_RULE_FLOW_ETHER_ARG_DMAC_MASK_ENABLE)
         {
             char mac_mask[MR_RULE_MAC_ADDR_LEN];
             ether_format_addr(mac_mask, sizeof(mac_mask), &ether_item->dmac_mask);
             cJSON_AddStringToObject(cjson_ether_item, MR_CJSON_KEY_ETHER_DMAC_MASK, mac_mask);
         }
 
-        if (ether_item->arg_flg & MR_RULE_FLOW_ETHER_ARG_TYPE_ENABLE)
+        if (ether_item->arg_flag & MR_RULE_FLOW_ETHER_ARG_TYPE_ENABLE)
         {
             cJSON_AddNumberToObject(cjson_ether_item, MR_CJSON_KEY_ETHER_TYPE, ether_item->ether_hdr.ether_type);
         }
@@ -896,30 +896,30 @@ int send_create_request_msg(struct mrctl_instance * instance, struct mrctl_offlo
     /* ipv4 Item */
     if (rule_item->item_list & MR_RULE_FLOW_ITEM_LIST_IPV4)
     {
-        struct mr_offload_item_ipv4 * ipv4_item = &rule_item->items[MR_RULE_FLOW_ITEM_IPV4].ipv4_item;
-        cJSON_AddNumberToObject(cjson_ipv4_item, MR_CJSON_KEY_ARG_FLG, ipv4_item->arg_flg);
+        struct mr_flow_item_ipv4 * ipv4_item = &rule_item->items[MR_RULE_FLOW_ITEM_IPV4].ipv4_item;
+        cJSON_AddNumberToObject(cjson_ipv4_item, MR_CJSON_KEY_ARG_FLAG, ipv4_item->arg_flag);
 
-        if(ipv4_item->arg_flg & MR_RULE_FLOW_IPV4_ARG_TOS_ENABLE)
+        if(ipv4_item->arg_flag & MR_RULE_FLOW_IPV4_ARG_TOS_ENABLE)
         {
             cJSON_AddNumberToObject(cjson_ipv4_item, MR_CJSON_KEY_IPV4_TOS, ipv4_item->ipv4_hdr.type_of_service);
         }
 
-        if (ipv4_item->arg_flg & MR_RULE_FLOW_IPV4_ARG_FRAGMENT_OFFSET_ENABLE)
+        if (ipv4_item->arg_flag & MR_RULE_FLOW_IPV4_ARG_FRAGMENT_OFFSET_ENABLE)
         {
             cJSON_AddNumberToObject(cjson_ipv4_item, MR_CJSON_KEY_IPV4_FRAGMENT_OFFSET, ipv4_item->ipv4_hdr.fragment_offset);
         }
 
-        if (ipv4_item->arg_flg & MR_RULE_FLOW_IPV4_ARG_TTL_ENABLE)
+        if (ipv4_item->arg_flag & MR_RULE_FLOW_IPV4_ARG_TTL_ENABLE)
         {
             cJSON_AddNumberToObject(cjson_ipv4_item, MR_CJSON_KEY_IPV4_TTL, ipv4_item->ipv4_hdr.time_to_live);
         }
 
-        if (ipv4_item->arg_flg & MR_RULE_FLOW_IPV4_ARG_NEXT_PROTO_ENABLE)
+        if (ipv4_item->arg_flag & MR_RULE_FLOW_IPV4_ARG_NEXT_PROTO_ENABLE)
         {
             cJSON_AddNumberToObject(cjson_ipv4_item, MR_CJSON_KEY_IPV4_NEXT_PROTO, ipv4_item->ipv4_hdr.next_proto_id);
         }
 
-        if (ipv4_item->arg_flg & MR_RULE_FLOW_IPV4_ARG_SADDR_ENABLE)
+        if (ipv4_item->arg_flag & MR_RULE_FLOW_IPV4_ARG_SADDR_ENABLE)
         {
             struct in_addr saddr;
             saddr.s_addr = ipv4_item->ipv4_hdr.src_addr;
@@ -927,7 +927,7 @@ int send_create_request_msg(struct mrctl_instance * instance, struct mrctl_offlo
             cJSON_AddStringToObject(cjson_ipv4_item, MR_CJSON_KEY_IPV4_SADDR_STR, inet_ntoa(saddr));
         }
 
-        if (ipv4_item->arg_flg & MR_RULE_FLOW_IPV4_ARG_SADDR_MASK_ENABLE)
+        if (ipv4_item->arg_flag & MR_RULE_FLOW_IPV4_ARG_SADDR_MASK_ENABLE)
         {
             struct in_addr saddr;
             saddr.s_addr = ipv4_item->ip_mask.src_addr;
@@ -935,7 +935,7 @@ int send_create_request_msg(struct mrctl_instance * instance, struct mrctl_offlo
             cJSON_AddStringToObject(cjson_ipv4_item, MR_CJSON_KEY_IPV4_SADDR_MASK_STR, inet_ntoa(saddr));
         }
 
-        if (ipv4_item->arg_flg & MR_RULE_FLOW_IPV4_ARG_DADDR_ENABLE)
+        if (ipv4_item->arg_flag & MR_RULE_FLOW_IPV4_ARG_DADDR_ENABLE)
         {
             struct in_addr daddr;
             daddr.s_addr = ipv4_item->ipv4_hdr.dst_addr;
@@ -943,7 +943,7 @@ int send_create_request_msg(struct mrctl_instance * instance, struct mrctl_offlo
             cJSON_AddStringToObject(cjson_ipv4_item, MR_CJSON_KEY_IPV4_DADDR_STR, inet_ntoa(daddr));
         }
 
-        if (ipv4_item->arg_flg & MR_RULE_FLOW_IPV4_ARG_DADDR_MASK_ENABLE)
+        if (ipv4_item->arg_flag & MR_RULE_FLOW_IPV4_ARG_DADDR_MASK_ENABLE)
         {
             struct in_addr daddr;
             daddr.s_addr = ipv4_item->ip_mask.dst_addr;
@@ -956,25 +956,25 @@ int send_create_request_msg(struct mrctl_instance * instance, struct mrctl_offlo
     /* UDP Item */
     if (rule_item->item_list & MR_RULE_FLOW_ITEM_LIST_UDP)
     {
-        struct mr_offload_item_udp * udp_item = &rule_item->items[MR_RULE_FLOW_ITEM_UDP].udp_item;
-        cJSON_AddNumberToObject(cjson_udp_item, MR_CJSON_KEY_ARG_FLG, udp_item->arg_flg);
+        struct mr_flow_item_udp * udp_item = &rule_item->items[MR_RULE_FLOW_ITEM_UDP].udp_item;
+        cJSON_AddNumberToObject(cjson_udp_item, MR_CJSON_KEY_ARG_FLAG, udp_item->arg_flag);
 
-        if(udp_item->arg_flg & MR_RULE_FLOW_UDP_ARG_SRC_PORT_ENABLE)
+        if(udp_item->arg_flag & MR_RULE_FLOW_UDP_ARG_SRC_PORT_ENABLE)
         {
             cJSON_AddNumberToObject(cjson_udp_item, MR_CJSON_KEY_UDP_SRC_PORT, udp_item->udp_hdr.src_port);
         }
 
-        if(udp_item->arg_flg & MR_RULE_FLOW_UDP_ARG_SRC_PORT_MASK_ENABLE)
+        if(udp_item->arg_flag & MR_RULE_FLOW_UDP_ARG_SRC_PORT_MASK_ENABLE)
         {
             cJSON_AddNumberToObject(cjson_udp_item, MR_CJSON_KEY_UDP_SRC_PORT_MASK, udp_item->udp_mask.src_port);
         }
 
-        if(udp_item->arg_flg & MR_RULE_FLOW_UDP_ARG_DST_PORT_ENABLE)
+        if(udp_item->arg_flag & MR_RULE_FLOW_UDP_ARG_DST_PORT_ENABLE)
         {
             cJSON_AddNumberToObject(cjson_udp_item, MR_CJSON_KEY_UDP_DST_PORT, udp_item->udp_hdr.dst_port);
         }
 
-        if(udp_item->arg_flg & MR_RULE_FLOW_UDP_ARG_DST_PORT_MASK_ENABLE)
+        if(udp_item->arg_flag & MR_RULE_FLOW_UDP_ARG_DST_PORT_MASK_ENABLE)
         {
             cJSON_AddNumberToObject(cjson_udp_item, MR_CJSON_KEY_UDP_DST_PORT_MASK, udp_item->udp_mask.dst_port);
         }
@@ -985,30 +985,30 @@ int send_create_request_msg(struct mrctl_instance * instance, struct mrctl_offlo
     /* TCP Item */
     if (rule_item->item_list & MR_RULE_FLOW_ITEM_LIST_TCP)
     {
-        struct mr_offload_item_tcp * tcp_item = &rule_item->items[MR_RULE_FLOW_ITEM_TCP].tcp_item;
-        cJSON_AddNumberToObject(cjson_tcp_item, MR_CJSON_KEY_ARG_FLG, tcp_item->arg_flg);
+        struct mr_flow_item_tcp * tcp_item = &rule_item->items[MR_RULE_FLOW_ITEM_TCP].tcp_item;
+        cJSON_AddNumberToObject(cjson_tcp_item, MR_CJSON_KEY_ARG_FLAG, tcp_item->arg_flag);
 
-        if(tcp_item->arg_flg & MR_RULE_FLOW_TCP_ARG_SRC_PORT_ENABLE)
+        if(tcp_item->arg_flag & MR_RULE_FLOW_TCP_ARG_SRC_PORT_ENABLE)
         {
             cJSON_AddNumberToObject(cjson_tcp_item, MR_CJSON_KEY_TCP_SRC_PORT, tcp_item->tcp_hdr.src_port);
         }
 
-        if(tcp_item->arg_flg & MR_RULE_FLOW_TCP_ARG_SRC_PORT_MASK_ENABLE)
+        if(tcp_item->arg_flag & MR_RULE_FLOW_TCP_ARG_SRC_PORT_MASK_ENABLE)
         {
             cJSON_AddNumberToObject(cjson_tcp_item, MR_CJSON_KEY_TCP_SRC_PORT_MASK, tcp_item->tcp_mask.src_port);
         }
 
-        if(tcp_item->arg_flg & MR_RULE_FLOW_TCP_ARG_DST_PORT_ENABLE)
+        if(tcp_item->arg_flag & MR_RULE_FLOW_TCP_ARG_DST_PORT_ENABLE)
         {
             cJSON_AddNumberToObject(cjson_tcp_item, MR_CJSON_KEY_TCP_DST_PORT, tcp_item->tcp_hdr.dst_port);
         }
 
-        if(tcp_item->arg_flg & MR_RULE_FLOW_TCP_ARG_DST_PORT_MASK_ENABLE)
+        if(tcp_item->arg_flag & MR_RULE_FLOW_TCP_ARG_DST_PORT_MASK_ENABLE)
         {
             cJSON_AddNumberToObject(cjson_tcp_item, MR_CJSON_KEY_TCP_DST_PORT_MASK, tcp_item->tcp_mask.dst_port);
         }
 
-        if(tcp_item->arg_flg & MR_RULE_FLOW_TCP_ARG_FLAGS_ENABLE)
+        if(tcp_item->arg_flag & MR_RULE_FLOW_TCP_ARG_FLAGS_ENABLE)
         {
             cJSON_AddNumberToObject(cjson_tcp_item, MR_CJSON_KEY_TCP_FLAGS, tcp_item->tcp_hdr.tcp_flags);
         }
@@ -1020,15 +1020,15 @@ int send_create_request_msg(struct mrctl_instance * instance, struct mrctl_offlo
     if (rule_item->item_list & MR_RULE_FLOW_ITEM_LIST_VXLAN)
     {
 
-        struct mr_offload_item_vxlan * vxlan_item = &rule_item->items[MR_RULE_FLOW_ITEM_VXLAN].vxlan_item;
-        cJSON_AddNumberToObject(cjson_vxlan_item, MR_CJSON_KEY_ARG_FLG, vxlan_item->arg_flg);
+        struct mr_flow_item_vxlan * vxlan_item = &rule_item->items[MR_RULE_FLOW_ITEM_VXLAN].vxlan_item;
+        cJSON_AddNumberToObject(cjson_vxlan_item, MR_CJSON_KEY_ARG_FLAG, vxlan_item->arg_flag);
 
-        if(vxlan_item->arg_flg & MR_RULE_FLOW_VXLAN_ARG_VNI_ENABLE)
+        if(vxlan_item->arg_flag & MR_RULE_FLOW_VXLAN_ARG_VNI_ENABLE)
         {
             cJSON_AddNumberToObject(cjson_vxlan_item, MR_CJSON_KEY_VXLAN_VNI, vxlan_item->vni);
         }
 
-        if(vxlan_item->arg_flg & MR_RULE_FLOW_VXLAN_ARG_VNI_MASK_ENABLE)
+        if(vxlan_item->arg_flag & MR_RULE_FLOW_VXLAN_ARG_VNI_MASK_ENABLE)
         {
             cJSON_AddNumberToObject(cjson_vxlan_item, MR_CJSON_KEY_VXLAN_VNI_MASK, vxlan_item->vni_mask);
         }
@@ -1043,9 +1043,9 @@ int send_create_request_msg(struct mrctl_instance * instance, struct mrctl_offlo
     /* Action Count */
     if (rule_item->action_list & MR_RULE_FLOW_ACTION_LIST_COUNT)
     {
-        struct mr_offload_action_count * count_action = &rule_item->actions[MR_RULE_FLOW_ACTION_COUNT].count;
-        cJSON_AddNumberToObject(cjson_action_count, MR_CJSON_KEY_ARG_FLG, count_action->arg_flg);
-        if (count_action->arg_flg & MR_RULE_FLOW_COUNT_ARG_SHARED_ENABLE)
+        struct mr_flow_action_count * count_action = &rule_item->actions[MR_RULE_FLOW_ACTION_COUNT].count;
+        cJSON_AddNumberToObject(cjson_action_count, MR_CJSON_KEY_ARG_FLAG, count_action->arg_flag);
+        if (count_action->arg_flag & MR_RULE_FLOW_COUNT_ARG_SHARED_ENABLE)
         {
             cJSON_AddNumberToObject(cjson_action_count, MR_CJSON_KEY_COUNT_SHARED, count_action->shared);
         }
@@ -1055,7 +1055,7 @@ int send_create_request_msg(struct mrctl_instance * instance, struct mrctl_offlo
             cJSON_AddNumberToObject(cjson_action_count, MR_CJSON_KEY_COUNT_SHARED, MR_RULE_ARG_DISABLE);
         }
 
-        if (count_action->arg_flg & MR_RULE_FLOW_COUNT_ARG_ID_ENABLE)
+        if (count_action->arg_flag & MR_RULE_FLOW_COUNT_ARG_ID_ENABLE)
         {
             cJSON_AddNumberToObject(cjson_action_count, MR_CJSON_KEY_COUNT_ID, count_action->id);
         }
@@ -1072,10 +1072,10 @@ int send_create_request_msg(struct mrctl_instance * instance, struct mrctl_offlo
     /* Action Queue */
     if (rule_item->action_list & MR_RULE_FLOW_ACTION_LIST_QUEUE)
     {
-        struct mr_offload_action_queue * queue_action = &rule_item->actions[MR_RULE_FLOW_ACTION_QUEUE].queue;
-        cJSON_AddNumberToObject(cjson_action_queue, MR_CJSON_KEY_ARG_FLG, queue_action->arg_flg);
+        struct mr_flow_action_queue * queue_action = &rule_item->actions[MR_RULE_FLOW_ACTION_QUEUE].queue;
+        cJSON_AddNumberToObject(cjson_action_queue, MR_CJSON_KEY_ARG_FLAG, queue_action->arg_flag);
 
-        if (queue_action->arg_flg & MR_RULE_FLOW_QUEUE_ARG_QUEUE_INDEX)
+        if (queue_action->arg_flag & MR_RULE_FLOW_QUEUE_ARG_QUEUE_INDEX)
         {
              cJSON_AddNumberToObject(cjson_action_queue, MR_CJSON_KEY_QUEUE_INDEX, queue_action->index);
         }
@@ -1085,10 +1085,10 @@ int send_create_request_msg(struct mrctl_instance * instance, struct mrctl_offlo
     /* Action Set Src Mac */
     if (rule_item->action_list & MR_RULE_FLOW_ACTION_LIST_SET_SRC_MAC)
     {
-        struct mr_offload_action_set_mac * set_src_mac_action = &rule_item->actions[MR_RULE_FLOW_ACTION_SET_SRC_MAC].set_src_mac;
-        cJSON_AddNumberToObject(cjson_action_set_src_mac, MR_CJSON_KEY_ARG_FLG, set_src_mac_action->arg_flg);
+        struct mr_flow_action_set_mac * set_src_mac_action = &rule_item->actions[MR_RULE_FLOW_ACTION_SET_SRC_MAC].set_src_mac;
+        cJSON_AddNumberToObject(cjson_action_set_src_mac, MR_CJSON_KEY_ARG_FLAG, set_src_mac_action->arg_flag);
 
-        if (set_src_mac_action->arg_flg & MR_RULE_FLOW_SET_SRC_MAC_ARG_SMAC_ENABLE)
+        if (set_src_mac_action->arg_flag & MR_RULE_FLOW_SET_SRC_MAC_ARG_SMAC_ENABLE)
         {
             char mac_addr[MR_RULE_MAC_ADDR_LEN];
             ether_format_addr(mac_addr, sizeof(mac_addr), &set_src_mac_action->mac_addr);
@@ -1100,10 +1100,10 @@ int send_create_request_msg(struct mrctl_instance * instance, struct mrctl_offlo
     /* Action Set Dst Mac */
     if (rule_item->action_list & MR_RULE_FLOW_ACTION_LIST_SET_DST_MAC)
     {
-        struct mr_offload_action_set_mac * set_dst_mac_action = &rule_item->actions[MR_RULE_FLOW_ACTION_SET_DST_MAC].set_dst_mac;
-        cJSON_AddNumberToObject(cjson_action_set_dst_mac, MR_CJSON_KEY_ARG_FLG, set_dst_mac_action->arg_flg);
+        struct mr_flow_action_set_mac * set_dst_mac_action = &rule_item->actions[MR_RULE_FLOW_ACTION_SET_DST_MAC].set_dst_mac;
+        cJSON_AddNumberToObject(cjson_action_set_dst_mac, MR_CJSON_KEY_ARG_FLAG, set_dst_mac_action->arg_flag);
 
-        if (set_dst_mac_action->arg_flg & MR_RULE_FLOW_SET_DST_MAC_ARG_DMAC_ENABLE)
+        if (set_dst_mac_action->arg_flag & MR_RULE_FLOW_SET_DST_MAC_ARG_DMAC_ENABLE)
         {
             char mac_addr[MR_RULE_MAC_ADDR_LEN];
             ether_format_addr(mac_addr, sizeof(mac_addr), &set_dst_mac_action->mac_addr);
@@ -1213,15 +1213,15 @@ int help()
 int main(int argc, char * argv[])
 {
     int opt = 0,close_delay = 0;
-    struct mrctl_offload_rule rule_item;
-    struct mr_offload_item_ether * ether_item = NULL;
-    struct mr_offload_item_ipv4 * ipv4_item = NULL;
-    struct mr_offload_item_udp * udp_item = NULL;
-    struct mr_offload_item_tcp * tcp_item = NULL;
-    struct mr_offload_item_vxlan * vxlan_item = NULL;
-    struct mr_offload_action_count * count_action = NULL;
-    struct mr_offload_action_queue * queue_action = NULL;
-    struct mr_offload_action_set_mac * set_src_mac_action = NULL, * set_dst_mac_action = NULL;
+    struct mrctl_flow_rule rule_item;
+    struct mr_flow_item_ether * ether_item = NULL;
+    struct mr_flow_item_ipv4 * ipv4_item = NULL;
+    struct mr_flow_item_udp * udp_item = NULL;
+    struct mr_flow_item_tcp * tcp_item = NULL;
+    struct mr_flow_item_vxlan * vxlan_item = NULL;
+    struct mr_flow_action_count * count_action = NULL;
+    struct mr_flow_action_queue * queue_action = NULL;
+    struct mr_flow_action_set_mac * set_src_mac_action = NULL, * set_dst_mac_action = NULL;
 
     memset(&rule_item, 0, sizeof(rule_item));
 
@@ -1251,49 +1251,49 @@ int main(int argc, char * argv[])
             }
             case 'c':
             {
-                rule_item.rule_flg |= MR_RULE_TYPE_ENABLE;
+                rule_item.rule_flag |= MR_RULE_TYPE_ENABLE;
                 rule_item.rule_type = MR_RULE_CREATE;
                 break;
             }
             case 'd':
             {
-                rule_item.rule_flg |= MR_RULE_TYPE_ENABLE;
+                rule_item.rule_flag |= MR_RULE_TYPE_ENABLE;
                 rule_item.rule_type = MR_RULE_DELETE;
                 break;
             }
             case 's':
             {
-                rule_item.rule_flg |= MR_RULE_TYPE_ENABLE;
+                rule_item.rule_flag |= MR_RULE_TYPE_ENABLE;
                 rule_item.rule_type = MR_RULE_SEARCH;
                 break;
             }
             case 'g':
             {
-                rule_item.attrs.arg_flg |= MR_RULE_FLOW_ATTR_ARG_GROUP_ENABLE;
+                rule_item.attrs.arg_flag |= MR_RULE_FLOW_ATTR_ARG_GROUP_ENABLE;
                 rule_item.attrs.attr.group = strtoull(optarg, &endptr, 0);
                 break;
             }
             case MR_CLI_ATTR_PRIORITY:
             {
-                rule_item.attrs.arg_flg |= MR_RULE_FLOW_ATTR_ARG_PRIORITY_ENABLE;
+                rule_item.attrs.arg_flag |= MR_RULE_FLOW_ATTR_ARG_PRIORITY_ENABLE;
                 rule_item.attrs.attr.priority = strtoull(optarg, &endptr, 0);
                 break;
             }
             case 'i':
             {
-                rule_item.attrs.arg_flg |= MR_RULE_FLOW_ATTR_ARG_INGRESS_ENABLE;
+                rule_item.attrs.arg_flag |= MR_RULE_FLOW_ATTR_ARG_INGRESS_ENABLE;
                 rule_item.attrs.attr.ingress = MR_RULE_ARG_ENABLE;
                 break;
             }
             case 'e':
             {
-                rule_item.attrs.arg_flg |= MR_RULE_FLOW_ATTR_ARG_EGRESS_ENABLE;
+                rule_item.attrs.arg_flag |= MR_RULE_FLOW_ATTR_ARG_EGRESS_ENABLE;
                 rule_item.attrs.attr.egress = MR_RULE_ARG_ENABLE;
                 break;
             }
             case 'p':
             {
-                rule_item.attrs.arg_flg |= MR_RULE_FLOW_ATTR_ARG_PORTNAME_ENABLE;
+                rule_item.attrs.arg_flag |= MR_RULE_FLOW_ATTR_ARG_PORTNAME_ENABLE;
                 snprintf(rule_item.port_name, sizeof(rule_item.port_name), "%s", optarg);
                 break;
             }
@@ -1301,7 +1301,7 @@ int main(int argc, char * argv[])
             /* Ether Item */
             case MR_CLI_ITEM_ETHER:
             {
-                rule_item.rule_flg |= MR_RULE_ITEM_ENABLE;
+                rule_item.rule_flag |= MR_RULE_ITEM_ENABLE;
                 rule_item.item_list |= MR_RULE_FLOW_ITEM_LIST_ETHER;
                 rule_item.item_num ++;
                 break;
@@ -1310,7 +1310,7 @@ int main(int argc, char * argv[])
             {
                 if(string_to_mac(optarg,&ether_item->ether_hdr.s_addr) == RT_SUCCESS)
                 {
-                    ether_item->arg_flg |= MR_RULE_FLOW_ETHER_ARG_SMAC_ENABLE;
+                    ether_item->arg_flag |= MR_RULE_FLOW_ETHER_ARG_SMAC_ENABLE;
                     ether_format_addr(mac_addr, sizeof(mac_addr), &ether_item->ether_hdr.s_addr);
                 }
                 else
@@ -1325,7 +1325,7 @@ int main(int argc, char * argv[])
             {
                 if(string_to_mac(optarg,&ether_item->ether_hdr.d_addr) == RT_SUCCESS)
                 {
-                    ether_item->arg_flg |= MR_RULE_FLOW_ETHER_ARG_DMAC_ENABLE;
+                    ether_item->arg_flag |= MR_RULE_FLOW_ETHER_ARG_DMAC_ENABLE;
                     ether_format_addr(mac_addr, sizeof(mac_addr), &ether_item->ether_hdr.d_addr);
                 }
                 else
@@ -1341,7 +1341,7 @@ int main(int argc, char * argv[])
                 if(string_to_mac(optarg,&ether_item->smac_mask) == RT_SUCCESS)
                 {
 
-                    ether_item->arg_flg |= MR_RULE_FLOW_ETHER_ARG_SMAC_MASK_ENABLE;
+                    ether_item->arg_flag |= MR_RULE_FLOW_ETHER_ARG_SMAC_MASK_ENABLE;
                     ether_format_addr(mac_mask, sizeof(mac_mask), &ether_item->smac_mask);
                 }
                 else
@@ -1357,7 +1357,7 @@ int main(int argc, char * argv[])
                 if(string_to_mac(optarg,&ether_item->dmac_mask) == RT_SUCCESS)
                 {
 
-                    ether_item->arg_flg |= MR_RULE_FLOW_ETHER_ARG_DMAC_MASK_ENABLE;
+                    ether_item->arg_flag |= MR_RULE_FLOW_ETHER_ARG_DMAC_MASK_ENABLE;
                     ether_format_addr(mac_mask, sizeof(mac_mask), &ether_item->dmac_mask);
                 }
                 else
@@ -1387,45 +1387,45 @@ int main(int argc, char * argv[])
                     fprintf(stderr, "Eth Type Only Support : ipv4 ipv6");
                     return 0;
                 }
-                ether_item->arg_flg |= MR_RULE_FLOW_ETHER_ARG_TYPE_ENABLE;
+                ether_item->arg_flag |= MR_RULE_FLOW_ETHER_ARG_TYPE_ENABLE;
                 break;
             }
             case MR_CLI_ITEM_ETHER_HAS_VLAN:
             {
                 ether_item->has_vlan = MR_RULE_ARG_ENABLE;
-                ether_item->arg_flg |= MR_RULE_FLOW_ETHER_ARG_HAS_VLAN_ENABLE;
+                ether_item->arg_flag |= MR_RULE_FLOW_ETHER_ARG_HAS_VLAN_ENABLE;
                 break;
             }
 
             /* Ipv4 Item */
             case MR_CLI_ITEM_IPV4:
             {
-                rule_item.rule_flg |= MR_RULE_ITEM_ENABLE;
+                rule_item.rule_flag |= MR_RULE_ITEM_ENABLE;
                 rule_item.item_list |= MR_RULE_FLOW_ITEM_LIST_IPV4;
                 rule_item.item_num ++;
                 break;
             }
             case MR_CLI_ITEM_IPV4_TOS:
             {
-                ipv4_item->arg_flg |= MR_RULE_FLOW_IPV4_ARG_TOS_ENABLE;
+                ipv4_item->arg_flag |= MR_RULE_FLOW_IPV4_ARG_TOS_ENABLE;
                 ipv4_item->ipv4_hdr.type_of_service = (uint8_t)strtoull(optarg, &endptr, 0);
                 break;
             }
             case MR_CLI_ITEM_IPV4_FRAGMENT_OFFSET:
             {
-                ipv4_item->arg_flg |= MR_RULE_FLOW_IPV4_ARG_FRAGMENT_OFFSET_ENABLE;
+                ipv4_item->arg_flag |= MR_RULE_FLOW_IPV4_ARG_FRAGMENT_OFFSET_ENABLE;
                 ipv4_item->ipv4_hdr.fragment_offset = (rte_be16_t)strtoull(optarg, &endptr, 0);
                 break;
             }
             case MR_CLI_ITEM_IPV4_TTL:
             {
-                ipv4_item->arg_flg |= MR_RULE_FLOW_IPV4_ARG_TTL_ENABLE;
+                ipv4_item->arg_flag |= MR_RULE_FLOW_IPV4_ARG_TTL_ENABLE;
                 ipv4_item->ipv4_hdr.time_to_live = (uint8_t)strtoull(optarg, &endptr, 0);
                 break;
             }
             case MR_CLI_ITEM_IPV4_PROTO:
             {
-                ipv4_item->arg_flg |= MR_RULE_FLOW_IPV4_ARG_NEXT_PROTO_ENABLE;
+                ipv4_item->arg_flag |= MR_RULE_FLOW_IPV4_ARG_NEXT_PROTO_ENABLE;
                 if(strcmp(optarg, "tcp") == 0)
                 {
                    ipv4_item->ipv4_hdr.next_proto_id = IPPROTO_TCP;
@@ -1446,7 +1446,7 @@ int main(int argc, char * argv[])
                 struct in_addr src_addr;
                 if (inet_pton(AF_INET, optarg, (void *)&src_addr))
                 {
-                    ipv4_item->arg_flg |= MR_RULE_FLOW_IPV4_ARG_SADDR_ENABLE;
+                    ipv4_item->arg_flag |= MR_RULE_FLOW_IPV4_ARG_SADDR_ENABLE;
                     ipv4_item->ipv4_hdr.src_addr = src_addr.s_addr;
 
                 }
@@ -1464,7 +1464,7 @@ int main(int argc, char * argv[])
                 if (inet_pton(AF_INET, optarg, (void *)&src_addr_mask))
                 {
                     ipv4_item->ip_mask.src_addr = src_addr_mask.s_addr;
-                    ipv4_item->arg_flg |= MR_RULE_FLOW_IPV4_ARG_SADDR_MASK_ENABLE;
+                    ipv4_item->arg_flag |= MR_RULE_FLOW_IPV4_ARG_SADDR_MASK_ENABLE;
                 }
                 else
                 {
@@ -1480,7 +1480,7 @@ int main(int argc, char * argv[])
                 if (inet_pton(AF_INET, optarg, (void *)&dst_addr))
                 {
                     ipv4_item->ipv4_hdr.dst_addr = dst_addr.s_addr;
-                    ipv4_item->arg_flg |= MR_RULE_FLOW_IPV4_ARG_DADDR_ENABLE;
+                    ipv4_item->arg_flag |= MR_RULE_FLOW_IPV4_ARG_DADDR_ENABLE;
                 }
                 else
                 {
@@ -1496,7 +1496,7 @@ int main(int argc, char * argv[])
                 if (inet_pton(AF_INET, optarg, (void *)&dst_addr_mask))
                 {
                     ipv4_item->ip_mask.dst_addr = dst_addr_mask.s_addr;
-                    ipv4_item->arg_flg |= MR_RULE_FLOW_IPV4_ARG_DADDR_MASK_ENABLE;
+                    ipv4_item->arg_flag |= MR_RULE_FLOW_IPV4_ARG_DADDR_MASK_ENABLE;
                 }
                 else
                 {
@@ -1510,32 +1510,32 @@ int main(int argc, char * argv[])
             /* Udp Item */
             case MR_CLI_ITEM_UDP:
             {
-                rule_item.rule_flg |= MR_RULE_ITEM_ENABLE;
+                rule_item.rule_flag |= MR_RULE_ITEM_ENABLE;
                 rule_item.item_list |= MR_RULE_FLOW_ITEM_LIST_UDP;
                 rule_item.item_num ++;
                 break;
             }
             case MR_CLI_ITEM_UDP_SRC_PORT:
             {
-                udp_item->arg_flg |= MR_RULE_FLOW_UDP_ARG_SRC_PORT_ENABLE;
+                udp_item->arg_flag |= MR_RULE_FLOW_UDP_ARG_SRC_PORT_ENABLE;
                 udp_item->udp_hdr.src_port = (uint16_t)strtoull(optarg, &endptr, 0);
                 break;
             }
             case MR_CLI_ITEM_UDP_SRC_PORT_MASK:
             {
-                udp_item->arg_flg |= MR_RULE_FLOW_UDP_ARG_SRC_PORT_MASK_ENABLE;
+                udp_item->arg_flag |= MR_RULE_FLOW_UDP_ARG_SRC_PORT_MASK_ENABLE;
                 udp_item->udp_mask.src_port = (uint16_t)strtoull(optarg, &endptr, 0);
                 break;
             }
             case MR_CLI_ITEM_UDP_DST_PORT:
             {
-                udp_item->arg_flg |= MR_RULE_FLOW_UDP_ARG_DST_PORT_ENABLE;
+                udp_item->arg_flag |= MR_RULE_FLOW_UDP_ARG_DST_PORT_ENABLE;
                 udp_item->udp_hdr.dst_port = (uint16_t)strtoull(optarg, &endptr, 0);
                 break;
             }
             case MR_CLI_ITEM_UDP_DST_PORT_MASK:
             {
-                udp_item->arg_flg |= MR_RULE_FLOW_UDP_ARG_DST_PORT_MASK_ENABLE;
+                udp_item->arg_flag |= MR_RULE_FLOW_UDP_ARG_DST_PORT_MASK_ENABLE;
                 udp_item->udp_mask.dst_port = (uint16_t)strtoull(optarg, &endptr, 0);
                 break;
             }
@@ -1543,38 +1543,38 @@ int main(int argc, char * argv[])
             /* TCP Item */
             case MR_CLI_ITEM_TCP:
             {
-                rule_item.rule_flg |= MR_RULE_ITEM_ENABLE;
+                rule_item.rule_flag |= MR_RULE_ITEM_ENABLE;
                 rule_item.item_list |= MR_RULE_FLOW_ITEM_LIST_TCP;
                 rule_item.item_num ++;
                 break;
             }
             case MR_CLI_ITEM_TCP_SRC_PORT:
             {
-                tcp_item->arg_flg |= MR_RULE_FLOW_TCP_ARG_SRC_PORT_ENABLE;
+                tcp_item->arg_flag |= MR_RULE_FLOW_TCP_ARG_SRC_PORT_ENABLE;
                 tcp_item->tcp_hdr.src_port = (uint16_t)strtoull(optarg, &endptr, 0);
                 break;
             }
             case MR_CLI_ITEM_TCP_SRC_PORT_MASK:
             {
-                tcp_item->arg_flg |= MR_RULE_FLOW_TCP_ARG_SRC_PORT_MASK_ENABLE;
+                tcp_item->arg_flag |= MR_RULE_FLOW_TCP_ARG_SRC_PORT_MASK_ENABLE;
                 tcp_item->tcp_mask.src_port = (uint16_t)strtoull(optarg, &endptr, 0);
                 break;
             }
             case MR_CLI_ITEM_TCP_DST_PORT:
             {
-                tcp_item->arg_flg |= MR_RULE_FLOW_TCP_ARG_DST_PORT_ENABLE;
+                tcp_item->arg_flag |= MR_RULE_FLOW_TCP_ARG_DST_PORT_ENABLE;
                 tcp_item->tcp_hdr.dst_port = (uint16_t)strtoull(optarg, &endptr, 0);
                 break;
             }
             case MR_CLI_ITEM_TCP_DST_PORT_MASK:
             {
-                tcp_item->arg_flg |= MR_RULE_FLOW_TCP_ARG_DST_PORT_MASK_ENABLE;
+                tcp_item->arg_flag |= MR_RULE_FLOW_TCP_ARG_DST_PORT_MASK_ENABLE;
                 tcp_item->tcp_mask.dst_port = (uint16_t)strtoull(optarg, &endptr, 0);
                 break;
             }
             case MR_CLI_ITEM_TCP_FLAGS:
             {
-                tcp_item->arg_flg |= MR_RULE_FLOW_TCP_ARG_FLAGS_ENABLE;
+                tcp_item->arg_flag |= MR_RULE_FLOW_TCP_ARG_FLAGS_ENABLE;
                 tcp_item->tcp_hdr.tcp_flags = (uint8_t)strtoull(optarg, &endptr, 0);
                 break;
             }
@@ -1582,20 +1582,20 @@ int main(int argc, char * argv[])
             /* VXLAN Item */
             case MR_CLI_ITEM_VXLAN:
             {
-                rule_item.rule_flg |= MR_RULE_ITEM_ENABLE;
+                rule_item.rule_flag |= MR_RULE_ITEM_ENABLE;
                 rule_item.item_list |= MR_RULE_FLOW_ITEM_LIST_VXLAN;
                 rule_item.item_num ++;
                 break;
             }
             case MR_CLI_ITEM_VXLAN_VNI:
             {
-                vxlan_item->arg_flg |= MR_RULE_FLOW_VXLAN_ARG_VNI_ENABLE;
+                vxlan_item->arg_flag |= MR_RULE_FLOW_VXLAN_ARG_VNI_ENABLE;
                 vxlan_item->vni = (uint32_t)strtoull(optarg, &endptr, 0);
                 break;
             }
             case MR_CLI_ITEM_VXLAN_VNI_MASK:
             {
-                vxlan_item->arg_flg |= MR_RULE_FLOW_VXLAN_ARG_VNI_MASK_ENABLE;
+                vxlan_item->arg_flag |= MR_RULE_FLOW_VXLAN_ARG_VNI_MASK_ENABLE;
                 vxlan_item->vni_mask = (uint32_t)strtoull(optarg, &endptr, 0);
                 break;
             }
@@ -1604,20 +1604,20 @@ int main(int argc, char * argv[])
             /* Count Action */
             case MR_CLI_ACTION_COUNT:
             {
-                rule_item.rule_flg |= MR_RULE_ACTION_ENABLE;
+                rule_item.rule_flag |= MR_RULE_ACTION_ENABLE;
                 rule_item.action_list |= MR_RULE_FLOW_ACTION_LIST_COUNT;
                 rule_item.action_num ++;
                 break;
             }
             case MR_CLI_ACTION_COUNT_SHARED:
             {
-                count_action->arg_flg |= MR_RULE_FLOW_COUNT_ARG_SHARED_ENABLE;
+                count_action->arg_flag |= MR_RULE_FLOW_COUNT_ARG_SHARED_ENABLE;
                 count_action->shared = MR_RULE_ARG_ENABLE;
                 break;
             }
             case MR_CLI_ACTION_COUNT_ID:
             {
-                count_action->arg_flg |= MR_RULE_FLOW_COUNT_ARG_ID_ENABLE;
+                count_action->arg_flag |= MR_RULE_FLOW_COUNT_ARG_ID_ENABLE;
                 count_action->id = strtoull(optarg, &endptr, 0);
                 break;
             }
@@ -1625,7 +1625,7 @@ int main(int argc, char * argv[])
             /* Drop Action */
             case MR_CLI_ACTION_DROP:
             {
-                rule_item.rule_flg |= MR_RULE_ACTION_ENABLE;
+                rule_item.rule_flag |= MR_RULE_ACTION_ENABLE;
                 rule_item.action_list |= MR_RULE_FLOW_ACTION_LIST_DROP;
                 rule_item.action_num ++;
                 break;
@@ -1634,14 +1634,14 @@ int main(int argc, char * argv[])
             /* Queue Action */
             case MR_CLI_ACTION_QUEUE:
             {
-                rule_item.rule_flg |= MR_RULE_ACTION_ENABLE;
+                rule_item.rule_flag |= MR_RULE_ACTION_ENABLE;
                 rule_item.action_list |= MR_RULE_FLOW_ACTION_LIST_QUEUE;
                 rule_item.action_num ++;
                 break;
             }
             case MR_CLI_ACTION_QUEUE_INDEX:
             {
-                queue_action->arg_flg |= MR_RULE_FLOW_QUEUE_ARG_QUEUE_INDEX;
+                queue_action->arg_flag |= MR_RULE_FLOW_QUEUE_ARG_QUEUE_INDEX;
                 queue_action->index = strtoull(optarg, &endptr, 0);
                 break;
             }
@@ -1649,7 +1649,7 @@ int main(int argc, char * argv[])
             /* Set Src Mac Action */
             case MR_CLI_ACTION_SET_SRC_MAC:
             {
-                rule_item.rule_flg |= MR_RULE_ACTION_ENABLE;
+                rule_item.rule_flag |= MR_RULE_ACTION_ENABLE;
                 rule_item.action_list |= MR_RULE_FLOW_ACTION_LIST_SET_SRC_MAC;
                 rule_item.action_num ++;
                 break;
@@ -1659,7 +1659,7 @@ int main(int argc, char * argv[])
                 if(string_to_mac(optarg,&set_src_mac_action->mac_addr) == RT_SUCCESS)
                 {
 
-                    set_src_mac_action->arg_flg |= MR_RULE_FLOW_SET_SRC_MAC_ARG_SMAC_ENABLE;
+                    set_src_mac_action->arg_flag |= MR_RULE_FLOW_SET_SRC_MAC_ARG_SMAC_ENABLE;
                     ether_format_addr(mac_addr, sizeof(mac_addr), &set_src_mac_action->mac_addr);
                 }
                 else
@@ -1674,7 +1674,7 @@ int main(int argc, char * argv[])
             /* Set Dst Mac Action */
             case MR_CLI_ACTION_SET_DST_MAC:
             {
-                rule_item.rule_flg |= MR_RULE_ACTION_ENABLE;
+                rule_item.rule_flag |= MR_RULE_ACTION_ENABLE;
                 rule_item.action_list |= MR_RULE_FLOW_ACTION_LIST_SET_DST_MAC;
                 rule_item.action_num ++;
                 break;
@@ -1684,7 +1684,7 @@ int main(int argc, char * argv[])
                 if(string_to_mac(optarg,&set_dst_mac_action->mac_addr) == RT_SUCCESS)
                 {
 
-                    set_dst_mac_action->arg_flg |= MR_RULE_FLOW_SET_DST_MAC_ARG_DMAC_ENABLE;
+                    set_dst_mac_action->arg_flag |= MR_RULE_FLOW_SET_DST_MAC_ARG_DMAC_ENABLE;
                     ether_format_addr(mac_addr, sizeof(mac_addr), &set_dst_mac_action->mac_addr);
                 }
                 else
@@ -1724,10 +1724,10 @@ int main(int argc, char * argv[])
         return 0;
     }
 
-    /* Offload Create Response */
-    ctrlmsg_msg_reciver_register(mrctl_instance->ctrlmsg_handler, CTRLMSG_TOPIC_OFFLOAD_CREATE,CTRL_MSG_TYPE_RESPONSE, __offload_create_response_handler, mrctl_instance);
-    /* Offload Search Response */
-    ctrlmsg_msg_reciver_register(mrctl_instance->ctrlmsg_handler, CTRLMSG_TOPIC_OFFLOAD_SEARCH,CTRL_MSG_TYPE_RESPONSE, __offload_search_response_handler, mrctl_instance);
+    /* Flow Create Response */
+    ctrlmsg_msg_reciver_register(mrctl_instance->ctrlmsg_handler, CTRLMSG_TOPIC_FLOW_CREATE,CTRL_MSG_TYPE_RESPONSE, __flow_create_response_handler, mrctl_instance);
+    /* Flow Search Response */
+    ctrlmsg_msg_reciver_register(mrctl_instance->ctrlmsg_handler, CTRLMSG_TOPIC_FLOW_SEARCH,CTRL_MSG_TYPE_RESPONSE, __flow_search_response_handler, mrctl_instance);
 
     /* Conn Close */
     ctrlmsg_event_conn_close_register(mrctl_instance->ctrlmsg_handler,__conn_close_handler, mrctl_instance);
@@ -1746,10 +1746,10 @@ int main(int argc, char * argv[])
     }
     else if (rule_item.rule_type == MR_RULE_SEARCH)
     {
-        struct ctrl_msg_offload_request req_msg;
+        struct ctrl_msg_flow_request req_msg;
 
         memset(&req_msg, 0, sizeof(req_msg));
-        ctrl_msg_header_construct(&req_msg.msg_header, sizeof(req_msg), CTRL_MSG_TYPE_REQUEST, CTRLMSG_TOPIC_OFFLOAD_SEARCH);
+        ctrl_msg_header_construct(&req_msg.msg_header, sizeof(req_msg), CTRL_MSG_TYPE_REQUEST, CTRLMSG_TOPIC_FLOW_SEARCH);
         /* Send Search Requeset Msg */
         ctrlmsg_msg_send(mrctl_instance->ctrlmsg_handler, NULL, (struct ctrl_msg_header*)&req_msg);
     }
@@ -1766,7 +1766,7 @@ int main(int argc, char * argv[])
         }
 
         close_delay ++;
-        sleep(1);
+        usleep(100000);
     }
     return RT_SUCCESS;
 }
\ No newline at end of file