1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2010-2014 Intel Corporation
8 #include <netinet/in.h>
9 #include <sys/socket.h>
11 #include <rte_string_fns.h>
13 #include <cmdline_parse.h>
14 #include <cmdline_parse_ipaddr.h>
16 #include "test_cmdline.h"
18 #define IP4(a,b,c,d) {((uint32_t)(((a) & 0xff)) | \
19 (((b) & 0xff) << 8) | \
20 (((c) & 0xff) << 16) | \
24 (((x & 0xFF) << 8) | ((x & 0xFF00) >> 8))
26 /* create IPv6 address, swapping bytes where needed */
28 # define s6_addr16 __u6_addr.__u6_addr16
30 #define IP6(a,b,c,d,e,f,g,h) .ipv6 = \
32 {U16_SWAP(a),U16_SWAP(b),U16_SWAP(c),U16_SWAP(d),\
33 U16_SWAP(e),U16_SWAP(f),U16_SWAP(g),U16_SWAP(h)}}
35 /** these are defined in netinet/in.h but not present in linux headers */
38 #define NIPQUAD_FMT "%u.%u.%u.%u"
39 #define NIPQUAD(addr) \
40 (unsigned)((unsigned char *)&addr)[0], \
41 (unsigned)((unsigned char *)&addr)[1], \
42 (unsigned)((unsigned char *)&addr)[2], \
43 (unsigned)((unsigned char *)&addr)[3]
45 #define NIP6_FMT "%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x"
47 (unsigned)((addr).s6_addr[0]), \
48 (unsigned)((addr).s6_addr[1]), \
49 (unsigned)((addr).s6_addr[2]), \
50 (unsigned)((addr).s6_addr[3]), \
51 (unsigned)((addr).s6_addr[4]), \
52 (unsigned)((addr).s6_addr[5]), \
53 (unsigned)((addr).s6_addr[6]), \
54 (unsigned)((addr).s6_addr[7]), \
55 (unsigned)((addr).s6_addr[8]), \
56 (unsigned)((addr).s6_addr[9]), \
57 (unsigned)((addr).s6_addr[10]), \
58 (unsigned)((addr).s6_addr[11]), \
59 (unsigned)((addr).s6_addr[12]), \
60 (unsigned)((addr).s6_addr[13]), \
61 (unsigned)((addr).s6_addr[14]), \
62 (unsigned)((addr).s6_addr[15])
70 cmdline_ipaddr_t addr;
74 const struct ipaddr_str ipaddr_valid_strs[] = {
75 {"0.0.0.0", {AF_INET, {IP4(0,0,0,0)}, 0},
77 {"0.0.0.0/0", {AF_INET, {IP4(0,0,0,0)}, 0},
78 CMDLINE_IPADDR_V4 | CMDLINE_IPADDR_NETWORK},
79 {"0.0.0.0/24", {AF_INET, {IP4(0,0,0,0)}, 24},
80 CMDLINE_IPADDR_V4 | CMDLINE_IPADDR_NETWORK},
81 {"192.168.1.0/24", {AF_INET, {IP4(192,168,1,0)}, 24},
82 CMDLINE_IPADDR_V4 | CMDLINE_IPADDR_NETWORK},
83 {"34.56.78.90/1", {AF_INET, {IP4(34,56,78,90)}, 1},
84 CMDLINE_IPADDR_V4 | CMDLINE_IPADDR_NETWORK},
85 {"::", {AF_INET6, {IP6(0,0,0,0,0,0,0,0)}, 0},
87 {"::1", {AF_INET6, {IP6(0,0,0,0,0,0,0,1)}, 0},
89 {"::1/32", {AF_INET6, {IP6(0,0,0,0,0,0,0,1)}, 32},
90 CMDLINE_IPADDR_V6 | CMDLINE_IPADDR_NETWORK},
91 {"::/32", {AF_INET6, {IP6(0,0,0,0,0,0,0,0)}, 32},
92 CMDLINE_IPADDR_V6 | CMDLINE_IPADDR_NETWORK},
93 /* RFC5952 requests that only lowercase should be used */
94 {"1234:5678:90ab:cdef:4321:8765:BA09:FEDC", {AF_INET6,
95 {IP6(0x1234,0x5678,0x90AB,0xCDEF,0x4321,0x8765,0xBA09,0xFEDC)},
98 {"1234::1234/64", {AF_INET6,
99 {IP6(0x1234,0,0,0,0,0,0,0x1234)},
101 CMDLINE_IPADDR_V6 | CMDLINE_IPADDR_NETWORK},
102 {"1234::/64", {AF_INET6,
103 {IP6(0x1234,0,0,0,0,0,0,0)},
105 CMDLINE_IPADDR_V6 | CMDLINE_IPADDR_NETWORK},
106 {"1:1::1/32", {AF_INET6,
107 {IP6(1,1,0,0,0,0,0,1)},
109 CMDLINE_IPADDR_V6 | CMDLINE_IPADDR_NETWORK},
110 {"1:2:3:4::/64", {AF_INET6,
111 {IP6(1,2,3,4,0,0,0,0)},
113 CMDLINE_IPADDR_V6 | CMDLINE_IPADDR_NETWORK},
114 {"::ffff:192.168.1.0/64", {AF_INET6,
115 {IP6(0,0,0,0,0,0xFFFF,0xC0A8,0x100)},
117 CMDLINE_IPADDR_V6 | CMDLINE_IPADDR_NETWORK},
118 /* RFC5952 requests not using :: to skip one block of zeros*/
119 {"1::2:3:4:5:6:7", {AF_INET6,
120 {IP6(1,0,2,3,4,5,6,7)},
125 const char * ipaddr_garbage_addr4_strs[] = {
127 "192.168.1.0 garbage",
128 "192.168.1.0\0garbage",
129 "192.168.1.0#garbage",
130 "192.168.1.0\tgarbage",
131 "192.168.1.0\rgarbage",
132 "192.168.1.0\ngarbage",
134 #define IPv4_GARBAGE_ADDR IP4(192,168,1,0)
136 const char * ipaddr_garbage_addr6_strs[] = {
138 "1:2:3:4::8 garbage",
139 "1:2:3:4::8#garbage",
140 "1:2:3:4::8\0garbage",
141 "1:2:3:4::8\rgarbage",
142 "1:2:3:4::8\ngarbage",
143 "1:2:3:4::8\tgarbage",
145 #define IPv6_GARBAGE_ADDR {IP6(1,2,3,4,0,0,0,8)}
147 const char * ipaddr_garbage_network4_strs[] = {
149 "192.168.1.0/24 garbage",
150 "192.168.1.0/24\0garbage",
151 "192.168.1.0/24#garbage",
152 "192.168.1.0/24\tgarbage",
153 "192.168.1.0/24\rgarbage",
154 "192.168.1.0/24\ngarbage",
156 #define IPv4_GARBAGE_PREFIX 24
158 const char * ipaddr_garbage_network6_strs[] = {
160 "1:2:3:4::8/64 garbage",
161 "1:2:3:4::8/64#garbage",
162 "1:2:3:4::8/64\0garbage",
163 "1:2:3:4::8/64\rgarbage",
164 "1:2:3:4::8/64\ngarbage",
165 "1:2:3:4::8/64\tgarbage",
167 #define IPv6_GARBAGE_PREFIX 64
171 const char * ipaddr_invalid_strs[] = {
174 /* invalid numbers */
184 "256.123.123.123/24",
185 "255.256.123.123/24",
186 "255.255.256.123/24",
187 "255.255.255.256/24",
188 /* invalid network mask */
202 "123.123.123.123.123",
207 "123.123.123.123./24",
208 "123.123.123..123/24",
209 "123.123.123.123.123/24",
211 ".123.123.123.123/24",
212 /* invalid characters */
220 "123.123.123.123/4F",
227 "1:2:3:4:5:6:7:192.168.1.1",
228 "1234:192.168.1.1:ffff::",
229 "1:2:3:4:5:6:7:890ab",
230 "1:2:3:4:5:6:7890a:b",
231 "1:2:3:4:5:67890:a:b",
232 "1:2:3:4:56789:0:a:b",
233 "1:2:3:45678:9:0:a:b",
234 "1:2:34567:8:9:0:a:b",
235 "1:23456:7:8:9:0:a:b",
236 "12345:6:7:8:9:0:a:b",
246 "1::2:3:4:5:6:7:8/64",
248 /* invalid network mask */
249 "1:2:3:4:5:6:7:8/129",
250 "1:2:3:4:5:6:7:8/-1",
252 /* invalid characters */
258 "1234:1234:1234:1234:1234:1234:1234:1234:1234:1234:1234"
259 "random invalid text",
265 #define IPADDR_VALID_STRS_SIZE \
266 (sizeof(ipaddr_valid_strs) / sizeof(ipaddr_valid_strs[0]))
267 #define IPADDR_GARBAGE_ADDR4_STRS_SIZE \
268 (sizeof(ipaddr_garbage_addr4_strs) / sizeof(ipaddr_garbage_addr4_strs[0]))
269 #define IPADDR_GARBAGE_ADDR6_STRS_SIZE \
270 (sizeof(ipaddr_garbage_addr6_strs) / sizeof(ipaddr_garbage_addr6_strs[0]))
271 #define IPADDR_GARBAGE_NETWORK4_STRS_SIZE \
272 (sizeof(ipaddr_garbage_network4_strs) / sizeof(ipaddr_garbage_network4_strs[0]))
273 #define IPADDR_GARBAGE_NETWORK6_STRS_SIZE \
274 (sizeof(ipaddr_garbage_network6_strs) / sizeof(ipaddr_garbage_network6_strs[0]))
275 #define IPADDR_INVALID_STRS_SIZE \
276 (sizeof(ipaddr_invalid_strs) / sizeof(ipaddr_invalid_strs[0]))
279 dump_addr(cmdline_ipaddr_t addr)
281 switch (addr.family) {
284 printf(NIPQUAD_FMT " prefixlen=%u\n",
285 NIPQUAD(addr.addr.ipv4.s_addr), addr.prefixlen);
290 printf(NIP6_FMT " prefixlen=%u\n",
291 NIP6(addr.addr.ipv6), addr.prefixlen);
295 printf("Can't dump: unknown address family.\n");
302 is_addr_different(cmdline_ipaddr_t addr1, cmdline_ipaddr_t addr2)
304 if (addr1.family != addr2.family)
307 if (addr1.prefixlen != addr2.prefixlen)
310 switch (addr1.family) {
313 if (memcmp(&addr1.addr.ipv4, &addr2.addr.ipv4,
314 sizeof(struct in_addr)) != 0)
320 if (memcmp(&addr1.addr.ipv6, &addr2.addr.ipv6,
321 sizeof(struct in6_addr)) != 0)
325 /* thing that should not be */
333 can_parse_addr(unsigned addr_flags, unsigned test_flags)
335 if ((test_flags & addr_flags) == addr_flags) {
336 /* if we are not trying to parse network addresses */
337 if (test_flags < CMDLINE_IPADDR_NETWORK)
339 /* if this is a network address */
340 else if (addr_flags & CMDLINE_IPADDR_NETWORK)
347 test_parse_ipaddr_valid(void)
349 cmdline_parse_token_ipaddr_t token;
350 char buf[CMDLINE_TEST_BUFSIZE];
351 cmdline_ipaddr_t result;
356 /* cover all cases in help */
357 for (flags = 0x1; flags < 0x8; flags++) {
358 token.ipaddr_data.flags = flags;
360 memset(buf, 0, sizeof(buf));
362 if (cmdline_get_help_ipaddr((cmdline_parse_token_hdr_t*)&token,
363 buf, sizeof(buf)) == -1) {
364 printf("Error: help rejected valid parameters!\n");
369 /* test valid strings */
370 for (i = 0; i < IPADDR_VALID_STRS_SIZE; i++) {
372 /* test each valid string against different flags */
373 for (flags = 1; flags < 0x8; flags++) {
376 if (flags == CMDLINE_IPADDR_NETWORK)
379 /* clear out everything */
380 memset(buf, 0, sizeof(buf));
381 memset(&result, 0, sizeof(result));
382 memset(&token, 0, sizeof(token));
384 token.ipaddr_data.flags = flags;
386 cmdline_get_help_ipaddr((cmdline_parse_token_hdr_t*)&token,
389 ret = cmdline_parse_ipaddr((cmdline_parse_token_hdr_t*)&token,
390 ipaddr_valid_strs[i].str, (void*)&result,
393 /* if should have passed, or should have failed */
395 (can_parse_addr(ipaddr_valid_strs[i].flags, flags))) {
396 printf("Error: unexpected behavior when parsing %s as %s!\n",
397 ipaddr_valid_strs[i].str, buf);
398 printf("Parsed result: ");
400 printf("Expected result: ");
401 dump_addr(ipaddr_valid_strs[i].addr);
405 is_addr_different(result, ipaddr_valid_strs[i].addr)) {
406 printf("Error: result mismatch when parsing %s as %s!\n",
407 ipaddr_valid_strs[i].str, buf);
408 printf("Parsed result: ");
410 printf("Expected result: ");
411 dump_addr(ipaddr_valid_strs[i].addr);
417 /* test garbage ipv4 address strings */
418 for (i = 0; i < IPADDR_GARBAGE_ADDR4_STRS_SIZE; i++) {
420 struct in_addr tmp = IPv4_GARBAGE_ADDR;
422 /* test each valid string against different flags */
423 for (flags = 1; flags < 0x8; flags++) {
426 if (flags == CMDLINE_IPADDR_NETWORK)
429 /* clear out everything */
430 memset(buf, 0, sizeof(buf));
431 memset(&result, 0, sizeof(result));
432 memset(&token, 0, sizeof(token));
434 token.ipaddr_data.flags = flags;
436 cmdline_get_help_ipaddr((cmdline_parse_token_hdr_t*)&token,
439 ret = cmdline_parse_ipaddr((cmdline_parse_token_hdr_t*)&token,
440 ipaddr_garbage_addr4_strs[i], (void*)&result,
443 /* if should have passed, or should have failed */
445 (can_parse_addr(CMDLINE_IPADDR_V4, flags))) {
446 printf("Error: unexpected behavior when parsing %s as %s!\n",
447 ipaddr_garbage_addr4_strs[i], buf);
451 memcmp(&result.addr.ipv4, &tmp, sizeof(tmp))) {
452 printf("Error: result mismatch when parsing %s as %s!\n",
453 ipaddr_garbage_addr4_strs[i], buf);
459 /* test garbage ipv6 address strings */
460 for (i = 0; i < IPADDR_GARBAGE_ADDR6_STRS_SIZE; i++) {
462 cmdline_ipaddr_t tmp = {.addr = IPv6_GARBAGE_ADDR};
464 /* test each valid string against different flags */
465 for (flags = 1; flags < 0x8; flags++) {
468 if (flags == CMDLINE_IPADDR_NETWORK)
471 /* clear out everything */
472 memset(buf, 0, sizeof(buf));
473 memset(&result, 0, sizeof(result));
474 memset(&token, 0, sizeof(token));
476 token.ipaddr_data.flags = flags;
478 cmdline_get_help_ipaddr((cmdline_parse_token_hdr_t*)&token,
481 ret = cmdline_parse_ipaddr((cmdline_parse_token_hdr_t*)&token,
482 ipaddr_garbage_addr6_strs[i], (void*)&result,
485 /* if should have passed, or should have failed */
487 (can_parse_addr(CMDLINE_IPADDR_V6, flags))) {
488 printf("Error: unexpected behavior when parsing %s as %s!\n",
489 ipaddr_garbage_addr6_strs[i], buf);
493 memcmp(&result.addr.ipv6, &tmp.addr.ipv6, sizeof(struct in6_addr))) {
494 printf("Error: result mismatch when parsing %s as %s!\n",
495 ipaddr_garbage_addr6_strs[i], buf);
502 /* test garbage ipv4 network strings */
503 for (i = 0; i < IPADDR_GARBAGE_NETWORK4_STRS_SIZE; i++) {
505 struct in_addr tmp = IPv4_GARBAGE_ADDR;
507 /* test each valid string against different flags */
508 for (flags = 1; flags < 0x8; flags++) {
511 if (flags == CMDLINE_IPADDR_NETWORK)
514 /* clear out everything */
515 memset(buf, 0, sizeof(buf));
516 memset(&result, 0, sizeof(result));
517 memset(&token, 0, sizeof(token));
519 token.ipaddr_data.flags = flags;
521 cmdline_get_help_ipaddr((cmdline_parse_token_hdr_t*)&token,
524 ret = cmdline_parse_ipaddr((cmdline_parse_token_hdr_t*)&token,
525 ipaddr_garbage_network4_strs[i], (void*)&result,
528 /* if should have passed, or should have failed */
530 (can_parse_addr(CMDLINE_IPADDR_V4 | CMDLINE_IPADDR_NETWORK, flags))) {
531 printf("Error: unexpected behavior when parsing %s as %s!\n",
532 ipaddr_garbage_network4_strs[i], buf);
536 memcmp(&result.addr.ipv4, &tmp, sizeof(tmp))) {
537 printf("Error: result mismatch when parsing %s as %s!\n",
538 ipaddr_garbage_network4_strs[i], buf);
544 /* test garbage ipv6 address strings */
545 for (i = 0; i < IPADDR_GARBAGE_NETWORK6_STRS_SIZE; i++) {
547 cmdline_ipaddr_t tmp = {.addr = IPv6_GARBAGE_ADDR};
549 /* test each valid string against different flags */
550 for (flags = 1; flags < 0x8; flags++) {
553 if (flags == CMDLINE_IPADDR_NETWORK)
556 /* clear out everything */
557 memset(buf, 0, sizeof(buf));
558 memset(&result, 0, sizeof(result));
559 memset(&token, 0, sizeof(token));
561 token.ipaddr_data.flags = flags;
563 cmdline_get_help_ipaddr((cmdline_parse_token_hdr_t*)&token,
566 ret = cmdline_parse_ipaddr((cmdline_parse_token_hdr_t*)&token,
567 ipaddr_garbage_network6_strs[i], (void*)&result,
570 /* if should have passed, or should have failed */
572 (can_parse_addr(CMDLINE_IPADDR_V6 | CMDLINE_IPADDR_NETWORK, flags))) {
573 printf("Error: unexpected behavior when parsing %s as %s!\n",
574 ipaddr_garbage_network6_strs[i], buf);
578 memcmp(&result.addr.ipv6, &tmp.addr.ipv6, sizeof(struct in6_addr))) {
579 printf("Error: result mismatch when parsing %s as %s!\n",
580 ipaddr_garbage_network6_strs[i], buf);
590 test_parse_ipaddr_invalid_data(void)
592 cmdline_parse_token_ipaddr_t token;
593 char buf[CMDLINE_TEST_BUFSIZE];
594 cmdline_ipaddr_t result;
599 memset(&result, 0, sizeof(result));
601 /* test invalid strings */
602 for (i = 0; i < IPADDR_INVALID_STRS_SIZE; i++) {
604 /* test each valid string against different flags */
605 for (flags = 1; flags < 0x8; flags++) {
608 if (flags == CMDLINE_IPADDR_NETWORK)
611 /* clear out everything */
612 memset(buf, 0, sizeof(buf));
613 memset(&token, 0, sizeof(token));
615 token.ipaddr_data.flags = flags;
617 cmdline_get_help_ipaddr((cmdline_parse_token_hdr_t*)&token,
620 ret = cmdline_parse_ipaddr((cmdline_parse_token_hdr_t*)&token,
621 ipaddr_invalid_strs[i], (void*)&result,
625 printf("Error: parsing %s as %s succeeded!\n",
626 ipaddr_invalid_strs[i], buf);
627 printf("Parsed result: ");
638 test_parse_ipaddr_invalid_param(void)
640 cmdline_parse_token_ipaddr_t token;
641 char buf[CMDLINE_TEST_BUFSIZE];
642 cmdline_ipaddr_t result;
644 snprintf(buf, sizeof(buf), "1.2.3.4");
645 token.ipaddr_data.flags = CMDLINE_IPADDR_V4;
648 if (cmdline_parse_ipaddr(NULL, buf, (void*)&result,
649 sizeof(result)) != -1) {
650 printf("Error: parser accepted invalid parameters!\n");
654 if (cmdline_parse_ipaddr((cmdline_parse_token_hdr_t*)&token,
655 NULL, (void*)&result, sizeof(result)) != -1) {
656 printf("Error: parser accepted invalid parameters!\n");
660 if (cmdline_parse_ipaddr((cmdline_parse_token_hdr_t*)&token,
661 "", (void*)&result, sizeof(result)) != -1) {
662 printf("Error: parser accepted invalid parameters!\n");
666 if (cmdline_parse_ipaddr((cmdline_parse_token_hdr_t*)&token,
667 buf, NULL, 0) == -1) {
668 printf("Error: parser rejected null result!\n");
673 if (cmdline_get_help_ipaddr(NULL, buf, 0) != -1) {
674 printf("Error: help accepted invalid parameters!\n");
678 if (cmdline_get_help_ipaddr((cmdline_parse_token_hdr_t*)&token,
680 printf("Error: help accepted invalid parameters!\n");