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

unify with snowcone

Browse Source
This commit is contained in:
Eric Mertens
2025-02-05 09:24:47 -08:00
parent 5f2439e5af
commit 2b4bb1f071
20 changed files with 589 additions and 483 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
myirc/CMakeLists.txt
View File

@@ -1,7 +1,7 @@
add_custom_command(
OUTPUT irc_commands.inc
COMMAND
gperf
/opt/homebrew/bin/gperf
-C -Z IrcCommandHash -K text -L C++ -t
--output-file irc_commands.inc
${CMAKE_CURRENT_SOURCE_DIR}/irc_commands.gperf
@@ -20,6 +20,7 @@ add_library(myirc STATIC
ratelimit.cpp
sasl_mechanism.cpp
snote.cpp
linebuffer.cpp
)
target_include_directories(myirc PUBLIC include)

2
myirc/bot.cpp
View File

@@ -9,7 +9,7 @@ auto Bot::start(std::shared_ptr<Client> self) -> std::shared_ptr<Bot>
const auto thread = std::make_shared<Bot>(std::move(self));
thread->self_->sig_chat.connect([thread](auto &chat) {
thread->self_->sig_chat.connect([thread](auto &chat, bool) {
thread->on_chat(chat);
});

20
myirc/challenge.cpp
View File

@@ -14,9 +14,9 @@
namespace myirc {
Challenge::Challenge(Ref<EVP_PKEY> key, std::shared_ptr<Connection> connection)
Challenge::Challenge(Ref<EVP_PKEY> key, std::shared_ptr<Client> client)
: key_{std::move(key)}
, connection_{std::move(connection)}
, client_{std::move(client)}
{}
auto Challenge::on_ircmsg(IrcCommand cmd, const IrcMsg &msg) -> void {
@@ -31,7 +31,6 @@ auto Challenge::on_ircmsg(IrcCommand cmd, const IrcMsg &msg) -> void {
break;
case IrcCommand::RPL_YOUREOPER:
slot_.disconnect();
//connection_->send_ping("mitigation");
break;
case IrcCommand::RPL_ENDOFRSACHALLENGE2:
finish_challenge();
@@ -46,9 +45,10 @@ auto Challenge::finish_challenge() -> void
size_t len = mybase64::decoded_size(buffer_.size());
std::vector<unsigned char> ciphertext(len, 0);
if (not mybase64::decode(buffer_, reinterpret_cast<char*>(ciphertext.data()), &len))
auto decode_end = mybase64::decode(buffer_, reinterpret_cast<char*>(ciphertext.data()));
if (decode_end == nullptr )
return log_openssl_errors("Challenge base64::decode: ");
ciphertext.resize(len);
ciphertext.resize(decode_end - reinterpret_cast<char*>(ciphertext.data()));
// Setup decryption context
Ref<EVP_PKEY_CTX> ctx{EVP_PKEY_CTX_new(key_.get(), nullptr)};
@@ -80,15 +80,15 @@ auto Challenge::finish_challenge() -> void
buffer_[0] = '+';
mybase64::encode(std::string_view{(char*)digest, digestlen}, buffer_.data() + 1);
connection_->send_challenge(buffer_);
client_->send_challenge(buffer_);
buffer_.clear();
}
auto Challenge::start(std::shared_ptr<Connection> connection, const std::string_view user, Ref<EVP_PKEY> ref) -> std::shared_ptr<Challenge>
auto Challenge::start(std::shared_ptr<Client> client, const std::string_view user, Ref<EVP_PKEY> ref) -> std::shared_ptr<Challenge>
{
auto self = std::make_shared<Challenge>(std::move(ref), connection);
self->slot_ = connection->sig_ircmsg.connect([self](auto cmd, auto &msg) { self->on_ircmsg(cmd, msg); });
connection->send_challenge(user);
auto self = std::make_shared<Challenge>(std::move(ref), client);
self->slot_ = client->get_connection().sig_ircmsg.connect([self](auto cmd, auto &msg, bool) { self->on_ircmsg(cmd, msg); });
client->send_challenge(user);
return self;
}

239
myirc/client.cpp
View File

@@ -2,6 +2,7 @@
#include "myirc/connection.hpp"
#include "myirc/sasl_mechanism.hpp"
#include "myirc/snote.hpp"
#include <mybase64.hpp>
@@ -121,7 +122,7 @@ auto Client::on_isupport(const IrcMsg &msg) -> void
}
}
auto Client::on_chat(bool notice, const IrcMsg &irc) -> void
auto Client::on_chat(bool notice, const IrcMsg &irc, bool flush) -> void
{
char status_msg = '\0';
std::string_view target = irc.args[0];
@@ -137,21 +138,26 @@ auto Client::on_chat(bool notice, const IrcMsg &irc) -> void
.source = irc.source,
.target = irc.args[0],
.message = irc.args[1],
});
}, flush);
}
auto Client::start(std::shared_ptr<Connection> connection) -> std::shared_ptr<Client>
{
auto thread = std::make_shared<Client>(connection);
connection->sig_ircmsg.connect([thread](auto cmd, auto &msg) {
connection->sig_ircmsg.connect([thread](auto cmd, auto &msg, bool flush) {
switch (cmd)
{
case IrcCommand::PRIVMSG:
thread->on_chat(false, msg);
thread->on_chat(false, msg, flush);
break;
case IrcCommand::NOTICE:
thread->on_chat(true, msg);
if (auto match = snoteCore.match(msg))
{
thread->sig_snote(*match, flush);
} else {
thread->on_chat(true, msg, flush);
}
break;
case IrcCommand::JOIN:
thread->on_join(msg);
@@ -184,15 +190,14 @@ auto Client::start(std::shared_ptr<Connection> connection) -> std::shared_ptr<Cl
case IrcCommand::CAP:
thread->on_cap(msg);
break;
case IrcCommand::AUTHENTICATE:
thread->on_authenticate_chunk(msg.args[0]);
break;
default:
break;
}
});
connection->sig_authenticate.connect([thread](auto msg) {
thread->on_authenticate(msg);
});
return thread;
}
@@ -242,20 +247,20 @@ auto Client::on_authenticate(const std::string_view body) -> void
if (not sasl_mechanism_)
{
BOOST_LOG_TRIVIAL(warning) << "Unexpected AUTHENTICATE from server"sv;
connection_->send_authenticate_abort();
send_authenticate_abort();
return;
}
std::visit(
overloaded{
[this](const std::string &reply) {
connection_->send_authenticate_encoded(reply);
send_authenticate_encoded(reply);
},
[this](SaslMechanism::NoReply) {
connection_->send_authenticate("*"sv);
send_authenticate("*"sv);
},
[this](SaslMechanism::Failure) {
connection_->send_authenticate_abort();
send_authenticate_abort();
},
},
sasl_mechanism_->step(body));
@@ -270,11 +275,11 @@ auto Client::start_sasl(std::unique_ptr<SaslMechanism> mechanism) -> void
{
if (sasl_mechanism_)
{
connection_->send_authenticate("*"sv); // abort SASL
send_authenticate("*"sv); // abort SASL
}
sasl_mechanism_ = std::move(mechanism);
connection_->send_authenticate(sasl_mechanism_->mechanism_name());
send_authenticate(sasl_mechanism_->mechanism_name());
}
static auto tolower_rfc1459(int c) -> int
@@ -334,7 +339,7 @@ auto Client::casemap_compare(std::string_view lhs, std::string_view rhs) const -
auto Client::list_caps() -> void
{
caps_available_.clear();
connection_->send_cap_ls();
send_cap_ls();
}
auto Client::on_cap(const IrcMsg &msg) -> void
@@ -429,4 +434,206 @@ auto Client::on_cap(const IrcMsg &msg) -> void
}
}
auto Client::on_authenticate_chunk(const std::string_view chunk) -> void
{
if (chunk != "+"sv)
{
authenticate_buffer_ += chunk;
}
if (chunk.size() != 400)
{
std::string decoded;
decoded.resize(mybase64::decoded_size(authenticate_buffer_.size()));
std::size_t len;
if (auto decode_end = mybase64::decode(authenticate_buffer_, decoded.data()))
{
decoded.resize(decode_end - decoded.data());
on_authenticate(decoded);
}
else
{
BOOST_LOG_TRIVIAL(debug) << "Invalid AUTHENTICATE base64"sv;
send_authenticate("*"sv); // abort SASL
}
authenticate_buffer_.clear();
}
else if (authenticate_buffer_.size() > 1024)
{
BOOST_LOG_TRIVIAL(debug) << "AUTHENTICATE buffer overflow"sv;
authenticate_buffer_.clear();
send_authenticate("*"sv); // abort SASL
}
}
auto Client::send_ping(std::string_view txt) -> void
{
connection_->write_irc("PING", txt);
}
auto Client::send_pong(std::string_view txt) -> void
{
connection_->write_irc("PONG", txt);
}
auto Client::send_pass(std::string_view password) -> void
{
connection_->write_irc("PASS", password);
}
auto Client::send_user(std::string_view user, std::string_view real) -> void
{
connection_->write_irc("USER", user, "*", "*", real);
}
auto Client::send_nick(std::string_view nick) -> void
{
connection_->write_irc("NICK", nick);
}
auto Client::send_cap_ls() -> void
{
connection_->write_irc("CAP", "LS", "302");
}
auto Client::send_cap_end() -> void
{
connection_->write_irc("CAP", "END");
}
auto Client::send_cap_req(std::string_view caps) -> void
{
connection_->write_irc("CAP", "REQ", caps);
}
auto Client::send_privmsg(std::string_view target, std::string_view message) -> void
{
connection_->write_irc("PRIVMSG", target, message);
}
auto Client::send_notice(std::string_view target, std::string_view message) -> void
{
connection_->write_irc("NOTICE", target, message);
}
auto Client::send_wallops(std::string_view message) -> void
{
connection_->write_irc("WALLOPS", message);
}
auto Client::send_names(std::string_view channel) -> void
{
connection_->write_irc("NAMES", channel);
}
auto Client::send_map() -> void
{
connection_->write_irc("MAP");
}
auto Client::send_get_topic(std::string_view channel) -> void
{
connection_->write_irc("TOPIC", channel);
}
auto Client::send_set_topic(std::string_view channel, std::string_view message) -> void
{
connection_->write_irc("TOPIC", channel, message);
}
auto Client::send_testline(std::string_view target) -> void
{
connection_->write_irc("TESTLINE", target);
}
auto Client::send_masktrace_gecos(std::string_view target, std::string_view gecos) -> void
{
connection_->write_irc("MASKTRACE", target, gecos);
}
auto Client::send_masktrace(std::string_view target) -> void
{
connection_->write_irc("MASKTRACE", target);
}
auto Client::send_testmask_gecos(std::string_view target, std::string_view gecos) -> void
{
connection_->write_irc("TESTMASK", target, gecos);
}
auto Client::send_testmask(std::string_view target) -> void
{
connection_->write_irc("TESTMASK", target);
}
auto Client::send_authenticate(std::string_view message) -> void
{
connection_->write_irc("AUTHENTICATE", message);
}
auto Client::send_join(std::string_view channel) -> void
{
connection_->write_irc("JOIN", channel);
}
auto Client::send_challenge(std::string_view message) -> void
{
connection_->write_irc("CHALLENGE", message);
}
auto Client::send_oper(std::string_view user, std::string_view pass) -> void
{
connection_->write_irc("OPER", user, pass);
}
auto Client::send_kick(std::string_view channel, std::string_view nick, std::string_view reason) -> void
{
connection_->write_irc("KICK", channel, nick, reason);
}
auto Client::send_kill(std::string_view nick, std::string_view reason) -> void
{
connection_->write_irc("KILL", nick, reason);
}
auto Client::send_quit(std::string_view message) -> void
{
connection_->write_irc("QUIT", message);
}
auto Client::send_whois(std::string_view arg1) -> void
{
connection_->write_irc("WHOIS", arg1);
}
auto Client::send_whois_remote(std::string_view arg1, std::string_view arg2) -> void
{
connection_->write_irc("WHOIS", arg1, arg2);
}
auto Client::send_authenticate_abort() -> void
{
send_authenticate("*");
}
auto Client::send_authenticate_encoded(std::string_view body) -> void
{
std::string encoded(mybase64::encoded_size(body.size()), 0);
mybase64::encode(body, encoded.data());
for (size_t lo = 0; lo < encoded.size(); lo += 400)
{
const auto hi = std::min(lo + 400, encoded.size());
const std::string_view chunk{encoded.begin() + lo, encoded.begin() + hi};
send_authenticate(chunk);
}
if (encoded.size() % 400 == 0)
{
send_authenticate("+"sv);
}
}
} // namespace myirc

