numam-dpdk/lib/kvargs/rte_kvargs.c
Bruce Richardson 99a2dd955f lib: remove librte_ prefix from directory names
There is no reason for the DPDK libraries to all have 'librte_' prefix on
the directory names. This prefix makes the directory names longer and also
makes it awkward to add features referring to individual libraries in the
build - should the lib names be specified with or without the prefix.
Therefore, we can just remove the library prefix and use the library's
unique name as the directory name, i.e. 'eal' rather than 'librte_eal'

Signed-off-by: Bruce Richardson <bruce.richardson@intel.com>
2021-04-21 14:04:09 +02:00

282 lines
5.6 KiB
C

/* SPDX-License-Identifier: BSD-3-Clause
* Copyright(c) 2010-2013 Intel Corporation.
* Copyright(c) 2014 6WIND S.A.
*/
#include <string.h>
#include <stdlib.h>
#include <stdbool.h>
#include <rte_os_shim.h>
#include <rte_string_fns.h>
#include "rte_kvargs.h"
/*
* Receive a string with a list of arguments following the pattern
* key=value,key=value,... and insert them into the list.
* Params string will be copied to be modified.
* list "[]" and list element splitter ",", "-" is treated as value.
* Supported examples:
* k1=v1,k2=v2
* k1
* k1=x[0-1]y[1,3-5,9]z
*/
static int
rte_kvargs_tokenize(struct rte_kvargs *kvlist, const char *params)
{
char *str, *start;
bool in_list = false, end_key = false, end_value = false;
bool save = false, end_pair = false;
/* Copy the const char *params to a modifiable string
* to pass to rte_strsplit
*/
kvlist->str = strdup(params);
if (kvlist->str == NULL)
return -1;
/* browse each key/value pair and add it in kvlist */
str = kvlist->str;
start = str; /* start of current key or value */
while (1) {
switch (*str) {
case '=': /* End of key. */
end_key = true;
save = true;
break;
case ',':
/* End of value, skip comma in middle of range */
if (!in_list) {
if (end_key)
end_value = true;
else
end_key = true;
save = true;
end_pair = true;
}
break;
case '[': /* Start of list. */
in_list = true;
break;
case ']': /* End of list. */
if (in_list)
in_list = false;
break;
case '\0': /* End of string */
if (end_key)
end_value = true;
else
end_key = true;
save = true;
end_pair = true;
break;
default:
break;
}
if (!save) {
/* Continue if not end of key or value. */
str++;
continue;
}
if (kvlist->count >= RTE_KVARGS_MAX)
return -1;
if (end_value)
/* Value parsed */
kvlist->pairs[kvlist->count].value = start;
else if (end_key)
/* Key parsed. */
kvlist->pairs[kvlist->count].key = start;
if (end_pair) {
if (end_value || str != start)
/* Ignore empty pair. */
kvlist->count++;
end_key = false;
end_value = false;
end_pair = false;
}
if (*str == '\0') /* End of string. */
break;
*str = '\0';
str++;
start = str;
save = false;
}
return 0;
}
/*
* Determine whether a key is valid or not by looking
* into a list of valid keys.
*/
static int
is_valid_key(const char * const valid[], const char *key_match)
{
const char * const *valid_ptr;
for (valid_ptr = valid; *valid_ptr != NULL; valid_ptr++) {
if (strcmp(key_match, *valid_ptr) == 0)
return 1;
}
return 0;
}
/*
* Determine whether all keys are valid or not by looking
* into a list of valid keys.
*/
static int
check_for_valid_keys(struct rte_kvargs *kvlist,
const char * const valid[])
{
unsigned i, ret;
struct rte_kvargs_pair *pair;
for (i = 0; i < kvlist->count; i++) {
pair = &kvlist->pairs[i];
ret = is_valid_key(valid, pair->key);
if (!ret)
return -1;
}
return 0;
}
/*
* Return the number of times a given arg_name exists in the key/value list.
* E.g. given a list = { rx = 0, rx = 1, tx = 2 } the number of args for
* arg "rx" will be 2.
*/
unsigned
rte_kvargs_count(const struct rte_kvargs *kvlist, const char *key_match)
{
const struct rte_kvargs_pair *pair;
unsigned i, ret;
ret = 0;
for (i = 0; i < kvlist->count; i++) {
pair = &kvlist->pairs[i];
if (key_match == NULL || strcmp(pair->key, key_match) == 0)
ret++;
}
return ret;
}
/*
* For each matching key, call the given handler function.
*/
int
rte_kvargs_process(const struct rte_kvargs *kvlist,
const char *key_match,
arg_handler_t handler,
void *opaque_arg)
{
const struct rte_kvargs_pair *pair;
unsigned i;
if (kvlist == NULL)
return 0;
for (i = 0; i < kvlist->count; i++) {
pair = &kvlist->pairs[i];
if (key_match == NULL || strcmp(pair->key, key_match) == 0) {
if ((*handler)(pair->key, pair->value, opaque_arg) < 0)
return -1;
}
}
return 0;
}
/* free the rte_kvargs structure */
void
rte_kvargs_free(struct rte_kvargs *kvlist)
{
if (!kvlist)
return;
free(kvlist->str);
free(kvlist);
}
/* Lookup a value in an rte_kvargs list by its key. */
const char *
rte_kvargs_get(const struct rte_kvargs *kvlist, const char *key)
{
unsigned int i;
if (kvlist == NULL || key == NULL)
return NULL;
for (i = 0; i < kvlist->count; ++i) {
if (strcmp(kvlist->pairs[i].key, key) == 0)
return kvlist->pairs[i].value;
}
return NULL;
}
/*
* Parse the arguments "key=value,key=value,..." string and return
* an allocated structure that contains a key/value list. Also
* check if only valid keys were used.
*/
struct rte_kvargs *
rte_kvargs_parse(const char *args, const char * const valid_keys[])
{
struct rte_kvargs *kvlist;
kvlist = malloc(sizeof(*kvlist));
if (kvlist == NULL)
return NULL;
memset(kvlist, 0, sizeof(*kvlist));
if (rte_kvargs_tokenize(kvlist, args) < 0) {
rte_kvargs_free(kvlist);
return NULL;
}
if (valid_keys != NULL && check_for_valid_keys(kvlist, valid_keys) < 0) {
rte_kvargs_free(kvlist);
return NULL;
}
return kvlist;
}
struct rte_kvargs *
rte_kvargs_parse_delim(const char *args, const char * const valid_keys[],
const char *valid_ends)
{
struct rte_kvargs *kvlist = NULL;
char *copy;
size_t len;
if (valid_ends == NULL)
return rte_kvargs_parse(args, valid_keys);
copy = strdup(args);
if (copy == NULL)
return NULL;
len = strcspn(copy, valid_ends);
copy[len] = '\0';
kvlist = rte_kvargs_parse(copy, valid_keys);
free(copy);
return kvlist;
}
int
rte_kvargs_strcmp(const char *key __rte_unused,
const char *value, void *opaque)
{
const char *str = opaque;
return -abs(strcmp(str, value));
}