formatting

Author: jagerman

llarp/consensus/reachability_testing.cpp

@@ -80,35 +80,40 @@ namespace llarp::consensus
             }
 
             auto [conn, btstr] = router.link_endpoint().testing_client_connect(*rc);
-            btstr->command("ping", "", TEST_REQUEST_TIMEOUT, [this, weak_conn = std::weak_ptr{conn}, rid, prev_fails](quic::message m) mutable {
-                auto conn = weak_conn.lock();
-                if (conn)
-                    conn->close_connection();
-                router.loop.call_soon([this, rid, prev_fails, m = std::move(m)] {
-                    if (m)
-                    {
-                        if (prev_fails)
+            btstr->command(
+                "ping",
+                "",
+                TEST_REQUEST_TIMEOUT,
+                [this, weak_conn = std::weak_ptr{conn}, rid, prev_fails](quic::message m) mutable {
+                    auto conn = weak_conn.lock();
+                    if (conn)
+                        conn->close_connection();
+                    router.loop.call_soon([this, rid, prev_fails, m = std::move(m)] {
+                        if (m)
+                        {
+                            if (prev_fails)
+                                log::info(
+                                    logcat,
+                                    "Successful SN reachability test to {} (after {} previous failures)",
+                                    rid.to_network_address(true),
+                                    prev_fails);
+                            else
+                                log::info(
+                                    logcat, "Successful SN reachability test to {}", rid.to_network_address(true));
+                            remove_node_from_failing(rid);
+                        }
+                        else
+                        {
                             log::info(
                                 logcat,
-                                "Successful SN reachability test to {} (after {} previous failures)",
+                                "Testing of {} failed: {}",
                                 rid.to_network_address(true),
-                                prev_fails);
-                        else
-                            log::info(logcat, "Successful SN reachability test to {}", rid.to_network_address(true));
-                        remove_node_from_failing(rid);
-                    }
-                    else
-                    {
-                        log::info(
-                            logcat,
-                            "Testing of {} failed: {}",
-                            rid.to_network_address(true),
-                            m.timed_out ? "request timed out" : m.body());
-                        add_failing_node(rid, prev_fails);
-                    }
-                    router.oxend()->inform_connection(rid, (bool)m);
+                                m.timed_out ? "request timed out" : m.body());
+                            add_failing_node(rid, prev_fails);
+                        }
+                        router.oxend()->inform_connection(rid, (bool)m);
+                    });
                 });
-            });
         }
     }
 

llarp/contact/contactdb.cpp

@@ -20,7 +20,7 @@ namespace llarp
 
     void ContactDB::start_tickers()
     {
-        _purge_ticker = _router.loop.call_every(30s, [this](){ purge_ccs(); }, true);
+        _purge_ticker = _router.loop.call_every(30s, [this]() { purge_ccs(); }, true);
     }
 
     void ContactDB::purge_ccs(std::chrono::milliseconds now)

llarp/crypto/key_manager.cpp

@@ -22,7 +22,8 @@ namespace llarp
             oxenc::from_hex(tmp.begin(), tmp.begin() + 128, key.data());
         else if (tmp.size() == 64)
             std::memcpy(key.data(), tmp.data(), 64);
-        else if (tmp.starts_with('d') and tmp.ends_with('e')) {
+        else if (tmp.starts_with('d') and tmp.ends_with('e'))
+        {
             // Old Lokinet keys were bt-dicts with the key we care about in the 's' key:
             oxenc::bt_dict_consumer old{tmp};
             auto oldkey = old.require_span<unsigned char, 64>("s");
@@ -31,7 +32,8 @@ namespace llarp
         }
         else
             throw std::invalid_argument{
-                "Invalid key file {} ({}B): Expected 64 bytes, 128 hex, or legacy lokinet key file"_format(fname, tmp.size())};
+                "Invalid key file {} ({}B): Expected 64 bytes, 128 hex, or legacy lokinet key file"_format(
+                    fname, tmp.size())};
 
         if (!key.check_pubkey())
             throw std::invalid_argument{"Invalid key file {}: Keypair seed and pubkey do not match"};

llarp/path/path_handler.cpp

@@ -651,8 +651,8 @@ namespace llarp::path
             std::chrono::seconds lifetime{
                 oxenc::load_little_to_host<uint32_t>(inner.require_span<std::byte, sizeof(uint32_t)>("l").data())};
             if (lifetime > path::MAX_LIFETIME_ACCEPTED)
