socket.hpp

#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 thread_pool;

enum class socket_event_flag
{
    // This is a nonfatal condition. It
    // means there are additional addresses to try.
    connection_next,

    connection,
    read,
    write
};

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

    socket_event_source* root() const {
        return root_;
    }

protected:
    socket_event_source() = default;
    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);

void FZ_PUBLIC_SYMBOL change_socket_event_handler(event_handler * old_handler, event_handler * new_handler, socket_event_source const* const source);

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();

    void do_set_event_handler(event_handler* pEvtHandler);

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

    thread_pool & thread_pool_;
    event_handler* evt_handler_;

    socket_t fd_{-1};

    socket_thread* socket_thread_{};

    unsigned int port_{};

    int family_;

    int buffer_sizes_[2];

    socket_event_source * const ev_source_{};
};

class socket;

enum class listen_socket_state
{
    none,

    listening,
};

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);

    listen_socket_state get_state() const;

    void set_event_handler(event_handler* pEvtHandler) {
        do_set_event_handler(pEvtHandler);
    }

private:
    listen_socket_state state_{};
};


enum class socket_state
{
    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;

    virtual void set_event_handler(event_handler* pEvtHandler) = 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;

protected:
    socket_interface() = default;
    
    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;

    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();

    void retrigger(socket_event_flag event);

    virtual int shutdown() override;

    virtual void set_event_handler(event_handler* pEvtHandler) override;

    enum
    {
        flag_nodelay = 0x01,

        flag_keepalive = 0x02
    };

    int flags() const { return flags_; }
    void set_flags(int flags);

    void set_keepalive_interval(duration const& d);

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

    socket_state state_{};

    int flags_{};
    duration keepalive_interval_;
};

#ifdef FZ_WINDOWS

#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