C++ (Cpp) async_accept Examples

Example #1

File: binding_iocp.c Project: AltGr/opalang

value iocp_ml_accept(value ListenSocket)
{
  CAMLparam1(ListenSocket);
  CAMLlocal1(res);
  SOCKET so = Socket_val(ListenSocket);
  res = Val_int(async_accept(so));
  CAMLreturn(res);
}

Example #2

File: webserver.cpp Project: manzali/cmon

void webserver::handle_accept(boost::system::error_code const& err) {
  if (!err) {
    m_io_service.post(boost::bind(&handle_connection, m_new_socket));
    async_accept();
  } else {
    std::cerr << "Unhandled error in handle_accept\n";
  }
}

Example #3

File: acceptor.hpp Project: CuriousBoy0822/orchid

 void accept(socket_type& sock,CO co,boost::system::error_code& e) {
     BOOST_ASSERT(co != NULL);
     accept_handler<CO> handler(co,e);
     async_accept(sock, handler);
     ///////////////////////////////////
     co -> yield();
     ////////////////////////////////////
     if(e) {
         ORCHID_DEBUG("acceptor accept error: %s",e.message().c_str());
     }
     return;
 }

Example #4

File: server.cpp Project: 3Hren/elliptics

void server::listen() {
	while (!m_monitor.node()->need_exit) {
		try {
			async_accept();
			m_io_service.run();
		} catch (const std::exception &e) {
			dnet_log(m_monitor.node(), DNET_LOG_ERROR, "monitor: server: got exception: %s, restarting it", e.what());
		} catch (...) {
			dnet_log(m_monitor.node(), DNET_LOG_ERROR, "monitor: server: got unknown exception, restarting");
		}
	}
}

Example #5

File: tcp_listener.hpp Project: ichramm/cppmisc

 void async_accept()
 {
     tcp_connection::ptr connection = std::make_shared<tcp_connection>(ioservice_);
     acceptor_.async_accept(connection->socket(), [=](const boost::system::error_code& error) {
         if (error != 0) {
             connection_handler_(error, tcp_connection::ptr());
         } else {
             connection_handler_(std::move(error), std::move(connection));
             async_accept();
         }
     });
 }

Example #6

File: rawsocket_listener.hpp Project: Afra-Felix/bonefish

inline void rawsocket_listener::handle_accept(
        const boost::system::error_code &error_code)
{
    if (error_code) {
        return;
    }

    assert(get_accept_handler());
    const auto& accept_handler = get_accept_handler();
    accept_handler(create_connection());

    async_accept();
}

Example #7

File: controller.hpp Project: amedama41/allium

 void async_accept()
 {
     auto socket = std::make_shared<tcp::socket>(*io_service_);
     acceptor_.async_accept(*socket, [=](boost::system::error_code const& error) mutable {
         if (!error) {
             send_hello(std::move(socket));
         }
         else {
             std::cout << "accept error: " << error.message() << std::endl;
         }
         async_accept();
     });
 }

Example #8

File: uds_listener.cpp Project: Afra-Felix/bonefish

void uds_listener::start_listening()
{
    if (is_listening()) {
        return;
    }

    unlink(m_endpoint.path().c_str());
    m_acceptor.open(m_endpoint.protocol());
    m_acceptor.set_option(
           boost::asio::local::stream_protocol::acceptor::reuse_address(true));
    m_acceptor.bind(m_endpoint);
    m_acceptor.listen();

    assert(get_accept_handler());
    set_listening(true);
    async_accept();
}

Example #9

File: server.hpp Project: maydayzm/Bex

        // 接受连接请求回调
        void on_async_accept(error_code const& ec, socket_ptr sp)
        {
            if (ec)
            {
                if (BOOST_INTERLOCKED_DECREMENT(&accept_count_) == 1 && shutdowning_.is_set())
                    shutdown_sessions();

                return ;
            }

            async_accept(true);

            /// create session
            session_type * session_p = allocate<session_type, allocator>();
            session_ptr session(session_p, BEX_IO_BIND(&this_type::session_deleter, this, _1), allocator());
            session_p->initialize(sp, opts_, callback_);
            session_mgr_.insert(session);
        }

Example #10

File: tcp_listener.cpp Project: VinnyOG/bonefish

void tcp_listener::start_listening()
{
    assert(get_error_handler());
    assert(get_accept_handler());

    if (is_listening()) {
        return;
    }

    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();

    set_listening(true);
    async_accept();
}

Example #11

File: LuaDebug.cpp Project: JohnCrash/iRobot

void LuaDebug::listener()
{
	async_accept();

	mIos.run();
}