/**
 * Perform search for a matching ACL rule for each input data buffer.
 * Each input data buffer can have up to *categories* matches.
 * That implies that results array should be big enough to hold
 * (categories * num) elements.
 * Also categories parameter should be either one or multiple of
 * RTE_ACL_RESULTS_MULTIPLIER and can't be bigger than RTE_ACL_MAX_CATEGORIES.
 * If more than one rule is applicable for given input buffer and
 * given category, then rule with highest priority will be returned as a match.
 * Note, that it is a caller's responsibility to ensure that input parameters
 * are valid and point to correct memory locations.
 *
 * @param ctx
 *   ACL context to search with.
 * @param data
 *   Array of pointers to input data buffers to perform search.
 *   Note that all fields in input data buffers supposed to be in network
 *   byte order (MSB).
 * @param results
 *   Array of search results, *categories* results per each input data buffer.
 * @param num
 *   Number of elements in the input data buffers array.
 * @param categories
 *   Number of maximum possible matches for each input buffer, one possible
 *   match per category.
 * @return
 *   zero on successful completion.
 *   -EINVAL for incorrect arguments.
 */
extern int
rte_acl_classify(const struct rte_acl_ctx *ctx,
         const uint8_t **data,
         uint32_t *results, uint32_t num,
         uint32_t categories);

         
以下是rte_acl_classify接口的使用

int acl_match_ipv4(struct acl_context_t *ctx, const char *data)
{
    int result = 0;
    int ret = rte_acl_classify(ctx->acl_ctx_v4, (const uint8_t **)&data, (uint32_t *)&result, 1, RTE_ACL_MAX_CATEGORIES);
    if (ret)
        rte_exit(EXIT_FAILURE, "ERROR rte_acl_classify in acl_match_ipv4\n");
    return result;
}

static int
acl_convert_ipv4_rule(struct acl_rule_t *rule, struct rte_acl_rule *v)
{
    v->field[PROTO_FIELD_IPV4].value.u8         = rule->proto_id;
    v->field[PROTO_FIELD_IPV4].mask_range.u8    = rule->proto_id ? 0xff : 0;

    v->field[SRC_FIELD_IPV4].value.u32          = rule->ipsrc[0];
    v->field[SRC_FIELD_IPV4].mask_range.u32     = rule->ipsrc_prefix;

    v->field[DST_FIELD_IPV4].value.u32          = rule->ipdst[0];
    v->field[DST_FIELD_IPV4].mask_range.u32     = rule->ipdst_prefix;

    v->field[SRCP_FIELD_IPV4].value.u16         = rule->src_port_begin;
    v->field[SRCP_FIELD_IPV4].mask_range.u16    = rule->src_port_end;

    v->field[DSTP_FIELD_IPV4].value.u16         = rule->dst_port_begin;
    v->field[DSTP_FIELD_IPV4].mask_range.u16    = rule->dst_port_end;

    v->data.userdata                            = rule->rule_id;
    return 0;
}

//解析外部规则
for(i = 0; i < rule_num; i++)
{
    rule = (struct rte_acl_rule *)(acl_rules +  acl_cnt * sizeof(struct acl4_rule));
    if (acl_convert_ipv4_rule(rule_list + i, rule) != 0)
        rte_exit(EXIT_FAILURE, "parse ipv4 rules error\n");

    rule->data.priority = ACL_PRIORITY_DEBIG + acl_cnt;
    rule->data.category_mask = 1;   //无需多模
    acl_cnt++;
};