CMakeLists.txt

@@ -39,7 +39,7 @@ add_custom_command(
 
 add_executable(xbot
   main.cpp irc_commands.inc ircmsg.cpp settings.cpp connection.cpp
-  snote_thread.cpp watchdog_thread.cpp write_irc.cpp
+  thread.cpp snote_thread.cpp watchdog_thread.cpp write_irc.cpp
   ping_thread.cpp irc_parse_thread.cpp registration_thread.cpp
   self_thread.cpp command_thread.cpp)
 target_include_directories(xbot PRIVATE ${CMAKE_CURRENT_BINARY_DIR})

c_callback.hpp

@@ -1,14 +0,0 @@
-#pragma once
-
-template <typename> struct CCallback_;
-template <typename F, typename R, typename... Ts>
-struct CCallback_<R (F::*) (Ts...) const>
-{
-    static R invoke(Ts... args, void* u)
-    {
-        return (*reinterpret_cast<F*>(u))(args...);
-    }
-};
-
-template <typename F>
-using CCallback = CCallback_<decltype(&F::operator())>;

command_thread.hpp

@@ -1,6 +1,6 @@
 #pragma once
 
-#include "event.hpp"
+#include "thread.hpp"
 
 #include <string>
 

connection.cpp

@@ -81,7 +81,6 @@ auto Connection::connect(
             break;
         }
         buffer.add_bytes(n, [this](char * line) {
-            std::cout << "RECV: " << line << std::endl;
             make_event<LineEvent>(line);
         });
     }
