socket.hpp

#ifndef LIBFORB_SOCKET_HPP
#define LIBFORB_SOCKET_HPP

#include <string>
#include <unistd.h> // close
#include <cstring>  // memset
#include <arpa/inet.h>
#include <sys/socket.h>

#include <cassert>
#include <forb/stream/stream.hpp>

namespace forb {
    namespace streams {

        // Returns true if the machine is big endian
        // (same byte order of network endianess).
        inline bool is_big_endian() {
            union {
                uint32_t i;
                char     c[4];
            } bint = {0x01020304};

            return bint.c[0] == 1;
        }

        class socket : public virtual stream {
            /* *********************************** ALIASES AND STATIC ATTRIBUTES ************************************ */
        private:
            using sockaddr_in_t = struct sockaddr_in;
            using sockaddr_t = struct sockaddr;

            struct socket_create_t {
            };

            // Constants used within the class
            static constexpr int       AF_TYPE       = AF_INET;
            static constexpr int       PROTOCOL      = SOCK_STREAM;
            static constexpr socklen_t SOCKADDR_SIZE = sizeof(sockaddr_in_t);

            /* ********************************************* ATTRIBUTES ********************************************* */
        private:
            int _sock_fd = 0;

            std::string _local_address = "";

            int _local_port = 0;

            std::string _remote_address = "";

            int _remote_port = 0;

            bool _is_server = false;

            /* ******************************************** CONSTRUCTORS ******************************************** */
        private:
            socket(socket_create_t);

            socket(int sock_fd, const std::string &remote_address, int remote_port);

            socket(const std::string &remote_address, int remote_port);

        public:
            socket() = default;

            /**********************************************************************************************************/

            ~socket() override {
                close();
            };

            socket(const socket &other) = delete;

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

            socket(socket &&other) noexcept;

            socket &operator=(socket &&other) noexcept;

            /**********************************************************************************************************/

            // Following static methods are implicitly inline

            static socket make_server(int port, int listen_queue_size = 10) {
                return make_server("", port, listen_queue_size);
            }

            static socket make_server(const std::string &address, int port, int listen_queue_size = 10) {
                socket new_socket = socket_create_t();
                new_socket.bind(address, port);
                new_socket.listen(listen_queue_size);
                return new_socket;
            }

            static socket make_client(const std::string &address, int port) {
                socket new_socket = socket_create_t();
                new_socket.connect(address, port);
                return new_socket;
            }

            /**********************************************************************************************************/
        private:
            static inline sockaddr_in_t build_sockaddr(const std::string &address, int port);

            void _move_attributes(socket &other) noexcept;

            /*
            void bind(int port) {
                return bind("", port);
            };
             */

            void bind(const std::string &address, int port);

            void listen(int listen_queue_size);

            void connect(const std::string &address, int port);

        public:
            socket accept();

            void send(const void *buffer, std::size_t size) override;

            void recv(void *buffer, std::size_t size) override;

            void close() noexcept override;

            type get_type() const override {
                return type::SOCKET;
            };

            bool require_marshal() const override {
                return !is_big_endian();
            };
        };

    } // namespace streams

} // namespace forb

#endif // #ifndef LIBFORB_SOCKET_HPP