pci: use SPDX tags in 6WIND copyrighted files
[dpdk.git] / app / test-eventdev / parser.c
1 /*-
2  *   BSD LICENSE
3  *
4  *   Copyright(c) 2016 Intel Corporation. All rights reserved.
5  *   Copyright(c) 2017 Cavium, Inc. All rights reserved.
6  *   All rights reserved.
7  *
8  *   Redistribution and use in source and binary forms, with or without
9  *   modification, are permitted provided that the following conditions
10  *   are met:
11  *
12  *     * Redistributions of source code must retain the above copyright
13  *       notice, this list of conditions and the following disclaimer.
14  *     * Redistributions in binary form must reproduce the above copyright
15  *       notice, this list of conditions and the following disclaimer in
16  *       the documentation and/or other materials provided with the
17  *       distribution.
18  *     * Neither the name of Intel Corporation nor the names of its
19  *       contributors may be used to endorse or promote products derived
20  *       from this software without specific prior written permission.
21  *
22  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
23  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
24  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
25  *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
26  *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
27  *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
28  *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
29  *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
30  *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
31  *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
32  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33  */
34
35 #include <stdint.h>
36 #include <stdlib.h>
37 #include <stdio.h>
38 #include <ctype.h>
39 #include <getopt.h>
40 #include <errno.h>
41 #include <stdarg.h>
42 #include <string.h>
43 #include <libgen.h>
44 #include <unistd.h>
45 #include <sys/wait.h>
46 #include <stdbool.h>
47
48 #include <rte_errno.h>
49 #include <rte_string_fns.h>
50
51 #include "parser.h"
52
53 static uint32_t
54 get_hex_val(char c)
55 {
56         switch (c) {
57         case '0': case '1': case '2': case '3': case '4': case '5':
58         case '6': case '7': case '8': case '9':
59                 return c - '0';
60         case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
61                 return c - 'A' + 10;
62         case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
63                 return c - 'a' + 10;
64         default:
65                 return 0;
66         }
67 }
68
69 int
70 parser_read_arg_bool(const char *p)
71 {
72         p = skip_white_spaces(p);
73         int result = -EINVAL;
74
75         if (((p[0] == 'y') && (p[1] == 'e') && (p[2] == 's')) ||
76                 ((p[0] == 'Y') && (p[1] == 'E') && (p[2] == 'S'))) {
77                 p += 3;
78                 result = 1;
79         }
80
81         if (((p[0] == 'o') && (p[1] == 'n')) ||
82                 ((p[0] == 'O') && (p[1] == 'N'))) {
83                 p += 2;
84                 result = 1;
85         }
86
87         if (((p[0] == 'n') && (p[1] == 'o')) ||
88                 ((p[0] == 'N') && (p[1] == 'O'))) {
89                 p += 2;
90                 result = 0;
91         }
92
93         if (((p[0] == 'o') && (p[1] == 'f') && (p[2] == 'f')) ||
94                 ((p[0] == 'O') && (p[1] == 'F') && (p[2] == 'F'))) {
95                 p += 3;
96                 result = 0;
97         }
98
99         p = skip_white_spaces(p);
100
101         if (p[0] != '\0')
102                 return -EINVAL;
103
104         return result;
105 }
106
107 int
108 parser_read_uint64(uint64_t *value, const char *p)
109 {
110         char *next;
111         uint64_t val;
112
113         p = skip_white_spaces(p);
114         if (!isdigit(*p))
115                 return -EINVAL;
116
117         val = strtoul(p, &next, 10);
118         if (p == next)
119                 return -EINVAL;
120
121         p = next;
122         switch (*p) {
123         case 'T':
124                 val *= 1024ULL;
125                 /* fall through */
126         case 'G':
127                 val *= 1024ULL;
128                 /* fall through */
129         case 'M':
130                 val *= 1024ULL;
131                 /* fall through */
132         case 'k':
133         case 'K':
134                 val *= 1024ULL;
135                 p++;
136                 break;
137         }
138
139         p = skip_white_spaces(p);
140         if (*p != '\0')
141                 return -EINVAL;
142
143         *value = val;
144         return 0;
145 }
146
147 int
148 parser_read_int32(int32_t *value, const char *p)
149 {
150         char *next;
151         int32_t val;
152
153         p = skip_white_spaces(p);
154         if (!isdigit(*p))
155                 return -EINVAL;
156
157         val = strtol(p, &next, 10);
158         if (p == next)
159                 return -EINVAL;
160
161         *value = val;
162         return 0;
163 }
164
165 int
166 parser_read_uint64_hex(uint64_t *value, const char *p)
167 {
168         char *next;
169         uint64_t val;
170
171         p = skip_white_spaces(p);
172
173         val = strtoul(p, &next, 16);
174         if (p == next)
175                 return -EINVAL;
176
177         p = skip_white_spaces(next);
178         if (*p != '\0')
179                 return -EINVAL;
180
181         *value = val;
182         return 0;
183 }
184
185 int
186 parser_read_uint32(uint32_t *value, const char *p)
187 {
188         uint64_t val = 0;
189         int ret = parser_read_uint64(&val, p);
190
191         if (ret < 0)
192                 return ret;
193
194         if (val > UINT32_MAX)
195                 return -ERANGE;
196
197         *value = val;
198         return 0;
199 }
200
201 int
202 parser_read_uint32_hex(uint32_t *value, const char *p)
203 {
204         uint64_t val = 0;
205         int ret = parser_read_uint64_hex(&val, p);
206
207         if (ret < 0)
208                 return ret;
209
210         if (val > UINT32_MAX)
211                 return -ERANGE;
212
213         *value = val;
214         return 0;
215 }
216
217 int
218 parser_read_uint16(uint16_t *value, const char *p)
219 {
220         uint64_t val = 0;
221         int ret = parser_read_uint64(&val, p);
222
223         if (ret < 0)
224                 return ret;
225
226         if (val > UINT16_MAX)
227                 return -ERANGE;
228
229         *value = val;
230         return 0;
231 }
232
233 int
234 parser_read_uint16_hex(uint16_t *value, const char *p)
235 {
236         uint64_t val = 0;
237         int ret = parser_read_uint64_hex(&val, p);
238
239         if (ret < 0)
240                 return ret;
241
242         if (val > UINT16_MAX)
243                 return -ERANGE;
244
245         *value = val;
246         return 0;
247 }
248
249 int
250 parser_read_uint8(uint8_t *value, const char *p)
251 {
252         uint64_t val = 0;
253         int ret = parser_read_uint64(&val, p);
254
255         if (ret < 0)
256                 return ret;
257
258         if (val > UINT8_MAX)
259                 return -ERANGE;
260
261         *value = val;
262         return 0;
263 }
264
265 int
266 parser_read_uint8_hex(uint8_t *value, const char *p)
267 {
268         uint64_t val = 0;
269         int ret = parser_read_uint64_hex(&val, p);
270
271         if (ret < 0)
272                 return ret;
273
274         if (val > UINT8_MAX)
275                 return -ERANGE;
276
277         *value = val;
278         return 0;
279 }
280
281 int
282 parse_tokenize_string(char *string, char *tokens[], uint32_t *n_tokens)
283 {
284         uint32_t i;
285
286         if ((string == NULL) ||
287                 (tokens == NULL) ||
288                 (*n_tokens < 1))
289                 return -EINVAL;
290
291         for (i = 0; i < *n_tokens; i++) {
292                 tokens[i] = strtok_r(string, PARSE_DELIMITER, &string);
293                 if (tokens[i] == NULL)
294                         break;
295         }
296
297         if ((i == *n_tokens) &&
298                 (strtok_r(string, PARSE_DELIMITER, &string) != NULL))
299                 return -E2BIG;
300
301         *n_tokens = i;
302         return 0;
303 }
304
305 int
306 parse_hex_string(char *src, uint8_t *dst, uint32_t *size)
307 {
308         char *c;
309         uint32_t len, i;
310
311         /* Check input parameters */
312         if ((src == NULL) ||
313                 (dst == NULL) ||
314                 (size == NULL) ||
315                 (*size == 0))
316                 return -1;
317
318         len = strlen(src);
319         if (((len & 3) != 0) ||
320                 (len > (*size) * 2))
321                 return -1;
322         *size = len / 2;
323
324         for (c = src; *c != 0; c++) {
325                 if ((((*c) >= '0') && ((*c) <= '9')) ||
326                         (((*c) >= 'A') && ((*c) <= 'F')) ||
327                         (((*c) >= 'a') && ((*c) <= 'f')))
328                         continue;
329
330                 return -1;
331         }
332
333         /* Convert chars to bytes */
334         for (i = 0; i < *size; i++)
335                 dst[i] = get_hex_val(src[2 * i]) * 16 +
336                         get_hex_val(src[2 * i + 1]);
337
338         return 0;
339 }
340
341 int
342 parse_lcores_list(bool lcores[], const char *corelist)
343 {
344         int i, idx = 0;
345         int min, max;
346         char *end = NULL;
347
348         if (corelist == NULL)
349                 return -1;
350         while (isblank(*corelist))
351                 corelist++;
352         i = strlen(corelist);
353         while ((i > 0) && isblank(corelist[i - 1]))
354                 i--;
355
356         /* Get list of lcores */
357         min = RTE_MAX_LCORE;
358         do {
359                 while (isblank(*corelist))
360                         corelist++;
361                 if (*corelist == '\0')
362                         return -1;
363                 idx = strtoul(corelist, &end, 10);
364
365                 if (end == NULL)
366                         return -1;
367                 while (isblank(*end))
368                         end++;
369                 if (*end == '-') {
370                         min = idx;
371                 } else if ((*end == ',') || (*end == '\0')) {
372                         max = idx;
373                         if (min == RTE_MAX_LCORE)
374                                 min = idx;
375                         for (idx = min; idx <= max; idx++) {
376                                 if (lcores[idx] == 1)
377                                         return -E2BIG;
378                                 lcores[idx] = 1;
379                         }
380
381                         min = RTE_MAX_LCORE;
382                 } else
383                         return -1;
384                 corelist = end + 1;
385         } while (*end != '\0');
386
387         return 0;
388 }