http_listener.h

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
#pragma once
 
#include <entropic/entropic_export.h>
 
#include <atomic>
#include <chrono>
#include <filesystem>
#include <memory>
#include <mutex>
#include <string>
#include <thread>
 
namespace entropic {
 
class ExternalBridge;
 
namespace http {
 
ENTROPIC_EXPORT std::string generate_token();
 
ENTROPIC_EXPORT bool tokens_equal(const std::string& a, const std::string& b);
 
ENTROPIC_EXPORT bool host_allowed(const std::string& host, int port);
 
ENTROPIC_EXPORT std::string bearer_token(const std::string& header);
 
ENTROPIC_EXPORT std::filesystem::path token_path_for(int port);
 
ENTROPIC_EXPORT bool prepare_private_dir(const std::filesystem::path& dir, std::string& err);
 
ENTROPIC_EXPORT bool write_token_file(const std::filesystem::path& path,
                      const std::string& token, std::string& err);
 
class ENTROPIC_EXPORT AuthThrottle {
public:
    using Clock = std::chrono::steady_clock;
 
    bool blocked(Clock::time_point now) const;
 
    void record_failure(Clock::time_point now);
 
private:
    mutable std::mutex mu_;
    int failures_ = 0;                 
    Clock::time_point window_start_{}; 
    Clock::time_point blocked_until_{};
};
 
class ENTROPIC_EXPORT HttpListener {
public:
    HttpListener(ExternalBridge* bridge, int port);
 
    ~HttpListener();
 
    HttpListener(const HttpListener&) = delete;
    HttpListener& operator=(const HttpListener&) = delete;
 
    bool start(std::string& err);
 
    void stop();
 
    int port() const { return port_.load(); }
 
    const std::filesystem::path& token_file() const { return token_file_; }
 
    struct Impl;
 
private:
    std::string publish_token(int bound);
 
    std::string await_running();
 
    std::unique_ptr<Impl> impl_;          
    ExternalBridge* bridge_;              
    std::atomic<int> port_{0};            
    std::filesystem::path token_file_;    
    std::thread thread_;                  
};
 
}  // namespace http
}  // namespace entropic