socket.hpp

Go to the documentation of this file.

#pragma once
#include "address_family.hpp"
#include "io_control_code.hpp"
#include "ip_packet_information.hpp"
#include "ip_protection_level.hpp"
#include "linger_option.hpp"
#include "multicast_option.hpp"
#include "ip_v6_multicast_option.hpp"
#include "protocol_type.hpp"
#include "select_mode.hpp"
#include "socket_error.hpp"
#include "socket_flags.hpp"
#include "socket_information.hpp"
#include "socket_option_level.hpp"
#include "socket_option_name.hpp"
#include "socket_shutdown.hpp"
#include "socket_type.hpp"
#include "../end_point.hpp"
#include "../ip_address.hpp"
#include "../../collections/generic/ilist.hpp"
#include "../../threading/manual_reset_event.hpp"
#include "../../core_export.hpp"
#include "../../argument_exception.hpp"
#include "../../async_callback.hpp"
#include "../../array.hpp"
#include "../../iasync_result.hpp"
#include "../../icomparable.hpp"
#include "../../iequatable.hpp"
#include "../../not_implemented_exception.hpp"
#include "../../not_supported_exception.hpp"
#include "../../object.hpp"
#include "../../types.hpp"
#include "../../string.hpp"
#include <exception>
#include <memory>

namespace xtd {
  namespace net {
    namespace sockets {
      class socket_async_event_args;
      
      class core_export_ socket : public xtd::object, public xtd::icomparable<socket>, public xtd::iequatable<socket> {
        class async_result_socket : public xtd::object, public xtd::iasync_result {
        public:
          explicit async_result_socket(const xtd::any_object& async_state) : async_state_(async_state) {}
          xtd::any_object async_state() const noexcept override {return async_state_;}
          xtd::threading::wait_handle& async_wait_handle() noexcept override {return async_event_;}
          bool completed_synchronously() const noexcept override {return false;}
          bool is_completed() const noexcept override {return is_completed_;};
          
          xtd::any_object async_state_;
          bool is_completed_ = false;
          xtd::threading::manual_reset_event async_event_;
          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(const xtd::any_object& async_state) : async_result_socket(async_state) {}
          xtd::any_object socket_;
        };
        
        class async_result_connect : public async_result_socket {
        public:
          explicit async_result_connect(const xtd::any_object& async_state) : async_result_socket(async_state) {}
        };
        
        class async_result_disconnect : public async_result_socket {
        public:
          explicit async_result_disconnect(const xtd::any_object& async_state) : async_result_socket(async_state) {}
        };
        
        class async_result_receive : public async_result_socket {
        public:
          explicit async_result_receive(const xtd::any_object& async_state) : async_result_socket(async_state) {}
          xtd::size number_of_bytes_received_ = 0;
        };
        
        class async_result_receive_from : public async_result_socket {
        public:
          explicit async_result_receive_from(const xtd::any_object& async_state) : async_result_socket(async_state) {}
          xtd::sptr<xtd::net::end_point> end_point_;
          xtd::size number_of_bytes_received_ = 0;
        };
        
        class async_result_receive_message_from : public async_result_socket {
        public:
          explicit async_result_receive_message_from(const xtd::any_object& async_state) : async_result_socket(async_state) {}
          xtd::sptr<xtd::net::end_point> end_point_;
          xtd::net::sockets::socket_flags socket_flags_ = xtd::net::sockets::socket_flags::none;
          xtd::size 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(const xtd::any_object& async_state) : async_result_socket(async_state) {}
          xtd::size number_of_bytes_sent_ = 0;
        };
        
        class async_result_send_to : public async_result_socket {
        public:
          explicit async_result_send_to(const xtd::any_object& async_state) : async_result_socket(async_state) {}
          xtd::size number_of_bytes_sent_ = 0;
        };
        
        struct data;
        
      public:
        
        socket();
        
