4 * Copyright(c) 2010-2013 Intel Corporation. All rights reserved.
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
11 * * Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
17 * * Neither the name of Intel Corporation nor the names of its
18 * contributors may be used to endorse or promote products derived
19 * from this software without specific prior written permission.
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
27 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
38 #include <netinet/in.h>
41 #include <net/socket.h>
44 #include <rte_string_fns.h>
46 #include <cmdline_parse.h>
47 #include <cmdline_parse_ipaddr.h>
49 #include "test_cmdline.h"
51 #define IP4(a,b,c,d) {((uint32_t)(((a) & 0xff)) | \
52 (((b) & 0xff) << 8) | \
53 (((c) & 0xff) << 16) | \
57 (((x & 0xFF) << 8) | ((x & 0xFF00) >> 8))
59 /* create IPv6 address, swapping bytes where needed */
60 #define IP6(a,b,c,d,e,f,g,h) .ipv6 = \
62 {U16_SWAP(a),U16_SWAP(b),U16_SWAP(c),U16_SWAP(d),\
63 U16_SWAP(e),U16_SWAP(f),U16_SWAP(g),U16_SWAP(h)}}
65 /** these are defined in netinet/in.h but not present in linux headers */
67 #define NIPQUAD_FMT "%u.%u.%u.%u"
68 #define NIPQUAD(addr) \
69 (unsigned)((unsigned char *)&addr)[0], \
70 (unsigned)((unsigned char *)&addr)[1], \
71 (unsigned)((unsigned char *)&addr)[2], \
72 (unsigned)((unsigned char *)&addr)[3]
74 #define NIP6_FMT "%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x"
76 (unsigned)((addr).s6_addr[0]), \
77 (unsigned)((addr).s6_addr[1]), \
78 (unsigned)((addr).s6_addr[2]), \
79 (unsigned)((addr).s6_addr[3]), \
80 (unsigned)((addr).s6_addr[4]), \
81 (unsigned)((addr).s6_addr[5]), \
82 (unsigned)((addr).s6_addr[6]), \
83 (unsigned)((addr).s6_addr[7]), \
84 (unsigned)((addr).s6_addr[8]), \
85 (unsigned)((addr).s6_addr[9]), \
86 (unsigned)((addr).s6_addr[10]), \
87 (unsigned)((addr).s6_addr[11]), \
88 (unsigned)((addr).s6_addr[12]), \
89 (unsigned)((addr).s6_addr[13]), \
90 (unsigned)((addr).s6_addr[14]), \
91 (unsigned)((addr).s6_addr[15])
98 cmdline_ipaddr_t addr;
102 const struct ipaddr_str ipaddr_valid_strs[] = {
103 {"0.0.0.0", {AF_INET, {IP4(0,0,0,0)}, 0},
105 {"0.0.0.0/0", {AF_INET, {IP4(0,0,0,0)}, 0},
106 CMDLINE_IPADDR_V4 | CMDLINE_IPADDR_NETWORK},
107 {"0.0.0.0/24", {AF_INET, {IP4(0,0,0,0)}, 24},
108 CMDLINE_IPADDR_V4 | CMDLINE_IPADDR_NETWORK},
109 {"192.168.1.0/24", {AF_INET, {IP4(192,168,1,0)}, 24},
110 CMDLINE_IPADDR_V4 | CMDLINE_IPADDR_NETWORK},
111 {"012.34.56.78/24", {AF_INET, {IP4(12,34,56,78)}, 24},
112 CMDLINE_IPADDR_V4 | CMDLINE_IPADDR_NETWORK},
113 {"34.56.78.90/1", {AF_INET, {IP4(34,56,78,90)}, 1},
114 CMDLINE_IPADDR_V4 | CMDLINE_IPADDR_NETWORK},
115 {"::", {AF_INET6, {IP6(0,0,0,0,0,0,0,0)}, 0},
117 {"::1", {AF_INET6, {IP6(0,0,0,0,0,0,0,1)}, 0},
119 {"::1/32", {AF_INET6, {IP6(0,0,0,0,0,0,0,1)}, 32},
120 CMDLINE_IPADDR_V6 | CMDLINE_IPADDR_NETWORK},
121 {"::/32", {AF_INET6, {IP6(0,0,0,0,0,0,0,0)}, 32},
122 CMDLINE_IPADDR_V6 | CMDLINE_IPADDR_NETWORK},
123 /* RFC5952 requests that only lowercase should be used */
124 {"1234:5678:90ab:cdef:4321:8765:BA09:FEDC", {AF_INET6,
125 {IP6(0x1234,0x5678,0x90AB,0xCDEF,0x4321,0x8765,0xBA09,0xFEDC)},
128 {"1234::1234/64", {AF_INET6,
129 {IP6(0x1234,0,0,0,0,0,0,0x1234)},
131 CMDLINE_IPADDR_V6 | CMDLINE_IPADDR_NETWORK},
132 {"1234::/64", {AF_INET6,
133 {IP6(0x1234,0,0,0,0,0,0,0)},
135 CMDLINE_IPADDR_V6 | CMDLINE_IPADDR_NETWORK},
136 {"1:1::1/32", {AF_INET6,
137 {IP6(1,1,0,0,0,0,0,1)},
139 CMDLINE_IPADDR_V6 | CMDLINE_IPADDR_NETWORK},
140 {"1:2:3:4::/64", {AF_INET6,
141 {IP6(1,2,3,4,0,0,0,0)},
143 CMDLINE_IPADDR_V6 | CMDLINE_IPADDR_NETWORK},
144 {"::ffff:192.168.1.0/64", {AF_INET6,
145 {IP6(0,0,0,0,0,0xFFFF,0xC0A8,0x100)},
147 CMDLINE_IPADDR_V6 | CMDLINE_IPADDR_NETWORK},
148 /* RFC5952 requests not using :: to skip one block of zeros*/
149 {"1::2:3:4:5:6:7", {AF_INET6,
150 {IP6(1,0,2,3,4,5,6,7)},
155 const char * ipaddr_garbage_addr4_strs[] = {
157 "192.168.1.0 garbage",
158 "192.168.1.0\0garbage",
159 "192.168.1.0#garbage",
160 "192.168.1.0\tgarbage",
161 "192.168.1.0\rgarbage",
162 "192.168.1.0\ngarbage",
164 #define IPv4_GARBAGE_ADDR IP4(192,168,1,0)
166 const char * ipaddr_garbage_addr6_strs[] = {
168 "1:2:3:4::8 garbage",
169 "1:2:3:4::8#garbage",
170 "1:2:3:4::8\0garbage",
171 "1:2:3:4::8\rgarbage",
172 "1:2:3:4::8\ngarbage",
173 "1:2:3:4::8\tgarbage",
175 #define IPv6_GARBAGE_ADDR {IP6(1,2,3,4,0,0,0,8)}
177 const char * ipaddr_garbage_network4_strs[] = {
179 "192.168.1.0/24 garbage",
180 "192.168.1.0/24\0garbage",
181 "192.168.1.0/24#garbage",
182 "192.168.1.0/24\tgarbage",
183 "192.168.1.0/24\rgarbage",
184 "192.168.1.0/24\ngarbage",
186 #define IPv4_GARBAGE_PREFIX 24
188 const char * ipaddr_garbage_network6_strs[] = {
190 "1:2:3:4::8/64 garbage",
191 "1:2:3:4::8/64#garbage",
192 "1:2:3:4::8/64\0garbage",
193 "1:2:3:4::8/64\rgarbage",
194 "1:2:3:4::8/64\ngarbage",
195 "1:2:3:4::8/64\tgarbage",
197 #define IPv6_GARBAGE_PREFIX 64
201 const char * ipaddr_invalid_strs[] = {
204 /* invalid numbers */
214 "256.123.123.123/24",
215 "255.256.123.123/24",
216 "255.255.256.123/24",
217 "255.255.255.256/24",
218 /* invalid network mask */
232 "123.123.123.123.123",
237 "123.123.123.123./24",
238 "123.123.123..123/24",
239 "123.123.123.123.123/24",
241 ".123.123.123.123/24",
242 /* invalid characters */
250 "123.123.123.123/4F",
257 "1:2:3:4:5:6:7:192.168.1.1",
258 "1234:192.168.1.1:ffff::",
259 "1:2:3:4:5:6:7:890ab",
260 "1:2:3:4:5:6:7890a:b",
261 "1:2:3:4:5:67890:a:b",
262 "1:2:3:4:56789:0:a:b",
263 "1:2:3:45678:9:0:a:b",
264 "1:2:34567:8:9:0:a:b",
265 "1:23456:7:8:9:0:a:b",
266 "12345:6:7:8:9:0:a:b",
276 "1::2:3:4:5:6:7:8/64",
278 /* invalid network mask */
279 "1:2:3:4:5:6:7:8/129",
280 "1:2:3:4:5:6:7:8/-1",
282 /* invalid characters */
288 "1234:1234:1234:1234:1234:1234:1234:1234:1234:1234:1234"
289 "random invalid text",
295 #define IPADDR_VALID_STRS_SIZE \
296 (sizeof(ipaddr_valid_strs) / sizeof(ipaddr_valid_strs[0]))
297 #define IPADDR_GARBAGE_ADDR4_STRS_SIZE \
298 (sizeof(ipaddr_garbage_addr4_strs) / sizeof(ipaddr_garbage_addr4_strs[0]))
299 #define IPADDR_GARBAGE_ADDR6_STRS_SIZE \
300 (sizeof(ipaddr_garbage_addr6_strs) / sizeof(ipaddr_garbage_addr6_strs[0]))
301 #define IPADDR_GARBAGE_NETWORK4_STRS_SIZE \
302 (sizeof(ipaddr_garbage_network4_strs) / sizeof(ipaddr_garbage_network4_strs[0]))
303 #define IPADDR_GARBAGE_NETWORK6_STRS_SIZE \
304 (sizeof(ipaddr_garbage_network6_strs) / sizeof(ipaddr_garbage_network6_strs[0]))
305 #define IPADDR_INVALID_STRS_SIZE \
306 (sizeof(ipaddr_invalid_strs) / sizeof(ipaddr_invalid_strs[0]))
309 dump_addr(cmdline_ipaddr_t addr)
311 switch (addr.family) {
314 printf(NIPQUAD_FMT " prefixlen=%u\n",
315 NIPQUAD(addr.addr.ipv4.s_addr), addr.prefixlen);
320 printf(NIP6_FMT " prefixlen=%u\n",
321 NIP6(addr.addr.ipv6), addr.prefixlen);
325 printf("Can't dump: unknown address family.\n");
332 is_addr_different(cmdline_ipaddr_t addr1, cmdline_ipaddr_t addr2)
334 if (addr1.family != addr2.family)
337 if (addr1.prefixlen != addr2.prefixlen)
340 switch (addr1.family) {
343 if (memcmp(&addr1.addr.ipv4, &addr2.addr.ipv4,
344 sizeof(struct in_addr)) != 0)
350 if (memcmp(&addr1.addr.ipv6, &addr2.addr.ipv6,
351 sizeof(struct in6_addr)) != 0)
355 /* thing that should not be */
363 can_parse_addr(unsigned addr_flags, unsigned test_flags)
365 if ((test_flags & addr_flags) == addr_flags) {
366 /* if we are not trying to parse network addresses */
367 if (test_flags < CMDLINE_IPADDR_NETWORK)
369 /* if this is a network address */
370 else if (addr_flags & CMDLINE_IPADDR_NETWORK)
377 test_parse_ipaddr_valid(void)
379 cmdline_parse_token_ipaddr_t token;
380 char buf[CMDLINE_TEST_BUFSIZE];
381 cmdline_ipaddr_t result;
386 /* cover all cases in help */
387 for (flags = 0x1; flags < 0x8; flags++) {
388 token.ipaddr_data.flags = flags;
390 memset(buf, 0, sizeof(buf));
392 if (cmdline_get_help_ipaddr((cmdline_parse_token_hdr_t*)&token,
393 buf, sizeof(buf)) == -1) {
394 printf("Error: help rejected valid parameters!\n");
399 /* test valid strings */
400 for (i = 0; i < IPADDR_VALID_STRS_SIZE; i++) {
402 /* test each valid string against different flags */
403 for (flags = 1; flags < 0x8; flags++) {
406 if (flags == CMDLINE_IPADDR_NETWORK)
409 /* clear out everything */
410 memset(buf, 0, sizeof(buf));
411 memset(&result, 0, sizeof(result));
412 memset(&token, 0, sizeof(token));
414 token.ipaddr_data.flags = flags;
416 cmdline_get_help_ipaddr((cmdline_parse_token_hdr_t*)&token,
419 ret = cmdline_parse_ipaddr((cmdline_parse_token_hdr_t*)&token,
420 ipaddr_valid_strs[i].str, (void*)&result);
422 /* if should have passed, or should have failed */
424 (can_parse_addr(ipaddr_valid_strs[i].flags, flags))) {
425 printf("Error: unexpected behavior when parsing %s as %s!\n",
426 ipaddr_valid_strs[i].str, buf);
427 printf("Parsed result: ");
429 printf("Expected result: ");
430 dump_addr(ipaddr_valid_strs[i].addr);
434 is_addr_different(result, ipaddr_valid_strs[i].addr)) {
435 printf("Error: result mismatch when parsing %s as %s!\n",
436 ipaddr_valid_strs[i].str, buf);
437 printf("Parsed result: ");
439 printf("Expected result: ");
440 dump_addr(ipaddr_valid_strs[i].addr);
446 /* test garbage ipv4 address strings */
447 for (i = 0; i < IPADDR_GARBAGE_ADDR4_STRS_SIZE; i++) {
449 struct in_addr tmp = IPv4_GARBAGE_ADDR;
451 /* test each valid string against different flags */
452 for (flags = 1; flags < 0x8; flags++) {
455 if (flags == CMDLINE_IPADDR_NETWORK)
458 /* clear out everything */
459 memset(buf, 0, sizeof(buf));
460 memset(&result, 0, sizeof(result));
461 memset(&token, 0, sizeof(token));
463 token.ipaddr_data.flags = flags;
465 cmdline_get_help_ipaddr((cmdline_parse_token_hdr_t*)&token,
468 ret = cmdline_parse_ipaddr((cmdline_parse_token_hdr_t*)&token,
469 ipaddr_garbage_addr4_strs[i], (void*)&result);
471 /* if should have passed, or should have failed */
473 (can_parse_addr(CMDLINE_IPADDR_V4, flags))) {
474 printf("Error: unexpected behavior when parsing %s as %s!\n",
475 ipaddr_garbage_addr4_strs[i], buf);
479 memcmp(&result.addr.ipv4, &tmp, sizeof(tmp))) {
480 printf("Error: result mismatch when parsing %s as %s!\n",
481 ipaddr_garbage_addr4_strs[i], buf);
487 /* test garbage ipv6 address strings */
488 for (i = 0; i < IPADDR_GARBAGE_ADDR6_STRS_SIZE; i++) {
490 cmdline_ipaddr_t tmp = {.addr = IPv6_GARBAGE_ADDR};
492 /* test each valid string against different flags */
493 for (flags = 1; flags < 0x8; flags++) {
496 if (flags == CMDLINE_IPADDR_NETWORK)
499 /* clear out everything */
500 memset(buf, 0, sizeof(buf));
501 memset(&result, 0, sizeof(result));
502 memset(&token, 0, sizeof(token));
504 token.ipaddr_data.flags = flags;
506 cmdline_get_help_ipaddr((cmdline_parse_token_hdr_t*)&token,
509 ret = cmdline_parse_ipaddr((cmdline_parse_token_hdr_t*)&token,
510 ipaddr_garbage_addr6_strs[i], (void*)&result);
512 /* if should have passed, or should have failed */
514 (can_parse_addr(CMDLINE_IPADDR_V6, flags))) {
515 printf("Error: unexpected behavior when parsing %s as %s!\n",
516 ipaddr_garbage_addr6_strs[i], buf);
520 memcmp(&result.addr.ipv6, &tmp.addr.ipv6, sizeof(struct in6_addr))) {
521 printf("Error: result mismatch when parsing %s as %s!\n",
522 ipaddr_garbage_addr6_strs[i], buf);
529 /* test garbage ipv4 network strings */
530 for (i = 0; i < IPADDR_GARBAGE_NETWORK4_STRS_SIZE; i++) {
532 struct in_addr tmp = IPv4_GARBAGE_ADDR;
534 /* test each valid string against different flags */
535 for (flags = 1; flags < 0x8; flags++) {
538 if (flags == CMDLINE_IPADDR_NETWORK)
541 /* clear out everything */
542 memset(buf, 0, sizeof(buf));
543 memset(&result, 0, sizeof(result));
544 memset(&token, 0, sizeof(token));
546 token.ipaddr_data.flags = flags;
548 cmdline_get_help_ipaddr((cmdline_parse_token_hdr_t*)&token,
551 ret = cmdline_parse_ipaddr((cmdline_parse_token_hdr_t*)&token,
552 ipaddr_garbage_network4_strs[i], (void*)&result);
554 /* if should have passed, or should have failed */
556 (can_parse_addr(CMDLINE_IPADDR_V4 | CMDLINE_IPADDR_NETWORK, flags))) {
557 printf("Error: unexpected behavior when parsing %s as %s!\n",
558 ipaddr_garbage_network4_strs[i], buf);
562 memcmp(&result.addr.ipv4, &tmp, sizeof(tmp))) {
563 printf("Error: result mismatch when parsing %s as %s!\n",
564 ipaddr_garbage_network4_strs[i], buf);
570 /* test garbage ipv6 address strings */
571 for (i = 0; i < IPADDR_GARBAGE_NETWORK6_STRS_SIZE; i++) {
573 cmdline_ipaddr_t tmp = {.addr = IPv6_GARBAGE_ADDR};
575 /* test each valid string against different flags */
576 for (flags = 1; flags < 0x8; flags++) {
579 if (flags == CMDLINE_IPADDR_NETWORK)
582 /* clear out everything */
583 memset(buf, 0, sizeof(buf));
584 memset(&result, 0, sizeof(result));
585 memset(&token, 0, sizeof(token));
587 token.ipaddr_data.flags = flags;
589 cmdline_get_help_ipaddr((cmdline_parse_token_hdr_t*)&token,
592 ret = cmdline_parse_ipaddr((cmdline_parse_token_hdr_t*)&token,
593 ipaddr_garbage_network6_strs[i], (void*)&result);
595 /* if should have passed, or should have failed */
597 (can_parse_addr(CMDLINE_IPADDR_V6 | CMDLINE_IPADDR_NETWORK, flags))) {
598 printf("Error: unexpected behavior when parsing %s as %s!\n",
599 ipaddr_garbage_network6_strs[i], buf);
603 memcmp(&result.addr.ipv6, &tmp.addr.ipv6, sizeof(struct in6_addr))) {
604 printf("Error: result mismatch when parsing %s as %s!\n",
605 ipaddr_garbage_network6_strs[i], buf);
615 test_parse_ipaddr_invalid_data(void)
617 cmdline_parse_token_ipaddr_t token;
618 char buf[CMDLINE_TEST_BUFSIZE];
619 cmdline_ipaddr_t result;
624 memset(&result, 0, sizeof(result));
626 /* test invalid strings */
627 for (i = 0; i < IPADDR_INVALID_STRS_SIZE; i++) {
629 /* test each valid string against different flags */
630 for (flags = 1; flags < 0x8; flags++) {
633 if (flags == CMDLINE_IPADDR_NETWORK)
636 /* clear out everything */
637 memset(buf, 0, sizeof(buf));
638 memset(&token, 0, sizeof(token));
640 token.ipaddr_data.flags = flags;
642 cmdline_get_help_ipaddr((cmdline_parse_token_hdr_t*)&token,
645 ret = cmdline_parse_ipaddr((cmdline_parse_token_hdr_t*)&token,
646 ipaddr_invalid_strs[i], (void*)&result);
649 printf("Error: parsing %s as %s succeeded!\n",
650 ipaddr_invalid_strs[i], buf);
651 printf("Parsed result: ");
662 test_parse_ipaddr_invalid_param(void)
664 cmdline_parse_token_ipaddr_t token;
665 char buf[CMDLINE_TEST_BUFSIZE];
666 cmdline_ipaddr_t result;
668 rte_snprintf(buf, sizeof(buf), "1.2.3.4");
669 token.ipaddr_data.flags = CMDLINE_IPADDR_V4;
672 if (cmdline_parse_ipaddr(NULL, buf, (void*)&result) != -1) {
673 printf("Error: parser accepted invalid parameters!\n");
677 if (cmdline_parse_ipaddr((cmdline_parse_token_hdr_t*)&token,
678 NULL, (void*)&result) != -1) {
679 printf("Error: parser accepted invalid parameters!\n");
683 if (cmdline_parse_ipaddr((cmdline_parse_token_hdr_t*)&token,
684 "", (void*)&result) != -1) {
685 printf("Error: parser accepted invalid parameters!\n");
689 if (cmdline_parse_ipaddr((cmdline_parse_token_hdr_t*)&token,
691 printf("Error: parser rejected null result!\n");
696 if (cmdline_get_help_ipaddr(NULL, buf, 0) != -1) {
697 printf("Error: help accepted invalid parameters!\n");
701 if (cmdline_get_help_ipaddr((cmdline_parse_token_hdr_t*)&token,
703 printf("Error: help accepted invalid parameters!\n");