LCOV - code coverage report
Current view: top level - tests - catch_ipv6.cpp (source / functions) Hit Total Coverage
Test: coverage.info Lines: 1000 1015 98.5 %
Date: 2022-01-30 17:24:05 Functions: 9 9 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : // Copyright (c) 2011-2021  Made to Order Software Corp.  All Rights Reserved
       2             : //
       3             : // Project: https://snapwebsites.org/project/libaddr
       4             : //
       5             : // Permission is hereby granted, free of charge, to any
       6             : // person obtaining a copy of this software and
       7             : // associated documentation files (the "Software"), to
       8             : // deal in the Software without restriction, including
       9             : // without limitation the rights to use, copy, modify,
      10             : // merge, publish, distribute, sublicense, and/or sell
      11             : // copies of the Software, and to permit persons to whom
      12             : // the Software is furnished to do so, subject to the
      13             : // following conditions:
      14             : //
      15             : // The above copyright notice and this permission notice
      16             : // shall be included in all copies or substantial
      17             : // portions of the Software.
      18             : //
      19             : // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
      20             : // ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
      21             : // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
      22             : // FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO
      23             : // EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
      24             : // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
      25             : // WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
      26             : // ARISING FROM, OUT OF OR IN CONNECTION WITH THE
      27             : // SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
      28             : // SOFTWARE.
      29             : 
      30             : 
      31             : /** \file
      32             :  * \brief Test the IPv6 interface.
      33             :  *
      34             :  * These test verify that the IPv6 side of things function as expected.
      35             :  *
      36             :  * Note that some of the tests between the IPv4 and IPv6 overlap. Here
      37             :  * you mainly find the IPv6 side of things.
      38             :  *
      39             :  * Also, the IPv6 tests include a certain number of default/global
      40             :  * tests because internally the addr class implements an IPv6 object.
      41             :  */
      42             : 
      43             : // self
      44             : //
      45             : #include    "catch_main.h"
      46             : 
      47             : 
      48             : // addr lib
      49             : //
      50             : #include    <libaddr/iface.h>
      51             : 
      52             : 
      53             : // last include
      54             : //
      55             : #include    <snapdev/poison.h>
      56             : 
      57             : 
      58             : 
      59             : 
      60             : /** \brief Details used by the addr class implementation.
      61             :  *
      62             :  * We have a function to check whether an address is part of
      63             :  * the interfaces of your computer. This check requires the
      64             :  * use of a `struct ifaddrs` and as such it requires to
      65             :  * delete that structure. We define a deleter for that
      66             :  * strucure here.
      67             :  */
      68             : namespace
      69             : {
      70             : 
      71             : /** \brief Close a socket.
      72             :  *
      73             :  * This deleter is used to make sure all the sockets get closed on exit.
      74             :  *
      75             :  * \param[in] s  The socket to close.
      76             :  */
      77           3 : void socket_deleter(int * s)
      78             : {
      79           3 :     close(*s);
      80           3 : }
      81             : 
      82             : 
      83             : }
      84             : // no name namespace
      85             : 
      86             : 
      87             : 
      88          16 : CATCH_TEST_CASE( "ipv6::invalid_input", "[ipv6]" )
      89             : {
      90          28 :     CATCH_GIVEN("addr()")
      91             :     {
      92           1 :         addr::addr a;
      93             : 
      94           2 :         CATCH_SECTION("set IPv6 with an invalid family")
      95             :         {
      96           1 :             struct sockaddr_in6 in6 = sockaddr_in6();
      97           0 :             do
      98             :             {
      99           1 :                 in6.sin6_family = rand();
     100             :             }
     101           1 :             while(in6.sin6_family == AF_INET6);
     102           1 :             in6.sin6_port = rand();
     103           9 :             for(int idx(0); idx < 8; ++idx)
     104             :             {
     105           8 :                 in6.sin6_addr.s6_addr16[idx] = rand();
     106             :             }
     107           1 :             CATCH_REQUIRE_THROWS_AS(a.set_ipv6(in6), addr::addr_invalid_argument);
     108           1 :             CATCH_REQUIRE_THROWS_AS(addr::addr(in6), addr::addr_invalid_argument);
     109             :         }
     110             :     }
     111             : 
     112          28 :     CATCH_GIVEN("addr_parser() with IPv6 addresses")
     113             :     {
     114           6 :         CATCH_SECTION("bad address")
     115             :         {
     116           2 :             addr::addr_parser p;
     117           2 :             addr::addr_range::vector_t ips(p.parse("[{bad-ip}]"));
     118           1 :             CATCH_REQUIRE(p.has_errors());
     119           1 :             CATCH_REQUIRE(p.error_count() == 1);
     120           1 :             CATCH_REQUIRE(p.error_messages() == "Invalid address in \"{bad-ip}\" error -2 -- Name or service not known (errno: 2 -- No such file or directory).\n");
     121           1 :             CATCH_REQUIRE(ips.size() == 0);
     122             :         }
     123             : 
     124           6 :         CATCH_SECTION("missing ']'")
     125             :         {
     126           2 :             addr::addr_parser p;
     127           2 :             addr::addr_range::vector_t ips(p.parse("[1:2:3:4:5:6:7"));
     128           1 :             CATCH_REQUIRE(p.has_errors());
     129           1 :             CATCH_REQUIRE(p.error_count() == 1);
     130           1 :             CATCH_REQUIRE(p.error_messages() == "IPv6 is missing the ']' ([1:2:3:4:5:6:7).\n");
     131           1 :             CATCH_REQUIRE(ips.size() == 0);
     132             :         }
     133             : 
     134           6 :         CATCH_SECTION("required address")
     135             :         {
     136           2 :             addr::addr_parser p;
     137           1 :             p.set_protocol(IPPROTO_TCP);
     138           1 :             p.set_allow(addr::addr_parser::flag_t::REQUIRED_ADDRESS, true);
     139           2 :             addr::addr_range::vector_t ips(p.parse("[]"));
     140           1 :             CATCH_REQUIRE(p.has_errors());
     141           1 :             CATCH_REQUIRE(p.error_count() == 1);
     142           1 :             CATCH_REQUIRE(p.error_messages() == "Required address is missing.\n");
     143           1 :             CATCH_REQUIRE(ips.size() == 0);
     144             :         }
     145             :     }
     146             : 
     147          28 :     CATCH_GIVEN("addr_parser() with IPv4 ports")
     148             :     {
     149           4 :         CATCH_SECTION("required port")
     150             :         {
     151             :             // optional + required -> required
     152             :             {
     153           2 :                 addr::addr_parser p;
     154           1 :                 p.set_protocol(IPPROTO_TCP);
     155           1 :                 p.set_allow(addr::addr_parser::flag_t::REQUIRED_PORT, true);
     156           2 :                 addr::addr_range::vector_t ips(p.parse("[1:2:3:4:5:6:7:8]"));
     157           1 :                 CATCH_REQUIRE(p.has_errors());
     158           1 :                 CATCH_REQUIRE(p.error_count() == 1);
     159           1 :                 CATCH_REQUIRE(p.error_messages() == "Required port is missing.\n");
     160           1 :                 CATCH_REQUIRE(ips.size() == 0);
     161             :             }
     162             : 
     163             :             // only required -> required just the same
     164             :             {
     165           2 :                 addr::addr_parser p;
     166           1 :                 p.set_protocol(IPPROTO_TCP);
     167           1 :                 p.set_allow(addr::addr_parser::flag_t::PORT, false);
     168           1 :                 p.set_allow(addr::addr_parser::flag_t::REQUIRED_PORT, true);
     169           2 :                 addr::addr_range::vector_t ips(p.parse("[1:2:3:4:5:6:7:8]"));
     170           1 :                 CATCH_REQUIRE(p.has_errors());
     171           1 :                 CATCH_REQUIRE(p.error_count() == 1);
     172           1 :                 CATCH_REQUIRE(p.error_messages() == "Required port is missing.\n");
     173           1 :                 CATCH_REQUIRE(ips.size() == 0);
     174             :             }
     175             :         }
     176             : 
     177           4 :         CATCH_SECTION("port not allowed")
     178             :         {
     179             :             {
     180           2 :                 addr::addr_parser p;
     181           1 :                 p.set_protocol(IPPROTO_TCP);
     182           1 :                 p.set_allow(addr::addr_parser::flag_t::PORT, false);
     183           2 :                 addr::addr_range::vector_t ips(p.parse("[1:2:3:4:5:6:7:8]:123"));
     184           1 :                 CATCH_REQUIRE(p.has_errors());
     185           1 :                 CATCH_REQUIRE(p.error_count() == 1);
     186           1 :                 CATCH_REQUIRE(p.error_messages() == "Port not allowed ([1:2:3:4:5:6:7:8]:123).\n");
     187           1 :                 CATCH_REQUIRE(ips.size() == 0);
     188             :             }
     189             : 
     190             :             {
     191           2 :                 addr::addr_parser p;
     192           1 :                 p.set_protocol(IPPROTO_TCP);
     193           1 :                 p.set_allow(addr::addr_parser::flag_t::PORT, false);
     194           2 :                 addr::addr_range::vector_t ips(p.parse("1:2:3:4:5:6:7:8:123.5"));
     195           1 :                 CATCH_REQUIRE(p.has_errors());
     196           1 :                 CATCH_REQUIRE(p.error_count() == 1);
     197           1 :                 CATCH_REQUIRE(p.error_messages() == "Port not allowed (1:2:3:4:5:6:7:8:123.5).\n");
     198           1 :                 CATCH_REQUIRE(ips.size() == 0);
     199             :             }
     200             :         }
     201             :     }
     202             : 
     203          28 :     CATCH_GIVEN("addr_parser() with invalid masks")
     204             :     {
     205          16 :         CATCH_SECTION("really large numbers (over 1000)")
     206             :         {
     207           6 :             for(int idx(0); idx < 5; ++idx)
     208             :             {
     209           5 :                 int const proto(rand() & 1 ? IPPROTO_TCP : IPPROTO_UDP);
     210           5 :                 int const port(rand() & 0xFFFF);
     211           5 :                 int const mask((rand() & 0xFF) + 1001);
     212          10 :                 addr::addr_parser p;
     213           5 :                 p.set_protocol(proto);
     214           5 :                 p.set_allow(addr::addr_parser::flag_t::MASK, true);
     215          10 :                 addr::addr_range::vector_t ips(p.parse("[1:2:3:4:5:6:7:8]:" + std::to_string(port) + "/" + std::to_string(mask)));
     216           5 :                 CATCH_REQUIRE(p.has_errors());
     217           5 :                 CATCH_REQUIRE(p.error_count() == 1);
     218           5 :                 CATCH_REQUIRE(p.error_messages() == "Mask number too large (" + std::to_string(mask) + ", expected a maximum of 128).\n");
     219           5 :                 CATCH_REQUIRE(ips.size() == 0);
     220             :             }
     221             : 
     222             :             // in case the number is between square brackets it looks like
     223             :             // an IPv4 to getaddrinfo() so we get a different error...
     224             :             // (i.e. the '[' is not a digit so we do not get the "too large"
     225             :             // error...)
     226             :             //
     227           6 :             for(int idx(0); idx < 5; ++idx)
     228             :             {
     229           5 :                 int const proto(rand() & 1 ? IPPROTO_TCP : IPPROTO_UDP);
     230           5 :                 int const port(rand() & 0xFFFF);
     231           5 :                 int const mask((rand() & 0xFF) + 1001);
     232          10 :                 addr::addr_parser p;
     233           5 :                 p.set_protocol(proto);
     234           5 :                 p.set_allow(addr::addr_parser::flag_t::MASK, true);
     235          10 :                 addr::addr_range::vector_t ips(p.parse("[1:2:3:4:5:6:7:8]:" + std::to_string(port) + "/[" + std::to_string(mask) + "]"));
     236           5 :                 CATCH_REQUIRE(p.has_errors());
     237           5 :                 CATCH_REQUIRE(p.error_count() == 1);
     238           5 :                 CATCH_REQUIRE(p.error_messages() == "Incompatible address between the address and mask address (first was an IPv6 second an IPv4).\n");
     239           5 :                 CATCH_REQUIRE(ips.size() == 0);
     240             :             }
     241             : 
     242             :             // an empty address with a mask too large gets us to another place
     243             :             //
     244           6 :             for(int idx(0); idx < 5; ++idx)
     245             :             {
     246           5 :                 int const proto(rand() & 1 ? IPPROTO_TCP : IPPROTO_UDP);
     247           5 :                 int const port(rand() & 0xFFFF);
     248           5 :                 int const mask((rand() & 0xFF) + 1001);
     249          10 :                 addr::addr_parser p;
     250           5 :                 p.set_protocol(proto);
     251           5 :                 p.set_allow(addr::addr_parser::flag_t::MASK, true);
     252          10 :                 addr::addr_range::vector_t ips(p.parse(":" + std::to_string(port) + "/" + std::to_string(mask)));
     253           5 :                 CATCH_REQUIRE(p.has_errors());
     254           5 :                 CATCH_REQUIRE(p.error_count() == 1);
     255           5 :                 CATCH_REQUIRE(p.error_messages() == "Mask number too large (" + std::to_string(mask) + ", expected a maximum of 128).\n");
     256           5 :                 CATCH_REQUIRE(ips.size() == 0);
     257             :             }
     258             : 
     259             :             // an empty address with a mask too large gets us to another place
     260             :             //
     261           6 :             for(int idx(0); idx < 5; ++idx)
     262             :             {
     263           5 :                 int const proto(rand() & 1 ? IPPROTO_TCP : IPPROTO_UDP);
     264           5 :                 int const port(rand() & 0xFFFF);
     265           5 :                 int const mask((rand() & 0xFF));
     266          10 :                 addr::addr_parser p;
     267           5 :                 p.set_protocol(proto);
     268           5 :                 p.set_allow(addr::addr_parser::flag_t::MASK, true);
     269          10 :                 addr::addr_range::vector_t ips(p.parse(":" + std::to_string(port) + "/" + std::to_string(mask) + "q"));
     270           5 :                 CATCH_REQUIRE(p.has_errors());
     271           5 :                 CATCH_REQUIRE(p.error_count() == 1);
     272           5 :                 CATCH_REQUIRE(p.error_messages() == "Invalid mask in \"/" + std::to_string(mask) + "q\", error -2 -- Name or service not known (errno: 0 -- Success).\n");
     273           5 :                 CATCH_REQUIRE(ips.size() == 0);
     274             :             }
     275             :         }
     276             : 
     277          16 :         CATCH_SECTION("ipv6 mask is limited between 0 and 128")
     278             :         {
     279           6 :             for(int idx(0); idx < 5; ++idx)
     280             :             {
     281           5 :                 int const proto(rand() & 1 ? IPPROTO_TCP : IPPROTO_UDP);
     282           5 :                 int const port(rand() & 0xFFFF);
     283           5 :                 int const mask((rand() & 0xFF) + 129);
     284          10 :                 addr::addr_parser p;
     285           5 :                 p.set_protocol(proto);
     286           5 :                 p.set_allow(addr::addr_parser::flag_t::MASK, true);
     287          10 :                 addr::addr_range::vector_t ips(p.parse("[1:2:3:4:5:6:7:8]:" + std::to_string(port) + "/" + std::to_string(mask)));
     288           5 :                 CATCH_REQUIRE(p.has_errors());
     289           5 :                 CATCH_REQUIRE(p.error_count() == 1);
     290           5 :                 CATCH_REQUIRE(p.error_messages() == "Unsupported mask size (" + std::to_string(mask) + ", expected 128 at the most for an IPv6).\n");
     291           5 :                 CATCH_REQUIRE(ips.size() == 0);
     292             :             }
     293             :         }
     294             : 
     295          16 :         CATCH_SECTION("ipv6 mask cannot use name")
     296             :         {
     297           6 :             for(int idx(0); idx < 5; ++idx)
     298             :             {
     299           5 :                 int const proto(rand() & 1 ? IPPROTO_TCP : IPPROTO_UDP);
     300           5 :                 int const port(rand() & 0xFFFF);
     301          10 :                 addr::addr_parser p;
     302           5 :                 p.set_protocol(proto);
     303           5 :                 p.set_allow(addr::addr_parser::flag_t::MASK, true);
     304          10 :                 addr::addr_range::vector_t ips(p.parse("[1:2:3:4:5:6:7:8]:" + std::to_string(port) + "/[localhost]"));
     305           5 :                 CATCH_REQUIRE(p.has_errors());
     306           5 :                 CATCH_REQUIRE(p.error_count() == 1);
     307           5 :                 CATCH_REQUIRE(p.error_messages() == "Invalid mask in \"/[localhost]\", error -2 -- Name or service not known (errno: 0 -- Success).\n");
     308           5 :                 CATCH_REQUIRE(ips.size() == 0);
     309             :             }
     310             :         }
     311             : 
     312          16 :         CATCH_SECTION("ipv6 mask must be between '[...]'")
     313             :         {
     314           1 :             int const proto(rand() & 1 ? IPPROTO_TCP : IPPROTO_UDP);
     315           1 :             int const port(rand() & 0xFFFF);
     316           2 :             addr::addr_parser p;
     317           1 :             p.set_protocol(proto);
     318           1 :             p.set_allow(addr::addr_parser::flag_t::MASK, true);
     319           2 :             addr::addr_range::vector_t ips(p.parse("[1:2:3:4:5:6:7:8]:" + std::to_string(port) + "/::3"));
     320           1 :             CATCH_REQUIRE(p.has_errors());
     321           1 :             CATCH_REQUIRE(p.error_count() == 1);
     322           1 :             CATCH_REQUIRE(p.error_messages() == "The address uses the IPv6 syntax, the mask cannot use IPv4.\n");
     323           1 :             CATCH_REQUIRE(ips.size() == 0);
     324             :         }
     325             : 
     326          16 :         CATCH_SECTION("ipv6 mask missing the ']'")
     327             :         {
     328           1 :             int const proto(rand() & 1 ? IPPROTO_TCP : IPPROTO_UDP);
     329           1 :             int const port(rand() & 0xFFFF);
     330           2 :             addr::addr_parser p;
     331           1 :             p.set_protocol(proto);
     332           1 :             p.set_allow(addr::addr_parser::flag_t::MASK, true);
     333           2 :             addr::addr_range::vector_t ips(p.parse("[1:2:3:4:5:6:7:8]:" + std::to_string(port) + "/[::3"));
     334           1 :             CATCH_REQUIRE(p.has_errors());
     335           1 :             CATCH_REQUIRE(p.error_count() == 1);
     336           1 :             CATCH_REQUIRE(p.error_messages() == "The IPv6 mask is missing the ']' ([::3).\n");
     337           1 :             CATCH_REQUIRE(ips.size() == 0);
     338             :         }
     339             : 
     340          16 :         CATCH_SECTION("ipv6 mask with an ipv4 in the '[...]'")
     341             :         {
     342           1 :             int const proto(rand() & 1 ? IPPROTO_TCP : IPPROTO_UDP);
     343           1 :             int const port(rand() & 0xFFFF);
     344           2 :             addr::addr_parser p;
     345           1 :             p.set_protocol(proto);
     346           1 :             p.set_allow(addr::addr_parser::flag_t::MASK, true);
     347           2 :             addr::addr_range::vector_t ips(p.parse("[1:2:3:4:5:6:7:8]:" + std::to_string(port) + "/[1.2.3.4]"));
     348           1 :             CATCH_REQUIRE(p.has_errors());
     349           1 :             CATCH_REQUIRE(p.error_count() == 1);
     350           1 :             CATCH_REQUIRE(p.error_messages() == "Incompatible address between the address and mask address (first was an IPv6 second an IPv4).\n");
     351           1 :             CATCH_REQUIRE(ips.size() == 0);
     352             :         }
     353             : 
     354          16 :         CATCH_SECTION("verify default mask")
     355             :         {
     356           2 :             addr::addr_parser p;
     357             : 
     358           1 :             CATCH_REQUIRE_THROWS_AS(p.set_default_address("[4:5:4:5:7:8:7:8"), addr::addr_invalid_argument);
     359           1 :             CATCH_REQUIRE(p.get_default_address4() == "");
     360           1 :             CATCH_REQUIRE(p.get_default_address6() == "");
     361             : 
     362           1 :             p.set_default_address("[1:7:1:7:1:7:1:7]");
     363           1 :             CATCH_REQUIRE(p.get_default_address4() == "");
     364           1 :             CATCH_REQUIRE(p.get_default_address6() == "1:7:1:7:1:7:1:7");
     365             : 
     366           1 :             CATCH_REQUIRE_THROWS_AS(p.set_default_address("[9:5:9:5:9:8:9:8"), addr::addr_invalid_argument);
     367           1 :             CATCH_REQUIRE(p.get_default_address4() == "");
     368           1 :             CATCH_REQUIRE(p.get_default_address6() == "1:7:1:7:1:7:1:7");
     369             : 
     370           1 :             p.set_default_address("12.55.1.9");
     371           1 :             CATCH_REQUIRE(p.get_default_address4() == "12.55.1.9");
     372           1 :             CATCH_REQUIRE(p.get_default_address6() == "1:7:1:7:1:7:1:7");
     373             : 
     374           1 :             CATCH_REQUIRE_THROWS_AS(p.set_default_address("[9:f00f:9:e00e:9:d00d:9:c00c"), addr::addr_invalid_argument);
     375           1 :             CATCH_REQUIRE(p.get_default_address4() == "12.55.1.9");
     376           1 :             CATCH_REQUIRE(p.get_default_address6() == "1:7:1:7:1:7:1:7");
     377             : 
     378           1 :             p.set_default_address("");
     379           1 :             CATCH_REQUIRE(p.get_default_address4() == "");
     380           1 :             CATCH_REQUIRE(p.get_default_address6() == "");
     381             :         }
     382             : 
     383          16 :         CATCH_SECTION("verify default mask")
     384             :         {
     385           2 :             addr::addr_parser p;
     386             : 
     387           1 :             CATCH_REQUIRE_THROWS_AS(p.set_default_mask("[4:5:4:5:7:8:7:8"), addr::addr_invalid_argument);
     388           1 :             CATCH_REQUIRE(p.get_default_mask4() == "");
     389           1 :             CATCH_REQUIRE(p.get_default_mask6() == "");
     390             : 
     391           1 :             p.set_default_mask("[1:7:1:7:1:7:1:7]");
     392           1 :             CATCH_REQUIRE(p.get_default_mask4() == "");
     393           1 :             CATCH_REQUIRE(p.get_default_mask6() == "1:7:1:7:1:7:1:7");
     394             : 
     395           1 :             CATCH_REQUIRE_THROWS_AS(p.set_default_mask("[9:5:9:5:9:8:9:8"), addr::addr_invalid_argument);
     396           1 :             CATCH_REQUIRE(p.get_default_mask4() == "");
     397           1 :             CATCH_REQUIRE(p.get_default_mask6() == "1:7:1:7:1:7:1:7");
     398             : 
     399           1 :             p.set_default_mask("12.55.1.9");
     400           1 :             CATCH_REQUIRE(p.get_default_mask4() == "12.55.1.9");
     401           1 :             CATCH_REQUIRE(p.get_default_mask6() == "1:7:1:7:1:7:1:7");
     402             : 
     403           1 :             CATCH_REQUIRE_THROWS_AS(p.set_default_mask("[9:f00f:9:e00e:9:d00d:9:c00c"), addr::addr_invalid_argument);
     404           1 :             CATCH_REQUIRE(p.get_default_mask4() == "12.55.1.9");
     405           1 :             CATCH_REQUIRE(p.get_default_mask6() == "1:7:1:7:1:7:1:7");
     406             : 
     407           1 :             p.set_default_mask("");
     408           1 :             CATCH_REQUIRE(p.get_default_mask4() == "");
     409           1 :             CATCH_REQUIRE(p.get_default_mask6() == "");
     410             :         }
     411             :     }
     412          14 : }
     413             : 
     414             : 
     415          10 : CATCH_TEST_CASE( "ipv6::address", "[ipv6]" )
     416             : {
     417          16 :     CATCH_GIVEN("addr() with an IPv6")
     418             :     {
     419           3 :         addr::addr a;
     420             : 
     421           6 :         CATCH_SECTION("set_ipv6() / get_ipv6()")
     422             :         {
     423          11 :             for(int idx(0); idx < 10; ++idx)
     424             :             {
     425          10 :                 struct sockaddr_in6 in6 = sockaddr_in6();
     426          10 :                 in6.sin6_family = AF_INET6;
     427          10 :                 in6.sin6_port = htons(rand());
     428          10 :                 in6.sin6_addr.s6_addr16[0] = rand();
     429          10 :                 in6.sin6_addr.s6_addr16[1] = rand();
     430          10 :                 in6.sin6_addr.s6_addr16[2] = rand();
     431          10 :                 in6.sin6_addr.s6_addr16[3] = rand();
     432          10 :                 in6.sin6_addr.s6_addr16[4] = rand();
     433          10 :                 in6.sin6_addr.s6_addr16[5] = rand();
     434          10 :                 in6.sin6_addr.s6_addr16[6] = rand();
     435          10 :                 in6.sin6_addr.s6_addr16[7] = rand();
     436             : 
     437             :                 // verify network type
     438             :                 //
     439          10 :                 a.set_ipv6(in6);
     440             : 
     441             :                 // test constructor
     442             :                 //
     443          10 :                 addr::addr b(in6);
     444          10 :                 struct sockaddr_in6 out6;
     445          10 :                 b.get_ipv6(out6);
     446          10 :                 CATCH_REQUIRE(memcmp(&out6, &in6, sizeof(struct sockaddr_in)) == 0);
     447             : 
     448             :                 // test set
     449             :                 //
     450          10 :                 a.set_ipv6(in6);
     451          10 :                 a.get_ipv6(out6);
     452          10 :                 CATCH_REQUIRE(memcmp(&out6, &in6, sizeof(struct sockaddr_in)) == 0);
     453             :             }
     454             :         }
     455             : 
     456           6 :         CATCH_SECTION("set_ipv6() check to_ipv6_string()")
     457             :         {
     458          11 :             for(int idx(0); idx < 10; ++idx)
     459             :             {
     460          10 :                 struct sockaddr_in6 in6 = sockaddr_in6();
     461          10 :                 in6.sin6_family = AF_INET6;
     462          10 :                 in6.sin6_port = htons(rand());
     463          90 :                 for(int j(0); j < 8; ++j)
     464             :                 {
     465             :                     // avoid any zeroes so that way we do not have
     466             :                     // to handle the "::" syntax
     467           0 :                     do
     468             :                     {
     469          80 :                         in6.sin6_addr.s6_addr16[j] = rand();
     470             :                     }
     471          80 :                     while(in6.sin6_addr.s6_addr16[j] == 0);
     472             :                 }
     473             : 
     474          20 :                 std::stringstream ip_buf;
     475          10 :                 ip_buf << std::hex
     476          10 :                        << ntohs(in6.sin6_addr.s6_addr16[0])
     477          10 :                        << ":"
     478          10 :                        << ntohs(in6.sin6_addr.s6_addr16[1])
     479          10 :                        << ":"
     480          10 :                        << ntohs(in6.sin6_addr.s6_addr16[2])
     481          10 :                        << ":"
     482          10 :                        << ntohs(in6.sin6_addr.s6_addr16[3])
     483          10 :                        << ":"
     484          10 :                        << ntohs(in6.sin6_addr.s6_addr16[4])
     485          10 :                        << ":"
     486          10 :                        << ntohs(in6.sin6_addr.s6_addr16[5])
     487          10 :                        << ":"
     488          10 :                        << ntohs(in6.sin6_addr.s6_addr16[6])
     489          10 :                        << ":"
     490          10 :                        << ntohs(in6.sin6_addr.s6_addr16[7]);
     491          20 :                 std::string const ip(ip_buf.str());
     492             : 
     493          20 :                 std::string port_str(std::to_string(static_cast<int>(htons(in6.sin6_port))));
     494             : 
     495             :                 // check IPv6 as a string
     496             :                 //
     497          10 :                 a.set_ipv6(in6);
     498          10 :                 CATCH_REQUIRE(a.to_ipv6_string(addr::addr::string_ip_t::STRING_IP_ONLY)          == ip);
     499          10 :                 CATCH_REQUIRE(a.to_ipv6_string(addr::addr::string_ip_t::STRING_IP_BRACKETS)      == "[" + ip + "]");
     500          10 :                 CATCH_REQUIRE(a.to_ipv6_string(addr::addr::string_ip_t::STRING_IP_PORT)          == "[" + ip + "]:" + port_str);
     501          10 :                 CATCH_REQUIRE(a.to_ipv6_string(addr::addr::string_ip_t::STRING_IP_MASK)          == ip + "/ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"); // will change to 128 at some point
     502          10 :                 CATCH_REQUIRE(a.to_ipv6_string(addr::addr::string_ip_t::STRING_IP_BRACKETS_MASK) == "[" + ip + "]/[ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff]");
     503          10 :                 CATCH_REQUIRE(a.to_ipv6_string(addr::addr::string_ip_t::STRING_IP_ALL)           == "[" + ip + "]:" + port_str + "/[ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff]");
     504             :             }
     505             :         }
     506             : 
     507           6 :         CATCH_SECTION("name of various IPs")
     508             :         {
     509           1 :             struct sockaddr_in6 in6 = sockaddr_in6();
     510           1 :             in6.sin6_family = AF_INET6;
     511           1 :             in6.sin6_port = htons(rand());
     512             : 
     513             :             // verify network type
     514             :             //
     515           1 :             a.set_ipv6(in6);
     516           1 :             CATCH_REQUIRE(a.get_name() == std::string()); // no name for "any" (TCP)
     517             : 
     518           1 :             a.set_protocol(IPPROTO_UDP);
     519           1 :             CATCH_REQUIRE(a.get_name() == std::string()); // no name for "any" (UDP)
     520             : 
     521           1 :             in6 = sockaddr_in6();
     522           1 :             in6.sin6_family = AF_INET6;
     523           1 :             in6.sin6_port = htons(rand());
     524           1 :             in6.sin6_addr.s6_addr16[7] = htons(1);
     525           1 :             a.set_ipv6(in6);
     526           1 :             char hostname[HOST_NAME_MAX + 1];
     527           1 :             hostname[HOST_NAME_MAX] = '\0';
     528           1 :             CATCH_REQUIRE(gethostname(hostname, sizeof(hostname)) == 0);
     529           1 :             CATCH_REQUIRE(hostname[0] != '\0');
     530           2 :             std::string localhost(a.get_name());
     531           1 :             bool const localhost_flag(localhost == hostname || localhost == "ip6-localhost");
     532           1 :             CATCH_REQUIRE(localhost_flag);
     533             : 
     534           1 :             CATCH_REQUIRE(addr::find_addr_interface(a, false) != nullptr);
     535             :         }
     536             :     }
     537             : 
     538          16 :     CATCH_GIVEN("addr_parser() with IPv6 addresses")
     539             :     {
     540           6 :         CATCH_SECTION("verify basics")
     541             :         {
     542           2 :             addr::addr_parser p;
     543           1 :             p.set_protocol(IPPROTO_TCP);
     544           2 :             addr::addr_range::vector_t ips(p.parse("[1:2:3:4:5:6:7:8]"));
     545           1 :             CATCH_REQUIRE_FALSE(p.has_errors());
     546           1 :             CATCH_REQUIRE(ips.size() == 1);
     547           1 :             addr::addr_range const & r(ips[0]);
     548           1 :             CATCH_REQUIRE(r.has_from());
     549           1 :             CATCH_REQUIRE_FALSE(r.has_to());
     550           1 :             CATCH_REQUIRE_FALSE(r.is_range());
     551           1 :             CATCH_REQUIRE_FALSE(r.is_empty());
     552           1 :             addr::addr f(r.get_from());
     553           1 :             CATCH_REQUIRE_FALSE(f.is_ipv4());
     554           1 :             CATCH_REQUIRE(f.to_ipv6_string(addr::addr::string_ip_t::STRING_IP_ONLY) == "1:2:3:4:5:6:7:8");
     555           1 :             CATCH_REQUIRE(f.to_ipv6_string(addr::addr::string_ip_t::STRING_IP_BRACKETS) == "[1:2:3:4:5:6:7:8]");
     556           1 :             CATCH_REQUIRE(f.to_ipv4or6_string(addr::addr::string_ip_t::STRING_IP_ONLY) == "1:2:3:4:5:6:7:8");
     557           1 :             CATCH_REQUIRE(f.get_port() == 0);
     558           1 :             CATCH_REQUIRE(f.get_protocol() == IPPROTO_TCP);
     559           1 :             CATCH_REQUIRE(f.get_network_type() == addr::addr::network_type_t::NETWORK_TYPE_PUBLIC);
     560           1 :             uint8_t mask[16] = {};
     561           1 :             f.get_mask(mask);
     562          17 :             for(int idx(0); idx < 16; ++idx)
     563             :             {
     564          16 :                 CATCH_REQUIRE(mask[idx] == 255);
     565             :             }
     566             :         }
     567             : 
     568           6 :         CATCH_SECTION("default address")
     569             :         {
     570           2 :             addr::addr_parser p;
     571           1 :             p.set_protocol(IPPROTO_TCP);
     572           1 :             p.set_default_address("5:5:5:5:5:5:5:5");
     573           2 :             addr::addr_range::vector_t ips(p.parse(""));
     574           1 :             CATCH_REQUIRE_FALSE(p.has_errors());
     575           1 :             CATCH_REQUIRE(ips.size() == 1);
     576           1 :             addr::addr_range const & r(ips[0]);
     577           1 :             CATCH_REQUIRE(r.has_from());
     578           1 :             CATCH_REQUIRE_FALSE(r.has_to());
     579           1 :             CATCH_REQUIRE_FALSE(r.is_range());
     580           1 :             CATCH_REQUIRE_FALSE(r.is_empty());
     581           1 :             addr::addr f(r.get_from());
     582           1 :             CATCH_REQUIRE_FALSE(f.is_ipv4());
     583           1 :             CATCH_REQUIRE(f.to_ipv6_string(addr::addr::string_ip_t::STRING_IP_ONLY) == "5:5:5:5:5:5:5:5");
     584           1 :             CATCH_REQUIRE(f.to_ipv6_string(addr::addr::string_ip_t::STRING_IP_BRACKETS) == "[5:5:5:5:5:5:5:5]");
     585           1 :             CATCH_REQUIRE(f.to_ipv4or6_string(addr::addr::string_ip_t::STRING_IP_ONLY) == "5:5:5:5:5:5:5:5");
     586           1 :             CATCH_REQUIRE(f.get_port() == 0);
     587           1 :             CATCH_REQUIRE(f.get_protocol() == IPPROTO_TCP);
     588           1 :             CATCH_REQUIRE(f.get_network_type() == addr::addr::network_type_t::NETWORK_TYPE_PUBLIC);
     589             :         }
     590             : 
     591           6 :         CATCH_SECTION("address, not port allowed")
     592             :         {
     593             :             // specific address with a default
     594             :             {
     595           2 :                 addr::addr_parser p;
     596           1 :                 p.set_allow(addr::addr_parser::flag_t::PORT, false);
     597           1 :                 p.set_protocol(IPPROTO_TCP);
     598           1 :                 p.set_default_address("8:7:6:5:4:3:2:1");
     599           2 :                 addr::addr_range::vector_t ips(p.parse("[9:9:9:9:4:3:2:1]"));
     600           1 :                 CATCH_REQUIRE_FALSE(p.has_errors());
     601           1 :                 CATCH_REQUIRE(ips.size() == 1);
     602           1 :                 addr::addr_range const & r(ips[0]);
     603           1 :                 CATCH_REQUIRE(r.has_from());
     604           1 :                 CATCH_REQUIRE_FALSE(r.has_to());
     605           1 :                 CATCH_REQUIRE_FALSE(r.is_range());
     606           1 :                 CATCH_REQUIRE_FALSE(r.is_empty());
     607           1 :                 addr::addr f(r.get_from());
     608           1 :                 CATCH_REQUIRE_FALSE(f.is_ipv4());
     609           1 :                 CATCH_REQUIRE(f.to_ipv6_string(addr::addr::string_ip_t::STRING_IP_ONLY) == "9:9:9:9:4:3:2:1");
     610           1 :                 CATCH_REQUIRE(f.to_ipv6_string(addr::addr::string_ip_t::STRING_IP_BRACKETS) == "[9:9:9:9:4:3:2:1]");
     611           1 :                 CATCH_REQUIRE(f.to_ipv4or6_string(addr::addr::string_ip_t::STRING_IP_ONLY) == "9:9:9:9:4:3:2:1");
     612           1 :                 CATCH_REQUIRE(f.get_port() == 0);
     613           1 :                 CATCH_REQUIRE(f.get_protocol() == IPPROTO_TCP);
     614           1 :                 CATCH_REQUIRE(f.get_network_type() == addr::addr::network_type_t::NETWORK_TYPE_PUBLIC);
     615             :             }
     616             : 
     617             :             // only a default address
     618             :             {
     619           2 :                 addr::addr_parser p;
     620           1 :                 p.set_allow(addr::addr_parser::flag_t::PORT, false);
     621           1 :                 p.set_protocol(IPPROTO_TCP);
     622           1 :                 p.set_default_address("5:1:6:2:7:3:8:4");
     623           2 :                 addr::addr_range::vector_t ips(p.parse(""));
     624           1 :                 CATCH_REQUIRE_FALSE(p.has_errors());
     625           1 :                 CATCH_REQUIRE(ips.size() == 1);
     626           1 :                 addr::addr_range const & r(ips[0]);
     627           1 :                 CATCH_REQUIRE(r.has_from());
     628           1 :                 CATCH_REQUIRE_FALSE(r.has_to());
     629           1 :                 CATCH_REQUIRE_FALSE(r.is_range());
     630           1 :                 CATCH_REQUIRE_FALSE(r.is_empty());
     631           1 :                 addr::addr f(r.get_from());
     632           1 :                 CATCH_REQUIRE_FALSE(f.is_ipv4());
     633           1 :                 CATCH_REQUIRE(f.to_ipv6_string(addr::addr::string_ip_t::STRING_IP_ONLY) == "5:1:6:2:7:3:8:4");
     634           1 :                 CATCH_REQUIRE(f.to_ipv6_string(addr::addr::string_ip_t::STRING_IP_BRACKETS) == "[5:1:6:2:7:3:8:4]");
     635           1 :                 CATCH_REQUIRE(f.to_ipv4or6_string(addr::addr::string_ip_t::STRING_IP_ONLY) == "5:1:6:2:7:3:8:4");
     636           1 :                 CATCH_REQUIRE(f.get_port() == 0);
     637           1 :                 CATCH_REQUIRE(f.get_protocol() == IPPROTO_TCP);
     638           1 :                 CATCH_REQUIRE(f.get_network_type() == addr::addr::network_type_t::NETWORK_TYPE_PUBLIC);
     639             :             }
     640             :         }
     641             :     }
     642             : 
     643          16 :     CATCH_GIVEN("addr_parser() with numeric only IPv6 addresses")
     644             :     {
     645           4 :         CATCH_SECTION("Simple numeric IPv6")
     646             :         {
     647           2 :             addr::addr_parser p;
     648           1 :             p.set_protocol(IPPROTO_TCP);
     649           1 :             p.set_allow(addr::addr_parser::flag_t::ADDRESS_LOOKUP, false);
     650           2 :             addr::addr_range::vector_t ips(p.parse("[4::f003:3001:20af]:5093"));
     651           1 :             CATCH_REQUIRE_FALSE(p.has_errors());
     652           1 :             CATCH_REQUIRE(ips.size() == 1);
     653             : 
     654           1 :             addr::addr_range const & r(ips[0]);
     655           1 :             CATCH_REQUIRE(r.has_from());
     656           1 :             CATCH_REQUIRE_FALSE(r.has_to());
     657           1 :             CATCH_REQUIRE_FALSE(r.is_range());
     658           1 :             CATCH_REQUIRE_FALSE(r.is_empty());
     659           1 :             addr::addr f(r.get_from());
     660           1 :             CATCH_REQUIRE_FALSE(f.is_ipv4());
     661             :             // getting an IPv4 would throw, which is checked somewhere else
     662             :             //CATCH_REQUIRE(f.to_ipv4_string(addr::addr::string_ip_t::STRING_IP_ONLY) == "");
     663           1 :             CATCH_REQUIRE(f.to_ipv4or6_string(addr::addr::string_ip_t::STRING_IP_ONLY) == "4::f003:3001:20af");
     664           1 :             CATCH_REQUIRE(f.get_port() == 5093);
     665           1 :             CATCH_REQUIRE(f.get_protocol() == IPPROTO_TCP);
     666           1 :             CATCH_REQUIRE(f.get_network_type() == addr::addr::network_type_t::NETWORK_TYPE_PUBLIC);
     667           1 :             uint8_t mask[16] = {};
     668           1 :             f.get_mask(mask);
     669          17 :             for(int idx(0); idx < 16; ++idx)
     670             :             {
     671          16 :                 CATCH_REQUIRE(mask[idx] == 255);
     672             :             }
     673             :         }
     674             : 
     675           4 :         CATCH_SECTION("Invalid IPv6 domain name address when we only accept numeric IPs")
     676             :         {
     677             :             // this is exactly the same path as the IPv4 test...
     678             :             // if we have a named domain then IPv4 fails, IPv6 fails, then we err on it
     679             :             //
     680           2 :             addr::addr_parser p;
     681           1 :             p.set_protocol(IPPROTO_TCP);
     682           1 :             p.set_allow(addr::addr_parser::flag_t::ADDRESS_LOOKUP, false);
     683           2 :             addr::addr_range::vector_t ips(p.parse("ipv6.example.com:4471"));
     684           1 :             CATCH_REQUIRE(p.has_errors());
     685           1 :             CATCH_REQUIRE(p.error_count() == 1);
     686           1 :             CATCH_REQUIRE(p.error_messages() == "Unknown address in \"ipv6.example.com\" (no DNS lookup was allowed).\n");
     687           1 :             CATCH_REQUIRE(ips.size() == 0);
     688             :         }
     689             :     }
     690           8 : }
     691             : 
     692             : 
     693           7 : CATCH_TEST_CASE( "ipv6::ports", "[ipv6]" )
     694             : {
     695             :     // by default addr() is an IPv6 address so we test the basic port
     696             :     // functions here, although it could be in a common place instead...
     697             :     //
     698          10 :     CATCH_GIVEN("addr()")
     699             :     {
     700           3 :         addr::addr a;
     701             : 
     702           6 :         CATCH_SECTION("default port")
     703             :         {
     704           1 :             CATCH_REQUIRE(a.get_port() == 0);
     705             :         }
     706             : 
     707           6 :         CATCH_SECTION("set_port()")
     708             :         {
     709             :             // setup a random port to start with
     710             :             //
     711           1 :             int const start_port(rand() & 0xFFFF);
     712           1 :             a.set_port(start_port);
     713             : 
     714             :             // test 100 invalid ports
     715             :             //
     716         101 :             for(int idx(0); idx < 100; ++idx)
     717             :             {
     718             :                 // first try a negative port
     719             :                 int port_too_small;
     720           0 :                 do
     721             :                 {
     722         100 :                     port_too_small = -(rand() & 0xFFFF);
     723             :                 }
     724         100 :                 while(port_too_small == 0);
     725         100 :                 CATCH_REQUIRE_THROWS_AS(a.set_port(port_too_small), addr::addr_invalid_argument);
     726             : 
     727             :                 // first try a negative port
     728         100 :                 int const port_too_large = (rand() & 0xFFFF) + 65536;
     729         100 :                 CATCH_REQUIRE_THROWS_AS(a.set_port(port_too_large), addr::addr_invalid_argument);
     730             : 
     731             :                 // make sure port does not get modified on errors
     732         100 :                 CATCH_REQUIRE(a.get_port() == start_port);
     733             :             }
     734             : 
     735             :             // test all ports
     736             :             //
     737       65537 :             for(int port(0); port < 65536; ++port)
     738             :             {
     739       65536 :                 a.set_port(port);
     740             : 
     741       65536 :                 CATCH_REQUIRE(a.get_port() == port);
     742             :             }
     743             :         }
     744             : 
     745           6 :         CATCH_SECTION("known ports to test get_service()")
     746             :         {
     747           1 :             a.set_port(80);
     748           1 :             CATCH_REQUIRE(a.get_service() == "http");
     749             : 
     750           1 :             a.set_port(443);
     751           1 :             CATCH_REQUIRE(a.get_service() == "https");
     752             : 
     753             :             // again with UDP
     754             :             // 
     755           1 :             a.set_protocol(IPPROTO_UDP);
     756             : 
     757           1 :             a.set_port(80);
     758           2 :             std::string service(a.get_service());
     759           1 :             CATCH_REQUIRE((service == "http" || service == "80"));
     760             : 
     761           1 :             a.set_port(443);
     762           1 :             service = a.get_service();
     763           1 :             CATCH_REQUIRE((service == "https"|| service == "443"));
     764             :         }
     765             :     }
     766             : 
     767          10 :     CATCH_GIVEN("addr_parser() with IPv6 addresses and port")
     768             :     {
     769           4 :         CATCH_SECTION("verify port")
     770             :         {
     771       65537 :             for(int port(0); port < 65536; ++port)
     772             :             {
     773       65536 :                 int proto(rand() & 1 ? IPPROTO_TCP : IPPROTO_UDP);
     774      131072 :                 addr::addr_parser p;
     775       65536 :                 p.set_protocol(proto);
     776      131072 :                 addr::addr_range::vector_t ips(p.parse("[ff01:2f3:f041:e301:f:10:11:12]:" + std::to_string(port)));
     777       65536 :                 CATCH_REQUIRE_FALSE(p.has_errors());
     778       65536 :                 CATCH_REQUIRE(ips.size() == 1);
     779       65536 :                 addr::addr_range const & r(ips[0]);
     780       65536 :                 addr::addr f(r.get_from());
     781       65536 :                 CATCH_REQUIRE_FALSE(f.is_ipv4());
     782       65536 :                 CATCH_REQUIRE(f.to_ipv6_string(addr::addr::string_ip_t::STRING_IP_ONLY) == "ff01:2f3:f041:e301:f:10:11:12");
     783       65536 :                 CATCH_REQUIRE(f.to_ipv6_string(addr::addr::string_ip_t::STRING_IP_BRACKETS) == "[ff01:2f3:f041:e301:f:10:11:12]");
     784       65536 :                 CATCH_REQUIRE(f.to_ipv6_string(addr::addr::string_ip_t::STRING_IP_PORT) == "[ff01:2f3:f041:e301:f:10:11:12]:" + std::to_string(port));
     785       65536 :                 CATCH_REQUIRE(f.to_ipv4or6_string(addr::addr::string_ip_t::STRING_IP_PORT) == "[ff01:2f3:f041:e301:f:10:11:12]:" + std::to_string(port));
     786       65536 :                 CATCH_REQUIRE(f.get_port() == port);
     787       65536 :                 CATCH_REQUIRE(f.get_protocol() == proto);
     788       65536 :                 CATCH_REQUIRE(f.get_network_type() == addr::addr::network_type_t::NETWORK_TYPE_LOOPBACK);
     789             :             }
     790             :         }
     791             : 
     792           4 :         CATCH_SECTION("default address with various port")
     793             :         {
     794         101 :             for(int idx(0); idx < 100; ++idx)
     795             :             {
     796         100 :                 uint16_t const port(rand());
     797         200 :                 addr::addr_parser p;
     798         100 :                 p.set_protocol(IPPROTO_TCP);
     799         100 :                 p.set_default_address("ff02:23:f41:e31:20:30:40:50");
     800         200 :                 addr::addr_range::vector_t ips(p.parse(":" + std::to_string(static_cast<int>(port))));
     801         100 :                 CATCH_REQUIRE_FALSE(p.has_errors());
     802         100 :                 CATCH_REQUIRE(ips.size() == 1);
     803         100 :                 addr::addr_range const & r(ips[0]);
     804         100 :                 CATCH_REQUIRE(r.has_from());
     805         100 :                 CATCH_REQUIRE_FALSE(r.has_to());
     806         100 :                 CATCH_REQUIRE_FALSE(r.is_range());
     807         100 :                 CATCH_REQUIRE_FALSE(r.is_empty());
     808         100 :                 addr::addr f(r.get_from());
     809         100 :                 CATCH_REQUIRE_FALSE(f.is_ipv4());
     810         100 :                 CATCH_REQUIRE(f.to_ipv6_string(addr::addr::string_ip_t::STRING_IP_PORT) == "[ff02:23:f41:e31:20:30:40:50]:" + std::to_string(static_cast<int>(port)));
     811         100 :                 CATCH_REQUIRE(f.to_ipv4or6_string(addr::addr::string_ip_t::STRING_IP_PORT) == "[ff02:23:f41:e31:20:30:40:50]:" + std::to_string(static_cast<int>(port)));
     812         100 :                 CATCH_REQUIRE(f.get_port() == port);
     813         100 :                 CATCH_REQUIRE(f.get_protocol() == IPPROTO_TCP);
     814         100 :                 CATCH_REQUIRE(f.get_network_type() == addr::addr::network_type_t::NETWORK_TYPE_LINK_LOCAL);
     815             :             }
     816             :         }
     817             :     }
     818           5 : }
     819             : 
     820             : 
     821          14 : CATCH_TEST_CASE( "ipv6::masks", "[ipv6]" )
     822             : {
     823          24 :     CATCH_GIVEN("addr()")
     824             :     {
     825             :         // technically, a default addr object represents and IPv6 so the
     826             :         // dealing with the mask without an IPv4 is done by IPv6 tests
     827             :         //
     828           3 :         addr::addr a;
     829             : 
     830           6 :         CATCH_SECTION("default mask")
     831             :         {
     832           1 :             uint8_t mask[16] = {};
     833           1 :             a.get_mask(mask);
     834          17 :             for(int idx(0); idx < 16; ++idx)
     835             :             {
     836          16 :                 CATCH_REQUIRE(mask[idx] == 255);
     837             :             }
     838             :         }
     839             : 
     840           6 :         CATCH_SECTION("set_mask()")
     841             :         {
     842           1 :             uint8_t mask[16], verify_mask[16];
     843           6 :             for(int idx(0); idx < 5; ++idx)
     844             :             {
     845          85 :                 for(int j(0); j < 16; ++j)
     846             :                 {
     847          80 :                     mask[j] = rand();
     848             :                 }
     849           5 :                 a.set_mask(mask);
     850           5 :                 a.get_mask(verify_mask);
     851          85 :                 for(int j(0); j < 16; ++j)
     852             :                 {
     853          80 :                     CATCH_REQUIRE(mask[j] == verify_mask[j]);
     854             :                 }
     855             : 
     856             :                 // verify that a copy does copy the mask as expected
     857             :                 //
     858           5 :                 addr::addr b(a);
     859           5 :                 b.get_mask(verify_mask);
     860          85 :                 for(int j(0); j < 16; ++j)
     861             :                 {
     862          80 :                     CATCH_REQUIRE(mask[j] == verify_mask[j]);
     863             :                 }
     864             :             }
     865             :         }
     866             : 
     867           6 :         CATCH_SECTION("set_mask()")
     868             :         {
     869           1 :             uint8_t mask[16];
     870           1 :             uint8_t verify_mask[16];
     871           6 :             for(int idx(0); idx < 5; ++idx)
     872             :             {
     873          85 :                 for(int j(0); j < 16; ++j)
     874             :                 {
     875          80 :                     mask[j] = rand();
     876             :                 }
     877           5 :                 a.set_mask(mask);
     878           5 :                 a.get_mask(verify_mask);
     879          85 :                 for(int j(0); j < 16; ++j)
     880             :                 {
     881          80 :                     CATCH_REQUIRE(mask[j] == verify_mask[j]);
     882          80 :                     verify_mask[j] = rand();
     883             :                 }
     884             : 
     885             :                 // verify that a copy does copy the mask as expected
     886             :                 //
     887           5 :                 addr::addr b(a);
     888           5 :                 b.get_mask(verify_mask);
     889          85 :                 for(int j(0); j < 16; ++j)
     890             :                 {
     891          80 :                     CATCH_REQUIRE(mask[j] == verify_mask[j]);
     892          80 :                     verify_mask[j] = rand();
     893             :                 }
     894             : 
     895             :                 // verify that copying inside a range works too
     896             :                 //
     897           5 :                 addr::addr_range r;
     898           5 :                 r.set_from(a);
     899           5 :                 r.get_from().get_mask(verify_mask);
     900          85 :                 for(int j(0); j < 16; ++j)
     901             :                 {
     902          80 :                     CATCH_REQUIRE(mask[j] == verify_mask[j]);
     903          80 :                     verify_mask[j] = rand();
     904             :                 }
     905             : 
     906             :                 // then that a range copy works as expected
     907             :                 //
     908           5 :                 addr::addr_range c(r);
     909           5 :                 c.get_from().get_mask(verify_mask);
     910          85 :                 for(int j(0); j < 16; ++j)
     911             :                 {
     912          80 :                     CATCH_REQUIRE(mask[j] == verify_mask[j]);
     913          80 :                     verify_mask[j] = rand();
     914             :                 }
     915             :             }
     916             :         }
     917             :     }
     918             : 
     919          24 :     CATCH_GIVEN("addr_parser() of address:port/mask")
     920             :     {
     921          18 :         CATCH_SECTION("mask allowed, but no mask")
     922             :         {
     923           1 :             int const proto(rand() & 1 ? IPPROTO_TCP : IPPROTO_UDP);
     924           1 :             int const port(rand() & 0xFFFF);
     925           2 :             addr::addr_parser p;
     926           1 :             p.set_protocol(proto);
     927           1 :             p.set_allow(addr::addr_parser::flag_t::MASK, true);
     928           2 :             addr::addr_range::vector_t ips(p.parse("[55:33:22:11:0:cc:bb:aa]:" + std::to_string(port)));
     929           1 :             CATCH_REQUIRE_FALSE(p.has_errors());
     930           1 :             CATCH_REQUIRE(ips.size() == 1);
     931           1 :             addr::addr_range const & r(ips[0]);
     932           1 :             addr::addr f(r.get_from());
     933           1 :             CATCH_REQUIRE_FALSE(f.is_ipv4());
     934           2 :             std::string result("[55:33:22:11:0:cc:bb:aa]:" + std::to_string(port) + "/[ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff]");
     935           1 :             CATCH_REQUIRE(f.to_ipv6_string(addr::addr::string_ip_t::STRING_IP_ALL) == result);
     936           1 :             CATCH_REQUIRE(f.to_ipv4or6_string(addr::addr::string_ip_t::STRING_IP_ALL) == result);
     937           1 :             CATCH_REQUIRE(f.get_port() == port);
     938           1 :             CATCH_REQUIRE(f.get_protocol() == proto);
     939             :         }
     940             : 
     941          18 :         CATCH_SECTION("empty mask")
     942             :         {
     943           1 :             int const proto(rand() & 1 ? IPPROTO_TCP : IPPROTO_UDP);
     944           1 :             int const port(rand() & 0xFFFF);
     945           2 :             addr::addr_parser p;
     946           1 :             p.set_protocol(proto);
     947           1 :             p.set_allow(addr::addr_parser::flag_t::MASK, true);
     948           2 :             addr::addr_range::vector_t ips(p.parse("[55:33:22:11:0:cc:bb:aa]:" + std::to_string(port) + "/"));
     949           1 :             CATCH_REQUIRE_FALSE(p.has_errors());
     950           1 :             CATCH_REQUIRE(ips.size() == 1);
     951           1 :             addr::addr_range const & r(ips[0]);
     952           1 :             addr::addr f(r.get_from());
     953           1 :             CATCH_REQUIRE_FALSE(f.is_ipv4());
     954           2 :             std::string result("[55:33:22:11:0:cc:bb:aa]:" + std::to_string(port) + "/[ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff]");
     955           1 :             CATCH_REQUIRE(f.to_ipv6_string(addr::addr::string_ip_t::STRING_IP_ALL) == result);
     956           1 :             CATCH_REQUIRE(f.to_ipv4or6_string(addr::addr::string_ip_t::STRING_IP_ALL) == result);
     957           1 :             CATCH_REQUIRE(f.get_port() == port);
     958           1 :             CATCH_REQUIRE(f.get_protocol() == proto);
     959             :         }
     960             : 
     961          18 :         CATCH_SECTION("empty mask including the '[]'")
     962             :         {
     963           1 :             int const proto(rand() & 1 ? IPPROTO_TCP : IPPROTO_UDP);
     964           1 :             int const port(rand() & 0xFFFF);
     965           2 :             addr::addr_parser p;
     966           1 :             p.set_protocol(proto);
     967           1 :             p.set_allow(addr::addr_parser::flag_t::MASK, true);
     968           2 :             addr::addr_range::vector_t ips(p.parse("[55:33:22:11:0:cc:bb:aa]:" + std::to_string(port) + "/[]"));
     969           1 :             CATCH_REQUIRE_FALSE(p.has_errors());
     970           1 :             CATCH_REQUIRE(ips.size() == 1);
     971           1 :             addr::addr_range const & r(ips[0]);
     972           1 :             addr::addr f(r.get_from());
     973           1 :             CATCH_REQUIRE_FALSE(f.is_ipv4());
     974           2 :             std::string result("[55:33:22:11:0:cc:bb:aa]:" + std::to_string(port) + "/[ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff]");
     975           1 :             CATCH_REQUIRE(f.to_ipv6_string(addr::addr::string_ip_t::STRING_IP_ALL) == result);
     976           1 :             CATCH_REQUIRE(f.to_ipv4or6_string(addr::addr::string_ip_t::STRING_IP_ALL) == result);
     977           1 :             CATCH_REQUIRE(f.get_port() == port);
     978           1 :             CATCH_REQUIRE(f.get_protocol() == proto);
     979             :         }
     980             : 
     981          18 :         CATCH_SECTION("one number masks")
     982             :         {
     983         130 :             for(int idx(0); idx <= 128; ++idx)
     984             :             {
     985         129 :                 int const proto(rand() & 1 ? IPPROTO_TCP : IPPROTO_UDP);
     986         129 :                 int const port(rand() & 0xFFFF);
     987         258 :                 addr::addr_parser p;
     988         129 :                 p.set_protocol(proto);
     989         129 :                 p.set_allow(addr::addr_parser::flag_t::MASK, true);
     990         258 :                 addr::addr_range::vector_t ips(p.parse("[55:33:22:11:0:cc:bb:aa]:" + std::to_string(port) + "/" + std::to_string(idx)));
     991         129 :                 CATCH_REQUIRE_FALSE(p.has_errors());
     992         129 :                 CATCH_REQUIRE(ips.size() == 1);
     993         129 :                 addr::addr_range const & r(ips[0]);
     994         129 :                 addr::addr f(r.get_from());
     995         129 :                 CATCH_REQUIRE_FALSE(f.is_ipv4());
     996         129 :                 uint8_t mask[16] = { 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255 };
     997         129 :                 int j(15);
     998         129 :                 int m(128 - idx);
     999        2049 :                 for(; m > 8; m -= 8, --j)
    1000             :                 {
    1001         960 :                     mask[j] = 0;
    1002             :                 }
    1003         129 :                 if(j < 0)
    1004             :                 {
    1005           0 :                     throw std::logic_error("invalid j here");
    1006             :                 }
    1007         129 :                 mask[j] = 255 << m;
    1008         129 :                 char buf[1024]; // really large buffer to make sure it does not get truncated
    1009         129 :                 if(inet_ntop(AF_INET6, mask, buf, sizeof(buf)) == nullptr)
    1010             :                 {
    1011           0 :                     throw std::logic_error("somehow we could not convert our mask to an IPv6 address.");
    1012             :                 }
    1013         258 :                 std::string result("[55:33:22:11:0:cc:bb:aa]:" + std::to_string(port) + "/[" + buf + "]");
    1014         129 :                 CATCH_REQUIRE(f.to_ipv6_string(addr::addr::string_ip_t::STRING_IP_ALL) == result);
    1015         129 :                 CATCH_REQUIRE(f.to_ipv4or6_string(addr::addr::string_ip_t::STRING_IP_ALL) == result);
    1016         129 :                 CATCH_REQUIRE(f.get_port() == port);
    1017         129 :                 CATCH_REQUIRE(f.get_protocol() == proto);
    1018             :             }
    1019             :         }
    1020             : 
    1021          18 :         CATCH_SECTION("address like mask")
    1022             :         {
    1023          26 :             for(int idx(0); idx < 25; ++idx)
    1024             :             {
    1025          25 :                 int const proto(rand() & 1 ? IPPROTO_TCP : IPPROTO_UDP);
    1026          25 :                 int const port(rand() & 0xFFFF);
    1027          50 :                 addr::addr_parser p;
    1028          25 :                 p.set_protocol(proto);
    1029          25 :                 p.set_allow(addr::addr_parser::flag_t::MASK, true);
    1030             :                 // when specified as an IP, the mask can be absolutely anything
    1031          25 :                 uint8_t mask[16];
    1032         425 :                 for(int j(0); j < 16; ++j)
    1033             :                 {
    1034         400 :                     mask[j] = rand();
    1035             :                 }
    1036          50 :                 std::stringstream smask;
    1037          25 :                 smask << std::hex
    1038          25 :                       << htons((mask[ 1] << 8) | mask[ 0])
    1039          25 :                       << ":"                            
    1040          25 :                       << htons((mask[ 3] << 8) | mask[ 2])
    1041          25 :                       << ":"                            
    1042          25 :                       << htons((mask[ 5] << 8) | mask[ 4])
    1043          25 :                       << ":"                            
    1044          25 :                       << htons((mask[ 7] << 8) | mask[ 6])
    1045          25 :                       << ":"                            
    1046          25 :                       << htons((mask[ 9] << 8) | mask[ 8])
    1047          25 :                       << ":"                            
    1048          25 :                       << htons((mask[11] << 8) | mask[10])
    1049          25 :                       << ":"                            
    1050          25 :                       << htons((mask[13] << 8) | mask[12])
    1051          25 :                       << ":"                            
    1052          25 :                       << htons((mask[15] << 8) | mask[14]);
    1053          25 :                 char buf[1024]; // really large buffer to make sure it does not get truncated
    1054          25 :                 if(inet_ntop(AF_INET6, mask, buf, sizeof(buf)) == nullptr)
    1055             :                 {
    1056           0 :                     throw std::logic_error("somehow we could not convert our mask to an IPv6 address.");
    1057             :                 }
    1058          50 :                 addr::addr_range::vector_t ips(p.parse("[55:33:22:11:0:cc:bb:aa]:" + std::to_string(port) + "/[" + smask.str() + "]"));
    1059          25 :                 CATCH_REQUIRE_FALSE(p.has_errors());
    1060          25 :                 CATCH_REQUIRE(ips.size() == 1);
    1061          25 :                 addr::addr_range const & r(ips[0]);
    1062          25 :                 addr::addr f(r.get_from());
    1063          25 :                 CATCH_REQUIRE_FALSE(f.is_ipv4());
    1064          50 :                 std::string result("[55:33:22:11:0:cc:bb:aa]:" + std::to_string(port) + "/[" + buf + "]");
    1065          25 :                 CATCH_REQUIRE(f.to_ipv6_string(addr::addr::string_ip_t::STRING_IP_ALL) == result);
    1066          25 :                 CATCH_REQUIRE(f.to_ipv4or6_string(addr::addr::string_ip_t::STRING_IP_ALL) == result);
    1067          25 :                 CATCH_REQUIRE(f.get_port() == port);
    1068          25 :                 CATCH_REQUIRE(f.get_protocol() == proto);
    1069             :             }
    1070             :         }
    1071             : 
    1072          18 :         CATCH_SECTION("address like default mask")
    1073             :         {
    1074          26 :             for(int idx(0); idx < 25; ++idx)
    1075             :             {
    1076          25 :                 int const proto(rand() & 1 ? IPPROTO_TCP : IPPROTO_UDP);
    1077          25 :                 int const port(rand() & 0xFFFF);
    1078          50 :                 addr::addr_parser p;
    1079          25 :                 p.set_protocol(proto);
    1080          25 :                 p.set_allow(addr::addr_parser::flag_t::MASK, true);
    1081             :                 // when specified as an IP, the mask can be absolutely anything
    1082             :                 // (here the mask is a string an it will be parsed by the
    1083             :                 // parser if required)
    1084             :                 //
    1085          25 :                 uint8_t mask[16];
    1086         425 :                 for(int j(0); j < 16; ++j)
    1087             :                 {
    1088         400 :                     mask[j] = rand();
    1089             :                 }
    1090          50 :                 std::stringstream smask;
    1091          25 :                 smask << std::hex
    1092          25 :                       << "["
    1093          25 :                       << htons((mask[ 1] << 8) | mask[ 0])
    1094          25 :                       << ":"                            
    1095          25 :                       << htons((mask[ 3] << 8) | mask[ 2])
    1096          25 :                       << ":"                            
    1097          25 :                       << htons((mask[ 5] << 8) | mask[ 4])
    1098          25 :                       << ":"                            
    1099          25 :                       << htons((mask[ 7] << 8) | mask[ 6])
    1100          25 :                       << ":"                            
    1101          25 :                       << htons((mask[ 9] << 8) | mask[ 8])
    1102          25 :                       << ":"                            
    1103          25 :                       << htons((mask[11] << 8) | mask[10])
    1104          25 :                       << ":"                            
    1105          25 :                       << htons((mask[13] << 8) | mask[12])
    1106          25 :                       << ":"                            
    1107          25 :                       << htons((mask[15] << 8) | mask[14])
    1108          25 :                       << "]";
    1109          25 :                 char buf[1024]; // really large buffer to make sure it does not get truncated
    1110          25 :                 if(inet_ntop(AF_INET6, mask, buf, sizeof(buf)) == nullptr)
    1111             :                 {
    1112           0 :                     throw std::logic_error("somehow we could not convert our mask to an IPv6 address.");
    1113             :                 }
    1114          25 :                 p.set_default_mask(smask.str());
    1115          50 :                 addr::addr_range::vector_t ips(p.parse("[55:33:22:11:0:cc:bb:aa]:" + std::to_string(port)));
    1116          25 :                 CATCH_REQUIRE_FALSE(p.has_errors());
    1117          25 :                 CATCH_REQUIRE(ips.size() == 1);
    1118          25 :                 addr::addr_range const & r(ips[0]);
    1119          25 :                 addr::addr f(r.get_from());
    1120          25 :                 CATCH_REQUIRE_FALSE(f.is_ipv4());
    1121          50 :                 std::string result("[55:33:22:11:0:cc:bb:aa]:" + std::to_string(port) + "/[" + buf + "]");
    1122          25 :                 CATCH_REQUIRE(f.to_ipv6_string(addr::addr::string_ip_t::STRING_IP_ALL) == result);
    1123          25 :                 CATCH_REQUIRE(f.to_ipv4or6_string(addr::addr::string_ip_t::STRING_IP_ALL) == result);
    1124          25 :                 CATCH_REQUIRE(f.get_port() == port);
    1125          25 :                 CATCH_REQUIRE(f.get_protocol() == proto);
    1126          25 :                 uint8_t verify_mask[16];
    1127          25 :                 f.get_mask(verify_mask);
    1128         425 :                 for(int j(0); j < 16; ++j)
    1129             :                 {
    1130         400 :                     CATCH_REQUIRE(verify_mask[j] == mask[j]);
    1131             :                 }
    1132             :             }
    1133             :         }
    1134             : 
    1135          18 :         CATCH_SECTION("address like mask with a default")
    1136             :         {
    1137          26 :             for(int idx(0); idx < 25; ++idx)
    1138             :             {
    1139          25 :                 int const proto(rand() & 1 ? IPPROTO_TCP : IPPROTO_UDP);
    1140          25 :                 int const port(rand() & 0xFFFF);
    1141          50 :                 addr::addr_parser p;
    1142          25 :                 p.set_protocol(proto);
    1143          25 :                 p.set_allow(addr::addr_parser::flag_t::MASK, true);
    1144             : 
    1145             :                 // here we want a default and an IP with a specific mask
    1146             :                 // to make sure that the specific mask has priority
    1147             :                 //
    1148          25 :                 uint8_t mask[16];
    1149         425 :                 for(int j(0); j < 16; ++j)
    1150             :                 {
    1151         400 :                     mask[j] = rand();
    1152             :                 }
    1153          50 :                 std::stringstream smask;
    1154          25 :                 smask << std::hex
    1155          25 :                       << "["
    1156          25 :                       << htons((mask[ 1] << 8) | mask[ 0])
    1157          25 :                       << ":"                            
    1158          25 :                       << htons((mask[ 3] << 8) | mask[ 2])
    1159          25 :                       << ":"                            
    1160          25 :                       << htons((mask[ 5] << 8) | mask[ 4])
    1161          25 :                       << ":"                            
    1162          25 :                       << htons((mask[ 7] << 8) | mask[ 6])
    1163          25 :                       << ":"                            
    1164          25 :                       << htons((mask[ 9] << 8) | mask[ 8])
    1165          25 :                       << ":"                            
    1166          25 :                       << htons((mask[11] << 8) | mask[10])
    1167          25 :                       << ":"                            
    1168          25 :                       << htons((mask[13] << 8) | mask[12])
    1169          25 :                       << ":"                            
    1170          25 :                       << htons((mask[15] << 8) | mask[14])
    1171          25 :                       << "]";
    1172          25 :                 char buf[1024]; // really large buffer to make sure it does not get truncated
    1173          25 :                 if(inet_ntop(AF_INET6, mask, buf, sizeof(buf)) == nullptr)
    1174             :                 {
    1175           0 :                     throw std::logic_error("somehow we could not convert our mask to an IPv6 address.");
    1176             :                 }
    1177             : 
    1178          25 :                 uint8_t default_mask[16];
    1179         425 :                 for(int j(0); j < 16; ++j)
    1180             :                 {
    1181         400 :                     default_mask[j] = rand();
    1182             :                 }
    1183             :                 //std::stringstream default_smask;
    1184             :                 //default_smask << std::hex
    1185             :                 //      << "["
    1186             :                 //      << htons((default_mask[ 1] << 8) | default_mask[ 0])
    1187             :                 //      << ":"                            
    1188             :                 //      << htons((default_mask[ 3] << 8) | default_mask[ 2])
    1189             :                 //      << ":"                            
    1190             :                 //      << htons((default_mask[ 5] << 8) | default_mask[ 4])
    1191             :                 //      << ":"                            
    1192             :                 //      << htons((default_mask[ 7] << 8) | default_mask[ 6])
    1193             :                 //      << ":"                            
    1194             :                 //      << htons((default_mask[ 9] << 8) | default_mask[ 8])
    1195             :                 //      << ":"                            
    1196             :                 //      << htons((default_mask[11] << 8) | default_mask[10])
    1197             :                 //      << ":"                            
    1198             :                 //      << htons((default_mask[13] << 8) | default_mask[12])
    1199             :                 //      << ":"                            
    1200             :                 //      << htons((default_mask[15] << 8) | default_mask[14])
    1201             :                 //      << "]";
    1202          25 :                 char default_buf[1024]; // really large buffer to make sure it does not get truncated
    1203          25 :                 if(inet_ntop(AF_INET6, default_mask, default_buf, sizeof(buf)) == nullptr)
    1204             :                 {
    1205           0 :                     throw std::logic_error("somehow we could not convert our mask to an IPv6 address.");
    1206             :                 }
    1207          25 :                 p.set_default_mask(default_buf);
    1208             : 
    1209          50 :                 addr::addr_range::vector_t ips(p.parse("[55:33:22:11:0:cc:bb:aa]:" + std::to_string(port) + "/" + smask.str()));
    1210          25 :                 CATCH_REQUIRE_FALSE(p.has_errors());
    1211          25 :                 CATCH_REQUIRE(ips.size() == 1);
    1212          25 :                 addr::addr_range const & r(ips[0]);
    1213          25 :                 addr::addr f(r.get_from());
    1214          25 :                 CATCH_REQUIRE_FALSE(f.is_ipv4());
    1215          50 :                 std::string result("[55:33:22:11:0:cc:bb:aa]:" + std::to_string(port) + "/[" + buf + "]");
    1216          25 :                 CATCH_REQUIRE(f.to_ipv6_string(addr::addr::string_ip_t::STRING_IP_ALL) == result);
    1217          25 :                 CATCH_REQUIRE(f.to_ipv4or6_string(addr::addr::string_ip_t::STRING_IP_ALL) == result);
    1218          25 :                 CATCH_REQUIRE(f.get_port() == port);
    1219          25 :                 CATCH_REQUIRE(f.get_protocol() == proto);
    1220          25 :                 uint8_t verify_mask[16];
    1221          25 :                 f.get_mask(verify_mask);
    1222         425 :                 for(int j(0); j < 16; ++j)
    1223             :                 {
    1224         400 :                     CATCH_REQUIRE(verify_mask[j] == mask[j]);
    1225             :                 }
    1226             :             }
    1227             :         }
    1228             : 
    1229          18 :         CATCH_SECTION("no address, but one IPv6 number masks")
    1230             :         {
    1231             :             // with just a number, the mask is considered an IPv6 mask
    1232             :             // if it is 33 or more
    1233             :             //
    1234          97 :             for(int idx(33); idx <= 128; ++idx)
    1235             :             {
    1236          96 :                 int const proto(rand() & 1 ? IPPROTO_TCP : IPPROTO_UDP);
    1237          96 :                 int const port(rand() & 0xFFFF);
    1238         192 :                 addr::addr_parser p;
    1239          96 :                 p.set_protocol(proto);
    1240          96 :                 p.set_allow(addr::addr_parser::flag_t::MASK, true);
    1241             :                 //p.set_default_address("55:33:22:11:0:cc:bb:aa");
    1242         192 :                 addr::addr_range::vector_t ips(p.parse(":" + std::to_string(port) + "/" + std::to_string(idx)));
    1243          96 :                 CATCH_REQUIRE_FALSE(p.has_errors());
    1244          96 :                 CATCH_REQUIRE(ips.size() == 1);
    1245          96 :                 addr::addr_range const & r(ips[0]);
    1246          96 :                 addr::addr f(r.get_from());
    1247          96 :                 CATCH_REQUIRE_FALSE(f.is_ipv4());
    1248          96 :                 uint8_t mask[16] = { 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255 };
    1249          96 :                 int j(15);
    1250          96 :                 int m(128 - idx);
    1251        1130 :                 for(; m > 8; m -= 8, --j)
    1252             :                 {
    1253         517 :                     mask[j] = 0;
    1254             :                 }
    1255          96 :                 if(j < 0)
    1256             :                 {
    1257           0 :                     throw std::logic_error("invalid j here");
    1258             :                 }
    1259          96 :                 mask[j] = 255 << m;
    1260          96 :                 char buf[1024]; // really large buffer to make sure it does not get truncated
    1261          96 :                 if(inet_ntop(AF_INET6, mask, buf, sizeof(buf)) == nullptr)
    1262             :                 {
    1263           0 :                     throw std::logic_error("somehow we could not convert our mask to an IPv6 address.");
    1264             :                 }
    1265         192 :                 std::string result("[::]:" + std::to_string(port) + "/[" + buf + "]");
    1266          96 :                 CATCH_REQUIRE(f.to_ipv6_string(addr::addr::string_ip_t::STRING_IP_ALL) == result);
    1267          96 :                 CATCH_REQUIRE(f.to_ipv4or6_string(addr::addr::string_ip_t::STRING_IP_ALL) == result);
    1268          96 :                 CATCH_REQUIRE(f.get_port() == port);
    1269          96 :                 CATCH_REQUIRE(f.get_protocol() == proto);
    1270             :             }
    1271             :         }
    1272             : 
    1273          18 :         CATCH_SECTION("no address, but one IPv6 masks")
    1274             :         {
    1275             :             // with just a number, the mask is considered an IPv6 mask
    1276             :             // if it is 33 or more
    1277             :             //
    1278           6 :             for(int idx(0); idx < 5; ++idx)
    1279             :             {
    1280           5 :                 int const proto(rand() & 1 ? IPPROTO_TCP : IPPROTO_UDP);
    1281           5 :                 int const port(rand() & 0xFFFF);
    1282          10 :                 addr::addr_parser p;
    1283           5 :                 p.set_protocol(proto);
    1284           5 :                 p.set_allow(addr::addr_parser::flag_t::MASK, true);
    1285             :                 //p.set_default_address("55:33:22:11:0:cc:bb:aa");
    1286          10 :                 addr::addr_range::vector_t ips(p.parse(":" + std::to_string(port) + "/[1:2:3:4:5:6:7:8]"));
    1287           5 :                 CATCH_REQUIRE_FALSE(p.has_errors());
    1288           5 :                 CATCH_REQUIRE(ips.size() == 1);
    1289           5 :                 addr::addr_range const & r(ips[0]);
    1290           5 :                 addr::addr f(r.get_from());
    1291           5 :                 CATCH_REQUIRE_FALSE(f.is_ipv4());
    1292          10 :                 std::string result("[::]:" + std::to_string(port) + "/[1:2:3:4:5:6:7:8]");
    1293           5 :                 CATCH_REQUIRE(f.to_ipv6_string(addr::addr::string_ip_t::STRING_IP_ALL) == result);
    1294           5 :                 CATCH_REQUIRE(f.to_ipv4or6_string(addr::addr::string_ip_t::STRING_IP_ALL) == result);
    1295           5 :                 CATCH_REQUIRE(f.get_port() == port);
    1296           5 :                 CATCH_REQUIRE(f.get_protocol() == proto);
    1297             :             }
    1298             :         }
    1299             :     }
    1300          12 : }
    1301             : 
    1302             : 
    1303           9 : CATCH_TEST_CASE( "ipv6::network_type", "[ipv6]" )
    1304             : {
    1305          14 :     CATCH_GIVEN("addr()")
    1306             :     {
    1307           7 :         addr::addr a;
    1308             : 
    1309          14 :         CATCH_SECTION("any (::)")
    1310             :         {
    1311             :             {
    1312           1 :                 struct sockaddr_in6 in6 = sockaddr_in6();
    1313           1 :                 in6.sin6_family = AF_INET6;
    1314           1 :                 in6.sin6_port = htons(rand());
    1315           1 :                 in6.sin6_addr.s6_addr32[0] = 0;
    1316           1 :                 in6.sin6_addr.s6_addr32[1] = 0;
    1317           1 :                 in6.sin6_addr.s6_addr32[2] = 0;
    1318           1 :                 in6.sin6_addr.s6_addr32[3] = 0;
    1319             : 
    1320             :                 // verify network type
    1321             :                 //
    1322           1 :                 a.set_ipv6(in6);
    1323             : 
    1324           1 :                 CATCH_REQUIRE(a.is_default());
    1325           1 :                 CATCH_REQUIRE(a.get_network_type() == addr::addr::network_type_t::NETWORK_TYPE_ANY);
    1326           1 :                 CATCH_REQUIRE(a.get_network_type_string() == "Any");
    1327             :             }
    1328             : 
    1329             :             // make sure that if any byte is set to non-zero it is not
    1330             :             // viewed as the ANY address
    1331             :             //
    1332          17 :             for(int idx(0); idx < 16; ++idx)
    1333             :             {
    1334          16 :                 struct sockaddr_in6 in6 = sockaddr_in6();
    1335          16 :                 in6.sin6_family = AF_INET6;
    1336          16 :                 in6.sin6_port = htons(rand());
    1337          16 :                 in6.sin6_addr.s6_addr32[0] = 0;
    1338          16 :                 in6.sin6_addr.s6_addr32[1] = 0;
    1339          16 :                 in6.sin6_addr.s6_addr32[2] = 0;
    1340          16 :                 in6.sin6_addr.s6_addr32[3] = 0;
    1341             : 
    1342             :                 // change one byte only
    1343             :                 //
    1344           0 :                 do
    1345             :                 {
    1346          16 :                     in6.sin6_addr.s6_addr[idx] = rand();
    1347             :                 }
    1348          16 :                 while(in6.sin6_addr.s6_addr[idx] == 0);
    1349             : 
    1350             :                 // verify network type
    1351             :                 //
    1352          16 :                 a.set_ipv6(in6);
    1353             : 
    1354          16 :                 CATCH_REQUIRE(a.get_network_type() != addr::addr::network_type_t::NETWORK_TYPE_ANY);
    1355          16 :                 CATCH_REQUIRE(a.get_network_type_string() != "Any");
    1356             :             }
    1357             :         }
    1358             : 
    1359          14 :         CATCH_SECTION("private address fd00::/8")
    1360             :         {
    1361          11 :             for(int idx(0); idx < 10; ++idx)
    1362             :             {
    1363          10 :                 struct sockaddr_in6 in6 = sockaddr_in6();
    1364          10 :                 in6.sin6_family = AF_INET6;
    1365          10 :                 in6.sin6_port = htons(rand());
    1366          10 :                 in6.sin6_addr.s6_addr16[0] = htons(0xFD00 | (rand() & 255));
    1367          10 :                 in6.sin6_addr.s6_addr16[1] = rand();
    1368          10 :                 in6.sin6_addr.s6_addr16[2] = rand();
    1369          10 :                 in6.sin6_addr.s6_addr16[3] = rand();
    1370          10 :                 in6.sin6_addr.s6_addr16[4] = rand();
    1371          10 :                 in6.sin6_addr.s6_addr16[5] = rand();
    1372          10 :                 in6.sin6_addr.s6_addr16[6] = rand();
    1373          10 :                 in6.sin6_addr.s6_addr16[7] = rand();
    1374             : 
    1375             :                 // verify network type
    1376             :                 //
    1377          10 :                 a.set_ipv6(in6);
    1378          10 :                 CATCH_REQUIRE(a.get_network_type() == addr::addr::network_type_t::NETWORK_TYPE_PRIVATE);
    1379          10 :                 CATCH_REQUIRE(a.get_network_type_string() == "Private");
    1380             :             }
    1381             :         }
    1382             : 
    1383          14 :         CATCH_SECTION("private address fe80::/10")
    1384             :         {
    1385          11 :             for(int idx(0); idx < 10; ++idx)
    1386             :             {
    1387          10 :                 struct sockaddr_in6 in6 = sockaddr_in6();
    1388          10 :                 in6.sin6_family = AF_INET6;
    1389          10 :                 in6.sin6_port = htons(rand());
    1390          10 :                 in6.sin6_addr.s6_addr16[0] = htons(0xFE80 | (rand() & 63));
    1391          10 :                 in6.sin6_addr.s6_addr16[1] = rand();
    1392          10 :                 in6.sin6_addr.s6_addr16[2] = rand();
    1393          10 :                 in6.sin6_addr.s6_addr16[3] = rand();
    1394          10 :                 in6.sin6_addr.s6_addr16[4] = rand();
    1395          10 :                 in6.sin6_addr.s6_addr16[5] = rand();
    1396          10 :                 in6.sin6_addr.s6_addr16[6] = rand();
    1397          10 :                 in6.sin6_addr.s6_addr16[7] = rand();
    1398             : 
    1399             :                 // verify network type
    1400             :                 //
    1401          10 :                 a.set_ipv6(in6);
    1402          10 :                 CATCH_REQUIRE(a.get_network_type() == addr::addr::network_type_t::NETWORK_TYPE_LINK_LOCAL);
    1403          10 :                 CATCH_REQUIRE(a.get_network_type_string() == "Local Link");
    1404             :             }
    1405             :         }
    1406             : 
    1407          14 :         CATCH_SECTION("private address ff02::/16")
    1408             :         {
    1409          11 :             for(int idx(0); idx < 10; ++idx)
    1410             :             {
    1411          10 :                 struct sockaddr_in6 in6 = sockaddr_in6();
    1412          10 :                 in6.sin6_family = AF_INET6;
    1413          10 :                 in6.sin6_port = htons(rand());
    1414          10 :                 in6.sin6_addr.s6_addr16[0] = htons(0xFF02);
    1415          10 :                 in6.sin6_addr.s6_addr16[1] = rand();
    1416          10 :                 in6.sin6_addr.s6_addr16[2] = rand();
    1417          10 :                 in6.sin6_addr.s6_addr16[3] = rand();
    1418          10 :                 in6.sin6_addr.s6_addr16[4] = rand();
    1419          10 :                 in6.sin6_addr.s6_addr16[5] = rand();
    1420          10 :                 in6.sin6_addr.s6_addr16[6] = rand();
    1421          10 :                 in6.sin6_addr.s6_addr16[7] = rand();
    1422             : 
    1423             :                 // verify network type
    1424             :                 //
    1425          10 :                 a.set_ipv6(in6);
    1426          10 :                 CATCH_REQUIRE(a.get_network_type() == addr::addr::network_type_t::NETWORK_TYPE_LINK_LOCAL);
    1427          10 :                 CATCH_REQUIRE(a.get_network_type_string() == "Local Link");
    1428             :             }
    1429             :         }
    1430             : 
    1431          14 :         CATCH_SECTION("private address ff00::/8")
    1432             :         {
    1433          11 :             for(int idx(0); idx < 10; ++idx)
    1434             :             {
    1435          10 :                 struct sockaddr_in6 in6 = sockaddr_in6();
    1436          10 :                 in6.sin6_family = AF_INET6;
    1437          10 :                 in6.sin6_port = htons(rand());
    1438           0 :                 do
    1439             :                 {
    1440          10 :                     in6.sin6_addr.s6_addr16[0] = htons(0xFF00 | (rand() & 255));
    1441             :                 }
    1442          10 :                 while((in6.sin6_addr.s6_addr16[0] & htons(0xFF0F)) == htons(0xFF01)       // ffx1::/16
    1443          10 :                    || (in6.sin6_addr.s6_addr16[0] & htons(0xFF0F)) == htons(0xFF02)       // ffx2::/16
    1444          10 :                    || (in6.sin6_addr.s6_addr16[0] & htons(0xFFC0)) == htons(0xFE80)       // fe80::/10
    1445          20 :                    || (in6.sin6_addr.s6_addr16[0] & htons(0xFF00)) == htons(0xFD00));     // fd00::/8
    1446          10 :                 in6.sin6_addr.s6_addr16[1] = rand();
    1447          10 :                 in6.sin6_addr.s6_addr16[2] = rand();
    1448          10 :                 in6.sin6_addr.s6_addr16[3] = rand();
    1449          10 :                 in6.sin6_addr.s6_addr16[4] = rand();
    1450          10 :                 in6.sin6_addr.s6_addr16[5] = rand();
    1451          10 :                 in6.sin6_addr.s6_addr16[6] = rand();
    1452          10 :                 in6.sin6_addr.s6_addr16[7] = rand();
    1453             : 
    1454             :                 // verify network type
    1455             :                 //
    1456          10 :                 a.set_ipv6(in6);
    1457          10 :                 CATCH_REQUIRE(a.get_network_type() == addr::addr::network_type_t::NETWORK_TYPE_MULTICAST);
    1458          10 :                 CATCH_REQUIRE(a.get_network_type_string() == "Multicast");
    1459             :             }
    1460             :         }
    1461             : 
    1462          14 :         CATCH_SECTION("private address ffx1::/8")
    1463             :         {
    1464          11 :             for(int idx(0); idx < 10; ++idx)
    1465             :             {
    1466          10 :                 struct sockaddr_in6 in6 = sockaddr_in6();
    1467          10 :                 in6.sin6_family = AF_INET6;
    1468          10 :                 in6.sin6_port = htons(rand());
    1469          10 :                 in6.sin6_addr.s6_addr16[0] = htons(0xFF01 | ((rand() & 15) << 4));
    1470          10 :                 in6.sin6_addr.s6_addr16[1] = rand();
    1471          10 :                 in6.sin6_addr.s6_addr16[2] = rand();
    1472          10 :                 in6.sin6_addr.s6_addr16[3] = rand();
    1473          10 :                 in6.sin6_addr.s6_addr16[4] = rand();
    1474          10 :                 in6.sin6_addr.s6_addr16[5] = rand();
    1475          10 :                 in6.sin6_addr.s6_addr16[6] = rand();
    1476          10 :                 in6.sin6_addr.s6_addr16[7] = rand();
    1477             : 
    1478             :                 // verify network type
    1479             :                 //
    1480          10 :                 a.set_ipv6(in6);
    1481          10 :                 CATCH_REQUIRE(a.get_network_type() == addr::addr::network_type_t::NETWORK_TYPE_LOOPBACK);
    1482          10 :                 CATCH_REQUIRE(a.get_network_type_string() == "Loopback");
    1483             :             }
    1484             :         }
    1485             : 
    1486          14 :         CATCH_SECTION("private address ::1")
    1487             :         {
    1488          11 :             for(int idx(0); idx < 10; ++idx)
    1489             :             {
    1490          10 :                 struct sockaddr_in6 in6 = sockaddr_in6();
    1491          10 :                 in6.sin6_family = AF_INET6;
    1492          10 :                 in6.sin6_port = htons(rand());
    1493          10 :                 in6.sin6_addr.s6_addr16[0] = 0;
    1494          10 :                 in6.sin6_addr.s6_addr16[1] = 0;
    1495          10 :                 in6.sin6_addr.s6_addr16[2] = 0;
    1496          10 :                 in6.sin6_addr.s6_addr16[3] = 0;
    1497          10 :                 in6.sin6_addr.s6_addr16[4] = 0;
    1498          10 :                 in6.sin6_addr.s6_addr16[5] = 0;
    1499          10 :                 in6.sin6_addr.s6_addr16[6] = 0;
    1500          10 :                 in6.sin6_addr.s6_addr16[7] = htons(1);
    1501             : 
    1502             :                 // verify network type
    1503             :                 //
    1504          10 :                 a.set_ipv6(in6);
    1505          10 :                 CATCH_REQUIRE(a.get_network_type() == addr::addr::network_type_t::NETWORK_TYPE_LOOPBACK);
    1506          10 :                 CATCH_REQUIRE(a.get_network_type_string() == "Loopback");
    1507             : 
    1508             :                 // try again from a string to confirm
    1509             :                 //
    1510          10 :                 struct addrinfo * addrlist(nullptr);
    1511          10 :                 int const port(rand() & 65535);
    1512          10 :                 int const r(getaddrinfo("::1", std::to_string(port).c_str(), nullptr, &addrlist));
    1513          10 :                 CATCH_REQUIRE(r == 0);
    1514          10 :                 CATCH_REQUIRE(addrlist != nullptr);
    1515          10 :                 CATCH_REQUIRE(addrlist->ai_family == AF_INET6);
    1516          10 :                 CATCH_REQUIRE(addrlist->ai_addrlen == sizeof(struct sockaddr_in6));
    1517          10 :                 a.set_ipv6(*reinterpret_cast<sockaddr_in6 *>(addrlist->ai_addr));
    1518          10 :                 CATCH_REQUIRE(a.get_network_type() == addr::addr::network_type_t::NETWORK_TYPE_LOOPBACK);
    1519          10 :                 CATCH_REQUIRE(a.get_network_type_string() == "Loopback");
    1520          10 :                 freeaddrinfo(addrlist);
    1521             :             }
    1522             :         }
    1523             :     }
    1524           7 : }
    1525             : 
    1526             : 
    1527           5 : CATCH_TEST_CASE( "ipv6::network", "[ipv6]" )
    1528             : {
    1529           6 :     CATCH_GIVEN("set_from_socket()")
    1530             :     {
    1531           6 :         CATCH_SECTION("create a server, but do not test it (yet)...")
    1532             :         {
    1533           2 :             addr::addr_parser p;
    1534           2 :             addr::addr_range::vector_t ips(p.parse("[::1]:49999"));
    1535           1 :             CATCH_REQUIRE(ips.size() >= 1);
    1536             : 
    1537           1 :             addr::addr & a(ips[0].get_from());
    1538           1 :             int s(a.create_socket(addr::addr::SOCKET_FLAG_NONBLOCK | addr::addr::SOCKET_FLAG_CLOEXEC | addr::addr::SOCKET_FLAG_REUSE));
    1539           1 :             CATCH_REQUIRE(s >= 0);
    1540           2 :             std::shared_ptr<int> auto_free(&s, socket_deleter);
    1541             : 
    1542           1 :             CATCH_REQUIRE(a.bind(s) == 0);
    1543             :         }
    1544             : 
    1545           6 :         CATCH_SECTION("connect with TCP to [::1]")
    1546             :         {
    1547           1 :             if(SNAP_CATCH2_NAMESPACE::g_tcp_port != -1)
    1548             :             {
    1549           2 :                 addr::addr_parser p;
    1550           2 :                 addr::addr_range::vector_t ips(p.parse("[::1]:" + std::to_string(SNAP_CATCH2_NAMESPACE::g_tcp_port)));
    1551           1 :                 CATCH_REQUIRE(ips.size() >= 1);
    1552             : 
    1553           1 :                 addr::addr & a(ips[0].get_from());
    1554           1 :                 int s(a.create_socket(addr::addr::SOCKET_FLAG_CLOEXEC));// | addr::addr::SOCKET_FLAG_REUSE));
    1555           1 :                 CATCH_REQUIRE(s >= 0);
    1556           2 :                 std::shared_ptr<int> auto_free(&s, socket_deleter);
    1557             : 
    1558           1 :                 CATCH_REQUIRE(a.connect(s) == 0);
    1559             : 
    1560             :                 // get socket info from the other side (peer == true)
    1561             :                 //
    1562           1 :                 addr::addr b;
    1563           1 :                 b.set_from_socket(s, true);
    1564           1 :                 CATCH_REQUIRE_FALSE(b.is_ipv4());
    1565           1 :                 CATCH_REQUIRE(b.to_ipv6_string(addr::addr::string_ip_t::STRING_IP_ONLY)    == "::1");
    1566           1 :                 CATCH_REQUIRE(b.to_ipv4or6_string(addr::addr::string_ip_t::STRING_IP_ONLY) == "::1");
    1567             : 
    1568             :                 // in this case we know what the port is since we specified
    1569             :                 // that when connecting
    1570             :                 //
    1571           1 :                 CATCH_REQUIRE(b.get_port() == SNAP_CATCH2_NAMESPACE::g_tcp_port);
    1572             : 
    1573             :                 // now try this side (peer == false)
    1574             :                 //
    1575           1 :                 addr::addr c;
    1576           1 :                 c.set_from_socket(s, false);
    1577           1 :                 CATCH_REQUIRE_FALSE(c.is_ipv4());
    1578           1 :                 CATCH_REQUIRE(c.to_ipv6_string(addr::addr::string_ip_t::STRING_IP_ONLY)    == "::1");
    1579           1 :                 CATCH_REQUIRE(c.to_ipv4or6_string(addr::addr::string_ip_t::STRING_IP_ONLY) == "::1");
    1580             : 
    1581             :                 // we cannot be sure of the port, there is a range we could
    1582             :                 // test better (more constraining) but for this test is
    1583             :                 // certainly does not matter much; it has to be more than
    1584             :                 // 1023, though
    1585             :                 //
    1586           1 :                 CATCH_REQUIRE(c.get_port() > 1023);
    1587             :             }
    1588             :             else
    1589             :             {
    1590             :                 // avoid issue of no assertions
    1591             :                 //
    1592           0 :                 CATCH_REQUIRE(SNAP_CATCH2_NAMESPACE::g_tcp_port == -1);
    1593           0 :                 std::cout << "connect to [::1] test skipped as no TCP port was specified on the command line." << std::endl;
    1594             :             }
    1595             :         }
    1596             : 
    1597           6 :         CATCH_SECTION("connect with UDP to [::1]")
    1598             :         {
    1599           2 :             addr::addr_parser p;
    1600           1 :             p.set_protocol("udp");
    1601           2 :             addr::addr_range::vector_t ips(p.parse("[::1]:53"));
    1602           1 :             CATCH_REQUIRE(ips.size() >= 1);
    1603             : 
    1604           1 :             addr::addr & a(ips[0].get_from());
    1605           1 :             int s(a.create_socket(addr::addr::SOCKET_FLAG_CLOEXEC));// | addr::addr::SOCKET_FLAG_REUSE));
    1606           1 :             CATCH_REQUIRE(s >= 0);
    1607           2 :             std::shared_ptr<int> auto_free(&s, socket_deleter);
    1608             : 
    1609           1 :             CATCH_REQUIRE(a.connect(s) == -1);
    1610             : 
    1611             :             // get socket info from the other side (peer == true)
    1612             :             //
    1613           1 :             addr::addr b;
    1614           1 :             CATCH_REQUIRE_THROWS_AS(b.set_from_socket(s, true), addr::addr_io_error);
    1615           1 :             CATCH_REQUIRE_FALSE(b.is_ipv4());
    1616           1 :             CATCH_REQUIRE(b.to_ipv6_string(addr::addr::string_ip_t::STRING_IP_ONLY)    == "::");
    1617           1 :             CATCH_REQUIRE(b.to_ipv4or6_string(addr::addr::string_ip_t::STRING_IP_ONLY) == "::");
    1618             : 
    1619             :             // in this case we know what the port is since we specified
    1620             :             // that when connecting
    1621             :             //
    1622           1 :             CATCH_REQUIRE(b.get_port() == 0);
    1623             : 
    1624             :             // now try this side (peer == false)
    1625             :             //
    1626           1 :             addr::addr c;
    1627           1 :             c.set_from_socket(s, false);
    1628           1 :             CATCH_REQUIRE_FALSE(c.is_ipv4());
    1629           1 :             CATCH_REQUIRE(c.to_ipv6_string(addr::addr::string_ip_t::STRING_IP_ONLY)    == "::");
    1630           1 :             CATCH_REQUIRE(c.to_ipv4or6_string(addr::addr::string_ip_t::STRING_IP_ONLY) == "::");
    1631             : 
    1632             :             // we cannot be sure of the port, there is a range we could
    1633             :             // test better (more constraining) but for this test is
    1634             :             // certainly does not matter much; it has to be more than
    1635             :             // 1023, though
    1636             :             //
    1637           1 :             CATCH_REQUIRE(c.get_port() == 0);
    1638             :         }
    1639             :     }
    1640           9 : }
    1641             : 
    1642             : 
    1643             : // vim: ts=4 sw=4 et

Generated by: LCOV version 1.13