309
myirc/connection.cpp
View File

@@ -1,12 +1,17 @@
#include "myirc/connection.hpp"
#include "myirc/linebuffer.hpp"
#include "myirc/snote.hpp"
#include <openssl/asn1.h>
#include <openssl/ssl.h>
#include <openssl/x509.h>
#include <socks5.hpp>
#include <mybase64.hpp>
#include <boost/asio/steady_timer.hpp>
#include <boost/log/trivial.hpp>
#include <sstream>
#include <iomanip>
namespace myirc {
@@ -99,7 +104,7 @@ auto Connection::watchdog() -> void
}
else
{
send_ping("watchdog");
write_irc("PING", "watchdog");
stalled_ = true;
watchdog();
}
@@ -114,7 +119,7 @@ auto Connection::watchdog_activity() -> void
}
/// Parse IRC message line and dispatch it to the ircmsg slot.
auto Connection::dispatch_line(char *line) -> void
auto Connection::dispatch_line(char *line, bool flush) -> void
{
const auto msg = parse_irc_message(line);
const auto recognized = IrcCommandHash::in_word_set(msg.command.data(), msg.command.size());
@@ -130,7 +135,7 @@ auto Connection::dispatch_line(char *line) -> void
// Respond to pings immediate and discard
case IrcCommand::PING:
send_pong(msg.args[0]);
write_irc("PONG", msg.args[0]);
break;
// Unknown message generate warnings but do not dispatch
@@ -139,22 +144,9 @@ auto Connection::dispatch_line(char *line) -> void
BOOST_LOG_TRIVIAL(warning) << "Unrecognized command: " << msg.command << " " << msg.args.size();
break;
case IrcCommand::AUTHENTICATE:
on_authenticate(msg.args[0]);
break;
// Server notice generate snote events but not IRC command events
case IrcCommand::NOTICE:
if (auto match = snoteCore.match(msg))
{
sig_snote(*match);
break;
}
/* FALLTHROUGH */
// Normal IRC commands
default:
sig_ircmsg(command, msg);
sig_ircmsg(command, msg, flush);
break;
}
}
@@ -202,208 +194,6 @@ auto Connection::write_irc(std::string front, std::string_view last) -> void
write_line(std::move(front));
}
auto Connection::send_ping(std::string_view txt) -> void
{
write_irc("PING", txt);
}
auto Connection::send_pong(std::string_view txt) -> void
{
write_irc("PONG", txt);
}
auto Connection::send_pass(std::string_view password) -> void
{
write_irc("PASS", password);
}
auto Connection::send_user(std::string_view user, std::string_view real) -> void
{
write_irc("USER", user, "*", "*", real);
}
auto Connection::send_nick(std::string_view nick) -> void
{
write_irc("NICK", nick);
}
auto Connection::send_cap_ls() -> void
{
write_irc("CAP", "LS", "302");
}
auto Connection::send_cap_end() -> void
{
write_irc("CAP", "END");
}
auto Connection::send_cap_req(std::string_view caps) -> void
{
write_irc("CAP", "REQ", caps);
}
auto Connection::send_privmsg(std::string_view target, std::string_view message) -> void
{
write_irc("PRIVMSG", target, message);
}
auto Connection::send_notice(std::string_view target, std::string_view message) -> void
{
write_irc("NOTICE", target, message);
}
auto Connection::send_wallops(std::string_view message) -> void
{
write_irc("WALLOPS", message);
}
auto Connection::send_names(std::string_view channel) -> void
{
write_irc("NAMES", channel);
}
auto Connection::send_map() -> void
{
write_irc("MAP");
}
auto Connection::send_get_topic(std::string_view channel) -> void
{
write_irc("TOPIC", channel);
}
auto Connection::send_set_topic(std::string_view channel, std::string_view message) -> void
{
write_irc("TOPIC", channel, message);
}
auto Connection::send_testline(std::string_view target) -> void
{
write_irc("TESTLINE", target);
}
auto Connection::send_masktrace_gecos(std::string_view target, std::string_view gecos) -> void
{
write_irc("MASKTRACE", target, gecos);
}
auto Connection::send_masktrace(std::string_view target) -> void
{
write_irc("MASKTRACE", target);
}
auto Connection::send_testmask_gecos(std::string_view target, std::string_view gecos) -> void
{
write_irc("TESTMASK", target, gecos);
}
auto Connection::send_testmask(std::string_view target) -> void
{
write_irc("TESTMASK", target);
}
auto Connection::send_authenticate(std::string_view message) -> void
{
write_irc("AUTHENTICATE", message);
}
auto Connection::send_join(std::string_view channel) -> void
{
write_irc("JOIN", channel);
}
auto Connection::send_challenge(std::string_view message) -> void
{
write_irc("CHALLENGE", message);
}
auto Connection::send_oper(std::string_view user, std::string_view pass) -> void
{
write_irc("OPER", user, pass);
}
auto Connection::send_kick(std::string_view channel, std::string_view nick, std::string_view reason) -> void
{
write_irc("KICK", channel, nick, reason);
}
auto Connection::send_kill(std::string_view nick, std::string_view reason) -> void
{
write_irc("KILL", nick, reason);
}
auto Connection::send_quit(std::string_view message) -> void
{
write_irc("QUIT", message);
}
auto Connection::send_whois(std::string_view arg1) -> void
{
write_irc("WHOIS", arg1);
}
auto Connection::send_whois_remote(std::string_view arg1, std::string_view arg2) -> void
{
write_irc("WHOIS", arg1, arg2);
}
auto Connection::on_authenticate(const std::string_view chunk) -> void
{
if (chunk != "+"sv)
{
authenticate_buffer_ += chunk;
}
if (chunk.size() != 400)
{
std::string decoded;
decoded.resize(mybase64::decoded_size(authenticate_buffer_.size()));
std::size_t len;
if (mybase64::decode(authenticate_buffer_, decoded.data(), &len))
{
decoded.resize(len);
sig_authenticate(decoded);
}
else
{
BOOST_LOG_TRIVIAL(debug) << "Invalid AUTHENTICATE base64"sv;
send_authenticate("*"sv); // abort SASL
}
authenticate_buffer_.clear();
}
else if (authenticate_buffer_.size() > 1024)
{
BOOST_LOG_TRIVIAL(debug) << "AUTHENTICATE buffer overflow"sv;
authenticate_buffer_.clear();
send_authenticate("*"sv); // abort SASL
}
}
auto Connection::send_authenticate_abort() -> void
{
send_authenticate("*");
}
auto Connection::send_authenticate_encoded(std::string_view body) -> void
{
std::string encoded(mybase64::encoded_size(body.size()), 0);
mybase64::encode(body, encoded.data());
for (size_t lo = 0; lo < encoded.size(); lo += 400)
{
const auto hi = std::min(lo + 400, encoded.size());
const std::string_view chunk{encoded.begin() + lo, encoded.begin() + hi};
send_authenticate(chunk);
}
if (encoded.size() % 400 == 0)
{
send_authenticate("+"sv);
}
}
static
auto set_buffer_size(tls_type& stream, std::size_t const n) -> void
{
@@ -504,6 +294,23 @@ auto build_ssl_context(
return ssl_context;
}
static auto peer_fingerprint(X509 *cer) -> std::string
{
std::ostringstream os;
std::vector<std::uint8_t> result;
EVP_MD *md_used;
if (auto digest = X509_digest_sig(cer, &md_used, nullptr))
{
os << EVP_MD_name(md_used) << ":" << std::hex << std::setfill('0');
EVP_MD_free(md_used);
for (int i = 0; i < digest->length; ++i) {
os << std::setw(2) << static_cast<unsigned>(digest->data[i]);
}
ASN1_OCTET_STRING_free(digest);
}
return os.str();
}
auto Connection::connect(
Settings settings
) -> boost::asio::awaitable<void>
@@ -514,6 +321,10 @@ auto Connection::connect(
const auto self = shared_from_this();
const size_t irc_buffer_size = 32'768;
boost::asio::ip::tcp::endpoint socket_endpoint;
std::optional<boost::asio::ip::tcp::endpoint> socks_endpoint;
std::string fingerprint;
{
// Name resolution
auto resolver = boost::asio::ip::tcp::resolver{stream_.get_executor()};
@@ -524,13 +335,37 @@ auto Connection::connect(
// Connect to the IRC server
auto& socket = stream_.reset();
const auto endpoint = co_await boost::asio::async_connect(socket, endpoints, boost::asio::use_awaitable);
BOOST_LOG_TRIVIAL(debug) << "CONNECTED: " << endpoint;
// If we're going to use SOCKS then the TCP connection host is actually the socks
// server and then the IRC server gets passed over the SOCKS protocol
auto const use_socks = not settings.socks_host.empty() && settings.socks_port != 0;
if (use_socks)
{
std::swap(settings.host, settings.socks_host);
std::swap(settings.port, settings.socks_port);
}
socket_endpoint = co_await boost::asio::async_connect(socket, endpoints, boost::asio::use_awaitable);
BOOST_LOG_TRIVIAL(debug) << "CONNECTED: " << socket_endpoint;
// Set socket options
socket.set_option(boost::asio::ip::tcp::no_delay(true));
set_buffer_size(socket, irc_buffer_size);
set_cloexec(socket.native_handle());
// Optionally negotiate SOCKS connection
if (use_socks)
{
auto auth = not settings.socks_user.empty() || not settings.socks_pass.empty()
? socks5::Auth{socks5::UsernamePasswordCredential{settings.socks_user, settings.socks_pass}}
: socks5::Auth{socks5::NoCredential{}};
socks_endpoint = co_await socks5::async_connect(
socket,
settings.socks_host, settings.socks_port, std::move(auth),
boost::asio::use_awaitable
);
}
}
if (settings.tls)
@@ -555,25 +390,39 @@ auto Connection::connect(
}
co_await stream.async_handshake(stream.client, boost::asio::use_awaitable);
const auto cer = SSL_get0_peer_certificate(stream.native_handle());
fingerprint = peer_fingerprint(cer);
}
sig_connect();
sig_connect(socket_endpoint, socks_endpoint, std::move(fingerprint));
watchdog();
for (LineBuffer buffer{irc_buffer_size};;)
{
boost::system::error_code error;
const auto n = co_await stream_.async_read_some(buffer.get_buffer(), boost::asio::redirect_error(boost::asio::use_awaitable, error));
auto const chunk = buffer.prepare();
if (chunk.size() == 0) break;
const auto n = co_await stream_.async_read_some(chunk, boost::asio::redirect_error(boost::asio::use_awaitable, error));
if (error)
{
break;
}
buffer.add_bytes(n, [this](char *line) {
BOOST_LOG_TRIVIAL(debug) << "RECV: " << line;
buffer.commit(n);
auto line = buffer.next_nonempty_line();
if (line)
{
watchdog_activity();
dispatch_line(line);
});
do
{
BOOST_LOG_TRIVIAL(debug) << "RECV: " << line;
const auto next_line = buffer.next_nonempty_line();
dispatch_line(line, next_line == nullptr);
line = next_line;
} while (line);
}
buffer.shift();
}
watchdog_timer_.cancel();
@@ -600,10 +449,8 @@ auto Connection::start(Settings settings) -> void
// Disconnect all slots to avoid circular references
self->sig_connect.disconnect_all_slots();
self->sig_ircmsg.disconnect_all_slots();
self->sig_snote.disconnect_all_slots();
self->sig_authenticate.disconnect_all_slots();
self->sig_disconnect();
self->sig_disconnect(e);
self->sig_disconnect.disconnect_all_slots();
});
}

