TorControl.hpp

Go to the documentation of this file.

/*
 *
 * ---
 *
 *  Copyright (C) 2020 Anselm Schmidt (ans[ät]ohai.su)
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version in addition to the terms of any
 *  licences already herein identified.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * ---
 *
 * TorControl.hpp
 *
 * Connecting to the TOR control server/port to request a new identity.
 *
 *  Created on: Nov 13, 2019
 *      Author: ans
 */

#ifndef NETWORK_TORCONTROL_HPP_
#define NETWORK_TORCONTROL_HPP_

#include "Config.hpp"

#include "../Main/Exception.hpp"
#include "../Timer/Simple.hpp"

#include "asio.hpp"

#include <array>        // std::array
#include <cstdint>      // std::uint16_t, std::uint64_t
#include <iostream>     // std::cerr, std::endl
#include <string>       // std::string, std::to_string
#include <string_view>  // std::string_view

namespace crawlservpp::Network {

    /*
     * CONSTANTS
     */


    inline constexpr auto responseCodeLength{3};

    inline constexpr auto millisecondsPerSecond{1000};


    /*
     * DECLARATION
     */


    class TorControl {
    public:

        TorControl(
                std::string_view controlServer,
                std::uint16_t controlPort,
                std::string_view controlPassword
        );
        virtual ~TorControl();


        [[nodiscard]] bool active() const noexcept;


        void setNewIdentityMin(std::uint64_t seconds);
        void setNewIdentityMax(std::uint64_t seconds);


        bool newIdentity();


        void tick();



        MAIN_EXCEPTION_CLASS();


        TorControl(TorControl&) = delete;

        TorControl& operator=(TorControl&) = delete;

        TorControl(TorControl&&) = delete;

        TorControl& operator=(TorControl&&) = delete;


    private:
        // settings
        const bool isActive{false};
        const std::string server;
        const std::uint16_t port{};
        const std::string password;
        std::uint64_t newIdentityNotBefore{};
        std::uint64_t newIdentityAfter{};

        // asio context and socket
        asio::io_context context;
        asio::ip::tcp::socket socket;

        // identity time and timers
        Timer::Simple minTimer;
        Timer::Simple maxTimer;
        std::uint64_t elapsedMin{};
        std::uint64_t elapsedMax{};
    };

    /*
     * IMPLEMENTATION
     */


    inline TorControl::TorControl(
            std::string_view controlServer,
            std::uint16_t controlPort,
            std::string_view controlPassword
    )       :   isActive(!controlServer.empty()),
                server(controlServer),
                port(controlPort),
                password(controlPassword),
                socket(this->context) {}


    inline TorControl::~TorControl() {
        if(this->socket.is_open()) {
            asio::error_code error;

            this->socket.shutdown(asio::ip::tcp::socket::shutdown_both, error);

            if(error) {
                std::cerr   << "TorControl::~TorControl(): "
                            << error.message()
                            << std::endl;
            }
        }
    }


    inline bool TorControl::active() const noexcept {
        return this->isActive;
    }


    inline void TorControl::setNewIdentityMin(std::uint64_t seconds) {
        this->newIdentityNotBefore = seconds;

        // reset timer
        this->elapsedMin = 0;

        this->minTimer.tick();
    }


    inline void TorControl::setNewIdentityMax(std::uint64_t seconds) {
        this->newIdentityAfter = seconds;

        // reset timer
        this->elapsedMax = 0;

        this->maxTimer.tick();
    }


    inline bool TorControl::newIdentity() {
        // check whether a TOR control server/port has been set
        if(!(this->isActive)) {
            throw Exception("No TOR control server/port set");
        }

        // check whether a sufficient amount of time has passed since the last request
        if(this->newIdentityNotBefore > 0) {
            this->elapsedMin += this->minTimer.tick();

            if(this->elapsedMin / millisecondsPerSecond < this->newIdentityNotBefore) {
                return false;
            }

            this->elapsedMin = 0;
        }

        // create asio resolver
        asio::ip::tcp::resolver resolver(this->context);

        try {
            // resolve the address of the control server
            asio::ip::tcp::resolver::results_type endpoints{
                resolver.resolve(
                        this->server,
                        std::to_string(this->port),
                        asio::ip::tcp::resolver::numeric_service
                )
            };

            // connect to control server
            asio::connect(this->socket, endpoints);

            // send authentification
            const std::string auth("AUTHENTICATE \"" + this->password + "\"\n");

            asio::write(this->socket, asio::buffer(auth.data(), auth.size()));

            // read response code (response should be "250 OK" or "515 Bad authentication")
            std::array<char, responseCodeLength> response{};

            this->socket.read_some(asio::mutable_buffer(response.data(), responseCodeLength));

            // check response code
            if(response[0] != '2' || response[1] != '5' || response[2] != '0') {
                throw Exception("Authentification failed");
            }

            // send command to request a new identity
            const std::string command("SIGNAL NEWNYM\r\n");

            asio::write(this->socket, asio::buffer(command.data(), command.size()));

            // reset timer if necessary
            if(this->newIdentityAfter > 0) {
                this->elapsedMax = 0;

                this->maxTimer.tick();
            }
        }
        catch(const asio::system_error& e) {
            throw Exception(e.what());
        }

        return true;
    }


    inline void TorControl::tick() {
        // check whether timer is enabled
        if(this->isActive && this->newIdentityAfter > 0) {
            // get elapsed time (in ms)
            this->elapsedMin += this->minTimer.tick();
            this->elapsedMax += this->maxTimer.tick();

            // check elapsed time (in s)
            if(this->elapsedMax / millisecondsPerSecond > this->newIdentityAfter) {
                // request new identity
                this->newIdentity();

                // reset timer
                this->elapsedMax = 0;

                this->maxTimer.tick();
            }
        }
    }

} /* namespace crawlservpp::Network */

#endif /* NETWORK_TORCONTROL_HPP_ */