i2p.h

Go to the documentation of this file.

// Copyright (c) 2020-2022 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_I2P_H
#define BITCOIN_I2P_H
 
#include <compat/compat.h>
#include <netaddress.h>
#include <netbase.h>
#include <sync.h>
#include <util/fs.h>
#include <util/sock.h>
#include <util/threadinterrupt.h>
 
#include <memory>
#include <optional>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace i2p {
 
using Binary = std::vector<uint8_t>;
 
struct Connection {
    std::unique_ptr<Sock> sock;
 
    CService me;
 
    CService peer;
};
 
namespace sam {
 
static constexpr size_t MAX_MSG_SIZE{65536};
 
class Session
{
public:
    Session(const fs::path& private_key_file,
            const Proxy& control_host,
            std::shared_ptr<CThreadInterrupt> interrupt);
 
    Session(const Proxy& control_host, std::shared_ptr<CThreadInterrupt> interrupt);
 
    ~Session();
 
    bool Listen(Connection& conn) EXCLUSIVE_LOCKS_REQUIRED(!m_mutex);
 
    bool Accept(Connection& conn) EXCLUSIVE_LOCKS_REQUIRED(!m_mutex);
 
    bool Connect(const CService& to, Connection& conn, bool& proxy_error) EXCLUSIVE_LOCKS_REQUIRED(!m_mutex);
 
private:
    struct Reply {
        std::string full;
 
        std::string request;
 
        std::unordered_map<std::string, std::optional<std::string>> keys;
 
        std::string Get(const std::string& key) const;
    };
 
    Reply SendRequestAndGetReply(const Sock& sock,
                                 const std::string& request,
                                 bool check_result_ok = true) const;
 
    std::unique_ptr<Sock> Hello() const EXCLUSIVE_LOCKS_REQUIRED(m_mutex);
 
    void CheckControlSock() EXCLUSIVE_LOCKS_REQUIRED(!m_mutex);
 
    void DestGenerate(const Sock& sock) EXCLUSIVE_LOCKS_REQUIRED(m_mutex);
 
    void GenerateAndSavePrivateKey(const Sock& sock) EXCLUSIVE_LOCKS_REQUIRED(m_mutex);
 
    Binary MyDestination() const EXCLUSIVE_LOCKS_REQUIRED(m_mutex);
 
    void CreateIfNotCreatedAlready() EXCLUSIVE_LOCKS_REQUIRED(m_mutex);
 
    std::unique_ptr<Sock> StreamAccept() EXCLUSIVE_LOCKS_REQUIRED(m_mutex);
 
    void Disconnect() EXCLUSIVE_LOCKS_REQUIRED(m_mutex);
 
    const fs::path m_private_key_file;
 
    const Proxy m_control_host;
 
    const std::shared_ptr<CThreadInterrupt> m_interrupt;
 
    mutable Mutex m_mutex;
 
    Binary m_private_key GUARDED_BY(m_mutex);
 
    std::unique_ptr<Sock> m_control_sock GUARDED_BY(m_mutex);
 
    CService m_my_addr GUARDED_BY(m_mutex);
 
    std::string m_session_id GUARDED_BY(m_mutex);
 
    const bool m_transient;
};
 
} // namespace sam
} // namespace i2p
 
#endif // BITCOIN_I2P_H