socket.h

Go to the documentation of this file.

#pragma once

#include <memory>
#include "../../core_export.h"
#include "../../argument_exception.h"
#include "../../async_callback.h"
#include "../../iasync_result.h"
#include "../../not_implemented_exception.h"
#include "../../not_supported_exception.h"
#include "../../object.h"
#include "../../types.h"
#include "../../ustring.h"
#include "../end_point.h"
#include "../ip_address.h"
#include "address_family.h"
#include "io_control_code.h"
#include "ip_packet_information.h"
#include "ip_protection_level.h"
#include "linger_option.h"
#include "multicast_option.h"
#include "ip_v6_multicast_option.h"
#include "protocol_type.h"
#include "select_mode.h"
#include "socket_error.h"
#include "socket_flags.h"
#include "socket_information.h"
#include "socket_option_level.h"
#include "socket_option_name.h"
#include "socket_shutdown.h"
#include "socket_type.h"

namespace xtd {
  namespace net {
    namespace sockets {
      class socket_async_event_args;
      
      class core_export_ socket : public xtd::object {
        class async_result_socket : public xtd::object, public xtd::iasync_result {
        public:
          explicit async_result_socket(std::any async_state) : async_state_(async_state) {}
          std::any async_state() const noexcept override {return async_state_;}
          std::shared_mutex& async_mutex() override {return async_mutex_;}
          bool completed_synchronously() const noexcept override {return false;}
          bool is_completed() const noexcept override {return is_completed_;};
          
          std::any async_state_;
          bool is_completed_ = false;
          std::shared_mutex async_mutex_;
          xtd::net::sockets::socket_error error_code_ = xtd::net::sockets::socket_error::success;
          std::exception_ptr exception_;
        };
        
        class async_result_accept : public async_result_socket {
        public:
          explicit async_result_accept(std::any async_state) : async_result_socket(async_state) {}
          std::any socket_;
        };
        
        class async_result_connect : public async_result_socket {
        public:
          explicit async_result_connect(std::any async_state) : async_result_socket(async_state) {}
        };
        
        class async_result_disconnect : public async_result_socket {
        public:
          explicit async_result_disconnect(std::any async_state) : async_result_socket(async_state) {}
        };
        
        class async_result_receive : public async_result_socket {
        public:
          explicit async_result_receive(std::any async_state) : async_result_socket(async_state) {}
          size_t number_of_bytes_received_ = 0;
        };
        
        class async_result_receive_from : public async_result_socket {
        public:
          explicit async_result_receive_from(std::any async_state) : async_result_socket(async_state) {}
          std::shared_ptr<xtd::net::end_point> end_point_;
          size_t number_of_bytes_received_ = 0;
        };
        
        class async_result_receive_message_from : public async_result_socket {
        public:
          explicit async_result_receive_message_from(std::any async_state) : async_result_socket(async_state) {}
          std::shared_ptr<xtd::net::end_point> end_point_;
          xtd::net::sockets::socket_flags socket_flags_ = xtd::net::sockets::socket_flags::none;
          size_t number_of_bytes_received_ = 0;
          xtd::net::sockets::ip_packet_information ip_packet_information_;
        };
        
        class async_result_send : public async_result_socket {
        public:
          explicit async_result_send(std::any async_state) : async_result_socket(async_state) {}
          size_t number_of_bytes_sent_ = 0;
        };
        
        class async_result_send_to : public async_result_socket {
        public:
          explicit async_result_send_to(std::any async_state) : async_result_socket(async_state) {}
          size_t number_of_bytes_sent_ = 0;
        };
        
      public:
        
        socket();
        
        explicit socket(intptr_t handle);
        explicit socket(const xtd::net::sockets::socket_information& socket_information);
        socket(xtd::net::sockets::socket_type socket_type, xtd::net::sockets::protocol_type protocol_type);
        socket(xtd::net::sockets::address_family address_family, xtd::net::sockets::socket_type socket_type, xtd::net::sockets::protocol_type protocol_type);
        