@@ -91,7 +90,6 @@ auto Connection::connect(
 
 auto Connection::write_line(std::string message) -> void
 {
-    std::cout << "SEND: " << message << std::endl;
     message += "\r\n";
     auto const need_cancel = write_strings_.empty();
     write_strings_.push_back(std::move(message));

connection.hpp

@@ -1,8 +1,8 @@
 #pragma once
 
-#include "event.hpp"
 #include "linebuffer.hpp"
 #include "settings.hpp"
+#include "thread.hpp"
 
 #include <eventpp/eventdispatcher.h>
 #include <eventpp/utilities/argumentadapter.h>

irc_commands.gperf

@@ -162,7 +162,7 @@ struct RecognizedCommand {
 438, IrcCommand::ERR_NICKTOOFAST
 440, IrcCommand::ERR_SERVICESDOWN
 441, IrcCommand::ERR_USERNOTINCHANNEL
-442, IrcCommand::ERR_NOTONCHANNEL, 3, 3
+442, IrcCommand::ERR_NOTONCHANNEL
 443, IrcCommand::ERR_USERONCHANNEL
 444, IrcCommand::ERR_NOLOGIN
 445, IrcCommand::ERR_SUMMONDISABLED

irc_parse_thread.cpp

@@ -10,7 +10,7 @@ namespace {
 
 } // namespace
 
-auto IrcParseThread::start(Connection& connection) -> void
+auto irc_parse_thread(Connection& connection) -> void
 {
     connection.add_listener<LineEvent>([&connection](LineEvent const& event)
     {
@@ -21,11 +21,6 @@ auto IrcParseThread::start(Connection& connection) -> void
             && recognized->min_args <= msg.args.size()
             && recognized->max_args >= msg.args.size()
             ? recognized->command : IrcCommand::UNKNOWN;
-        
-        if (IrcCommand::UNKNOWN == command)
-        {
-            std::cout << "Unrecognized command: " << msg.command << " " << msg.args.size() << std::endl;
-        }
         connection.make_event<IrcMsgEvent>(command, msg);
     });
 }

irc_parse_thread.hpp

@@ -1,6 +1,6 @@
 #pragma once
 
-#include "event.hpp"
+#include "thread.hpp"
 
 #include <string_view>
 
@@ -293,7 +293,4 @@ struct IrcMsgEvent : Event
     IrcMsg const& irc;
 };
 
-struct IrcParseThread
+auto irc_parse_thread(Connection& connection) -> void;
-{
-    static auto start(Connection& connection) -> void;
-};

main.cpp

@@ -1,19 +1,19 @@
 #include <boost/asio.hpp>
 
 #include "connection.hpp"
-#include "event.hpp"
 #include "ircmsg.hpp"
 #include "linebuffer.hpp"
 #include "settings.hpp"
+#include "thread.hpp"
 #include "write_irc.hpp"
 
-#include "command_thread.hpp"
 #include "irc_parse_thread.hpp"
-#include "ping_thread.hpp"
 #include "registration_thread.hpp"
-#include "self_thread.hpp"
+#include "ping_thread.hpp"
-#include "snote_thread.hpp"
 #include "watchdog_thread.hpp"
+#include "snote_thread.hpp"
+#include "self_thread.hpp"
+#include "command_thread.hpp"
 
 #include <algorithm>
 #include <chrono>
@@ -34,6 +34,23 @@
 
 using namespace std::chrono_literals;
 
+auto unhandled_message_thread(Connection& connection) -> void
+{
+    connection.add_listener<IrcMsgEvent>([](IrcMsgEvent const& event)
+    {
+        if (IrcCommand::UNKNOWN == event.command)
+        {
+            auto& irc = event.irc;
+            std::cout << "Unknown message " << irc.command;
+            for (auto const arg : irc.args)
+            {
+                std::cout << " " << arg;
+            }
+            std::cout << "\n";
+        }
+    });
+}
+
 auto echo_thread(Connection& connection) -> void
 {
     connection.add_listener<CommandEvent>([&connection](CommandEvent& event)
@@ -42,7 +59,9 @@ auto echo_thread(Connection& connection) -> void
         and "glguy" == event.oper
         and "glguy" == event.account)
         {
-            connection.write_line(std::string{event.arg});
+            auto txt = std::string{event.arg};
+            txt += "\r\n";
+            connection.write_line(std::move(txt));
             event.handled_ = true;
             send_notice(connection, event.nick, "ack");
         }
@@ -53,14 +72,20 @@ auto start(boost::asio::io_context & io, Settings const& settings) -> void
 {
     auto connection = std::make_shared<Connection>(io);
 
-    WatchdogThread::start(*connection);
+    watchdog_thread(*connection);
-    IrcParseThread::start(*connection);
+    irc_parse_thread(*connection);
-    PingThread::start(*connection);
+    ping_thread(*connection);
-    SelfThread::start(*connection);
+    auto const self_thread = SelfThread::start(*connection);
-    RegistrationThread::start(*connection, settings.password, settings.username, settings.realname, settings.nickname);
+    registration_thread(*connection, settings.password, settings.username, settings.realname, settings.nickname);
     SnoteThread::start(*connection);
     CommandThread::start(*connection);
     echo_thread(*connection);
+    unhandled_message_thread(*connection);
+
+    connection->add_listener<SnoteEvent>([](SnoteEvent& event)
+    {
+        std::cout << "Snote match " << static_cast<int>(event.tag) << std::endl;
+    });
 
     boost::asio::co_spawn(
         io,

ping_thread.cpp

@@ -3,7 +3,7 @@
 #include "irc_parse_thread.hpp"
 #include "write_irc.hpp"
 
-auto PingThread::start(Connection& connection) -> void
+auto ping_thread(Connection& connection) -> void
 {
     connection.add_listener<IrcMsgEvent>([&connection](IrcMsgEvent& event)
     {

ping_thread.hpp

@@ -1,9 +1,6 @@
 #pragma once
 
 #include "connection.hpp"
-#include "event.hpp"
+#include "thread.hpp"
 
-struct PingThread
+auto ping_thread(Connection& connection) -> void;
-{
-    static auto start(Connection& connection) -> void;
-};

registration_thread.cpp

@@ -4,6 +4,48 @@
 #include <unordered_set>
 #include <unordered_map>
 
+namespace {
+struct RegistrationThread : std::enable_shared_from_this<RegistrationThread>
+{
+    Connection& connection_;
+    std::string password_;
+    std::string username_;
+    std::string realname_;
+    std::string nickname_;
+
+    std::unordered_map<std::string, std::string> caps;
+    std::unordered_set<std::string> outstanding;
+
+    Connection::Handle<ConnectEvent> connect_handle_;
+    Connection::Handle<IrcMsgEvent> message_handle_;
+
+    enum class Stage
+    {
+        LsReply,
+        AckReply,
+    };
+
+    Stage stage_;
+
+    RegistrationThread(
+        Connection& connection_,
+        std::string password,
+        std::string username,
+        std::string realname,
+        std::string nickname
+    );
+
+    auto on_connect() -> void;
+
+    auto send_req() -> void;
+
+    auto capack(IrcMsg const& msg) -> void;
+
+    auto capls(IrcMsg const& msg) -> void;
+
+    auto on_msg(IrcMsg const& msg) -> void;
+};
+
 RegistrationThread::RegistrationThread(
     Connection& connection,
     std::string password,
@@ -16,8 +58,8 @@ RegistrationThread::RegistrationThread(
     , username_{username}
     , realname_{realname}
     , nickname_{nickname}
-{
+    , stage_{Stage::LsReply}
-}
+{}
 
 auto RegistrationThread::on_connect() -> void
 {
@@ -58,121 +100,117 @@ auto RegistrationThread::send_req() -> void
             outstanding.insert(cap);
         }
     }
-    
-    connection_.remove_listener(message_handle_);
-    
     if (not outstanding.empty())
     {
         request.pop_back();
         send_cap_req(connection_, request);
-        
+        stage_ = Stage::AckReply;
-        listen_for_cap_ack();
     }
     else
-    {
-        send_cap_end(connection_);
-    }
-}
-
-auto RegistrationThread::on_msg_cap_ack(IrcMsg const& msg) -> void
-{
-    auto in = std::istringstream{std::string{msg.args[2]}};
-    std::for_each(
-        std::istream_iterator<std::string>{in},
-        std::istream_iterator<std::string>{},
-        [this](std::string x) {
-            outstanding.erase(x);
-        }
-    );
-    if (outstanding.empty())
     {
         send_cap_end(connection_);
         connection_.remove_listener(message_handle_);
     }
 }
 
-auto RegistrationThread::on_msg_cap_ls(IrcMsg const& msg) -> void
+auto RegistrationThread::capack(IrcMsg const& msg) -> void
 {
-    std::string_view const* kvs;
+    auto const n = msg.args.size();
-    bool last;
+    if (n >= 2 && "*" == msg.args[0] && "ACK" == msg.args[1])
-
-    if (3 == msg.args.size())
     {
-        kvs = &msg.args[2];
+        auto in = std::istringstream{std::string{msg.args[2]}};
-        last = true;
+        std::for_each(
-    }
+            std::istream_iterator<std::string>{in},
-    else if (4 == msg.args.size() && "*" == msg.args[2])
+            std::istream_iterator<std::string>{},
-    {
+            [this](std::string x) {
-        kvs = &msg.args[3];
+                outstanding.erase(x);
-        last = false;
-    }
-    else
-    {
-        return;
-    }
-
-    auto in = std::istringstream{std::string{*kvs}};
-
-    std::for_each(
-        std::istream_iterator<std::string>{in},
-        std::istream_iterator<std::string>{},
-        [this](std::string x) {
-            auto const eq = x.find('=');
-            if (eq == x.npos)
-            {
-                caps.emplace(x, std::string{});
-            }
-            else
-            {
-                caps.emplace(std::string{x, 0, eq}, std::string{x, eq+1, x.npos});
             }
+        );
+        if (outstanding.empty())
+        {
+            send_cap_end(connection_);
+            connection_.remove_listener(message_handle_);
         }
-    );
-
-    if (last)
-    {
-        send_req();
     }
 }
 
-auto RegistrationThread::start(
+auto RegistrationThread::capls(IrcMsg const& msg) -> void
+{
+    auto const n = msg.args.size();
+    if (n >= 2 && "*" == msg.args[0] && "LS" == msg.args[1])
+    {
+        std::string_view const* kvs;
+        bool last;
+
+        if (3 == n)
+        {
+            kvs = &msg.args[2];
+            last = true;
+        }
+        else if (4 == n && "*" == msg.args[2])
+        {
+            kvs = &msg.args[3];
+            last = false;
+        }
+        else
+        {
+            return;
+        }
+
+        auto in = std::istringstream{std::string{*kvs}};
+
+        std::for_each(
+            std::istream_iterator<std::string>{in},
+            std::istream_iterator<std::string>{},
+            [this](std::string x) {
+                auto const eq = x.find('=');
+                if (eq == x.npos)
+                {
+                    caps.emplace(x, std::string{});
+                }
+                else
+                {
+                    caps.emplace(std::string{x, 0, eq}, std::string{x, eq+1, x.npos});
+                }
+            }
+        );
+
+        if (last)
+        {
+            send_req();
+        }
+    }
+}
+
+auto RegistrationThread::on_msg(IrcMsg const& msg) -> void
+{
+    switch (stage_)
+    {
+        case Stage::LsReply: capls(msg); return;
+        case Stage::AckReply: capack(msg); return;
+    }
+}
+
+} // namespace
+
+auto registration_thread(
     Connection& connection,
     std::string password,
     std::string username,
     std::string realname,
     std::string nickname
-) -> std::shared_ptr<RegistrationThread>
+) -> void
 {
     auto const thread = std::make_shared<RegistrationThread>(connection, password, username, realname, nickname);
-
+    thread->message_handle_ = connection.add_listener<IrcMsgEvent>([thread](IrcMsgEvent const& event)
-    thread->listen_for_cap_ls();
+    {
-
+        if (IrcCommand::CAP == event.command)
+        {
+            thread->on_msg(event.irc);
+        }
+    });
     thread->connect_handle_ = connection.add_listener<ConnectEvent>([thread](ConnectEvent const&)
     {
         thread->on_connect();
     });
-
-    return thread;
-}
-
-auto RegistrationThread::listen_for_cap_ack() -> void
-{
-    message_handle_ = connection_.add_listener<IrcMsgEvent>([thread = shared_from_this()](IrcMsgEvent const& event)
-    {
-        if (IrcCommand::CAP == event.command && event.irc.args.size() >= 2 && "*" == event.irc.args[0] && "ACK" == event.irc.args[1])
-        {
-            thread->on_msg_cap_ack(event.irc);
-        }
-    });
-}
-
-auto RegistrationThread::listen_for_cap_ls() -> void
-{
-    message_handle_ = connection_.add_listener<IrcMsgEvent>([thread = shared_from_this()](IrcMsgEvent const& event)
-    {
-        if (IrcCommand::CAP == event.command && event.irc.args.size() >= 2 && "*" == event.irc.args[0] && "LS" == event.irc.args[1])
-        {
-            thread->on_msg_cap_ls(event.irc);
-        }
-    });
 }

registration_thread.hpp

@@ -1,53 +1,18 @@
 #pragma once
 
+#include "thread.hpp"
 #include "connection.hpp"
-#include "event.hpp"
 #include "irc_parse_thread.hpp"
 #include "write_irc.hpp"
 
 #include <eventpp/eventdispatcher.h>
 
-#include <memory>
 #include <string>
-#include <unordered_map>
-#include <unordered_set>
 
-class RegistrationThread : public std::enable_shared_from_this<RegistrationThread>
+auto registration_thread(
-{
+    Connection& connection,
-    Connection& connection_;
+    std::string password,
-    std::string password_;
+    std::string username,
-    std::string username_;
+    std::string realname,
-    std::string realname_;
+    std::string nickname
-    std::string nickname_;
+) -> void;
-
-    std::unordered_map<std::string, std::string> caps;
-    std::unordered_set<std::string> outstanding;
-
-    Connection::Handle<ConnectEvent> connect_handle_;
-    Connection::Handle<IrcMsgEvent> message_handle_;
-
-    auto on_connect() -> void;
-    auto send_req() -> void;
-    auto on_msg_cap_ls(IrcMsg const& msg) -> void;
-    auto on_msg_cap_ack(IrcMsg const& msg) -> void;
-
-    auto listen_for_cap_ack() -> void;
-    auto listen_for_cap_ls() -> void;
-
-public:
-    RegistrationThread(
-        Connection& connection_,
-        std::string password,
-        std::string username,
-        std::string realname,
-        std::string nickname
-    );
-
-    static auto start(
-        Connection& connection,
-        std::string password,
-        std::string username,
-        std::string realname,
-        std::string nickname
-    ) -> std::shared_ptr<RegistrationThread>;
-};

self_thread.hpp

@@ -15,3 +15,4 @@ public:
     SelfThread(Connection& connection) : connection_{connection} {}
     static auto start(Connection&) -> std::shared_ptr<SelfThread>;
 };
+

snote_thread.cpp

@@ -2,7 +2,6 @@
 
 #include "irc_parse_thread.hpp"
 #include "connection.hpp"
-#include "c_callback.hpp"
 
 #include <cstring>
 #include <cstdlib>
@@ -17,12 +16,14 @@ struct SnotePattern
     SnotePattern(SnoteTag tag, char const* expression, unsigned flags = 0)
     : tag{tag}
     , expression{expression}
+    , flags{flags}
     , regex{expression, std::regex_constants::ECMAScript | std::regex_constants::optimize}
     {
     }
 
     SnoteTag tag;
     char const* expression;
+    unsigned flags;
     std::regex regex;
 };
 
@@ -33,61 +34,31 @@ SnotePattern const patterns[] =
 
     {SnoteTag::ClientExiting,
      R"(^Client exiting: ([^ ]+) \(([^@ ]+)@([^) ]+)\) \[(.*)\] \[(.*)\]$)"},
-
-    {SnoteTag::RejectingKlined,
-     R"(^Rejecting K-Lined user ([^ ]+)\[([^@]+)@([^\]]+)\] \[([^\] ]+)\] \((.*)\)$)"},
-
-    {SnoteTag::NickChange,
-     R"(^Nick change: From ([^ ]+) to ([^ ]+) \[([^@]+)@([^ ]+)\]$)"},
-
-    {SnoteTag::CreateChannel,
-     R"(^([^ ]+) is creating new channel ([^ ]+)$)"},
-
-    {SnoteTag::TemporaryKlineExpired,
-     R"(^Temporary K-line for \[([^ ]+)\] expired$)"},
-
-    {SnoteTag::PropagatedBanExpired,
-     R"(^Propagated ban for \[([^ ]+)\] expired$)"},
-
-    {SnoteTag::DisconnectingKlined,
-     R"(^Disconnecting K-Lined user ([^ ]+)\[([^@]+)@([^ ]+)\] \((.*)\)$)"},
-
-    {SnoteTag::NewPropagatedKline,
-     R"(^([^ ]+)!([^ ]+)@([^ ]+)\{([^ ]+)\} added global ([^ ]+) min\. K-Line for \[([^ ]+)\] \[(.*)\]$)"},
-
-    {SnoteTag::NewTemporaryKline,
-     R"(^([^ ]+)!([^ ]+)@([^ ]+)\{([^ ]+)\} added temporary ([^ ]+) min\. K-Line for \[([^ ]+)\] \[(.*)\]$)"},
-
-    {SnoteTag::LoginAttempts,
-     "^Warning: \x02([^ ]+)\x02 failed login attempts to \x02([^ ]+)\x02\\. Last attempt received from \x02(.+)\x02.*$"},
-
-    {SnoteTag::PossibleFlooder,
-     R"(^Possible Flooder ([^ ]+)\[([^ ]+)@[^ ]+\] on ([^ ]+) target: ([^ ]+)$)"},
-
-    {SnoteTag::Killed,
-     R"(^Received KILL message for ([^ ]+)!([^ ]+)@([^ ]+)\. From ([^ ]+) Path: ([^ ]+) \((.*)\)$)"},
 };
 
-auto setup_database() -> hs_database_t*
+auto setup_database() -> std::unique_ptr<hs_database_t, SnoteThread::DbDeleter>
 {
-    auto const n = std::size(patterns);
     std::vector<char const*> expressions;
-    std::vector<unsigned> flags(n, HS_FLAG_SINGLEMATCH);
+    std::vector<unsigned> flags;
     std::vector<unsigned> ids;
 
-    expressions.reserve(n);
+    expressions.reserve(std::size(patterns));
-    ids.reserve(n);
+    flags.reserve(std::size(patterns));
+    ids.reserve(std::size(patterns));
 
-    for (std::size_t i = 0; i < n; i++)
+    unsigned id = 0;
+
+    for (auto const& pattern : patterns)
     {
-        expressions.push_back(patterns[i].expression);
+        expressions.push_back(pattern.expression);
-        ids.push_back(i);
+        flags.push_back(pattern.flags);
+        ids.push_back(id++);
     }
 
     hs_database_t* db;
     hs_compile_error *error;
-    hs_platform_info_t *platform = nullptr; // target current platform
+
-    switch (hs_compile_multi(expressions.data(), flags.data(), ids.data(), expressions.size(), HS_MODE_BLOCK, platform, &db, &error))
+    switch (hs_compile_multi(expressions.data(), flags.data(), ids.data(), expressions.size(), HS_MODE_BLOCK, nullptr, &db, &error))
     {
         case HS_COMPILER_ERROR:
         {
@@ -100,7 +71,7 @@ auto setup_database() -> hs_database_t*
         default:
             abort();
     }
-    return db;
+    return std::unique_ptr<hs_database_t, SnoteThread::DbDeleter>{db};
 }
 
 } // namespace
@@ -109,47 +80,41 @@ auto SnoteThread::start(Connection& connection) -> std::shared_ptr<SnoteThread>
 {
     auto thread = std::make_shared<SnoteThread>();
 
-    thread->db_.reset(setup_database());
+    thread->db_ = setup_database();
 
     hs_scratch_t* scratch = nullptr;
     if (HS_SUCCESS != hs_alloc_scratch(thread->db_.get(), &scratch))
     {
         abort();
     }
-    thread->scratch_.reset(scratch);
+    thread->scratch_ = std::unique_ptr<hs_scratch_t, ScratchDeleter>{scratch};
 
     static char const* const prefix = "*** Notice -- ";
     connection.add_listener<IrcMsgEvent>([&connection, thread](IrcMsgEvent& event)
     {
         auto& args = event.irc.args;
-        if (IrcCommand::NOTICE == event.command && "*" == args[0] && args[1].starts_with(prefix))
+        if (IrcCommand::NOTICE == event.command
+         && "*" == args[0]
+         && args[1].starts_with(prefix))
         {
             event.handled_ = true;
-            auto const message = args[1].substr(strlen(prefix));
+            auto message = args[1].substr(strlen(prefix));
+            unsigned int match_id = -1;
+            auto const scan_result = hs_scan(thread->db_.get(), message.data(), message.size(), 0, thread->scratch_.get(),
+                [](unsigned int id, unsigned long long from, unsigned long long to, unsigned int flags, void *context) -> int
+                {
+                    int* const match_id = static_cast<int*>(context);
+                    *match_id = id;
+                    return 1; // stop scanning
+                }
+            , &match_id);
 
-            unsigned match_id;
+            if (scan_result != HS_SUCCESS && scan_result != HS_SCAN_TERMINATED)
-            auto cb = [&match_id](unsigned id, unsigned long long, unsigned long long, unsigned) -> int
             {
-                match_id = id;
+                abort();
-                return 1; // stop scanning
+            }
-            };
 
-            auto const scan_result =
+            if (match_id != -1)
-                hs_scan(
-                    thread->db_.get(),
-                    message.data(), message.size(),
-                    0, // no flags
-                    thread->scratch_.get(),
-                    CCallback<decltype(cb)>::invoke, &cb
-                );
-
-            switch (scan_result)
-            {
-            case HS_SUCCESS:
-                std::cout << "Unknown snote: " << message << std::endl;
-                break;
-            
-            case HS_SCAN_TERMINATED:
             {
                 auto& pattern = patterns[match_id];
                 std::match_results<std::string_view::const_iterator> results;                
@@ -165,11 +130,6 @@ auto SnoteThread::start(Connection& connection) -> std::shared_ptr<SnoteThread>
                     parts.push_back(std::string_view{sub.first, sub.second});
                 }
                 connection.make_event<SnoteEvent>(pattern.tag, std::move(parts));
-                break;
-            }
-
-            default:
-                abort();
             }
         }
     });

snote_thread.hpp

@@ -1,6 +1,6 @@
 #pragma once
 
-#include "event.hpp"
+#include "thread.hpp"
 
 #include <hs.h>
 
@@ -12,17 +12,6 @@ enum class SnoteTag
 {
     ClientConnecting,
     ClientExiting,
-    RejectingKlined,
-    NickChange,
-    CreateChannel,
-    TemporaryKlineExpired,
-    PropagatedBanExpired,
-    DisconnectingKlined,
-    NewPropagatedKline,
-    NewTemporaryKline,
-    LoginAttempts,
-    PossibleFlooder,
-    Killed,
 };
 
 struct SnoteEvent : Event

thread.cpp

@@ -0,0 +1 @@
+#include "thread.hpp"

thread.hpp

@@ -6,6 +6,6 @@
 #include <vector>
 
 struct Event {
-    virtual ~Event() = default;
+    virtual ~Event() {}
     bool handled_ = false;
 };

watchdog_thread.cpp

@@ -11,60 +11,71 @@
 
 using namespace std::chrono_literals;
 
-WatchdogThread::WatchdogThread(Connection& connection)
+namespace {
-: connection_{connection}
-, timer_{connection.get_executor()}
-, tried_ping{false}
-{
-}
 
-auto WatchdogThread::on_activity() -> void
+struct WatchdogThread : std::enable_shared_from_this<WatchdogThread>
 {
-    tried_ping = false;
+    WatchdogThread(Connection& connection)
-    timer_.expires_from_now(30s);
+    : connection_{connection}
-}
+    , timer_{connection.get_executor()}
-
+    , tried_ping{false}
-auto WatchdogThread::timeout_token() 
-{
-    return [weak = weak_from_this()](auto const& error)
     {
-        if (not error)
-        {
-            if (auto self = weak.lock())
-            {
-                self->on_timeout();
-            }
-        }
-    };
-}
-
-auto WatchdogThread::on_timeout() -> void
-{
-    if (tried_ping)
-    {
-        connection_.close();
     }
-    else
+
+    Connection& connection_;
+    boost::asio::steady_timer timer_;
+    bool tried_ping;
+
+    auto on_activity() -> void
     {
-        send_ping(connection_, "watchdog");
+        tried_ping = false;
-        tried_ping = true;
         timer_.expires_from_now(30s);
+    }
+
+    auto timeout_token() 
+    {
+        return [weak = weak_from_this()](auto const& error)
+        {
+            if (not error)
+            {
+                if (auto self = weak.lock())
+                {
+                    self->on_timeout();
+                }
+            }
+        };
+    }
+
+    auto on_timeout() -> void
+    {
+        if (tried_ping)
+        {
+            connection_.close();
+        }
+        else
+        {
+            send_ping(connection_, "watchdog");
+            tried_ping = true;
+            timer_.expires_from_now(30s);
+            timer_.async_wait(timeout_token());
+        }
+    }
+
+    auto on_connect() -> void
+    {
+        on_activity();
         timer_.async_wait(timeout_token());
     }
-}
 
-auto WatchdogThread::on_connect() -> void
+    auto on_disconnect() -> void
-{
+    {
-    on_activity();
+        timer_.cancel();
-    timer_.async_wait(timeout_token());
+    }
-}
+};
 
-auto WatchdogThread::on_disconnect() -> void
+} // namespace
-{
-    timer_.cancel();
-}
 
-auto WatchdogThread::start(Connection& connection) -> void
+auto watchdog_thread(Connection& connection) -> void
 {
     auto const thread = std::make_shared<WatchdogThread>(connection);
     connection.add_listener<ConnectEvent>([thread](auto&)

watchdog_thread.hpp

@@ -1,24 +1,4 @@
 #pragma once
 
-#include <boost/asio/steady_timer.hpp>
-
-#include <memory>
-
 class Connection;
-
+auto watchdog_thread(Connection& connection) -> void;
-class WatchdogThread : std::enable_shared_from_this<WatchdogThread>
-{
-    Connection& connection_;
-    boost::asio::steady_timer timer_;
-    bool tried_ping;
-
-    auto on_activity() -> void;
-    auto timeout_token();
-    auto on_timeout() -> void;
-    auto on_connect() -> void;
-    auto on_disconnect() -> void;
-
-public:
-    WatchdogThread(Connection& connection);
-    static auto start(Connection& connection) -> void;
-};