net/avp: remove resources when port is closed
[dpdk.git] / drivers / net / softnic / parser.c
1 /* SPDX-License-Identifier: BSD-3-Clause
2  * Copyright(c) 2016 Intel Corporation.
3  * Copyright (c) 2009, Olivier MATZ <zer0@droids-corp.org>
4  * All rights reserved.
5  */
6
7 /* For inet_pton4() and inet_pton6() functions:
8  *
9  * Copyright (c) 1996 by Internet Software Consortium.
10  *
11  * Permission to use, copy, modify, and distribute this software for any
12  * purpose with or without fee is hereby granted, provided that the above
13  * copyright notice and this permission notice appear in all copies.
14  *
15  * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM DISCLAIMS
16  * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
17  * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE
18  * CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
19  * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
20  * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
21  * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
22  * SOFTWARE.
23  */
24
25 #include <stdint.h>
26 #include <stdlib.h>
27 #include <stdio.h>
28 #include <ctype.h>
29 #include <getopt.h>
30 #include <errno.h>
31 #include <stdarg.h>
32 #include <string.h>
33 #include <libgen.h>
34 #include <unistd.h>
35 #include <sys/wait.h>
36
37 #include <rte_errno.h>
38
39 #include "parser.h"
40
41 static uint32_t
42 get_hex_val(char c)
43 {
44         switch (c) {
45         case '0': case '1': case '2': case '3': case '4': case '5':
46         case '6': case '7': case '8': case '9':
47                 return c - '0';
48         case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
49                 return c - 'A' + 10;
50         case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
51                 return c - 'a' + 10;
52         default:
53                 return 0;
54         }
55 }
56
57 int
58 softnic_parser_read_arg_bool(const char *p)
59 {
60         p = skip_white_spaces(p);
61         int result = -EINVAL;
62
63         if (((p[0] == 'y') && (p[1] == 'e') && (p[2] == 's')) ||
64                 ((p[0] == 'Y') && (p[1] == 'E') && (p[2] == 'S'))) {
65                 p += 3;
66                 result = 1;
67         }
68
69         if (((p[0] == 'o') && (p[1] == 'n')) ||
70                 ((p[0] == 'O') && (p[1] == 'N'))) {
71                 p += 2;
72                 result = 1;
73         }
74
75         if (((p[0] == 'n') && (p[1] == 'o')) ||
76                 ((p[0] == 'N') && (p[1] == 'O'))) {
77                 p += 2;
78                 result = 0;
79         }
80
81         if (((p[0] == 'o') && (p[1] == 'f') && (p[2] == 'f')) ||
82                 ((p[0] == 'O') && (p[1] == 'F') && (p[2] == 'F'))) {
83                 p += 3;
84                 result = 0;
85         }
86
87         p = skip_white_spaces(p);
88
89         if (p[0] != '\0')
90                 return -EINVAL;
91
92         return result;
93 }
94
95 int
96 softnic_parser_read_int32(int32_t *value, const char *p)
97 {
98         char *next;
99         int32_t val;
100
101         p = skip_white_spaces(p);
102         if (!isdigit(*p))
103                 return -EINVAL;
104
105         val = strtol(p, &next, 10);
106         if (p == next)
107                 return -EINVAL;
108
109         *value = val;
110         return 0;
111 }
112
113 int
114 softnic_parser_read_uint64(uint64_t *value, const char *p)
115 {
116         char *next;
117         uint64_t val;
118
119         p = skip_white_spaces(p);
120         if (!isdigit(*p))
121                 return -EINVAL;
122
123         val = strtoul(p, &next, 10);
124         if (p == next)
125                 return -EINVAL;
126
127         p = next;
128         switch (*p) {
129         case 'T':
130                 val *= 1024ULL;
131                 /* fall through */
132         case 'G':
133                 val *= 1024ULL;
134                 /* fall through */
135         case 'M':
136                 val *= 1024ULL;
137                 /* fall through */
138         case 'k':
139         case 'K':
140                 val *= 1024ULL;
141                 p++;
142                 break;
143         }
144
145         p = skip_white_spaces(p);
146         if (*p != '\0')
147                 return -EINVAL;
148
149         *value = val;
150         return 0;
151 }
152
153 int
154 softnic_parser_read_uint64_hex(uint64_t *value, const char *p)
155 {
156         char *next;
157         uint64_t val;
158
159         p = skip_white_spaces(p);
160
161         val = strtoul(p, &next, 16);
162         if (p == next)
163                 return -EINVAL;
164
165         p = skip_white_spaces(next);
166         if (*p != '\0')
167                 return -EINVAL;
168
169         *value = val;
170         return 0;
171 }
172
173 int
174 softnic_parser_read_uint32(uint32_t *value, const char *p)
175 {
176         uint64_t val = 0;
177         int ret = softnic_parser_read_uint64(&val, p);
178
179         if (ret < 0)
180                 return ret;
181
182         if (val > UINT32_MAX)
183                 return -ERANGE;
184
185         *value = val;
186         return 0;
187 }
188
189 int
190 softnic_parser_read_uint32_hex(uint32_t *value, const char *p)
191 {
192         uint64_t val = 0;
193         int ret = softnic_parser_read_uint64_hex(&val, p);
194
195         if (ret < 0)
196                 return ret;
197
198         if (val > UINT32_MAX)
199                 return -ERANGE;
200
201         *value = val;
202         return 0;
203 }
204
205 int
206 softnic_parser_read_uint16(uint16_t *value, const char *p)
207 {
208         uint64_t val = 0;
209         int ret = softnic_parser_read_uint64(&val, p);
210
211         if (ret < 0)
212                 return ret;
213
214         if (val > UINT16_MAX)
215                 return -ERANGE;
216
217         *value = val;
218         return 0;
219 }
220
221 int
222 softnic_parser_read_uint16_hex(uint16_t *value, const char *p)
223 {
224         uint64_t val = 0;
225         int ret = softnic_parser_read_uint64_hex(&val, p);
226
227         if (ret < 0)
228                 return ret;
229
230         if (val > UINT16_MAX)
231                 return -ERANGE;
232
233         *value = val;
234         return 0;
235 }
236
237 int
238 softnic_parser_read_uint8(uint8_t *value, const char *p)
239 {
240         uint64_t val = 0;
241         int ret = softnic_parser_read_uint64(&val, p);
242
243         if (ret < 0)
244                 return ret;
245
246         if (val > UINT8_MAX)
247                 return -ERANGE;
248
249         *value = val;
250         return 0;
251 }
252
253 int
254 softnic_parser_read_uint8_hex(uint8_t *value, const char *p)
255 {
256         uint64_t val = 0;
257         int ret = softnic_parser_read_uint64_hex(&val, p);
258
259         if (ret < 0)
260                 return ret;
261
262         if (val > UINT8_MAX)
263                 return -ERANGE;
264
265         *value = val;
266         return 0;
267 }
268
269 int
270 softnic_parse_tokenize_string(char *string, char *tokens[], uint32_t *n_tokens)
271 {
272         uint32_t i;
273
274         if (string == NULL ||
275                 tokens == NULL ||
276                 (*n_tokens < 1))
277                 return -EINVAL;
278
279         for (i = 0; i < *n_tokens; i++) {
280                 tokens[i] = strtok_r(string, PARSE_DELIMITER, &string);
281                 if (tokens[i] == NULL)
282                         break;
283         }
284
285         if (i == *n_tokens &&
286                 strtok_r(string, PARSE_DELIMITER, &string) != NULL)
287                 return -E2BIG;
288
289         *n_tokens = i;
290         return 0;
291 }
292
293 int
294 softnic_parse_hex_string(char *src, uint8_t *dst, uint32_t *size)
295 {
296         char *c;
297         uint32_t len, i;
298
299         /* Check input parameters */
300         if (src == NULL ||
301                 dst == NULL ||
302                 size == NULL ||
303                 (*size == 0))
304                 return -1;
305
306         len = strlen(src);
307         if (((len & 3) != 0) ||
308                 (len > (*size) * 2))
309                 return -1;
310         *size = len / 2;
311
312         for (c = src; *c != 0; c++) {
313                 if ((((*c) >= '0') && ((*c) <= '9')) ||
314                         (((*c) >= 'A') && ((*c) <= 'F')) ||
315                         (((*c) >= 'a') && ((*c) <= 'f')))
316                         continue;
317
318                 return -1;
319         }
320
321         /* Convert chars to bytes */
322         for (i = 0; i < *size; i++)
323                 dst[i] = get_hex_val(src[2 * i]) * 16 +
324                         get_hex_val(src[2 * i + 1]);
325
326         return 0;
327 }
328
329 int
330 softnic_parse_mpls_labels(char *string, uint32_t *labels, uint32_t *n_labels)
331 {
332         uint32_t n_max_labels = *n_labels, count = 0;
333
334         /* Check for void list of labels */
335         if (strcmp(string, "<void>") == 0) {
336                 *n_labels = 0;
337                 return 0;
338         }
339
340         /* At least one label should be present */
341         for ( ; (*string != '\0'); ) {
342                 char *next;
343                 int value;
344
345                 if (count >= n_max_labels)
346                         return -1;
347
348                 if (count > 0) {
349                         if (string[0] != ':')
350                                 return -1;
351
352                         string++;
353                 }
354
355                 value = strtol(string, &next, 10);
356                 if (next == string)
357                         return -1;
358                 string = next;
359
360                 labels[count++] = (uint32_t)value;
361         }
362
363         *n_labels = count;
364         return 0;
365 }
366
367 #define INADDRSZ 4
368 #define IN6ADDRSZ 16
369
370 /* int
371  * inet_pton4(src, dst)
372  *      like inet_aton() but without all the hexadecimal and shorthand.
373  * return:
374  *      1 if `src' is a valid dotted quad, else 0.
375  * notice:
376  *      does not touch `dst' unless it's returning 1.
377  * author:
378  *      Paul Vixie, 1996.
379  */
380 static int
381 inet_pton4(const char *src, unsigned char *dst)
382 {
383         static const char digits[] = "0123456789";
384         int saw_digit, octets, ch;
385         unsigned char tmp[INADDRSZ], *tp;
386
387         saw_digit = 0;
388         octets = 0;
389         *(tp = tmp) = 0;
390         while ((ch = *src++) != '\0') {
391                 const char *pch;
392
393                 pch = strchr(digits, ch);
394                 if (pch != NULL) {
395                         unsigned int new = *tp * 10 + (pch - digits);
396
397                         if (new > 255)
398                                 return 0;
399                         if (!saw_digit) {
400                                 if (++octets > 4)
401                                         return 0;
402                                 saw_digit = 1;
403                         }
404                         *tp = (unsigned char)new;
405                 } else if (ch == '.' && saw_digit) {
406                         if (octets == 4)
407                                 return 0;
408                         *++tp = 0;
409                         saw_digit = 0;
410                 } else
411                         return 0;
412         }
413         if (octets < 4)
414                 return 0;
415
416         memcpy(dst, tmp, INADDRSZ);
417         return 1;
418 }
419
420 /* int
421  * inet_pton6(src, dst)
422  *      convert presentation level address to network order binary form.
423  * return:
424  *      1 if `src' is a valid [RFC1884 2.2] address, else 0.
425  * notice:
426  *      (1) does not touch `dst' unless it's returning 1.
427  *      (2) :: in a full address is silently ignored.
428  * credit:
429  *      inspired by Mark Andrews.
430  * author:
431  *      Paul Vixie, 1996.
432  */
433 static int
434 inet_pton6(const char *src, unsigned char *dst)
435 {
436         static const char xdigits_l[] = "0123456789abcdef",
437                 xdigits_u[] = "0123456789ABCDEF";
438         unsigned char tmp[IN6ADDRSZ], *tp = 0, *endp = 0, *colonp = 0;
439         const char *xdigits = 0, *curtok = 0;
440         int ch = 0, saw_xdigit = 0, count_xdigit = 0;
441         unsigned int val = 0;
442         unsigned int dbloct_count = 0;
443
444         memset((tp = tmp), '\0', IN6ADDRSZ);
445         endp = tp + IN6ADDRSZ;
446         colonp = NULL;
447         /* Leading :: requires some special handling. */
448         if (*src == ':')
449                 if (*++src != ':')
450                         return 0;
451         curtok = src;
452         saw_xdigit = count_xdigit = 0;
453         val = 0;
454
455         while ((ch = *src++) != '\0') {
456                 const char *pch;
457
458                 pch = strchr((xdigits = xdigits_l), ch);
459                 if (pch == NULL)
460                         pch = strchr((xdigits = xdigits_u), ch);
461                 if (pch != NULL) {
462                         if (count_xdigit >= 4)
463                                 return 0;
464                         val <<= 4;
465                         val |= (pch - xdigits);
466                         if (val > 0xffff)
467                                 return 0;
468                         saw_xdigit = 1;
469                         count_xdigit++;
470                         continue;
471                 }
472                 if (ch == ':') {
473                         curtok = src;
474                         if (!saw_xdigit) {
475                                 if (colonp)
476                                         return 0;
477                                 colonp = tp;
478                                 continue;
479                         } else if (*src == '\0') {
480                                 return 0;
481                         }
482                         if (tp + sizeof(int16_t) > endp)
483                                 return 0;
484                         *tp++ = (unsigned char)((val >> 8) & 0xff);
485                         *tp++ = (unsigned char)(val & 0xff);
486                         saw_xdigit = 0;
487                         count_xdigit = 0;
488                         val = 0;
489                         dbloct_count++;
490                         continue;
491                 }
492                 if (ch == '.' && ((tp + INADDRSZ) <= endp) &&
493                     inet_pton4(curtok, tp) > 0) {
494                         tp += INADDRSZ;
495                         saw_xdigit = 0;
496                         dbloct_count += 2;
497                         break;  /* '\0' was seen by inet_pton4(). */
498                 }
499                 return 0;
500         }
501         if (saw_xdigit) {
502                 if (tp + sizeof(int16_t) > endp)
503                         return 0;
504                 *tp++ = (unsigned char)((val >> 8) & 0xff);
505                 *tp++ = (unsigned char)(val & 0xff);
506                 dbloct_count++;
507         }
508         if (colonp != NULL) {
509                 /* if we already have 8 double octets, having a colon means error */
510                 if (dbloct_count == 8)
511                         return 0;
512
513                 /* Since some memmove()'s erroneously fail to handle
514                  * overlapping regions, we'll do the shift by hand.
515                  */
516                 const int n = tp - colonp;
517                 int i;
518
519                 for (i = 1; i <= n; i++) {
520                         endp[-i] = colonp[n - i];
521                         colonp[n - i] = 0;
522                 }
523                 tp = endp;
524         }
525         if (tp != endp)
526                 return 0;
527         memcpy(dst, tmp, IN6ADDRSZ);
528         return 1;
529 }
530
531 static struct rte_ether_addr *
532 my_ether_aton(const char *a)
533 {
534         int i;
535         char *end;
536         unsigned long o[RTE_ETHER_ADDR_LEN];
537         static struct rte_ether_addr ether_addr;
538
539         i = 0;
540         do {
541                 errno = 0;
542                 o[i] = strtoul(a, &end, 16);
543                 if (errno != 0 || end == a || (end[0] != ':' && end[0] != 0))
544                         return NULL;
545                 a = end + 1;
546         } while (++i != sizeof(o) / sizeof(o[0]) && end[0] != 0);
547
548         /* Junk at the end of line */
549         if (end[0] != 0)
550                 return NULL;
551
552         /* Support the format XX:XX:XX:XX:XX:XX */
553         if (i == RTE_ETHER_ADDR_LEN) {
554                 while (i-- != 0) {
555                         if (o[i] > UINT8_MAX)
556                                 return NULL;
557                         ether_addr.addr_bytes[i] = (uint8_t)o[i];
558                 }
559         /* Support the format XXXX:XXXX:XXXX */
560         } else if (i == RTE_ETHER_ADDR_LEN / 2) {
561                 while (i-- != 0) {
562                         if (o[i] > UINT16_MAX)
563                                 return NULL;
564                         ether_addr.addr_bytes[i * 2] = (uint8_t)(o[i] >> 8);
565                         ether_addr.addr_bytes[i * 2 + 1] = (uint8_t)(o[i] & 0xff);
566                 }
567         /* unknown format */
568         } else
569                 return NULL;
570
571         return (struct rte_ether_addr *)&ether_addr;
572 }
573
574 int
575 softnic_parse_ipv4_addr(const char *token, struct in_addr *ipv4)
576 {
577         if (strlen(token) >= INET_ADDRSTRLEN)
578                 return -EINVAL;
579
580         if (inet_pton4(token, (unsigned char *)ipv4) != 1)
581                 return -EINVAL;
582
583         return 0;
584 }
585
586 int
587 softnic_parse_ipv6_addr(const char *token, struct in6_addr *ipv6)
588 {
589         if (strlen(token) >= INET6_ADDRSTRLEN)
590                 return -EINVAL;
591
592         if (inet_pton6(token, (unsigned char *)ipv6) != 1)
593                 return -EINVAL;
594
595         return 0;
596 }
597
598 int
599 softnic_parse_mac_addr(const char *token, struct rte_ether_addr *addr)
600 {
601         struct rte_ether_addr *tmp;
602
603         tmp = my_ether_aton(token);
604         if (tmp == NULL)
605                 return -1;
606
607         memcpy(addr, tmp, sizeof(struct rte_ether_addr));
608         return 0;
609 }
610
611 int
612 softnic_parse_cpu_core(const char *entry,
613         struct softnic_cpu_core_params *p)
614 {
615         size_t num_len;
616         char num[8];
617
618         uint32_t s = 0, c = 0, h = 0, val;
619         uint8_t s_parsed = 0, c_parsed = 0, h_parsed = 0;
620         const char *next = skip_white_spaces(entry);
621         char type;
622
623         if (p == NULL)
624                 return -EINVAL;
625
626         /* Expect <CORE> or [sX][cY][h]. At least one parameter is required. */
627         while (*next != '\0') {
628                 /* If everything parsed nothing should left */
629                 if (s_parsed && c_parsed && h_parsed)
630                         return -EINVAL;
631
632                 type = *next;
633                 switch (type) {
634                 case 's':
635                 case 'S':
636                         if (s_parsed || c_parsed || h_parsed)
637                                 return -EINVAL;
638                         s_parsed = 1;
639                         next++;
640                         break;
641                 case 'c':
642                 case 'C':
643                         if (c_parsed || h_parsed)
644                                 return -EINVAL;
645                         c_parsed = 1;
646                         next++;
647                         break;
648                 case 'h':
649                 case 'H':
650                         if (h_parsed)
651                                 return -EINVAL;
652                         h_parsed = 1;
653                         next++;
654                         break;
655                 default:
656                         /* If it start from digit it must be only core id. */
657                         if (!isdigit(*next) || s_parsed || c_parsed || h_parsed)
658                                 return -EINVAL;
659
660                         type = 'C';
661                 }
662
663                 for (num_len = 0; *next != '\0'; next++, num_len++) {
664                         if (num_len == RTE_DIM(num))
665                                 return -EINVAL;
666
667                         if (!isdigit(*next))
668                                 break;
669
670                         num[num_len] = *next;
671                 }
672
673                 if (num_len == 0 && type != 'h' && type != 'H')
674                         return -EINVAL;
675
676                 if (num_len != 0 && (type == 'h' || type == 'H'))
677                         return -EINVAL;
678
679                 num[num_len] = '\0';
680                 val = strtol(num, NULL, 10);
681
682                 h = 0;
683                 switch (type) {
684                 case 's':
685                 case 'S':
686                         s = val;
687                         break;
688                 case 'c':
689                 case 'C':
690                         c = val;
691                         break;
692                 case 'h':
693                 case 'H':
694                         h = 1;
695                         break;
696                 }
697         }
698
699         p->socket_id = s;
700         p->core_id = c;
701         p->thread_id = h;
702         return 0;
703 }