int Sockets_manager::AcceptFromHost(void)
{
Socket* skt;
char ip[16];
skt = this->GetHostSocket();
if (skt != NULL)
{
int fdmax;
fd_set fdread;
struct timeval timeout;
fdmax = skt->fd + 1;
FD_ZERO(&fdread);
FD_SET(skt->fd, &fdread);
timeout.tv_sec = 0;
timeout.tv_usec = 0;
if (select(fdmax, &fdread, 0, 0, &timeout) == -1)
return -1;
if (FD_ISSET(skt->fd, &fdread))
{
skt->Accept(&fdmax, ip);
if (fdmax != -1)
{
skt = NULL;
while (skt == NULL)
skt = new Socket(fdmax, ip);
this->clientSockets.push_back(skt);
return 1;
}
}
}
return 0;
}
int main(int argc, char **argv)
{
print("151 - TCP Server | Centhra Engine v%s\n", getVersionString().c_str());
Socket *server = Socket::Create(Socket::IP4, Socket::Stream, Socket::TCP, true);
server->Bind(12345);
server->Listen(16);
while(true)
{
Socket *client = server->Accept();
if(client)
{
char buff[1024];
memset(buff, 0, 1024);
client->Read(buff, 1024);
print("Receiving Msg: %s\n", buff);
client->Shutdown();
delete client;
}
sleepMS(16);
}
delete server;
return 0;
}
int Socket_accept(Context* ctx, Value& self)
{
Socket* socket = static_cast<Socket*>(self.val.object);
Socket* retSock = 0;
SocketAddress* retAddr = 0;
if (socket->Accept(&retSock, &retAddr)) {
ctx->Push(retSock);
ctx->Push(retAddr);
} else {
ctx->PushNull();
ctx->PushNull();
}
return 2;
}
/*
* Start job handler thread
*/
void* StartJobHandler(void* thread_args){
int listen_port = *(int*) thread_args;
std::cout << "StartJobHandler(" << listen_port << ")\n";
//
// Server socket
//
try {
Socket server;
if (!server.Create() ) {
throw SocketException ( "Could not create server socket." );
}
if (!server.Bind(listen_port)) {
throw SocketException ( "Could not bind to port." );
}
std::cout << "bind done" << std::endl;
if ( ! server.Listen() ) {
throw SocketException ( "Could not listen to socket." );
}
std::cout << "Waiting for incoming connections..." << std::endl;
while ( true ) {
Socket *client_sock = new Socket();
std::cout << "before accept\n";
//server.accept ( new_sock );
if ( ! server.Accept(*client_sock )) {
delete client_sock;
throw SocketException ( "Could not accept socket." );
}
std::cout << "Connection accepted" << std::endl;
pthread_t sniffer_thread;
//thrd_args->socket = &client_sock;
if (pthread_create(&sniffer_thread , NULL , JobHandlerConnectionHandler , (void*)client_sock) < 0) {
//perror("could not create thread");
std::cout << "could not create thread\n";
delete client_sock;
continue;
}
//Now join the thread , so that we dont terminate before the thread
//pthread_join( sniffer_thread , NULL);
std::cout <<"Handler assigned" << std::endl;
}
} catch ( SocketException& e ) {
std::cout << "Exception was caught:" << e.description() << "\nExiting.\n";
}
return NULL;
}
unsigned long THREAD_FUNC SocketSubsystem::ListeningThread( void* Arg )
{
SocketSubsystem* Subsystem = (SocketSubsystem*)Arg;
ThreadStartupData StartupData;
memset( &StartupData, 0, sizeof( StartupData ) );
Subsystem->mListeningMutex.Aquire();
Array<ThreadStartupData>& StartupDataList = Subsystem->mThreadStartupData;
for( size_t i = 0; i < StartupDataList.Length(); ++i )
{
if( !StartupDataList[i].IsClaimed )
{
StartupDataList[i].IsClaimed = TRUE;
StartupData = StartupDataList[i];
}
}
Subsystem->mListeningMutex.Release();
assert( StartupData.IsClaimed && StartupData.Socket != NULL && "Couldn't find startup data for socket listening thread" );
Socket* ListeningSocket = StartupData.Socket;
UBOOL ContinueListening = TRUE;
while( ContinueListening && !fPendingDestroy )
{
// Blocking call
ListeningSocket->Listen();
// If we get here, we have gotten a new connection, accept it
Socket* NewSocket = ListeningSocket->Accept();
if( NewSocket != NULL && !fPendingDestroy )
{
Subsystem->mConnectionMutex.Aquire();
Subsystem->mNewConnections.AddItem( NewSocket );
Subsystem->mConnectionMutex.Release();
}
else if( NewSocket != NULL )
{
// CLEANUP, we allocated a socket while shutting down
delete NewSocket;
}
Sleep( 10 );
}
return 0;
}
void EpollFrame::NewConnectMonitor()
{
#ifndef WIN32
int nCount = MAXPOLLSIZE;
epoll_event *events = new epoll_event[nCount]; //epoll事件
int i = 0;
Socket listenSock;
Socket clientSock;
while ( !m_stop )
{
nCount = MAXPOLLSIZE;
if ( !((EpollMonitor*)m_pNetMonitor)->WaitConnect( events, nCount, -1 ) ) break;
for ( i = 0; i < nCount; i++ )
{
if ( ((EpollMonitor*)m_pNetMonitor)->IsStop(events[i].data.u64) )
{
delete[]events;
return;
}
listenSock.Detach();
listenSock.Attach((SOCKET)events[i].data.u64);
while ( true )
{
listenSock.Accept( clientSock );
if ( INVALID_SOCKET == clientSock.GetSocket() )
{
clientSock.Detach();
break;
}
OnConnect(clientSock.Detach(), false);
}
if ( !m_pNetMonitor->AddAccept( listenSock.GetSocket() ) )
{
printf( "AddAccept (%d) error \n", listenSock.GetSocket() );
listenSock.Close();
}
}
}
delete[]events;
#endif
}
bool SocketCom::Open()
{
if (server)
{
#ifdef TRACE
printf("Opening server\n");
#endif
Socket listener;
if (!listener.Create()) return false;
#ifdef TRACE
printf("Create OK\n");
#endif
if (!listener.Bind(port)) return false;
#ifdef TRACE
printf("Binding OK\n");
#endif
if (!listener.Listen()) return false;
#ifdef TRACE
printf("Listening OK\n");
#endif
if (!listener.Accept(*this)) return false;
#ifdef TRACE
printf("Accept OK\n");
#endif
}
else
{
#ifdef TRACE
printf("Opening client %s:%d\n",host,port);
#endif
if (!Create()) return false;
#ifdef TRACE
printf("Create OK\n");
#endif
if (!Connect(host,port)) return false;
#ifdef TRACE
printf("Connect OK\n");
#endif
SetNonBlocking(true);
}
return true;
}
void* EpollMonitor::WaitAcceptEvent( void *pData )
{
#ifndef WIN32
epoll_event *events = new epoll_event[m_nMaxMonitor]; //epoll事件
Socket sock;
Socket sockClient;
SOCKET hSock;
/* 等待有事件发生 */
while ( !m_bStop )
{
int nPollCount = epoll_wait(m_hEPollAccept, events, m_nMaxMonitor, -1 );
if ( -1 == nPollCount ) break;
/* 处理所有事件，nfds 为返回发生事件数 */
int i = 0;
for ( i = 0; i < nPollCount; i++ )
{
if ( m_epollExit == events[i].data.fd )
{
::closesocket(m_epollExit);
break;
}
sock.Detach();
sock.Attach(events[i].data.fd);
while ( true )
{
sock.Accept( sockClient );
if ( INVALID_SOCKET == sockClient.GetSocket() ) break;
sockClient.SetSockMode();
hSock = sockClient.Detach();
AddMonitor(hSock);
while ( !m_acceptEvents->Push((void*)hSock) ) m_sigWaitAcceptSpace.Wait();
m_ioSignal.Notify();
}
}
}
delete[]events;
#endif
return NULL;
}
//
// Main function
//
int main (int argc, char **argv) {
// Get hostname
std::string hostname = SystemCommandUtils::Exec("hostname");
std::cout << "Host name: " << hostname.c_str() << std::endl;
// Redirect cout to log file <programe name>.stdout;
char* app_name = argv[0];
std::stringstream ss;
ss << app_name << kLogExtension;
std::string log_filename = ss.str();
g_log_redirector = NULL;
std::ofstream log_strm(log_filename.c_str());
g_log_redirector = new StreamRedirector(std::cout, log_strm.rdbuf());
ss.str("");
ss << app_name << kErrExtension;
std::string err_filename = ss.str();
g_err_redirector = NULL;
std::ofstream err_strm(err_filename.c_str());
g_err_redirector = new StreamRedirector(std::cerr, err_strm.rdbuf());
std::cout << "Host name: " << hostname.c_str() << std::endl;
// Create job home path
std::string homepath = getenv("HOME");
g_home_job_dir = homepath + kJobDirName;
std::cout << "Home job: " << g_home_job_dir << std::endl;
if (argc < 2) {
std::cout << "kdeskdaemon <port no>\n";
delete g_err_redirector;
delete g_log_redirector;
return 1;
}
//
// Server socket
//
try {
// Create the socket
//ServerSocket server ( 30000 );
Socket server;
g_kdesk_port = atoi(argv[1]);
if (!server.Create() ) {
throw SocketException ( "Could not create server socket." );
}
if (!server.Bind(g_kdesk_port)) {
throw SocketException ( "Could not bind to port." );
}
std::cout << "bind done" << std::endl;
if ( ! server.Listen() ) {
throw SocketException ( "Could not listen to socket." );
}
std::cout << "Waiting for incoming connections..." << std::endl;
while ( true ) {
Socket* client_sock = new Socket();
std::cout << "before accept\n";
//server.accept ( new_sock );
if ( ! server.Accept(*client_sock)) {
delete client_sock;
throw SocketException ( "Could not accept socket." );
}
std::cout << "Connection accepted" << std::endl;
//ConnectionHandler((void*)&client_sock);
//continue;
pthread_t sniffer_thread;
//thrd_args->socket = &client_sock;
if (pthread_create( &sniffer_thread , NULL , ConnectionHandler , (void*)client_sock) < 0) {
//perror("could not create thread");
std::cout << "could not create thread\n";
continue;
}
//Now join the thread , so that we dont terminate before the thread
//pthread_join( sniffer_thread , NULL);
std::cout <<"Handler assigned" << std::endl;
}
} catch ( SocketException& e ) {
std::cout << "Exception was caught:" << e.description() << "\nExiting.\n";
}
if(g_log_redirector != NULL)
delete g_log_redirector;
if(g_err_redirector != NULL)
delete g_err_redirector;
return 0;
}
bool STNetEngine::LinuxIO( int timeout )
{
#ifndef WIN32
int nCount = 0;
int eventType = 0;
int i = 0;
Socket sockListen;
Socket sockClient;
SOCKET sock;
map<SOCKET,int>::iterator it;
pair<map<SOCKET,int>::iterator,bool> ret;
//没有可io的socket则等待新可io的socket
//否则检查是否有新的可io的socket，有则取出加入到m_ioList中，没有也不等待
//继续进行m_ioList中的socket进行io操作
if ( 0 >= m_ioList.size() ) nCount = m_pNetMonitor->WaitEvent( timeout );
else nCount = m_pNetMonitor->WaitEvent( 0 );
if ( 0 > nCount ) return false;
//加入到m_ioList中
for ( i = 0; i < nCount; i++ )
{
sock = m_pNetMonitor->GetSocket(i);
if ( INVALID_SOCKET == sock ) return false;//STEpoll已关闭
if ( m_pNetMonitor->IsAcceptAble(i) )//连接类型直接执行业务
{
while ( true )
{
sockListen.Detach();
sockListen.Attach(sock);
sockListen.Accept( sockClient );
if ( INVALID_SOCKET == sockClient.GetSocket() ) break;
sockClient.SetSockMode();
OnConnect(sockClient.Detach(), false);
}
continue;
}
//不是监听socket一定是io事件
//加入到io列表，统一调度
if ( m_pNetMonitor->IsWriteAble(i) ) eventType = 1|2;//recv+send事件
else eventType = 1;//recv事件
ret = m_ioList.insert(map<SOCKET,int>::value_type(sock,eventType) );//增加可io的对象
if ( !ret.second ) ret.first->second = ret.first->second|eventType;//设置新事件
}
//遍历m_ioList，执行1次io
for ( it = m_ioList.begin(); it != m_ioList.end(); it++ )
{
if ( 1&it->second ) //可读
{
if ( ok != OnData( it->first, 0, 0 ) ) //数据已读完或连接已断开
{
it->second = it->second&~1;//清除事件
}
}
if ( 2&it->second ) //可写
{
if ( ok != OnSend( it->first, 0 ) )//数据已经发送完，或socket已经断开，或socket不可写
{
it->second = it->second&~2;//清除事件
}
}
}
//将不可io的socket清除
it = m_ioList.begin();
while ( it != m_ioList.end() )
{
if ( 0 == it->second )
{
m_ioList.erase(it);
it = m_ioList.begin();
continue;
}
it++;
}
return true;
#endif
return false;
}
