/** * This function is used to modify the non-blocking mode of the underlying * native descriptor. It has no effect on the behaviour of the descriptor * object's synchronous operations. * * @param mode If @c true, the underlying descriptor is put into non-blocking * mode and direct system calls may fail with boost::asio::error::would_block * (or the equivalent system error). * * @param ec Set to indicate what error occurred, if any. If the @c mode is * @c false, but the current value of @c non_blocking() is @c true, this * function fails with boost::asio::error::invalid_argument, as the * combination does not make sense. */ BOOST_ASIO_SYNC_OP_VOID native_non_blocking( bool mode, boost::system::error_code& ec) { this->get_service().native_non_blocking( this->get_implementation(), mode, ec); BOOST_ASIO_SYNC_OP_VOID_RETURN(ec); }
BOOST_ASIO_SYNC_OP_VOID set_verify_callback(VerifyCallback callback, boost::system::error_code& ec) { core_.engine_.set_verify_callback( new detail::verify_callback<VerifyCallback>(callback), ec); BOOST_ASIO_SYNC_OP_VOID_RETURN(ec); }
BOOST_ASIO_SYNC_OP_VOID handshake(handshake_type type, const ConstBufferSequence& buffers, boost::system::error_code& ec) { detail::io(next_layer_, core_, detail::buffered_handshake_op<ConstBufferSequence>(type, buffers), ec); BOOST_ASIO_SYNC_OP_VOID_RETURN(ec); }
inline BOOST_ASIO_SYNC_OP_VOID connect_pair( basic_socket<Protocol BOOST_ASIO_SVC_TARG>& socket1, basic_socket<Protocol BOOST_ASIO_SVC_TARG1>& socket2, boost::system::error_code& ec) { // Check that this function is only being used with a UNIX domain socket. boost::asio::local::basic_endpoint<Protocol>* tmp = static_cast<typename Protocol::endpoint*>(0); (void)tmp; Protocol protocol; boost::asio::detail::socket_type sv[2]; if (boost::asio::detail::socket_ops::socketpair(protocol.family(), protocol.type(), protocol.protocol(), sv, ec) == boost::asio::detail::socket_error_retval) BOOST_ASIO_SYNC_OP_VOID_RETURN(ec); socket1.assign(protocol, sv[0], ec); if (ec) { boost::system::error_code temp_ec; boost::asio::detail::socket_ops::state_type state[2] = { 0, 0 }; boost::asio::detail::socket_ops::close(sv[0], state[0], true, temp_ec); boost::asio::detail::socket_ops::close(sv[1], state[1], true, temp_ec); BOOST_ASIO_SYNC_OP_VOID_RETURN(ec); } socket2.assign(protocol, sv[1], ec); if (ec) { boost::system::error_code temp_ec; socket1.close(temp_ec); boost::asio::detail::socket_ops::state_type state = 0; boost::asio::detail::socket_ops::close(sv[1], state, true, temp_ec); BOOST_ASIO_SYNC_OP_VOID_RETURN(ec); } BOOST_ASIO_SYNC_OP_VOID_RETURN(ec); }
/** * This function is used to perform SSL handshaking on the stream. The * function call will block until handshaking is complete or an error occurs. * * @param type The type of handshaking to be performed, i.e. as a client or as * a server. * * @param ec Set to indicate what error occurred, if any. */ BOOST_ASIO_SYNC_OP_VOID handshake(handshake_type type, boost::system::error_code& ec) { detail::io(next_layer_, core_, detail::handshake_op(type), ec); BOOST_ASIO_SYNC_OP_VOID_RETURN(ec); }
/** * This function may be used to configure the maximum verification depth * allowed by the stream. * * @param depth Maximum depth for the certificate chain verification that * shall be allowed. * * @param ec Set to indicate what error occurred, if any. * * @note Calls @c SSL_set_verify_depth. */ BOOST_ASIO_SYNC_OP_VOID set_verify_depth( int depth, boost::system::error_code& ec) { core_.engine_.set_verify_depth(depth, ec); BOOST_ASIO_SYNC_OP_VOID_RETURN(ec); }
/** * This function may be used to configure the peer verification mode used by * the stream. The new mode will override the mode inherited from the context. * * @param v A bitmask of peer verification modes. See @ref verify_mode for * available values. * * @param ec Set to indicate what error occurred, if any. * * @note Calls @c SSL_set_verify. */ BOOST_ASIO_SYNC_OP_VOID set_verify_mode( verify_mode v, boost::system::error_code& ec) { core_.engine_.set_verify_mode(v, ec); BOOST_ASIO_SYNC_OP_VOID_RETURN(ec); }
/// Send a break sequence to the serial port. BOOST_ASIO_SYNC_OP_VOID send_break(implementation_type& impl, boost::system::error_code& ec) { service_impl_.send_break(impl, ec); BOOST_ASIO_SYNC_OP_VOID_RETURN(ec); }
BOOST_ASIO_SYNC_OP_VOID get_option(const implementation_type& impl, GettableSerialPortOption& option, boost::system::error_code& ec) const { service_impl_.get_option(impl, option, ec); BOOST_ASIO_SYNC_OP_VOID_RETURN(ec); }
BOOST_ASIO_SYNC_OP_VOID io_control(IoControlCommand& command, boost::system::error_code& ec) { this->get_service().io_control(this->get_implementation(), command, ec); BOOST_ASIO_SYNC_OP_VOID_RETURN(ec); }
/// Open a serial port. BOOST_ASIO_SYNC_OP_VOID open(implementation_type& impl, const std::string& device, boost::system::error_code& ec) { service_impl_.open(impl, device, ec); BOOST_ASIO_SYNC_OP_VOID_RETURN(ec); }
/** * This function causes all outstanding asynchronous read or write operations * to finish immediately, and the handlers for cancelled operations will be * passed the boost::asio::error::operation_aborted error. * * @param ec Set to indicate what error occurred, if any. */ BOOST_ASIO_SYNC_OP_VOID cancel(boost::system::error_code& ec) { this->get_service().cancel(this->get_implementation(), ec); BOOST_ASIO_SYNC_OP_VOID_RETURN(ec); }
/* * This function opens the handle to hold an existing native handle. * * @param handle A native handle. * * @param ec Set to indicate what error occurred, if any. */ BOOST_ASIO_SYNC_OP_VOID assign(const native_handle_type& handle, boost::system::error_code& ec) { this->get_service().assign(this->get_implementation(), handle, ec); BOOST_ASIO_SYNC_OP_VOID_RETURN(ec); }
/// Close the stream. BOOST_ASIO_SYNC_OP_VOID close(boost::system::error_code& ec) { stream_impl_.close(ec); BOOST_ASIO_SYNC_OP_VOID_RETURN(ec); }
/** * This function removes the specified signal from the set. It has no effect * if the signal is not in the set. * * @param signal_number The signal to be removed from the set. * * @param ec Set to indicate what error occurred, if any. * * @note Removes any notifications that have been queued for the specified * signal number. */ BOOST_ASIO_SYNC_OP_VOID remove(int signal_number, boost::system::error_code& ec) { this->get_service().remove(this->get_implementation(), signal_number, ec); BOOST_ASIO_SYNC_OP_VOID_RETURN(ec); }
/** * This function is used to perform a blocking wait for a descriptor to enter * a ready to read, write or error condition state. * * @param w Specifies the desired descriptor state. * * @param ec Set to indicate what error occurred, if any. * * @par Example * Waiting for a descriptor to become readable. * @code * boost::asio::posix::stream_descriptor descriptor(io_context); * ... * boost::system::error_code ec; * descriptor.wait(boost::asio::posix::stream_descriptor::wait_read, ec); * @endcode */ BOOST_ASIO_SYNC_OP_VOID wait(wait_type w, boost::system::error_code& ec) { this->get_service().wait(this->get_implementation(), w, ec); BOOST_ASIO_SYNC_OP_VOID_RETURN(ec); }
/// Assign an existing native handle to a serial port. BOOST_ASIO_SYNC_OP_VOID assign(implementation_type& impl, const native_handle_type& handle, boost::system::error_code& ec) { service_impl_.assign(impl, handle, ec); BOOST_ASIO_SYNC_OP_VOID_RETURN(ec); }
/// Close the stream. BOOST_ASIO_SYNC_OP_VOID close(boost::system::error_code& ec) { next_layer_.close(ec); BOOST_ASIO_SYNC_OP_VOID_RETURN(ec); }