10
myirc/include/myirc/challenge.hpp
View File

@@ -1,7 +1,7 @@
#pragma once
#include "connection.hpp"
#include "ref.hpp"
#include "myirc/client.hpp"
#include "myirc/ref.hpp"
#include <boost/signals2/connection.hpp>
@@ -14,7 +14,7 @@ namespace myirc {
class Challenge : std::enable_shared_from_this<Challenge>
{
Ref<EVP_PKEY> key_;
std::shared_ptr<Connection> connection_;
std::shared_ptr<Client> client_;
boost::signals2::scoped_connection slot_;
std::string buffer_;
@@ -22,14 +22,14 @@ class Challenge : std::enable_shared_from_this<Challenge>
auto finish_challenge() -> void;
public:
Challenge(Ref<EVP_PKEY>, std::shared_ptr<Connection>);
Challenge(Ref<EVP_PKEY>, std::shared_ptr<Client>);
/// @brief Starts the CHALLENGE protocol.
/// @param connection Registered connection.
/// @param user Operator username
/// @param key Operator private RSA key
/// @return Handle to the challenge object.
static auto start(std::shared_ptr<Connection>, std::string_view user, Ref<EVP_PKEY> key) -> std::shared_ptr<Challenge>;
static auto start(std::shared_ptr<Client>, std::string_view user, Ref<EVP_PKEY> key) -> std::shared_ptr<Challenge>;
};
} // namespace myirc

