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