Socket.hxx

#pragma once
 
// C++
#include <string_view>
#include <string>
 
// cosmos
#include <cosmos/fs/FDFile.hxx>
#include <cosmos/net/SocketOptions.hxx>
#include <cosmos/net/types.hxx>
#include <cosmos/utils.hxx>
 
namespace cosmos {
 
class SocketAddress;
class SendMessageHeader;
class ReceiveMessageHeader;
 
 
class COSMOS_API Socket :
                public FDFile {
 
public: // types
 
        enum class Direction : int {
                READ = SHUT_RD,
                WRITE = SHUT_WR,
                READ_WRITE = SHUT_RDWR
        };
 
        using AddressFilledIn = NamedBool<struct addr_filled_in_t, false>;
 
public: // functions
 
        auto sockOptions() {
                return SocketOptions{m_fd};
        }
 
        auto sockOptions() const {
                return SocketOptions{m_fd};
        }
 
        void getSockName(SocketAddress &addr);
 
 
        void shutdown(const Direction dir);
 
protected: // functions
 
        Socket(
                        const SocketFamily family,
                        const SocketType type,
                        const SocketFlags flags = SocketFlags{SocketFlag::CLOEXEC},
                        const SocketProtocol protocol = SocketProtocol::DEFAULT);
 
        Socket(FileDescriptor fd, const AutoCloseFD auto_close) :
                        FDFile{fd, auto_close}
        {}
 
 
        void bind(const SocketAddress &addr);
 
 
        void connect(const SocketAddress &addr);
 
 
        void listen(const size_t backlog);
 
 
        FileDescriptor accept(SocketAddress *addr);
 
 
        size_t send(const void *buf, size_t length, const MessageFlags flags = MessageFlags{});
 
        size_t send(const std::string_view data, const MessageFlags flags = MessageFlags{}) {
                return send(data.data(), data.size(), flags);
        }
 
 
        size_t sendTo(const void *buf, size_t length, const SocketAddress &addr,
                        const MessageFlags flags = MessageFlags{});
 
        size_t sendTo(const std::string_view data, const SocketAddress &addr,
                        const MessageFlags flags = MessageFlags{}) {
                return sendTo(data.data(), data.size(), addr, flags);
        }
 
 
        void sendMessage(SendMessageHeader &header, const SocketAddress* addr = nullptr);
 
 
        size_t receive(void *buf, size_t length, const MessageFlags flags = MessageFlags{});
 
 
        std::pair<size_t, AddressFilledIn> receiveFrom(
                        void *buf, size_t length, SocketAddress &addr,
                        const MessageFlags flags = MessageFlags{});
 
 
        AddressFilledIn receiveMessage(ReceiveMessageHeader &header, SocketAddress *addr = nullptr);
};
 
} // end ns