app/test/test_cmdline_ipaddr.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2010-2014 Intel Corporation
   3  */
   4
   5 #include <stdio.h>
   6 #include <string.h>
   7 #include <inttypes.h>
   8 #include <netinet/in.h>
   9 #include <sys/socket.h>
  10
  11 #include <rte_string_fns.h>
  12
  13 #include <cmdline_parse.h>
  14 #include <cmdline_parse_ipaddr.h>
  15
  16 #include "test_cmdline.h"
  17
  18 #define IP4(a,b,c,d) {((uint32_t)(((a) & 0xff)) | \
  19                                            (((b) & 0xff) << 8) | \
  20                                            (((c) & 0xff) << 16)  | \
  21                                            ((d) & 0xff)  << 24)}
  22
  23 #define U16_SWAP(x) \
  24                 (((x & 0xFF) << 8) | ((x & 0xFF00) >> 8))
  25
  26 /* create IPv6 address, swapping bytes where needed */
  27 #ifndef s6_addr16
  28 # define s6_addr16      __u6_addr.__u6_addr16
  29 #endif
  30 #define IP6(a,b,c,d,e,f,g,h) .ipv6 = \
  31                 {.s6_addr16 = \
  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)}}
  34
  35 /** these are defined in netinet/in.h but not present in linux headers */
  36 #ifndef NIPQUAD
  37
  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]
  44
  45 #define NIP6_FMT "%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x"
  46 #define NIP6(addr)                                      \
  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])
  63
  64 #endif
  65
  66
  67
  68 struct ipaddr_str {
  69         const char * str;
  70         cmdline_ipaddr_t addr;
  71         unsigned flags;
  72 };
  73
  74 const struct ipaddr_str ipaddr_valid_strs[] = {
  75                 {"0.0.0.0", {AF_INET, {IP4(0,0,0,0)}, 0},
  76                                 CMDLINE_IPADDR_V4},
  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},
  86                                         CMDLINE_IPADDR_V6},
  87                 {"::1", {AF_INET6, {IP6(0,0,0,0,0,0,0,1)}, 0},
  88                                 CMDLINE_IPADDR_V6},
  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)},
  96                                 0},
  97                                 CMDLINE_IPADDR_V6},
  98                 {"1234::1234/64", {AF_INET6,
  99                                 {IP6(0x1234,0,0,0,0,0,0,0x1234)},
 100                                 64},
 101                                 CMDLINE_IPADDR_V6 | CMDLINE_IPADDR_NETWORK},
 102                 {"1234::/64", {AF_INET6,
 103                                 {IP6(0x1234,0,0,0,0,0,0,0)},
 104                                 64},
 105                                 CMDLINE_IPADDR_V6 | CMDLINE_IPADDR_NETWORK},
 106                 {"1:1::1/32", {AF_INET6,
 107                                 {IP6(1,1,0,0,0,0,0,1)},
 108                                 32},
 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)},
 112                                 64},
 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)},
 116                                 64},
 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)},
 121                                 0},
 122                         CMDLINE_IPADDR_V6},
 123 };
 124
 125 const char * ipaddr_garbage_addr4_strs[] = {
 126                 /* IPv4 */
 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",
 133 };
 134 #define IPv4_GARBAGE_ADDR IP4(192,168,1,0)
 135
 136 const char * ipaddr_garbage_addr6_strs[] = {
 137                 /* IPv6 */
 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",
 144 };
 145 #define IPv6_GARBAGE_ADDR {IP6(1,2,3,4,0,0,0,8)}
 146
 147 const char * ipaddr_garbage_network4_strs[] = {
 148                 /* IPv4 */
 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",
 155 };
 156 #define IPv4_GARBAGE_PREFIX 24
 157
 158 const char * ipaddr_garbage_network6_strs[] = {
 159                 /* IPv6 */
 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",
 166 };
 167 #define IPv6_GARBAGE_PREFIX 64
 168
 169
 170
 171 const char * ipaddr_invalid_strs[] = {
 172                 /** IPv4 **/
 173
 174                 /* invalid numbers */
 175                 "0.0.0.-1",
 176                 "0.0.-1.0",
 177                 "0.-1.0.0",
 178                 "-1.0.0.0",
 179                 "0.0.0.-1/24",
 180                 "256.123.123.123",
 181                 "255.256.123.123",
 182                 "255.255.256.123",
 183                 "255.255.255.256",
 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 */
 189                 "1.2.3.4/33",
 190                 "1.2.3.4/33231313",
 191                 "1.2.3.4/-1",
 192                 "1.2.3.4/24/33",
 193                 "1.2.3.4/24/-1",
 194                 "1.2.3.4/24/",
 195                 /* wrong format */
 196                 "1/24"
 197                 "/24"
 198                 "123.123.123",
 199                 "123.123.123.",
 200                 "123.123.123.123.",
 201                 "123.123.123..123",
 202                 "123.123.123.123.123",
 203                 ".123.123.123",
 204                 ".123.123.123.123",
 205                 "123.123.123/24",
 206                 "123.123.123./24",
 207                 "123.123.123.123./24",
 208                 "123.123.123..123/24",
 209                 "123.123.123.123.123/24",
 210                 ".123.123.123/24",
 211                 ".123.123.123.123/24",
 212                 /* invalid characters */
 213                 "123.123.123.12F",
 214                 "123.123.12F.123",
 215                 "123.12F.123.123",
 216                 "12F.123.123.123",
 217                 "12J.123.123.123",
 218                 "123,123,123,123",
 219                 "123!123!123!12F",
 220                 "123.123.123.123/4F",
 221
 222                 /** IPv6 **/
 223
 224                 /* wrong format */
 225                 "::fffff",
 226                 "ffff:",
 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",
 237                 "1:::2",
 238                 "1::::2",
 239                 "::fffff/64",
 240                 "1::2::3",
 241                 "1::2::3/64",
 242                 ":1:2",
 243                 ":1:2/64",
 244                 ":1::2",
 245                 ":1::2/64",
 246                 "1::2:3:4:5:6:7:8/64",
 247
 248                 /* invalid network mask */
 249                 "1:2:3:4:5:6:7:8/129",
 250                 "1:2:3:4:5:6:7:8/-1",
 251
 252                 /* invalid characters */
 253                 "a:b:c:d:e:f:g::",
 254
 255                 /** misc **/
 256
 257                 /* too long */
 258                 "1234:1234:1234:1234:1234:1234:1234:1234:1234:1234:1234"
 259                 "random invalid text",
 260                 "",
 261                 "\0",
 262                 " ",
 263 };
 264
 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]))
 277
 278 static void
 279 dump_addr(cmdline_ipaddr_t addr)
 280 {
 281         switch (addr.family) {
 282         case AF_INET:
 283         {
 284                 printf(NIPQUAD_FMT " prefixlen=%u\n",
 285                                 NIPQUAD(addr.addr.ipv4.s_addr), addr.prefixlen);
 286                 break;
 287         }
 288         case AF_INET6:
 289         {
 290                 printf(NIP6_FMT " prefixlen=%u\n",
 291                                 NIP6(addr.addr.ipv6), addr.prefixlen);
 292                 break;
 293         }
 294         default:
 295                 printf("Can't dump: unknown address family.\n");
 296                 return;
 297         }
 298 }
 299
 300
 301 static int
 302 is_addr_different(cmdline_ipaddr_t addr1, cmdline_ipaddr_t addr2)
 303 {
 304         if (addr1.family != addr2.family)
 305                 return 1;
 306
 307         if (addr1.prefixlen != addr2.prefixlen)
 308                 return 1;
 309
 310         switch (addr1.family) {
 311         /* IPv4 */
 312         case AF_INET:
 313                 if (memcmp(&addr1.addr.ipv4, &addr2.addr.ipv4,
 314                                 sizeof(struct in_addr)) != 0)
 315                         return 1;
 316                 break;
 317         /* IPv6 */
 318         case AF_INET6:
 319         {
 320                 if (memcmp(&addr1.addr.ipv6, &addr2.addr.ipv6,
 321                                 sizeof(struct in6_addr)) != 0)
 322                         return 1;
 323                 break;
 324         }
 325         /* thing that should not be */
 326         default:
 327                 return -1;
 328         }
 329         return 0;
 330 }
 331
 332 static int
 333 can_parse_addr(unsigned addr_flags, unsigned test_flags)
 334 {
 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)
 338                         return 1;
 339                 /* if this is a network address */
 340                 else if (addr_flags & CMDLINE_IPADDR_NETWORK)
 341                         return 1;
 342         }
 343         return 0;
 344 }
 345
 346 int
 347 test_parse_ipaddr_valid(void)
 348 {
 349         cmdline_parse_token_ipaddr_t token;
 350         char buf[CMDLINE_TEST_BUFSIZE];
 351         cmdline_ipaddr_t result;
 352         unsigned i;
 353         uint8_t flags;
 354         int ret;
 355
 356         /* cover all cases in help */
 357         for (flags = 0x1; flags < 0x8; flags++) {
 358                 token.ipaddr_data.flags = flags;
 359
 360                 memset(buf, 0, sizeof(buf));
 361
 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");
 365                         return -1;
 366                 }
 367         }
 368
 369         /* test valid strings */
 370         for (i = 0; i < IPADDR_VALID_STRS_SIZE; i++) {
 371
 372                 /* test each valid string against different flags */
 373                 for (flags = 1; flags < 0x8; flags++) {
 374
 375                         /* skip bad flag */
 376                         if (flags == CMDLINE_IPADDR_NETWORK)
 377                                 continue;
 378
 379                         /* clear out everything */
 380                         memset(buf, 0, sizeof(buf));
 381                         memset(&result, 0, sizeof(result));
 382                         memset(&token, 0, sizeof(token));
 383
 384                         token.ipaddr_data.flags = flags;
 385
 386                         cmdline_get_help_ipaddr((cmdline_parse_token_hdr_t*)&token,
 387                                                         buf, sizeof(buf));
 388
 389                         ret = cmdline_parse_ipaddr((cmdline_parse_token_hdr_t*)&token,
 390                                 ipaddr_valid_strs[i].str, (void*)&result,
 391                                 sizeof(result));
 392
 393                         /* if should have passed, or should have failed */
 394                         if ((ret < 0) ==
 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: ");
 399                                 dump_addr(result);
 400                                 printf("Expected result: ");
 401                                 dump_addr(ipaddr_valid_strs[i].addr);
 402                                 return -1;
 403                         }
 404                         if (ret != -1 &&
 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: ");
 409                                 dump_addr(result);
 410                                 printf("Expected result: ");
 411                                 dump_addr(ipaddr_valid_strs[i].addr);
 412                                 return -1;
 413                         }
 414                 }
 415         }
 416
 417         /* test garbage ipv4 address strings */
 418         for (i = 0; i < IPADDR_GARBAGE_ADDR4_STRS_SIZE; i++) {
 419
 420                 struct in_addr tmp = IPv4_GARBAGE_ADDR;
 421
 422                 /* test each valid string against different flags */
 423                 for (flags = 1; flags < 0x8; flags++) {
 424
 425                         /* skip bad flag */
 426                         if (flags == CMDLINE_IPADDR_NETWORK)
 427                                 continue;
 428
 429                         /* clear out everything */
 430                         memset(buf, 0, sizeof(buf));
 431                         memset(&result, 0, sizeof(result));
 432                         memset(&token, 0, sizeof(token));
 433
 434                         token.ipaddr_data.flags = flags;
 435
 436                         cmdline_get_help_ipaddr((cmdline_parse_token_hdr_t*)&token,
 437                                                         buf, sizeof(buf));
 438
 439                         ret = cmdline_parse_ipaddr((cmdline_parse_token_hdr_t*)&token,
 440                                 ipaddr_garbage_addr4_strs[i], (void*)&result,
 441                                 sizeof(result));
 442
 443                         /* if should have passed, or should have failed */
 444                         if ((ret < 0) ==
 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);
 448                                 return -1;
 449                         }
 450                         if (ret != -1 &&
 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);
 454                                 return -1;
 455                         }
 456                 }
 457         }
 458
 459         /* test garbage ipv6 address strings */
 460         for (i = 0; i < IPADDR_GARBAGE_ADDR6_STRS_SIZE; i++) {
 461
 462                 cmdline_ipaddr_t tmp = {.addr = IPv6_GARBAGE_ADDR};
 463
 464                 /* test each valid string against different flags */
 465                 for (flags = 1; flags < 0x8; flags++) {
 466
 467                         /* skip bad flag */
 468                         if (flags == CMDLINE_IPADDR_NETWORK)
 469                                 continue;
 470
 471                         /* clear out everything */
 472                         memset(buf, 0, sizeof(buf));
 473                         memset(&result, 0, sizeof(result));
 474                         memset(&token, 0, sizeof(token));
 475
 476                         token.ipaddr_data.flags = flags;
 477
 478                         cmdline_get_help_ipaddr((cmdline_parse_token_hdr_t*)&token,
 479                                                         buf, sizeof(buf));
 480
 481                         ret = cmdline_parse_ipaddr((cmdline_parse_token_hdr_t*)&token,
 482                                 ipaddr_garbage_addr6_strs[i], (void*)&result,
 483                                 sizeof(result));
 484
 485                         /* if should have passed, or should have failed */
 486                         if ((ret < 0) ==
 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);
 490                                 return -1;
 491                         }
 492                         if (ret != -1 &&
 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);
 496                                 return -1;
 497                         }
 498                 }
 499         }
 500
 501
 502         /* test garbage ipv4 network strings */
 503         for (i = 0; i < IPADDR_GARBAGE_NETWORK4_STRS_SIZE; i++) {
 504
 505                 struct in_addr tmp = IPv4_GARBAGE_ADDR;
 506
 507                 /* test each valid string against different flags */
 508                 for (flags = 1; flags < 0x8; flags++) {
 509
 510                         /* skip bad flag */
 511                         if (flags == CMDLINE_IPADDR_NETWORK)
 512                                 continue;
 513
 514                         /* clear out everything */
 515                         memset(buf, 0, sizeof(buf));
 516                         memset(&result, 0, sizeof(result));
 517                         memset(&token, 0, sizeof(token));
 518
 519                         token.ipaddr_data.flags = flags;
 520
 521                         cmdline_get_help_ipaddr((cmdline_parse_token_hdr_t*)&token,
 522                                                         buf, sizeof(buf));
 523
 524                         ret = cmdline_parse_ipaddr((cmdline_parse_token_hdr_t*)&token,
 525                                 ipaddr_garbage_network4_strs[i], (void*)&result,
 526                                 sizeof(result));
 527
 528                         /* if should have passed, or should have failed */
 529                         if ((ret < 0) ==
 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);
 533                                 return -1;
 534                         }
 535                         if (ret != -1 &&
 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);
 539                                 return -1;
 540                         }
 541                 }
 542         }
 543
 544         /* test garbage ipv6 address strings */
 545         for (i = 0; i < IPADDR_GARBAGE_NETWORK6_STRS_SIZE; i++) {
 546
 547                 cmdline_ipaddr_t tmp = {.addr = IPv6_GARBAGE_ADDR};
 548
 549                 /* test each valid string against different flags */
 550                 for (flags = 1; flags < 0x8; flags++) {
 551
 552                         /* skip bad flag */
 553                         if (flags == CMDLINE_IPADDR_NETWORK)
 554                                 continue;
 555
 556                         /* clear out everything */
 557                         memset(buf, 0, sizeof(buf));
 558                         memset(&result, 0, sizeof(result));
 559                         memset(&token, 0, sizeof(token));
 560
 561                         token.ipaddr_data.flags = flags;
 562
 563                         cmdline_get_help_ipaddr((cmdline_parse_token_hdr_t*)&token,
 564                                                         buf, sizeof(buf));
 565
 566                         ret = cmdline_parse_ipaddr((cmdline_parse_token_hdr_t*)&token,
 567                                 ipaddr_garbage_network6_strs[i], (void*)&result,
 568                                 sizeof(result));
 569
 570                         /* if should have passed, or should have failed */
 571                         if ((ret < 0) ==
 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);
 575                                 return -1;
 576                         }
 577                         if (ret != -1 &&
 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);
 581                                 return -1;
 582                         }
 583                 }
 584         }
 585
 586         return 0;
 587 }
 588
 589 int
 590 test_parse_ipaddr_invalid_data(void)
 591 {
 592         cmdline_parse_token_ipaddr_t token;
 593         char buf[CMDLINE_TEST_BUFSIZE];
 594         cmdline_ipaddr_t result;
 595         unsigned i;
 596         uint8_t flags;
 597         int ret;
 598
 599         memset(&result, 0, sizeof(result));
 600
 601         /* test invalid strings */
 602         for (i = 0; i < IPADDR_INVALID_STRS_SIZE; i++) {
 603
 604                 /* test each valid string against different flags */
 605                 for (flags = 1; flags < 0x8; flags++) {
 606
 607                         /* skip bad flag */
 608                         if (flags == CMDLINE_IPADDR_NETWORK)
 609                                 continue;
 610
 611                         /* clear out everything */
 612                         memset(buf, 0, sizeof(buf));
 613                         memset(&token, 0, sizeof(token));
 614
 615                         token.ipaddr_data.flags = flags;
 616
 617                         cmdline_get_help_ipaddr((cmdline_parse_token_hdr_t*)&token,
 618                                         buf, sizeof(buf));
 619
 620                         ret = cmdline_parse_ipaddr((cmdline_parse_token_hdr_t*)&token,
 621                                 ipaddr_invalid_strs[i], (void*)&result,
 622                                 sizeof(result));
 623
 624                         if (ret != -1) {
 625                                 printf("Error: parsing %s as %s succeeded!\n",
 626                                                 ipaddr_invalid_strs[i], buf);
 627                                 printf("Parsed result: ");
 628                                 dump_addr(result);
 629                                 return -1;
 630                         }
 631                 }
 632         }
 633
 634         return 0;
 635 }
 636
 637 int
 638 test_parse_ipaddr_invalid_param(void)
 639 {
 640         cmdline_parse_token_ipaddr_t token;
 641         char buf[CMDLINE_TEST_BUFSIZE];
 642         cmdline_ipaddr_t result;
 643
 644         snprintf(buf, sizeof(buf), "1.2.3.4");
 645         token.ipaddr_data.flags = CMDLINE_IPADDR_V4;
 646
 647         /* null token */
 648         if (cmdline_parse_ipaddr(NULL, buf, (void*)&result,
 649                         sizeof(result)) != -1) {
 650                 printf("Error: parser accepted invalid parameters!\n");
 651                 return -1;
 652         }
 653         /* null buffer */
 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");
 657                 return -1;
 658         }
 659         /* empty buffer */
 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");
 663                 return -1;
 664         }
 665         /* null result */
 666         if (cmdline_parse_ipaddr((cmdline_parse_token_hdr_t*)&token,
 667                         buf, NULL, 0) == -1) {
 668                 printf("Error: parser rejected null result!\n");
 669                 return -1;
 670         }
 671
 672         /* null token */
 673         if (cmdline_get_help_ipaddr(NULL, buf, 0) != -1) {
 674                 printf("Error: help accepted invalid parameters!\n");
 675                 return -1;
 676         }
 677         /* null buffer */
 678         if (cmdline_get_help_ipaddr((cmdline_parse_token_hdr_t*)&token,
 679                         NULL, 0) != -1) {
 680                 printf("Error: help accepted invalid parameters!\n");
 681                 return -1;
 682         }
 683         return 0;
 684 }