jay/connection/connection.cpp

// SPDX-FileCopyrightText: 2024 Yury Gubich <blue@macaw.me>
// SPDX-License-Identifier: GPL-3.0-or-later

#include "connection.h"

Connection::Connection(const std::shared_ptr<Core>& core):
    Shared::Loggable(core->logger, {"Connection"}),
    state(initial),
    core(core),
    gloox(),
    pubsub()
{}

Connection::~Connection() noexcept {
    deinitialize();
}

void Connection::initialize() {
    if (state != initial)
        return;

    gloox = std::make_unique<gloox::Client>(core->config.getFullJID(), core->config.getPassword());
    gloox->registerConnectionListener(this);
    gloox->registerMessageHandler(this);

    ::gloox::LogLevel level = Shared::Logger::convert(core->config.getLogLevel());
    gloox->logInstance().registerLogHandler(level, gloox::LogAreaAll, &core->logger);

    gloox::Disco* disco = gloox->disco();
    disco->setVersion("Jay", "0.0.1");
    disco->setIdentity("client", "bot");

    gloox->setTls(core->config.getTLSPolicy());
    gloox->setSASLMechanisms(gloox::SaslMechAll);
    gloox->setStreamManagement(true, true);

    pubsub = std::make_unique<gloox::PubSub::Manager>(gloox.get());

    state = disconnected;
}

void Connection::deinitialize() {
    if (state == initial)
        return;

    debug("deinitializing");
    gloox->logInstance().removeLogHandler(&core->logger);

    gloox->removeMessageHandler(this);
    gloox->removeConnectionListener(this);
    gloox = nullptr;

    state = initial;
}

void Connection::connect() {
    if (state != disconnected)
        return;

    debug("connecting");
    state = connected;
    gloox->connect(true);
    state = disconnected;
}

void Connection::send(const std::string& jid, const std::string& body) {
    debug("sending message \"" + body + "\" to " + jid);
    gloox->send(gloox::Message(gloox::Message::Chat, jid, body));
}

void Connection::publish(const std::string& service, const std::string& node, const std::string& title, const std::string& body) {
    debug("publishing an article \"" + title + "\" to " + node + "@" + service);

    gloox::Tag* entry = new gloox::Tag("entry");
    entry->setXmlns("http://www.w3.org/2005/Atom");

    entry->addChild(new gloox::Tag("id", "urn:uuid:" + Shared::getUUID()));
    entry->addChild(new gloox::Tag("title", title));
    entry->addChild(new gloox::Tag("summary", body));
    entry->addChild(new gloox::Tag("updated", Shared::getISOTimestamp()));
    entry->addChild(new gloox::Tag("published", Shared::getISOTimestamp()));

    gloox::PubSub::Item* item = new gloox::PubSub::Item();
    item->setPayload(entry);
    gloox::PubSub::ItemList list({item});

    pubsub->publishItem(service, node, list, nullptr, this);
}

std::string Connection::errorTypeToString(gloox::StanzaErrorType err) {
    switch (err) {
        case gloox::StanzaErrorTypeAuth: 
            return "Authentication";
        case gloox::StanzaErrorTypeCancel: 
            return "Cancel";
        case gloox::StanzaErrorTypeContinue: 
            return "Continue";
        case gloox::StanzaErrorTypeModify: 
            return "Modify";
        case gloox::StanzaErrorTypeWait: 
            return "Wait";
        case gloox::StanzaErrorTypeUndefined: 
            return "Undefined";
    }
}

void Connection::handleMessage(const gloox::Message& message, gloox::MessageSession* session) {
    if (message.subtype() != gloox::Message::Chat)
        return;

    std::string body = message.body();
    if (body.empty())
        return;

    std::string jid = message.from().bare();
    debug("received message \"" + body + "\" from " + jid);
    core->router.routeMessage(jid, body);
}

void Connection::handleItemPublication(const std::string& id, const gloox::JID& service, const std::string& node, const gloox::PubSub::ItemList& itemList, const gloox::Error* err) {
    std::string srv(node + "@" + service.full());
    
    if (err) {
        error("Publish failed to " + srv + ", Error: [" + errorTypeToString(err->type()) + "]");
        return;
    }

    info("Publish successful to " + srv + ", ID: " + id);
}

void Connection::onConnect() {
    info("connection established");
}

void Connection::onDisconnect(gloox::ConnectionError e) {
    std::string error;

    switch (e) {
        case gloox::ConnNoError:
            break;
        case gloox::ConnStreamError:   //TODO Use ClientBase::streamError() to find the reason. */
            error = "stream error occured";
            break;
        case gloox::ConnStreamVersionError:
            error = "incoming stream's version is not supported";
            break;
        case gloox::ConnStreamClosed:
            error = "stream has been closed (by the server)";
            break;
        case gloox::ConnProxyAuthRequired:
            error = "HTTP/SOCKS5 proxy requires authentication";
            break;
        case gloox::ConnProxyAuthFailed:
            error = "HTTP/SOCKS5 proxy authentication failed";
            break;
        case gloox::ConnProxyNoSupportedAuth:
            error = "HTTP/SOCKS5 proxy requires an unsupported auth mechanism";
            break;
        case gloox::ConnIoError:
            error = "I/O error occured";
            break;
        case gloox::ConnParseError:
            error = "XML parse error occurred";
            break;
        case gloox::ConnConnectionRefused:
            error = "connection was refused by the server (on the socket level)";
            break;
        case gloox::ConnDnsError:
            error = "resolving the server's hostname failed";
            break;
        case gloox::ConnOutOfMemory:
            error = "connection out of memory";
            break;
        case gloox::ConnNoSupportedAuth:
            error = "auth mechanisms the server offers are not supported";
            break;
        case gloox::ConnTlsFailed:
            error = "server's certificate could not be verified or the TLS";
            break;
        case gloox::ConnTlsNotAvailable:
            error = "server didn't offer TLS while it was set to be required";
            break;
        case gloox::ConnCompressionFailed:
            error = "negotiating/initializing compression failed";
            break;
        case gloox::ConnAuthenticationFailed: //TODO use ClientBase::authError() to find the reason. */
            error = "authentication failed";
            break;

        case gloox::ConnUserDisconnected:
            error = "user (or higher-level protocol) requested a disconnect";
            break;
        case gloox::ConnNotConnected:
            error = "there is no active connection";
    }

    if (error.empty())
        info("disconnected");
    else
        Loggable::error("disconnected: " + error);
}

bool Connection::onTLSConnect(const gloox::CertInfo&) {
    info("TLS established");
    return true;
}