RouterInfo: refactor address getters + fix logic

- Use bitwise operations to ensure appropriate transport and version
- Refactor bool logic + remove unnecessary code
- Implement transport trait getter
- Related refactoring + add docs

src/core/router/info.cc

@@ -868,31 +868,56 @@ bool RouterInfo::UsesIntroducer() const {
   return HasCap(Cap::Unreachable);  // Router is unreachable, must use introducer
 }
 
-const RouterInfo::Address* RouterInfo::GetNTCPAddress(
-    bool v4only) const {
-  return GetAddress(Transport::NTCP, v4only);
-}
-
-const RouterInfo::Address* RouterInfo::GetSSUAddress(
-    bool v4only) const {
-  return GetAddress(Transport::SSU, v4only);
+const RouterInfo::Address* RouterInfo::GetNTCPAddress(bool has_v6) const
+{
+  if (!has_v6)
+    return GetAddress(SupportedTransport::NTCPv4);
+  return GetAddress(SupportedTransport::NTCPv4 | SupportedTransport::NTCPv6);
 }
 
-const RouterInfo::Address* RouterInfo::GetSSUV6Address() const {
-  return GetAddress(Transport::SSU, false, true);
+const RouterInfo::Address* RouterInfo::GetSSUAddress(bool has_v6) const
+{
+  if (!has_v6)
+    return GetAddress(SupportedTransport::SSUv4);
+  return GetAddress(SupportedTransport::SSUv4 | SupportedTransport::SSUv6);
 }
 
 const RouterInfo::Address* RouterInfo::GetAddress(
-    Transport s,
-    bool v4only,
-    bool v6only) const {
-  for (auto& address : m_Addresses) {
-    if (address.transport == s) {
-      if ((!v4only || address.host.is_v4()) &&
-          (!v6only || address.host.is_v6()))
-        return &address;
+    const std::uint8_t transports) const
+{
+  // Ensures supported transports
+  auto has_transport = [transports](const std::uint8_t supported) -> bool {
+    return transports & supported;
+  };
+
+  Transport transport;
+  bool has_v6(false);
+
+  // Ensure address has appropriate transport
+  if (has_transport(SupportedTransport::NTCPv4 | SupportedTransport::NTCPv6))
+    transport = Transport::NTCP;
+
+  if (has_transport(SupportedTransport::SSUv4 | SupportedTransport::SSUv6))
+    transport = Transport::SSU;
+
+  if (has_transport(SupportedTransport::NTCPv6 | SupportedTransport::SSUv6))
+    has_v6 = true;
+
+  // Return only usable addresses
+  for (const auto& address : GetAddresses())
+    {
+      if (address.transport == transport)
+        {
+          // Ensurew we return v6 capable address if selected
+          if (address.host.is_v4() || (has_v6 && address.host.is_v6()))
+            {
+              LOG(debug) << "RouterInfo: " << __func__ << GetTrait(transport)
+                         << " " << address.host;
+              return &address;
+            }
+        }
     }
-  }
+
   return nullptr;
 }
 

src/core/router/info.h

@@ -272,6 +272,23 @@ class RouterInfo : public RoutingDestination {
     Unknown,
   };
 
+  /// @return String value of given transport
+  /// @param transport Enumerated transport
+  const std::string GetTrait(Transport transport) const noexcept
+  {
+    switch (transport)
+      {
+        case Transport::NTCP:
+          return GetTrait(Trait::NTCP);
+
+        case Transport::SSU:
+          return GetTrait(Trait::SSU);
+
+        default:
+          return GetTrait(Trait::Unknown);
+      }
+  }
+
   /// @return String value of given enumerated RI trait
   /// @param trait key used for RI trait string value
   const std::string GetTrait(Trait trait) const noexcept
@@ -399,13 +416,13 @@ class RouterInfo : public RoutingDestination {
     return m_Addresses;
   }
 
-  const Address* GetNTCPAddress(
-      bool v4only = true) const;
-
-  const Address* GetSSUAddress(
-      bool v4only = true) const;
+  /// @return Address object capable of NTCP
+  /// @param has_v6 Address should have v6 capability
+  const Address* GetNTCPAddress(bool has_v6 = false) const;
 
-  const Address* GetSSUV6Address() const;
+  /// @return Address object capable of SSU
+  /// @param has_v6 Address should have v6 capability
+  const Address* GetSSUAddress(bool has_v6 = false) const;
 
   void AddNTCPAddress(
       const std::string& host,
@@ -586,10 +603,11 @@ class RouterInfo : public RoutingDestination {
   /// @return Capabilities flags in string form
   const std::string GetCapsFlags() const;
 
-  const Address* GetAddress(
-      Transport s,
-      bool v4only,
-      bool v6only = false) const;
+  /// @brief Return address object which uses given transport(s)
+  /// @details Performs bitwise operations to determine if address contains given transport
+  /// @param transports integer value of transport(s) (see enum)
+  /// @return Address capable of given transport(s)
+  const RouterInfo::Address* GetAddress(const std::uint8_t transports) const;
 
  private:
   std::string m_FullPath;

src/core/router/transports/impl.cc

@@ -378,7 +378,7 @@ bool Transports::ConnectToPeerNTCP(
   LOG(debug)
     << "Transports: attempting NTCP for peer"
     << GetFormattedSessionInfo(peer.router);
-  const auto address = peer.router->GetNTCPAddress(!context.SupportsV6());
+  const auto address = peer.router->GetNTCPAddress(context.SupportsV6());
   // No NTCP address found
   if (!address)
     return false;

src/core/router/transports/ssu/server.cc

@@ -277,15 +277,15 @@ std::shared_ptr<SSUSession> SSUServer::FindSession(
   LOG(debug) << "SSUServer: finding session from RI";
   if (!router)
     return nullptr;
-  auto address = router->GetSSUAddress(true);  // v4 only
+  auto address = router->GetSSUAddress();  // v4 only
   if (!address)
     return nullptr;
   auto session =
     FindSession(boost::asio::ip::udp::endpoint(address->host, address->port));
   if (session || !context.SupportsV6())
     return session;
   // try v6
-  address = router->GetSSUV6Address();
+  address = router->GetSSUAddress(true);
   if (!address)
     return nullptr;
   return FindSession(boost::asio::ip::udp::endpoint(address->host, address->port));
@@ -307,7 +307,7 @@ std::shared_ptr<SSUSession> SSUServer::GetSession(
   LOG(debug) << "SSUServer: getting session";
   std::shared_ptr<SSUSession> session;
   if (router) {
-    auto address = router->GetSSUAddress(!context.SupportsV6());
+    auto address = router->GetSSUAddress(context.SupportsV6());
     if (address) {
       boost::asio::ip::udp::endpoint remote_endpoint(
           address->host,

src/core/router/transports/ssu/session.cc

@@ -441,8 +441,8 @@ void SSUSession::SendSessionCreated(
     const std::uint8_t* x) {
   auto intro_key = GetIntroKey();
   auto address = IsV6() ?
-    kovri::context.GetRouterInfo().GetSSUV6Address() :
-    kovri::context.GetRouterInfo().GetSSUAddress(true);  // v4 only
+    kovri::context.GetRouterInfo().GetSSUAddress(true) :
+    kovri::context.GetRouterInfo().GetSSUAddress();  // v4 only
   if (!intro_key || !address) {
     LOG(error)
       << "SSUSession:" << GetFormattedSessionInfo()