socket.hpp

Go to the documentation of this file.

#ifndef LIBFILEZILLA_SOCKET_HEADER
#define LIBFILEZILLA_SOCKET_HEADER

#include "libfilezilla.hpp"

#include "event_handler.hpp"
#include "iputils.hpp"

#include <memory>

#include <errno.h>

struct sockaddr;

namespace fz {
class buffer;
class thread_pool;

enum class socket_event_flag
{
    connection_next = 0x1,

    connection = 0x2,

    read = 0x4,

    write = 0x8,
};

inline bool operator&(socket_event_flag lhs, socket_event_flag rhs) {
    return (static_cast<std::underlying_type_t<socket_event_flag>>(lhs) & static_cast<std::underlying_type_t<socket_event_flag>>(rhs)) != 0;
}
inline socket_event_flag operator|(socket_event_flag lhs, socket_event_flag rhs)
{
    return static_cast<socket_event_flag>(static_cast<std::underlying_type_t<socket_event_flag>>(lhs) | static_cast<std::underlying_type_t<socket_event_flag>>(rhs));
}
inline socket_event_flag& operator|=(socket_event_flag& lhs, socket_event_flag rhs)
{
    lhs = lhs | rhs;
    return lhs;
}


class FZ_PUBLIC_SYMBOL socket_event_source
{
public:
    virtual ~socket_event_source() = default;

    socket_event_source* root() const {
        return root_;
    }

protected:
    socket_event_source() = delete;
    explicit socket_event_source(socket_event_source* root)
        : root_(root)
    {}

    socket_event_source* const root_{};
};

struct socket_event_type;

typedef simple_event<socket_event_type, socket_event_source*, socket_event_flag, int> socket_event;

struct hostaddress_event_type{};

typedef simple_event<hostaddress_event_type, socket_event_source*, std::string> hostaddress_event;

void FZ_PUBLIC_SYMBOL remove_socket_events(event_handler * handler, socket_event_source const* const source);

fz::socket_event_flag FZ_PUBLIC_SYMBOL change_socket_event_handler(event_handler * old_handler, event_handler * new_handler, socket_event_source const* const source, fz::socket_event_flag remove);

class socket_thread;

class FZ_PUBLIC_SYMBOL socket_base
{
public:
    int set_buffer_sizes(int size_receive, int size_send);

    address_type address_family() const;

    std::string local_ip(bool strip_zone_index = false) const;

    int local_port(int& error) const;

    static std::string address_to_string(sockaddr const* addr, int addr_len, bool with_port = true, bool strip_zone_index = false);
    static std::string address_to_string(char const* buf, int buf_len);

    bool bind(std::string const& address);

#if FZ_WINDOWS
    typedef intptr_t socket_t;
#else
    typedef int socket_t;
#endif

protected:
    friend class socket_thread;

    socket_base(thread_pool& pool, event_handler* evt_handler, socket_event_source* ev_source);
    virtual ~socket_base() = default;

    int close();

    // Note: Unlocks the lock.
    void detach_thread(scoped_lock & l);

    thread_pool & thread_pool_;
    event_handler* evt_handler_;

    socket_thread* socket_thread_{};

    socket_event_source * const ev_source_{};

    socket_t fd_{-1};

    unsigned int port_{};

    int family_;

    int buffer_sizes_[2];
};

class socket;

enum class listen_socket_state
{
    none,

    listening,
};

class FZ_PUBLIC_SYMBOL socket_descriptor final
{
public:
    socket_descriptor() = default;
    ~socket_descriptor();
    explicit socket_descriptor(socket_base::socket_t fd) noexcept : fd_(fd) {}

    socket_descriptor(socket_descriptor const&) = delete;
    socket_descriptor& operator=(socket_descriptor const&) = delete;

    socket_descriptor(socket_descriptor && rhs) noexcept { std::swap(fd_, rhs.fd_); }
    socket_descriptor& operator=(socket_descriptor && rhs) noexcept {
        std::swap(fd_, rhs.fd_);
        return *this;
    }

    socket_base::socket_t detach() {
        socket_base::socket_t ret = fd_;
        fd_ = -1;
        return ret;
    }

    explicit operator bool() const { return fd_ != -1; }

    std::string peer_ip(bool strip_zone_index = false) const;

    int peer_port(int& error) const;

private:
    socket_base::socket_t fd_{-1};
};

class FZ_PUBLIC_SYMBOL listen_socket final : public socket_base, public socket_event_source
{
    friend class socket_base;
    friend class socket_thread;
public:
    listen_socket(thread_pool& pool, event_handler* evt_handler);
    virtual ~listen_socket();

