/*
* 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 ();
}
