glguy/xbot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: glguy:efb49b87086d05945ff20e8fa9ae99a5d7504300
Branches Tags
glguy:main
..
compare: glguy:f59049187e2c8e80dc5713b5ed0bf6222fe8e606
Branches Tags
glguy:main

No commits in common. "efb49b87086d05945ff20e8fa9ae99a5d7504300" and "f59049187e2c8e80dc5713b5ed0bf6222fe8e606" have entirely different histories.
efb49b8708 ... f59049187e

8 changed files with 67 additions and 192 deletions
Show Stats Expand all files Collapse all files

6
connection.cpp
View File

@ -10,7 +10,7 @@ Connection::Connection(boost::asio::io_context & io)
{
}
auto Connection::writer_immediate() -> void
auto Connection::writer_() -> void
{
std::vector<boost::asio::const_buffer> buffers;
buffers.reserve(write_strings_.size());
@ -45,14 +45,14 @@ auto Connection::writer() -> void
{
if (not self->write_strings_.empty())
{
self->writer_immediate();
self->writer_();
}
}
});
}
else
{
writer_immediate();
writer_();
}
}

2
connection.hpp
View File

@ -59,7 +59,7 @@ private:
EventDispatcher dispatcher_;
auto writer() -> void;
auto writer_immediate() -> void;
auto writer_() -> void;
public:
Connection(boost::asio::io_context & io);

165
self_thread.cpp
View File

@ -1,87 +1,9 @@
#include "self_thread.hpp"
#include <boost/log/trivial.hpp>
#include "connection.hpp"
#include "ircmsg.hpp"
#include "irc_parse_thread.hpp"
auto SelfThread::on_welcome(IrcMsg const& irc) -> void
{
nickname_ = irc.args[0];
}
auto SelfThread::on_nick(IrcMsg const& irc) -> void
{
if (is_my_mask(irc.source))
{
nickname_ = irc.args[0];
}
}
auto SelfThread::on_umodeis(IrcMsg const& irc) -> void
{
mode_ = irc.args[1];
}
auto SelfThread::on_join(IrcMsg const& irc) -> void
{
if (is_my_mask(irc.source))
{
channels_.insert(std::string{irc.args[0]});
}
}
auto SelfThread::on_kick(IrcMsg const& irc) -> void
{
if (is_my_nick(irc.args[1]))
{
channels_.erase(std::string{irc.args[0]});
}
}
auto SelfThread::on_part(IrcMsg const& irc) -> void
{
if (is_my_mask(irc.source))
{
channels_.erase(std::string{irc.args[0]});
}
}
auto SelfThread::on_mode(IrcMsg const& irc) -> void
{
if (is_my_nick(irc.args[0]))
{
auto polarity = true;
for (char const c : irc.args[1])
{
switch (c)
{
case '+':
polarity = true;
break;
case '-':
polarity = false;
break;
default:
if (polarity)
{
mode_ += c;
}
else
{
auto const ix = mode_.find(c);
if (ix != std::string::npos)
{
mode_.erase(ix, 1);
}
}
break;
}
}
}
}
auto SelfThread::start(Connection& connection) -> std::shared_ptr<SelfThread>
{
auto thread = std::make_shared<SelfThread>(connection);
@ -92,65 +14,64 @@ auto SelfThread::start(Connection& connection) -> std::shared_ptr<SelfThread>
{
// Learn nickname from 001
case IrcCommand::RPL_WELCOME:
thread->on_welcome(event.irc);
thread->nickname_ = event.irc.args[0];
break;
// Track changes to our nickname
case IrcCommand::NICK:
thread->on_nick(event.irc);
{
auto const bang = event.irc.source.find('!');
if (bang != std::string::npos
&& thread->nickname_ == event.irc.source.substr(0, bang)
)
{
thread->nickname_ = event.irc.args[0];
}
break;
}
// Re-establish user modes
case IrcCommand::RPL_UMODEIS:
thread->on_umodeis(event.irc);
break;
case IrcCommand::JOIN:
thread->on_join(event.irc);
break;
case IrcCommand::KICK:
thread->on_kick(event.irc);
break;
case IrcCommand::PART:
thread->on_part(event.irc);
thread->mode_ = event.irc.args[1];
break;
// Interpret self mode changes
case IrcCommand::MODE:
thread->on_mode(event.irc);
break;
if (2 == event.irc.args.size()
&& thread->nickname_ == event.irc.args[0]
)
{
auto polarity = true;
for (char const c : event.irc.args[1])
{
switch (c)
{
case '+':
polarity = true;
break;
case '-':
polarity = false;
break;
default:
if (polarity)
{
thread->mode_ += c;
}
else
{
auto const ix = thread->mode_.find(c);
if (ix != std::string::npos)
{
thread->mode_.erase(ix, 1);
}
}
break;
}
}
}
default: break;
}
});
return thread;
}
auto SelfThread::get_my_nickname() const -> std::string const&
{
return nickname_;
}
auto SelfThread::get_my_mode() const -> std::string const&
{
return mode_;
}
auto SelfThread::get_my_channels() const -> std::unordered_set<std::string> const&
{
return channels_;
}
auto SelfThread::is_my_nick(std::string_view nick) const -> bool
{
return nick == nickname_;
}
auto SelfThread::is_my_mask(std::string_view mask) const -> bool
{
auto const bang = mask.find('!');
return bang != std::string_view::npos && nickname_ == mask.substr(0, bang);
}