        socket(socket&&) = default;
        socket(const socket&) = default;
        ~socket();
        socket& operator=(const socket&) = default;
        friend std::ostream& operator <<(std::ostream& os, const socket& mo) noexcept {return os << mo.to_string();}
        bool operator==(const socket& s) const {return data_ == s.data_;};
        bool operator!=(const socket& s) const {return !operator==(s);};
        
        
        xtd::net::sockets::address_family address_family() const noexcept;
        
        size_t available() const;
        
        bool blocking() const;
        socket& blocking(bool value);
        
        bool connected() const noexcept;
        
        bool dont_fragment() const;
        socket& dont_fragment(bool value);
        
        bool dual_mode() const;
        socket& dual_mode(bool value);
        
        bool enable_broadcast() const;
        socket& enable_broadcast(bool value);
        
        bool exclusive_address_use() const;
        socket& exclusive_address_use(bool value);
        
        intptr_t handle() const noexcept;
        
        bool is_bound() const noexcept;
        
        xtd::net::sockets::linger_option linger_state() const;
        socket& linger_state(const xtd::net::sockets::linger_option& value);
        
        std::shared_ptr<xtd::net::end_point> local_end_point() const;
        
        bool multicast_loopback() const;
        socket& multicast_loopback(bool value);
        
        bool no_delay() const;
        socket& no_delay(bool value);
        
        static bool os_supports_ip_v4() noexcept;
        
        static bool os_supports_ip_v6() noexcept;
        
        xtd::net::sockets::protocol_type protocol_type() const noexcept;
        
        size_t receive_buffer_size() const;
        socket& receive_buffer_size(size_t value);
        
        int32_t receive_timeout() const;
        socket& receive_timeout(int32_t value);
        
        std::shared_ptr<xtd::net::end_point> remote_end_point() const;
        
        size_t send_buffer_size() const;
        socket& send_buffer_size(size_t value);
        
        int32_t send_timeout() const;
        socket& send_timeout(int32_t value);
        
        xtd::net::sockets::socket_type socket_type() const noexcept;
        
        byte_t ttl() const;
        socket& ttl(byte_t value);
        
        
        socket accept();
        
        bool accept_async(xtd::net::sockets::socket_async_event_args& e);
        
        std::shared_ptr<xtd::iasync_result> begin_accept(xtd::async_callback callback, const std::any& state);
        
        template<typename end_point_t>
        std::shared_ptr<xtd::iasync_result> begin_connect(const end_point_t& remote_end_point, xtd::async_callback callback, const std::any& state) {
          return begin_connect_(std::make_shared<end_point_t>(remote_end_point), callback, state);
        }
        std::shared_ptr<xtd::iasync_result> begin_connect(const xtd::net::ip_address& address, uint16_t port, xtd::async_callback callback, const std::any& state);
        std::shared_ptr<xtd::iasync_result> begin_connect(const std::vector<xtd::net::ip_address>& addresses, uint16_t port, xtd::async_callback callback, const std::any& state);
        std::shared_ptr<xtd::iasync_result> begin_connect(const xtd::ustring& host, uint16_t port, xtd::async_callback callback, const std::any& state);
        
        std::shared_ptr<xtd::iasync_result> begin_disconnect(bool reuse_socket, xtd::async_callback callback, const std::any& state);
        
        std::shared_ptr<xtd::iasync_result> begin_receive(std::vector<byte_t>& buffer, size_t offset, size_t size, xtd::net::sockets::socket_flags socket_flags, xtd::async_callback callback, const std::any& state);
        std::shared_ptr<xtd::iasync_result> begin_receive(std::vector<byte_t>& buffer, size_t offset, size_t size, xtd::net::sockets::socket_flags socket_flags, xtd::net::sockets::socket_error& error_code, xtd::async_callback callback, const std::any& state);
        
        std::shared_ptr<xtd::iasync_result> begin_receive_from(std::vector<byte_t>& buffer, size_t offset, size_t size, xtd::net::sockets::socket_flags socket_flags, xtd::net::end_point& remote_end_point, xtd::async_callback callback, const std::any& state);
        
        std::shared_ptr<xtd::iasync_result> begin_receive_message_from(std::vector<byte_t>& buffer, size_t offset, size_t size, xtd::net::sockets::socket_flags socket_flags, xtd::net::end_point& remote_end_point, xtd::async_callback callback, const std::any& state);
        
