/* * This method has two functionalities * -It waits for incoming connections if local port is defined * -It tries to connect to remote host if local host is not defined */ void IPCommMonitorThread::Connect(Socket*& s) { // This trickery here is because if there are no sockets (Socket::nofSockets_) // WSACleanup gets called and then SOAP gets messed up. // And creating a new socket for a new connection seems to work better // than using the old when re-connecting / re-listening. Socket* new_s = new Socket(); delete s; s = new_s; // If local port is defined start open listening socket SocketServer ss; if( m_LocalPort ) { Util::Info("[IPComm] Listen for incoming connection..."); String remoteHost( "[IPComm] Connected! Remote host : " ); ss.Accept( s, m_LocalPort, 1, remoteHost ); Util::Info(remoteHost); } // If not start connecting else { Util::Info("[IPComm] Connecting..."); ss.Connect( s, m_RemoteHost.c_str(), m_RemotePort ); Util::Info("[IPComm] Connected!"); } }
void clientThread(int clientsock) { while (1) { if(g_server.getClient(clientsock).wantClose) break; std::string raw_buff; char buff[1024] = {0}; if(recv(clientsock, buff, sizeof(buff), 0)<=0){ break; } raw_buff += buff; do{ size_t endpos = raw_buff.find("$"); if (endpos==-1) break; const std::string msg = raw_buff.substr(0, endpos); raw_buff = raw_buff.substr(endpos+1); g_server.mtx.lock(); g_server.ondata(clientsock, msg); g_server.mtx.unlock(); }while(1); } g_server.rmClient(clientsock); }
void* SocketServer::sReadLoop(void* data){ SocketServer* pthis = (SocketServer*)data; pthis->ReadLoop(); return NULL; }
int EServer::StartEServer() { int res = -1; pthread_t sendThreadID, checkClientThreadID; pthread_create(&sendThreadID, NULL, SendThread, this); pthread_create(&checkClientThreadID, NULL, CheckClientStatus, this); socketServer.SetServer(atoi(EServerPort), Parallel); socketServer.setCallback(this); res = socketServer.StartServer(); cout << "Authentication Server Start Failed\n"; return res; }
int main () { Log l("server "); Registry::add("Test", new TestImpl()); // server EventDriver ed; SocketServer srv; srv.start(8091, &ed); ed.run(); return 0; }
bool initialize_socket_server () { String address = scim_get_default_helper_manager_socket_address (); __socket_timeout = scim_get_default_socket_timeout (); if (!__socket_server.create (SocketAddress (address))) return false; __socket_server.signal_connect_accept (slot (socket_accept_callback)); __socket_server.signal_connect_receive (slot (socket_receive_callback)); __socket_server.signal_connect_exception (slot (socket_exception_callback)); return true; }
int EServer::CallbackUpdateMessage(messageNode *recvMsg) { if (clientStatus[recvMsg->index] == Disconnected) { return 0; } messageNode *p = fakeAquireNewMessageSpace(); while (p == NULL) { usleep(10000); //sleep 10ms p = fakeAquireNewMessageSpace(); } int res = messageHanle.HandleMessage(recvMsg, p); if (res == 0) { if (p) { p = aquireNewMessageSpace(); if (p->idIndex == 0) { p->idIndex = idIndex[p->index]; } sem_post(&sendMsgInfo.sigMessage); } connectedTime[recvMsg->index] = time(NULL); } else { logControl.SaveToLog(LogLevelSave, "WARNING: message handle failed!!%d\n", res); socketServer.ForceDisconnectClient(recvMsg->index); } return 0; }
/* * Main Entry function */ int main(int argc, char** argv) { Order::init(); Currency *usd = new Currency("usd"); Currency *btc = new Currency("btc"); Currency *ltc = new Currency("ltc"); new Market(BTC_USD, usd, btc); new Market(LTC_USD, ltc, usd); new Market(BTC_LTC, btc, ltc); SocketServer *server = new SocketServer("/tmp/BitcoinTradeEngine.sock"); server->start(); Order::unInit(); return 0; }
bool TransporterRegistry::start_service(SocketServer& socket_server) { DBUG_ENTER("TransporterRegistry::start_service"); if (m_transporter_interface.size() > 0 && !nodeIdSpecified) { g_eventLogger.error("TransporterRegistry::startReceiving: localNodeId not specified"); DBUG_RETURN(false); } for (unsigned i= 0; i < m_transporter_interface.size(); i++) { Transporter_interface &t= m_transporter_interface[i]; unsigned short port= (unsigned short)t.m_s_service_port; if(t.m_s_service_port<0) port= -t.m_s_service_port; // is a dynamic port TransporterService *transporter_service = new TransporterService(new SocketAuthSimple("ndbd", "ndbd passwd")); if(!socket_server.setup(transporter_service, &port, t.m_interface)) { DBUG_PRINT("info", ("Trying new port")); port= 0; if(t.m_s_service_port>0 || !socket_server.setup(transporter_service, &port, t.m_interface)) { /* * If it wasn't a dynamically allocated port, or * our attempts at getting a new dynamic port failed */ g_eventLogger.error("Unable to setup transporter service port: %s:%d!\n" "Please check if the port is already used,\n" "(perhaps the node is already running)", t.m_interface ? t.m_interface : "*", t.m_s_service_port); delete transporter_service; DBUG_RETURN(false); } } t.m_s_service_port= (t.m_s_service_port<=0)?-port:port; // -`ve if dynamic DBUG_PRINT("info", ("t.m_s_service_port = %d",t.m_s_service_port)); transporter_service->setTransporterRegistry(this); } DBUG_RETURN(true); }
int PsCacheSetHandler::handle(PcMsg * msg , SocketServer & server , int peer) { PcMsgSetReq * set = (PcMsgSetReq *)msg; PcMsgSetRes res; COMMON_LOGGER_DEBUG("set command , %s %s\n" , set->getKey().c_str() , set->getValue().c_str()); int len = 0; #ifndef __STORAGE_FASTDB__ PsData * data = PsDataMgr::instance()->set(const_cast<char *>(set->getKey().c_str()) , const_cast<char *>(set->getValue().c_str()) , strlen(set->getValue().c_str())); if (data) { res.setCode(0); res.setDesc("success"); res.setValue(data->value); len += strlen(data->value); len += 4; } else { res.setCode(1); res.setDesc("failed"); } #else bool ret = PsDataMgr::instance()->set(const_cast<char *>(set->getKey().c_str()) , const_cast<char *>(set->getValue().c_str()) , strlen(set->getValue().c_str()) , -1); if (ret) { res.setCode(0); res.setDesc("success"); res.setValue(set->getValue()); len += strlen(set->getValue().c_str()); len += 4; } else { res.setCode(1); res.setDesc("failed"); } #endif res.setType(PSCACHE_MSG_SET_RES); res.setLength(80 + len); res.setVersion(msg->getVersion()); PscacheMsgResParser parser; char * buffer = new char[80 + len]; (void)memset(buffer , 0x00 , 80 + len); parser.compile(res , buffer); server.write(peer , buffer , 80 + len); delete [] buffer; return 0; }
void serverWaitClientThread() { while(1){ sockaddr_in addr; socklen_t len = sizeof(addr); int s = g_server.sock(); const int client = accept(s, (struct sockaddr*)&addr, &len); if(client==-1){ printf("%d=%s\n", errno, strerror(errno)); continue; } Client c{client, false}; g_server.mtx.lock(); g_server.onconnect(client); g_server.clients.push_back(c); g_server.mtx.unlock(); std::thread t(clientThread, client); t.detach(); } }
static void* serverCallback(void* arg) { try { ServerData* data = static_cast<ServerData*>(arg); SocketServer* server = new SocketServer; std::string host = "127.0.0.1"; if (!data->isServer) host = "127.0.0.2"; server->run(serverHandleCallback, host); delete server; data->serverThread->exit(); } catch (ISocket::Exception& e) { std::cerr << e.what() << std::endl; } return NULL; }
int main(void) { try { std::vector<DylThread*> vectorOfThreads; SocketServer servSock = SocketServer (2000); while (1) { std::cout << "I am a server!" << std::endl; //create a new socket Socket s = servSock.Accept(); // blocking call - waits for request //put that new socket into a thread DylThread *dThr = new DylThread(s, true); vectorOfThreads.push_back(dThr); std::cout << "hm +" << vectorOfThreads << std::endl; for (DylThread* i: vectorOfThreads) { std::cout << "hm " << i << std::endl; } } } // catch(...) catch(std::string e) { std::cout << e << " Caught unexpected exception" << std::endl; } }
void on_event(int sock, short event, void *arg) { Peer * peer = 0; if (sock == server.getHandle()) { int cfd = -1; if (-1 == (cfd = server.accept())) { COMMON_LOGGER_ERROR_S("accept failed\n"); return; } if (0 != (peer = server.findPeer(cfd))) { (void)event_set(peer->event() , cfd, EV_READ | EV_PERSIST , on_event , 0); (void)event_add(peer->event() , 0); } COMMON_LOGGER_DEBUG("accept peer %d OK.\n" , cfd); return; } else if ((peer = server.findPeer(sock)) != 0) { int ret = -1; if ((ret = server.read(sock)) == -1) { event_del(peer->event()); server.deletePeer(sock); COMMON_LOGGER_DEBUG("close socket %d\n" , sock); } return; } else { COMMON_LOGGER_INFO("total:%d get:%d set:%d del:%d rep:%d\n" , pscache_get_counter + pscache_set_counter + pscache_del_counter + pscache_rep_counter , pscache_get_counter , pscache_set_counter , pscache_del_counter , pscache_rep_counter); pscache_get_counter = pscache_set_counter = pscache_del_counter = pscache_rep_counter = 0; struct timeval tv; tv.tv_sec = DEFAULT_PSC_TIMEOUT; tv.tv_usec = 0; (void)event_add((struct event*)arg, &tv); return; } }
void Monitor::CreateSocketServer(MonitorConfiguration *config) { static SocketServer socketServer(config,0) ; static SocketServer fms32ProServer(config,1000) ; fms32ProServer.m_ServerModus = SocketThread::fms32pro ; static SocketServer crusaderServer(config,2000) ; crusaderServer.m_ServerModus = SocketThread::crusader ; socketServer.Start() ; fms32ProServer.Start() ; crusaderServer.Start() ; }
int PsCacheDelHandler::handle(PcMsg * msg , SocketServer & server , int peer) { PcMsgDelReq * del = (PcMsgDelReq *)msg; PcMsgDelRes res; COMMON_LOGGER_DEBUG("del command , %s\n" , del->getKey().c_str()); bool ret = PsDataMgr::instance()->del(const_cast<char *>(del->getKey().c_str())); int len = 0; if (ret) { res.setCode(0); res.setDesc("success"); res.setValue("null"); len += 4; len += strlen("null"); } else { res.setCode(1); res.setDesc("failed"); } res.setType(PSCACHE_MSG_DEL_RES); res.setLength(80 + len); res.setVersion(msg->getVersion()); PscacheMsgResParser parser; char * buffer = new char[80 + len]; parser.compile(res , buffer); server.write(peer , buffer , 80 + len); delete [] buffer; return 0; }
void Monitor::MainLoop() { // Soundkarte initialisieren InitSndCard() ; /********************************************************/ static SocketServer socketServer(&m_MonitorConfig,m_MonitorConfig.m_socketFilterFileName ,0) ; socketServer.Start() ; FILE_LOG(logINFO) << "monitord socketserver started" ; static SocketServer fms32ProServer(&m_MonitorConfig,m_MonitorConfig.m_socketFilterFileName ,1000) ; fms32ProServer.m_ServerModus=SocketThread::fms32pro ; fms32ProServer.Start() ; FILE_LOG(logINFO) << "fms32pro socketserver started" ; static SocketServer crusaderServer(&m_MonitorConfig,m_MonitorConfig.m_socketFilterFileName ,2000) ; crusaderServer.m_ServerModus=SocketThread::crusader ; crusaderServer.Start() ; FILE_LOG(logINFO) << "crusader socketserver started" ; /*******************************************************/ #ifdef PLUGINS //GetPluginsManager().loadPlugin("plugins/.libs/libmplugin_mysql-0.dll",NULL); GetPluginsManager().loadScriptFilter(m_MonitorConfig.m_pluginFilterFileName) ; GetPluginsManager().loadPluginsFromConfigNode(&m_MonitorConfig.m_configDataPlugins); FILE_LOG(logDEBUG) << "PluginManager started" ; #endif /*********************************************************/ while (!m_bWantStop) { /** * Wer sich fragt, wo eigentlich denn die Arbeit gemacht wird: * Die drei SocketServer sind eigenstaendige Threads. Die bedienen * die TCP/IP Verbindungen und laufen unabhaegig. * * Die eigentliche (Ton) Auswertung erfolgt in jeweils einem Thread * pro Soundkarte. Diese Threads werden im InitSndCard gestartet. * * Dann gibt es noch den GlobalDispatcher. Er ist auch ein eigenstaendiger * Thread. Er wird von dem Auswerten mit ResultSets versorgt. Die Auswerter * haben damit Ihren Teil erledigt. * Der Dispatcher verteilt dann die Results an alle Sockets und Plugins (ohne die * Auswerter zu blockieren) * */ usleep(100); // Wie man sieht: hier gibt es im Moment nichts zu tun :- } FILE_LOG(logINFO) << PACKAGE_NAME << " shutting down..." ; StopSndCard() ; FILE_LOG(logINFO) << "stopping socketserver monitord"; socketServer.m_bWantStop=true ; FILE_LOG(logINFO) << "stopping socketserver FMS32"; fms32ProServer.m_bWantStop=true ; FILE_LOG(logINFO) << "stopping socketserver Crusader"; crusaderServer.m_bWantStop=true ; usleep(1000) ; m_SignalStopped->SetSignal() ; usleep(500) ; FILE_LOG(logINFO) << "all done. " << PACKAGE_NAME << " exiting"; }
void* SocketServer::acceptHandler(void* param) { SocketServer* instance = (SocketServer*)param; instance->doAcceptLoop(); }
void* SocketServer::readHandler(void* param) { SocketServer* instance = (SocketServer*)param; instance->doReadLoop(); }
void* socketServerThread_C(void* _ss){ SocketServer * ss = (SocketServer *)_ss; ss->doRun(); return 0; }
int main(int argc, char *argv[]) { SocketServer* socketServer = new SocketServer(); socketServer->Start(MAX_CLIENT_COUNT); while (getch()!=27) {} }
int main (int argc, char * argv []) { int i = 0; bool daemon = true; while (i<argc) { if (++i >= argc) break; if (String ("-nd") == argv [i] || String ("--no-daemon") == argv [i]) { daemon = false; continue; } if (String ("-v") == argv [i] || String ("--verbose") == argv [i]) { if (++i >= argc) { std::cerr << "No argument for option " << argv [i-1] << "\n"; return -1; } DebugOutput::set_verbose_level (atoi (argv [i])); continue; } if (String ("-m") == argv [i] || String ("--mask") == argv [i]) { if (++i >= argc) { std::cerr << "No argument for option " << argv [i-1] << "\n"; return -1; } if (String (argv [i]) != "none") { std::vector<String> debug_mask_list; scim_split_string_list (debug_mask_list, argv [i], ','); DebugOutput::disable_debug (SCIM_DEBUG_AllMask); for (size_t j=0; j<debug_mask_list.size (); j++) DebugOutput::enable_debug_by_name (debug_mask_list [j]); } continue; } if (String ("-o") == argv [i] || String ("--output") == argv [i]) { if (++i >= argc) { std::cerr << "No argument for option " << argv [i-1] << "\n"; return -1; } DebugOutput::set_output (String (argv [i])); continue; } std::cerr << "Invalid command line option: " << argv [i] << "\n"; return -1; } //End of command line parsing. load_helper_modules (); if (!initialize_socket_server ()) { std::cerr << "Can't initialize SocketServer.\n"; return -1; } if (daemon) scim_daemon (); signal(SIGQUIT, signalhandler); signal(SIGTERM, signalhandler); signal(SIGINT, signalhandler); signal(SIGHUP, signalhandler); __socket_server.run (); SCIM_DEBUG_MAIN (1) << "exit scim-helper-manager.\n"; }
bool SocketConnection::read( SocketAcceptor& a, SocketServer& s ) { std::string msg; try { if ( !m_pSession ) { struct timeval timeout = { 1, 0 }; fd_set readset = m_fds; while( !readMessage( msg ) ) { int result = select( 1 + m_socket, &readset, 0, 0, &timeout ); if( result > 0 ) readFromSocket(); else if( result == 0 ) return false; else if( result < 0 ) return false; } m_pSession = Session::lookupSession( msg, true ); if( !isValidSession() ) { m_pSession = 0; if( a.getLog() ) { a.getLog()->onEvent( "Session not found for incoming message: " + msg ); a.getLog()->onIncoming( msg ); } } if( m_pSession ) m_pSession = a.getSession( msg, *this ); if( m_pSession ) m_pSession->next( msg, UtcTimeStamp() ); if( !m_pSession ) { s.getMonitor().drop( m_socket ); return false; } Session::registerSession( m_pSession->getSessionID() ); return true; } else { readFromSocket(); readMessages( s.getMonitor() ); return true; } } catch ( SocketRecvFailed& e ) { if( m_pSession ) m_pSession->getLog()->onEvent( e.what() ); s.getMonitor().drop( m_socket ); } catch ( InvalidMessage& ) { s.getMonitor().drop( m_socket ); } return false; }
int PsCacheGetHandler::handle(PcMsg * msg , SocketServer & server , int peer) { PcMsgGetReq * get = (PcMsgGetReq *)msg; PcMsgGetRes res; int len = 0; #ifndef __STORAGE_FASTDB__ PsData * data = PsDataMgr::instance()->get(const_cast<char *>(get->getKey().c_str())); if (data && data->value) { res.setCode(0); res.setDesc("found value by key"); res.setValue(data->value); len += 4; len += strlen(data->value); COMMON_LOGGER_DEBUG("get command , %s %s\n" , get->getKey().c_str() , data->value); } else { res.setCode(1); res.setDesc("can not found value by key"); COMMON_LOGGER_DEBUG("get command , %s null\n" , get->getKey().c_str()); } #else char value[102400] = {0}; bool ret = PsDataMgr::instance()->get(const_cast<char *>(get->getKey().c_str()) , value); if (ret) { res.setCode(0); res.setDesc("found value by key"); res.setValue(value); len += 4; len += strlen(value); COMMON_LOGGER_DEBUG("get command , %s %s\n" , get->getKey().c_str() , value); } else { res.setCode(1); res.setDesc("can not found value by key"); COMMON_LOGGER_DEBUG("get command , %s null\n" , get->getKey().c_str()); } #endif res.setType(PSCACHE_MSG_GET_RES); res.setLength(80 + len); res.setVersion(msg->getVersion()); PscacheMsgResParser parser; char * buffer = new char[80 + len]; parser.compile(res , buffer); server.write(peer , buffer , 80 + len); delete [] buffer; return 0; }
int main(int argc , char ** args) { if (argc < 3) { printf("Usage: pscache isDeamon port\n"); return -1; } if (atoi(args[1]) != 0) { init_daemon(); } (void)signal(SIGPIPE , SIG_IGN); if (-1 == PsCacheHandlerMgr::instance()->initialize()) { COMMON_LOGGER_ERROR_S("initialize handler mgr failed."); return -1; } if (0 != Logger::instance()->initialize("pscache")) { COMMON_LOGGER_ERROR_S("initialize failed.\n"); return -1; } #ifndef __STORAGE_FASTDB__ int pre_malloc_size = 5000000; if (argc == 4) { pre_malloc_size = atoi(args[3]); if (pre_malloc_size > 5000000) { pre_malloc_size = 5000000; } } COMMON_LOGGER_INFO("pre-malloc-size is %d\n" , pre_malloc_size); if (!PscMemMgr::instance()->initialize(pre_malloc_size)) { COMMON_LOGGER_ERROR_S("malloc memory failed.\n"); return -1; } #endif if (!PsDataMgr::instance()->initialize()) { COMMON_LOGGER_ERROR_S("init failed.\n"); return -1; } (void)event_init(); struct event evTime; (void)evtimer_set(&evTime, on_event, &evTime); struct timeval tv; tv.tv_sec = DEFAULT_PSC_TIMEOUT; tv.tv_usec = 0; (void)event_add(&evTime, &tv); int pcPort = atoi(args[2]); PsrHandlerMgr::instance()->initialize(pcPort); union ipu iptest; iptest.ip = getlocalhostip(); char localIp[32] = {0}; (void)sprintf(localIp , "%u.%u.%u.%u" , iptest.ipchar[0] , iptest.ipchar[1] , iptest.ipchar[2] , iptest.ipchar[3]); COMMON_LOGGER_DEBUG("local ip is %s, local port is %d\n" , localIp , pcPort); if (!PsrManager::instance()->initialize(localIp , pcPort)) { COMMON_LOGGER_ERROR_S("initialize psr mgr failed.\n"); return -1; } if (-1 == server.intialize(pcPort , socketCallback)) { COMMON_LOGGER_ERROR_S("create server failed.\n"); } (void)event_set(&svrEvt , server.getHandle(), EV_READ | EV_PERSIST, on_event , 0); (void)event_add(&svrEvt, 0); (void)event_dispatch(); return 0; }
int socketCallback(int sock , char * buffer) { PcMsg * pmsg = 0; unsigned int type = 0; (void)PcMsgUtil::parse(buffer + 4 , type); COMMON_LOGGER_DEBUG("type is %04X\n" , type); if (type == PSCACHE_MSG_GET_REQ) { pmsg = new PcMsgGetReq; pscache_get_counter ++; } else if (type == PSCACHE_MSG_SET_REQ) { pmsg = new PcMsgSetReq; pscache_set_counter ++; } else if (type == PSCACHE_MSG_DEL_REQ) { pmsg = new PcMsgDelReq; pscache_del_counter ++; } else if (type == PSCACHE_MSG_REP_REQ) { unsigned int number = 0; PcMsgUtil::parse(buffer + 8 , number); unsigned int subType = 0; PcMsgUtil::parse(buffer + 12 + number * 36 + 4 , subType); if (subType == PSCACHE_MSG_SET_REQ) { pmsg = new PcMsgSetReq; } else if (subType == PSCACHE_MSG_DEL_REQ) { pmsg = new PcMsgDelReq; } else { return 0; } PscacheMsgReqParser parser; parser.parse(buffer + 12 + number * 36 , *pmsg); if (pmsg->getType() == PSCACHE_MSG_SET_REQ) { PcMsgSetReq * set = (PcMsgSetReq *)pmsg; #ifndef __STORAGE_FASTDB__ PsDataMgr::instance()->set(const_cast<char *>(set->getKey().c_str()) , const_cast<char *>(set->getValue().c_str()) , strlen(set->getValue().c_str())); #else PsDataMgr::instance()->set(const_cast<char *>(set->getKey().c_str()) , const_cast<char *>(set->getValue().c_str()) , strlen(set->getValue().c_str()) , -1); #endif COMMON_LOGGER_DEBUG("replica set command , %s %s\n" , set->getKey().c_str() , set->getValue().c_str()); } else if (pmsg->getType() == PSCACHE_MSG_DEL_REQ) { PcMsgDelReq * del = (PcMsgDelReq *)pmsg; PsDataMgr::instance()->del(const_cast<char *>(del->getKey().c_str())); COMMON_LOGGER_DEBUG("replica del command , %s\n" , del->getKey().c_str()); } pscache_rep_counter ++; delete pmsg; char res[12] = {0}; unsigned int length = 12; int offset = 0; offset += PcMsgUtil::compile(res + offset , length); unsigned int type = PSCACHE_MSG_REP_RES; offset += PcMsgUtil::compile(res + offset , type); server.write(sock , res , 12); PcMsgUtil::parse(buffer , length); PsrHandlerMgr::instance()->handle(sock , buffer , length); return 0; } else if (type == PSCACHE_MSG_HB_REQ) { COMMON_LOGGER_INFO("get heart beat request from %d\n" , sock); char res[12] = {0}; PcMsgHBRes resp; int offset = 0; offset += PcMsgUtil::compile(res + offset , resp.getLength()); offset += PcMsgUtil::compile(res + offset , resp.getType()); offset += PcMsgUtil::compile(res + offset , resp.getVersion()); server.write(sock , res , offset); return 0; } else { COMMON_LOGGER_ERROR("invalid message %04X\n" , type); return 0; } if (type != PSCACHE_MSG_GET_REQ) { unsigned int length = 0; PcMsgUtil::parse(buffer , length); int rlen = 0; char * rbuffer = PsrManager::instance()->prepareRP(buffer , rlen); if (rbuffer == 0) { return 0; } PsrHandlerMgr::instance()->handle(sock , rbuffer , rlen); } PscacheMsgReqParser parser; parser.parse(buffer,*pmsg); PcHandler * handler = PsCacheHandlerMgr::instance()->getHandler(pmsg->getType()); if (handler && -1 == handler->handle(pmsg , server , sock)) { COMMON_LOGGER_ERROR("handle message failed, %04X.\n" , pmsg->getType()); } delete pmsg; return 0; }
/** * Entry point into kwbrouter application. */ int main (int argc, char* argv[]) { int rc = eERR_NONE; bool end_application = false; options_t options; ioloop_t mainloop; do { // all logs on log_set_mask(0xFFFFFFFF); log_msg(KWB_LOG_INFO, "kwbrouter..."); // set default options for kwbrouter set_options(&options, "", // no serial device 57600, // baudrate, if not given "/tmp/kwbr.usk", // default address of kwbrouter socket 0); // port 0: use unix sockets // parse and validate commandline options if (parse_commandline_options(argc, argv, &options) == false || validate_options(&options) == false) { print_usage(); rc = eERR_BAD_PARAMETER; break; } ioloop_init(&mainloop); Router* router = new Router(); RConnSerial* serconn = new RConnSerial(&mainloop); serconn->Open(options.serial_device, options.serial_baudrate); router->AddConnection(serconn); // open new server and let-every connection auto-connect to router create_unix_socket_file(&options); SocketServer* server = new SocketServer(&mainloop, router); server->Open(options.router_address, options.router_port); // RConnSocketServer server = new /* route_init(&router); // initialize network routing msg_s_init(&msg_socket); if ((rc = msg_s_open_server(&msg_socket, &mainloop, "/tmp/kwb.usk", 0)) != eERR_NONE) { break; } msg_s_set_incomming_handler(&msg_socket, handle_incomming_msg, &router); msg_s_set_newconnection_handler(&msg_socket, handle_new_connection, &router); // add route for every client of unix socket ep = msg_s_get_endpoint(&msg_socket, 0, eMSG_EP_COMM); // initialize bus routing msg_b_init(&msg_bus, 0); if (options.serial_device_set) { address = options.serial_device; port = options.serial_baudrate; serial = true; } else { address = options.vbusd_address; port = options.vbusd_port; serial = false; } rc = msg_b_open(&msg_bus, &mainloop, options.own_node_address, serial, address, port); if (rc != eERR_NONE) break; msg_b_set_incomming_handler(&msg_bus, handle_incomming_msg, &router); route_add(&router, 1, 65535, address, port, eROUTE_TYPE_SERIAL, &msg_bus); */ log_msg(KWB_LOG_STATUS, "entering mainloop...\n"); while (!end_application) { ioloop_run_once(&mainloop); } server->Close(); delete server; router->RemoveConnection(serconn); serconn->Close(); delete serconn; delete router; } while (0); return rc; }
int _tmain(int argc, _TCHAR* argv[]) { using namespace Framework; using namespace log4cplus; using namespace std; using namespace TcpSocketServerSide; using namespace Business; using namespace Business::Handlers; // configure log4cplus SharedAppenderPtr appender(new DailyRollingFileAppender(_T("Whisper.log"))); //tstring patternExp = _T("%-5p - %Y-%m-%d %H:%M:%S - %l - %m%n"); tstring patternExp = _T("%-5p - %D - %l - %m%n"); auto_ptr<Layout> layout(new PatternLayout(patternExp)); appender->setLayout(layout); Logger logger = Logger::getRoot(); logger.addAppender(appender); // configure Framework Configurations::BufferSize = 1024; Configurations::Logger = &logger; try{ ITaskFactory* taskFactory = new DefaultTaskFactory(1); SocketServer* server = new TcpSocketServer( "127.0.0.1", //"192.168.1.103",// 8888, taskFactory ); auto dispatcher = new TcpSocketEventDispatcher(*server); auto socketFactory = new TcpSocketFactory(); auto manager = new TcpConnectionManager(*server, *dispatcher, *socketFactory); auto handler = new WhisperSocketEventHandler(*server); auto serverEventHandler = new WhisperSocketEventHandler::ServerEventHandler( *server, *handler ); /* register message handler */ PacketDispatcher& packetDispatcher = handler->GetPacketDispatcher(); packetDispatcher.Register(new AuthenticateRequestHandler()); /* register message handler */ server->SetSocketEventDispatcher(dispatcher); server->SetConnectionManager(manager); server->SetSocketEventHandler(handler); server->SetServerEventHandler(serverEventHandler); server->Start(); /*Sleep(10*1000);*/ //server->Shutdown(); server->WaitForShutdown(); delete server; cout << " Server closed." << endl; } catch(std::exception &ex){ cout << ex.what() << endl; } cin.get(); return 0; }
int main( char inNumArgs, char **inArgs ) { if( inNumArgs < 2 ) { usage( inArgs[0] ); } if( inNumArgs > 3 ) { usage( inArgs[0] ); } char useFile = true; if( inNumArgs != 3 ) { useFile = false; } long port; int numRead = sscanf( inArgs[1], "%d", &port ); if( numRead != 1 ) { printf( "port number must be a valid integer: %s\n", inArgs[2] ); usage( inArgs[0] ); } File *outFile; FileOutputStream *outStream; if( useFile ) { outFile = new File( NULL, inArgs[2], strlen( inArgs[2] ) ); outStream = new FileOutputStream( outFile ); } SocketServer *server = new SocketServer( port, 1 ); printf( "listening for a connection on port %d\n", port ); Socket *sock = server->acceptConnection(); if( sock == NULL ) { printf( "socket connection failed\n" ); return( 1 ); } printf( "connection received\n" ); SocketStream *inStream = new SocketStream( sock ); unsigned long checksum = 0; unsigned char *buffer = new unsigned char[ BUFFER_SIZE ]; numRead = BUFFER_SIZE; int numWritten = BUFFER_SIZE; while( numWritten == numRead && numRead == BUFFER_SIZE ) { // read a buffer full of data from standard in numRead = inStream->read( buffer, BUFFER_SIZE ); // add the buffer to our checksum for( int i=0; i<numRead; i++ ) { checksum += buffer[i]; } if( useFile ) { // write the buffer out to our file stream numWritten = outStream->write( buffer, numRead ); } else { // write to std out numWritten = fwrite( buffer, 1, numRead, stdout ); } } if( numRead != numWritten ) { printf( "file output failed\n" ); } printf( "checksum = %d\n", checksum ); delete sock; delete server; delete inStream; if( useFile ) { delete outStream; delete outFile; } delete [] buffer; return 0; }
void signalhandler(int sig) { SCIM_DEBUG_MAIN (1) << "signalhandler ()\n"; __socket_server.shutdown (); }