        explicit socket(xtd::intptr 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();
        auto operator =(const socket&) -> socket& = default;
        
        
        [[nodiscard]] auto address_family() const noexcept -> xtd::net::sockets::address_family;
        
        [[nodiscard]] auto available() const -> xtd::size;
        
        [[nodiscard]] auto blocking() const -> bool;
        auto blocking(bool value) -> socket&;
        
        [[nodiscard]] auto connected() const noexcept -> bool;
        
        [[nodiscard]] auto dont_fragment() const -> bool;
        auto dont_fragment(bool value) -> socket&;
        
        [[nodiscard]] auto dual_mode() const -> bool;
        auto dual_mode(bool value) -> socket&;
        
        [[nodiscard]] auto enable_broadcast() const -> bool;
        auto enable_broadcast(bool value) -> socket&;
        
        [[nodiscard]] auto exclusive_address_use() const -> bool;
        auto exclusive_address_use(bool value) -> socket&;
        
        [[nodiscard]] auto handle() const noexcept -> xtd::intptr;
        
        [[nodiscard]] auto is_bound() const noexcept -> bool;
        
        [[nodiscard]] auto linger_state() const -> xtd::net::sockets::linger_option;
        auto linger_state(const xtd::net::sockets::linger_option& value) -> socket&;
        
        [[nodiscard]] auto local_end_point() const -> xtd::sptr<xtd::net::end_point>;
        
        [[nodiscard]] auto multicast_loopback() const -> bool;
        auto multicast_loopback(bool value) -> socket&;
        
        [[nodiscard]] auto no_delay() const -> bool;
        auto no_delay(bool value) -> socket&;
        
        [[nodiscard]] auto protocol_type() const noexcept -> xtd::net::sockets::protocol_type;
        
        [[nodiscard]] auto receive_buffer_size() const -> xtd::size;
        auto receive_buffer_size(xtd::size value) -> socket&;
        
        [[nodiscard]] auto receive_timeout() const -> xtd::int32;
        auto receive_timeout(xtd::int32 value) -> socket&;
        
        [[nodiscard]] auto remote_end_point() const -> xtd::sptr<xtd::net::end_point>;
        
        [[nodiscard]] auto send_buffer_size() const -> xtd::size;
        auto send_buffer_size(xtd::size value) -> socket&;
        
        [[nodiscard]] auto send_timeout() const -> xtd::int32;
        auto send_timeout(xtd::int32 value) -> socket&;
        
        [[nodiscard]] auto socket_type() const noexcept -> xtd::net::sockets::socket_type;
        
        [[nodiscard]] auto ttl() const -> xtd::byte;
        auto ttl(xtd::byte value) -> socket&;
        
        
        [[nodiscard]] static auto os_supports_ip_v4() noexcept -> bool;
        
        [[nodiscard]] static auto os_supports_ip_v6() noexcept -> bool;
        
        
        [[nodiscard]] auto accept() -> socket;
        
        auto accept_async(xtd::net::sockets::socket_async_event_args& e) -> bool;
        
        auto begin_accept(xtd::async_callback callback, const xtd::any_object& state) -> xtd::sptr<xtd::iasync_result>;
        
        template<class end_point_t>
        auto begin_connect(const end_point_t& remote_end_point, xtd::async_callback callback, const xtd::any_object& state) -> xtd::sptr<xtd::iasync_result> {
          return begin_connect_(xtd::new_sptr<end_point_t>(remote_end_point), callback, state);
        }

        auto begin_connect(const xtd::net::ip_address& address, uint16 port, xtd::async_callback callback, const xtd::any_object& state) -> xtd::sptr<xtd::iasync_result>;
        auto begin_connect(const xtd::array<xtd::net::ip_address>& addresses, uint16 port, xtd::async_callback callback, const xtd::any_object& state) -> xtd::sptr<xtd::iasync_result>;
        auto begin_connect(const xtd::string& host, uint16 port, xtd::async_callback callback, const xtd::any_object& state) -> xtd::sptr<xtd::iasync_result>;
        
        auto begin_disconnect(bool reuse_socket, xtd::async_callback callback, const xtd::any_object& state) -> xtd::sptr<xtd::iasync_result>;
        
        auto begin_receive(xtd::array<xtd::byte>& buffer, xtd::size offset, xtd::size size, xtd::net::sockets::socket_flags socket_flags, xtd::async_callback callback, const xtd::any_object& state) -> xtd::sptr<xtd::iasync_result>;
        auto begin_receive(xtd::array<xtd::byte>& buffer, xtd::size offset, xtd::size size, xtd::net::sockets::socket_flags socket_flags, xtd::net::sockets::socket_error& error_code, xtd::async_callback callback, const xtd::any_object& state) -> xtd::sptr<xtd::iasync_result>;
        
        auto begin_receive_from(xtd::array<xtd::byte>& buffer, xtd::size offset, xtd::size size, xtd::net::sockets::socket_flags socket_flags, xtd::net::end_point& remote_end_point, xtd::async_callback callback, const xtd::any_object& state) -> xtd::sptr<xtd::iasync_result>;
        
        auto begin_receive_message_from(xtd::array<xtd::byte>& buffer, xtd::size offset, xtd::size size, xtd::net::sockets::socket_flags socket_flags, xtd::net::end_point& remote_end_point, xtd::async_callback callback, const xtd::any_object& state) -> xtd::sptr<xtd::iasync_result>;
        
        auto begin_send(const xtd::array<xtd::byte>& buffer, xtd::size offset, xtd::size size, xtd::net::sockets::socket_flags socket_flags, xtd::async_callback callback, const xtd::any_object& state) -> xtd::sptr<xtd::iasync_result>;
        auto begin_send(const xtd::array<xtd::byte>& buffer, xtd::size offset, xtd::size size, xtd::net::sockets::socket_flags socket_flags, xtd::net::sockets::socket_error& error_code, xtd::async_callback callback, const xtd::any_object& state) -> xtd::sptr<xtd::iasync_result>;
        
        auto begin_send_to(const xtd::array<xtd::byte>& buffer, xtd::size offset, xtd::size size, xtd::net::sockets::socket_flags socket_flags, const xtd::net::end_point& remote_end_point, xtd::async_callback callback, const xtd::any_object& state) -> xtd::sptr<xtd::iasync_result>;
        
        template<class end_point_t>
        auto bind(const end_point_t& local_end_point) -> void {
          bind_(xtd::new_sptr<end_point_t>(local_end_point));
        }
        
        auto close() -> void;
        
        [[nodiscard]] auto compare_to(const socket& obj) const noexcept -> xtd::int32 override;
        
        template<class end_point_t>
        auto connect(const end_point_t& remote_end_point) -> void {
          connect_(xtd::new_sptr<end_point_t>(remote_end_point));
        }
        
        auto connect(const xtd::net::ip_address& address, uint16 port) -> void;
        
        auto connect(const xtd::array<xtd::net::ip_address>& addresses, uint16 port) -> void;
        
        auto connect(const xtd::string& host, uint16 port) -> void;
        
        auto disconnect(bool reuse_socket) -> void;
        
        [[nodiscard]] auto end_accept(xtd::sptr<xtd::iasync_result> async_result) -> socket;
        
        auto end_connect(xtd::sptr<xtd::iasync_result> async_result) -> void;
        
        auto end_disconnect(xtd::sptr<xtd::iasync_result> async_result) -> void;
        
        auto end_receive(xtd::sptr<xtd::iasync_result> async_result) -> xtd::size;
        auto end_receive(xtd::sptr<xtd::iasync_result> async_result, xtd::net::sockets::socket_error& error_code) -> xtd::size;
        
        auto end_receive_from(xtd::sptr<xtd::iasync_result> async_result, xtd::sptr<xtd::net::end_point>& end_point) -> xtd::size;
        
        auto end_receive_message_from(xtd::sptr<xtd::iasync_result> async_result, xtd::net::sockets::socket_flags& socket_flags, xtd::sptr<xtd::net::end_point>& end_point, xtd::net::sockets::ip_packet_information& ip_packet_information) -> xtd::size;
        
        auto end_send(xtd::sptr<xtd::iasync_result> async_result) -> xtd::size;
        auto end_send(xtd::sptr<xtd::iasync_result> async_result, xtd::net::sockets::socket_error& error_code) -> xtd::size;
        
        auto end_send_to(xtd::sptr<xtd::iasync_result> async_result) -> xtd::size;
        
        [[nodiscard]] auto equals(const xtd::object& obj) const noexcept -> bool override;
        [[nodiscard]] auto equals(const socket& other) const noexcept -> bool override;
        
        auto get_raw_socket_option(xtd::int32 socket_option_level, xtd::int32 socket_option_name, xtd::intptr option_value, xtd::size size_option_value) const -> xtd::size;
        
        auto get_socket_option(xtd::net::sockets::socket_option_level socket_option_level, xtd::net::sockets::socket_option_name socket_option_name) const -> xtd::int32;
        [[nodiscard]] auto get_socket_linger_option() const -> xtd::net::sockets::linger_option;
        [[nodiscard]] auto get_socket_multicast_option(xtd::net::sockets::socket_option_name socket_option_name) const -> xtd::net::sockets::multicast_option;
        [[nodiscard]] auto get_socket_ip_v6_multicast_option(xtd::net::sockets::socket_option_name socket_option_name) const -> xtd::net::sockets::ip_v6_multicast_option;
        
        auto io_control(xtd::int32 io_control_code, xtd::array<xtd::byte>& option_in_value, xtd::array<xtd::byte>& option_out_value) -> xtd::size;
        auto io_control(xtd::net::sockets::io_control_code io_control_code, xtd::array<xtd::byte>& option_in_value, xtd::array<xtd::byte>& option_out_value) -> xtd::size;
        
        auto listen(xtd::size backlog) -> void;
        
        auto listen() -> void;
        
        auto poll(xtd::int32 micro_seconds, xtd::net::sockets::select_mode mode) -> bool;
        
        auto receive(xtd::array<xtd::byte>& buffer) -> xtd::size;
        
        auto receive(xtd::array<xtd::byte>& buffer, xtd::net::sockets::socket_flags socket_flags) -> xtd::size;
        
        auto receive(xtd::array<xtd::byte>& buffer, xtd::size size, xtd::net::sockets::socket_flags socket_flags) -> xtd::size;
        
        auto receive(xtd::array<xtd::byte>& buffer, xtd::size offset, xtd::size size, xtd::net::sockets::socket_flags socket_flags) -> xtd::size;
        
        auto receive(xtd::array<xtd::byte>& buffer, xtd::size offset, xtd::size size, xtd::net::sockets::socket_flags socket_flags, xtd::net::sockets::socket_error& error) -> xtd::size;
        
        auto receive_from(xtd::array<xtd::byte>& buffer, xtd::net::end_point& remote_end_point) -> xtd::size;
        
        auto receive_from(xtd::array<xtd::byte>& buffer, xtd::net::sockets::socket_flags socket_flags, xtd::net::end_point& remote_end_point) -> xtd::size;
        
        auto receive_from(xtd::array<xtd::byte>& buffer, xtd::size size, xtd::net::sockets::socket_flags socket_flags, xtd::net::end_point& remote_end_point) -> xtd::size;
        
        auto receive_from(xtd::array<xtd::byte>& buffer, xtd::size offset, xtd::size size, xtd::net::sockets::socket_flags socket_flags, xtd::net::end_point& remote_end_point) -> xtd::size;
        
        auto receive_message_from(xtd::array<xtd::byte>& buffer, xtd::size offset, xtd::size size, xtd::net::sockets::socket_flags socket_flags, xtd::net::end_point& remote_end_point, xtd::net::sockets::ip_packet_information& ip_packet_information) -> xtd::size;
        
        auto send(const xtd::array<xtd::byte>& buffer) -> xtd::size;
        
        auto send(const xtd::array<xtd::byte>& buffer, xtd::net::sockets::socket_flags socket_flags) -> xtd::size;
        
        auto send(const xtd::array<xtd::byte>& buffer, xtd::size size, xtd::net::sockets::socket_flags socket_flags) -> xtd::size;
        
        auto send(const xtd::array<xtd::byte>& buffer, xtd::size offset, xtd::size size, xtd::net::sockets::socket_flags socket_flags) -> xtd::size;
        
        auto send(const xtd::array<xtd::byte>& buffer, xtd::size offset, xtd::size size, xtd::net::sockets::socket_flags socket_flags, xtd::net::sockets::socket_error& error_code) -> xtd::size;
        
        auto send_to(const xtd::array<xtd::byte>& buffer, const xtd::net::end_point& remote_end_point) -> xtd::size;
        auto send_to(const xtd::array<xtd::byte>& buffer, xtd::net::sockets::socket_flags socket_flags, const xtd::net::end_point& remote_end_point) -> xtd::size;
        auto send_to(const xtd::array<xtd::byte>& buffer, xtd::size size, xtd::net::sockets::socket_flags socket_flags, const xtd::net::end_point& remote_end_point) -> xtd::size;
        auto send_to(const xtd::array<xtd::byte>& buffer, xtd::size offset, xtd::size size, xtd::net::sockets::socket_flags socket_flags, const xtd::net::end_point& remote_end_point) -> xtd::size;
        
        auto set_ip_protection_level(xtd::net::sockets::ip_protection_level level) -> void;
        
        auto 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;
        
        auto set_socket_option(xtd::net::sockets::socket_option_level socket_option_level, xtd::net::sockets::socket_option_name socket_option_name, xtd::int32 option_value) -> void;
        auto set_socket_option(xtd::net::sockets::linger_option option_value) -> void;
        auto set_socket_option(xtd::net::sockets::socket_option_name socket_option_name, const xtd::net::sockets::multicast_option& option_value) -> void;
        auto set_socket_option(xtd::net::sockets::socket_option_name socket_option_name, const xtd::net::sockets::ip_v6_multicast_option& option_value) -> void;
        
        auto set_raw_socket_option(xtd::int32 socket_option_level, xtd::int32 socket_option_name, xtd::intptr option_value, xtd::size option_value_size) -> void;
        
        auto shutdown(xtd::net::sockets::socket_shutdown how) -> void;
        
        
        static auto select(xtd::collections::generic::ilist<socket>& check_read, xtd::collections::generic::ilist<socket>& check_write, xtd::collections::generic::ilist<socket>& check_error, xtd::int32 microseconds) -> xtd::size;
        
      private:
        [[nodiscard]] static auto get_last_error_() -> xtd::net::sockets::socket_error;
        [[nodiscard]] auto begin_connect_(xtd::sptr<xtd::net::end_point> remote_end_point, xtd::async_callback callback, const xtd::any_object& state) -> xtd::sptr<xtd::iasync_result>;
        auto bind_(xtd::sptr<xtd::net::end_point> local_end_point) -> void;
        auto connect_(xtd::sptr<xtd::net::end_point> remote_end_point) -> void;
        
        xtd::sptr<data> data_;
      };
    }
  }
}