44
myirc/include/myirc/client.hpp
View File

@@ -50,6 +50,12 @@ class Client
std::unordered_map<std::string, std::string> caps_available_;
std::unordered_set<std::string> caps_;
// AUTHENTICATE support
std::string authenticate_buffer_;
auto on_authenticate(std::string_view) -> void;
auto on_authenticate_chunk(std::string_view) -> void;
auto on_welcome(const IrcMsg &irc) -> void;
auto on_isupport(const IrcMsg &irc) -> void;
auto on_nick(const IrcMsg &irc) -> void;
@@ -59,14 +65,14 @@ class Client
auto on_part(const IrcMsg &irc) -> void;
auto on_mode(const IrcMsg &irc) -> void;
auto on_cap(const IrcMsg &irc) -> void;
auto on_authenticate(std::string_view) -> void;
auto on_registered() -> void;
auto on_chat(bool, const IrcMsg &irc) -> void;
auto on_chat(bool, const IrcMsg &irc, bool flush) -> void;
public:
boost::signals2::signal<void()> sig_registered;
boost::signals2::signal<void(const std::unordered_map<std::string, std::string> &)> sig_cap_ls;
boost::signals2::signal<void(const Chat &)> sig_chat;
boost::signals2::signal<void(const Chat &, bool flush)> sig_chat;
boost::signals2::signal<void(SnoteMatch &, bool flush)> sig_snote;
Client(std::shared_ptr<Connection> connection)
: connection_{std::move(connection)}
@@ -101,6 +107,38 @@ public:
auto casemap_compare(std::string_view, std::string_view) const -> int;
auto shutdown() -> void;
auto send_ping(std::string_view) -> void;
auto send_pong(std::string_view) -> void;
auto send_pass(std::string_view) -> void;
auto send_user(std::string_view, std::string_view) -> void;
auto send_nick(std::string_view) -> void;
auto send_join(std::string_view) -> void;
auto send_names(std::string_view channel) -> void;
auto send_kick(std::string_view, std::string_view, std::string_view) -> void;
auto send_kill(std::string_view, std::string_view) -> void;
auto send_quit(std::string_view) -> void;
auto send_cap_ls() -> void;
auto send_cap_end() -> void;
auto send_map() -> void;
auto send_testline(std::string_view) -> void;
auto send_testmask(std::string_view) -> void;
auto send_testmask_gecos(std::string_view, std::string_view) -> void;
auto send_masktrace(std::string_view) -> void;
auto send_masktrace_gecos(std::string_view, std::string_view) -> void;
auto send_get_topic(std::string_view) -> void;
auto send_set_topic(std::string_view, std::string_view) -> void;
auto send_cap_req(std::string_view) -> void;
auto send_privmsg(std::string_view, std::string_view) -> void;
auto send_wallops(std::string_view) -> void;
auto send_notice(std::string_view, std::string_view) -> void;
auto send_authenticate(std::string_view message) -> void;
auto send_authenticate_encoded(std::string_view message) -> void;
auto send_authenticate_abort() -> void;
auto send_whois(std::string_view) -> void;
auto send_whois_remote(std::string_view, std::string_view) -> void;
auto send_challenge(std::string_view) -> void;
auto send_oper(std::string_view, std::string_view) -> void;
};
} // namespace myirc

