exception: make Ipv6Instance and Ipv4Instance not throw and remove some try catch pattern

source/common/network/address_impl.cc

@@ -77,6 +77,15 @@ StatusOr<Address::InstanceConstSharedPtr> addressFromSockAddr(const sockaddr_sto
   NOT_REACHED_GCOVR_EXCL_LINE;
 }
 
+Address::InstanceConstSharedPtr addressFromSockAddrOrThrow(const sockaddr_storage& ss,
+                                                           socklen_t ss_len, bool v6only) {
+  StatusOr<InstanceConstSharedPtr> address = addressFromSockAddr(ss, ss_len, v6only);
+  if (!address.ok()) {
+    throw EnvoyException(address.status().ToString());
+  }
+  return *address;
+}
+
 Address::InstanceConstSharedPtr
 getAddressFromSockAddrOrDie(const sockaddr_storage& ss, socklen_t ss_len, os_fd_t fd, bool v6only) {
   // Set v6only to false so that mapped-v6 address can be normalize to v4

source/common/network/address_impl.h

@@ -29,6 +29,8 @@ namespace Address {
  */
 StatusOr<InstanceConstSharedPtr> addressFromSockAddr(const sockaddr_storage& ss, socklen_t len,
                                                      bool v6only = true);
+InstanceConstSharedPtr addressFromSockAddrOrThrow(const sockaddr_storage& ss, socklen_t len,
+                                                  bool v6only = true);
 
 Address::InstanceConstSharedPtr getAddressFromSockAddrOrDie(const sockaddr_storage& ss,
                                                             socklen_t ss_len, os_fd_t fd,
@@ -135,6 +137,7 @@ class Ipv4Instance : public InstanceBase {
 private:
   /**
    * Construct from an existing unix IPv4 socket address (IP v4 address and port).
+   * Store the status code in passed in parameter instead of throwing.
    */
   explicit Ipv4Instance(absl::Status& error, const sockaddr_in* address,
                         const SocketInterface* sock_interface = nullptr);
@@ -213,6 +216,7 @@ class Ipv6Instance : public InstanceBase {
 private:
   /**
    * Construct from an existing unix IPv6 socket address (IP v6 address and port).
+   * Store the status code in passed in parameter instead of throwing.
    */
   Ipv6Instance(absl::Status& error, const sockaddr_in6& address, bool v6only = true,
                const SocketInterface* sock_interface = nullptr);

source/common/network/io_socket_handle_impl.cc

@@ -586,7 +586,7 @@ Address::InstanceConstSharedPtr IoSocketHandleImpl::localAddress() {
     throw EnvoyException(fmt::format("getsockname failed for '{}': ({}) {}", fd_, result.errno_,
                                      errorDetails(result.errno_)));
   }
-  return Address::getAddressFromSockAddrOrDie(ss, ss_len, -1, socket_v6only_);
+  return Address::addressFromSockAddrOrThrow(ss, ss_len, socket_v6only_);
 }
 
 Address::InstanceConstSharedPtr IoSocketHandleImpl::peerAddress() {
@@ -611,7 +611,7 @@ Address::InstanceConstSharedPtr IoSocketHandleImpl::peerAddress() {
           fmt::format("getsockname failed for '{}': {}", fd_, errorDetails(result.errno_)));
     }
   }
-  return Address::getAddressFromSockAddrOrDie(ss, ss_len, -1, true);
+  return Address::addressFromSockAddrOrThrow(ss, ss_len, socket_v6only_);
 }
 
 void IoSocketHandleImpl::initializeFileEvent(Event::Dispatcher& dispatcher, Event::FileReadyCb cb,

source/common/network/tcp_listener_impl.cc

@@ -82,14 +82,13 @@ void TcpListenerImpl::onSocketEvent(short flags) {
     // Pass the 'v6only' parameter as true if the local_address is an IPv6 address. This has no
     // effect if the socket is a v4 socket, but for v6 sockets this will create an IPv4 remote
     // address if an IPv4 local_address was created from an IPv6 mapped IPv4 address.
-    Address::InstanceConstSharedPtr remote_address;
-    if (remote_addr.ss_family == AF_UNIX) {
-      remote_address = io_handle->peerAddress();
-    } else {
-      remote_address = Address::getAddressFromSockAddrOrDie(remote_addr, remote_addr_len, -1,
-                                                            local_address->ip()->version() ==
-                                                                Address::IpVersion::v6);
-    }
+
+    const Address::InstanceConstSharedPtr remote_address =
+        (remote_addr.ss_family == AF_UNIX)
+            ? io_handle->peerAddress()
+            : Address::addressFromSockAddrOrThrow(remote_addr, remote_addr_len,
+                                                  local_address->ip()->version() ==
+                                                      Address::IpVersion::v6);
 
     cb_.onAccept(
         std::make_unique<AcceptedSocketImpl>(std::move(io_handle), local_address, remote_address));

source/common/network/utility.cc

@@ -129,19 +129,28 @@ uint32_t Utility::portFromUdpUrl(const std::string& url) {
 
 Address::InstanceConstSharedPtr Utility::parseInternetAddressNoThrow(const std::string& ip_address,
                                                                      uint16_t port, bool v6only) {
-  Address::InstanceConstSharedPtr address;
   sockaddr_in sa4;
   if (inet_pton(AF_INET, ip_address.c_str(), &sa4.sin_addr) == 1) {
     sa4.sin_family = AF_INET;
     sa4.sin_port = htons(port);
-    return Address::InstanceFactory::createInstancePtrOrDie<Address::Ipv4Instance>(&sa4);
+    StatusOr<Address::InstanceConstSharedPtr> address =
+        Address::InstanceFactory::createInstancePtr<Address::Ipv4Instance>(&sa4);
+    if (address.ok()) {
+      return *address;
+    }
+    return nullptr;
   }
   sockaddr_in6 sa6;
   memset(&sa6, 0, sizeof(sa6));
   if (inet_pton(AF_INET6, ip_address.c_str(), &sa6.sin6_addr) == 1) {
     sa6.sin6_family = AF_INET6;
     sa6.sin6_port = htons(port);
-    return Address::InstanceFactory::createInstancePtrOrDie<Address::Ipv6Instance>(sa6, v6only);
+    StatusOr<Address::InstanceConstSharedPtr> address =
+        Address::InstanceFactory::createInstancePtr<Address::Ipv6Instance>(sa6, v6only);
+    if (address.ok()) {
+      return *address;
+    }
+    return nullptr;
   }
   return nullptr;
 }
@@ -180,7 +189,12 @@ Utility::parseInternetAddressAndPortNoThrow(const std::string& ip_address, bool
     }
     sa6.sin6_family = AF_INET6;
     sa6.sin6_port = htons(port64);
-    return Address::InstanceFactory::createInstancePtrOrDie<Address::Ipv6Instance>(sa6, v6only);
+    StatusOr<Address::InstanceConstSharedPtr> address =
+        Address::InstanceFactory::createInstancePtr<Address::Ipv6Instance>(sa6, v6only);
+    if (address.ok()) {
+      return *address;
+    }
+    return nullptr;
   }
   // Treat it as an IPv4 address followed by a port.
   const auto pos = ip_address.rfind(':');
@@ -200,7 +214,12 @@ Utility::parseInternetAddressAndPortNoThrow(const std::string& ip_address, bool
   }
   sa4.sin_family = AF_INET;
   sa4.sin_port = htons(port64);
-  return Address::InstanceFactory::createInstancePtrOrDie<Address::Ipv4Instance>(&sa4);
+  StatusOr<Address::InstanceConstSharedPtr> address =
+      Address::InstanceFactory::createInstancePtrOrDie<Address::Ipv4Instance>(&sa4);
+  if (address.ok()) {
+    return *address;
+  }
+  return nullptr;
 }
 
 Address::InstanceConstSharedPtr Utility::parseInternetAddressAndPort(const std::string& ip_address,
@@ -248,9 +267,8 @@ Address::InstanceConstSharedPtr Utility::getLocalAddress(const Address::IpVersio
         (ifa->ifa_addr->sa_family == AF_INET6 && version == Address::IpVersion::v6)) {
       const struct sockaddr_storage* addr =
           reinterpret_cast<const struct sockaddr_storage*>(ifa->ifa_addr);
-      ret = Address::getAddressFromSockAddrOrDie(
-          *addr, (version == Address::IpVersion::v4) ? sizeof(sockaddr_in) : sizeof(sockaddr_in6),
-          -1, true);
+      ret = Address::addressFromSockAddrOrThrow(
+          *addr, (version == Address::IpVersion::v4) ? sizeof(sockaddr_in) : sizeof(sockaddr_in6));
       if (!isLoopbackAddress(*ret)) {
         break;
       }

source/common/quic/envoy_quic_utils.cc

@@ -17,14 +17,14 @@ namespace Quic {
 // the heap allocation is too expensive.
 Network::Address::InstanceConstSharedPtr
 quicAddressToEnvoyAddressInstance(const quic::QuicSocketAddress& quic_address) {
-  if (!quic_address.IsInitialized()) {
-    return nullptr;
-  }
-  return Network::Address::getAddressFromSockAddrOrDie(
-      quic_address.generic_address(),
-      quic_address.host().address_family() == quic::IpAddressFamily::IP_V4 ? sizeof(sockaddr_in)
-                                                                           : sizeof(sockaddr_in6),
-      -1, false);
+  return quic_address.IsInitialized()
+             ? Network::Address::addressFromSockAddrOrThrow(quic_address.generic_address(),
+                                                            quic_address.host().address_family() ==
+                                                                    quic::IpAddressFamily::IP_V4
+                                                                ? sizeof(sockaddr_in)
+                                                                : sizeof(sockaddr_in6),
+                                                            false)
+             : nullptr;
 }
 
 quic::QuicSocketAddress envoyIpAddressToQuicSocketAddress(const Network::Address::Ip* envoy_ip) {

source/common/upstream/strict_dns_cluster.cc

@@ -129,12 +129,10 @@ void StrictDnsClusterImpl::ResolveTarget::startResolve() {
             // make a new address that has port in it. We need to both support IPv6 as well as
             // potentially move port handling into the DNS interface itself, which would work better
             // for SRV.
-
             ASSERT(resp.address_ != nullptr);
-            Network::Address::InstanceConstSharedPtr new_address =
-                Network::Utility::getAddressWithPort(*(resp.address_), port_);
             new_hosts.emplace_back(new HostImpl(
-                parent_.info_, hostname_, new_address,
+                parent_.info_, hostname_,
+                Network::Utility::getAddressWithPort(*(resp.address_), port_),
                 // TODO(zyfjeff): Created through metadata shared pool
                 std::make_shared<const envoy::config::core::v3::Metadata>(lb_endpoint_.metadata()),
                 lb_endpoint_.load_balancing_weight().value(), locality_lb_endpoints_.locality(),

test/common/network/dns_impl_test.cc

@@ -697,7 +697,6 @@ TEST_P(DnsImplTest, DestroyChannelOnRefused) {
   // If that flag needs to be set, or c-ares changes its handling this test will need to be updated
   // to create another condition where c-ares invokes onAresGetAddrInfoCallback with status ==
   // ARES_ECONNREFUSED.
-
   EXPECT_TRUE(peer_->isChannelDirty());
 
   server_->setRefused(false);