WIP

Signed-off-by: Alyssa Wilk <alyssar@chromium.org>

source/common/listener_manager/filter_chain_manager_impl.cc

@@ -28,7 +28,7 @@ namespace FilterChain {
 // when no IP matcher is configured.
 Network::Address::InstanceConstSharedPtr fakeAddress() {
   CONSTRUCT_ON_FIRST_USE(Network::Address::InstanceConstSharedPtr,
-                         Network::Utility::parseInternetAddress("255.255.255.255"));
+                         Network::Utility::parseInternetAddressNoThrow("255.255.255.255"));
 }
 
 struct FilterChainNameAction

source/common/network/resolver_impl.cc

@@ -26,8 +26,12 @@ class IpResolver : public Resolver {
     case envoy::config::core::v3::SocketAddress::PortSpecifierCase::kPortValue:
     // Default to port 0 if no port value is specified.
     case envoy::config::core::v3::SocketAddress::PortSpecifierCase::PORT_SPECIFIER_NOT_SET:
-      return Network::Utility::parseInternetAddress(
+      auto addr = Network::Utility::parseInternetAddressNoThrow(
           socket_address.address(), socket_address.port_value(), !socket_address.ipv4_compat());
+      if (!addr) {
+        return absl::InvalidArgumentError(absl::StrCat("malformed IP address: ", socket_address.address()));
+      }
+      return addr;
     case envoy::config::core::v3::SocketAddress::PortSpecifierCase::kNamedPort:
       break;
     }

source/common/network/utility.cc

@@ -160,16 +160,6 @@ Address::InstanceConstSharedPtr Utility::parseInternetAddressNoThrow(const std::
   return nullptr;
 }
 
-Address::InstanceConstSharedPtr Utility::parseInternetAddress(const std::string& ip_address,
-                                                              uint16_t port, bool v6only) {
-  const Address::InstanceConstSharedPtr address =
-      parseInternetAddressNoThrow(ip_address, port, v6only);
-  if (address == nullptr) {
-    throwEnvoyExceptionOrPanic(absl::StrCat("malformed IP address: ", ip_address));
-  }
-  return address;
-}
-
 Address::InstanceConstSharedPtr
 Utility::parseInternetAddressAndPortNoThrow(const std::string& ip_address, bool v6only) {
   if (ip_address.empty()) {

source/common/network/utility.h

@@ -240,18 +240,6 @@ class Utility {
   static Address::InstanceConstSharedPtr getAddressWithPort(const Address::Instance& address,
                                                             uint32_t port);
 
-  /**
-   * Parse an internet host address (IPv4 or IPv6) and create an Instance from it. The address must
-   * not include a port number. Throws EnvoyException if unable to parse the address.
-   * @param ip_address string to be parsed as an internet address.
-   * @param port optional port to include in Instance created from ip_address, 0 by default.
-   * @param v6only disable IPv4-IPv6 mapping for IPv6 addresses?
-   * @return pointer to the Instance.
-   * @throw EnvoyException in case of a malformed IP address.
-   */
-  static Address::InstanceConstSharedPtr
-  parseInternetAddress(const std::string& ip_address, uint16_t port = 0, bool v6only = true);
-
   /**
    * Retrieve the original destination address from an accepted socket.
    * The address (IP and port) may be not local and the port may differ from

source/extensions/filters/udp/dns_filter/dns_filter.cc

@@ -55,7 +55,10 @@ DnsFilterEnvoyConfig::DnsFilterEnvoyConfig(
       // Creating the IP address will throw an exception if the address string is malformed
       for (auto index = 0; index < address_list.size(); index++) {
         const auto address_iter = std::next(address_list.begin(), (i++ % address_list.size()));
-        auto ipaddr = Network::Utility::parseInternetAddress(*address_iter, 0 /* port */);
+        auto ipaddr = Network::Utility::parseInternetAddressNoThrow(*address_iter, 0 /* port */);
+        if (!ipaddr) {
+          throw EnvoyException(absl::StrCat("malformed IP address: ", *address_iter));
+        }
         addrs.push_back(std::move(ipaddr));
       }
 

test/common/common/dns_utils_test.cc

@@ -20,11 +20,11 @@ TEST(DnsUtils, MultipleGenerateTest) {
 
 TEST(DnsUtils, ListChanged) {
   Network::Address::InstanceConstSharedPtr address1 =
-      Network::Utility::parseInternetAddress("10.0.0.1");
+      Network::Utility::parseInternetAddressNoThrow("10.0.0.1");
   Network::Address::InstanceConstSharedPtr address1_dup =
-      Network::Utility::parseInternetAddress("10.0.0.1");
+      Network::Utility::parseInternetAddressNoThrow("10.0.0.1");
   Network::Address::InstanceConstSharedPtr address2 =
-      Network::Utility::parseInternetAddress("10.0.0.2");
+      Network::Utility::parseInternetAddressNoThrow("10.0.0.2");
 
   std::vector<Network::Address::InstanceConstSharedPtr> addresses1 = {address1, address2};
   std::vector<Network::Address::InstanceConstSharedPtr> addresses2 = {address1_dup, address2};

test/common/listener_manager/filter_chain_benchmark_test.cc

@@ -56,16 +56,16 @@ class MockConnectionSocket : public Network::ConnectionSocket {
           std::make_shared<Network::Address::PipeInstance>(destination_address));
     } else {
       res->connection_info_provider_->setLocalAddress(
-          Network::Utility::parseInternetAddress(destination_address, destination_port));
+          Network::Utility::parseInternetAddressNoThrow(destination_address, destination_port));
     }
     if (absl::StartsWith(source_address, "/")) {
       res->connection_info_provider_->setRemoteAddress(
           std::make_shared<Network::Address::PipeInstance>(source_address));
     } else {
       res->connection_info_provider_->setRemoteAddress(
-          Network::Utility::parseInternetAddress(source_address, source_port));
+          Network::Utility::parseInternetAddressNoThrow(source_address, source_port));
       res->connection_info_provider_->setDirectRemoteAddressForTest(
-          Network::Utility::parseInternetAddress(source_address, source_port));
+          Network::Utility::parseInternetAddressNoThrow(source_address, source_port));
     }
     res->server_name_ = server_name;
     res->ja3_hash_ = ja3_hash;

