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