sock.h

Go to the documentation of this file.

// Copyright (c) 2020-2021 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_UTIL_SOCK_H
#define BITCOIN_UTIL_SOCK_H
 
#include <compat.h>
#include <threadinterrupt.h>
#include <util/time.h>
 
#include <chrono>
#include <string>
 
static constexpr auto MAX_WAIT_FOR_IO = 1s;
 
class Sock
{
public:
    Sock();
 
    explicit Sock(SOCKET s);
 
    Sock(const Sock&) = delete;
 
    Sock(Sock&& other);
 
    virtual ~Sock();
 
    Sock& operator=(const Sock&) = delete;
 
    virtual Sock& operator=(Sock&& other);
 
    [[nodiscard]] virtual SOCKET Get() const;
 
    virtual SOCKET Release();
 
    virtual void Reset();
 
    [[nodiscard]] virtual ssize_t Send(const void* data, size_t len, int flags) const;
 
    [[nodiscard]] virtual ssize_t Recv(void* buf, size_t len, int flags) const;
 
    [[nodiscard]] virtual int Connect(const sockaddr* addr, socklen_t addr_len) const;
 
    [[nodiscard]] virtual int GetSockOpt(int level,
                                         int opt_name,
                                         void* opt_val,
                                         socklen_t* opt_len) const;
 
    using Event = uint8_t;
 
    static constexpr Event RECV = 0b01;
 
    static constexpr Event SEND = 0b10;
 
    [[nodiscard]] virtual bool Wait(std::chrono::milliseconds timeout,
                                    Event requested,
                                    Event* occurred = nullptr) const;
 
    /* Higher level, convenience, methods. These may throw. */
 
    virtual void SendComplete(const std::string& data,
                              std::chrono::milliseconds timeout,
                              CThreadInterrupt& interrupt) const;
 
    [[nodiscard]] virtual std::string RecvUntilTerminator(uint8_t terminator,
                                                          std::chrono::milliseconds timeout,
                                                          CThreadInterrupt& interrupt,
                                                          size_t max_data) const;
 
    [[nodiscard]] virtual bool IsConnected(std::string& errmsg) const;
 
protected:
    SOCKET m_socket;
};
 
std::string NetworkErrorString(int err);
 
bool CloseSocket(SOCKET& hSocket);
 
#endif // BITCOIN_UTIL_SOCK_H