C++ tcp::acceptor类代码示例

 void start_listening() {
     using boost::asio::ip::tcp;
     system::error_code error;
     tcp::resolver resolver(service_);
     tcp::resolver::query query(address_, port_);
     tcp::resolver::iterator endpoint_iterator = resolver.resolve(query, error);
     if (error) {
         NETWORK_MESSAGE("Error resolving address: " << address_ << ':' << port_);
         return;
     }
     tcp::endpoint endpoint = *endpoint_iterator;
     acceptor_.open(endpoint.protocol(), error);
     if (error) {
         NETWORK_MESSAGE("Error opening socket: " << address_ << ':' << port_ << " -- reason: '" << error << '\'');
         return;
     }
     socket_options_base::acceptor_options(acceptor_);
     acceptor_.bind(endpoint, error);
     if (error) {
         NETWORK_MESSAGE("Error binding to socket: " << address_ << ':' << port_ << " -- reason: '" << error << '\'');
         return;
     }
     acceptor_.listen(tcp::socket::max_connections, error);
     if (error) {
         NETWORK_MESSAGE("Error listening on socket: " << address_ << ':' << port_ << " -- reason: '" << error << '\'');
         return;
     }
     new_connection.reset(new sync_connection<Tag,Handler>(service_, handler_));
     acceptor_.async_accept(new_connection->socket(),
         boost::bind(&sync_server_base<Tag,Handler>::handle_accept,
                     this, boost::asio::placeholders::error));
     listening_ = true;
 }

	~PrivateData()
	{
		if ( m_success )
		{
			m_acceptor.cancel();
			m_acceptor.close();
			m_thread.join();
		}
	}

void InitTCPServer(boost::asio::ip::tcp::acceptor& server, int server_port) {
  boost::system::error_code server_ec;
  boost::asio::ip::tcp::endpoint server_ep(boost::asio::ip::tcp::v4(),
                                           server_port);
  server.open(boost::asio::ip::tcp::v4(), server_ec);
  ASSERT_EQ(0, server_ec.value()) << "Could not open server acceptor";
  server.bind(server_ep, server_ec);
  ASSERT_EQ(0, server_ec.value()) << "Could not bind server acceptor";
  server.listen(boost::asio::socket_base::max_connections, server_ec);
  ASSERT_EQ(0, server_ec.value()) << "Server acceptor could not listen";
}

 void
 on_accept(error_code ec)
 {
     if(! acceptor_.is_open())
         return;
     maybe_throw(ec, "accept");
     static int id_ = 0;
     std::thread{lambda{++id_, *this, std::move(sock_)}}.detach();
     acceptor_.async_accept(sock_,
         std::bind(&http_sync_server::on_accept, this,
             asio::placeholders::error));
 }

	PrivateData( int portNumber ) :
		m_success(false),
		m_endpoint(tcp::v4(), portNumber),
		m_service(),
		m_acceptor( m_service ),
		m_thread()
	{
		m_acceptor.open(  m_endpoint.protocol() );
		m_acceptor.set_option( boost::asio::ip::tcp::acceptor::reuse_address(true));
		m_acceptor.bind( m_endpoint );
		m_acceptor.listen();
		m_success = true;
	}

 inline accepting_source::element_type *
 accepting_source::copy_next(iterator_range<element_type *> destination)
 {
     assert(m_acceptor);
     assert(m_yield);
     for (auto &client : destination)
     {
         assert(m_acceptor);
         client = std::make_shared<boost::asio::ip::tcp::socket>(
             m_acceptor->get_io_service());
         assert(m_yield);
         m_acceptor->async_accept(*client, *m_yield);
     }
     return destination.end();
 }

 /// Handle a request to stop the server.
 virtual void handle_stop() {
     // The server is stopped by cancelling all outstanding asynchronous
     // operations. Once all operations have finished the io_service::run() call
     // will exit.
     m_acceptor.close();
     base_t::handle_stop();
 }

	void start_accept()
	{
		using namespace std;
		using namespace boost::asio::ip;

		auto connection = make_shared<tcp_connection>(_acceptor.get_io_service());
		_acceptor.async_accept(connection->socket(), [connection, this](const boost::system::error_code &ec)
		{
			if (!ec)
			{
				connection->send_string();
			}

			this->start_accept();
		});
	}

 void Release() {
   acceptor->close();
   delete acceptor;
   (*socket_pptr)->close();
   delete *socket_pptr;
   delete socket_pptr;
 }

 void start()
 {
     session * new_session( new session( io_service_) );
     acceptor_.async_accept(
         new_session->socket(),
         boost::bind( & server::handle_accept_, this->shared_from_this(),
             new_session, boost::asio::placeholders::error) );
 }

    /** Open a listening port.

        @param ep The address and port to bind to.

        @param ec Set to the error, if any occurred.
    */
    void
    open(tcp::endpoint const& ep, error_code& ec)
    {
        acceptor_.open(ep.protocol(), ec);
        if(ec)
            return fail("open", ec);
        acceptor_.set_option(
            boost::asio::socket_base::reuse_address{true});
        acceptor_.bind(ep, ec);
        if(ec)
            return fail("bind", ec);
        acceptor_.listen(
            boost::asio::socket_base::max_connections, ec);
        if(ec)
            return fail("listen", ec);
        do_accept();
    }

	inline void server::handle_accept(const boost::system::error_code& e) {
	    if (!e) {
		new_connection_->start();
		new_connection_.reset(new connection(io_service_, request_handler_));
		acceptor_.async_accept(new_connection_->socket(),
				       boost::bind(&server::handle_accept, this,
						   boost::asio::placeholders::error));
	    }
	}

	void start_accept()
	{
		boost::shared_ptr<session> new_session =
			boost::make_shared<session>(boost::ref(io_service_));
		acceptor_.async_accept(new_session->socket_,
			boost::bind(&server::handle_accept, this,
				boost::asio::placeholders::error,
				new_session));
	}

	sock_handle_t start_accept()
	{
		sock_handle_t handle = next_unused_tcp();
		if (!socket_handle_valid(handle))
			return handle;

		ip::tcp::socket& sock = tcp_from(handle);
		acceptor.accept(sock);
		return handle;
	}

 void handle_accept(boost::system::error_code const & ec) {
     if (!ec) {
         socket_options_base::socket_options(new_connection->socket());
         new_connection->start();
         new_connection.reset(new sync_connection<Tag,Handler>(service_, handler_));
         acceptor_.async_accept(new_connection->socket(),
             boost::bind(&sync_server_base<Tag,Handler>::handle_accept,
                         this, boost::asio::placeholders::error));
     }
 }