util: removing exceptions

Risk Level: low
Testing: updated tests
Docs Changes: n/a
Release Notes: n/a
envoyproxy/envoy-mobile#176

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

46

@@ -0,0 +1 @@
+22 -

contrib/golang/filters/network/source/upstream.cc

@@ -59,12 +59,15 @@ UpstreamConn::UpstreamConn(std::string addr, Dso::NetworkFilterDsoPtr dynamic_li
   }
   stream_info_ = std::make_unique<StreamInfo::StreamInfoImpl>(
       dispatcher_->timeSource(), nullptr, StreamInfo::FilterState::LifeSpan::FilterChain);
-  stream_info_->filterState()->setData(
-      "envoy.network.transport_socket.original_dst_address",
-      std::make_shared<Network::AddressObject>(
-          Network::Utility::parseInternetAddressAndPort(addr, false)),
-      StreamInfo::FilterState::StateType::ReadOnly, StreamInfo::FilterState::LifeSpan::FilterChain,
-      StreamInfo::StreamSharingMayImpactPooling::None);
+  auto address = std::make_shared<Network::AddressObject>(
+      Network::Utility::parseInternetAddressAndPortNoThrow(addr, false));
+  if (!address) {
+    throwEnvoyExceptionOrPanic(absl::StrCat("malformed IP address: ", addr));
+  }
+  stream_info_->filterState()->setData("envoy.network.transport_socket.original_dst_address",
+                                       address, StreamInfo::FilterState::StateType::ReadOnly,
+                                       StreamInfo::FilterState::LifeSpan::FilterChain,
+                                       StreamInfo::StreamSharingMayImpactPooling::None);
 }
 
 void UpstreamConn::connect() {

source/common/network/utility.cc

@@ -53,16 +53,21 @@ std::string Utility::urlFromDatagramAddress(const Address::Instance& addr) {
   }
 }
 