        std::shared_ptr<xtd::iasync_result> begin_send(const std::vector<byte_t>& buffer, size_t offset, size_t size, xtd::net::sockets::socket_flags socket_flags, xtd::async_callback callback, const std::any& state);
        std::shared_ptr<xtd::iasync_result> begin_send(const std::vector<byte_t>& buffer, size_t offset, size_t size, xtd::net::sockets::socket_flags socket_flags, xtd::net::sockets::socket_error& error_code, xtd::async_callback callback, const std::any& state);
        
        std::shared_ptr<xtd::iasync_result> begin_send_to(const std::vector<byte_t>& buffer, size_t offset, size_t size, xtd::net::sockets::socket_flags socket_flags, const xtd::net::end_point& remote_end_point, xtd::async_callback callback, const std::any& state);
        
        template<typename end_point_t>
        void bind(const end_point_t& local_end_point) {
          bind_(std::make_shared<end_point_t>(local_end_point));
        }
        
        void close();
        
        template<typename end_point_t>
        void connect(const end_point_t& remote_end_point) {
          connect_(std::make_shared<end_point_t>(remote_end_point));
        }
        
        void connect(const xtd::net::ip_address& address, uint16_t port);
        
        void connect(const std::vector<xtd::net::ip_address>& addresses, uint16_t port);
        
        void connect(const xtd::ustring& host, uint16_t port);
        
        void disconnect(bool reuse_socket);
        
        socket end_accept(std::shared_ptr<xtd::iasync_result> async_result);
        
        void end_connect(std::shared_ptr<xtd::iasync_result> async_result);
        
        void end_disconnect(std::shared_ptr<xtd::iasync_result> async_result);
        
        size_t end_receive(std::shared_ptr<xtd::iasync_result> async_result);
        size_t end_receive(std::shared_ptr<xtd::iasync_result> async_result, xtd::net::sockets::socket_error& error_code);
        
        size_t end_receive_from(std::shared_ptr<xtd::iasync_result> async_result, std::shared_ptr<xtd::net::end_point>& end_point);
        
        size_t end_receive_message_from(std::shared_ptr<xtd::iasync_result> async_result, xtd::net::sockets::socket_flags& socket_flags, std::shared_ptr<xtd::net::end_point>& end_point, xtd::net::sockets::ip_packet_information& ip_packet_information);
        
        size_t end_send(std::shared_ptr<xtd::iasync_result> async_result);
        size_t end_send(std::shared_ptr<xtd::iasync_result> async_result, xtd::net::sockets::socket_error& error_code);
        
        size_t end_send_to(std::shared_ptr<xtd::iasync_result> async_result);
        
        size_t get_raw_socket_option(int32_t socket_option_level, int32_t socket_option_name, intptr_t option_value, size_t size_option_value) const;
        
        int32_t get_socket_option(xtd::net::sockets::socket_option_level socket_option_level, xtd::net::sockets::socket_option_name socket_option_name) const;
        xtd::net::sockets::linger_option get_socket_linger_option() const;
        xtd::net::sockets::multicast_option get_socket_multicast_option(xtd::net::sockets::socket_option_name socket_option_name) const;
        xtd::net::sockets::ip_v6_multicast_option get_socket_ip_v6_multicast_option(xtd::net::sockets::socket_option_name socket_option_name) const;
        
        size_t io_control(int32_t io_control_code, std::vector<uint8_t>& option_in_value, std::vector<uint8_t>& option_out_value);
        size_t io_control(xtd::net::sockets::io_control_code io_control_code, std::vector<uint8_t>& option_in_value, std::vector<uint8_t>& option_out_value);
        
        void listen(size_t backlog);
        
        void listen();
        
        bool poll(int32_t micro_seconds, xtd::net::sockets::select_mode mode);
        
        size_t receive(std::vector<byte_t>& buffer);
        
        size_t receive(std::vector<byte_t>& buffer, xtd::net::sockets::socket_flags socket_flags);
        
        size_t receive(std::vector<byte_t>& buffer, size_t size, xtd::net::sockets::socket_flags socket_flags);
        