    listen_socket(listen_socket const&) = delete;
    listen_socket& operator=(listen_socket const&) = delete;

    int listen(address_type family, int port = 0);

    std::unique_ptr<socket> accept(int& error, fz::event_handler * handler = nullptr);

    socket_descriptor fast_accept(int& error);

    listen_socket_state get_state() const;

    void set_event_handler(event_handler* pEvtHandler);

private:
    listen_socket_state state_{};
};


enum class socket_state : unsigned char
{
    none,

    connecting,

    connected,

    shutting_down,

    shut_down,

    closed,

    failed
};

class FZ_PUBLIC_SYMBOL socket_interface : public socket_event_source
{
public:
    socket_interface(socket_interface const&) = delete;
    socket_interface& operator=(socket_interface const&) = delete;

    virtual int read(void* buffer, unsigned int size, int& error) = 0;
    virtual int write(void const* buffer, unsigned int size, int& error) = 0;

    template<typename T, std::enable_if_t<std::is_signed_v<T>, int> = 0>
    int read(void* buffer, T size, int& error)
    {
        if (size < 0) {
            error = EINVAL;
            return -1;
        }

        return read(buffer, static_cast<unsigned int>(size), error);
    }
    template<typename T, std::enable_if_t<std::is_unsigned_v<T> && (sizeof(T) > sizeof(unsigned int)), int> = 0>
    int read(void* buffer, T size, int& error)
    {
        if (size > std::numeric_limits<unsigned int>::max()) {
            size = std::numeric_limits<unsigned int>::max();
        }
        return read(buffer, static_cast<unsigned int>(size), error);
    }

    template<typename T, std::enable_if_t<std::is_signed_v<T>, int> = 0>
    int write(void const* buffer, T size, int& error)
    {
        if (size < 0) {
            error = EINVAL;
            return -1;
        }

        return write(buffer, static_cast<std::make_unsigned_t<T>>(size), error);
    }
    template<typename T, std::enable_if_t<std::is_unsigned_v<T> && (sizeof(T) > sizeof(unsigned int)), int> = 0>
    int write(void const* buffer, T size, int& error)
    {
        if (size > std::numeric_limits<unsigned int>::max()) {
            size = std::numeric_limits<unsigned int>::max();
        }
        return write(buffer, static_cast<unsigned int>(size), error);
    }

    virtual void set_event_handler(event_handler* pEvtHandler, fz::socket_event_flag retrigger_block = fz::socket_event_flag{}) = 0;

    virtual native_string peer_host() const = 0;
    virtual int peer_port(int& error) const = 0;

    virtual int connect(native_string const& host, unsigned int port, address_type family = address_type::unknown) = 0;

    virtual fz::socket_state get_state() const = 0;

    virtual int shutdown() = 0;

    virtual int shutdown_read() = 0;

protected:
    socket_interface() = delete;

    explicit socket_interface(socket_event_source * root)
        : socket_event_source(root)
    {}
};

class FZ_PUBLIC_SYMBOL socket final : public socket_base, public socket_interface
{
    friend class socket_thread;
public:
    socket(thread_pool& pool, event_handler* evt_handler);
    virtual ~socket();

    socket(socket const&) = delete;
    socket& operator=(socket const&) = delete;

    static std::unique_ptr<socket> from_descriptor(socket_descriptor && desc, thread_pool & pool, int & error, fz::event_handler * handler = nullptr);

    socket_state get_state() const override;
    bool is_connected() const {
        socket_state s = get_state();
        return s == socket_state::connected || s == socket_state::shutting_down || s == socket_state::shut_down;
    };

    virtual int connect(native_string const& host, unsigned int port, address_type family = address_type::unknown) override;

    virtual int read(void *buffer, unsigned int size, int& error) override;

    virtual int write(void const* buffer, unsigned int size, int& error) override;

    std::string peer_ip(bool strip_zone_index = false) const;

    virtual native_string peer_host() const override;

    virtual int peer_port(int& error) const override;

    int ideal_send_buffer_size();

    virtual int shutdown() override;

    virtual void set_event_handler(event_handler* pEvtHandler, fz::socket_event_flag retrigger_block = fz::socket_event_flag{}) override;

    enum
    {
        flag_nodelay = 0x01,

        flag_keepalive = 0x02
    };