-Address::InstanceConstSharedPtr Utility::resolveUrl(const std::string& url) {
+absl::StatusOr<Address::InstanceConstSharedPtr> Utility::resolveUrl(const std::string& url) {
+  Address::InstanceConstSharedPtr address{};
   if (urlIsTcpScheme(url)) {
-    return parseInternetAddressAndPort(url.substr(TCP_SCHEME.size()));
+    address = parseInternetAddressAndPortNoThrow(url.substr(TCP_SCHEME.size()));
   } else if (urlIsUdpScheme(url)) {
-    return parseInternetAddressAndPort(url.substr(UDP_SCHEME.size()));
+    address = parseInternetAddressAndPortNoThrow(url.substr(UDP_SCHEME.size()));
   } else if (urlIsUnixScheme(url)) {
     return std::make_shared<Address::PipeInstance>(url.substr(UNIX_SCHEME.size()));
   } else {
-    throwEnvoyExceptionOrPanic(absl::StrCat("unknown protocol scheme: ", url));
+    return absl::InvalidArgumentError(absl::StrCat("unknown protocol scheme: ", url));
+  }
+  if (!address) {
+    return absl::InvalidArgumentError(absl::StrCat("malformed IP address: ", url));
   }
+  return address;
 }
 
 StatusOr<Socket::Type> Utility::socketTypeFromUrl(const std::string& url) {
@@ -160,7 +165,7 @@ Address::InstanceConstSharedPtr Utility::parseInternetAddress(const std::string&
   const Address::InstanceConstSharedPtr address =
       parseInternetAddressNoThrow(ip_address, port, v6only);
   if (address == nullptr) {
-    throwWithMalformedIp(ip_address);
+    throwEnvoyExceptionOrPanic(absl::StrCat("malformed IP address: ", ip_address));
   }
   return address;
 }
@@ -208,28 +213,13 @@ Utility::parseInternetAddressAndPortNoThrow(const std::string& ip_address, bool
   return nullptr;
 }
 
-Address::InstanceConstSharedPtr Utility::parseInternetAddressAndPort(const std::string& ip_address,
-                                                                     bool v6only) {
-
-  const Address::InstanceConstSharedPtr address =
-      parseInternetAddressAndPortNoThrow(ip_address, v6only);
-  if (address == nullptr) {
-    throwWithMalformedIp(ip_address);
-  }
-  return address;
-}
-
 Address::InstanceConstSharedPtr Utility::copyInternetAddressAndPort(const Address::Ip& ip) {
   if (ip.version() == Address::IpVersion::v4) {
     return std::make_shared<Address::Ipv4Instance>(ip.addressAsString(), ip.port());
   }
   return std::make_shared<Address::Ipv6Instance>(ip.addressAsString(), ip.port());
 }
 
-void Utility::throwWithMalformedIp(absl::string_view ip_address) {
-  throwEnvoyExceptionOrPanic(absl::StrCat("malformed IP address: ", ip_address));
-}
-
 // TODO(hennna): Currently getLocalAddress does not support choosing between
 // multiple interfaces and addresses not returned by getifaddrs. In addition,
 // the default is to return a loopback address of type version. This function may
@@ -428,45 +418,6 @@ Address::InstanceConstSharedPtr Utility::getOriginalDst(Socket& sock) {
 #endif
 }
 
-void Utility::parsePortRangeList(absl::string_view string, std::list<PortRange>& list) {
-  const auto ranges = StringUtil::splitToken(string, ",");
-  for (const auto& s : ranges) {
-    const std::string s_string{s};
-    std::stringstream ss(s_string);
-    uint32_t min = 0;
-    uint32_t max = 0;
-
-    if (absl::StrContains(s, '-')) {
-      char dash = 0;
-      ss >> min;
-      ss >> dash;
-      ss >> max;
-    } else {
-      ss >> min;
-      max = min;
-    }
-
-    if (s.empty() || (min > 65535) || (max > 65535) || ss.fail() || !ss.eof()) {
-      throwEnvoyExceptionOrPanic(fmt::format("invalid port number or range '{}'", s_string));
-    }
-
-    list.emplace_back(PortRange(min, max));
-  }
-}
-
-bool Utility::portInRangeList(const Address::Instance& address, const std::list<PortRange>& list) {
-  if (address.type() != Address::Type::Ip) {
-    return false;
-  }
-
-  for (const PortRange& p : list) {
-    if (p.contains(address.ip()->port())) {
-      return true;
-    }
-  }
-  return false;
-}
-
 absl::uint128 Utility::Ip6ntohl(const absl::uint128& address) {
 #ifdef ABSL_IS_LITTLE_ENDIAN
   return flipOrder(address);

source/common/network/utility.h

@@ -16,22 +16,6 @@
 namespace Envoy {
 namespace Network {
 
-/**
- * Utility class to represent TCP/UDP port range
- */
-class PortRange {
-public:
-  PortRange(uint32_t min, uint32_t max) : min_(min), max_(max) {}
-
-  bool contains(uint32_t port) const { return (port >= min_ && port <= max_); }
-
-private:
-  const uint32_t min_;
-  const uint32_t max_;
-};
-
-using PortRangeList = std::list<PortRange>;
-
 /**
  * A callback interface used by readFromSocket() to pass packets read from
  * socket.
@@ -119,10 +103,9 @@ class Utility {
   /**
    * Resolve a URL.
    * @param url supplies the url to resolve.
-   * @return Address::InstanceConstSharedPtr the resolved address.
-   * @throw EnvoyException if url is invalid.
+   * @return Address::InstanceConstSharedPtr the resolved address or an error status
    */
-  static Address::InstanceConstSharedPtr resolveUrl(const std::string& url);
+  static absl::StatusOr<Address::InstanceConstSharedPtr> resolveUrl(const std::string& url);
 
   /**
    * Determine the socket type for a URL.
@@ -153,18 +136,6 @@ class Utility {
    */
   static bool urlIsUnixScheme(absl::string_view url);
 
-  /**
-   * 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);
-
   /**
    * Parse an internet host address (IPv4 or IPv6) and create an Instance from it. The address must
    * not include a port number.
@@ -185,18 +156,6 @@ class Utility {
    */
   static Address::InstanceConstSharedPtr copyInternetAddressAndPort(const Address::Ip& ip);
 
-  /**
-   * Create a new Instance from an internet host address (IPv4 or IPv6) and port.
-   * @param ip_addr string to be parsed as an internet address and port. Examples:
-   *        - "1.2.3.4:80"
-   *        - "[1234:5678::9]:443"
-   * @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 parseInternetAddressAndPort(const std::string& ip_address,
-                                                                     bool v6only = true);
-
   /**
    * Create a new Instance from an internet host address (IPv4 or IPv6) and port.
    * @param ip_addr string to be parsed as an internet address and port. Examples:
@@ -281,6 +240,18 @@ 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
@@ -290,24 +261,6 @@ class Utility {
    */
   static Address::InstanceConstSharedPtr getOriginalDst(Socket& sock);
 
-  /**
-   * Parses a string containing a comma-separated list of port numbers and/or
-   * port ranges and appends the values to a caller-provided list of PortRange structures.
-   * For example, the string "1-1024,2048-4096,12345" causes 3 PortRange structures
-   * to be appended to the supplied list.
-   * @param str is the string containing the port numbers and ranges
-   * @param list is the list to append the new data structures to
-   */
-  static void parsePortRangeList(absl::string_view string, std::list<PortRange>& list);
-
-  /**
-   * Checks whether a given port number appears in at least one of the port ranges in a list
-   * @param address supplies the IP address to compare.
-   * @param list the list of port ranges in which the port may appear
-   * @return whether the port appears in at least one of the ranges in the list
-   */
-  static bool portInRangeList(const Address::Instance& address, const std::list<PortRange>& list);
-
   /**
    * Converts IPv6 absl::uint128 in network byte order to host byte order.
    * @param address supplies the IPv6 address in network byte order.
@@ -408,8 +361,6 @@ class Utility {
                                                bool allow_mmsg, uint32_t& packets_dropped);
 
 private:
-  static void throwWithMalformedIp(absl::string_view ip_address);
-
   /**
    * Takes a number and flips the order in byte chunks. The last byte of the input will be the
    * first byte in the output. The second to last byte will be the second to first byte in the

source/extensions/tracers/xray/daemon_broker.cc

@@ -28,8 +28,13 @@ std::string createHeader(const std::string& format, uint32_t version) {
 } // namespace
 
 DaemonBrokerImpl::DaemonBrokerImpl(const std::string& daemon_endpoint)
-    : address_(Network::Utility::parseInternetAddressAndPort(daemon_endpoint, false /*v6only*/)),
-      io_handle_(Network::ioHandleForAddr(Network::Socket::Type::Datagram, address_, {})) {}
+    : address_(
+          Network::Utility::parseInternetAddressAndPortNoThrow(daemon_endpoint, false /*v6only*/)),
+      io_handle_(Network::ioHandleForAddr(Network::Socket::Type::Datagram, address_, {})) {
+  if (address_ == nullptr) {
+    throwEnvoyExceptionOrPanic(absl::StrCat("malformed IP address: ", daemon_endpoint));
+  }
+}
 
 void DaemonBrokerImpl::send(const std::string& data) const {
   auto& logger = Logger::Registry::getLog(Logger::Id::tracing);

source/server/hot_restarting_child.cc

@@ -92,8 +92,7 @@ void HotRestartingChild::initialize(Event::Dispatcher& dispatcher) {
       udp_forwarding_rpc_stream_.domain_socket_,
       [this](uint32_t events) {
         ASSERT(events == Event::FileReadyType::Read);
-        onSocketEventUdpForwarding();
-        return absl::OkStatus();
+        return onSocketEventUdpForwarding();
       },
       Event::FileTriggerType::Edge, Event::FileReadyType::Read);
 }
@@ -266,7 +265,7 @@ void HotRestartingChild::mergeParentStats(Stats::Store& stats_store,
   stat_merger_->mergeStats(stats_proto.counter_deltas(), stats_proto.gauges(), dynamics);
 }
 
-void HotRestartingChild::onSocketEventUdpForwarding() {
+absl::Status HotRestartingChild::onSocketEventUdpForwarding() {
   std::unique_ptr<HotRestartMessage> wrapped_request;
   while ((wrapped_request =
               udp_forwarding_rpc_stream_.receiveHotRestartMessage(RpcStream::Blocking::No))) {
@@ -280,8 +279,12 @@ void HotRestartingChild::onSocketEventUdpForwarding() {
     case HotRestartMessage::Request::kForwardedUdpPacket: {
       const auto& req = wrapped_request->request().forwarded_udp_packet();
       Network::UdpRecvData packet;
-      packet.addresses_.local_ = Network::Utility::resolveUrl(req.local_addr());
-      packet.addresses_.peer_ = Network::Utility::resolveUrl(req.peer_addr());
+      auto local_or_error = Network::Utility::resolveUrl(req.local_addr());
+      RETURN_IF_NOT_OK(local_or_error.status());
+      packet.addresses_.local_ = *local_or_error;
+      auto peer_or_error = Network::Utility::resolveUrl(req.peer_addr());
+      RETURN_IF_NOT_OK(peer_or_error.status());
+      packet.addresses_.peer_ = *peer_or_error;
       if (!packet.addresses_.local_ || !packet.addresses_.peer_) {
         break;
       }
@@ -299,6 +302,7 @@ void HotRestartingChild::onSocketEventUdpForwarding() {
     }
     }
   }
+  return absl::OkStatus();
 }
 
 } // namespace Server

source/server/hot_restarting_child.h

@@ -64,7 +64,7 @@ class HotRestartingChild : public HotRestartingBase,
                         const envoy::HotRestartMessage::Reply::Stats& stats_proto);
 
 protected:
-  void onSocketEventUdpForwarding();
+  absl::Status onSocketEventUdpForwarding();
   void onForwardedUdpPacket(uint32_t worker_index, Network::UdpRecvData&& data);
   // When call to terminate parent is sent, or parent is already terminated,
   void allDrainsImplicitlyComplete();

source/server/hot_restarting_parent.cc

@@ -140,7 +140,8 @@ HotRestartingParent::Internal::getListenSocketsForChild(const HotRestartMessage:
   HotRestartMessage wrapped_reply;
   wrapped_reply.mutable_reply()->mutable_pass_listen_socket()->set_fd(-1);
   Network::Address::InstanceConstSharedPtr addr =
-      Network::Utility::resolveUrl(request.pass_listen_socket().address());
+      THROW_OR_RETURN_VALUE(Network::Utility::resolveUrl(request.pass_listen_socket().address()),
+                            Network::Address::InstanceConstSharedPtr);
 
   for (const auto& listener : server_->listenerManager().listeners()) {
     for (auto& socket_factory : listener.get().listenSocketFactories()) {

test/common/event/dispatcher_impl_test.cc

@@ -1570,7 +1570,7 @@ class DispatcherConnectionTest : public testing::Test {
 TEST_F(DispatcherConnectionTest, CreateTcpConnection) {
   for (auto ip_version : TestEnvironment::getIpVersionsForTest()) {
     SCOPED_TRACE(Network::Test::addressVersionAsString(ip_version));
-    auto client_addr_port = Network::Utility::parseInternetAddressAndPort(
+    auto client_addr_port = Network::Utility::parseInternetAddressAndPortNoThrow(
         fmt::format("{}:{}", Network::Test::getLoopbackAddressUrlString(ip_version), 10911));
     auto client_conn = dispatcher_->createClientConnection(
         client_addr_port, Network::Address::InstanceConstSharedPtr(),

test/common/http/http3/conn_pool_test.cc

@@ -78,7 +78,7 @@ class Http3ConnPoolImplTest : public Event::TestUsingSimulatedTime, public testi
   NiceMock<Random::MockRandomGenerator> random_;
   Upstream::ClusterConnectivityState state_;
   Network::Address::InstanceConstSharedPtr test_address_ =
-      Network::Utility::resolveUrl("tcp://127.0.0.1:3000");
+      *Network::Utility::resolveUrl("tcp://127.0.0.1:3000");
   NiceMock<Server::Configuration::MockTransportSocketFactoryContext> context_;
   absl::optional<Quic::QuicClientTransportSocketFactory> factory_;
   Ssl::ClientContextSharedPtr ssl_context_{new Ssl::MockClientContext()};

test/common/network/address_impl_test.cc

@@ -38,7 +38,7 @@ bool addressesEqual(const InstanceConstSharedPtr& a, const Instance& b) {
 }
 
 void testSocketBindAndConnect(Network::Address::IpVersion ip_version, bool v6only) {
-  auto addr_port = Network::Utility::parseInternetAddressAndPort(
+  auto addr_port = Network::Utility::parseInternetAddressAndPortNoThrow(
       fmt::format("{}:0", Network::Test::getAnyAddressUrlString(ip_version)), v6only);
   ASSERT_NE(addr_port, nullptr);
 
@@ -91,7 +91,7 @@ void testSocketBindAndConnect(Network::Address::IpVersion ip_version, bool v6onl
         << "\nerrno: " << result.errno_;
   };
 
-  auto client_addr_port = Network::Utility::parseInternetAddressAndPort(
+  auto client_addr_port = Network::Utility::parseInternetAddressAndPortNoThrow(
       fmt::format("{}:{}", Network::Test::getLoopbackAddressUrlString(ip_version),
                   addr_port->ip()->port()),
       v6only);