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
,
217 RTE_MIN((unsigned int long)(pch
- token
+ 1),
220 if (is_str_num(pch
) != 0)
225 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
,
247 RTE_MIN((unsigned int long)(pch
- token
+ 1),
250 if (is_str_num(pch
) != 0)
255 strlcpy(ip_str
, token
, sizeof(ip_str
));
260 if (strlen(ip_str
) >= INET6_ADDRSTRLEN
)
263 if (inet_pton6(ip_str
, (unsigned char *)ipv6
) != 1)
270 parse_range(const char *token
, uint16_t *low
, uint16_t *high
)
281 memset(num_str
, 0, 20);
284 while ((ch
= *token
++) != '\0') {
289 } else if (ch
== ':') {
292 range_low
= atoi(num_str
);
293 memset(num_str
, 0, 20);
298 if (strlen(num_str
) == 0)
301 range_high
= atoi(num_str
);
303 *low
= (uint16_t)range_low
;
304 *high
= (uint16_t)range_high
;
310 * helper function for parse_mac, parse one section of the ether addr.
313 parse_uint8x16(const char *s
, uint8_t *v
, uint8_t ls
)
319 t
= strtoul(s
, &end
, 16);
320 if (errno
!= 0 || end
[0] != ls
|| t
> UINT8_MAX
)
327 parse_mac(const char *str
, struct rte_ether_addr
*addr
)
331 static const uint8_t stop_sym
[RTE_DIM(addr
->addr_bytes
)] = {
340 for (i
= 0; i
!= RTE_DIM(addr
->addr_bytes
); i
++) {
341 str
= parse_uint8x16(str
, addr
->addr_bytes
+ i
, stop_sym
[i
]);
350 struct cfg_sp_add_cfg_item
{
351 cmdline_fixed_string_t sp_keyword
;
352 cmdline_multi_string_t multi_string
;
356 cfg_sp_add_cfg_item_parsed(void *parsed_result
,
357 __rte_unused
struct cmdline
*cl
, void *data
)
359 struct cfg_sp_add_cfg_item
*params
= parsed_result
;
361 uint32_t n_tokens
= RTE_DIM(tokens
);
362 struct parse_status
*status
= (struct parse_status
*)data
;
364 APP_CHECK((parse_tokenize_string(params
->multi_string
, tokens
,
365 &n_tokens
) == 0), status
, "too many arguments");
367 if (status
->status
< 0)
370 if (strcmp(tokens
[0], "ipv4") == 0) {
371 parse_sp4_tokens(tokens
, n_tokens
, status
);
372 if (status
->status
< 0)
374 } else if (strcmp(tokens
[0], "ipv6") == 0) {
375 parse_sp6_tokens(tokens
, n_tokens
, status
);
376 if (status
->status
< 0)
379 APP_CHECK(0, status
, "unrecognizable input %s\n",
385 static cmdline_parse_token_string_t cfg_sp_add_sp_str
=
386 TOKEN_STRING_INITIALIZER(struct cfg_sp_add_cfg_item
,
389 static cmdline_parse_token_string_t cfg_sp_add_multi_str
=
390 TOKEN_STRING_INITIALIZER(struct cfg_sp_add_cfg_item
, multi_string
,
393 cmdline_parse_inst_t cfg_sp_add_rule
= {
394 .f
= cfg_sp_add_cfg_item_parsed
,
398 (void *) &cfg_sp_add_sp_str
,
399 (void *) &cfg_sp_add_multi_str
,
405 struct cfg_sa_add_cfg_item
{
406 cmdline_fixed_string_t sa_keyword
;
407 cmdline_multi_string_t multi_string
;
411 cfg_sa_add_cfg_item_parsed(void *parsed_result
,
412 __rte_unused
struct cmdline
*cl
, void *data
)
414 struct cfg_sa_add_cfg_item
*params
= parsed_result
;
416 uint32_t n_tokens
= RTE_DIM(tokens
);
417 struct parse_status
*status
= (struct parse_status
*)data
;
419 APP_CHECK(parse_tokenize_string(params
->multi_string
, tokens
,
420 &n_tokens
) == 0, status
, "too many arguments\n");
422 parse_sa_tokens(tokens
, n_tokens
, status
);
425 static cmdline_parse_token_string_t cfg_sa_add_sa_str
=
426 TOKEN_STRING_INITIALIZER(struct cfg_sa_add_cfg_item
,
429 static cmdline_parse_token_string_t cfg_sa_add_multi_str
=
430 TOKEN_STRING_INITIALIZER(struct cfg_sa_add_cfg_item
, multi_string
,
433 cmdline_parse_inst_t cfg_sa_add_rule
= {
434 .f
= cfg_sa_add_cfg_item_parsed
,
438 (void *) &cfg_sa_add_sa_str
,
439 (void *) &cfg_sa_add_multi_str
,
445 struct cfg_rt_add_cfg_item
{
446 cmdline_fixed_string_t rt_keyword
;
447 cmdline_multi_string_t multi_string
;
451 cfg_rt_add_cfg_item_parsed(void *parsed_result
,
452 __rte_unused
struct cmdline
*cl
, void *data
)
454 struct cfg_rt_add_cfg_item
*params
= parsed_result
;
456 uint32_t n_tokens
= RTE_DIM(tokens
);
457 struct parse_status
*status
= (struct parse_status
*)data
;
459 APP_CHECK(parse_tokenize_string(
460 params
->multi_string
, tokens
, &n_tokens
) == 0,
461 status
, "too many arguments\n");
462 if (status
->status
< 0)
465 parse_rt_tokens(tokens
, n_tokens
, status
);
468 static cmdline_parse_token_string_t cfg_rt_add_rt_str
=
469 TOKEN_STRING_INITIALIZER(struct cfg_rt_add_cfg_item
,
472 static cmdline_parse_token_string_t cfg_rt_add_multi_str
=
473 TOKEN_STRING_INITIALIZER(struct cfg_rt_add_cfg_item
, multi_string
,
476 cmdline_parse_inst_t cfg_rt_add_rule
= {
477 .f
= cfg_rt_add_cfg_item_parsed
,
481 (void *) &cfg_rt_add_rt_str
,
482 (void *) &cfg_rt_add_multi_str
,
487 /* neigh add parse */
488 struct cfg_neigh_add_item
{
489 cmdline_fixed_string_t neigh
;
490 cmdline_fixed_string_t pstr
;
492 cmdline_fixed_string_t mac
;
496 cfg_parse_neigh(void *parsed_result
, __rte_unused
struct cmdline
*cl
,
500 struct cfg_neigh_add_item
*res
;
501 struct parse_status
*st
;
502 struct rte_ether_addr mac
;
506 rc
= parse_mac(res
->mac
, &mac
);
507 APP_CHECK(rc
== 0, st
, "invalid ether addr:%s", res
->mac
);
508 rc
= add_dst_ethaddr(res
->port
, &mac
);
509 APP_CHECK(rc
== 0, st
, "invalid port numer:%hu", res
->port
);
514 cmdline_parse_token_string_t cfg_add_neigh_start
=
515 TOKEN_STRING_INITIALIZER(struct cfg_neigh_add_item
, neigh
, "neigh");
516 cmdline_parse_token_string_t cfg_add_neigh_pstr
=
517 TOKEN_STRING_INITIALIZER(struct cfg_neigh_add_item
, pstr
, "port");
518 cmdline_parse_token_num_t cfg_add_neigh_port
=
519 TOKEN_NUM_INITIALIZER(struct cfg_neigh_add_item
, port
, UINT16
);
520 cmdline_parse_token_string_t cfg_add_neigh_mac
=
521 TOKEN_STRING_INITIALIZER(struct cfg_neigh_add_item
, mac
, NULL
);
523 cmdline_parse_inst_t cfg_neigh_add_rule
= {
524 .f
= cfg_parse_neigh
,
528 (void *)&cfg_add_neigh_start
,
529 (void *)&cfg_add_neigh_pstr
,
530 (void *)&cfg_add_neigh_port
,
531 (void *)&cfg_add_neigh_mac
,
536 /** set of cfg items */
537 cmdline_parse_ctx_t ipsec_ctx
[] = {
538 (cmdline_parse_inst_t
*)&cfg_sp_add_rule
,
539 (cmdline_parse_inst_t
*)&cfg_sa_add_rule
,
540 (cmdline_parse_inst_t
*)&cfg_rt_add_rule
,
541 (cmdline_parse_inst_t
*)&cfg_neigh_add_rule
,
546 parse_cfg_file(const char *cfg_filename
)
548 struct cmdline
*cl
= cmdline_stdin_new(ipsec_ctx
, "");
549 FILE *f
= fopen(cfg_filename
, "r");
550 char str
[1024] = {0}, *get_s
= NULL
;
551 uint32_t line_num
= 0;
552 struct parse_status status
= {0};
555 rte_panic("Error: invalid file descriptor %s\n", cfg_filename
);
560 rte_panic("Error: cannot create cmdline instance\n");
564 cfg_sp_add_rule
.data
= &status
;
565 cfg_sa_add_rule
.data
= &status
;
566 cfg_rt_add_rule
.data
= &status
;
567 cfg_neigh_add_rule
.data
= &status
;
572 get_s
= fgets(oneline
, 1024, f
);
579 if (strlen(oneline
) > 1022) {
580 rte_panic("%s:%u: error: "
581 "the line contains more characters the parser can handle\n",
582 cfg_filename
, line_num
);
586 /* process comment char '#' */
587 if (oneline
[0] == '#')
590 pos
= strchr(oneline
, '#');
594 /* process line concatenator '\' */
595 pos
= strchr(oneline
, 92);
597 if (pos
!= oneline
+strlen(oneline
) - 2) {
598 rte_panic("%s:%u: error: "
599 "no character should exist after '\\'\n",
600 cfg_filename
, line_num
);
606 if (strlen(oneline
) + strlen(str
) > 1022) {
607 rte_panic("%s:%u: error: "
608 "the concatenated line contains more characters the parser can handle\n",
609 cfg_filename
, line_num
);
613 strcpy(str
+ strlen(str
), oneline
);
617 /* copy the line to str and process */
618 if (strlen(oneline
) + strlen(str
) > 1022) {
619 rte_panic("%s:%u: error: "
620 "the line contains more characters the parser can handle\n",
621 cfg_filename
, line_num
);
624 strcpy(str
+ strlen(str
), oneline
);
626 str
[strlen(str
)] = '\n';
627 if (cmdline_parse(cl
, str
) < 0) {
628 rte_panic("%s:%u: error: parsing \"%s\" failed\n",
629 cfg_filename
, line_num
, str
);
633 if (status
.status
< 0) {
634 rte_panic("%s:%u: error: %s", cfg_filename
,
635 line_num
, status
.parse_msg
);
639 memset(str
, 0, 1024);
642 cmdline_stdin_exit(cl
);
653 cmdline_stdin_exit(cl
);