-                throw std::runtime_error{
-                    "Path lifetime {} exceeds maximum allowed path lifetime {}"_format(lifetime, path::MAX_LIFETIME_ACCEPTED)};
+                throw std::runtime_error{"Path lifetime {} exceeds maximum allowed path lifetime {}"_format(
+                    lifetime, path::MAX_LIFETIME_ACCEPTED)};
             hop.expiry = now + lifetime;
             hop.rxid.assign(inner.require_span<std::byte, HopID::SIZE>("r"));
             hop.txid.assign(inner.require_span<std::byte, HopID::SIZE>("t"));

llarp/session/session.cpp

@@ -106,7 +106,7 @@ namespace llarp::session
                 }};
 
             auto stream_opened = [this](quic::Stream& stream) {
-/*
+#if 0
                 stream.set_stream_data_cb([this, prev_byte = std::optional<std::byte>{std::nullopt}](
                                               quic::Stream& stream, std::span<const std::byte> data) mutable {
                     uint16_t dest_port{0};
@@ -163,7 +163,7 @@ namespace llarp::session
                                             50'000,
                                             [this, tcp_conn](auto&) { tcp_conn->resume_reading(); });
                 });
-*/
+#endif
                 return 0;
             };
 
@@ -817,10 +817,7 @@ namespace llarp::session
         }
     }
 
-    void Session::recv_close()
-    {
-        _parent.close_session(_inbound_tag, false);
-    }
+    void Session::recv_close() { _parent.close_session(_inbound_tag, false); }
 
     void OutboundRelaySession::recv_close()
     {
@@ -1185,7 +1182,10 @@ namespace llarp::session
             _remote.router_id(), [this, alive = canary()](std::optional<ClientContact> cc) mutable {
                 if (!alive.lock())
                 {
-                    log::debug(logcat, "OutboundClientSession::refresh_intros lookup_client_intro callback returning early; session-alive canary is dead");
+                    log::debug(
+                        logcat,
+                        "OutboundClientSession::refresh_intros lookup_client_intro callback returning early; "
+                        "session-alive canary is dead");
                     return;
                 }
                 updating_intros = false;
@@ -1205,7 +1205,7 @@ namespace llarp::session
     {
         log::debug(logcat, "Update session {} intros from client contact: {}", *this, cc);
         last_cc_update = llarp::time_now_ms();
-        last_inbound_activity = last_cc_update; // so we don't just fetch again right away
+        last_inbound_activity = last_cc_update;  // so we don't just fetch again right away
         auto intros = cc.intros();
         _intros.assign(intros.begin(), intros.end());
         log::trace(logcat, "New client intros: {}", fmt::join(_intros, ", "));
@@ -1396,15 +1396,15 @@ namespace llarp::session
                 return;
             }
             auto& m = maybe_path_switch_msg->first;
-            m.resize(m.size() - (sizeof(session_tag) + HopID::SIZE)); // these go on outer message here
+            m.resize(m.size() - (sizeof(session_tag) + HopID::SIZE));  // these go on outer message here
 
             oxenc::bt_list_producer btlp;
             btlp.append(std::move((*maybe_path_switch_msg).first));
             btlp.append(std::move(session_init_msg));
             auto list_span = btlp.span<std::byte>();
             std::vector<std::byte> payload{list_span.begin(), list_span.end()};
             auto old_size = payload.size();
-            payload.resize(payload.size() + sizeof(_outbound_tag) + HopID::SIZE); // see make_session_data_message
+            payload.resize(payload.size() + sizeof(_outbound_tag) + HopID::SIZE);  // see make_session_data_message
             auto [payload_span, tag_span, pivot_span] = split_span(payload, old_size, sizeof(_outbound_tag));
             oxenc::write_host_as_big(_outbound_tag, tag_span.data());
             std::memcpy(pivot_span.data(), _remote_pivot_txid.data(), _remote_pivot_txid.size());
@@ -1572,13 +1572,14 @@ namespace llarp::session
                 "Received session accept message for established session, likely a path switch failed because the "
                 "remote restarted, so it accepted our backup session init.");
         }
-        _is_established = false; // become unestablished if this parsing fails to trigger a new session init
+        _is_established = false;  // become unestablished if this parsing fails to trigger a new session init
         oxenc::bt_dict_consumer btdc{params};
         _outbound_tag = btdc.require<session_tag>("t"sv);
 
         log::debug(logcat, "Remote provided session tag: {}", _outbound_tag);
 
-        log::trace(logcat, "Outbound session to {} successfully {}established.", remote(), was_established ? "re-"sv : ""sv);
+        log::trace(
+            logcat, "Outbound session to {} successfully {}established.", remote(), was_established ? "re-"sv : ""sv);
         _is_established = true;
 
         if (pre_establish_data_queue)