swg-source-1.2/src-1.2
1
0
Fork 0
mirror of https://bitbucket.org/theswgsource/src-1.2.git synced 2026-07-14 00:01:30 -04:00
Code Issues Projects Releases Wiki Activity
Files
f9c0a47a39aa0bb7f6d29e61fb47879ac0321337
src-1.2/engine/server/application/ConnectionServer/src/shared/ConnectionServer.cpp
T

1620 lines
53 KiB
C++
Executable File
Raw Blame History

// ConnectionServer.cpp
// copyright 2001 Verant Interactive
//-----------------------------------------------------------------------
#include "FirstConnectionServer.h"
#include "ConnectionServer.h"
#include "Archive/ByteStream.h"
#include "CentralConnection.h"
#include "ChatServerConnection.h"
#include "ClientConnection.h"
#include "ConfigConnectionServer.h"
#include "ConnectionServerMetricsData.h"
#include "CustomerServiceConnection.h"
#include "GameConnection.h"
#include "PseudoClientConnection.h"
#include "SessionApiClient.h"
#include "UdpLibrary.h"
#include "UnicodeUtils.h"
#include "serverKeyShare/KeyShare.h"
#include "serverMetrics/MetricsManager.h"
#include "serverNetworkMessages/CentralConnectionServerMessages.h"
#include "serverNetworkMessages/CharacterListMessage.h"
#include "serverNetworkMessages/ExcommunicateGameServerMessage.h"
#include "serverNetworkMessages/GameConnectionServerMessages.h"
#include "serverNetworkMessages/GameServerForLoginMessage.h"
#include "serverNetworkMessages/LoginKeyPush.h"
#include "serverNetworkMessages/NewClient.h"
#include "serverNetworkMessages/ProfilerOperationMessage.h"
#include "serverNetworkMessages/RandomName.h"
#include "serverNetworkMessages/SetConnectionServerPublic.h"
#include "serverNetworkMessages/UpdateConnectionServerStatus.h"
#include "serverNetworkMessages/UpdatePlayerCountMessage.h"
#include "serverNetworkMessages/ValidateAccountReplyMessage.h"
#include "serverNetworkMessages/ValidateCharacterForLoginReplyMessage.h"
#include "serverNetworkMessages/VerifyAndLockName.h"
#include "serverUtility/AdminAccountManager.h"
#include "sharedDebug/Profiler.h"
#include "sharedFoundation/Clock.h"
#include "sharedFoundation/ConfigFile.h"
#include "sharedFoundation/Os.h"
#include "sharedFoundation/Timer.h"
#include "sharedGame/PlatformFeatureBits.h"
#include "sharedLog/Log.h"
#include "sharedLog/LogManager.h"
#include "sharedLog/SetupSharedLog.h"
#include "sharedNetwork/NetworkSetupData.h"
#include "sharedNetwork/Service.h"
#include "sharedNetwork/UdpSock.h"
#include "sharedNetworkMessages/ClientCentralMessages.h"
#include "sharedNetworkMessages/GenericValueTypeMessage.h"
#include "sharedUtility/DataTableManager.h"
#include <vector>
#include "sharedFoundation/CrcConstexpr.hpp"
// ======================================================================
namespace ConnectionServerNamespace
{
ConnectionServer * s_connectionServer = 0;
NetworkSetupData * s_clientServiceSetup = 0;
const std::string SCENE_NAME_TUTORIAL = "tutorial";
const std::string SCENE_NAME_FALCON_PREFIX = "space_npe_falcon";
};
using namespace ConnectionServerNamespace;
// ======================================================================
ConnectionServer & ConnectionServer::instance()
{
return *s_connectionServer;
}
//-----------------------------------------------------------------------
ConnectionServer::ConnectionServer() :
MessageDispatch::Receiver(),
chatService(0),
customerService(0),
clientServicePrivate(0),
clientServicePublic(0),
gameService(0),
loginServerKeys(0),
done(false),
m_id(0),
m_metricsData(0),
centralConnection(0),
chatServers(),
customerServiceServers(),
clientMap(),
connectedMap(),
gameServerMap(),
freeTrials(),
networkBarrier(0),
pingSocket(new UdpSock),
m_recoverTime(0),
m_sessionApiClient(0),
m_pingTrafficNumBytes(0),
m_recoveringClientList()
{
if (s_clientServiceSetup == 0)
s_clientServiceSetup = new NetworkSetupData;
s_clientServiceSetup->maxOutstandingPackets = ConfigConnectionServer::getClientMaxOutstandingPackets();
s_clientServiceSetup->maxRawPacketSize = ConfigConnectionServer::getClientMaxRawPacketSize();
s_clientServiceSetup->maxConnections = ConfigConnectionServer::getClientMaxConnections();
s_clientServiceSetup->fragmentSize = ConfigConnectionServer::getClientFragmentSize();
s_clientServiceSetup->maxDataHoldTime = ConfigConnectionServer::getClientMaxDataHoldTime();
s_clientServiceSetup->hashTableSize = ConfigConnectionServer::getClientHashTableSize();
s_clientServiceSetup->port = ConfigConnectionServer::getClientServicePortPublic();
s_clientServiceSetup->maxConnectionsPerIP = ConfigConnectionServer::getMaxConnectionsPerIP();
s_clientServiceSetup->compress = ConfigConnectionServer::getCompressClientNetworkTraffic();
s_clientServiceSetup->useTcp = false;
loginServerKeys = new KeyServer(20);
Address a("", ConfigConnectionServer::getPingPort());
IGNORE_RETURN(pingSocket->bind(a));
if (ConfigConnectionServer::getValidateStationKey())
{
installSessionValidation();
}
}
//-----------------------------------------------------------------------
ConnectionServer::~ConnectionServer()
{
delete pingSocket;
pingSocket = 0;
delete loginServerKeys;
loginServerKeys = 0;
centralConnection = 0;
chatServers.clear();
customerServiceServers.clear();
connectedMap.clear();
clientServicePublic = 0;
clientServicePrivate = 0;
chatService = 0;
customerService = 0;
gameService = 0;
gameServerMap.clear();
freeTrials.clear();
delete s_clientServiceSetup;
}
//-----------------------------------------------------------------------
const CustomerServiceConnection * ConnectionServer::getCustomerServiceConnection()
{
if (!instance().customerServiceServers.empty())
{
return (*(instance().customerServiceServers.begin()));
}
return nullptr;
}
//-----------------------------------------------------------------------
//TODO: This assumes that all characters that aren't on a game server
// are waiting for this gameserver. This assumption is bad: they could
// be waiting on a different gameserver, or they could be in the process
// of being validated
void ConnectionServer::addGameConnection(unsigned long gameServerId, GameConnection* gc)
{
static ConnectionServer & cs = instance();
cs.gameServerMap[gameServerId] = gc;//@todo check for dupe
// find characters pending for THIS gameserver
SuidMap::iterator i;
for (i = cs.connectedMap.begin(); i != cs.connectedMap.end(); ++i)
{
ClientConnection * c = (*i).second;
if (!c->getHasBeenSentToGameServer())
IGNORE_RETURN(c->sendToGameServer());
}
}
//-----------------------------------------------------------------------
bool ConnectionServer::decryptToken(const KeyShare::Token & token, uint32 & stationUserId, bool & secure, std::string & accountName)
{
static ConnectionServer & cs = instance();
//Also the sizeof(int) is likewise magic from the session api
uint32 len = sizeof(uint32) + sizeof(bool) + MAX_ACCOUNT_NAME_LENGTH + 1;
unsigned char * keyBuffer = new unsigned char[len];
unsigned char * keyBufferPointer = keyBuffer;
memset(keyBuffer, 0, len);
bool retval = cs.loginServerKeys->decipherToken(token, keyBuffer, len);
if (!retval)
return retval;
char *tmpBuffer = new char[MAX_ACCOUNT_NAME_LENGTH + 1];
memset(tmpBuffer, 0, MAX_ACCOUNT_NAME_LENGTH + 1);
memcpy(&stationUserId, keyBufferPointer, sizeof(uint32));
keyBufferPointer += sizeof(uint32);
memcpy(&secure, keyBufferPointer, sizeof(bool));
keyBufferPointer += sizeof(bool);
memcpy(tmpBuffer, keyBufferPointer, MAX_ACCOUNT_NAME_LENGTH);
accountName = tmpBuffer;
delete[] tmpBuffer;
delete[] keyBuffer;
return retval;
}
bool ConnectionServer::decryptToken(const KeyShare::Token & token, char* sessionKey, StationId & stationId)
{
static ConnectionServer & cs = instance();
uint32 len = apiSessionIdWidth + sizeof(StationId);
unsigned char * keyBuffer = new unsigned char[len + 1];
unsigned char * keyBufferPointer = keyBuffer;
memset(keyBuffer, 0, sizeof(*keyBuffer));
bool retval = cs.loginServerKeys->decipherToken(token, keyBuffer, len);
if (!retval)
return retval;
memcpy(sessionKey, keyBufferPointer, len);
keyBufferPointer += apiSessionIdWidth;
memcpy(&stationId, keyBufferPointer, sizeof(StationId));
delete[] keyBuffer;
return retval;
}
//-----------------------------------------------------------------------
const Service * ConnectionServer::getChatService()
{
static ConnectionServer & cs = instance();
return cs.chatService;
}
//-----------------------------------------------------------------------
const Service * ConnectionServer::getCustomerService()
{
static ConnectionServer & cs = instance();
return cs.customerService;
}
//-----------------------------------------------------------------------
Service * ConnectionServer::getClientServicePrivate()
{
static ConnectionServer & cs = instance();
return cs.clientServicePrivate;
}
//-----------------------------------------------------------------------
Service * ConnectionServer::getClientServicePublic()
{
static ConnectionServer & cs = instance();
return cs.clientServicePublic;
}
//-----------------------------------------------------------------------
KeyShare::Token ConnectionServer::makeToken(const unsigned char * newData, const uint32 dataLen)
{
static ConnectionServer & cs = instance();
return cs.loginServerKeys->makeToken(newData, dataLen);
}
//-----------------------------------------------------------------------
void ConnectionServer::pushKey(const KeyShare::Key & newKey)
{
static ConnectionServer & cs = instance();
cs.loginServerKeys->pushKey(newKey);
}
//-----------------------------------------------------------------------
void ConnectionServer::addNewClient(ClientConnection* cconn, const NetworkId &oid, GameConnection* gconn, const std::string &, bool sendToStarport)
{
static ConnectionServer & cs = instance();
ClientMap::iterator i = cs.clientMap.find(oid);
if (i != cs.clientMap.end())
{
if (cconn->getClient())
{
WARNING_STRICT_FATAL(true, ("Client already connected, attempting to drop old one\n"));
dropClient(cconn, "Duplicate Login");
return;
}
else
{
// stale connection in map
cs.removeFromClientMap(oid);
}
}
// Create a new entry in the client map
cs.addToClientMap(oid, cconn);
// Get the client that was just created
Client * newClient = cs.getClient(oid);
NOT_NULL(newClient);
// select a chat server connection for the client
// if non exists, then the client will be notified when
// one starts
if (!cs.chatServers.empty())
{
//ChatServerConnection * c = (*chatServers.begin());
// find chat server with least load
size_t max = 0xFFFFFFFF;
ChatServerConnection * candidate = 0;
std::set<ChatServerConnection *>::const_iterator iter;
for (iter = cs.chatServers.begin(); iter != cs.chatServers.end(); ++iter)
{
if ((*iter)->getClients().size() <= max)
{
candidate = (*iter);
max = (*iter)->getClients().size();
}
}
if (candidate)
newClient->setChatConnection(candidate);
}
// select a cs server connection for the client
// if non exists, then the client will be notified when
// one starts
if (!cs.customerServiceServers.empty())
{
//ChatServerConnection * c = (*chatServers.begin());
// find chat server with least load
size_t max = 0xFFFFFFFF;
CustomerServiceConnection * candidate = 0;
std::set<CustomerServiceConnection *>::const_iterator iter;
for (iter = cs.customerServiceServers.begin(); iter != cs.customerServiceServers.end(); ++iter)
{
if ((*iter)->getClients().size() <= max)
{
candidate = (*iter);
max = (*iter)->getClients().size();
}
}
if (candidate)
newClient->setCustomerServiceConnection(candidate);
}
//send the game server a message about this client.
static const std::string loginTrace("TRACE_LOGIN");
LOG(loginTrace, ("NewClient(%d, %s, %s)", cconn->getSUID(), oid.getValueString().c_str(), cconn->getAccountName().c_str()));
NewClient m(oid, cconn->getAccountName(), cconn->getRemoteAddress(), cconn->getIsSecure(), false, cconn->getSUID(), nullptr, cconn->getGameFeatures(), cconn->getSubscriptionFeatures(), cconn->getEntitlementTotalTime(), cconn->getEntitlementEntitledTime(), cconn->getEntitlementTotalTimeSinceLastLogin(), cconn->getEntitlementEntitledTimeSinceLastLogin(), cconn->getBuddyPoints(), cconn->getConsumedRewardEvents(), cconn->getClaimedRewardItems(), cconn->isUsingAdminLogin(), cconn->getCanSkipTutorial(), sendToStarport);
gconn->send(m, true);
//@todo move this to ClientConnection.cpp
}
//-----------------------------------------------------------------------
void ConnectionServer::dropClient(ClientConnection * conn, const std::string& description)
{
DEBUG_FATAL(!conn, ("Cannot call dropClient with nullptr connection"));
if (!conn) //lint !e774 // boolean within 'if' always evaluates to False //suppresed because this is only relevant in DEBUG builds
return;
static ConnectionServer & cs = instance();
//Client dropped. Tell game server if they've logged in.
LOG("ClientDisconnect", ("Dropping client for SUID %d\n", conn->getSUID()));
LOG("CustomerService", ("Login:%s Dropped Reason: %s. Character: %s (%s). Play time: %s. Active play time: %s", ClientConnection::describeAccount(conn).c_str(), description.c_str(), conn->getCharacterName().c_str(), conn->getCharacterId().getValueString().c_str(), conn->getPlayTimeDuration().c_str(), conn->getActivePlayTimeDuration().c_str()));
Client *client = conn->getClient();
if (client)
{
DropClient msg(client->getNetworkId());
GameConnection* gconn = client->getGameConnection();
//Don't worry about sending a message to a non-existant game server
if (gconn)
gconn->send(msg, true);
else
DEBUG_REPORT_LOG(true, ("Could not find game server to drop this client\n"));
// Remove the entry from the client map
cs.removeFromClientMap(client->getNetworkId());
}
else
{
//If they aren't connected to the game yet, they're probably on the pending list.
//@todo ensure we don't need to send a cleanup message to central
// removePendingCharacter(conn->getSUID());
}
// Remove entry from the connected map
cs.removeFromConnectedMap(conn->getSUID());
conn->disconnect();
}
//-----------------------------------------------------------------------
// void ConnectionServer::addPendingCharacter(uint32 suid, ClientConnection* conn)
// {
// if (pendingMap.find(suid) == pendingMap.end())
// pendingMap[suid] = conn;
// else
// {
// WARNING_STRICT_FATAL(true, ("Attepting to add duplicate pending chatacter"));
// pendingMap[suid] = conn;
// }
// }
//-----------------------------------------------------------------------
void ConnectionServer::addConnectedClient(uint32 suid, ClientConnection* conn)
{
static ConnectionServer & cs = instance();
cs.addToConnectedMap(suid, conn);
}
//-----------------------------------------------------------------------
ClientConnection* ConnectionServer::getClientConnection(const uint32 suid)
{
static ConnectionServer & cs = instance();
ClientConnection * result = 0;
SuidMap::const_iterator i = cs.connectedMap.find(suid);
if (i != cs.connectedMap.end())
{
result = (*i).second;
}
return result;
}
// ----------------------------------------------------------------------
const Service * ConnectionServer::getGameService()
{
static ConnectionServer & cs = instance();
return cs.gameService;
}
// ----------------------------------------------------------------------
GameConnection* ConnectionServer::getGameConnection(const std::string &sceneName)
{
static ConnectionServer & cs = instance();
GameServerMap::iterator i = cs.gameServerMap.begin();
for (; i != cs.gameServerMap.end(); ++i)
{
if (sceneName == (*i).second->getSceneName())
{
return (*i).second;
}
}
return nullptr;
}
// ----------------------------------------------------------------------
void ConnectionServer::handleConnectionServerIdMessage(const ConnectionServerId & m)
{
// Connection established with central server. Set everything up.
m_id = m.getId();
const Service * const servicePrivate = getClientServicePrivate();
const Service * const servicePublic = getClientServicePublic();
FATAL(servicePrivate == nullptr && servicePublic == nullptr, ("No client service is active!"));
const Service * const g = getGameService();
FATAL(g == nullptr, ("No game service is active!"));
const Service * const c = getChatService();
const Service * const cs = getCustomerService();
const uint16 pingPort = getPingPort();
if ((servicePrivate != nullptr || servicePublic != nullptr) && g != nullptr) //lint !e774 // always evaluates to false // suppresed because the FATAL macro triggers this lint warning
{
uint16 chatPort = 0;
uint16 csPort = 0;
if (c)
{
chatPort = c->getBindPort();
}
if (cs)
{
csPort = cs->getBindPort();
}
uint16 publicPort = 0;
if (servicePublic)
{
publicPort = servicePublic->getBindPort();
}
uint16 privatePort = 0;
if (servicePrivate)
{
privatePort = servicePrivate->getBindPort();
}
std::string clientServicePublicBindAddress = ConfigConnectionServer::getPublicBindAddress();
if (clientServicePublicBindAddress.empty())
{
clientServicePublicBindAddress = NetworkHandler::getHostName();
}
NOT_NULL(gameService);
NOT_NULL(chatService);
NOT_NULL(customerService);
const NewCentralConnectionServer ncs(gameService->getBindAddress(), clientServicePublicBindAddress, chatService->getBindAddress(), customerService->getBindAddress(), privatePort, publicPort, g->getBindPort(), chatPort, csPort, pingPort, ConfigConnectionServer::getConnectionServerNumber());
sendToCentralProcess(ncs);
}
else
{
FATAL(true, ("Error in connection server startup"));
}
}
// ----------------------------------------------------------------------
void ConnectionServer::receiveMessage(const MessageDispatch::Emitter & source, const MessageDispatch::MessageBase & message)
{
// it's reasonably safe to cast, message type verified
// determine message type
const uint32 messageType = message.getType();
switch(messageType) {
case constcrc("GameConnectionOpened") :
{
DEBUG_REPORT_LOG(true, ("Game Connection opened\n"));
break;
}
case constcrc("GameConnectionClosed") :
{
//@todo handle case where game server drops and we have users connected to it.
//Drop all connected clients.
const GameConnection & downConnection = static_cast<const GameConnection &>(source);
DEBUG_REPORT_LOG(true, ("Game Server connection went down. Dropping clients.\n"));
//remove Game Conection from list
PseudoClientConnection::gameConnectionClosed(&downConnection);
GameServerMap::iterator j = gameServerMap.find(downConnection.getGameServerId());
if (j != gameServerMap.end())
{
gameServerMap.erase(j);
}
break;
}
case constcrc("CentralConnectionOpened") :
{
DEBUG_REPORT_LOG(true, ("Opened connection with central\n"));
centralConnection = const_cast<CentralConnection *>(static_cast<const CentralConnection *>(&source));//lint !e826 // info: Suspiscious pointer-to-pointer conversion (area too small)
if (ConfigConnectionServer::getStartPublicServer())
{
s_clientServiceSetup->port = ConfigConnectionServer::getClientServicePortPublic();
s_clientServiceSetup->maxConnectionsPerIP = ConfigConnectionServer::getMaxConnectionsPerIP();
clientServicePublic = new Service(ConnectionAllocator<ClientConnection>(), *s_clientServiceSetup);
}
s_clientServiceSetup->port = ConfigConnectionServer::getClientServicePortPrivate();
s_clientServiceSetup->maxConnectionsPerIP = 0;
clientServicePrivate = new Service(ConnectionAllocator<ClientConnection>(), *s_clientServiceSetup);
connectToMessage("ClientConnectionOpened");
connectToMessage("ClientConnectionClosed");
break;
}
case constcrc("CentralConnectionClosed") :
{
centralConnection = const_cast<CentralConnection *>(static_cast<const CentralConnection *>(&source));//lint !e826 // info: Suspiscious pointer-to-pointer conversion (area too small)
setDone("CentralConnectionClosed: %s", centralConnection ? centralConnection->getDisconnectReason().c_str() : "");
centralConnection = 0;
DEBUG_REPORT_LOG(true, ("CentralDied. So we will too\n"));
//@todo Drop all pending clients.
break;
}
case constcrc("ClientConnectionOpened") :
{
DEBUG_REPORT_LOG(true, ("Opened connection with client\n"));
break;
}
case constcrc("ClientConnectionClosed") :
{
DEBUG_REPORT_LOG(true, ("Client is Dropping connection\n"));
ClientConnection * cconn = const_cast<ClientConnection *>(static_cast<const ClientConnection*>(&source));//lint !e826 // info: Suspiscious pointer-to-pointer conversion (area too small)
//tell CentralServer
if (centralConnection)
{
GenericValueTypeMessage<StationId> const msg("ClientConnectionClosed", cconn->getSUID());
centralConnection->send(msg, true);
}
//Client dropped. Tell game server if they've logged in.
Client *client = cconn->getClient();
if (client)
{
DropClient msg(client->getNetworkId());
GameConnection* gconn = client->getGameConnection();
//Don't worry about sending a message to a non-existant game server
if (gconn)
gconn->send(msg, true);
// Remove the entry from the client map
removeFromClientMap(client->getNetworkId());
}
else
{
// TODO: wtf is this? @Darth, fix it!
//If they aren't connected to the game yet, they're probably on the pending list.
//removePendingCharacter(cconn->getSUID());
}
removeFromConnectedMap(cconn->getSUID());
break;
}
case constcrc("ConnectionServerId") :
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
ConnectionServerId m(ri);
handleConnectionServerIdMessage(m);
break;
}
case constcrc("ConnectionKeyPush") :
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
ConnectionKeyPush pk(ri);
loginServerKeys->pushKey(pk.getKey());
break;
}
case constcrc("LoginKeyPush") :
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
const LoginKeyPush k(ri);
loginServerKeys->pushKey(k.getKey());
break;
}
case constcrc("CharacterListMessage") :
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
const CharacterListMessage msg(ri);
WARNING_STRICT_FATAL(true, ("CharacterListMessage is deprecated on the ConnectionServer -- fix whoever is sending it.\n"));
break;
}
case constcrc("ConnectionCreateCharacterSuccess") :
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
const ConnectionCreateCharacterSuccess msg(ri);
LOG("TraceCharacterCreation", ("Received ConnectionCreateCharacterSuccess for %d", msg.getStationId()));
ClientConnection* const client = getClientConnection(msg.getStationId());
if (client)
{
const ClientCreateCharacterSuccess m(msg.getNetworkId());
client->send(m, true);
}
else
{
LOG("CustomerService", ("CharacterTransfer: Trying to deliver ConnectionCreateCharacterSuccess to PsuedoClientConnection(%d)", msg.getStationId()));
PseudoClientConnection::tryToDeliverMessageTo(static_cast<unsigned int>(msg.getStationId()), static_cast<const GameNetworkMessage &>(message).getByteStream());
}
break;
}
case constcrc("ConnectionCreateCharacterFailed") :
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
const ConnectionCreateCharacterFailed msg(ri);
ClientConnection* client = getClientConnection(msg.getStationId());
if (client)
{
client->setHasRequestedCharacterCreate(false);
ClientCreateCharacterFailed m(msg.getName(), msg.getErrorMessage()); //lint !e1013 !e1055 !e746 (Symbol 'getErrorMessage' not a member of class 'const ConnectionCreateCharacterFailed') // supressed because it IS a member of that class. //lint !e1055 //lint !e746
client->send(m, true);
}
else
{
PseudoClientConnection::tryToDeliverMessageTo(static_cast<unsigned int>(msg.getStationId()), static_cast<const GameNetworkMessage &>(message).getByteStream());
}
break;
}
case constcrc("NewCharacterCreated") :
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
GenericValueTypeMessage<StationId> const msg(ri);
ClientConnection* client = getClientConnection(msg.getValue());
if (client)
{
// don't allow this client to request another character create;
// this will forced the client to disconnect and reconnect at which time
// a check will be done (taking the newly created character into account)
// to see if the client is allowed to create another character on this account
client->setHasCreatedCharacter(true);
}
break;
}
case constcrc("RandomNameResponse") :
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
RandomNameResponse connMsg(ri);
ClientConnection* cconn = getClientConnection(connMsg.getStationId());
ClientRandomNameResponse cnr(connMsg.getCreatureTemplate(), connMsg.getName(), connMsg.getErrorMessage());//lint !e1013 (Symbol 'getErrorMessage' not a member of class 'RandomNameResponse') // supressed because it IS a member of that class.
if (cconn)
cconn->send(cnr, true);
break;
}
case constcrc("VerifyAndLockNameResponse") :
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
VerifyAndLockNameResponse connMsg(ri);
ClientConnection* cconn = getClientConnection(connMsg.getStationId());
ClientVerifyAndLockNameResponse cvalnr(connMsg.getCharacterName(), connMsg.getErrorMessage());
if (cconn)
cconn->send(cvalnr, true);
break;
}
case constcrc("ChatServerConnectionOpened") :
{
ChatServerConnection * c = const_cast<ChatServerConnection *>(static_cast<const ChatServerConnection *>(&source));//lint !e826 suspiscious pointer-to-pointer conversion // suppressed, you bet it is
IGNORE_RETURN(chatServers.insert(c));
break;
}
case constcrc("ChatServerConnectionClosed") :
{
ChatServerConnection * c = const_cast<ChatServerConnection *>(static_cast<const ChatServerConnection *>(&source));//lint !e826 suspiscious pointer-to-pointer conversion // suppressed, you bet it is
std::set<ChatServerConnection *>::iterator f = chatServers.find(c);
if (f != chatServers.end())
{
// migrate players that were on this chat server
// to another chat server
// now remove the server from the set
chatServers.erase(f);
if (!chatServers.empty())
{
std::set<ChatServerConnection *>::iterator ic = chatServers.begin();
const std::set<Client *> & clients = c->getClients();
std::set<Client *>::const_iterator i;
for (i = clients.begin(); i != clients.end(); ++i)
{
ChatServerConnection * newConn = (*ic);
Client * cl = (*i);
cl->setChatConnection(newConn);
++ic;
if (ic == chatServers.end())
ic = chatServers.begin();
}
}
else
{
const std::set<Client *> & clients = c->getClients();
std::set<Client *>::const_iterator i;
for (i = clients.begin(); i != clients.end(); ++i)
{
(*i)->setChatConnection(nullptr);
}
}
}
break;
}
case constcrc("CustomerServiceConnectionOpened") :
{
CustomerServiceConnection * c = const_cast<CustomerServiceConnection *>(static_cast<const CustomerServiceConnection *>(&source));//lint !e826 suspiscious pointer-to-pointer conversion // suppressed, you bet it is
IGNORE_RETURN(customerServiceServers.insert(c));
break;
}
case constcrc("CustomerServiceConnectionClosed") :
{
CustomerServiceConnection * c = const_cast<CustomerServiceConnection *>(static_cast<const CustomerServiceConnection *>(&source));//lint !e826 suspiscious pointer-to-pointer conversion // suppressed, you bet it is
std::set<CustomerServiceConnection *>::iterator f = customerServiceServers.find(c);
if (f != customerServiceServers.end())
{
// migrate players that were on this chat server
// to another chat server
// now remove the server from the set
customerServiceServers.erase(f);
if (!customerServiceServers.empty())
{
std::set<CustomerServiceConnection *>::iterator ic = customerServiceServers.begin();
const std::set<Client *> & clients = c->getClients();
std::set<Client *>::const_iterator i;
for (i = clients.begin(); i != clients.end(); ++i)
{
CustomerServiceConnection * newConn = (*ic);
Client * cl = (*i);
cl->setCustomerServiceConnection(newConn);
++ic;
if (ic == customerServiceServers.end())
ic = customerServiceServers.begin();
}
}
else
{
const std::set<Client *> & clients = c->getClients();
std::set<Client *>::const_iterator i;
for (i = clients.begin(); i != clients.end(); ++i)
{
(*i)->setCustomerServiceConnection(nullptr);
}
}
}
break;
}
case constcrc("GameServerForLoginMessage") :
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
const GameServerForLoginMessage msg(ri);
ClientConnection* client = getClientConnection(msg.getStationId());
// see if the client is for the same character as the login message.
// this is required to prevent admin login via the CS Tool from
// disconnecting other characters logged in from the same account
// (but not the same character) as the character we're administratively
// logging in.
bool clientIsForSameCharacterId = false;
if (client)
{
clientIsForSameCharacterId = client->getCharacterId() == msg.getCharacterId();
}
bool handledByPseudoClient = false;
// if the character id in the message doesn't match the character id for
// the existing client, it may be for a pseudoclient. Check, and if so,
// handle there.
if (!clientIsForSameCharacterId)
{
PseudoClientConnection * pcc = PseudoClientConnection::getPseudoClientConnection(msg.getCharacterId());
// hand off to the PCC only if we do have a pseudoclient, and either we don't have a client, or
// the pseudoclient has a tool id, telling us that it's for cs tool login.
if (pcc && ((!client) || (pcc->getTransferCharacterData().getCSToolId() > 0)))
{
handledByPseudoClient = true;
bool result;
result = PseudoClientConnection::tryToDeliverMessageTo(msg.getStationId(), static_cast<const GameNetworkMessage &>(message).getByteStream());
UNREF(result);
DEBUG_REPORT_LOG(!result, ("Received GameServerForLoginMessage for %lu, who was not connected.\n", msg.getStationId()));
}
}
if (client && (!handledByPseudoClient))
{
static const std::string loginTrace("TRACE_LOGIN");
LOG(loginTrace, ("GameServerForLoginMessage(%d, %s)", client->getSUID(), client->getCharacterId().getValueString().c_str()));
client->handleGameServerForLoginMessage(msg.getServer());
}
break;
}
case constcrc("ValidateCharacterForLoginReplyMessage") :
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
const ValidateCharacterForLoginReplyMessage msg(ri);
ClientConnection* cconn = getClientConnection(msg.getSuid());
if (!cconn)
DEBUG_REPORT_LOG(true, ("Received ValidateCharacterForLoginReplyMessage for account %lu, which is no longer connected.\n", msg.getSuid()));
else
{
cconn->onCharacterValidated(msg.getApproved(), msg.getCharacterId(), Unicode::wideToNarrow(msg.getCharacterName()), msg.getContainerId(), msg.getScene(), msg.getCoordinates());
}
break;
}
case constcrc("ValidateAccountReplyMessage") :
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
const ValidateAccountReplyMessage msg(ri);
ClientConnection* cconn = getClientConnection(msg.getStationId());
if (!cconn)
DEBUG_REPORT_LOG(true, ("Received ValidateAccountReplyMessage for account %lu, which is no longer connected.\n", msg.getStationId()));
else
{
cconn->onIdValidated(msg.getCanLogin(), msg.getCanCreateRegular(), msg.getCanCreateJedi(), msg.getCanSkipTutorial(), msg.getConsumedRewardEvents(), msg.getClaimedRewardItems());
}
break;
}
case constcrc("SetConnectionServerPublic") :
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
SetConnectionServerPublic p(ri);//lint !e40 !e522 !e10 // Undeclared identifier 'SetConnectionServerPublic' // suppressed because it IS declared
bool statusChanged = false;
DEBUG_REPORT_LOG(true, ("Conn Server: attempting to chang status\n"));
if (p.getIsPublic())//lint !e40 !e1013 !e10 // Undeclared identifier 'p' // suppressed because it IS declared
{
if (!clientServicePublic)
{
statusChanged = true;
}
}
else
{
delete clientServicePublic;
clientServicePublic = 0;
statusChanged = true;
}
if (statusChanged && centralConnection)
{
const Service * publicService = getClientServicePublic();
const Service * privateService = getClientServicePrivate();
if (publicService || privateService)
{
uint16 publicServicePort = 0;
uint16 privateServicePort = 0;
if (publicService)
{
publicServicePort = publicService->getBindPort();
}
if (privateService)
{
privateServicePort = privateService->getBindPort();
}
const UpdateConnectionServerStatus ucs(publicServicePort, privateServicePort);
centralConnection->send(ucs, true);
}
}
break;
}//lint !e529 // Symbol 'ri' not subsequently referenced // suppressed because it IS referenced. I think lint is very confused for some reason.
case constcrc("ProfilerOperationMessage") :
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
ProfilerOperationMessage msg(ri);
unsigned int processId = msg.getProcessId();
if (!processId)
Profiler::handleOperation(msg.getOperation().c_str());
break;
}
case constcrc("ExcommunicateGameServerMessage") :
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
ExcommunicateGameServerMessage msg(ri);
LOG("GameGameConnect", ("Told to drop connection to %lu by Central", msg.getServerId()));
GameConnection *conn = getGameConnection(msg.getServerId());
if (conn)
conn->disconnect();
break;
}
case constcrc("CntrlSrvDropDupeConns") :
{
Archive::ReadIterator ri = static_cast<const GameNetworkMessage &>(message).getByteStream().begin();
GenericValueTypeMessage<std::pair<uint32, std::string> > const msg(ri);
ClientConnection* client = getClientConnection(msg.getValue().first);
if (client && !client->isUsingAdminLogin() && !client->getIsSecure())
{
std::string s = "New Connection on galaxy ";
s += msg.getValue().second;
dropClient(client, s);
}
break;
}
}
}
//-----------------------------------------------------------------------
void ConnectionServer::install()
{
s_connectionServer = new ConnectionServer;
char tmp[128] = { "\0" };
IGNORE_RETURN(snprintf(tmp, sizeof(tmp), "ConnectionServer:%d", Os::getProcessId()));
SetupSharedLog::install(tmp);
s_connectionServer->setupConnections();
s_connectionServer->m_metricsData = new ConnectionServerMetricsData;
MetricsManager::install(s_connectionServer->m_metricsData, true, "ConnectionServer", "", ConfigConnectionServer::getConnectionServerNumber());
DataTableManager::install();
AdminAccountManager::install(ConfigConnectionServer::getAdminAccountDataTable());
}
//-----------------------------------------------------------------------
void ConnectionServer::remove()
{
MetricsManager::remove();
delete s_connectionServer->m_metricsData;
s_connectionServer->m_metricsData = 0;
// explicitly delete all connections that were setup from setupConnections rather than letting
// Connection::remove do it. There are connections that require a valid s_connectionServer which is deleted
// and set to nullptr.
s_connectionServer->unsetupConnections();
SetupSharedLog::remove();
delete s_connectionServer;
s_connectionServer = 0;
}
//-----------------------------------------------------------------------
void ConnectionServer::run(void)
{
static const bool shouldSleep = ConfigConnectionServer::getShouldSleep();
static ConnectionServer & cserver = instance();
DEBUG_FATAL(!cserver.m_metricsData, ("Connection server not installed properly"));
unsigned long startTime = Clock::timeMs();
Clock::setFrameRateLimit(50.0f);
LOG("ServerStartup", ("ConnectionServer starting on %s", NetworkHandler::getHostName().c_str()));
while (!cserver.done)
{
PROFILER_AUTO_BLOCK_DEFINE("main loop");
//bool barrierReached = true;
do
{
{
PROFILER_AUTO_BLOCK_DEFINE("Os::update");
if (!Os::update())
cserver.setDone("Os condition (Parent pid change)");
}
{
PROFILER_AUTO_BLOCK_DEFINE("NetworkHandler::update1");
NetworkHandler::update();
}
{
GenericValueTypeMessage<std::pair<uint16, uint32> > const syncStampMessage("SetSyncStamp", std::make_pair(static_cast<uint16>(UdpMisc::LocalSyncStampShort()), static_cast<uint32>(UdpMisc::LocalSyncStampLong())));
GameServerMap::iterator end = cserver.gameServerMap.end();
for (GameServerMap::iterator iter = cserver.gameServerMap.begin(); iter != end; ++iter)
iter->second->send(syncStampMessage, true);
}
{
PROFILER_AUTO_BLOCK_DEFINE("NetworkHandler::dispatch");
NetworkHandler::dispatch();
}
{
PROFILER_AUTO_BLOCK_DEFINE("update");
cserver.update();
}
{
PROFILER_AUTO_BLOCK_DEFINE("NetworkHandler::update2");
NetworkHandler::update();
}
{
PROFILER_AUTO_BLOCK_DEFINE("MetricsManager::update");
unsigned long curTime = Clock::timeMs();
MetricsManager::update(static_cast<float>(curTime - startTime));
startTime = curTime;
}
if (shouldSleep)
{
PROFILER_AUTO_BLOCK_DEFINE("Os::sleep");
Os::sleep(1);
}
} while (!cserver.done);
NetworkHandler::clearBytesThisFrame();
cserver.updateRecoveringClientList(static_cast<uint>(Clock::frameTime()*1000.0f));
}
}
// ----------------------------------------------------------------------
/**
* Invoked every frame to do whatever updates are needed
*/
void ConnectionServer::update()
{
if (centralConnection)
{
static Timer t(5.0f);
if (t.updateZero(Clock::frameTime()))
{
// Update the population on the central server
updatePopulationOnCentralServer();
if (getNumberOfClients() >= ConfigConnectionServer::getMaxClients() - 1)
{
//@todo need an Alert here
WARNING(true, ("We've reached maximum client capacity on a connection server with %d clients", getNumberOfClients()));
}
}
}
if (m_sessionApiClient)
{
m_sessionApiClient->update();
}
static const int ping_throttle_max = 1024;
static char buffer[4];
for (int throttle = 0; pingSocket->canRecv() && throttle < ping_throttle_max; ++throttle)
{
Address addr;
const uint32 count = pingSocket->recvFrom(addr, buffer, 4);
m_pingTrafficNumBytes += static_cast<int>(count);
if (m_pingTrafficNumBytes < 0)
m_pingTrafficNumBytes = 0;
IGNORE_RETURN(pingSocket->sendTo(addr, buffer, count));
}
}
// ----------------------------------------------------------------------
/**
* The recovering client list holds players who are trying to recover from a server
* crash. If another game server takes authority within a few frames, the player
* is OK and we don't do anything. If no game server takes authority for them,
* we drop them and force them to log in again.
*/
void ConnectionServer::updateRecoveringClientList(uint elapsedTime)
{
if (!m_recoveringClientList.empty())
{
m_recoverTime += elapsedTime;
static std::set<NetworkId> listPlayersDropped;
for (RecoveringClientListType::iterator i = m_recoveringClientList.begin(); i != m_recoveringClientList.end();)
{
if (m_recoverTime > i->first)
{
Client *client = getClient(i->second);
if (client)
{
if (client->getGameConnection())
DEBUG_REPORT_LOG(true, ("Player %s recovered from a server crash and will not be dropped.\n", i->second.getValueString().c_str()));
else
{
LOG("Network", ("Dropping player %s because game server crashed and no other server took authority.\n", i->second.getValueString().c_str()));
dropClient(client->getClientConnection(), "Game Server Crash");
IGNORE_RETURN(listPlayersDropped.insert(i->second));
}
}
i = m_recoveringClientList.erase(i);
}
else
++i;
}
if (!listPlayersDropped.empty())
{
GenericValueTypeMessage<std::set<NetworkId> > const m("PlayerDroppedFromGameServerCrash", listPlayersDropped);
// let one of the game server know that we dropped the player(s) due to a game server crash
GameConnection * const anyGameConnection = getAnyGameConnection();
if (anyGameConnection)
anyGameConnection->send(m, true);
// let CentralServer know that we dropped the player(s) due to a game server crash
sendToCentralProcess(m);
listPlayersDropped.clear();
}
if (m_recoveringClientList.empty())
m_recoverTime = 0; // prevent rollover and other problems I don't want to worry about
}
}
// ----------------------------------------------------------------------
void ConnectionServer::addRecoveringClient(const NetworkId& networkId)
{
instance().m_recoveringClientList.push_back(std::pair<int, NetworkId>(static_cast<int>(instance().m_recoverTime) + ConfigConnectionServer::getCrashRecoveryTimeout(), networkId));//lint !e737 !e713 !e1703 !e1025 // going nuts over unsigned/signed conversion and type mismatch on template
}
// ----------------------------------------------------------------------
void ConnectionServer::unsetupConnections()
{
// remove all ClientConnection objects so when Connection::remove() is called we don't crash since
// ConnectionServer no longer exists
while (!instance().connectedMap.empty())
{
SuidMap::iterator i = instance().connectedMap.begin();
if (i != instance().connectedMap.end())
{
ClientConnection * c = (*i).second;
uint32 suid = (*i).first;
IGNORE_RETURN(instance().connectedMap.erase(suid));
if (c)
{
ConnectionServer::dropClient(c, "ConnectionServer shutting down.");
delete c;
}
}
}
if (customerService)
{
delete customerService;
customerService = 0;
}
if (chatService)
{
delete chatService;
chatService = 0;
}
if (centralConnection)
{
delete centralConnection;
centralConnection = 0;
}
if (gameService)
{
delete gameService;
gameService = 0;
}
}
//-----------------------------------------------------------------------
void ConnectionServer::setupConnections()
{
// set up message connections
connectToMessage("ConnectionGameServerConnect");
connectToMessage("SetConnectionServerPublic");
// set up port to listen for clients, central, and game servers
connectToMessage("CentralConnectionOpened");
connectToMessage("CentralConnectionClosed");
NetworkSetupData setup;
setup.port = ConfigConnectionServer::getGameServicePort();
setup.bindInterface = ConfigConnectionServer::getGameServiceBindInterface();
setup.maxConnections = 1000;
gameService = new Service(ConnectionAllocator<GameConnection>(), setup);
connectToMessage("GameConnectionOpened");
connectToMessage("GameConnectionClosed");
// connect to central server
centralConnection = new CentralConnection(ConfigConnectionServer::getCentralServerAddress(), ConfigConnectionServer::getCentralServerPort());
setup.port = 0;
setup.bindInterface = ConfigConnectionServer::getChatServiceBindInterface();
chatService = new Service(ConnectionAllocator<ChatServerConnection>(), setup);
connectToMessage("ChatServerConnectionOpened");
connectToMessage("ChatServerConnectionClosed");
setup.bindInterface = ConfigConnectionServer::getCustomerServiceBindInterface();
customerService = new Service(ConnectionAllocator<CustomerServiceConnection>(), setup);
connectToMessage("CustomerServiceConnectionOpened");
connectToMessage("CustomerServiceConnectionClosed");
connectToMessage("ConnectionServerId");
connectToMessage("ConnectionKeyPush");
connectToMessage("LoginKeyPush");
connectToMessage("CharacterListMessage");
//Create Characters Messages
connectToMessage("ClientCreateCharacter");
connectToMessage("ConnectionCreateCharacterSuccess");
connectToMessage("ConnectionCreateCharacterFailed");
connectToMessage("NewCharacterCreated");
connectToMessage("GameServerForLoginMessage");
// name query messages
connectToMessage("ClientRandomNameRequest"); // from client
connectToMessage("RandomNameResponse"); // from game server
connectToMessage("ClientVerifyAndLockNameRequest"); // from client
connectToMessage("VerifyAndLockNameResponse"); // from game server
connectToMessage("ValidateCharacterForLoginReplyMessage");
connectToMessage("ValidateAccountReplyMessage");
connectToMessage("ProfilerOperationMessage");
connectToMessage("CentralConnectionClosed");
connectToMessage("CentralConnectionOpened");
connectToMessage("ChunkCompleteMessage");
connectToMessage("FrameEndMessage");
connectToMessage("GameConnectionClosed");
connectToMessage("GameGameServerConnect");
connectToMessage("GameServerReadyMessage");
connectToMessage("GameServerUniverseLoadedMessage");
connectToMessage("PersistedPlayerMessage");
connectToMessage("PreloadListMessage");
connectToMessage("PreloadRequestCompleteMessage");
connectToMessage("ProfilerOperationMessage");
connectToMessage("RequestGameServerForLoginMessage");
connectToMessage("RequestSceneTransfer");
connectToMessage("ShutdownMessage");
connectToMessage("TaskConnectionOpened");
connectToMessage("UnloadedPlayerMessage");
connectToMessage("WatcherConnectionClosed");
connectToMessage("WatcherConnectionOpened");
connectToMessage("ExcommunicateGameServerMessage");
connectToMessage("CntrlSrvDropDupeConns");
}
//----------------------------------------------------------------------
uint16 ConnectionServer::getPingPort()
{
static ConnectionServer & cs = instance();
return cs.pingSocket->getBindAddress().getHostPort();
}
//-----------------------------------------------------------------------
Client* ConnectionServer::getClient(const NetworkId & oid)
{
static ConnectionServer & cs = instance();
ClientMap::const_iterator iter = cs.clientMap.find(oid);
if (iter != cs.clientMap.end())
return (*iter).second;
return 0;
}
//-----------------------------------------------------------------------
const ConnectionServer::ClientMap & ConnectionServer::getClientMap()
{
return instance().clientMap;
}
//-----------------------------------------------------------------------
GameConnection* ConnectionServer::getGameConnection(uint32 gameServerId)
{
static ConnectionServer & cs = instance();
const GameServerMap::const_iterator i = cs.gameServerMap.find(gameServerId);
if (i != cs.gameServerMap.end())
return (*i).second;
return nullptr;
}
//-----------------------------------------------------------------------
GameConnection* ConnectionServer::getAnyGameConnection()
{
static ConnectionServer & cs = instance();
if (!cs.gameServerMap.empty())
return cs.gameServerMap.begin()->second;
return nullptr;
}
//-----------------------------------------------------------------------
int ConnectionServer::getPingTrafficNumBytes()
{
static ConnectionServer & cs = instance();
return cs.m_pingTrafficNumBytes;
}
//-----------------------------------------------------------------------
int ConnectionServer::getNumberOfClients()
{
static ConnectionServer & cs = instance();
return static_cast<int>(cs.connectedMap.size());
}
//-----------------------------------------------------------------------
int ConnectionServer::getNumberOfFreeTrials()
{
static ConnectionServer & cs = instance();
return static_cast<int>(cs.freeTrials.size());
}
//-----------------------------------------------------------------------
int ConnectionServer::getNumberOfGameServers()
{
static ConnectionServer & cs = instance();
return static_cast<int>(cs.gameServerMap.size());
}
//-----------------------------------------------------------------------
void ConnectionServer::removeConnectedCharacter(uint32 suid)
{
static ConnectionServer & cs = instance();
cs.removeFromConnectedMap(suid);
}
//-----------------------------------------------------------------------
void ConnectionServer::sendToCentralProcess(const GameNetworkMessage & msg)
{
static ConnectionServer & cs = instance();
if (cs.centralConnection)
cs.centralConnection->send(msg, true);
else
WARNING(true, ("Connection tried to send a message Central, but there is no Central Connection"));
}
//-----------------------------------------------------------------------
CentralConnection * ConnectionServer::getCentralConnection()
{
static ConnectionServer & cs = instance();
return cs.centralConnection;
}
//-----------------------------------------------------------------------
void ConnectionServer::installSessionValidation()
{
int i = 0;
std::vector<char const *> sessionServers;
int const numberOfSessionServers = ConfigConnectionServer::getNumberOfSessionServers();
for (i = 0; i < numberOfSessionServers; ++i)
{
char const * const p = ConfigConnectionServer::getSessionServer(i);
if (p)
{
REPORT_LOG(true, ("Using session server %s\n", p));
sessionServers.push_back(p);
}
}
// if there were none specified, use defaults
FATAL(i == 0, ("No session servers specified for session API"));
m_sessionApiClient = new SessionApiClient(&sessionServers[0], i);
}
// ----------------------------------------------------------------------
void ConnectionServer::addToClientMap(const NetworkId &oid, ClientConnection* cconn)
{
Client * newClient = new Client(cconn, oid);
clientMap[oid] = newClient;
//associate the ClientConnection object.
cconn->setClient(newClient);
}
// ----------------------------------------------------------------------
void ConnectionServer::removeFromClientMap(const NetworkId &oid)
{
ClientMap::iterator i = clientMap.find(oid);
if (i != clientMap.end())
{
clientMap.erase(i);
}
}
//-----------------------------------------------------------------------
void ConnectionServer::addToConnectedMap(uint32 suid, ClientConnection* cconn)
{
SuidMap::iterator i = connectedMap.find(suid);
if (i == connectedMap.end())
{
connectedMap[suid] = cconn;
}
else
{
WARNING_STRICT_FATAL(true, ("Attepting to add duplicate connected chatacter"));
connectedMap[suid] = cconn;
}
if (((cconn->getSubscriptionFeatures() & ClientSubscriptionFeature::FreeTrial) != 0)
&& ((cconn->getSubscriptionFeatures() & ClientSubscriptionFeature::Base) == 0))
{
freeTrials.insert(suid);
}
// Update the population on the CentralServer immediately
// since we are trying to avoid people "rushing" the server
updatePopulationOnCentralServer();
}
// ----------------------------------------------------------------------
void ConnectionServer::removeFromConnectedMap(uint32 suid)
{
SuidMap::iterator i = connectedMap.find(suid);
if (i != connectedMap.end())
{
connectedMap.erase(i);
}
FreeTrialsSet::iterator j = freeTrials.find(suid);
if (j != freeTrials.end())
{
freeTrials.erase(j);
}
// We could update the CentralServer population but people
// leaving the server are not as important as people connecting
// and so we will wait for update() to handle things
}
// ----------------------------------------------------------------------
void ConnectionServer::updatePopulationOnCentralServer()
{
if (centralConnection)
{
// Total number of clients and how many of those are free trials
const int numPlayers = getNumberOfClients();
const int numFreeTrial = getNumberOfFreeTrials();
// We are concerned about too many people piling up at the beginning
// of the tutorial, so count how many players could be a problem
int numPlayersEmptyScene = 0;
int numPlayersTutorialScene = 0;
int numPlayersFalconScene = 0;
// Walk through the clients and evaluate what scene they are in
SuidMap::const_iterator i;
for (i = connectedMap.begin(); i != connectedMap.end(); ++i)
{
const ClientConnection * const conn = (*i).second;
const Client * const client = conn->getClient();
if (client && client->getGameConnection())
{
const std::string& scene = client->getGameConnection()->getSceneName();
if (scene.empty())
{
numPlayersEmptyScene += 1;
}
else if (scene == SCENE_NAME_TUTORIAL)
{
numPlayersTutorialScene += 1;
}
else if (scene.substr(0, SCENE_NAME_FALCON_PREFIX.length()) == SCENE_NAME_FALCON_PREFIX)
{
numPlayersFalconScene += 1;
}
}
else
{
numPlayersEmptyScene += 1;
}
}
const UpdatePlayerCountMessage msg(false, numPlayers, numFreeTrial, numPlayersEmptyScene, numPlayersTutorialScene, numPlayersFalconScene);
centralConnection->send(msg, true);
}
}
// ----------------------------------------------------------------------
SessionApiClient* ConnectionServer::getSessionApiClient()
{
// this is causing crashes when ConnectionServer is shutdown and something calls this function
// because instance() returns 0.
if (s_connectionServer)
{
return instance().m_sessionApiClient;
}
else
{
return 0;
}
}
// ----------------------------------------------------------------------
void ConnectionServer::setDone(char const *reasonfmt, ...)
{
if (!done)
{
char reason[1024];
va_list ap;
va_start(ap, reasonfmt);
IGNORE_RETURN(_vsnprintf(reason, sizeof(reason), reasonfmt, ap));//lint !e530 Symbol 'ap' not initialized
reason[sizeof(reason) - 1] = '\0';
LOG(
"ServerShutdown",
(
"ConnectionServer (pid %d) shutdown, reason: %s",
static_cast<int>(Os::getProcessId()),
reason));
REPORT_LOG(
true,
(
"ConnectionServer (pid %d) shutdown, reason: %s\n",
static_cast<int>(Os::getProcessId()),
reason));
done = true;
va_end(ap);
}
}
// ======================================================================
Reference in New Issue View Git Blame Copy Permalink