ceph/src/boost/libs/asio/include/boost/asio/detail/winrt_ssocket_service_base.hpp

   1 //
   2 // detail/winrt_ssocket_service_base.hpp
   3 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   4 //
   5 // Copyright (c) 2003-2016 Christopher M. Kohlhoff (chris at kohlhoff dot com)
   6 //
   7 // Distributed under the Boost Software License, Version 1.0. (See accompanying
   8 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   9 //
  10
  11 #ifndef BOOST_ASIO_DETAIL_WINRT_SSOCKET_SERVICE_BASE_HPP
  12 #define BOOST_ASIO_DETAIL_WINRT_SSOCKET_SERVICE_BASE_HPP
  13
  14 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
  15 # pragma once
  16 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
  17
  18 #include <boost/asio/detail/config.hpp>
  19
  20 #if defined(BOOST_ASIO_WINDOWS_RUNTIME)
  21
  22 #include <boost/asio/buffer.hpp>
  23 #include <boost/asio/error.hpp>
  24 #include <boost/asio/io_service.hpp>
  25 #include <boost/asio/socket_base.hpp>
  26 #include <boost/asio/detail/addressof.hpp>
  27 #include <boost/asio/detail/buffer_sequence_adapter.hpp>
  28 #include <boost/asio/detail/socket_types.hpp>
  29 #include <boost/asio/detail/winrt_async_manager.hpp>
  30 #include <boost/asio/detail/winrt_socket_recv_op.hpp>
  31 #include <boost/asio/detail/winrt_socket_send_op.hpp>
  32
  33 #include <boost/asio/detail/push_options.hpp>
  34
  35 namespace boost {
  36 namespace asio {
  37 namespace detail {
  38
  39 class winrt_ssocket_service_base
  40 {
  41 public:
  42   // The native type of a socket.
  43   typedef Windows::Networking::Sockets::StreamSocket^ native_handle_type;
  44
  45   // The implementation type of the socket.
  46   struct base_implementation_type
  47   {
  48     // Default constructor.
  49     base_implementation_type()
  50       : socket_(nullptr),
  51         next_(0),
  52         prev_(0)
  53     {
  54     }
  55
  56     // The underlying native socket.
  57     native_handle_type socket_;
  58
  59     // Pointers to adjacent socket implementations in linked list.
  60     base_implementation_type* next_;
  61     base_implementation_type* prev_;
  62   };
  63
  64   // Constructor.
  65   BOOST_ASIO_DECL winrt_ssocket_service_base(
  66       boost::asio::io_service& io_service);
  67
  68   // Destroy all user-defined handler objects owned by the service.
  69   BOOST_ASIO_DECL void shutdown_service();
  70
  71   // Construct a new socket implementation.
  72   BOOST_ASIO_DECL void construct(base_implementation_type&);
  73
  74   // Move-construct a new socket implementation.
  75   BOOST_ASIO_DECL void base_move_construct(base_implementation_type& impl,
  76       base_implementation_type& other_impl);
  77
  78   // Move-assign from another socket implementation.
  79   BOOST_ASIO_DECL void base_move_assign(base_implementation_type& impl,
  80       winrt_ssocket_service_base& other_service,
  81       base_implementation_type& other_impl);
  82
  83   // Destroy a socket implementation.
  84   BOOST_ASIO_DECL void destroy(base_implementation_type& impl);
  85
  86   // Determine whether the socket is open.
  87   bool is_open(const base_implementation_type& impl) const
  88   {
  89     return impl.socket_ != nullptr;
  90   }
  91
  92   // Destroy a socket implementation.
  93   BOOST_ASIO_DECL boost::system::error_code close(
  94       base_implementation_type& impl, boost::system::error_code& ec);
  95
  96   // Get the native socket representation.
  97   native_handle_type native_handle(base_implementation_type& impl)
  98   {
  99     return impl.socket_;
 100   }
 101
 102   // Cancel all operations associated with the socket.
 103   boost::system::error_code cancel(base_implementation_type&,
 104       boost::system::error_code& ec)
 105   {
 106     ec = boost::asio::error::operation_not_supported;
 107     return ec;
 108   }
 109
 110   // Determine whether the socket is at the out-of-band data mark.
 111   bool at_mark(const base_implementation_type&,
 112       boost::system::error_code& ec) const
 113   {
 114     ec = boost::asio::error::operation_not_supported;
 115     return false;
 116   }
 117
 118   // Determine the number of bytes available for reading.
 119   std::size_t available(const base_implementation_type&,
 120       boost::system::error_code& ec) const
 121   {
 122     ec = boost::asio::error::operation_not_supported;
 123     return 0;
 124   }
 125
 126   // Perform an IO control command on the socket.
 127   template <typename IO_Control_Command>
 128   boost::system::error_code io_control(base_implementation_type&,
 129       IO_Control_Command&, boost::system::error_code& ec)
 130   {
 131     ec = boost::asio::error::operation_not_supported;
 132     return ec;
 133   }
 134
 135   // Gets the non-blocking mode of the socket.
 136   bool non_blocking(const base_implementation_type&) const
 137   {
 138     return false;
 139   }
 140
 141   // Sets the non-blocking mode of the socket.
 142   boost::system::error_code non_blocking(base_implementation_type&,
 143       bool, boost::system::error_code& ec)
 144   {
 145     ec = boost::asio::error::operation_not_supported;
 146     return ec;
 147   }
 148
 149   // Gets the non-blocking mode of the native socket implementation.
 150   bool native_non_blocking(const base_implementation_type&) const
 151   {
 152     return false;
 153   }
 154
 155   // Sets the non-blocking mode of the native socket implementation.
 156   boost::system::error_code native_non_blocking(base_implementation_type&,
 157       bool, boost::system::error_code& ec)
 158   {
 159     ec = boost::asio::error::operation_not_supported;
 160     return ec;
 161   }
 162
 163   // Disable sends or receives on the socket.
 164   boost::system::error_code shutdown(base_implementation_type&,
 165       socket_base::shutdown_type, boost::system::error_code& ec)
 166   {
 167     ec = boost::asio::error::operation_not_supported;
 168     return ec;
 169   }
 170
 171   // Send the given data to the peer.
 172   template <typename ConstBufferSequence>
 173   std::size_t send(base_implementation_type& impl,
 174       const ConstBufferSequence& buffers,
 175       socket_base::message_flags flags, boost::system::error_code& ec)
 176   {
 177     return do_send(impl,
 178         buffer_sequence_adapter<boost::asio::const_buffer,
 179           ConstBufferSequence>::first(buffers), flags, ec);
 180   }
 181
 182   // Wait until data can be sent without blocking.
 183   std::size_t send(base_implementation_type&, const null_buffers&,
 184       socket_base::message_flags, boost::system::error_code& ec)
 185   {
 186     ec = boost::asio::error::operation_not_supported;
 187     return 0;
 188   }
 189
 190   // Start an asynchronous send. The data being sent must be valid for the
 191   // lifetime of the asynchronous operation.
 192   template <typename ConstBufferSequence, typename Handler>
 193   void async_send(base_implementation_type& impl,
 194       const ConstBufferSequence& buffers,
 195       socket_base::message_flags flags, Handler& handler)
 196   {
 197     bool is_continuation =
 198       boost_asio_handler_cont_helpers::is_continuation(handler);
 199
 200     // Allocate and construct an operation to wrap the handler.
 201     typedef winrt_socket_send_op<ConstBufferSequence, Handler> op;
 202     typename op::ptr p = { boost::asio::detail::addressof(handler),
 203       boost_asio_handler_alloc_helpers::allocate(
 204         sizeof(op), handler), 0 };
 205     p.p = new (p.v) op(buffers, handler);
 206
 207     BOOST_ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_send"));
 208
 209     start_send_op(impl,
 210         buffer_sequence_adapter<boost::asio::const_buffer,
 211           ConstBufferSequence>::first(buffers),
 212         flags, p.p, is_continuation);
 213     p.v = p.p = 0;
 214   }
 215
 216   // Start an asynchronous wait until data can be sent without blocking.
 217   template <typename Handler>
 218   void async_send(base_implementation_type&, const null_buffers&,
 219       socket_base::message_flags, Handler& handler)
 220   {
 221     boost::system::error_code ec = boost::asio::error::operation_not_supported;
 222     const std::size_t bytes_transferred = 0;
 223     io_service_.get_io_service().post(
 224         detail::bind_handler(handler, ec, bytes_transferred));
 225   }
 226
 227   // Receive some data from the peer. Returns the number of bytes received.
 228   template <typename MutableBufferSequence>
 229   std::size_t receive(base_implementation_type& impl,
 230       const MutableBufferSequence& buffers,
 231       socket_base::message_flags flags, boost::system::error_code& ec)
 232   {
 233     return do_receive(impl,
 234         buffer_sequence_adapter<boost::asio::mutable_buffer,
 235           MutableBufferSequence>::first(buffers), flags, ec);
 236   }
 237
 238   // Wait until data can be received without blocking.
 239   std::size_t receive(base_implementation_type&, const null_buffers&,
 240       socket_base::message_flags, boost::system::error_code& ec)
 241   {
 242     ec = boost::asio::error::operation_not_supported;
 243     return 0;
 244   }
 245
 246   // Start an asynchronous receive. The buffer for the data being received
 247   // must be valid for the lifetime of the asynchronous operation.
 248   template <typename MutableBufferSequence, typename Handler>
 249   void async_receive(base_implementation_type& impl,
 250       const MutableBufferSequence& buffers,
 251       socket_base::message_flags flags, Handler& handler)
 252   {
 253     bool is_continuation =
 254       boost_asio_handler_cont_helpers::is_continuation(handler);
 255
 256     // Allocate and construct an operation to wrap the handler.
 257     typedef winrt_socket_recv_op<MutableBufferSequence, Handler> op;
 258     typename op::ptr p = { boost::asio::detail::addressof(handler),
 259       boost_asio_handler_alloc_helpers::allocate(
 260         sizeof(op), handler), 0 };
 261     p.p = new (p.v) op(buffers, handler);
 262
 263     BOOST_ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_receive"));
 264
 265     start_receive_op(impl,
 266         buffer_sequence_adapter<boost::asio::mutable_buffer,
 267           MutableBufferSequence>::first(buffers),
 268         flags, p.p, is_continuation);
 269     p.v = p.p = 0;
 270   }
 271
 272   // Wait until data can be received without blocking.
 273   template <typename Handler>
 274   void async_receive(base_implementation_type&, const null_buffers&,
 275       socket_base::message_flags, Handler& handler)
 276   {
 277     boost::system::error_code ec = boost::asio::error::operation_not_supported;
 278     const std::size_t bytes_transferred = 0;
 279     io_service_.get_io_service().post(
 280         detail::bind_handler(handler, ec, bytes_transferred));
 281   }
 282
 283 protected:
 284   // Helper function to obtain endpoints associated with the connection.
 285   BOOST_ASIO_DECL std::size_t do_get_endpoint(
 286       const base_implementation_type& impl, bool local,
 287       void* addr, std::size_t addr_len, boost::system::error_code& ec) const;
 288
 289   // Helper function to set a socket option.
 290   BOOST_ASIO_DECL boost::system::error_code do_set_option(
 291       base_implementation_type& impl,
 292       int level, int optname, const void* optval,
 293       std::size_t optlen, boost::system::error_code& ec);
 294
 295   // Helper function to get a socket option.
 296   BOOST_ASIO_DECL void do_get_option(
 297       const base_implementation_type& impl,
 298       int level, int optname, void* optval,
 299       std::size_t* optlen, boost::system::error_code& ec) const;
 300
 301   // Helper function to perform a synchronous connect.
 302   BOOST_ASIO_DECL boost::system::error_code do_connect(
 303       base_implementation_type& impl,
 304       const void* addr, boost::system::error_code& ec);
 305
 306   // Helper function to start an asynchronous connect.
 307   BOOST_ASIO_DECL void start_connect_op(
 308       base_implementation_type& impl, const void* addr,
 309       winrt_async_op<void>* op, bool is_continuation);
 310
 311   // Helper function to perform a synchronous send.
 312   BOOST_ASIO_DECL std::size_t do_send(
 313       base_implementation_type& impl, const boost::asio::const_buffer& data,
 314       socket_base::message_flags flags, boost::system::error_code& ec);
 315
 316   // Helper function to start an asynchronous send.
 317   BOOST_ASIO_DECL void start_send_op(base_implementation_type& impl,
 318       const boost::asio::const_buffer& data, socket_base::message_flags flags,
 319       winrt_async_op<unsigned int>* op, bool is_continuation);
 320
 321   // Helper function to perform a synchronous receive.
 322   BOOST_ASIO_DECL std::size_t do_receive(
 323       base_implementation_type& impl, const boost::asio::mutable_buffer& data,
 324       socket_base::message_flags flags, boost::system::error_code& ec);
 325
 326   // Helper function to start an asynchronous receive.
 327   BOOST_ASIO_DECL void start_receive_op(base_implementation_type& impl,
 328       const boost::asio::mutable_buffer& data, socket_base::message_flags flags,
 329       winrt_async_op<Windows::Storage::Streams::IBuffer^>* op,
 330       bool is_continuation);
 331
 332   // The io_service implementation used for delivering completions.
 333   io_service_impl& io_service_;
 334
 335   // The manager that keeps track of outstanding operations.
 336   winrt_async_manager& async_manager_;
 337
 338   // Mutex to protect access to the linked list of implementations.
 339   boost::asio::detail::mutex mutex_;
 340
 341   // The head of a linked list of all implementations.
 342   base_implementation_type* impl_list_;
 343 };
 344
 345 } // namespace detail
 346 } // namespace asio
 347 } // namespace boost
 348
 349 #include <boost/asio/detail/pop_options.hpp>
 350
 351 #if defined(BOOST_ASIO_HEADER_ONLY)
 352 # include <boost/asio/detail/impl/winrt_ssocket_service_base.ipp>
 353 #endif // defined(BOOST_ASIO_HEADER_ONLY)
 354
 355 #endif // defined(BOOST_ASIO_WINDOWS_RUNTIME)
 356
 357 #endif // BOOST_ASIO_DETAIL_WINRT_SSOCKET_SERVICE_BASE_HPP