dht_discovery.h

Go to the documentation of this file.

#pragma once
 
#include "node/peer_network.h"
#include "subsystems/dht_service.h"
#include "dht/dht.h"
 
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <cstdint>
#include <memory>
#include <mutex>
#include <string>
#include <thread>
#include <unordered_set>
#include <vector>
 
namespace librats {
 
class DhtDiscovery final : public Subsystem, public DhtService {
public:
    struct Config {
        uint16_t                  dht_port = 0;          
        std::string               bind_address = "";
        std::string               data_dir = "";         
        bool                      enable_ipv4 = true;    
        bool                      enable_ipv6 = true;    
        std::string               discovery_key = "librats";  
        std::vector<Address>         bootstrap_nodes;       
        std::chrono::milliseconds search_interval{5000};
        std::chrono::milliseconds announce_interval{30000};
 
        bool                      discover_external_ip = true;
        std::vector<Address>      stun_servers;          
        std::chrono::milliseconds stun_timeout{3000};
    };
 
    explicit DhtDiscovery(Config config);
    ~DhtDiscovery() override;
 
    void attach(NodeContext& ctx) override;
    void start() override;
    void stop() override;
 
    bool     is_running() const;
 
    DhtClient* dht_client() override { return dht_ ? dht_.get() : dht6_.get(); }
 
    uint16_t dht_port() const;       
    uint16_t dht_port_v6() const;    
    InfoHash discovery_hash() const { return hash_; }
 
    std::string external_address() const;
 
    static InfoHash hash_for_key(const std::string& key);
 
private:
    void loop();
    void probe_external_ip();  
    void on_peers(const std::vector<Address>& peers, const InfoHash& info_hash);
 
    std::unique_ptr<DhtClient> make_client(AddressFamily family);
 
    template <typename Fn>
    void for_each_client(Fn fn) {
        if (dht_)  fn(*dht_);
        if (dht6_) fn(*dht6_);
    }
 
    Config                     config_;
    InfoHash                   hash_;
    PeerNetwork*               network_ = nullptr;
    std::unique_ptr<DhtClient> dht_;    
    std::unique_ptr<DhtClient> dht6_;   
 
    std::thread             thread_;
    std::atomic<bool>       running_{false};
    std::atomic<bool>       recover_pending_{false};  
    std::mutex              wait_mutex_;
    std::condition_variable wake_;
 
    std::mutex                      dialed_mutex_;
    std::unordered_set<std::string> dialed_;  
};
 
} // namespace librats