mn_basic_socket.hpp

Go to the documentation of this file.

/*
*This file is part of the Mini Thread Library (https://github.com/RoseLeBlood/MiniThread ).
*Copyright (c) 2018 Amber-Sophia Schroeck
*
*The Mini Thread Library is free software; you can redistribute it and/or modify
*it under the terms of the GNU Lesser General Public License as published by
*the Free Software Foundation, version 3, or (at your option) any later version.
 
*The Mini Thread 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
*General Public License for more details.
*
*You should have received a copy of the GNU Lesser General Public
*License along with the Mini Thread  Library; if not, see
*<https://www.gnu.org/licenses/>.
*/
#ifndef _MINILIB_BASIC_SOCKET_HPP_
#define _MINILIB_BASIC_SOCKET_HPP_
 
#include "../mn_config.hpp"
#include "../mn_autolock.hpp"
 
#include <sdkconfig.h>
#include <lwip/api.h>
#include <lwip/sockets.h>
#include <lwip/udp.h>
 
#include "mn_basic_endpoint.hpp"
 
#ifndef UDPLITE_SEND_CSCOV
#define UDPLITE_SEND_CSCOV 0x01
#endif // UDPLITE_SEND_CSCOV
 
#ifndef UDPLITE_RECV_CSCOV
#define UDPLITE_RECV_CSCOV 0x02
#endif // UDPLITE_RECV_CSCOV
 
#define MNTHREAD_NET_INVALID_SOCKET -1
 
namespace mn {
    namespace net {
 
        class basic_ip_socket {
        public:
            using handle_type = int;
 
            explicit basic_ip_socket(const handle_type& hndl) noexcept;
            basic_ip_socket(const address_family& fam, const socket_type& type, const protocol_type& protocol) noexcept;
            basic_ip_socket(const basic_ip_socket& other) noexcept;
            virtual ~basic_ip_socket() noexcept;
 
            virtual bool                open();
 
 
            virtual void                close()          { lwip_close(m_iHandle); }
            virtual int                 available();
 
            virtual void                reset(const handle_type& hnd = MNTHREAD_NET_INVALID_SOCKET, bool bClosed = false);
 
            virtual bool                initialized();
 
            int                         get_last_error(bool poolLast = true);
            int                         get_handle()     { return m_iHandle; }
            virtual basic_ip_socket*    get_copy() = 0;
 
 
            basic_ip_socket& operator = (const basic_ip_socket& other);
 
 
            virtual void swap(basic_ip_socket& rhs) noexcept {
                mn::swap(m_iHandle, rhs.m_iHandle);
                mn::swap(m_eFam, rhs.m_eFam);
                mn::swap(m_eType, rhs.m_eType);
                mn::swap(m_eProtocol, rhs.m_eProtocol);
                mn::swap(m_bBlocked, rhs.m_bBlocked);
            }
 
            void shutdown(const socket_shutdown_type& cmd);
 
            bool poll(const unsigned long& timeout, int mode);
            void set_reuse_address(bool flag);
            void set_rause_port(bool flag);
            void set_linger(bool on, int seconds);
            void set_no_delay(bool flag);
            void set_keep_alive(bool flag);
            void set_oob_inline(bool flag);
            void set_blocking(bool flag);
            void set_nocheak(bool value);
            void set_send_buffer_size(int value);
            void set_recive_buffer_size(int value);
 
            void set_send_timeout(int value);
            void set_recive_timeout(int value);
 
 
            bool get_reuse_address();
            bool get_rause_port();
            void get_linger(bool& on, int& seconds);
 
            bool get_no_delay();
            bool get_keep_alive();
            bool get_oob_inline();
            bool get_nocheak();
 
            bool get_blocking() { return m_bBlocked; }
            int get_send_buffer_size();
            int get_recive_buffer_size();
 
            int get_send_timeout();
            int get_recive_timeout();
        public:
            int set_options(const socket_option_level& opt, const socket_option_name& name, int value);
 
            int set_options(const socket_option_level& opt, const socket_option_name& name, unsigned int value);
 
            int set_options(const socket_option_level& opt, const socket_option_name& name, basic_ip4_address value);
 
            int set_options(const socket_option_level& opt, const socket_option_name& name, basic_ip6_address value);
 
            int set_options(const socket_option_level& opt, const socket_option_name& name, bool value);
            int set_options(const socket_option_level& opt, const socket_option_name& name,
                            void* value, uint32_t size);
 
            int get_option_int(const socket_option_level& opt, const socket_option_name& name);
            bool get_option_bool(const socket_option_level& opt, const socket_option_name& name);
            int get_option_raw(const socket_option_level& opt, const socket_option_name& name, void* value,
                                uint32_t size);
        public:
            int ioctl(const ioctl_request_type& request, int& arg);
            int ioctl(const ioctl_request_type& request, void* arg);
 
            int set_fcntl(int arg);
 
            int get_fcntl();
 
        protected:
            virtual bool                open(const address_family& fam, const socket_type& type,
                                             const protocol_type& protocol);
 
 
        protected:
            handle_type m_iHandle;
 
            address_family  m_eFam;
            socket_type     m_eType;
            protocol_type   m_eProtocol;
 
            bool m_bBlocked;
        };
 
    }
}
 
 
 
#endif // _MINILIB_BASIC_SOCKET_HPP_