LCOV - code coverage report
Current view: top level - app/test - test_cmdline_ipaddr.c (source / functions) Hit Total Coverage
Test: Code coverage Lines: 89 130 68.5 %
Date: 2024-01-22 15:35:40 Functions: 4 5 80.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 90 116 77.6 %

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

Generated by: LCOV version 1.14