67
myirc/include/myirc/connection.hpp
View File

@@ -47,43 +47,33 @@ private:
// Set false when message received.
bool stalled_;
// AUTHENTICATE support
std::string authenticate_buffer_;
/// write buffers after consulting with rate limit
auto write_buffers() -> void;
/// write a specific number of messages now
auto write_buffers(size_t) -> void;
auto dispatch_line(char *line) -> void;
auto dispatch_line(char *line, bool) -> void;
static constexpr std::chrono::seconds watchdog_duration = std::chrono::seconds{30};
auto watchdog() -> void;
auto watchdog_activity() -> void;
auto connect(Settings settings) -> boost::asio::awaitable<void>;
auto on_authenticate(std::string_view) -> void;
/// Build and send well-formed IRC message from individual parameters
auto write_irc(std::string) -> void;
auto write_irc(std::string, std::string_view) -> void;
template <typename... Args>
auto write_irc(std::string front, std::string_view next, Args... rest) -> void;
public:
boost::signals2::signal<void()> sig_connect;
boost::signals2::signal<void()> sig_disconnect;
boost::signals2::signal<void(IrcCommand, const IrcMsg &)> sig_ircmsg;
boost::signals2::signal<void(SnoteMatch &)> sig_snote;
boost::signals2::signal<void(std::string_view)> sig_authenticate;
boost::signals2::signal<void(
boost::asio::ip::tcp::endpoint,
std::optional<boost::asio::ip::tcp::endpoint>,
std::string
)> sig_connect;
boost::signals2::signal<void(std::exception_ptr)> sig_disconnect;
boost::signals2::signal<void(IrcCommand, const IrcMsg &, bool flush)> sig_ircmsg;
std::unique_ptr<RateLimit> rate_limit;
Connection(boost::asio::io_context &io);
/// Write bytes into the socket.
auto write_line(std::string message) -> void;
auto get_executor() -> boost::asio::any_io_executor
{
return stream_.get_executor();
@@ -92,37 +82,14 @@ public:
auto start(Settings) -> void;
auto close() -> void;
auto send_ping(std::string_view) -> void;
auto send_pong(std::string_view) -> void;
auto send_pass(std::string_view) -> void;
auto send_user(std::string_view, std::string_view) -> void;
auto send_nick(std::string_view) -> void;
auto send_join(std::string_view) -> void;
auto send_names(std::string_view channel) -> void;
auto send_kick(std::string_view, std::string_view, std::string_view) -> void;
auto send_kill(std::string_view, std::string_view) -> void;
auto send_quit(std::string_view) -> void;
auto send_cap_ls() -> void;
auto send_cap_end() -> void;
auto send_map() -> void;
auto send_testline(std::string_view) -> void;
auto send_testmask(std::string_view) -> void;
auto send_testmask_gecos(std::string_view, std::string_view) -> void;
auto send_masktrace(std::string_view) -> void;
auto send_masktrace_gecos(std::string_view, std::string_view) -> void;
auto send_get_topic(std::string_view) -> void;
auto send_set_topic(std::string_view, std::string_view) -> void;
auto send_cap_req(std::string_view) -> void;
auto send_privmsg(std::string_view, std::string_view) -> void;
auto send_wallops(std::string_view) -> void;
auto send_notice(std::string_view, std::string_view) -> void;
auto send_authenticate(std::string_view message) -> void;
auto send_authenticate_encoded(std::string_view message) -> void;
auto send_authenticate_abort() -> void;
auto send_whois(std::string_view) -> void;
auto send_whois_remote(std::string_view, std::string_view) -> void;
auto send_challenge(std::string_view) -> void;
auto send_oper(std::string_view, std::string_view) -> void;
/// Write bytes into the socket.
auto write_line(std::string message) -> void;
/// Build and send well-formed IRC message from individual parameters
auto write_irc(std::string) -> void;
auto write_irc(std::string, std::string_view) -> void;
template <typename... Args>
auto write_irc(std::string front, std::string_view next, Args... rest) -> void;
};
template <typename... Args>

