BaseSocket.h

/*
╔══════════════════════════════════════════════════════════════════════════════╗
║                       SIMPLY POWERFUL TOOLKIT (SPTK)                         ║
╟──────────────────────────────────────────────────────────────────────────────╢
║  copyright            © 1999-2022 Alexey Parshin. All rights reserved.       ║
║  email                alexeyp@gmail.com                                      ║
╚══════════════════════════════════════════════════════════════════════════════╝
┌──────────────────────────────────────────────────────────────────────────────┐
│   This library is free software; you can redistribute it and/or modify it    │
│   under the terms of the GNU Library General Public License as published by  │
│   the Free Software Foundation; either version 2 of the License, or (at your │
│   option) any later version.                                                 │
│                                                                              │
│   This library is distributed in the hope that it will be useful, but        │
│   WITHOUT ANY WARRANTY; without even the implied warranty of                 │
│   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library   │
│   General Public License for more details.                                   │
│                                                                              │
│   You should have received a copy of the GNU Library General Public License  │
│   along with this library; if not, write to the Free Software Foundation,    │
│   Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.               │
│                                                                              │
│   Please report all bugs and problems to alexeyp@gmail.com.                  │
└──────────────────────────────────────────────────────────────────────────────┘
*/
 
#pragma once
 
#include <chrono>
#include <sptk5/Buffer.h>
#include <sptk5/DateTime.h>
#include <sptk5/Exception.h>
#include <sptk5/Strings.h>
#include <sptk5/net/Host.h>
 
#ifndef _WIN32
 
#include <arpa/inet.h>
#include <fcntl.h>
#include <netdb.h>
#include <netinet/in.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/un.h>
#include <unistd.h>
 
using SOCKET = int;
using SOCKET_ADDRESS_FAMILY = sa_family_t;
 
#ifdef __APPLE__
using socklen_t = int;
#endif
 
#define INVALID_SOCKET (-1)
 
#else
#include <winsock2.h>
#include <ws2tcpip.h>
 
#include <windows.h>
using socklen_t = int;
using SOCKET_ADDRESS_FAMILY = unsigned short;
#endif
 
namespace sptk {
 
class SP_EXPORT BaseSocket
{
public:
    enum class OpenMode : uint8_t
    {
        CREATE,  
        CONNECT, 
        BIND     
    };
 
    SOCKET fd() const
    {
        return m_sockfd;
    }
 
    void open_addr(OpenMode openMode = OpenMode::CREATE, const sockaddr_in* addr = nullptr,
                   std::chrono::milliseconds timeout = std::chrono::milliseconds(0));
 
    explicit BaseSocket(SOCKET_ADDRESS_FAMILY domain = AF_INET, int32_t type = SOCK_STREAM, int32_t protocol = 0);
 
    BaseSocket(const BaseSocket& other) = delete;
 
    BaseSocket(BaseSocket&& other) noexcept = default;
 
    virtual ~BaseSocket();
 
    BaseSocket& operator=(const BaseSocket& other) = delete;
 
    BaseSocket& operator=(BaseSocket&& other) noexcept = default;
 
    void blockingMode(bool blocking);
 
    [[nodiscard]] virtual size_t socketBytes();
 
    virtual void attach(SOCKET socketHandle, bool accept);
 
    virtual SOCKET detach();
 
    void host(const Host& host);
 
    [[nodiscard]] const Host& host() const
    {
        return m_host;
    }
 
    void open(const Host& host = Host(), OpenMode openMode = OpenMode::CONNECT, bool blockingMode = true,
              std::chrono::milliseconds timeoutMS = std::chrono::milliseconds(0))
    {
        _open(host, openMode, blockingMode, timeoutMS);
    }
 
    void open(const struct sockaddr_in& address, OpenMode openMode = OpenMode::CONNECT,
              bool blockingMode = true, std::chrono::milliseconds timeoutMS = std::chrono::milliseconds(0))
    {
        _open(address, openMode, blockingMode, timeoutMS);
    }
 
    void bind(const char* address, uint32_t portNumber);
 
    void listen(uint16_t portNumber = 0);
 
    virtual void close() noexcept;
 
    [[nodiscard]] bool active() const
    {
        return m_sockfd != INVALID_SOCKET;
    }
 
    int32_t control(int flag, const uint32_t* check) const;
 
    void setOption(int level, int option, int value) const;
 
    void getOption(int level, int option, int& value) const;
 
    [[nodiscard]] virtual size_t recv(uint8_t* buffer, size_t len);
 
    [[nodiscard]] virtual size_t send(const uint8_t* buffer, size_t len);
 
    [[nodiscard]] virtual size_t read(uint8_t* buffer, size_t size, sockaddr_in* from);
 
    [[nodiscard]] virtual size_t read(uint8_t* buffer, size_t size)
    {
        return read(buffer, size, nullptr);
    }
 
    [[nodiscard]] virtual size_t read(Buffer& buffer, size_t size, sockaddr_in* from);
 
    [[nodiscard]] size_t read(Buffer& buffer, size_t size)
    {
        return read(buffer, size, nullptr);
    }
 
    [[nodiscard]] virtual size_t read(String& buffer, size_t size, sockaddr_in* from);
 
    [[nodiscard]] size_t read(String& buffer, size_t size)
    {
        return read(buffer, size, nullptr);
    }
 
    virtual size_t write(const uint8_t* buffer, size_t size, const sockaddr_in* peer);
 
    size_t write(const uint8_t* buffer, size_t size)
    {
        return write(buffer, size, nullptr);
    }
 
    virtual size_t write(const Buffer& buffer, const sockaddr_in* peer);
 
    size_t write(const Buffer& buffer)
    {
        return write(buffer, nullptr);
    }
 
    virtual size_t write(const String& buffer, const sockaddr_in* peer);
 
    size_t write(const String& buffer)
    {
        return write(buffer, nullptr);
    }
 
    [[nodiscard]] virtual bool readyToRead(std::chrono::milliseconds timeout);
 
    [[nodiscard]] virtual bool readyToWrite(std::chrono::milliseconds timeout);
 
    [[nodiscard]] bool blockingMode() const
    {
        return m_blockingMode;
    }
 
protected:
    void setSocketFD(SOCKET socket)
    {
        m_sockfd = socket;
    }
 
    [[nodiscard]] int32_t domain() const
    {
        return m_domain;
    }
 
    [[nodiscard]] int32_t type() const
    {
        return m_type;
    }
 
    [[nodiscard]] int32_t protocol() const
    {
        return m_protocol;
    }
 
#ifdef _WIN32
    static void init() noexcept;
 
    static void cleanup() noexcept;
#endif
 
    virtual void _open(const Host& host, OpenMode openMode, bool blockingMode, std::chrono::milliseconds timeoutMS);
 
    virtual void _open(const struct sockaddr_in& address, OpenMode openMode, bool blockingMode,
                       std::chrono::milliseconds timeoutMS)
    {
        // Implement in derived class
    }
 
private:
    SOCKET m_sockfd {INVALID_SOCKET}; 
    int32_t m_domain;                 
    int32_t m_type;                   
    int32_t m_protocol;               
    Host m_host;                      
    bool m_blockingMode {false};      
};
 
SP_EXPORT void throwSocketError(const String& message, const char* file, int line);
 
#define THROW_SOCKET_ERROR(msg) sptk::throwSocketError(msg, __FILE__, __LINE__)
 
} // namespace sptk