bool bind(endpoint_type& endpoint)
		{
			return socket_ops::bind(
				_socket,
				endpoint.data(),
				endpoint.size());
		}

 void listen(endpoint_type const & endpoint, boost::system::error_code & ec, bool reuse_addr = true)
 {
     if (endpoint.protocol() == protocol_type::v4())
         v4_type::listen(endpoint, ec, reuse_addr);
     if (endpoint.protocol() == protocol_type::v6())
         v6_type::listen(endpoint, ec, reuse_addr);
 }

 // Connect the socket to the specified endpoint.
 asio::error_code connect(implementation_type& impl,
     const endpoint_type& peer_endpoint, asio::error_code& ec)
 {
   socket_ops::sync_connect(impl.socket_,
       peer_endpoint.data(), peer_endpoint.size(), ec);
   return ec;
 }

    explicit
    socket(endpoint_type endpoint) {
        typename endpoint_type::protocol_type protocol = endpoint.protocol();

        m_fd = ::socket(protocol.family(), protocol.type(), protocol.protocol());

        if(m_fd == -1) {
            throw std::system_error(errno, std::system_category(), "unable to create a socket");
        }

        medium_type::configure(m_fd);

        if(::connect(m_fd, endpoint.data(), endpoint.size()) != 0) {
            auto ec = std::error_code(errno, std::system_category());

            ::close(m_fd);

            throw std::system_error(
                ec,
                cocaine::format("unable to connect a socket to '%s'", endpoint)
            );
        }

        ::fcntl(m_fd, F_SETFD, FD_CLOEXEC);
        ::fcntl(m_fd, F_SETFL, O_NONBLOCK);
    }

  /// Bind the fiber acceptor to the specified local endpoint.
  boost::system::error_code bind(implementation_type& impl,
                                 const endpoint_type& endpoint,
                                 boost::system::error_code& ec) {
    impl->p_fib_demux = &(endpoint.demux());
    impl->p_fib_demux->bind(endpoint.port(), impl, ec);

    return ec;
  }

    static inline
    void
    pack(msgpack::packer<Stream>& target, const endpoint_type& source) {
        const std::string address = source.address().to_string();
        const unsigned short port = source.port();

        type_traits<tuple_type>::pack(target, tuple_type(address, port));
    }

  size_t send_to(implementation_type& impl, const ConstBufferSequence& buffers,
      const endpoint_type& destination, socket_base::message_flags flags,
      asio::error_code& ec)
  {
    buffer_sequence_adapter<asio::const_buffer,
        ConstBufferSequence> bufs(buffers);

    return socket_ops::sync_sendto(impl.socket_, impl.state_,
        bufs.buffers(), bufs.count(), flags,
        destination.data(), destination.size(), ec);
  }

    static inline
    void
    unpack(const msgpack::object& source, endpoint_type& target) {
        std::string address;
        unsigned short port;

        type_traits<tuple_type>::unpack(source, std::move(std::tie(address, port)));

        target.address(boost::asio::ip::address::from_string(address));
        target.port(port);
    }

  // Resolve an endpoint to a list of entries.
  iterator_type resolve(implementation_type&,
      const endpoint_type& endpoint, asio::error_code& ec)
  {
    char host_name[NI_MAXHOST];
    char service_name[NI_MAXSERV];
    socket_ops::sync_getnameinfo(endpoint.data(), endpoint.size(),
        host_name, NI_MAXHOST, service_name, NI_MAXSERV,
        endpoint.protocol().type(), ec);

    return ec ? iterator_type() : iterator_type::create(
        endpoint, host_name, service_name);
  }

		ssize_t sendto(
			endpoint_type& to,
			void* buffer,
			size_t len
		)
		{
			return detail::socket_ops::sync_sendto(
				_socket,
				buffer,
				len,
				0,
				to.data(),
				to.size());
		}

 virtual request_t build_request(endpoint_type ep, error_code & ec)
 {
     request_t rc = request_t();
     if(!ep.address().is_v4())
     {
         ec = error_code(boost::asio::error::address_family_not_supported);
         return rc;
     }
     rc.detail.version = 4;
     rc.detail.command = 1;
     rc.detail.destination_port = ::htons(ep.port());
     rc.detail.destination_address = ep.address().to_v4().to_bytes();
     rc.detail.end_marker = 0;
     return rc;
 }

		ssize_t recvfrom(
			endpoint_type& from,
			void* buffer,
			size_t len
		)
		{
			socklen_t size = from.size();
			return detail::socket_ops::sync_recvfrom(
				_socket,
				buffer,
				len,
				0,
				from.data(),
				&size);
		}

	void async_connect(endpoint_type const& endpoint, Handler const& handler)
	{
		// make sure we don't try to connect to INADDR_ANY. binding is fine,
		// and using a hostname is fine on SOCKS version 5.
		TORRENT_ASSERT(m_command == socks5_bind
			|| endpoint.address() != address()
			|| (!m_dst_name.empty() && m_version == 5));

		m_remote_endpoint = endpoint;

		// the connect is split up in the following steps:
		// 1. resolve name of proxy server
		// 2. connect to proxy server
		// 3. if version == 5:
		//   3.1 send SOCKS5 authentication method message
		//   3.2 read SOCKS5 authentication response
		//   3.3 send username+password
		// 4. send SOCKS command message

		// to avoid unnecessary copying of the handler,
		// store it in a shaed_ptr
		boost::shared_ptr<handler_type> h(new handler_type(handler));

		ADD_OUTSTANDING_ASYNC("socks5_stream::name_lookup");
		tcp::resolver::query q(m_hostname, to_string(m_port).elems);
		m_resolver.async_resolve(q, boost::bind(
			&socks5_stream::name_lookup, this, _1, _2, h));
	}

  void async_connect(implementation_type& impl,
      const endpoint_type& peer_endpoint, Handler& handler)
  {
    // Allocate and construct an operation to wrap the handler.
    typedef win_iocp_socket_connect_op<Handler> op;
    typename op::ptr p = { asio::detail::addressof(handler),
      op::ptr::allocate(handler), 0 };
    p.p = new (p.v) op(impl.socket_, handler);

    ASIO_HANDLER_CREATION((io_context_, *p.p, "socket",
          &impl, impl.socket_, "async_connect"));

    start_connect_op(impl, impl.protocol_.family(), impl.protocol_.type(),
        peer_endpoint.data(), static_cast<int>(peer_endpoint.size()), p.p);
    p.v = p.p = 0;
  }

    boost::system::error_code
    bind
        ( endpoint_type const& e )
    {
        // Only fixed port is handled right now.
        if ( e.port() != FIXED_PORT )
            return make_error_code( boost::system::errc::invalid_argument );

        // Generate our local address.
        if ( e.address().is_v4() )
            local_endpoint( generate_unique_ipv4_endpoint( e.port() ) );
        else
            local_endpoint( generate_unique_ipv6_endpoint( e.port() ) );

        add_route_to_socket( local_endpoint(), this );
        return boost::system::error_code();
    }

  size_t receive_from(implementation_type& impl,
      const MutableBufferSequence& buffers,
      endpoint_type& sender_endpoint, socket_base::message_flags flags,
      asio::error_code& ec)
  {
    buffer_sequence_adapter<asio::mutable_buffer,
        MutableBufferSequence> bufs(buffers);

    std::size_t addr_len = sender_endpoint.capacity();
    std::size_t bytes_recvd = socket_ops::sync_recvfrom(
        impl.socket_, impl.state_, bufs.buffers(), bufs.count(),
        flags, sender_endpoint.data(), &addr_len, ec);

    if (!ec)
      sender_endpoint.resize(addr_len);

    return bytes_recvd;
  }

  void async_connect(implementation_type& impl,
      const endpoint_type& peer_endpoint, Handler& handler)
  {
    bool is_continuation =
      asio_handler_cont_helpers::is_continuation(handler);

    // Allocate and construct an operation to wrap the handler.
    typedef reactive_socket_connect_op<Handler> op;
    typename op::ptr p = { asio::detail::addressof(handler),
      op::ptr::allocate(handler), 0 };
    p.p = new (p.v) op(impl.socket_, handler);

    ASIO_HANDLER_CREATION((p.p, "socket", &impl, "async_connect"));

    start_connect_op(impl, p.p, is_continuation,
        peer_endpoint.data(), peer_endpoint.size());
    p.v = p.p = 0;
  }

 /**
  * This function is used to connect a socket to the specified remote endpoint.
  * The function call will block until the connection is successfully made or
  * an error occurs.
  *
  * The socket is automatically opened if it is not already open. If the
  * connect fails, and the socket was automatically opened, the socket is
  * not returned to the closed state.
  *
  * @param peer_endpoint The remote endpoint to which the socket will be
  * connected.
  *
  * @throws boost::system::system_error Thrown on failure.
  *
  * @par Example
  * @code
  * boost::asio::ip::tcp::socket socket(io_service);
  * boost::asio::ip::tcp::endpoint endpoint(
  *     boost::asio::ip::address::from_string("1.2.3.4"), 12345);
  * socket.connect(endpoint);
  * @endcode
  */
 void connect(const endpoint_type& peer_endpoint)
 {
   boost::system::error_code ec;
   if (!is_open())
   {
     this->service.open(this->implementation, peer_endpoint.protocol(), ec);
     boost::asio::detail::throw_error(ec);
   }
   this->service.connect(this->implementation, peer_endpoint, ec);
   boost::asio::detail::throw_error(ec);
 }

 /**
  * This function is used to connect a socket to the specified remote endpoint.
  * The function call will block until the connection is successfully made or
  * an error occurs.
  *
  * The socket is automatically opened if it is not already open. If the
  * connect fails, and the socket was automatically opened, the socket is
  * not returned to the closed state.
  *
  * @param peer_endpoint The remote endpoint to which the socket will be
  * connected.
  *
  * @throws asio::system_error Thrown on failure.
  *
  * @par Example
  * @code
  * asio::ip::tcp::socket socket(io_service);
  * asio::ip::tcp::endpoint endpoint(
  *     asio::ip::address::from_string("1.2.3.4"), 12345);
  * socket.connect(endpoint);
  * @endcode
  */
 void connect(const endpoint_type& peer_endpoint)
 {
   asio::error_code ec;
   if (!is_open())
   {
     this->get_service().open(this->get_implementation(),
         peer_endpoint.protocol(), ec);
     asio::detail::throw_error(ec, "connect");
   }
   this->get_service().connect(this->get_implementation(), peer_endpoint, ec);
   asio::detail::throw_error(ec, "connect");
 }

  void async_send_to(implementation_type& impl,
      const ConstBufferSequence& buffers, const endpoint_type& destination,
      socket_base::message_flags flags, Handler& handler)
  {
    // Allocate and construct an operation to wrap the handler.
    typedef win_iocp_socket_send_op<ConstBufferSequence, Handler> op;
    typename op::ptr p = { asio::detail::addressof(handler),
      op::ptr::allocate(handler), 0 };
    p.p = new (p.v) op(impl.cancel_token_, buffers, handler);

    ASIO_HANDLER_CREATION((io_context_, *p.p, "socket",
          &impl, impl.socket_, "async_send_to"));

    buffer_sequence_adapter<asio::const_buffer,
        ConstBufferSequence> bufs(buffers);

    start_send_to_op(impl, bufs.buffers(), bufs.count(),
        destination.data(), static_cast<int>(destination.size()),
        flags, p.p);
    p.v = p.p = 0;
  }