2
myirc/include/myirc/irc_coroutine.hpp
View File

@@ -238,7 +238,7 @@ auto Wait<Ts...>::await_suspend(std::coroutine_handle<irc_promise> handle) -> vo
const auto tuple_size = std::tuple_size_v<decltype(modes_)>;
start_modes(std::make_index_sequence<tuple_size>{});
disconnect_slot_ = get_connection().sig_disconnect.connect([this]() {
disconnect_slot_ = get_connection().sig_disconnect.connect([this](auto) {
handle_.resume();
});
}

93
myirc/include/myirc/linebuffer.hpp
View File

@@ -12,8 +12,6 @@
#include <boost/asio/buffer.hpp>
#include <algorithm>
#include <concepts>
#include <vector>
namespace myirc {
@@ -24,11 +22,13 @@ namespace myirc {
*/
class LineBuffer
{
std::vector<char> buffer;
std::vector<char> buffer_;
// [buffer.begin(), end_) contains buffered data
// [end_, buffer.end()) is available buffer space
std::vector<char>::iterator end_;
// [std::begin(buffer), end_) contains buffered data
// [end_, std::end(buffer)) is available buffer space
decltype(buffer_)::iterator start_;
decltype(buffer_)::iterator search_;
decltype(buffer_)::iterator end_;
public:
/**
@@ -37,19 +37,27 @@ public:
* @param n Buffer size
*/
LineBuffer(std::size_t n)
: buffer(n)
, end_{buffer.begin()}
: buffer_(n)
, start_{buffer_.begin()}
, search_{buffer_.begin()}
, end_{buffer_.begin()}
{
}
// can't copy the iterator member safely
LineBuffer(LineBuffer const&) = delete;
LineBuffer(LineBuffer&&) = delete;
auto operator=(LineBuffer const&) -> LineBuffer& = delete;
auto operator=(LineBuffer&&) -> LineBuffer& = delete;
/**
* @brief Get the available buffer space
*
* @return boost::asio::mutable_buffer
*/
auto get_buffer() -> boost::asio::mutable_buffer
auto prepare() -> boost::asio::mutable_buffer
{
return boost::asio::buffer(&*end_, std::distance(end_, buffer.end()));
return boost::asio::buffer(&*end_, std::distance(end_, buffer_.end()));
}
/**
@@ -58,48 +66,39 @@ public:
* The first n bytes of the buffer will be considered to be
* populated. The line callback function will be called once
* per completed line. Those lines are removed from the buffer
* and the is ready for additional calls to get_buffer and
* add_bytes.
* and the is ready for additional calls to prepare and
* commit.
*
* @param n Bytes written to the last call of get_buffer
* @param n Bytes written to the last call of prepare
* @param line_cb Callback function to run on each completed line
*/
auto add_bytes(std::size_t n, std::invocable<char *> auto line_cb) -> void
auto commit(std::size_t const n) -> void
{
const auto start = end_;
std::advance(end_, n);
// new data is now located in [start, end_)
// cursor marks the beginning of the current line
auto cursor = buffer.begin();
for (auto nl = std::find(start, end_, '\n');
nl != end_;
nl = std::find(cursor, end_, '\n'))
{
// Null-terminate the line. Support both \n and \r\n
if (cursor < nl && *std::prev(nl) == '\r')
{
*std::prev(nl) = '\0';
}
else
{
*nl = '\0';
}
line_cb(&*cursor);
cursor = std::next(nl);
}
// If any lines were processed, move all processed lines to
// the front of the buffer
if (cursor != buffer.begin())
{
end_ = std::move(cursor, end_, buffer.begin());
}
}
/**
* @brief Return the next null-terminated line in the buffer
*
* This function should be repeatedly called until it returns
* nullptr. After that shift can be used to reclaim the
* previously used buffer.
*
* @return null-terminated line or nullptr if no line is ready
*/
auto next_line() -> char*;
/**
* @brief Return the next non-empty line if there is one.
*/
auto next_nonempty_line() -> char*;
/**
* @brief Reclaim used buffer space invalidating all previous
* next_line() results;
*
*/
auto shift() -> void;
};
} // namespace myirc
} // namespace

6
myirc/include/myirc/ref.hpp
View File

@@ -42,6 +42,12 @@ struct Ref : std::unique_ptr<T, RefDeleter<T>>
/// Takes ownership of the pointer
explicit Ref(T *x) noexcept : base{x} {}
/// Takes ownership of the pointer
static auto borrow(T *x) -> Ref {
RefTraits<T>::UpRef(x);
return Ref{x};
}
Ref(Ref &&ref) noexcept = default;
Ref(const Ref &ref) noexcept : base{ref.get()} {
if (*this) {

4
myirc/irc_commands.gperf
View File

@@ -260,8 +260,8 @@ struct RecognizedCommand {
ACCOUNT, IrcCommand::ACCOUNT, 1, 1
AUTHENTICATE, IrcCommand::AUTHENTICATE, 1, 1
AWAY, IrcCommand::AWAY, 0, 1
BATCH, IrcCommand::BATCH
BOUNCER, IrcCommand::BOUNCER
BATCH, IrcCommand::BATCH, 1, 15
BOUNCER, IrcCommand::BOUNCER, 1, 15
CAP, IrcCommand::CAP, 1, 15
CHGHOST, IrcCommand::CHGHOST, 2, 2
ERROR, IrcCommand::ERROR, 1, 1

54
myirc/linebuffer.cpp Normal file
View File

@@ -0,0 +1,54 @@
#include "myirc/linebuffer.hpp"
namespace myirc {
auto LineBuffer::next_line() -> char*
{
auto const nl = std::find(search_, end_, '\n');
if (nl == end_) // no newline found, line incomplete
{
search_ = end_;
return nullptr;
}
// Null-terminate the line. Support both \n and \r\n
*(start_ < nl && *std::prev(nl) == '\r' ? std::prev(nl) : nl) = '\0';
auto const result = start_;
start_ = search_ = std::next(nl);
return &*result;
}
// Get the next complete line skipping over empty lines
auto LineBuffer::next_nonempty_line() -> char*
{
char* line;
while ((line = next_line()))
{
while (*line == ' ')
{
line++;
}
if ('\0' != *line)
{
break;
}
}
return line;
}
auto LineBuffer::shift() -> void
{
auto const first = std::begin(buffer_);
auto const gap = std::distance(start_, first);
if (gap != 0) // relocate incomplete line to front of buffer
{
end_ = std::move(start_, end_, first);
start_ = first;
std::advance(search_, gap);
}
}
} // namespace myirc

4
myirc/openssl_utils.cpp
View File

@@ -48,9 +48,9 @@ auto key_from_file(const std::string &filename, const std::string_view password)
if (const auto fp = fopen(filename.c_str(), "r"))
{
auto cb = [password](char * const buf, int const size, int) -> int {
if (size < password.size()) { return -1; }
if (std::cmp_less(size, password.size())) { return -1; }
std::copy(password.begin(), password.end(), buf);
return password.size();
return static_cast<int>(password.size());
};
key.reset(PEM_read_PrivateKey(fp, nullptr, CCallback<decltype(cb)>::invoke, &cb));

18
myirc/registration.cpp
View File

@@ -29,7 +29,7 @@ auto Registration::on_connect() -> void
});
slot_ = connection.sig_ircmsg.connect(
[self = shared_from_this()](const auto cmd, auto &msg)
[self = shared_from_this()](const auto cmd, auto &msg, auto)
{
self->on_ircmsg(cmd, msg);
}
@@ -37,10 +37,10 @@ auto Registration::on_connect() -> void
if (not settings_.password.empty())
{
connection.send_pass(settings_.password);
client_->send_pass(settings_.password);
}
connection.send_user(settings_.username, settings_.realname);
connection.send_nick(settings_.nickname);
client_->send_user(settings_.username, settings_.realname);
client_->send_nick(settings_.nickname);
}
auto Registration::on_cap_list(const std::unordered_map<std::string, std::string> &caps) -> void
@@ -79,13 +79,13 @@ auto Registration::on_cap_list(const std::unordered_map<std::string, std::string
if (not request.empty())
{
request.pop_back(); // trailing space
client_->get_connection().send_cap_req(request);
client_->send_cap_req(request);
}
if (do_sasl) {
client_->start_sasl(std::move(settings_.sasl_mechanism));
} else {
client_->get_connection().send_cap_end();
client_->send_cap_end();
}
}
@@ -96,7 +96,7 @@ auto Registration::start(
{
const auto thread = std::make_shared<Registration>(std::move(settings), std::move(client));
thread->slot_ = thread->client_->get_connection().sig_connect.connect([thread]() {
thread->slot_ = thread->client_->get_connection().sig_connect.connect([thread](auto, auto, auto) {
thread->slot_.disconnect();
thread->on_connect();
});
@@ -118,7 +118,7 @@ auto Registration::randomize_nick() -> void
new_nick += x < 10 ? '0' + x : 'A' + (x-10);
}
client_->get_connection().send_nick(new_nick);
client_->send_nick(new_nick);
}
auto Registration::on_ircmsg(const IrcCommand cmd, const IrcMsg &msg) -> void
@@ -140,7 +140,7 @@ auto Registration::on_ircmsg(const IrcCommand cmd, const IrcMsg &msg) -> void
case IrcCommand::RPL_SASLSUCCESS:
case IrcCommand::ERR_SASLFAIL:
client_->get_connection().send_cap_end();
client_->send_cap_end();
break;
}
}

7
myirc/snote.cpp
View File

@@ -167,7 +167,7 @@ static auto setup_database() -> hs_database_t *
expressions.reserve(n);
ids.reserve(n);
for (std::size_t i = 0; i < n; i++)
for (unsigned i = 0; i < n; i++)
{
expressions.push_back(patterns[i].expression);
ids.push_back(i);
@@ -176,7 +176,7 @@ static auto setup_database() -> hs_database_t *
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(), static_cast<unsigned>(expressions.size()), HS_MODE_BLOCK, platform, &db, &error))
{
case HS_COMPILER_ERROR: {
std::string msg = std::to_string(error->expression) + ": " + error->message;
@@ -225,7 +225,8 @@ auto SnoteCore::match(const IrcMsg &msg) -> std::optional<SnoteMatch>
const auto scan_result = hs_scan(
db_.get(),
message.data(), message.size(),
message.data(),
static_cast<unsigned>(message.size()),
0, // no flags
scratch_.get(),
CCallback<decltype(cb)>::invoke, &cb