sparkle/libs/tls/Network.hpp

#ifndef TLS_NETWORK_HPP_
#define TLS_NETWORK_HPP_
#include <openssl/ssl.h>
#include <openssl/err.h>
#include <memory>
#include <iostream>
#include <string>
#include <net/if.h>
#include <netdb.h>
#include <utils/types.hpp>
#include <gateway/Websocket.hpp>
#include <utils/logs.hpp>
using std::cout;
using std::cerr;
using std::endl;
class NetworkManager {
private:
    WebSocket& web;
    SSL_CTX* ctx;
    int sock = -1;
    std::unique_ptr<SSL, decltype(&SSL_free)> ssl = { nullptr, &SSL_free };
    void handleSSLInitErrors() {
        ERR_print_errors_fp(stderr);
        abort();
    }
    void createSSLConnection(const std::string& hostname, const std::string& port) {
        Logs::create(INFO, NETWORK, "SSL connection");
        addrinfo hints = { 0 }, *res = { 0 };
        hints.ai_socktype = SOCK_STREAM;
        if (getaddrinfo(hostname.c_str(), port.c_str(), &hints, &res) != 0) {
            Logs::create(ERROR, NETWORK, "Failed to get address info for " + hostname + ":" + port);
            handleSSLInitErrors();
        }
        sock = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
        if (sock == -1) {
            Logs::create(ERROR, NETWORK, "Socket error");
            close(sock);
            handleSSLInitErrors();
        }
        if (connect(sock, res->ai_addr, res->ai_addrlen) == -1) {
            Logs::create(ERROR, NETWORK, "Failed to connect to " + hostname + ":" + port);
            close(sock);
            handleSSLInitErrors();
        }
        ssl.reset(SSL_new(ctx));
        if (!ssl) {
            Logs::create(ERROR, NETWORK, "Failed to create SSL structure");
            close(sock);
            handleSSLInitErrors();
        }
        SSL_set_fd(ssl.get(), sock);
        if (SSL_connect(ssl.get()) != 1) {
            Logs::create(ERROR, NETWORK, "SSL connection failed");
            close(sock);
            handleSSLInitErrors();
        }
        freeaddrinfo(res);
    }
    NetworkManager& operator=(const NetworkManager&) = delete;
    NetworkManager(const NetworkManager&) = delete;
    NetworkManager() : web(WebSocket::getInstance()) {
        Logs::create(INFO, NETWORK, "Network init");
        if (!ctx) {
            ctx = SSL_CTX_new(TLS_client_method());
            if (!ctx) {
                Logs::create(ERROR, NETWORK, "Failed to create SSL context");
                handleSSLInitErrors();
            }
            OPENSSL_init_ssl(0, 0);
            OPENSSL_add_all_algorithms_noconf();
            SSL_CTX_set_min_proto_version(ctx, TLS1_2_VERSION);
            SSL_CTX_set_max_proto_version(ctx, TLS1_3_VERSION);
            createSSLConnection("discord.com", "443");
        }
    }
    std::string parseJson(const std::string& response) {
        unsigned long jsonStart = response.find("\r\n\r\n");
        if (jsonStart == std::string::npos) {
            return "";
        }
        jsonStart += 4;
        std::string jsonString = response.substr(jsonStart);
        unsigned long jsonBegin = jsonString.find('['), jsonEnd = jsonString.rfind(']');
        if (jsonBegin == std::string::npos || jsonEnd == std::string::npos || jsonEnd < jsonBegin) {
            return "";
        }
        jsonString = jsonString.substr(jsonBegin, jsonEnd - jsonBegin + 1);
        jsonString.erase(std::remove(jsonString.begin(), jsonString.end(), '\r'), jsonString.end());
        jsonString.erase(std::remove(jsonString.begin(), jsonString.end(), '\t'), jsonString.end());
        jsonString.erase(std::remove(jsonString.begin(), jsonString.end(), '\n'), jsonString.end());
        jsonString.erase(std::remove(jsonString.begin(), jsonString.end(), '\\'), jsonString.end());
        jsonString.erase(std::remove(jsonString.begin(), jsonString.end(), '\''), jsonString.end());
        jsonString.erase(std::remove(jsonString.begin(), jsonString.end(), ' '), jsonString.end());
        try {
            nlohmann::json jsonData = nlohmann::json::parse(jsonString);
            return jsonData.dump();
        }
        catch (const nlohmann::json::parse_error& e) {
            return "";
        }
    }
public:
    static NetworkManager& getInstance() {
        Logs::create(WARNING, NETWORK, "Instance event");
        static NetworkManager instance;
        return instance;
    }
    ~NetworkManager() {
        if (ctx) SSL_CTX_free(ctx);
        close(sock);
    }
    std::string request(const std::string& method, const std::string& path, const std::string& data = "") {
    #ifdef DEBUG
        createSSLConnection("discord.com", "443");
    #endif
        auto net = [this, method, path, data, result = std::string("")]() mutable -> std::string {
            std::string request = method + " " + path + " HTTP/1.1\r\nHost: discord.com\r\nAccept: application/json\r\nContent-Type: application/json\r\n";
            request += "Authorization: " + web.getToken() + "\r\nContent-Length: " + std::to_string(data.length()) + "\r\n";
        #ifdef DEBUG
            request += "Connection: close\r\n\r\n";
        #elif defined(RELEASE)
            request += "Connection: keep-alive\r\n\r\n";
        #endif
            request += data;
            if (SSL_write(ssl.get(), request.c_str(), request.length()) <= 0) {
                std::cerr << "Failed to send request" << std::endl;
                handleSSLInitErrors();
            }
            Logs::create(INFO, NETWORK, "Request " + method + " " + path);
        #ifdef DEBUG
            std::vector<char> buffer(1024);
            int bytesRead;
            while ((bytesRead = SSL_read(ssl.get(), buffer.data(), buffer.size())) > 0) {
                result.append(buffer.data(), bytesRead);
                if (bytesRead == buffer.size()) {
                    buffer.resize(buffer.size() * 2);
                }
            }
            return parseJson(result);
        #elif defined(RELEASE)
            return result;
        #endif
        };
        return net();
    }
};
#endif