test/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
  10 #ifndef __linux__
  11 #ifndef __FreeBSD__
  12 #include <net/socket.h>
  13 #else
  14 #include <sys/socket.h>
  15 #endif
  16 #endif
  17
  18 #include <rte_string_fns.h>
  19
  20 #include <cmdline_parse.h>
  21 #include <cmdline_parse_ipaddr.h>
  22
  23 #include "test_cmdline.h"
  24
  25 #define IP4(a,b,c,d) {((uint32_t)(((a) & 0xff)) | \
  26                                            (((b) & 0xff) << 8) | \
  27                                            (((c) & 0xff) << 16)  | \
  28                                            ((d) & 0xff)  << 24)}
  29
  30 #define U16_SWAP(x) \
  31                 (((x & 0xFF) << 8) | ((x & 0xFF00) >> 8))
  32
  33 /* create IPv6 address, swapping bytes where needed */
  34 #ifndef s6_addr16
  35 # define s6_addr16      __u6_addr.__u6_addr16
  36 #endif
  37 #define IP6(a,b,c,d,e,f,g,h) .ipv6 = \
  38                 {.s6_addr16 = \
  39                 {U16_SWAP(a),U16_SWAP(b),U16_SWAP(c),U16_SWAP(d),\
  40                  U16_SWAP(e),U16_SWAP(f),U16_SWAP(g),U16_SWAP(h)}}
  41
  42 /** these are defined in netinet/in.h but not present in linux headers */
  43 #ifndef NIPQUAD
  44
  45 #define NIPQUAD_FMT "%u.%u.%u.%u"
  46 #define NIPQUAD(addr)                           \
  47         (unsigned)((unsigned char *)&addr)[0],  \
  48         (unsigned)((unsigned char *)&addr)[1],  \
  49         (unsigned)((unsigned char *)&addr)[2],  \
  50         (unsigned)((unsigned char *)&addr)[3]
  51
  52 #define NIP6_FMT "%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x"
  53 #define NIP6(addr)                                      \
  54         (unsigned)((addr).s6_addr[0]),                  \
  55         (unsigned)((addr).s6_addr[1]),                  \
  56         (unsigned)((addr).s6_addr[2]),                  \
  57         (unsigned)((addr).s6_addr[3]),                  \
  58         (unsigned)((addr).s6_addr[4]),                  \
  59         (unsigned)((addr).s6_addr[5]),                  \
  60         (unsigned)((addr).s6_addr[6]),                  \
  61         (unsigned)((addr).s6_addr[7]),                  \
  62         (unsigned)((addr).s6_addr[8]),                  \
  63         (unsigned)((addr).s6_addr[9]),                  \
  64         (unsigned)((addr).s6_addr[10]),                 \
  65         (unsigned)((addr).s6_addr[11]),                 \
  66         (unsigned)((addr).s6_addr[12]),                 \
  67         (unsigned)((addr).s6_addr[13]),                 \
  68         (unsigned)((addr).s6_addr[14]),                 \
  69         (unsigned)((addr).s6_addr[15])
  70
  71 #endif
  72
  73
  74
  75 struct ipaddr_str {
  76         const char * str;
  77         cmdline_ipaddr_t addr;
  78         unsigned flags;
  79 };
  80
  81 const struct ipaddr_str ipaddr_valid_strs[] = {
  82                 {"0.0.0.0", {AF_INET, {IP4(0,0,0,0)}, 0},
  83                                 CMDLINE_IPADDR_V4},
  84                 {"0.0.0.0/0", {AF_INET, {IP4(0,0,0,0)}, 0},
  85                                 CMDLINE_IPADDR_V4 | CMDLINE_IPADDR_NETWORK},
  86                 {"0.0.0.0/24", {AF_INET, {IP4(0,0,0,0)}, 24},
  87                                 CMDLINE_IPADDR_V4 | CMDLINE_IPADDR_NETWORK},
  88                 {"192.168.1.0/24", {AF_INET, {IP4(192,168,1,0)}, 24},
  89                                 CMDLINE_IPADDR_V4 | CMDLINE_IPADDR_NETWORK},
  90                 {"34.56.78.90/1", {AF_INET, {IP4(34,56,78,90)}, 1},
  91                                 CMDLINE_IPADDR_V4 | CMDLINE_IPADDR_NETWORK},
  92                 {"::", {AF_INET6, {IP6(0,0,0,0,0,0,0,0)}, 0},
  93                                         CMDLINE_IPADDR_V6},
  94                 {"::1", {AF_INET6, {IP6(0,0,0,0,0,0,0,1)}, 0},
  95                                 CMDLINE_IPADDR_V6},
  96                 {"::1/32", {AF_INET6, {IP6(0,0,0,0,0,0,0,1)}, 32},
  97                                 CMDLINE_IPADDR_V6 | CMDLINE_IPADDR_NETWORK},
  98                 {"::/32", {AF_INET6, {IP6(0,0,0,0,0,0,0,0)}, 32},
  99                                         CMDLINE_IPADDR_V6 | CMDLINE_IPADDR_NETWORK},
 100                 /* RFC5952 requests that only lowercase should be used */
 101                 {"1234:5678:90ab:cdef:4321:8765:BA09:FEDC", {AF_INET6,
 102                                 {IP6(0x1234,0x5678,0x90AB,0xCDEF,0x4321,0x8765,0xBA09,0xFEDC)},
 103                                 0},
 104                                 CMDLINE_IPADDR_V6},
 105                 {"1234::1234/64", {AF_INET6,
 106                                 {IP6(0x1234,0,0,0,0,0,0,0x1234)},
 107                                 64},
 108                                 CMDLINE_IPADDR_V6 | CMDLINE_IPADDR_NETWORK},
 109                 {"1234::/64", {AF_INET6,
 110                                 {IP6(0x1234,0,0,0,0,0,0,0)},
 111                                 64},
 112                                 CMDLINE_IPADDR_V6 | CMDLINE_IPADDR_NETWORK},
 113                 {"1:1::1/32", {AF_INET6,
 114                                 {IP6(1,1,0,0,0,0,0,1)},
 115                                 32},
 116                                 CMDLINE_IPADDR_V6 | CMDLINE_IPADDR_NETWORK},
 117                 {"1:2:3:4::/64", {AF_INET6,
 118                                 {IP6(1,2,3,4,0,0,0,0)},
 119                                 64},
 120                         CMDLINE_IPADDR_V6 | CMDLINE_IPADDR_NETWORK},
 121                 {"::ffff:192.168.1.0/64", {AF_INET6,
 122                                 {IP6(0,0,0,0,0,0xFFFF,0xC0A8,0x100)},
 123                                 64},
 124                         CMDLINE_IPADDR_V6 | CMDLINE_IPADDR_NETWORK},
 125                 /* RFC5952 requests not using :: to skip one block of zeros*/
 126                 {"1::2:3:4:5:6:7", {AF_INET6,
 127                                 {IP6(1,0,2,3,4,5,6,7)},
 128                                 0},
 129                         CMDLINE_IPADDR_V6},
 130 };
 131
 132 const char * ipaddr_garbage_addr4_strs[] = {
 133                 /* IPv4 */
 134                 "192.168.1.0 garbage",
 135                 "192.168.1.0\0garbage",
 136                 "192.168.1.0#garbage",
 137                 "192.168.1.0\tgarbage",
 138                 "192.168.1.0\rgarbage",
 139                 "192.168.1.0\ngarbage",
 140 };
 141 #define IPv4_GARBAGE_ADDR IP4(192,168,1,0)
 142
 143 const char * ipaddr_garbage_addr6_strs[] = {
 144                 /* IPv6 */
 145                 "1:2:3:4::8 garbage",
 146                 "1:2:3:4::8#garbage",
 147                 "1:2:3:4::8\0garbage",
 148                 "1:2:3:4::8\rgarbage",
 149                 "1:2:3:4::8\ngarbage",
 150                 "1:2:3:4::8\tgarbage",
 151 };
 152 #define IPv6_GARBAGE_ADDR {IP6(1,2,3,4,0,0,0,8)}
 153
 154 const char * ipaddr_garbage_network4_strs[] = {
 155                 /* IPv4 */
 156                 "192.168.1.0/24 garbage",
 157                 "192.168.1.0/24\0garbage",
 158                 "192.168.1.0/24#garbage",
 159                 "192.168.1.0/24\tgarbage",
 160                 "192.168.1.0/24\rgarbage",
 161                 "192.168.1.0/24\ngarbage",
 162 };
 163 #define IPv4_GARBAGE_PREFIX 24
 164
 165 const char * ipaddr_garbage_network6_strs[] = {
 166                 /* IPv6 */
 167                 "1:2:3:4::8/64 garbage",
 168                 "1:2:3:4::8/64#garbage",
 169                 "1:2:3:4::8/64\0garbage",
 170                 "1:2:3:4::8/64\rgarbage",
 171                 "1:2:3:4::8/64\ngarbage",
 172                 "1:2:3:4::8/64\tgarbage",
 173 };
 174 #define IPv6_GARBAGE_PREFIX 64
 175
 176
 177
 178 const char * ipaddr_invalid_strs[] = {
 179                 /** IPv4 **/
 180
 181                 /* invalid numbers */
 182                 "0.0.0.-1",
 183                 "0.0.-1.0",
 184                 "0.-1.0.0",
 185                 "-1.0.0.0",
 186                 "0.0.0.-1/24",
 187                 "256.123.123.123",
 188                 "255.256.123.123",
 189                 "255.255.256.123",
 190                 "255.255.255.256",
 191                 "256.123.123.123/24",
 192                 "255.256.123.123/24",
 193                 "255.255.256.123/24",
 194                 "255.255.255.256/24",
 195                 /* invalid network mask */
 196                 "1.2.3.4/33",
 197                 "1.2.3.4/33231313",
 198                 "1.2.3.4/-1",
 199                 "1.2.3.4/24/33",
 200                 "1.2.3.4/24/-1",
 201                 "1.2.3.4/24/",
 202                 /* wrong format */
 203                 "1/24"
 204                 "/24"
 205                 "123.123.123",
 206                 "123.123.123.",
 207                 "123.123.123.123.",
 208                 "123.123.123..123",
 209                 "123.123.123.123.123",
 210                 ".123.123.123",
 211                 ".123.123.123.123",
 212                 "123.123.123/24",
 213                 "123.123.123./24",
 214                 "123.123.123.123./24",
 215                 "123.123.123..123/24",
 216                 "123.123.123.123.123/24",
 217                 ".123.123.123/24",
 218                 ".123.123.123.123/24",
 219                 /* invalid characters */
 220                 "123.123.123.12F",
 221                 "123.123.12F.123",
 222                 "123.12F.123.123",
 223                 "12F.123.123.123",
 224                 "12J.123.123.123",
 225                 "123,123,123,123",
 226                 "123!123!123!12F",
 227                 "123.123.123.123/4F",
 228
 229                 /** IPv6 **/
 230
 231                 /* wrong format */
 232                 "::fffff",
 233                 "ffff:",
 234                 "1:2:3:4:5:6:7:192.168.1.1",
 235                 "1234:192.168.1.1:ffff::",
 236                 "1:2:3:4:5:6:7:890ab",
 237                 "1:2:3:4:5:6:7890a:b",
 238                 "1:2:3:4:5:67890:a:b",
 239                 "1:2:3:4:56789:0:a:b",
 240                 "1:2:3:45678:9:0:a:b",
 241                 "1:2:34567:8:9:0:a:b",
 242                 "1:23456:7:8:9:0:a:b",
 243                 "12345:6:7:8:9:0:a:b",
 244                 "1:::2",
 245                 "1::::2",
 246                 "::fffff/64",
 247                 "1::2::3",
 248                 "1::2::3/64",
 249                 ":1:2",
 250                 ":1:2/64",
 251                 ":1::2",
 252                 ":1::2/64",
 253                 "1::2:3:4:5:6:7:8/64",
 254
 255                 /* invalid network mask */
 256                 "1:2:3:4:5:6:7:8/129",
 257                 "1:2:3:4:5:6:7:8/-1",
 258
 259                 /* invalid characters */
 260                 "a:b:c:d:e:f:g::",
 261
 262                 /** misc **/
 263
 264                 /* too long */
 265                 "1234:1234:1234:1234:1234:1234:1234:1234:1234:1234:1234"
 266                 "random invalid text",
 267                 "",
 268                 "\0",
 269                 " ",
 270 };
 271
 272 #define IPADDR_VALID_STRS_SIZE \
 273         (sizeof(ipaddr_valid_strs) / sizeof(ipaddr_valid_strs[0]))
 274 #define IPADDR_GARBAGE_ADDR4_STRS_SIZE \
 275         (sizeof(ipaddr_garbage_addr4_strs) / sizeof(ipaddr_garbage_addr4_strs[0]))
 276 #define IPADDR_GARBAGE_ADDR6_STRS_SIZE \
 277         (sizeof(ipaddr_garbage_addr6_strs) / sizeof(ipaddr_garbage_addr6_strs[0]))
 278 #define IPADDR_GARBAGE_NETWORK4_STRS_SIZE \
 279         (sizeof(ipaddr_garbage_network4_strs) / sizeof(ipaddr_garbage_network4_strs[0]))
 280 #define IPADDR_GARBAGE_NETWORK6_STRS_SIZE \
 281         (sizeof(ipaddr_garbage_network6_strs) / sizeof(ipaddr_garbage_network6_strs[0]))
 282 #define IPADDR_INVALID_STRS_SIZE \
 283         (sizeof(ipaddr_invalid_strs) / sizeof(ipaddr_invalid_strs[0]))
 284
 285 static void
 286 dump_addr(cmdline_ipaddr_t addr)
 287 {
 288         switch (addr.family) {
 289         case AF_INET:
 290         {
 291                 printf(NIPQUAD_FMT " prefixlen=%u\n",
 292                                 NIPQUAD(addr.addr.ipv4.s_addr), addr.prefixlen);
 293                 break;
 294         }
 295         case AF_INET6:
 296         {
 297                 printf(NIP6_FMT " prefixlen=%u\n",
 298                                 NIP6(addr.addr.ipv6), addr.prefixlen);
 299                 break;
 300         }
 301         default:
 302                 printf("Can't dump: unknown address family.\n");
 303                 return;
 304         }
 305 }
 306
 307
 308 static int
 309 is_addr_different(cmdline_ipaddr_t addr1, cmdline_ipaddr_t addr2)
 310 {
 311         if (addr1.family != addr2.family)
 312                 return 1;
 313
 314         if (addr1.prefixlen != addr2.prefixlen)
 315                 return 1;
 316
 317         switch (addr1.family) {
 318         /* IPv4 */
 319         case AF_INET:
 320                 if (memcmp(&addr1.addr.ipv4, &addr2.addr.ipv4,
 321                                 sizeof(struct in_addr)) != 0)
 322                         return 1;
 323                 break;
 324         /* IPv6 */
 325         case AF_INET6:
 326         {
 327                 if (memcmp(&addr1.addr.ipv6, &addr2.addr.ipv6,
 328                                 sizeof(struct in6_addr)) != 0)
 329                         return 1;
 330                 break;
 331         }
 332         /* thing that should not be */
 333         default:
 334                 return -1;
 335         }
 336         return 0;
 337 }
 338
 339 static int
 340 can_parse_addr(unsigned addr_flags, unsigned test_flags)
 341 {
 342         if ((test_flags & addr_flags) == addr_flags) {
 343                 /* if we are not trying to parse network addresses */
 344                 if (test_flags < CMDLINE_IPADDR_NETWORK)
 345                         return 1;
 346                 /* if this is a network address */
 347                 else if (addr_flags & CMDLINE_IPADDR_NETWORK)
 348                         return 1;
 349         }
 350         return 0;
 351 }
 352
 353 int
 354 test_parse_ipaddr_valid(void)
 355 {
 356         cmdline_parse_token_ipaddr_t token;
 357         char buf[CMDLINE_TEST_BUFSIZE];
 358         cmdline_ipaddr_t result;
 359         unsigned i;
 360         uint8_t flags;
 361         int ret;
 362
 363         /* cover all cases in help */
 364         for (flags = 0x1; flags < 0x8; flags++) {
 365                 token.ipaddr_data.flags = flags;
 366
 367                 memset(buf, 0, sizeof(buf));
 368
 369                 if (cmdline_get_help_ipaddr((cmdline_parse_token_hdr_t*)&token,
 370                                 buf, sizeof(buf)) == -1) {
 371                         printf("Error: help rejected valid parameters!\n");
 372                         return -1;
 373                 }
 374         }
 375
 376         /* test valid strings */
 377         for (i = 0; i < IPADDR_VALID_STRS_SIZE; i++) {
 378
 379                 /* test each valid string against different flags */
 380                 for (flags = 1; flags < 0x8; flags++) {
 381
 382                         /* skip bad flag */
 383                         if (flags == CMDLINE_IPADDR_NETWORK)
 384                                 continue;
 385
 386                         /* clear out everything */
 387                         memset(buf, 0, sizeof(buf));
 388                         memset(&result, 0, sizeof(result));
 389                         memset(&token, 0, sizeof(token));
 390
 391                         token.ipaddr_data.flags = flags;
 392
 393                         cmdline_get_help_ipaddr((cmdline_parse_token_hdr_t*)&token,
 394                                                         buf, sizeof(buf));
 395
 396                         ret = cmdline_parse_ipaddr((cmdline_parse_token_hdr_t*)&token,
 397                                 ipaddr_valid_strs[i].str, (void*)&result,
 398                                 sizeof(result));
 399
 400                         /* if should have passed, or should have failed */
 401                         if ((ret < 0) ==
 402                                         (can_parse_addr(ipaddr_valid_strs[i].flags, flags))) {
 403                                 printf("Error: unexpected behavior when parsing %s as %s!\n",
 404                                                 ipaddr_valid_strs[i].str, buf);
 405                                 printf("Parsed result: ");
 406                                 dump_addr(result);
 407                                 printf("Expected result: ");
 408                                 dump_addr(ipaddr_valid_strs[i].addr);
 409                                 return -1;
 410                         }
 411                         if (ret != -1 &&
 412                                         is_addr_different(result, ipaddr_valid_strs[i].addr)) {
 413                                 printf("Error: result mismatch when parsing %s as %s!\n",
 414                                                 ipaddr_valid_strs[i].str, buf);
 415                                 printf("Parsed result: ");
 416                                 dump_addr(result);
 417                                 printf("Expected result: ");
 418                                 dump_addr(ipaddr_valid_strs[i].addr);
 419                                 return -1;
 420                         }
 421                 }
 422         }
 423
 424         /* test garbage ipv4 address strings */
 425         for (i = 0; i < IPADDR_GARBAGE_ADDR4_STRS_SIZE; i++) {
 426
 427                 struct in_addr tmp = IPv4_GARBAGE_ADDR;
 428
 429                 /* test each valid string against different flags */
 430                 for (flags = 1; flags < 0x8; flags++) {
 431
 432                         /* skip bad flag */
 433                         if (flags == CMDLINE_IPADDR_NETWORK)
 434                                 continue;
 435
 436                         /* clear out everything */
 437                         memset(buf, 0, sizeof(buf));
 438                         memset(&result, 0, sizeof(result));
 439                         memset(&token, 0, sizeof(token));
 440
 441                         token.ipaddr_data.flags = flags;
 442
 443                         cmdline_get_help_ipaddr((cmdline_parse_token_hdr_t*)&token,
 444                                                         buf, sizeof(buf));
 445
 446                         ret = cmdline_parse_ipaddr((cmdline_parse_token_hdr_t*)&token,
 447                                 ipaddr_garbage_addr4_strs[i], (void*)&result,
 448                                 sizeof(result));
 449
 450                         /* if should have passed, or should have failed */
 451                         if ((ret < 0) ==
 452                                         (can_parse_addr(CMDLINE_IPADDR_V4, flags))) {
 453                                 printf("Error: unexpected behavior when parsing %s as %s!\n",
 454                                                 ipaddr_garbage_addr4_strs[i], buf);
 455                                 return -1;
 456                         }
 457                         if (ret != -1 &&
 458                                         memcmp(&result.addr.ipv4, &tmp, sizeof(tmp))) {
 459                                 printf("Error: result mismatch when parsing %s as %s!\n",
 460                                                 ipaddr_garbage_addr4_strs[i], buf);
 461                                 return -1;
 462                         }
 463                 }
 464         }
 465
 466         /* test garbage ipv6 address strings */
 467         for (i = 0; i < IPADDR_GARBAGE_ADDR6_STRS_SIZE; i++) {
 468
 469                 cmdline_ipaddr_t tmp = {.addr = IPv6_GARBAGE_ADDR};
 470
 471                 /* test each valid string against different flags */
 472                 for (flags = 1; flags < 0x8; flags++) {
 473
 474                         /* skip bad flag */
 475                         if (flags == CMDLINE_IPADDR_NETWORK)
 476                                 continue;
 477
 478                         /* clear out everything */
 479                         memset(buf, 0, sizeof(buf));
 480                         memset(&result, 0, sizeof(result));
 481                         memset(&token, 0, sizeof(token));
 482
 483                         token.ipaddr_data.flags = flags;
 484
 485                         cmdline_get_help_ipaddr((cmdline_parse_token_hdr_t*)&token,
 486                                                         buf, sizeof(buf));
 487
 488                         ret = cmdline_parse_ipaddr((cmdline_parse_token_hdr_t*)&token,
 489                                 ipaddr_garbage_addr6_strs[i], (void*)&result,
 490                                 sizeof(result));
 491
 492                         /* if should have passed, or should have failed */
 493                         if ((ret < 0) ==
 494                                         (can_parse_addr(CMDLINE_IPADDR_V6, flags))) {
 495                                 printf("Error: unexpected behavior when parsing %s as %s!\n",
 496                                                 ipaddr_garbage_addr6_strs[i], buf);
 497                                 return -1;
 498                         }
 499                         if (ret != -1 &&
 500                                         memcmp(&result.addr.ipv6, &tmp.addr.ipv6, sizeof(struct in6_addr))) {
 501                                 printf("Error: result mismatch when parsing %s as %s!\n",
 502                                                 ipaddr_garbage_addr6_strs[i], buf);
 503                                 return -1;
 504                         }
 505                 }
 506         }
 507
 508
 509         /* test garbage ipv4 network strings */
 510         for (i = 0; i < IPADDR_GARBAGE_NETWORK4_STRS_SIZE; i++) {
 511
 512                 struct in_addr tmp = IPv4_GARBAGE_ADDR;
 513
 514                 /* test each valid string against different flags */
 515                 for (flags = 1; flags < 0x8; flags++) {
 516
 517                         /* skip bad flag */
 518                         if (flags == CMDLINE_IPADDR_NETWORK)
 519                                 continue;
 520
 521                         /* clear out everything */
 522                         memset(buf, 0, sizeof(buf));
 523                         memset(&result, 0, sizeof(result));
 524                         memset(&token, 0, sizeof(token));
 525
 526                         token.ipaddr_data.flags = flags;
 527
 528                         cmdline_get_help_ipaddr((cmdline_parse_token_hdr_t*)&token,
 529                                                         buf, sizeof(buf));
 530
 531                         ret = cmdline_parse_ipaddr((cmdline_parse_token_hdr_t*)&token,
 532                                 ipaddr_garbage_network4_strs[i], (void*)&result,
 533                                 sizeof(result));
 534
 535                         /* if should have passed, or should have failed */
 536                         if ((ret < 0) ==
 537                                         (can_parse_addr(CMDLINE_IPADDR_V4 | CMDLINE_IPADDR_NETWORK, flags))) {
 538                                 printf("Error: unexpected behavior when parsing %s as %s!\n",
 539                                                 ipaddr_garbage_network4_strs[i], buf);
 540                                 return -1;
 541                         }
 542                         if (ret != -1 &&
 543                                         memcmp(&result.addr.ipv4, &tmp, sizeof(tmp))) {
 544                                 printf("Error: result mismatch when parsing %s as %s!\n",
 545                                                 ipaddr_garbage_network4_strs[i], buf);
 546                                 return -1;
 547                         }
 548                 }
 549         }
 550
 551         /* test garbage ipv6 address strings */
 552         for (i = 0; i < IPADDR_GARBAGE_NETWORK6_STRS_SIZE; i++) {
 553
 554                 cmdline_ipaddr_t tmp = {.addr = IPv6_GARBAGE_ADDR};
 555
 556                 /* test each valid string against different flags */
 557                 for (flags = 1; flags < 0x8; flags++) {
 558
 559                         /* skip bad flag */
 560                         if (flags == CMDLINE_IPADDR_NETWORK)
 561                                 continue;
 562
 563                         /* clear out everything */
 564                         memset(buf, 0, sizeof(buf));
 565                         memset(&result, 0, sizeof(result));
 566                         memset(&token, 0, sizeof(token));
 567
 568                         token.ipaddr_data.flags = flags;
 569
 570                         cmdline_get_help_ipaddr((cmdline_parse_token_hdr_t*)&token,
 571                                                         buf, sizeof(buf));
 572
 573                         ret = cmdline_parse_ipaddr((cmdline_parse_token_hdr_t*)&token,
 574                                 ipaddr_garbage_network6_strs[i], (void*)&result,
 575                                 sizeof(result));
 576
 577                         /* if should have passed, or should have failed */
 578                         if ((ret < 0) ==
 579                                         (can_parse_addr(CMDLINE_IPADDR_V6 | CMDLINE_IPADDR_NETWORK, flags))) {
 580                                 printf("Error: unexpected behavior when parsing %s as %s!\n",
 581                                                 ipaddr_garbage_network6_strs[i], buf);
 582                                 return -1;
 583                         }
 584                         if (ret != -1 &&
 585                                         memcmp(&result.addr.ipv6, &tmp.addr.ipv6, sizeof(struct in6_addr))) {
 586                                 printf("Error: result mismatch when parsing %s as %s!\n",
 587                                                 ipaddr_garbage_network6_strs[i], buf);
 588                                 return -1;
 589                         }
 590                 }
 591         }
 592
 593         return 0;
 594 }
 595
 596 int
 597 test_parse_ipaddr_invalid_data(void)
 598 {
 599         cmdline_parse_token_ipaddr_t token;
 600         char buf[CMDLINE_TEST_BUFSIZE];
 601         cmdline_ipaddr_t result;
 602         unsigned i;
 603         uint8_t flags;
 604         int ret;
 605
 606         memset(&result, 0, sizeof(result));
 607
 608         /* test invalid strings */
 609         for (i = 0; i < IPADDR_INVALID_STRS_SIZE; i++) {
 610
 611                 /* test each valid string against different flags */
 612                 for (flags = 1; flags < 0x8; flags++) {
 613
 614                         /* skip bad flag */
 615                         if (flags == CMDLINE_IPADDR_NETWORK)
 616                                 continue;
 617
 618                         /* clear out everything */
 619                         memset(buf, 0, sizeof(buf));
 620                         memset(&token, 0, sizeof(token));
 621
 622                         token.ipaddr_data.flags = flags;
 623
 624                         cmdline_get_help_ipaddr((cmdline_parse_token_hdr_t*)&token,
 625                                         buf, sizeof(buf));
 626
 627                         ret = cmdline_parse_ipaddr((cmdline_parse_token_hdr_t*)&token,
 628                                 ipaddr_invalid_strs[i], (void*)&result,
 629                                 sizeof(result));
 630
 631                         if (ret != -1) {
 632                                 printf("Error: parsing %s as %s succeeded!\n",
 633                                                 ipaddr_invalid_strs[i], buf);
 634                                 printf("Parsed result: ");
 635                                 dump_addr(result);
 636                                 return -1;
 637                         }
 638                 }
 639         }
 640
 641         return 0;
 642 }
 643
 644 int
 645 test_parse_ipaddr_invalid_param(void)
 646 {
 647         cmdline_parse_token_ipaddr_t token;
 648         char buf[CMDLINE_TEST_BUFSIZE];
 649         cmdline_ipaddr_t result;
 650
 651         snprintf(buf, sizeof(buf), "1.2.3.4");
 652         token.ipaddr_data.flags = CMDLINE_IPADDR_V4;
 653
 654         /* null token */
 655         if (cmdline_parse_ipaddr(NULL, buf, (void*)&result,
 656                         sizeof(result)) != -1) {
 657                 printf("Error: parser accepted invalid parameters!\n");
 658                 return -1;
 659         }
 660         /* null buffer */
 661         if (cmdline_parse_ipaddr((cmdline_parse_token_hdr_t*)&token,
 662                         NULL, (void*)&result, sizeof(result)) != -1) {
 663                 printf("Error: parser accepted invalid parameters!\n");
 664                 return -1;
 665         }
 666         /* empty buffer */
 667         if (cmdline_parse_ipaddr((cmdline_parse_token_hdr_t*)&token,
 668                         "", (void*)&result, sizeof(result)) != -1) {
 669                 printf("Error: parser accepted invalid parameters!\n");
 670                 return -1;
 671         }
 672         /* null result */
 673         if (cmdline_parse_ipaddr((cmdline_parse_token_hdr_t*)&token,
 674                         buf, NULL, 0) == -1) {
 675                 printf("Error: parser rejected null result!\n");
 676                 return -1;
 677         }
 678
 679         /* null token */
 680         if (cmdline_get_help_ipaddr(NULL, buf, 0) != -1) {
 681                 printf("Error: help accepted invalid parameters!\n");
 682                 return -1;
 683         }
 684         /* null buffer */
 685         if (cmdline_get_help_ipaddr((cmdline_parse_token_hdr_t*)&token,
 686                         NULL, 0) != -1) {
 687                 printf("Error: help accepted invalid parameters!\n");
 688                 return -1;
 689         }
 690         return 0;
 691 }