// Misc
void BF3CommandHandler::parseServerInfoCommand(const FrostbiteRconPacket &packet, const FrostbiteRconPacket &lastSentPacket)
{
Q_UNUSED(lastSentPacket);
QString response = packet.getWord(0).getContent();
if (response == "OK" && packet.getWordCount() > 1) {
QString serverName = packet.getWord(1).getContent();
int playerCount = FrostbiteUtils::toInt(packet.getWord(2).getContent());
int maxPlayerCount = FrostbiteUtils::toInt(packet.getWord(3).getContent());
QString gamemode = packet.getWord(4).getContent();
QString currentMap = packet.getWord(5).getContent();
int roundsPlayed = FrostbiteUtils::toInt(packet.getWord(6).getContent());
int roundsTotal = FrostbiteUtils::toInt(packet.getWord(7).getContent());
// Parsing team scores.
int entries = FrostbiteUtils::toInt(packet.getWord(8).getContent());
QList<int> scoreList;
int targetScore;
for (int i = 9; i < entries; i++) {
scoreList.append(FrostbiteUtils::toInt(packet.getWord(i).getContent()));
if (i == entries) {
targetScore = FrostbiteUtils::toInt(packet.getWord(i + 1).getContent());
}
}
TeamScores scores(scoreList, targetScore);
// Parsing online state.
QString onlineStateString = packet.getWord(12).getContent();
OnlineState onlineState;
if (onlineStateString == "NotConnected") {
onlineState = OnlineState::NotConnected;
} else if (onlineStateString == "ConnectedToBackend") {
onlineState = OnlineState::ConnectedToBackend;
} else if (onlineStateString == "AcceptingPlayers") {
onlineState = OnlineState::AcceptingPlayers;
}
bool ranked = FrostbiteUtils::toBool(packet.getWord(13).getContent());
bool punkBuster = FrostbiteUtils::toBool(packet.getWord(14).getContent());
bool hasGamePassword = FrostbiteUtils::toBool(packet.getWord(15).getContent());
int serverUpTime = FrostbiteUtils::toInt(packet.getWord(16).getContent());
int roundTime = FrostbiteUtils::toInt(packet.getWord(17).getContent());
QString gameIpAndPort = packet.getWord(18).getContent();
QString punkBusterVersion = packet.getWord(19).getContent();
bool joinQueueEnabled = FrostbiteUtils::toBool(packet.getWord(20).getContent());
QString region = packet.getWord(21).getContent();
QString closestPingSite = packet.getWord(22).getContent();
QString country = packet.getWord(23).getContent();
bool matchMakingEnabled = FrostbiteUtils::toBool(packet.getWord(24).getContent());
Frostbite2ServerInfo serverInfo(
serverName,
playerCount,
maxPlayerCount,
gamemode,
currentMap,
roundsPlayed,
roundsTotal,
scores,
onlineState,
ranked,
punkBuster,
hasGamePassword,
serverUpTime,
roundTime,
gameIpAndPort,
punkBusterVersion,
joinQueueEnabled,
region,
closestPingSite,
country,
matchMakingEnabled
);
emit (onServerInfoCommand(serverInfo));
}
}
int main()
{
// Initialize the winsock library
MyTcpSocket::initialize();
// get client's information (assume neither the name nor the address is given)
winLog << endl;
winLog << "Retrieve the localHost [CLIENT] name and address:" << endl;
winLog.flush();
//以下是客户端程序，所有服务器IP从配置文件中读取
//*********************************************************************************
// 【①】 客户端HostInfo(hostent)
MyHostInfo clientInfo;
string clientName = clientInfo.getHostName();
string clientIPAddress = clientInfo.getHostIPAddress();
cout << "Name: " << clientName << endl;
cout << "Address: " << clientIPAddress << endl;
winLog << " ==> Name: " << clientName << endl;
winLog << " ==> Address: " << clientIPAddress << endl;
//*********************************************************************************
// get server's IP address and name 【服务器IP，从配置文件读取】
string serverIPAddress = "";
readServerConfig(serverIPAddress);
winLog << endl;
winLog << "Retrieve the remoteHost [SERVER] name and address:" << endl;
winLog << " ==> the given address is " << serverIPAddress << endl;
// 【②】 服务器端HostInfo(hostent)
MyHostInfo serverInfo(serverIPAddress,ADDRESS);
string serverName = serverInfo.getHostName();
cout << "Name: " << serverName << endl;
cout << "Address: " << serverIPAddress << endl;
winLog << " ==> Name: " << serverName << endl;
winLog << " ==> Address: " << serverIPAddress << endl;
//*********************************************************************************
// create the socket for client
MyTcpSocket myClient(PORTNUM);
cout << myClient;
winLog << "client configuation: " << endl;
winLog << myClient;
//*********************************************************************************
// connect to the server.
cout << "connecting to the server [" << serverName << "] ... " << endl;
winLog << "connecting to the server [" << serverName << "] ... " << endl;
myClient.connectToServer(serverIPAddress,ADDRESS);
int recvBytes = 0;
while (1)
{
// send message to server
char messageToServer[MAX_MSG_LEN+1];
memset(messageToServer,0,sizeof(messageToServer));
cout << "[SEND] ";
cin.getline(messageToServer,MAX_MSG_LEN);
winLog << "[SEND] " << messageToServer << endl;
myClient.sendMessage(string(messageToServer));
if ( !string(messageToServer).compare("Quit") || !string(messageToServer).compare("quit") ) break;
// receive message from server
string messageFromServer = "";
recvBytes = myClient.recieveMessage(messageFromServer);
if ( recvBytes == -99 ) break;
cout << "[RECV:" << serverName << "]: " << messageFromServer << endl;
winLog << "[RECV:" << serverName << "]: " << messageFromServer << endl;
}
return EXIT_SUCCESS;
}
shared_ptr<ServerInfo>
ServerTargetResolver::GetFixedSMTPHostForDomain_(const String &sDomain)
//---------------------------------------------------------------------------()
// DESCRIPTION:
// Check if there exists a fixed SMTP host for the domain given, and in that
// case it returns it. May be used for example for routes or when a SMTP
// relayer is used.
//---------------------------------------------------------------------------()
{
String sSMTPHost;
long lPort = 0;
String sUsername;
String sPassword;
ConnectionSecurity connection_security = CSNone;
shared_ptr<SMTPConfiguration> pSMTPConfig = Configuration::Instance()->GetSMTPConfiguration();
// Check if we have any route for this domain.
shared_ptr<Route> pRoute = pSMTPConfig->GetRoutes()->GetItemByNameWithWildcardMatch(sDomain);
if (pRoute)
{
sSMTPHost = pRoute->TargetSMTPHost();
lPort = pRoute->TargetSMTPPort();
connection_security = pRoute->GetConnectionSecurity();
if (pRoute->GetRelayerRequiresAuth())
{
sUsername = pRoute->GetRelayerAuthUsername();
sPassword = pRoute->GetRelayerAuthPassword();
}
}
else
{
// Do we have a fixed SMTP relayer?
String sRelayer = pSMTPConfig->GetSMTPRelayer();
if (!sRelayer.IsEmpty())
{
sSMTPHost = sRelayer;
lPort = pSMTPConfig->GetSMTPRelayerPort();
if (lPort == 0)
lPort = 25;
if (pSMTPConfig->GetSMTPRelayerRequiresAuthentication())
{
sUsername = pSMTPConfig->GetSMTPRelayerUsername();
sPassword = pSMTPConfig->GetSMTPRelayerPassword();
}
connection_security = pSMTPConfig->GetSMTPRelayerConnectionSecurity();
}
}
if (sSMTPHost.IsEmpty())
{
return shared_ptr<ServerInfo>();
}
bool is_ipaddress = StringParser::IsValidIPAddress(sSMTPHost);
String host_name = is_ipaddress ? "" : sSMTPHost;
String ip_address = is_ipaddress ? sSMTPHost : "";
shared_ptr<ServerInfo> serverInfo(new ServerInfo(true, host_name, ip_address, lPort, sUsername, sPassword, connection_security));
return serverInfo;
}
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);
}