Fix warnings for redundant closed connections

Use a close code for a redundant conn closure so that we can detect it
for the purpose of identifying and logging the close properly.

Author: jagerman

src/link/connection.cpp

@@ -10,9 +10,9 @@ namespace srouter::link
         : conn{std::move(c)}, datagrams{conn->datagrams()}, control_stream{std::move(s)}
     {}
 
-    void Connection::close()
+    void Connection::close(uint64_t errcode)
     {
         log::trace(logcat, "{} called", __PRETTY_FUNCTION__);
-        conn->close_connection();
+        conn->close_connection(errcode);
     }
 }  // namespace srouter::link

src/link/connection.hpp

@@ -24,6 +24,6 @@ namespace srouter::link
 
         bool is_inbound() const { return conn->is_inbound(); }
 
-        void close();
+        void close(uint64_t errcode = 0);
     };
 }  // namespace srouter::link

src/link/endpoint.cpp

@@ -27,31 +27,31 @@ namespace srouter::link
             conn = ptr.get();
     }
 
-    void relay_conn::close(bool direction_inbound)
+    void relay_conn::close(bool direction_inbound, uint64_t errcode)
     {
         auto& to_close = direction_inbound ? inbound : outbound;
         if (not to_close)
             return;
 
-        to_close->close();
+        to_close->close(errcode);
         to_close.reset();
 
         // Switch preferred conn to the other direction (will be nullptr if the other direction
         // isn't established):
         conn = (direction_inbound ? outbound : inbound).get();
     }
 
-    void relay_conn::close_all()
+    void relay_conn::close_all(uint64_t errcode)
     {
         if (inbound)
-            inbound->close();
+            inbound->close(errcode);
         if (outbound)
-            outbound->close();
+            outbound->close(errcode);
         inbound = outbound = nullptr;
         conn = nullptr;
     }
 
-    void relay_conn::close_redundant() { close(not inbound_wins); }
+    void relay_conn::close_redundant() { close(not inbound_wins, CONN_CLOSE_REDUNDANT); }
 
     static std::vector<uint8_t> make_static_secret(
         const Ed25519SecretKey& sk, std::string_view static_secret_key = "Session Router static shared secret key"sv)
@@ -275,7 +275,8 @@ namespace srouter::link
             it = pending_dead.erase(it);
         }
 
-        // Record timestamps for any newly unregistered nodes
+        // Record timestamps for any newly unregistered nodes so that, when the timer expires, we
+        // drop the connection.
         for (const auto& [rid, rconn] : relay_conns)
             if (!registered.contains(rid) && pending_dead.emplace(rid, now).second)
                 log::critical(
@@ -867,6 +868,18 @@ namespace srouter::link
                     pending_outbound.erase(it);
                     found = true;
                 }
+
+                if (!found && ec == CONN_CLOSE_REDUNDANT)
+                {
+                    log::debug(
+                        logcat,
+                        "Closed redundant connection {} {} @ {} (cid={})",
+                        conn.is_inbound() ? "from" : "to",
+                        rid->to_network_address(true),
+                        conn.remote(),
+                        conn.reference_id());
+                    found = true;
+                }
             }
             else if (alpn == CLIENT_ALPN)
             {
@@ -916,9 +929,9 @@ namespace srouter::link
             if (!found)
                 log::warning(
                     logcat,
-                    "Closed untracked connection {} {} @ {} (cid={}, ec={})",
+                    "Closed connection {} {} @ {} (cid={}, ec={})",
                     conn.is_inbound() ? "from" : "to",
-                    rid ? rid->to_network_address(true /* don't know! */).to_string() : "",
+                    rid ? rid->to_string() : "",
                     conn.remote(),
                     conn.reference_id(),
                     ec);

src/link/endpoint.hpp

@@ -39,6 +39,8 @@ namespace srouter::link
     // longer than the longest path to allow those clients to naturally migrate to new paths.
     inline constexpr auto DEREGGED_LINGER = 30min;
 
+    static constexpr uint64_t CONN_CLOSE_REDUNDANT = 6;
+
     // Stores relay-to-relay connections.  In order to not lose stream messages, we temporarily
     // allow simultaneous connections in both directions between a pair of relays, but then
     // after a timeout, both sides choose the same winner and drop the other one.  The timeout
@@ -67,10 +69,10 @@ namespace srouter::link
         // Closes either the inbound or outbound connection and drops it from this instance.  If
         // the other connection still exists then `conn` is updated to point at it, otherwise it
         // is set to nullptr.  Does nothing if the indicated connection is already closed.
-        void close(bool direction_inbound);
+        void close(bool direction_inbound, uint64_t errcode = 0);
 
         // Closes all connections, in both directions (if opened).
-        void close_all();
+        void close_all(uint64_t errcode = 0);
 
         // Closes the "loser" connection, if this instance has connections in both directions.
         void close_redundant();