torcontrol.h

Go to the documentation of this file.

// Copyright (c) 2015-present The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
#ifndef BITCOIN_TORCONTROL_H
#define BITCOIN_TORCONTROL_H
 
#include <netaddress.h>
#include <util/fs.h>
#include <util/sock.h>
#include <util/threadinterrupt.h>
 
#include <cstdint>
#include <deque>
#include <functional>
#include <memory>
#include <string>
#include <thread>
#include <vector>
 
constexpr uint16_t DEFAULT_TOR_SOCKS_PORT{9050};
constexpr int DEFAULT_TOR_CONTROL_PORT = 9051;
extern const std::string DEFAULT_TOR_CONTROL;
static const bool DEFAULT_LISTEN_ONION = true;
 
constexpr int TOR_REPLY_OK{250};
constexpr int TOR_REPLY_UNRECOGNIZED{510};
constexpr int TOR_REPLY_SYNTAX_ERROR{512}; 
 
CService DefaultOnionServiceTarget(uint16_t port);
 
class TorControlReply
{
public:
    TorControlReply() { Clear(); }
 
    int code;
    std::vector<std::string> lines;
 
    void Clear()
    {
        code = 0;
        lines.clear();
    }
};
 
class TorControlConnection
{
public:
    typedef std::function<void(TorControlConnection &,const TorControlReply &)> ReplyHandlerCB;
 
    explicit TorControlConnection(CThreadInterrupt& interrupt);
    ~TorControlConnection();
 
    bool Connect(const std::string& tor_control_center);
 
    void Disconnect();
 
    bool Command(const std::string &cmd, const ReplyHandlerCB& reply_handler);
 
    bool IsConnected() const;
 
    bool WaitForData(std::chrono::milliseconds timeout);
 
    bool ReceiveAndProcess();
 
private:
    CThreadInterrupt& m_interrupt;
    std::unique_ptr<Sock> m_sock;
    TorControlReply m_message;
    std::deque<ReplyHandlerCB> m_reply_handlers;
    std::vector<std::byte> m_recv_buffer;
    bool ProcessBuffer();
};
 
/****** Bitcoin specific TorController implementation ********/
 
class TorController
{
public:
    TorController(const std::string& tor_control_center, const CService& target);
    TorController() : m_conn(m_interrupt) {
        // Used for testing only.
    }
    ~TorController();
 
    fs::path GetPrivateKeyFile();
 
    void Interrupt();
 
    void Join();
private:
    CThreadInterrupt m_interrupt;
    std::thread m_thread;
    const std::string m_tor_control_center;
    TorControlConnection m_conn;
    std::string m_private_key;
    std::string m_service_id;
    std::atomic<bool> m_reconnect;
    std::chrono::duration<double> m_reconnect_timeout;
    CService m_service;
    const CService m_target;
    std::vector<uint8_t> m_cookie;
    std::vector<uint8_t> m_client_nonce;
    void ThreadControl();
 
public:
    void get_socks_cb(TorControlConnection& conn, const TorControlReply& reply);
    void add_onion_cb(TorControlConnection& conn, const TorControlReply& reply, bool pow_was_enabled);
    void auth_cb(TorControlConnection& conn, const TorControlReply& reply);
    void authchallenge_cb(TorControlConnection& conn, const TorControlReply& reply);
    void protocolinfo_cb(TorControlConnection& conn, const TorControlReply& reply);
    void connected_cb(TorControlConnection& conn);
    void disconnected_cb(TorControlConnection& conn);
};
 
#endif // BITCOIN_TORCONTROL_H