void Horus::Commons::Network::StreamServer::start() { if (m_running) return; boost::asio::ip::tcp::resolver resolver(m_acceptor.get_io_service()); boost::asio::ip::tcp::resolver::query query( m_address.toStdString(), m_port.toStdString()); try { boost::asio::ip::tcp::endpoint endpoint = *resolver.resolve(query); m_acceptor.open(endpoint.protocol()); m_acceptor.set_option(boost::asio::ip::tcp::acceptor::reuse_address(true)); m_acceptor.bind(endpoint); m_acceptor.listen(); m_running = true; emit startSuccess(); startAccept(); } catch (std::exception& e) { Q_UNUSED(e); emit startFailure(); } }
void Server::handleAccept (const boost::system::error_code& ec) { if (!ec) m_conn->start (); startAccept (); }
void Server::start(unsigned short port) { MLOG_MESSAGE(Debug, "start(" << port << ")"); nexus::listen(acceptor_, port); startAccept(); }
void KinectServer::handleAccept(KinectServerConnection::pointer new_connection, const boost::system::error_code& error) { if (!error) { new_connection->Start(); startAccept(); } }
void TcpServer::handleAccept( TcpConnection::SharedPtr newConnection, const boost::system::error_code &error ) { if(!error) { newConnection->start(); startAccept(); } }
ServeurCentral::ServeurCentral(boost::asio::io_service &io_service, int portecoute) : portecoute(portecoute), m_acceptor(io_service, tcp::endpoint(tcp::v4(), portecoute)), io_service(io_service) { cout << "Construction du serveur central" << std::endl; startAccept(); }
TcpServer::TcpServer( boost::asio::io_service &io , MessageHandler &msgHandler , unsigned int serverPort ) : m_acceptor(io, tcp::endpoint(tcp::v4(),serverPort)) , m_msgHandler(msgHandler) { startAccept(); }
void TcpServer::start() { running_ = true; startAccept(); init(); self_ = new std::thread(boost::bind(&boost::asio::io_service::run, &io_)); }
void Server::handleAccept(OnlineUser* newUser, const boost::system::error_code& error) { if (!error) { newUser->start(); } startAccept(); }
SecureNodeListProvider::SecureNodeListProvider(boost::asio::io_service &io_service, int portecoute) : portecoute(portecoute), m_acceptor(io_service, tcp::endpoint(tcp::v4(), portecoute)), io_service(io_service) { cout << "Construction du serveur de liste de noeud" << std::endl; startAccept(); }
void CS3100::ServerImpl::onAccept(boost::shared_ptr<CS3100::ConnectionImpl> connection, const boost::system::error_code& error) { if(!error) { boost::interprocess::scoped_lock<boost::mutex> lock(connectionListMutex); connectionList.push_back(boost::shared_ptr<CS3100::Connection>(new CS3100::Connection(connection))); } startAccept(); }
void EventManager::handleAccept(EventSystem::NetworkChannel::Pointer newConnection, const boost::system::error_code& error) { std::cout << "New Incoming connection" << std::endl; if (!error) { newConnection->startHandShake(); startAccept(); } }
void SecureNodeListProvider::handle_accept(Client<SecureNodeListProvider> *noeud, const boost::system::error_code &error) { if (!error) { std::cout << "Un client est accepté" << std::endl; toutlemonde.push_back(noeud); noeud->startRead(); startAccept(); } }
void TcpServer::createServer(int port, int) { tcp::endpoint endpoint(tcp::v4(), port); mPort = port; mAcceptor = boost::shared_ptr<tcp::acceptor>(new tcp::acceptor(mService, endpoint)); std::cout << "[TCP] start listening on port " << port << std::endl; startAccept(); boost::system::error_code ec; mService.run(ec); }
void ServeurCentral::handle_accept(Client<ServeurCentral> *noeud, const boost::system::error_code &error) { if (!error) { std::cout << "Un client est accepté !" << std::endl; toutlemonde.push_back(noeud); noeud->startRead(); startAccept(); } }
void GameServer::handleAccept(PlayerSession::ptr session, boost::system::error_code const& error) { if (!error) { session->start(); } startAccept(); }
void TCP_Async_Server::acceptHandle(TCPConnectionPtr newConnectionPtr, const boost::system::error_code& error) { if(!error) { std::cout << "Start handling request\n"; newConnectionPtr->start(); } waitingSocket--; if(waitingSocket == 0) startAccept(); }
void Server::initService() { startAccept(); for (int i = 0; i < 4; i++) { threads.create_thread( [&]() { ioService.run(); }); } //ioService.run(); }
void Server::handleAccept(const boost::system::error_code & error) { if (!error) { auto endp=newConnection_.get()->socket().remote_endpoint(); std::cout << "new connection from " <<endp.address() <<" at port " <<endp.port()<<std::endl; connectionManager_.start(newConnection_); } startAccept(); }
void TelnetServer::handleAccept(TelnetConnection::pointer newCon, const boost::system::error_code &err) { if (!err) { newCon->setupLineMode(); mNewConnectionHandler(newCon); newCon->startReceive(); } else { std::cerr << "handleAccept: " << err.message() << std::endl; } startAccept(); }
void PeerServer::handleAccept(PeerConnection::pointer conn, const boost::system::error_code &error) { if (!error) { conn->start(); // Go back accepting other connections startAccept(); } else { LOG(ERROR) << "Error accepting peer connection"; } }
void LBServer::handleAccept(WorkerConnection::pointer conn, const boost::system::error_code &error) { if (!error) { LOG(INFO) << "Connection received from " << conn->getSocket().remote_endpoint().address(); conn->start(); // Go back and accept another connection startAccept(); } else { LOG(ERROR) << "Error accepting worker connection"; } }
Server::Server () : m_acceptor (m_io) , m_dbMgr (new DBManager) { std::string address = "127.0.0.1"; ip::tcp::resolver resolver (m_io); ip::tcp::endpoint ep = *resolver.resolve (ip::tcp::resolver::query (address, "54093")); m_acceptor.open (ep.protocol()); m_acceptor.set_option (ip::tcp::acceptor::reuse_address (true)); m_acceptor.bind (ep); m_acceptor.listen (); startAccept (); }
AsyncServer::AsyncServer(const SmartMet::Spine::Options& theOptions, SmartMet::Spine::Reactor& theReactor) : Server(theOptions, theReactor), itsNewConnection(), itsMutex(), itsConnections(0) { try { // Fire the connect accept loop startAccept(); } catch (...) { throw SmartMet::Spine::Exception(BCP, "Operation failed!", NULL); } }
void Server::handleAccept(TCPConnection::Pointer_t newConnection, const boost::system::error_code &error) { if (verbose) { std::cout << "[Server] Incoming connection from " << newConnection->socket().remote_endpoint().address().to_string() << "." << std::endl; } if (!error) { newConnection->setParent(this); newConnection->start(); clients.insert(newConnection); } startAccept(); }
void Server::handleAccept(ServerConnectionPtr connection, const boost::system::error_code &error) { if (_acceptor.is_open()) { if (!error) { std::cout << "Connection accepted." << std::endl; bool acceptConnection = true; _onConnectionCreated(connection, acceptConnection); if(acceptConnection) connection->Start(); } startAccept(); } }
void Horus::Commons::Network::StreamServer::handleAccept(const boost::system::error_code &e) { if (m_manager->isNewConnectionAvailable() == false) { m_new_connection->socket().close(); return; } if (m_acceptor.is_open()==false) return; if (!e) m_manager->join(m_new_connection); startAccept(); }
//----------------------------------------------------------------------------- // Network stuff void EventManager::listen(const int port) { dbglog << "EventManager: Listening on port " << port << " ..."; boost::asio::ip::tcp::endpoint ep(boost::asio::ip::tcp::v4(), port); if (!mAcceptor) { mAcceptor = new boost::asio::ip::tcp::acceptor(mService, ep); startAccept(); } else { throw std::logic_error("EventManager::init(): Initialized twice!"); } }
void TcpServer::startAccept(void) { tcp::socket *socket = new tcp::socket(mService); mSockets.push_back(socket); mAcceptor->async_accept(*socket, [this](const boost::system::error_code& error) { if (!error) { if (mListener) mListener->onNewConnection(this); } else { std::cout << "[TCP] async_accept failed: " << error.message() << std::endl; delete this; } startAccept(); }); }
void Server::handleAccept(const boost::system::error_code & ec, const nexus::isocket & socket) { MLOG_MESSAGE(Info, "handleAccept(" << ec << ")"); if(!ec) { MLOG_MESSAGE(Debug, "accepted, local: " << (*socket)->local_endpoint() << ", remote: " << (*socket)->remote_endpoint()); (*socket)->set_option(boost::asio::ip::tcp::no_delay(true)); ConnectionPtr conn = new Connection(socket, handler_); conn->start(); startAccept(); } else { MLOG_MESSAGE(Warning, "Accept failed: " << ec << ", message: " << ec.message()); } }