xbot/main.cpp

303 lines
8.0 KiB
C++
Raw Normal View History

2023-11-22 19:59:34 -08:00
#include <boost/asio.hpp>
#include <boost/asio/ssl.hpp>
#include "linebuffer.hpp"
#include "ircmsg.hpp"
#include "settings.hpp"
#include "irc_thread.hpp"
#include "connection.hpp"
#include <algorithm>
#include <chrono>
#include <fstream>
#include <coroutine>
#include <iostream>
#include <limits>
#include <list>
#include <memory>
#include <string>
#include <string_view>
#include <tuple>
#include <utility>
#include <variant>
#include <vector>
#include <unordered_map>
#include <unordered_set>
using namespace std::chrono_literals;
struct ChatThread : public IrcThread
{
auto priority() const -> priority_type override
{
return 100;
}
auto on_msg(ircmsg const& irc) -> std::pair<ThreadOutcome, EventOutcome> override
{
if (irc.command == "PRIVMSG" && 2 == irc.args.size())
{
std::cout << "Chat from " << irc.source << ": " << irc.args[1] << std::endl;
return {ThreadOutcome::Continue, EventOutcome::Pass};
}
else
{
return {ThreadOutcome::Continue, EventOutcome::Pass};
}
}
};
struct UnhandledThread : public IrcThread
{
auto priority() const -> priority_type override
{
return std::numeric_limits<IrcThread::priority_type>::max();
}
auto on_msg(ircmsg const& irc) -> std::pair<ThreadOutcome, EventOutcome> override
{
std::cout << "Unhandled message " << irc.command;
for (auto const arg : irc.args)
{
std::cout << " " << arg;
}
std::cout << "\n";
return {ThreadOutcome::Continue, EventOutcome::Pass};
}
};
class PingThread : public IrcThread
{
Connection * connection_;
public:
PingThread(Connection * connection) noexcept : connection_{connection} {}
auto priority() const -> priority_type override
{
return 0;
}
auto on_msg(ircmsg const& irc) -> std::pair<ThreadOutcome, EventOutcome> override
{
if (irc.command == "PING" && 1 == irc.args.size())
{
connection_->write("PONG", irc.args[0]);
return {ThreadOutcome::Continue, EventOutcome::Consume};
}
else
{
return {};
}
}
};
struct RegistrationThread : IrcThread
{
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;
enum class Stage
{
LsReply,
AckReply,
};
Stage stage_;
RegistrationThread(
Connection * connection_,
std::string password,
std::string username,
std::string realname,
std::string nickname
)
: connection_{connection_}
, password_{password}
, username_{username}
, realname_{realname}
, nickname_{nickname}
, stage_{Stage::LsReply}
{}
auto priority() const -> priority_type override { return 1; }
auto on_connect() -> IrcThread::callback_result override
{
connection_->write("CAP", "LS", "302");
connection_->write("PASS", password_);
connection_->write("USER", username_, "*", "*", realname_);
connection_->write("NICK", nickname_);
return {};
}
auto send_req() -> IrcThread::callback_result
{
std::string request;
char const* want[] = { "extended-join", "account-notify", "draft/chathistory", "batch", "soju.im/no-implicit-names", "chghost", "setname", "account-tag", "solanum.chat/oper", "solanum.chat/identify-msg", "solanum.chat/realhost", "server-time", "invite-notify", "extended-join" };
for (auto cap : want)
{
if (caps.contains(cap))
{
request.append(cap);
request.push_back(' ');
outstanding.insert(cap);
}
}
if (not outstanding.empty())
{
request.pop_back();
connection_->write("CAP", "REQ", request);
stage_ = Stage::AckReply;
return {ThreadOutcome::Continue, EventOutcome::Consume};
}
else
{
connection_->write("CAP", "END");
return {ThreadOutcome::Finish, EventOutcome::Consume};
}
}
auto capack(ircmsg const& msg) -> IrcThread::callback_result
{
auto const n = msg.args.size();
if ("CAP" == msg.command && n >= 2 && "*" == msg.args[0] && "ACK" == msg.args[1])
{
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())
{
connection_->write("CAP","END");
return {ThreadOutcome::Finish, EventOutcome::Consume};
}
else
{
return {ThreadOutcome::Continue, EventOutcome::Consume};
}
}
else
{
return {};
}
}
auto capls(ircmsg const& msg) -> IrcThread::callback_result
{
auto const n = msg.args.size();
if ("CAP" == msg.command && 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)
{
return send_req();
}
return {ThreadOutcome::Continue, EventOutcome::Consume};
}
else
{
return {};
}
}
auto on_msg(ircmsg const& msg) -> IrcThread::callback_result override
{
switch (stage_)
{
case Stage::LsReply: return capls(msg);
case Stage::AckReply: return capack(msg);
default: return {};
}
}
};
auto start(boost::asio::io_context & io, Settings const& settings) -> void
{
auto connection = std::make_shared<Connection>(io);
connection->listen(std::make_unique<PingThread>(connection.get()));
connection->listen(std::make_unique<RegistrationThread>(connection.get(), settings.password, settings.username, settings.realname, settings.nickname));
connection->listen(std::make_unique<ChatThread>());
connection->listen(std::make_unique<UnhandledThread>());
boost::asio::co_spawn(
io,
connection->connect(io, settings),
[&io, &settings](std::exception_ptr e)
{
auto timer = boost::asio::steady_timer{io};
timer.expires_from_now(5s);
timer.async_wait([&io, &settings](auto) {
start(io, settings);
});
});
}
auto get_settings() -> Settings
{
if (auto config_stream = std::ifstream {"config.toml"})
{
return Settings::from_stream(config_stream);
}
else
{
std::cerr << "Unable to open config.toml\n";
std::exit(1);
}
}
auto main() -> int
{
auto const settings = get_settings();
auto io = boost::asio::io_context{};
start(io, settings);
io.run();
}