1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2016 Intel Corporation
4 #include <rte_common.h>
5 #include <rte_crypto.h>
6 #include <rte_string_fns.h>
8 #include <cmdline_parse_string.h>
9 #include <cmdline_parse_num.h>
10 #include <cmdline_parse_ipaddr.h>
11 #include <cmdline_socket.h>
17 #define PARSE_DELIMITER " \f\n\r\t\v"
19 parse_tokenize_string(char *string, char *tokens[], uint32_t *n_tokens)
23 if ((string == NULL) ||
28 for (i = 0; i < *n_tokens; i++) {
29 tokens[i] = strtok_r(string, PARSE_DELIMITER, &string);
30 if (tokens[i] == NULL)
34 if ((i == *n_tokens) &&
35 (NULL != strtok_r(string, PARSE_DELIMITER, &string)))
46 * inet_pton4(src, dst)
47 * like inet_aton() but without all the hexadecimal and shorthand.
49 * 1 if `src' is a valid dotted quad, else 0.
51 * does not touch `dst' unless it's returning 1.
56 inet_pton4(const char *src, unsigned char *dst)
58 static const char digits[] = "0123456789";
59 int saw_digit, octets, ch;
60 unsigned char tmp[INADDRSZ], *tp;
65 while ((ch = *src++) != '\0') {
68 pch = strchr(digits, ch);
70 unsigned int new = *tp * 10 + (pch - digits);
79 *tp = (unsigned char)new;
80 } else if (ch == '.' && saw_digit) {
91 memcpy(dst, tmp, INADDRSZ);
96 * inet_pton6(src, dst)
97 * convert presentation level address to network order binary form.
99 * 1 if `src' is a valid [RFC1884 2.2] address, else 0.
101 * (1) does not touch `dst' unless it's returning 1.
102 * (2) :: in a full address is silently ignored.
104 * inspired by Mark Andrews.
109 inet_pton6(const char *src, unsigned char *dst)
111 static const char xdigits_l[] = "0123456789abcdef",
112 xdigits_u[] = "0123456789ABCDEF";
113 unsigned char tmp[IN6ADDRSZ], *tp = 0, *endp = 0, *colonp = 0;
114 const char *xdigits = 0, *curtok = 0;
115 int ch = 0, saw_xdigit = 0, count_xdigit = 0;
116 unsigned int val = 0;
117 unsigned dbloct_count = 0;
119 memset((tp = tmp), '\0', IN6ADDRSZ);
120 endp = tp + IN6ADDRSZ;
122 /* Leading :: requires some special handling. */
127 saw_xdigit = count_xdigit = 0;
130 while ((ch = *src++) != '\0') {
133 pch = strchr((xdigits = xdigits_l), ch);
135 pch = strchr((xdigits = xdigits_u), ch);
137 if (count_xdigit >= 4)
140 val |= (pch - xdigits);
154 } else if (*src == '\0') {
157 if (tp + sizeof(int16_t) > endp)
159 *tp++ = (unsigned char) ((val >> 8) & 0xff);
160 *tp++ = (unsigned char) (val & 0xff);
167 if (ch == '.' && ((tp + INADDRSZ) <= endp) &&
168 inet_pton4(curtok, tp) > 0) {
172 break; /* '\0' was seen by inet_pton4(). */
177 if (tp + sizeof(int16_t) > endp)
179 *tp++ = (unsigned char) ((val >> 8) & 0xff);
180 *tp++ = (unsigned char) (val & 0xff);
183 if (colonp != NULL) {
184 /* if we already have 8 double octets, having a colon
186 if (dbloct_count == 8)
190 * Since some memmove()'s erroneously fail to handle
191 * overlapping regions, we'll do the shift by hand.
193 const int n = tp - colonp;
196 for (i = 1; i <= n; i++) {
197 endp[-i] = colonp[n - i];
204 memcpy(dst, tmp, IN6ADDRSZ);
209 parse_ipv4_addr(const char *token, struct in_addr *ipv4, uint32_t *mask)
211 char ip_str[INET_ADDRSTRLEN] = {0};
214 pch = strchr(token, '/');
216 strlcpy(ip_str, token, RTE_MIN((unsigned int long)(pch - token),
219 if (is_str_num(pch) != 0)
224 strlcpy(ip_str, token, sizeof(ip_str));
229 if (strlen(ip_str) >= INET_ADDRSTRLEN)
232 if (inet_pton4(ip_str, (unsigned char *)ipv4) != 1)
239 parse_ipv6_addr(const char *token, struct in6_addr *ipv6, uint32_t *mask)
241 char ip_str[256] = {0};
244 pch = strchr(token, '/');
246 strlcpy(ip_str, token, RTE_MIN((unsigned int long)(pch - token),
249 if (is_str_num(pch) != 0)
254 strlcpy(ip_str, token, sizeof(ip_str));
259 if (strlen(ip_str) >= INET6_ADDRSTRLEN)
262 if (inet_pton6(ip_str, (unsigned char *)ipv6) != 1)
269 parse_range(const char *token, uint16_t *low, uint16_t *high)
280 memset(num_str, 0, 20);
283 while ((ch = *token++) != '\0') {
288 } else if (ch == ':') {
291 range_low = atoi(num_str);
292 memset(num_str, 0, 20);
297 if (strlen(num_str) == 0)
300 range_high = atoi(num_str);
302 *low = (uint16_t)range_low;
303 *high = (uint16_t)range_high;
309 struct cfg_sp_add_cfg_item {
310 cmdline_fixed_string_t sp_keyword;
311 cmdline_multi_string_t multi_string;
315 cfg_sp_add_cfg_item_parsed(void *parsed_result,
316 __rte_unused struct cmdline *cl, void *data)
318 struct cfg_sp_add_cfg_item *params = parsed_result;
320 uint32_t n_tokens = RTE_DIM(tokens);
321 struct parse_status *status = (struct parse_status *)data;
323 APP_CHECK((parse_tokenize_string(params->multi_string, tokens,
324 &n_tokens) == 0), status, "too many arguments");
326 if (status->status < 0)
329 if (strcmp(tokens[0], "ipv4") == 0) {
330 parse_sp4_tokens(tokens, n_tokens, status);
331 if (status->status < 0)
333 } else if (strcmp(tokens[0], "ipv6") == 0) {
334 parse_sp6_tokens(tokens, n_tokens, status);
335 if (status->status < 0)
338 APP_CHECK(0, status, "unrecognizable input %s\n",
344 static cmdline_parse_token_string_t cfg_sp_add_sp_str =
345 TOKEN_STRING_INITIALIZER(struct cfg_sp_add_cfg_item,
348 static cmdline_parse_token_string_t cfg_sp_add_multi_str =
349 TOKEN_STRING_INITIALIZER(struct cfg_sp_add_cfg_item, multi_string,
352 cmdline_parse_inst_t cfg_sp_add_rule = {
353 .f = cfg_sp_add_cfg_item_parsed,
357 (void *) &cfg_sp_add_sp_str,
358 (void *) &cfg_sp_add_multi_str,
364 struct cfg_sa_add_cfg_item {
365 cmdline_fixed_string_t sa_keyword;
366 cmdline_multi_string_t multi_string;
370 cfg_sa_add_cfg_item_parsed(void *parsed_result,
371 __rte_unused struct cmdline *cl, void *data)
373 struct cfg_sa_add_cfg_item *params = parsed_result;
375 uint32_t n_tokens = RTE_DIM(tokens);
376 struct parse_status *status = (struct parse_status *)data;
378 APP_CHECK(parse_tokenize_string(params->multi_string, tokens,
379 &n_tokens) == 0, status, "too many arguments\n");
381 parse_sa_tokens(tokens, n_tokens, status);
384 static cmdline_parse_token_string_t cfg_sa_add_sa_str =
385 TOKEN_STRING_INITIALIZER(struct cfg_sa_add_cfg_item,
388 static cmdline_parse_token_string_t cfg_sa_add_multi_str =
389 TOKEN_STRING_INITIALIZER(struct cfg_sa_add_cfg_item, multi_string,
392 cmdline_parse_inst_t cfg_sa_add_rule = {
393 .f = cfg_sa_add_cfg_item_parsed,
397 (void *) &cfg_sa_add_sa_str,
398 (void *) &cfg_sa_add_multi_str,
404 struct cfg_rt_add_cfg_item {
405 cmdline_fixed_string_t rt_keyword;
406 cmdline_multi_string_t multi_string;
410 cfg_rt_add_cfg_item_parsed(void *parsed_result,
411 __rte_unused struct cmdline *cl, void *data)
413 struct cfg_rt_add_cfg_item *params = parsed_result;
415 uint32_t n_tokens = RTE_DIM(tokens);
416 struct parse_status *status = (struct parse_status *)data;
418 APP_CHECK(parse_tokenize_string(
419 params->multi_string, tokens, &n_tokens) == 0,
420 status, "too many arguments\n");
421 if (status->status < 0)
424 parse_rt_tokens(tokens, n_tokens, status);
427 static cmdline_parse_token_string_t cfg_rt_add_rt_str =
428 TOKEN_STRING_INITIALIZER(struct cfg_rt_add_cfg_item,
431 static cmdline_parse_token_string_t cfg_rt_add_multi_str =
432 TOKEN_STRING_INITIALIZER(struct cfg_rt_add_cfg_item, multi_string,
435 cmdline_parse_inst_t cfg_rt_add_rule = {
436 .f = cfg_rt_add_cfg_item_parsed,
440 (void *) &cfg_rt_add_rt_str,
441 (void *) &cfg_rt_add_multi_str,
446 /** set of cfg items */
447 cmdline_parse_ctx_t ipsec_ctx[] = {
448 (cmdline_parse_inst_t *)&cfg_sp_add_rule,
449 (cmdline_parse_inst_t *)&cfg_sa_add_rule,
450 (cmdline_parse_inst_t *)&cfg_rt_add_rule,
455 parse_cfg_file(const char *cfg_filename)
457 struct cmdline *cl = cmdline_stdin_new(ipsec_ctx, "");
458 FILE *f = fopen(cfg_filename, "r");
459 char str[1024] = {0}, *get_s = NULL;
460 uint32_t line_num = 0;
461 struct parse_status status = {0};
464 rte_panic("Error: invalid file descriptor %s\n", cfg_filename);
469 rte_panic("Error: cannot create cmdline instance\n");
473 cfg_sp_add_rule.data = &status;
474 cfg_sa_add_rule.data = &status;
475 cfg_rt_add_rule.data = &status;
480 get_s = fgets(oneline, 1024, f);
487 if (strlen(oneline) > 1022) {
488 rte_panic("%s:%u: error: "
489 "the line contains more characters the parser can handle\n",
490 cfg_filename, line_num);
494 /* process comment char '#' */
495 if (oneline[0] == '#')
498 pos = strchr(oneline, '#');
502 /* process line concatenator '\' */
503 pos = strchr(oneline, 92);
505 if (pos != oneline+strlen(oneline) - 2) {
506 rte_panic("%s:%u: error: "
507 "no character should exist after '\\'\n",
508 cfg_filename, line_num);
514 if (strlen(oneline) + strlen(str) > 1022) {
515 rte_panic("%s:%u: error: "
516 "the concatenated line contains more characters the parser can handle\n",
517 cfg_filename, line_num);
521 strcpy(str + strlen(str), oneline);
525 /* copy the line to str and process */
526 if (strlen(oneline) + strlen(str) > 1022) {
527 rte_panic("%s:%u: error: "
528 "the line contains more characters the parser can handle\n",
529 cfg_filename, line_num);
532 strcpy(str + strlen(str), oneline);
534 str[strlen(str)] = '\n';
535 if (cmdline_parse(cl, str) < 0) {
536 rte_panic("%s:%u: error: parsing \"%s\" failed\n",
537 cfg_filename, line_num, str);
541 if (status.status < 0) {
542 rte_panic("%s:%u: error: %s", cfg_filename,
543 line_num, status.parse_msg);
547 memset(str, 0, 1024);
550 cmdline_stdin_exit(cl);
557 cmdline_stdin_exit(cl);