Format with clang-format-22

Author: Zitrax

CMakeLists.txt

@@ -126,7 +126,7 @@ list(FILTER ALL_SOURCE_FILES EXCLUDE REGEX "#")
 list(FILTER ALL_HEADER_FILES EXCLUDE REGEX "#")
 set(ALL_INPUT_FILES ${ALL_SOURCE_FILES} ${ALL_HEADER_FILES})
 
-find_program(CLANG_FORMAT NAMES clang-format-14 clang-format-17)
+find_program(CLANG_FORMAT NAMES clang-format-22)
 if(CLANG_FORMAT)
   add_custom_target(format
     COMMENT "Formatting ${ALL_INPUT_FILES}"

src/main.cpp

@@ -4,9 +4,9 @@
 #include "logger.hpp"
 #include "torrent.hpp"
 
-#include <asio/io_context.hpp>
 #include <fmt/format.h>
 #include <spdlog/common.h>
+#include <asio/io_context.hpp>
 
 #include <algorithm>
 #include <cstdlib>
@@ -81,7 +81,9 @@ int main(int argc, const char* argv[]) noexcept {
         .help("Log level (trace, debug, info, warning, error, critical, off)");
     parser.add_option<std::string>("--log-prefix")
         .default_value("")
-        .help("Prefix to add to all log messages (useful when running multiple instances)");
+        .help(
+            "Prefix to add to all log messages (useful when running multiple "
+            "instances)");
     parser.add_option<bool>("--dump-torrent")
         .help("Dump info about specified .torrent file and exit");
     parser.add_option<bool>("--dump-config").help("Dump config to console");
@@ -104,7 +106,8 @@ int main(int argc, const char* argv[]) noexcept {
       // Set pattern with prefix for all loggers
       // Default spdlog pattern is: [%Y-%m-%d %H:%M:%S.%e] [%n] [%^%l%$] %v
       // We'll add the prefix before the message
-      const auto pattern = "[%Y-%m-%d %H:%M:%S.%e] [%n] [%^%l%$] [" + log_prefix + "] %v";
+      const auto pattern =
+          "[%Y-%m-%d %H:%M:%S.%e] [%n] [%^%l%$] [" + log_prefix + "] %v";
       zit::logger()->set_pattern(pattern);
       zit::logger("file_writer")->set_pattern(pattern);
     }

src/messages.cpp

@@ -6,6 +6,7 @@
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
+#include <cstdlib>
 #include <cstring>
 #include <iomanip>
 #include <ios>
@@ -145,9 +146,19 @@ optional<HandshakeMsg> HandshakeMsg::parse(const bytes& msg) {
   }
 
   if (sr.begin() != msg.begin()) {
-    logger()->debug("Found BT start at {}",
-                    std::distance(msg.begin(), sr.begin()));
-    return HandshakeMsg::parse(bytes{sr.begin(), msg.end()});
+    const auto pos = std::distance(msg.begin(), sr.begin());
+    logger()->debug("Found BT start at {}", pos);
+    // Parse from the actual handshake start, but make sure the consumed
+    // length accounts for any leading garbage before the handshake.
+    auto parsed = HandshakeMsg::parse(bytes{sr.begin(), msg.end()});
+    if (!parsed) {
+      return {};
+    }
+    // Repackage with adjusted consumed to include the offset
+    return HandshakeMsg(parsed->getReserved(), parsed->getInfoHash(),
+                        parsed->getPeerId(),
+                        parsed->getConsumed() + numeric_cast<size_t>(pos),
+                        parsed->getBitfield());
   }
 
   const bytes reserved(&msg.at(20), &msg.at(28));
@@ -156,26 +167,31 @@ optional<HandshakeMsg> HandshakeMsg::parse(const bytes& msg) {
 
   // Handle optional bitfield
   if (msg.size() > MIN_BT_MSG_LENGTH) {
-    if (msg.size() < 73) {
-      logger()->error("Invalid handshake length: {}", msg.size());
-      return {};
+    // If we don't yet have enough bytes to decide on BITFIELD, or if the
+    // next message isn't a BITFIELD, just consume the handshake (68 bytes)
+    // and let the caller parse subsequent messages normally.
+    bool strict_handshake = false;
+    if (const char* env_p = std::getenv("ZIT_STRICT_HANDSHAKE")) {
+      strict_handshake = std::string(env_p) == "1";
     }
-    if (to_peer_wire_id(msg.at(72)) != peer_wire_id::BITFIELD) {
-      logger()->error("Expected bitfield id ({}) but got: {}",
-                      static_cast<pwid_t>(peer_wire_id::BITFIELD),
-                      static_cast<uint8_t>(msg.at(72)));
-      return {};
+
+    if (msg.size() < 73 || (!strict_handshake && to_peer_wire_id(msg.at(72)) !=
+                                                     peer_wire_id::BITFIELD)) {
+      logger()->debug(
+          "Handshake without immediate BITFIELD; consuming 68 bytes");
+      return make_optional<HandshakeMsg>(reserved, info_hash, peer_id,
+                                         MIN_BT_MSG_LENGTH);
     }
-    // 4-byte big endian
+    // 4-byte big endian length for BITFIELD payload
     auto len = from_big_endian<uint32_t>(msg, 68);
     auto end = 73 + len - 1;
     if (end > msg.size()) {
-      logger()->debug("Wait for more handshake data...");
+      logger()->debug("Wait for more handshake+BITFIELD data...");
       return make_optional<HandshakeMsg>(reserved, info_hash, peer_id, 0);
     }
     Bitfield bf(bytes(std::next(msg.begin(), 73), std::next(msg.begin(), end)));
     logger()->debug("Handshake: {}", bf);
-    // Consume the parsed part, the caller have to deal with the rest
+    // Consume the parsed part, the caller has to deal with the rest
     return make_optional<HandshakeMsg>(reserved, info_hash, peer_id, end, bf);
   }
 

src/peer.cpp

@@ -126,8 +126,8 @@ void PeerConnection::write(const optional<Url>& url, const std::string& msg) {
     }
     auto self = shared_from_this();
     resolver_.async_resolve(
-      url->host(), url->service(),
-      [self](auto&& ec, auto&& it) { self->handle_resolve(ec, it); });
+        url->host(), url->service(),
+        [self](auto&& ec, auto&& it) { self->handle_resolve(ec, it); });
   }
 }
 
@@ -170,30 +170,30 @@ void PeerConnection::send(bool start_read) {
 
   // NOLINTNEXTLINE(misc-include-cleaner)
   auto self = shared_from_this();
-  asio::async_write(
-      *socket_, asio::buffer(m_msg.c_str(), m_msg.size()),
-      [self, start_read](auto err, auto len) {
-        if (self->m_stopped) {
-          return;
-        }
-        if (!err) {
-          logger()->debug("{}: Data of len {} sent", self->peer_.str(), len);
-        } else {
-          logger()->error("{}: Write failed: {}", self->peer_.str(),
-                          err.message());
-        }
-        if (start_read) {
-          self->handle_response({}, 0);
-        }
-        if (!self->m_send_queue.empty()) {
-          self->m_msg = self->m_send_queue.front();
-          self->m_send_queue.pop_front();
-          self->send();
-        } else {
-          // Indicates that all sending is done
-          self->m_msg.clear();
-        }
-      });
+  asio::async_write(*socket_, asio::buffer(m_msg.c_str(), m_msg.size()),
+                    [self, start_read](auto err, auto len) {
+                      if (self->m_stopped) {
+                        return;
+                      }
+                      if (!err) {
+                        logger()->debug("{}: Data of len {} sent",
+                                        self->peer_.str(), len);
+                      } else {
+                        logger()->error("{}: Write failed: {}",
+                                        self->peer_.str(), err.message());
+                      }
+                      if (start_read) {
+                        self->handle_response({}, 0);
+                      }
+                      if (!self->m_send_queue.empty()) {
+                        self->m_msg = self->m_send_queue.front();
+                        self->m_send_queue.pop_front();
+                        self->send();
+                      } else {
+                        // Indicates that all sending is done
+                        self->m_msg.clear();
+                      }
+                    });
 }
 
 void PeerConnection::handle_connect(const asio::error_code& err,
@@ -260,14 +260,13 @@ void PeerConnection::handle_response(const asio::error_code& err, std::size_t) {
     //       bytes at a time
     // NOLINTNEXTLINE(misc-include-cleaner)
     auto self = shared_from_this();
-    asio::async_read(
-        *socket_, response_, asio::transfer_at_least(1),
-        [self](const auto& ec, auto s) {
-          if (self->m_stopped) {
-            return;
-          }
-          self->handle_response(ec, s);
-        });
+    asio::async_read(*socket_, response_, asio::transfer_at_least(1),
+                     [self](const auto& ec, auto s) {
+                       if (self->m_stopped) {
+                         return;
+                       }
+                       self->handle_response(ec, s);
+                     });
   } else if (err != asio::error::eof) {
     logger()->error("Response failed: {}", err.message());
   } else {
@@ -686,7 +685,7 @@ void Peer::init_io_service(socket_ptr socket) {
   m_work = make_unique<asio::io_service::work>(*m_io_service);
   try {
     m_connection = std::make_shared<PeerConnection>(
-      *this, *m_io_service, m_torrent.connection_port(), std::move(socket));
+        *this, *m_io_service, m_torrent.connection_port(), std::move(socket));
   } catch (const asio::system_error& err) {
     throw_with_nested(
         runtime_error("Creating peer connection to " + str() + err.what()));