void CTestConnectionHandler::OnMessage(BUF buf)
{
char data[1024];
CSocket& socket = GetSocket();
size_t msg_size = BUF_Read(buf, data, sizeof(data));
if (msg_size > 0) {
ERR_POST(Info << "Got \"" << string(data, msg_size) << "\"");
} else {
ERR_POST(Info << "Got empty line");
}
if (m_State != Read) {
ERR_POST(Info << "... ignored");
return;
}
socket.Write("Goodbye!\n", sizeof("Goodbye!\n") - 1);
socket.Close();
int this_client_number = m_Server->RegisterClient();
int max_number_of_clients = m_Server->GetMaxNumberOfClients();
ERR_POST(Info << "Processed " << this_client_number
<< "/" << max_number_of_clients);
if (this_client_number == max_number_of_clients) {
ERR_POST(Info << "All clients processed");
m_Server->RequestShutdown();
}
}
//
// Thread to run the server code
//
TInt ServerThread(TAny*)
{
RTest test(_L("T_SCHEDRACE server"));
test.Title();
// UserSvr::FsRegisterThread();
test.Start(_L("Create and install ActiveScheduler"));
CActiveScheduler* pScheduler = new CActiveScheduler;
test_NotNull(pScheduler);
CActiveScheduler::Install(pScheduler);
test.Next(_L("Creating and starting Server"));
CTestServer* pServer = new CTestServer(&test);
test_NotNull(pServer);
test_KErrNone(pServer->Start(KServerName)); // Starting a CServer2 also Adds it to the ActiveScheduler
test.Next(_L("Rendezvous with main thread, then Start ActiveScheduler"));
RThread self;
self.Rendezvous(KErrNone);
test.Printf(_L(" There might be something going on beneath this window\n"));
CActiveScheduler::Start();
// This code is not reached until the active scheduler exits.
test.Next(_L("Destroy Server and ActiveScheduler"));
delete pServer;
delete pScheduler;
test.Close();
return (KErrNone);
}
// ---------------------------------------------------------------------------
// CStunTurnTests::TestSetIncomingAddrL
// ---------------------------------------------------------------------------
//
void CStunTurnTests::TestSetIncomingAddrL()
{
RDebug::Print( _L( "\nTEST CASE: Set Incoming Address" ) );
if ( KProtocolInetTcp == iProtocol )
{
RDebug::Print( _L( "\nTEST CASE: Set Incoming Address - TCP" ) );
iNotificationIsOn = EFalse;
CTestServer* server = CTestServer::NewLC( this );
CTestClient* client = CTestClient::NewLC( this );
TInetAddr addr( KInetAddrLoop, KTestServerPort );
server->OpenL( addr, KTimeoutTime );
iWrapper->SetIncomingAddrL( addr );
//iWrapper->SetupTcpConnectionL( ETcpSetupActive, *this );
iIfStub.StartActiveSchedulerL( KRunningTime );
iNotificationIsOn = ETrue;
CleanupStack::PopAndDestroy( client );
CleanupStack::PopAndDestroy( server );
}
else
{
RDebug::Print( _L( "\nTEST CASE: Set Incoming Address - UDP" ) );
iWrapper->SetIncomingAddrL( TInetAddr( KIncomingAddr, KIncomingPort ) );
}
}
int main()
{
CTestServer* server = new CTestServer();
server->ServerStart();
delete server;
return 0;
}
void CTestConnectionHandler::OnOpen(void)
{
CRandom rng;
unsigned int delay = m_Server->GetRandomDelay();
m_AlarmTime.SetCurrent();
m_AlarmTime.AddTimeSpan(CTimeSpan(delay / 1000,
(delay % 1000) * 1000 * 1000));
m_State = Delay;
}
TInt ServerThread(TAny* aPinningAttrib)
//
// Passed as the server thread in 2 tests - sets up and runs CTestServer
//
{
RTest test(_L("T_SVRPINNING...server"));
CMyActiveScheduler* pScheduler = new CMyActiveScheduler;
if (pScheduler == NULL)
{
gSem.Signal();
test(0);
}
CActiveScheduler::Install(pScheduler);
CTestServer* pServer = new CTestServer(0);
if (pServer == NULL)
{
gSem.Signal();
test(0);
}
// Set the pinning attributes of the server.
TServerPinning pinningAttrib = (TServerPinning)(TInt)aPinningAttrib;
switch (pinningAttrib)
{
case EServerDefault :
case EServerSetPinningTooLate :
break;
case EServerPinning :
pServer->SetPinClientDescriptors(ETrue);
break;
case EServerNotPinning :
pServer->SetPinClientDescriptors(EFalse);
break;
default :
break;
}
//Starting a CServer2 also Adds it to the ActiveScheduler
TInt r = pServer->Start(KServerName);
if (r != KErrNone)
{
gSem.Signal();
test(0);
}
if (pinningAttrib == EServerSetPinningTooLate)
{
pServer->SetPinClientDescriptors(EFalse);
}
test.Next(_L("Start ActiveScheduler and signal to client"));
test.Printf(_L(" There might be something going on beneath this window\n"));
gSem.Signal();
CActiveScheduler::Start();
test.Next(_L("Destroy ActiveScheduler"));
delete pScheduler;
delete pServer;
test.Close();
return (KErrNone);
}
// ---------------------------------------------------------------------------
// CStunTurnTests::TestSetReceivingStatusTCPL
// ---------------------------------------------------------------------------
//
void CStunTurnTests::TestSetReceivingStatusTCPL()
{
// Connect wrapper to test server
CTestServer* server = CTestServer::NewLC( this );
TInetAddr addr( KInetAddrAny, KTestServerPort );
// stop scheduler when clients timer runs out
server->OpenL( addr, KTimeoutTime );
iNotificationIsOn = EFalse;
CTestClient* client = CTestClient::NewLC( this );
TInetAddr testServerAddr;
client->ResolveLocalAddrL( testServerAddr, iTestIapId );
testServerAddr.SetPort( KTestServerPort );
iWrapper->SetIncomingAddrL( testServerAddr );
iIfStub.StartActiveSchedulerL( KRunningTime );
iNotificationIsOn = ETrue;
// Set receiving status active
RDebug::Print( _L( "\nTEST CASE: Set Receiving Status Active" ) );
iNat.SetReceivingStateL( iIfStub.LocalCandidateL(),
EStreamingStateActive );
// connect test client to natfw
TInetAddr incomingAddr;
client->ResolveLocalAddrL( incomingAddr, iTestIapId );
incomingAddr.SetPort( 5000 );
TBuf<40> buffer;
incomingAddr.Output( buffer );
RDebug::Print(
_L( "CStunTurnTests::TestSetReceivingStatusTCPL; ADDR: %S PORT: %d" ),
&buffer ,incomingAddr.Port() );
client->OpenL( iTestIapId );
iIfStub.StartActiveSchedulerL();
// stop scheduler when clients timer runs out
client->ConnectL( incomingAddr, KTimeoutTime );
iNotificationIsOn = EFalse;
iIfStub.StartActiveSchedulerL( KRunningTime );
iNotificationIsOn = ETrue;
// Set receiving status passive
RDebug::Print( _L( "\nTEST CASE: Set Receiving Status Passive" ) );
iNat.SetReceivingStateL( iIfStub.LocalCandidateL(),
EStreamingStatePassive );
iIfStub.StartActiveSchedulerL( KRunningTime );
CleanupStack::PopAndDestroy( client );
CleanupStack::PopAndDestroy( server );
}
// ---------------------------------------------------------------------------
// CStunTurnTests::TestSetSendingStatusTCPL
// ---------------------------------------------------------------------------
//
void CStunTurnTests::TestSetSendingStatusTCPL()
{
TInetAddr inetAddr;
TBuf<40> buffer;
CTestClient* client = CTestClient::NewLC( this );
// testserver to wrapper
CTestServer* server = CTestServer::NewLC( this );
TInetAddr addr( KInetAddrAny, KTestServerPort );
// stop scheduler when server timer runs out
server->OpenL( addr, KTimeoutTime );
iNotificationIsOn = EFalse;
TInetAddr testServerAddr;
client->ResolveLocalAddrL( testServerAddr, iTestIapId );
testServerAddr.SetPort( KTestServerPort );
iWrapper->SetIncomingAddrL( testServerAddr );
iIfStub.StartActiveSchedulerL( KRunningTime );
iNotificationIsOn = ETrue;
// testserver to natfw
CTestServer* server2 = CTestServer::NewLC( this );
TInetAddr addr2( KInetAddrAny, KTestServer2Port );
server2->OpenL( addr2, KTimeoutTime );
TInetAddr destination;
client->ResolveLocalAddrL( destination, iTestIapId );
destination.SetPort( KTestServer2Port );
destination.Output( buffer );
RDebug::Print( _L( "CStunTurnTests::TestSetSendingStatusTCPL; ADDR: %S PORT: %d" ),
&buffer, destination.Port() );
// set sending status active
RDebug::Print( _L( "\nTEST CASE: Set Sending Status Active" ) );
iNat.SetSendingStateL( iIfStub.LocalCandidateL(), EStreamingStateActive,
destination );
iIfStub.StartActiveSchedulerL( KRunningTime );
server2->Cancel();
// set sending status passive
RDebug::Print( _L( "\nTEST CASE: Set Sending Status Passive" ) );
iNat.SetSendingStateL( iIfStub.LocalCandidateL(), EStreamingStatePassive,
destination );
iIfStub.StartActiveSchedulerL( KRunningTime );
CleanupStack::PopAndDestroy( server2 );
CleanupStack::PopAndDestroy( server );
CleanupStack::PopAndDestroy( client );
}
void main()
{
CTestServer *pServer = new CTestServer;
pServer->IniServer();
// 开启服务, 启动发送与接收队列及线程
if(pServer->Start() && pServer->StartupAllMsgThread())
{
printf(" 服务器开启成功... \n");
}
else
{
printf(" 服务器开启失败！\n");
return;
}
/*
getchar();
CIOCPContext *m_pCCon;
m_pCCon = pServer->GetConnectionList();
while(m_pCCon != NULL)
{
while(m_pCCon != NULL)
{
pServer->SendText(m_pCCon,"123456",6);
m_pCCon = m_pCCon->pNext;
}
m_pCCon = pServer->GetConnectionList();
Sleep(500);
}
*/
/*
getchar();
PACKET *lpPacket = pServer->AllocatePacket();
char *cNum = "54630";
memcpy(lpPacket->buf,cNum,strlen(cNum));
lpPacket->lpOCPContext = pServer->GetConnectionList();
while(lpPacket->lpOCPContext != NULL)
{
while(lpPacket->lpOCPContext != NULL)
{
pServer->SendPacket(lpPacket);
lpPacket->lpOCPContext = lpPacket->lpOCPContext->pNext;
}
lpPacket->lpOCPContext = pServer->GetConnectionList();
Sleep(500);
}
pServer->ReleasePacket(lpPacket);
*/
// 创建事件对象，让ServerShutdown程序能够关闭自己
HANDLE hEvent = ::CreateEvent(NULL, FALSE, FALSE, "ShutdownEvent");
::WaitForSingleObject(hEvent, INFINITE);
::CloseHandle(hEvent);
// 关闭服务
pServer->Shutdown();
delete pServer;
printf(" 服务器关闭 \n ");
}
