From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id 9F0E0A034E; Fri, 21 Jan 2022 11:32:17 +0100 (CET) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id E639A42771; Fri, 21 Jan 2022 11:31:41 +0100 (CET) Received: from mga01.intel.com (mga01.intel.com [192.55.52.88]) by mails.dpdk.org (Postfix) with ESMTP id 4D3B742762 for ; Fri, 21 Jan 2022 11:31:39 +0100 (CET) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1642761099; x=1674297099; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=RuPcIUsRTV2HJiGIyJKPAQE4R/HT7XW2d1NgMkWj6/Q=; b=hYtmLDIZFND9sOZpiYpIQgXUr8xqvAdXVv7SgT52/KrhsFlu/3ynPqQM DoOiCpIHxj3cNpQcm5ffIw6jGx951rnCljrPvMO3FVn+piszwOWzjYefZ KLiXVtYqIRIpU353Na0QMiiLcTMbkrJO+RYKi8Lsn2Y2cUttI0cglEkeG l86C2hTehvYh7/ompxhY+DKbvJu+J+KsdqDppxNbGtN0lBvQbtK8K1v/S 3xBaQbz2FXSqDa3pdyMELD7mFtms6HjCy/afdt6dRdq4PlbHGbgRIWNIJ OMcoFzS8IPXhLnLvtnhhZj+LgMJQzijeq3/KwkTBZP55416PjhVz0syS/ w==; X-IronPort-AV: E=McAfee;i="6200,9189,10233"; a="270045112" X-IronPort-AV: E=Sophos;i="5.88,304,1635231600"; d="scan'208";a="270045112" Received: from orsmga008.jf.intel.com ([10.7.209.65]) by fmsmga101.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 21 Jan 2022 02:31:38 -0800 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.88,304,1635231600"; d="scan'208";a="533222755" Received: from silpixa00401120.ir.intel.com ([10.55.128.255]) by orsmga008.jf.intel.com with ESMTP; 21 Jan 2022 02:31:37 -0800 From: Ronan Randles To: dev@dpdk.org Cc: Harry van Haaren , Ronan Randles Subject: [PATCH v2 07/15] gen: add gen IP parsing Date: Fri, 21 Jan 2022 10:31:14 +0000 Message-Id: <20220121103122.2926856-8-ronan.randles@intel.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20220121103122.2926856-1-ronan.randles@intel.com> References: <20211214141242.3383831-1-ronan.randles@intel.com> <20220121103122.2926856-1-ronan.randles@intel.com> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org From: Harry van Haaren This commit adds support for the parsing of "IP(src=...,dst=...)" strings. Parse string API improvement for app RCU. Appropriate unit tests also added. Signed-off-by: Harry van Haaren Signed-off-by: Ronan Randles --- app/test/test_gen.c | 29 +++++++-- lib/gen/rte_gen.c | 153 +++++++++++++++++++++++++++++++++++++++++++- 2 files changed, 177 insertions(+), 5 deletions(-) diff --git a/app/test/test_gen.c b/app/test/test_gen.c index 324582d0a5..7b67835c80 100644 --- a/app/test/test_gen.c +++ b/app/test/test_gen.c @@ -117,26 +117,47 @@ test_gen_packet_parse_string(void) { struct rte_gen *gen = rte_gen_create(mp); TEST_ASSERT_FAIL(gen, "Expected valid pointer after create()"); - struct str_parse_t { const char *str; + uint32_t expected_to_fail; } pkt_strings[] = { { .str = "Ether()"}, { .str = "Ether()/"}, { .str = "/Ether()"}, - { .str = "/Ether()/"} + { .str = "/Ether()/"}, + { .str = "Ether()/IP()"}, + { .str = "Ether()/IP(src=1.2.3.4,dst=5.6.7.8)"}, + { .str = "Ether()/IP(src=1.2.3.4,dst=192.168.255.255)"}, + { .str = "Ether()/IP(dst=172.16.0.9,src=1.2.3.4)"}, + { .str = "Ether()/IP(src=1.2.3.4)"}, + { .str = "Ether()/IP(srdst=5.6.7.8)", .expected_to_fail = 1}, + { .str = "Ether()/IP(src=1.2.3.4,ds=)", .expected_to_fail = 1}, + { .str = "Ether()/IP(src=1.2.3.4,dst=)", .expected_to_fail = 1}, + { .str = "Ether()/IP(src=,dst=5.6.7.8)", .expected_to_fail = 1}, + { .str = "Ether()/IP(sr=,dst=5.6.7.8)", .expected_to_fail = 1}, + { .str = "Ether()/IP(src=1.2.3.fail,dst=5.6.7.8)", + .expected_to_fail = 1}, }; uint32_t i; for (i = 0; i < RTE_DIM(pkt_strings); i++) { const char *pkt_str = pkt_strings[i].str; int32_t err = rte_gen_packet_parse_string(gen, pkt_str, NULL); - TEST_ASSERT_EQUAL(err, 0, "Expected string %s to parse.", - pkt_str); + + if (err && pkt_strings[i].expected_to_fail != 1) { + printf("Expected string %s to parse.", pkt_str); + return -1; + } + /* False pass if reached with no err when e_t_f = 1 */ + if (!err && pkt_strings[i].expected_to_fail) { + printf("False Pass on string: %s\n", pkt_str); + return -1; + } } rte_gen_destroy(gen); return 0; + } diff --git a/lib/gen/rte_gen.c b/lib/gen/rte_gen.c index 4d3fe4017f..4020150712 100644 --- a/lib/gen/rte_gen.c +++ b/lib/gen/rte_gen.c @@ -10,6 +10,7 @@ #include #include +#include RTE_LOG_REGISTER(gen_logtype, lib.gen, NOTICE); @@ -136,6 +137,7 @@ rte_gen_tx_burst(struct rte_gen *gen, enum GEN_PROTO { GEN_PROTO_INVALID, GEN_PROTO_ETHER, + GEN_PROTO_IPV4, /* Must be last. */ GEN_PROTO_COUNT, @@ -219,6 +221,145 @@ gen_parser_init(struct gen_parser *parser, struct rte_gen *gen, return -ENOMEM; } +static void +gen_log_ipv4(void *data, const char *indent) +{ + struct rte_ipv4_hdr *ip = data; + + const char *proto_str; + switch (ip->next_proto_id) { + case 0: + proto_str = "hopopt"; + break; + default: + proto_str = "unknown next proto"; + break; + } + + GEN_LOG_PROTOCOL(DEBUG, + "###[ IP ]###\n%sversion = %d\n%sihl = %d\n%stos = %d\n" + "%slen = %d\n%sid = %d\n%sflags = 0x%x\n%sfrag = %d\n" + "%sttl = %d\n%sproto = %s (%d)\n%schksum 0x%x\n%ssrc = 0x%x\n" + "%sdst = 0x%x\n%soptions = %s\n", + indent, ip->version_ihl >> 4, + indent, ip->version_ihl & RTE_IPV4_HDR_IHL_MASK, + indent, ip->type_of_service, + indent, rte_be_to_cpu_16(ip->total_length), + indent, rte_be_to_cpu_16(ip->packet_id), /* TODO: Scapy ID? */ + indent, rte_be_to_cpu_16(ip->packet_id), /*TODO: Scapy Flags?*/ + indent, rte_be_to_cpu_16(ip->fragment_offset), + indent, ip->time_to_live, + indent, proto_str, ip->next_proto_id, + indent, rte_be_to_cpu_16(ip->hdr_checksum), + indent, rte_be_to_cpu_32(ip->src_addr), + indent, rte_be_to_cpu_32(ip->dst_addr), + indent, "notImplemented"); +} + +static int32_t +gen_parse_ipv4_params(char *protocol_str, struct rte_ipv4_hdr *ip) +{ + /* Strings to look for. */ + static const char * const items[] = { + "src=", + "dst=", + }; + const uint32_t num_items = RTE_DIM(items); + + char *tok_ptr; + uint32_t err = 0; + uint32_t i; + for (i = 0; i < num_items; i++) { + /* Print input string into local buffer for processing. */ + char buffer[1024]; + int chars_printed = snprintf(buffer, 1024, "%s", protocol_str); + if (chars_printed >= 1024) + return -1; + + /* Find substring (e.g. src=) if not found skip to next one. */ + char *start = strstr(buffer, items[i]); + char check_previous[32]; + if (start != NULL) { + snprintf(check_previous, 32, "%.1s", start - 1); + if (strcmp(&check_previous[0], "(") && + strcmp(&check_previous[0], ",")) + return -EINVAL; + } + + if (!start) { + if (!strstr(buffer, ",")) + continue; + else + return -EINVAL; + } + /* get from start of string till first , character. */ + char *item = strtok_r(start, ",", &tok_ptr); + + if (strcmp(item, items[i]) == 0) + return -EINVAL; + /* skip past the src= prefix. We know string is long enough as + * otherwise strstr() wouldn't have matched it. + */ + item = &item[4]; + + if (strcmp(items[i], "src=") == 0) { + err = rte_ip_parse_addr(item, &ip->src_addr); + ip->src_addr = rte_cpu_to_be_32(ip->src_addr); + } else { + err = rte_ip_parse_addr(item, &ip->dst_addr); + ip->dst_addr = rte_cpu_to_be_32(ip->dst_addr); + } + if (err) { + GEN_LOG(ERR, "parser ip_parse_addr error %d\n", err); + return err; + } + } + return 0; +} + +static int32_t +gen_parse_ipv4(struct gen_parser *parser, char *protocol_str) +{ + struct rte_ipv4_hdr *ip = gen_parser_get_data_ptr(parser); + uint32_t pre_ip_len = parser->buf_write_offset; + memset(ip, 0, sizeof(*ip)); + ip->version_ihl = RTE_IPV4_VHL_DEF; + ip->time_to_live = 64; + ip->packet_id = rte_cpu_to_be_16(1); + + /* default addrs */ + ip->src_addr = rte_cpu_to_be_32(RTE_IPV4(127, 0, 0, 1)); + ip->dst_addr = rte_cpu_to_be_32(RTE_IPV4(127, 0, 0, 1)); + + uint32_t err = 0; + if (strcmp("IP()", protocol_str)) + err = gen_parse_ipv4_params(protocol_str, ip); + + if (err) { + GEN_LOG(ERR, "parser parse ipv4 params error %d\n", err); + return err; + } + /* Move up write pointer in packet. */ + parser->buf_write_offset += sizeof(*ip); + + /* Move up write pointer in packet, recurse to next. */ + enum GEN_PROTO inner; + err = gen_parser_parse_next(parser, &inner); + if (err) { + GEN_LOG(ERR, "parser parse next() error %d\n", err); + return err; + } + + switch (inner) { + default: + /* Default protocol is hopopt (0). */ + break; + }; + + ip->total_length = rte_cpu_to_be_16(parser->mbuf->pkt_len - pre_ip_len); + return 0; +} + static void gen_log_ether(void *data, const char *indent) { @@ -279,6 +420,9 @@ gen_parse_ether(struct gen_parser *parser, char *protocol_str) } switch (inner) { + case GEN_PROTO_IPV4: + eth->ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4); + break; default: eth->ether_type = rte_cpu_to_be_16(0x9000); break; @@ -304,7 +448,14 @@ static struct gen_parse_func_t gen_protocols[] = { .proto = GEN_PROTO_ETHER, .parse_func = gen_parse_ether, .log_func = gen_log_ether, - } + }, + { + .name = "IP(", + .proto = GEN_PROTO_IPV4, + .parse_func = gen_parse_ipv4, + .log_func = gen_log_ipv4, + }, + }; /* Function to tokenize and parse each segment of a string. -- 2.25.1