24
self_thread.hpp
View File

@ -1,39 +1,17 @@
#pragma once
#include <memory>
#include <string>
#include <unordered_set>
#include <memory>
struct Connection;
struct IrcMsg;
/**
* @brief Thread to track this connection's identity, and IRC state.
*
*/
class SelfThread
{
Connection& connection_;
std::string nickname_;
std::string mode_;
std::unordered_set<std::string> channels_;
auto on_welcome(IrcMsg const& irc) -> void;
auto on_nick(IrcMsg const& irc) -> void;
auto on_umodeis(IrcMsg const& irc) -> void;
auto on_join(IrcMsg const& irc) -> void;
auto on_kick(IrcMsg const& irc) -> void;
auto on_part(IrcMsg const& irc) -> void;
auto on_mode(IrcMsg const& irc) -> void;
public:
SelfThread(Connection& connection) : connection_{connection} {}
static auto start(Connection&) -> std::shared_ptr<SelfThread>;
auto get_my_nickname() const -> std::string const&;
auto get_my_mode() const -> std::string const&;
auto get_my_channels() const -> std::unordered_set<std::string> const&;
auto is_my_nick(std::string_view nick) const -> bool;
auto is_my_mask(std::string_view nick) const -> bool;
};

4
snote_thread.cpp
View File

@ -31,7 +31,7 @@ struct SnotePattern
std::regex regex;
};
SnotePattern static const patterns[] =
SnotePattern const patterns[] =
{
{SnoteTag::ClientConnecting,
R"(^Client connecting: ([^ ]+) \(([^@ ]+)@([^) ]+)\) \[(.*)\] \{([^ ]*)\} <([^ ]*)> \[(.*)\]$)"},
@ -79,7 +79,7 @@ SnotePattern static const patterns[] =
"^\x02([^ ]+)\x02 set vhost ([^ ]+) on the \x02MARKED\x02 account ([^ ]+).$"},
};
static auto setup_database() -> hs_database_t*
auto setup_database() -> hs_database_t*
{
auto const n = std::size(patterns);
std::vector<char const*> expressions;

3
snote_thread.hpp
View File

@ -58,10 +58,7 @@ struct SnoteThread
auto operator()(hs_scratch * scratch) const -> void;
};
/// @brief Database of server notice patterns
std::unique_ptr<hs_database, DbDeleter> db_;
/// @brief HyperScan scratch space
std::unique_ptr<hs_scratch, ScratchDeleter> scratch_;
static auto start(Connection& connection) -> std::shared_ptr<SnoteThread>;

24
watchdog_thread.cpp
View File

@ -9,22 +9,24 @@
#include <chrono>
#include <memory>
using namespace std::chrono_literals;
WatchdogThread::WatchdogThread(Connection& connection)
: connection_{connection}
, timer_{connection.get_executor()}
, stalled_{false}
, tried_ping{false}
{
}
auto WatchdogThread::on_activity() -> void
{
stalled_ = false;
timer_.expires_from_now(WatchdogThread::TIMEOUT);
tried_ping = false;
timer_.expires_from_now(30s);
}
auto WatchdogThread::start_timer()
auto WatchdogThread::timeout_token()
{
timer_.async_wait([weak = weak_from_this()](auto const& error)
return [weak = weak_from_this()](auto const& error)
{
if (not error)
{
@ -33,28 +35,28 @@ auto WatchdogThread::start_timer()
self->on_timeout();
}
}
});
};
}
auto WatchdogThread::on_timeout() -> void
{
if (stalled_)
if (tried_ping)
{
connection_.close();
}
else
{
send_ping(connection_, "watchdog");
stalled_ = true;
timer_.expires_from_now(WatchdogThread::TIMEOUT);
start_timer();
tried_ping = true;
timer_.expires_from_now(30s);
timer_.async_wait(timeout_token());
}
}
auto WatchdogThread::on_connect() -> void
{
on_activity();
start_timer();
timer_.async_wait(timeout_token());
}
auto WatchdogThread::on_disconnect() -> void

27
watchdog_thread.hpp
View File

@ -2,43 +2,20 @@
#include <boost/asio/steady_timer.hpp>
#include <chrono>
#include <memory>
class Connection;
/**
* @brief Watch for connection activity and disconnect on stall
*
* The thread will send a ping if no message is received in the
* last TIMEOUT seconds. After another period of no messages
* the thread will disconnect the connection.
*
*/
class WatchdogThread : std::enable_shared_from_this<WatchdogThread>
{
Connection& connection_;
boost::asio::steady_timer timer_;
bool tried_ping;
/// @brief Set true and ping sent and false when reply received
bool stalled_;
const std::chrono::steady_clock::duration TIMEOUT = std::chrono::seconds{30};
/// @brief Start the timer
/// @return
auto start_timer();
/// @brief
auto on_activity() -> void;
/// @brief
auto timeout_token();
auto on_timeout() -> void;
/// @brief callback for ConnectEvent event
auto on_connect() -> void;
/// @brief callback for DisconnectEvent event
auto on_disconnect() -> void;
public: