1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2010-2013 Intel Corporation.
3 * Copyright(c) 2014 6WIND S.A.
4 */
5
6 #include <string.h>
7 #include <stdlib.h>
8
9 #include <rte_string_fns.h>
10
11 #include "rte_kvargs.h"
12
13 /*
14 * Receive a string with a list of arguments following the pattern
15 * key=value,key=value,... and insert them into the list.
16 * strtok() is used so the params string will be copied to be modified.
17 */
18 static int
rte_kvargs_tokenize(struct rte_kvargs * kvlist,const char * params)19 rte_kvargs_tokenize(struct rte_kvargs *kvlist, const char *params)
20 {
21 unsigned i;
22 char *str;
23 char *ctx1 = NULL;
24 char *ctx2 = NULL;
25
26 /* Copy the const char *params to a modifiable string
27 * to pass to rte_strsplit
28 */
29 kvlist->str = strdup(params);
30 if (kvlist->str == NULL)
31 return -1;
32
33 /* browse each key/value pair and add it in kvlist */
34 str = kvlist->str;
35 while ((str = strtok_r(str, RTE_KVARGS_PAIRS_DELIM, &ctx1)) != NULL) {
36
37 i = kvlist->count;
38 if (i >= RTE_KVARGS_MAX)
39 return -1;
40
41 kvlist->pairs[i].key = strtok_r(str, RTE_KVARGS_KV_DELIM, &ctx2);
42 kvlist->pairs[i].value = strtok_r(NULL, RTE_KVARGS_KV_DELIM, &ctx2);
43 if (kvlist->pairs[i].key == NULL ||
44 kvlist->pairs[i].value == NULL)
45 return -1;
46
47 /* Detect list [a,b] to skip comma delimiter in list. */
48 str = kvlist->pairs[i].value;
49 if (str[0] == '[') {
50 /* Find the end of the list. */
51 while (str[strlen(str) - 1] != ']') {
52 /* Restore the comma erased by strtok_r(). */
53 if (ctx1 == NULL || ctx1[0] == '\0')
54 return -1; /* no closing bracket */
55 str[strlen(str)] = ',';
56 /* Parse until next comma. */
57 str = strtok_r(NULL, RTE_KVARGS_PAIRS_DELIM, &ctx1);
58 if (str == NULL)
59 return -1; /* no closing bracket */
60 }
61 }
62
63 kvlist->count++;
64 str = NULL;
65 }
66
67 return 0;
68 }
69
70 /*
71 * Determine whether a key is valid or not by looking
72 * into a list of valid keys.
73 */
74 static int
is_valid_key(const char * const valid[],const char * key_match)75 is_valid_key(const char * const valid[], const char *key_match)
76 {
77 const char * const *valid_ptr;
78
79 for (valid_ptr = valid; *valid_ptr != NULL; valid_ptr++) {
80 if (strcmp(key_match, *valid_ptr) == 0)
81 return 1;
82 }
83 return 0;
84 }
85
86 /*
87 * Determine whether all keys are valid or not by looking
88 * into a list of valid keys.
89 */
90 static int
check_for_valid_keys(struct rte_kvargs * kvlist,const char * const valid[])91 check_for_valid_keys(struct rte_kvargs *kvlist,
92 const char * const valid[])
93 {
94 unsigned i, ret;
95 struct rte_kvargs_pair *pair;
96
97 for (i = 0; i < kvlist->count; i++) {
98 pair = &kvlist->pairs[i];
99 ret = is_valid_key(valid, pair->key);
100 if (!ret)
101 return -1;
102 }
103 return 0;
104 }
105
106 /*
107 * Return the number of times a given arg_name exists in the key/value list.
108 * E.g. given a list = { rx = 0, rx = 1, tx = 2 } the number of args for
109 * arg "rx" will be 2.
110 */
111 unsigned
rte_kvargs_count(const struct rte_kvargs * kvlist,const char * key_match)112 rte_kvargs_count(const struct rte_kvargs *kvlist, const char *key_match)
113 {
114 const struct rte_kvargs_pair *pair;
115 unsigned i, ret;
116
117 ret = 0;
118 for (i = 0; i < kvlist->count; i++) {
119 pair = &kvlist->pairs[i];
120 if (key_match == NULL || strcmp(pair->key, key_match) == 0)
121 ret++;
122 }
123
124 return ret;
125 }
126
127 /*
128 * For each matching key, call the given handler function.
129 */
130 int
rte_kvargs_process(const struct rte_kvargs * kvlist,const char * key_match,arg_handler_t handler,void * opaque_arg)131 rte_kvargs_process(const struct rte_kvargs *kvlist,
132 const char *key_match,
133 arg_handler_t handler,
134 void *opaque_arg)
135 {
136 const struct rte_kvargs_pair *pair;
137 unsigned i;
138
139 if (kvlist == NULL)
140 return 0;
141
142 for (i = 0; i < kvlist->count; i++) {
143 pair = &kvlist->pairs[i];
144 if (key_match == NULL || strcmp(pair->key, key_match) == 0) {
145 if ((*handler)(pair->key, pair->value, opaque_arg) < 0)
146 return -1;
147 }
148 }
149 return 0;
150 }
151
152 /* free the rte_kvargs structure */
153 void
rte_kvargs_free(struct rte_kvargs * kvlist)154 rte_kvargs_free(struct rte_kvargs *kvlist)
155 {
156 if (!kvlist)
157 return;
158
159 free(kvlist->str);
160 free(kvlist);
161 }
162
163 /*
164 * Parse the arguments "key=value,key=value,..." string and return
165 * an allocated structure that contains a key/value list. Also
166 * check if only valid keys were used.
167 */
168 struct rte_kvargs *
rte_kvargs_parse(const char * args,const char * const valid_keys[])169 rte_kvargs_parse(const char *args, const char * const valid_keys[])
170 {
171 struct rte_kvargs *kvlist;
172
173 kvlist = malloc(sizeof(*kvlist));
174 if (kvlist == NULL)
175 return NULL;
176 memset(kvlist, 0, sizeof(*kvlist));
177
178 if (rte_kvargs_tokenize(kvlist, args) < 0) {
179 rte_kvargs_free(kvlist);
180 return NULL;
181 }
182
183 if (valid_keys != NULL && check_for_valid_keys(kvlist, valid_keys) < 0) {
184 rte_kvargs_free(kvlist);
185 return NULL;
186 }
187
188 return kvlist;
189 }
190
191 struct rte_kvargs *
rte_kvargs_parse_delim(const char * args,const char * const valid_keys[],const char * valid_ends)192 rte_kvargs_parse_delim(const char *args, const char * const valid_keys[],
193 const char *valid_ends)
194 {
195 struct rte_kvargs *kvlist = NULL;
196 char *copy;
197 size_t len;
198
199 if (valid_ends == NULL)
200 return rte_kvargs_parse(args, valid_keys);
201
202 copy = strdup(args);
203 if (copy == NULL)
204 return NULL;
205
206 len = strcspn(copy, valid_ends);
207 copy[len] = '\0';
208
209 kvlist = rte_kvargs_parse(copy, valid_keys);
210
211 free(copy);
212 return kvlist;
213 }
214
215 int
rte_kvargs_strcmp(const char * key __rte_unused,const char * value,void * opaque)216 rte_kvargs_strcmp(const char *key __rte_unused,
217 const char *value, void *opaque)
218 {
219 const char *str = opaque;
220
221 return -abs(strcmp(str, value));
222 }
223