        size_t receive(std::vector<byte_t>& buffer, size_t offset, size_t size, xtd::net::sockets::socket_flags socket_flags);
        
        size_t receive(std::vector<byte_t>& buffer, size_t offset, size_t size, xtd::net::sockets::socket_flags socket_flags, xtd::net::sockets::socket_error& error);
        
        size_t receive_from(std::vector<byte_t>& buffer, xtd::net::end_point& remote_end_point);
        
        size_t receive_from(std::vector<byte_t>& buffer, xtd::net::sockets::socket_flags socket_flags, xtd::net::end_point& remote_end_point);
        
        size_t receive_from(std::vector<byte_t>& buffer, size_t size, xtd::net::sockets::socket_flags socket_flags, xtd::net::end_point& remote_end_point);
        
        size_t receive_from(std::vector<byte_t>& buffer, size_t offset, size_t size, xtd::net::sockets::socket_flags socket_flags, xtd::net::end_point& remote_end_point);
        
        size_t receive_message_from(std::vector<byte_t>& buffer, size_t offset, size_t size, xtd::net::sockets::socket_flags socket_flags, xtd::net::end_point& remote_end_point, xtd::net::sockets::ip_packet_information& ip_packet_information);
        
        static size_t select(std::vector<socket>& check_read, std::vector<socket>& check_write, std::vector<socket>& check_error, int32_t microseconds);
        
        size_t send(const std::vector<byte_t>& buffer);
        
        size_t send(const std::vector<byte_t>& buffer, xtd::net::sockets::socket_flags socket_flags);
        
        size_t send(const std::vector<byte_t>& buffer, size_t size, xtd::net::sockets::socket_flags socket_flags);
        
        size_t send(const std::vector<byte_t>& buffer, size_t offset, size_t size, xtd::net::sockets::socket_flags socket_flags);
        
        size_t send(const std::vector<byte_t>& buffer, size_t offset, size_t size, xtd::net::sockets::socket_flags socket_flags, xtd::net::sockets::socket_error& error_code);
        
        size_t send_to(const std::vector<byte_t>& buffer, const xtd::net::end_point& remote_end_point);
        size_t send_to(const std::vector<byte_t>& buffer, xtd::net::sockets::socket_flags socket_flags, const xtd::net::end_point& remote_end_point);
        size_t send_to(const std::vector<byte_t>& buffer, size_t size, xtd::net::sockets::socket_flags socket_flags, const xtd::net::end_point& remote_end_point);
        size_t send_to(const std::vector<byte_t>& buffer, size_t offset, size_t size, xtd::net::sockets::socket_flags socket_flags, const xtd::net::end_point& remote_end_point);
        
        void set_ip_protection_level(xtd::net::sockets::ip_protection_level level);
        
        void set_socket_option(xtd::net::sockets::socket_option_level socket_option_level, xtd::net::sockets::socket_option_name socket_option_name, bool option_value);
        
        void set_socket_option(xtd::net::sockets::socket_option_level socket_option_level, xtd::net::sockets::socket_option_name socket_option_name, int32_t option_value);
        void set_socket_option(xtd::net::sockets::linger_option option_value);
        void set_socket_option(xtd::net::sockets::socket_option_name socket_option_name, const xtd::net::sockets::multicast_option& option_value);
        void set_socket_option(xtd::net::sockets::socket_option_name socket_option_name, const xtd::net::sockets::ip_v6_multicast_option& option_value);
        
        void set_raw_socket_option(int32_t socket_option_level, int32_t socket_option_name, intptr_t option_value, size_t option_value_size);
        
        void shutdown(xtd::net::sockets::socket_shutdown how);
        
      private:
        static xtd::net::sockets::socket_error get_last_error_();
        std::shared_ptr<xtd::iasync_result> begin_connect_(std::shared_ptr<xtd::net::end_point> remote_end_point, xtd::async_callback callback, const std::any& state);
        void bind_(std::shared_ptr<xtd::net::end_point> local_end_point);
        void connect_(std::shared_ptr<xtd::net::end_point> remote_end_point);
        struct data;
        
        std::shared_ptr<data> data_;
      };
    }
  }
}