MyTcpSocket* MyTcpSocket::acceptClient(string& clientHostName)
{
int newSocket; // the new socket file descriptor returned by the accept systme call
// the length of the client's address
struct sockaddr_in clientAddress; // Address of the client that sent data
int clientAddressLen = sizeof(struct sockaddr_in);
// Accepts a new client connection and stores its socket file descriptor
try
{
if ((newSocket = accept(m_nSocketId, (struct sockaddr *)&clientAddress,&clientAddressLen)) == -1)
{
#ifdef WINDOWS_XP
int errorCode = 0;
string errorMsg = "error calling accept(): \n";
detectErrorAccept(&errorCode,errorMsg);
MyException socketAcceptException(errorCode,errorMsg);
throw socketAcceptException;
#endif
#ifdef UNIX
MyException unixSocketAcceptException(0,"unix: error calling accept()");
throw unixSocketAcceptException;
#endif
}
}
catch(MyException& excp)
{
excp.response();
return NULL;
}
// Get the host name given the address
char *sAddress = inet_ntoa((struct in_addr)clientAddress.sin_addr);
/*******MyHostInfo from ADDRESS**********/
MyHostInfo clientInfo(string(sAddress),ADDRESS);
char* hostName = clientInfo.getHostName();
clientHostName+= string(hostName);
// Create and return the new MyTcpSocket object
MyTcpSocket* retSocket = new MyTcpSocket();
//保存与客户端通信的句柄
retSocket->setSocketId(newSocket);
return retSocket;
}
void OscarConnection::processNewConnection()
{
AbstractConnection::processNewConnection();
const ClientInfo &info = clientInfo();
FLAP flap(0x01);
flap.append<quint32>(0x01);
flap.appendTLV<QByteArray>(0x0006, m_auth_cookie);
flap.appendTLV<QByteArray>(0x0003, info.id_string);
flap.appendTLV<quint16>(0x0017, info.major_version);
flap.appendTLV<quint16>(0x0018, info.minor_version);
flap.appendTLV<quint16>(0x0019, info.lesser_version);
flap.appendTLV<quint16>(0x001a, info.build_number);
flap.appendTLV<quint16>(0x0016, info.id_number);
flap.appendTLV<quint32>(0x0014, info.distribution_number);
flap.appendTLV<QByteArray>(0x000f, info.language);
flap.appendTLV<QByteArray>(0x000e, info.country);
// Unknown shit
flap.appendTLV<quint8>(0x0094, 0x00);
flap.appendTLV<quint32>(0x8003, 0x00100000);
send(flap);
}
void TCPServer::connectClient()
{
emit info(classname, "adding new connection");
// Create socket and client
while(server->hasPendingConnections())
{
QTcpSocket *socket = server->nextPendingConnection();
QObject::connect(socket, SIGNAL(disconnected()), this, SLOT(disconnectClient()));
socketMap[socket] = socket;
TCPClient *client = new TCPClient(this);
client->connect(socket);
QObject::connect(client, SIGNAL(dataReceived(QByteArray)), this, SLOT(clientDataReceived(QByteArray)));
QObject::connect(client, SIGNAL(info(QString,QString)), this, SLOT(clientInfo(QString,QString)));
QObject::connect(client, SIGNAL(warning(QString,QString)), this, SLOT(clientWarning(QString,QString)));
QObject::connect(client, SIGNAL(error(QString,QString)), this, SLOT(clientError(QString,QString)));
clientMap[socket] = client;
}
emit connectionCount(socketMap.size());
}
void addAllowedClientCertificate(const String& host, const String& certificate, const String& key)
{
clientCertificate clientInfo(certificate, key);
allowedClientHosts.set(host.lower(), clientInfo);
}
GLDEF_C TInt E32Main()
{
RTest test(_L("T_SVRPINNING...main"));
test.Title();
if (DPTest::Attributes() & DPTest::ERomPaging)
test.Printf(_L("Rom paging supported\n"));
if (DPTest::Attributes() & DPTest::ECodePaging)
test.Printf(_L("Code paging supported\n"));
if (DPTest::Attributes() & DPTest::EDataPaging)
{
test.Printf(_L("Data paging supported\n"));
gDataPagingSupport = ETrue;
}
// Determine the data paging attribute.
RProcess process; // Default to point to current process.
gProcessPaged = process.DefaultDataPaged();
test.Printf(_L("Process data paged %x\n"), gProcessPaged);
test.Start(_L("Test IPC message arguments pinning"));
test_KErrNone(HAL::Get(HAL::EMemoryPageSize, gPageSize));
gPageMask = gPageSize - 1;
test_Equal(KPageSize, gPageSize);
// Disable JIT as we are testing panics and don't want the emulator to hang.
TBool justInTime = User::JustInTime();
User::SetJustInTime(EFalse);
TBool exitFailure = EFalse;
for ( gServerPinningState = EServerDefault;
gServerPinningState < EServerSetPinningTooLate && !exitFailure;
gServerPinningState++)
{
// Create the server with the specified pinning mode.
switch (gServerPinningState)
{
case EServerDefault :
test.Next(_L("Test server with default pinning policy"));
break;
case EServerPinning :
test.Next(_L("Test server with pinning policy"));
break;
case EServerNotPinning :
test.Next(_L("Test server with not pinning policy"));
break;
}
test_KErrNone(gSem.CreateLocal(0));
test_KErrNone(gSem1.CreateLocal(0));
// Create the server thread it needs to have a unpaged stack and heap.
TThreadCreateInfo serverInfo(_L("Server Thread"), ServerThread, KDefaultStackSize, (TAny*)gServerPinningState);
serverInfo.SetPaging(TThreadCreateInfo::EUnpaged);
serverInfo.SetCreateHeap(KHeapMinSize, KHeapMaxSize);
RThread serverThread;
test_KErrNone(serverThread.Create(serverInfo));
TRequestStatus serverStat;
serverThread.Logon(serverStat);
serverThread.Resume();
// Wait for the server to start and then create a session to it.
gSem.Wait();
RSession session;
test_KErrNone(session.PublicCreateSession(_L("CTestServer"),5));
for ( TUint clientTest = CTestSession::ETestRdPinAll;
clientTest <= CTestSession::ETestPinDefault && !exitFailure;
clientTest++)
{
// Create the client thread it needs to have a paged stack and heap.
TThreadCreateInfo clientInfo(_L("Client Thread"), ClientThread, 10 * gPageSize, (TAny*)clientTest);
clientInfo.SetPaging(TThreadCreateInfo::EPaged);
clientInfo.SetCreateHeap(KHeapMinSize, KHeapMaxSize);
RThread clientThread;
test_KErrNone(clientThread.Create(clientInfo));
TRequestStatus clientStat;
clientThread.Logon(clientStat);
clientThread.Resume();
// Wait for the client thread to end.
User::WaitForRequest(clientStat);
// If all the descriptor arguments were not pinned then the client
// thread should have been panicked.
TBool expectPanic = (clientTest == CTestSession::ETestRdPinAll ||
clientTest == CTestSession::ETestWrPinAll ||
clientTest == CTestSession::ETestPinOOM )? 0 : 1;
expectPanic = !UpdateExpected(!expectPanic);
TInt exitReason = clientThread.ExitReason();
TInt exitType = clientThread.ExitType();
if (expectPanic)
{
if (exitType != EExitPanic ||
exitReason != EIllegalFunctionForRealtimeThread ||
clientThread.ExitCategory() != _L("KERN-EXEC"))
{
test.Printf(_L("Thread didn't panic as expected\n"));
exitFailure = ETrue;
}
}
else
{
if (exitType != EExitKill || exitReason != KErrNone)
{
test.Printf(_L("Thread didn't exit gracefully as expected\n"));
exitFailure = ETrue;
}
}
test(!exitFailure);
CLOSE_AND_WAIT(clientThread);
}
test.Next(_L("Test client sending message to closed server"));
TThreadCreateInfo clientInfo(_L("Client Thread"), ClientThread, 10 * gPageSize, (TAny*)CTestSession::ETestDeadServer);
clientInfo.SetPaging(TThreadCreateInfo::EPaged);
clientInfo.SetCreateHeap(KHeapMinSize, KHeapMaxSize);
RThread clientThread;
test_KErrNone(clientThread.Create(clientInfo));
TRequestStatus clientStat;
clientThread.Logon(clientStat);
clientThread.Resume();
gSem.Wait();
// Signal to stop ActiveScheduler and wait for server to stop.
session.PublicSendReceive(CTestSession::EStop, TIpcArgs());
session.Close();
User::WaitForRequest(serverStat);
if (serverThread.ExitType() != EExitKill)
{
test.Printf(_L("!!Server thread did something bizarre %d\n"), serverThread.ExitReason());
}
gSem1.Signal();
User::WaitForRequest(clientStat);
test_Equal(EExitKill, clientThread.ExitType());
test_Equal(KErrServerTerminated, clientThread.ExitReason());
CLOSE_AND_WAIT(clientThread);
CLOSE_AND_WAIT(serverThread);
CLOSE_AND_WAIT(gSem);
CLOSE_AND_WAIT(gSem1);
}
test.Next(_L("Test server setting pinning policy after server started"));
RThread serverThread;
test_KErrNone(serverThread.Create(_L("Server Thread"),ServerThread,KDefaultStackSize,KHeapMinSize,KHeapMaxSize, (TAny*)gServerPinningState));
TRequestStatus serverStat;
serverThread.Logon(serverStat);
serverThread.Resume();
// The server should have panicked with E32USER-CBase 106.
User::WaitForRequest(serverStat);
TInt exitReason = serverThread.ExitReason();
TInt exitType = serverThread.ExitType();
test_Equal(EExitPanic, exitType);
test_Equal(ECServer2InvalidSetPin, exitReason);
if (_L("E32USER-CBase") != serverThread.ExitCategory())
test(0);
CLOSE_AND_WAIT(serverThread);
test.End();
// Set JIT back to original state.
User::SetJustInTime(justInTime);
return (KErrNone);
}