test/common/listener_manager/filter_chain_manager_impl_test.cc

@@ -82,7 +82,7 @@ class FilterChainManagerImplTest : public testing::TestWithParam<bool> {
       local_address_ = std::make_shared<Network::Address::PipeInstance>(destination_address);
     } else {
       local_address_ =
-          Network::Utility::parseInternetAddress(destination_address, destination_port);
+          Network::Utility::parseInternetAddressNoThrow(destination_address, destination_port);
     }
     mock_socket->connection_info_provider_->setLocalAddress(local_address_);
 
@@ -96,7 +96,7 @@ class FilterChainManagerImplTest : public testing::TestWithParam<bool> {
     if (absl::StartsWith(source_address, "/")) {
       remote_address_ = std::make_shared<Network::Address::PipeInstance>(source_address);
     } else {
-      remote_address_ = Network::Utility::parseInternetAddress(source_address, source_port);
+      remote_address_ = Network::Utility::parseInternetAddressNoThrow(source_address, source_port);
     }
     mock_socket->connection_info_provider_->setRemoteAddress(remote_address_);
     NiceMock<StreamInfo::MockStreamInfo> stream_info;

test/common/listener_manager/listener_manager_impl_test.cc

@@ -6519,7 +6519,7 @@ TEST_P(ListenerManagerImplWithRealFiltersTest, AddressResolver) {
   NiceMock<Network::MockAddressResolver> mock_resolver;
   EXPECT_CALL(mock_resolver, resolve(_))
       .Times(2)
-      .WillRepeatedly(Return(Network::Utility::parseInternetAddress("127.0.0.1", 1111, false)));
+      .WillRepeatedly(Return(Network::Utility::parseInternetAddressNoThrow("127.0.0.1", 1111, false)));
   Registry::InjectFactory<Network::Address::Resolver> register_resolver(mock_resolver);
 
   EXPECT_CALL(listener_factory_, createListenSocket(_, _, _, default_bind_type, _, 0));

test/common/listener_manager/listener_manager_impl_test.h

@@ -228,7 +228,7 @@ class ListenerManagerImplTest : public testing::TestWithParam<bool> {
       local_address_ = std::make_shared<Network::Address::PipeInstance>(destination_address);
     } else {
       local_address_ =
-          Network::Utility::parseInternetAddress(destination_address, destination_port);
+          Network::Utility::parseInternetAddressNoThrow(destination_address, destination_port);
     }
     socket_->connection_info_provider_->setLocalAddress(local_address_);
 
@@ -242,7 +242,7 @@ class ListenerManagerImplTest : public testing::TestWithParam<bool> {
     if (absl::StartsWith(source_address, "/")) {
       remote_address_ = std::make_shared<Network::Address::PipeInstance>(source_address);
     } else {
-      remote_address_ = Network::Utility::parseInternetAddress(source_address, source_port);
+      remote_address_ = Network::Utility::parseInternetAddressNoThrow(source_address, source_port);
     }
     socket_->connection_info_provider_->setRemoteAddress(remote_address_);
 
@@ -254,7 +254,7 @@ class ListenerManagerImplTest : public testing::TestWithParam<bool> {
           std::make_shared<Network::Address::PipeInstance>(direct_source_address);
     } else {
       direct_remote_address_ =
-          Network::Utility::parseInternetAddress(direct_source_address, source_port);
+          Network::Utility::parseInternetAddressNoThrow(direct_source_address, source_port);
     }
     socket_->connection_info_provider_->setDirectRemoteAddressForTest(direct_remote_address_);
 

test/common/network/address_impl_test.cc

@@ -100,7 +100,7 @@ void testSocketBindAndConnect(Network::Address::IpVersion ip_version, bool v6onl
 
   if (!v6only) {
     ASSERT_EQ(IpVersion::v6, addr_port->ip()->version());
-    auto v4_addr_port = Network::Utility::parseInternetAddress(
+    auto v4_addr_port = Network::Utility::parseInternetAddressNoThrow(
         Network::Test::getLoopbackAddressUrlString(Network::Address::IpVersion::v4),
         addr_port->ip()->port(), true);
     ASSERT_NE(v4_addr_port, nullptr);
@@ -157,7 +157,7 @@ TEST(Ipv4InstanceTest, SocketAddress) {
   EXPECT_EQ("1.2.3.4", address.ip()->addressAsString());
   EXPECT_EQ(6502U, address.ip()->port());
   EXPECT_EQ(IpVersion::v4, address.ip()->version());
-  EXPECT_TRUE(addressesEqual(Network::Utility::parseInternetAddress("1.2.3.4"), address));
+  EXPECT_TRUE(addressesEqual(Network::Utility::parseInternetAddressNoThrow("1.2.3.4"), address));
   EXPECT_EQ(nullptr, address.ip()->ipv6());
   EXPECT_TRUE(address.ip()->isUnicastAddress());
   EXPECT_EQ(nullptr, address.pipe());
@@ -172,7 +172,7 @@ TEST(Ipv4InstanceTest, AddressOnly) {
   EXPECT_EQ("3.4.5.6", address.ip()->addressAsString());
   EXPECT_EQ(0U, address.ip()->port());
   EXPECT_EQ(IpVersion::v4, address.ip()->version());
-  EXPECT_TRUE(addressesEqual(Network::Utility::parseInternetAddress("3.4.5.6"), address));
+  EXPECT_TRUE(addressesEqual(Network::Utility::parseInternetAddressNoThrow("3.4.5.6"), address));
   EXPECT_TRUE(address.ip()->isUnicastAddress());
 }
 
@@ -185,7 +185,7 @@ TEST(Ipv4InstanceTest, AddressAndPort) {
   EXPECT_FALSE(address.ip()->isAnyAddress());
   EXPECT_EQ(80U, address.ip()->port());
   EXPECT_EQ(IpVersion::v4, address.ip()->version());
-  EXPECT_TRUE(addressesEqual(Network::Utility::parseInternetAddress("127.0.0.1"), address));
+  EXPECT_TRUE(addressesEqual(Network::Utility::parseInternetAddressNoThrow("127.0.0.1"), address));
   EXPECT_TRUE(address.ip()->isUnicastAddress());
 }
 
@@ -198,7 +198,7 @@ TEST(Ipv4InstanceTest, PortOnly) {
   EXPECT_TRUE(address.ip()->isAnyAddress());
   EXPECT_EQ(443U, address.ip()->port());
   EXPECT_EQ(IpVersion::v4, address.ip()->version());
-  EXPECT_TRUE(addressesEqual(Network::Utility::parseInternetAddress("0.0.0.0"), address));
+  EXPECT_TRUE(addressesEqual(Network::Utility::parseInternetAddressNoThrow("0.0.0.0"), address));
   EXPECT_FALSE(address.ip()->isUnicastAddress());
 }
 
@@ -211,7 +211,7 @@ TEST(Ipv4InstanceTest, Multicast) {
   EXPECT_FALSE(address.ip()->isAnyAddress());
   EXPECT_EQ(0U, address.ip()->port());
   EXPECT_EQ(IpVersion::v4, address.ip()->version());
-  EXPECT_TRUE(addressesEqual(Network::Utility::parseInternetAddress("230.0.0.1"), address));
+  EXPECT_TRUE(addressesEqual(Network::Utility::parseInternetAddressNoThrow("230.0.0.1"), address));
   EXPECT_FALSE(address.ip()->isUnicastAddress());
 }
 
@@ -223,7 +223,7 @@ TEST(Ipv4InstanceTest, Broadcast) {
   EXPECT_EQ("255.255.255.255", address.ip()->addressAsString());
   EXPECT_EQ(0U, address.ip()->port());
   EXPECT_EQ(IpVersion::v4, address.ip()->version());
-  EXPECT_TRUE(addressesEqual(Network::Utility::parseInternetAddress("255.255.255.255"), address));
+  EXPECT_TRUE(addressesEqual(Network::Utility::parseInternetAddressNoThrow("255.255.255.255"), address));
   EXPECT_FALSE(address.ip()->isUnicastAddress());
 }
 
@@ -247,7 +247,7 @@ TEST(Ipv6InstanceTest, SocketAddress) {
   EXPECT_FALSE(address.ip()->isAnyAddress());
   EXPECT_EQ(32000U, address.ip()->port());
   EXPECT_EQ(IpVersion::v6, address.ip()->version());
-  EXPECT_TRUE(addressesEqual(Network::Utility::parseInternetAddress("1:0023::0Ef"), address));
+  EXPECT_TRUE(addressesEqual(Network::Utility::parseInternetAddressNoThrow("1:0023::0Ef"), address));
   EXPECT_EQ(nullptr, address.ip()->ipv4());
   EXPECT_TRUE(address.ip()->isUnicastAddress());
   EXPECT_EQ(nullptr, address.pipe());
@@ -263,7 +263,7 @@ TEST(Ipv6InstanceTest, AddressOnly) {
   EXPECT_EQ(0U, address.ip()->port());
   EXPECT_EQ(IpVersion::v6, address.ip()->version());
   EXPECT_TRUE(addressesEqual(
-      Network::Utility::parseInternetAddress("2001:db8:85a3::8a2e:0370:7334"), address));
+      Network::Utility::parseInternetAddressNoThrow("2001:db8:85a3::8a2e:0370:7334"), address));
   EXPECT_TRUE(address.ip()->isUnicastAddress());
 }
 
@@ -275,7 +275,7 @@ TEST(Ipv6InstanceTest, AddressAndPort) {
   EXPECT_EQ("::1", address.ip()->addressAsString());
   EXPECT_EQ(80U, address.ip()->port());
   EXPECT_EQ(IpVersion::v6, address.ip()->version());
-  EXPECT_TRUE(addressesEqual(Network::Utility::parseInternetAddress("0:0:0:0:0:0:0:1"), address));
+  EXPECT_TRUE(addressesEqual(Network::Utility::parseInternetAddressNoThrow("0:0:0:0:0:0:0:1"), address));
   EXPECT_TRUE(address.ip()->isUnicastAddress());
 }
 
@@ -306,7 +306,7 @@ TEST(Ipv6InstanceTest, PortOnly) {
   EXPECT_TRUE(address.ip()->isAnyAddress());
   EXPECT_EQ(443U, address.ip()->port());
   EXPECT_EQ(IpVersion::v6, address.ip()->version());
-  EXPECT_TRUE(addressesEqual(Network::Utility::parseInternetAddress("::0000"), address));
+  EXPECT_TRUE(addressesEqual(Network::Utility::parseInternetAddressNoThrow("::0000"), address));
   EXPECT_FALSE(address.ip()->isUnicastAddress());
 }
 
@@ -320,7 +320,7 @@ TEST(Ipv6InstanceTest, Multicast) {
   EXPECT_EQ(0U, address.ip()->port());
   EXPECT_EQ(IpVersion::v6, address.ip()->version());
   EXPECT_TRUE(addressesEqual(
-      Network::Utility::parseInternetAddress("FF00:0000:0000:0000:0000:0000:0000:0000"), address));
+      Network::Utility::parseInternetAddressNoThrow("FF00:0000:0000:0000:0000:0000:0000:0000"), address));
   EXPECT_FALSE(address.ip()->isUnicastAddress());
 }
 
@@ -332,7 +332,7 @@ TEST(Ipv6InstanceTest, Broadcast) {
   EXPECT_EQ(0U, address.ip()->port());
   EXPECT_EQ(IpVersion::v6, address.ip()->version());
   EXPECT_TRUE(addressesEqual(
-      Network::Utility::parseInternetAddress("FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF"), address));
+      Network::Utility::parseInternetAddressNoThrow("FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF"), address));
   EXPECT_FALSE(address.ip()->isUnicastAddress());
 }
 

test/common/network/cidr_range_test.cc

@@ -69,7 +69,7 @@ TEST(TruncateIpAddressAndLength, Various) {
       {{"ffff::ffff", 999}, {"ffff::ffff", 128}},
   };
   for (const auto& kv : test_cases) {
-    InstanceConstSharedPtr inPtr = Utility::parseInternetAddress(kv.first.first);
+    InstanceConstSharedPtr inPtr = Utility::parseInternetAddressNoThrow(kv.first.first);
     EXPECT_NE(inPtr, nullptr) << kv.first.first;
     int length_io = kv.first.second;
     InstanceConstSharedPtr outPtr = CidrRange::truncateIpAddressAndLength(inPtr, &length_io);
@@ -202,7 +202,7 @@ TEST(CidrRangeTest, OperatorIsEqual) {
 TEST(CidrRangeTest, InvalidCidrRange) { EXPECT_FALSE(CidrRange::create("foo").status().ok()); }
 
 TEST(Ipv4CidrRangeTest, InstanceConstSharedPtrAndLengthCtor) {
-  InstanceConstSharedPtr ptr = Utility::parseInternetAddress("1.2.3.5");
+  InstanceConstSharedPtr ptr = Utility::parseInternetAddressNoThrow("1.2.3.5");
   CidrRange rng(*CidrRange::create(ptr, 31)); // Copy ctor.
   EXPECT_EQ(rng.length(), 31);
   EXPECT_EQ(rng.ip()->version(), IpVersion::v4);
@@ -267,7 +267,7 @@ TEST(Ipv4CidrRangeTest, BigRange) {
 }
 
 TEST(Ipv6CidrRange, InstanceConstSharedPtrAndLengthCtor) {
-  InstanceConstSharedPtr ptr = Utility::parseInternetAddress("abcd::0345");
+  InstanceConstSharedPtr ptr = Utility::parseInternetAddressNoThrow("abcd::0345");
   CidrRange rng(*CidrRange::create(ptr, 127)); // Copy ctor.
   EXPECT_EQ(rng.length(), 127);
   EXPECT_EQ(rng.ip()->version(), IpVersion::v6);

test/common/network/lc_trie_speed_test.cc

@@ -12,7 +12,7 @@ struct AddressInputs {
         "192.0.2.225",   "198.51.100.55", "198.51.100.105", "192.0.2.150",   "203.0.113.162",
         "203.0.113.110", "203.0.113.99",  "198.51.100.23",  "198.51.100.24", "203.0.113.12"};
     for (const auto& address : test_addresses) {
-      addresses_.push_back(Envoy::Network::Utility::parseInternetAddress(address));
+      addresses_.push_back(Envoy::Network::Utility::parseInternetAddressNoThrow(address));
     }
   }
 

test/common/network/lc_trie_test.cc

@@ -40,7 +40,7 @@ class LcTrieTest : public testing::Test {
     for (const auto& kv : test_output) {
       std::vector<std::string> expected(kv.second);
       std::sort(expected.begin(), expected.end());
-      std::vector<std::string> actual(trie_->getData(Utility::parseInternetAddress(kv.first)));
+      std::vector<std::string> actual(trie_->getData(Utility::parseInternetAddressNoThrow(kv.first)));
       std::sort(actual.begin(), actual.end());
       EXPECT_EQ(expected, actual);
     }

test/common/network/listen_socket_impl_test.cc

@@ -207,7 +207,7 @@ TEST_P(ListenSocketImplTestTcp, SetLocalAddress) {
     address_str = "1::2";
   }
 
-  Address::InstanceConstSharedPtr address = Network::Utility::parseInternetAddress(address_str);
+  Address::InstanceConstSharedPtr address = Network::Utility::parseInternetAddressNoThrow(address_str);
 
   TestListenSocket socket(Utility::getIpv4AnyAddress());
 

test/common/network/utility_fuzz_test.cc

@@ -12,7 +12,7 @@ DEFINE_FUZZER(const uint8_t* buf, size_t len) {
   const std::string string_buffer(reinterpret_cast<const char*>(buf), len);
 
   try {
-    Network::Utility::parseInternetAddress(string_buffer);
+    Network::Utility::parseInternetAddressNoThrow(string_buffer);
   } catch (const EnvoyException& e) {
     ENVOY_LOG_MISC(debug, "EnvoyException: {}", e.what());
   }