xbot/main.cpp

#include "bot.hpp"
#include "c_callback.hpp"
#include "challenge.hpp"
#include "client.hpp"
#include "connection.hpp"
#include "openssl_errors.hpp"
#include "registration.hpp"
#include "settings.hpp"
#include "irc_coroutine.hpp"

#include <boost/asio.hpp>
#include <boost/log/trivial.hpp>

#include <openssl/pem.h>

#include <cstdio>
#include <fstream>
#include <iostream>
#include <memory>

using namespace std::literals;

static auto cert_from_file(const std::string &filename) -> X509_Ref
{
    X509_Ref cert;
    if (const auto fp = fopen(filename.c_str(), "r"))
    {
        cert.reset(PEM_read_X509(fp, nullptr, nullptr, nullptr));
        if (cert.get() == nullptr)
        {
            log_openssl_errors("Reading certificate: "sv);
        }
        fclose(fp);
    }
    else
    {
        const auto err = strerror(errno);
        BOOST_LOG_TRIVIAL(error) << "Opening certificate: " << err;
    }
    return cert;
}

static auto key_from_file(const std::string &filename, const std::string_view password) -> EVP_PKEY_Ref
{
    EVP_PKEY_Ref key;
    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; }
            std::copy(password.begin(), password.end(), buf);
            return password.size();
        };

        key.reset(PEM_read_PrivateKey(fp, nullptr, CCallback<decltype(cb)>::invoke, &cb));
        if (key.get() == nullptr)
        {
            log_openssl_errors("Reading private key: "sv);
        }
        fclose(fp);
    }
    else
    {
        const auto err = strerror(errno);
        BOOST_LOG_TRIVIAL(error) << "Opening private key: " << err;
    }
    return key;
}

static auto start(boost::asio::io_context &io, const Settings &settings) -> void
{
    X509_Ref cert;
    if (settings.use_tls && not settings.tls_certfile.empty())
    {
        cert = cert_from_file(settings.tls_certfile);
    }

    EVP_PKEY_Ref key;
    if (settings.use_tls && not settings.tls_keyfile.empty())
    {
        key = key_from_file(settings.tls_keyfile, "");
    }

    const auto connection = std::make_shared<Connection>(io);
    const auto client = Client::start(*connection);
    Registration::start(settings, client);

    const auto bot = Bot::start(client);

/*
    connection->sig_snote.connect([](auto &match) {
        std::cout << "SNOTE " << static_cast<int>(match.get_tag()) << std::endl;
        for (auto c : match.get_results())
        {
            std::cout << "    " << std::string_view{c.first, c.second} << std::endl;
        }
    });
*/
    client->sig_registered.connect([&settings, connection, client]() {
        connection->send_join("##glguy"sv);
        connection->send_whois(client->get_my_nick());

        if (not settings.challenge_username.empty() &&
            not settings.challenge_key_file.empty()) {
            auto key = key_from_file(settings.challenge_key_file, settings.challenge_key_password);
            Challenge::start(*connection, settings.challenge_username, std::move(key));
        }
    });

    client->sig_chat.connect([client, connection](const Chat &chat){
                    if (chat.source.starts_with("glguy!") && client->is_my_nick(chat.target)) {
                        connection->send_notice("glguy", chat.message);
                    }});

    connection->sig_disconnect.connect(
        [&io, &settings, client, bot]() {
            client->shutdown();
            bot->shutdown();

            auto timer = std::make_shared<boost::asio::steady_timer>(io);
            timer->expires_after(5s);
            timer->async_wait([&io, &settings, timer](auto) { start(io, settings); });
        }
    );

    bot->sig_command.connect([connection](const Command &cmd) {
        std::cout << "COMMAND " << cmd.command << " from " << cmd.account << std::endl;
    });

    connection->start({
        .tls = settings.use_tls,
        .host = settings.host,
        .port = settings.service,
        .verify = settings.tls_hostname,
        .client_cert = std::move(cert),
        .client_key = std::move(key),
    });
}

static auto get_settings(const char *filename) -> Settings
{
    if (auto config_stream = std::ifstream{filename})
    {
        return Settings::from_stream(config_stream);
    }
    else
    {
        BOOST_LOG_TRIVIAL(error) << "Unable to open configuration";
        std::exit(1);
    }
}

auto main(int argc, char *argv[]) -> int
{
    if (argc != 2) {
        BOOST_LOG_TRIVIAL(error) << "Bad arguments";
        return 1;
    }
    const auto settings = get_settings(argv[1]);
    auto io = boost::asio::io_context{};
    start(io, settings);
    io.run();
}