    int flags() const { return flags_; }

    void set_flags(int flags, bool enable);

    void set_flags(int flags);

    void set_keepalive_interval(duration const& d);

    virtual int shutdown_read() override { return 0; }

    socket_t get_descriptor();

#ifndef FZ_WINDOWS

    int send_fd(fz::buffer & buf, int fd, int & error);

    int read_fd(fz::buffer & buf, int &fd, int & error);
#endif

private:
    friend class socket_base;
    friend class listen_socket;
    native_string host_;

    duration keepalive_interval_;

    int flags_{};
    socket_state state_{};
};

class FZ_PUBLIC_SYMBOL socket_layer : public socket_interface
{
public:
    explicit socket_layer(event_handler* handler, socket_interface& next_layer, bool event_passthrough);
    virtual ~socket_layer();

    socket_layer(socket_layer const&) = delete;
    socket_layer& operator=(socket_layer const&) = delete;

    virtual void set_event_handler(event_handler* handler, fz::socket_event_flag retrigger_block = fz::socket_event_flag{}) override;

    virtual native_string peer_host() const override { return next_layer_.peer_host(); }

    virtual int peer_port(int& error) const override { return next_layer_.peer_port(error); }

    socket_interface& next() { return next_layer_; }

    virtual int shutdown_read() override;

    virtual int connect(native_string const& host, unsigned int port, address_type family = address_type::unknown) override {
        return next_layer_.connect(host, port, family);
    }

    virtual int shutdown() override {
        return next_layer_.shutdown();
    }

    virtual socket_state get_state() const override {
        return next_layer_.get_state();
    }

protected:
    void forward_socket_event(socket_event_source* source, socket_event_flag t, int error);

    void forward_hostaddress_event(socket_event_source* source, std::string const& address);

    void set_event_passthrough(socket_event_flag retrigger_block = socket_event_flag{});

    event_handler* event_handler_{};
    socket_interface& next_layer_;
    bool event_passthrough_{};
};

std::string FZ_PUBLIC_SYMBOL socket_error_string(int error);

native_string FZ_PUBLIC_SYMBOL socket_error_description(int error);


#ifdef FZ_WINDOWS

class FZ_PRIVATE_SYMBOL winsock_initializer final
{
public:
    winsock_initializer();
    ~winsock_initializer();

private:
    bool initialized_{};
};

#ifndef EISCONN
#define EISCONN WSAEISCONN
#endif
#ifndef EINPROGRESS
#define EINPROGRESS WSAEINPROGRESS
#endif
#ifndef EAFNOSUPPORT
#define EAFNOSUPPORT WSAEAFNOSUPPORT
#endif
#ifndef EADDRINUSE
#define EADDRINUSE WSAEADDRINUSE
#endif
#ifndef ENOBUFS
#define ENOBUFS WSAENOBUFS
#endif
#ifndef EPROTONOSUPPORT
#define EPROTONOSUPPORT WSAEPROTONOSUPPORT
#endif
#ifndef EALREADY
#define EALREADY WSAEALREADY
#endif
#ifndef ECONNREFUSED
#define ECONNREFUSED WSAECONNREFUSED
#endif
#ifndef ENOTSOCK
#define ENOTSOCK WSAENOTSOCK
#endif
#ifndef ETIMEDOUT
#define ETIMEDOUT WSAETIMEDOUT
#endif
#ifndef ENETUNREACH
#define ENETUNREACH WSAENETUNREACH
#endif
#ifndef EHOSTUNREACH
#define EHOSTUNREACH WSAEHOSTUNREACH
#endif
#ifndef ENOTCONN
#define ENOTCONN WSAENOTCONN
#endif
#ifndef ENETRESET
#define ENETRESET WSAENETRESET
#endif
#ifndef EOPNOTSUPP
#define EOPNOTSUPP WSAEOPNOTSUPP
#endif
#ifndef ESHUTDOWN
#define ESHUTDOWN WSAESHUTDOWN
#endif
#ifndef EMSGSIZE
#define EMSGSIZE WSAEMSGSIZE
#endif
#ifndef ECONNABORTED
#define ECONNABORTED WSAECONNABORTED
#endif
#ifndef ECONNRESET
#define ECONNRESET WSAECONNRESET
#endif
#ifndef EHOSTDOWN
#define EHOSTDOWN WSAEHOSTDOWN
#endif

// For the future:
// Handle ERROR_NETNAME_DELETED=64
#endif //FZ_WINDOWS

}

#endif