khanat-code-old/code/ryzom/server/src/monitor_service/service_main.cpp

723 lines
18 KiB
C++

// Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2010 Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "stdpch.h"
#include "game_share/tick_event_handler.h"
#include "game_share/ryzom_version.h"
#include "game_share/crypt.h"
#include "nel/misc/time_nl.h"
#include "client.h"
#include "mirrors.h"
#include "messages.h"
#ifdef NL_OS_WINDOWS
# ifndef NL_COMP_MINGW
# define NOMINMAX
# endif
# include <WinSock2.h>
# include <Windows.h>
typedef unsigned long ulong;
#endif // NL_OS_WINDOWS
#include <mysql.h>
using namespace NLMISC;
using namespace NLNET;
using namespace std;
bool EGSHasMirrorReady = false;
bool IOSHasMirrorReady = false;
bool EmulateShard = false;
std::map<TYPE_NAME_STRING_ID, std::string> StringMap;
std::set<TYPE_NAME_STRING_ID> StringAsked;
// Must be a pointer to control when to start listening socket and when stop it
CCallbackServer *Server;
// Dates at which bad login msg should be sent
std::multimap<NLMISC::TTime, CRefPtr<CMonitorClient> > BadLoginClients;
const NLMISC::TTime LOGIN_RETRY_DELAY_IN_MILLISECONDS = 4000;
// Code taken from login service
/**
* Encapsulation of MySQL result
*/
class CMySQLResult
{
public:
/// Constructor
CMySQLResult(MYSQL_RES* res = NULL);
/// Constructor
CMySQLResult(MYSQL* database);
/// Destructor
~CMySQLResult();
/// Cast operator
operator MYSQL_RES*();
/// Affectation
CMySQLResult& operator = (MYSQL_RES* res);
/// Test success
bool success() const;
/// Test failure
bool failed() const;
/// Number of rows of result
uint numRows();
/// Number of fields of result
uint numFields();
/// Fetch row
MYSQL_ROW fetchRow();
private:
MYSQL_RES* _Result;
};
//
// Constructor
CMySQLResult::CMySQLResult(MYSQL_RES* res)
{
_Result = res;
}
/// Constructor
CMySQLResult::CMySQLResult(MYSQL* database)
{
_Result = mysql_store_result(database);
}
/// Destructor
CMySQLResult::~CMySQLResult()
{
if (_Result != NULL)
mysql_free_result(_Result);
}
/// Cast operator
CMySQLResult::operator MYSQL_RES*()
{
return _Result;
}
/// Affectation
CMySQLResult& CMySQLResult::operator = (MYSQL_RES* res)
{
if (res == _Result)
return *this;
if (_Result != NULL)
mysql_free_result(_Result);
_Result = res;
return *this;
}
/// Test success
bool CMySQLResult::success() const
{
return _Result != NULL;
}
/// Test failure
bool CMySQLResult::failed() const
{
return !success();
}
/// Number of rows of result
uint CMySQLResult::numRows()
{
return (uint)mysql_num_rows(_Result);
}
uint CMySQLResult::numFields()
{
return (uint)mysql_num_fields(_Result);
}
/// Fetch row
MYSQL_ROW CMySQLResult::fetchRow()
{
return mysql_fetch_row(_Result);
}
/* ***************************************************************************
Doc :
When an entity is added in the service mirror, the service checks if its name is in the name cache. If
the string ID is not known, the server ask the IOS for the string.
When the IOS sends back a string, the server broadcasts this string to the connected clients.
When a client connects the server, the server send it all the strings in the cache. The client sends a WINDOW message
to set the world window that is visible on the client.
A each tick, the server update some entities (UpdatePerTick) to the connected clients.
If the entity doesn't exist on the client, it send a ADD message with its entity ID and the string ID.
The server always sends a POS message for the entites it updates.
// ***************************************************************************/
// ***************************************************************************
// PASSWORD DB
// ***************************************************************************
MYSQL *DatabaseConnection = NULL;
void disconnectFromDatabase();
void connectToDatabase()
{
disconnectFromDatabase();
std::string DatabaseName;
std::string DatabaseHost;
std::string DatabaseLogin;
std::string DatabasePassword;
try
{
DatabaseName = IService::getInstance ()->ConfigFile.getVar("DatabaseName").asString ();
DatabaseHost = IService::getInstance ()->ConfigFile.getVar("DatabaseHost").asString ();
DatabaseLogin = IService::getInstance ()->ConfigFile.getVar("DatabaseLogin").asString ();
DatabasePassword = IService::getInstance ()->ConfigFile.getVar("DatabasePassword").asString ();
}
catch(const EConfigFile &e)
{
nlwarning(e.what());
return;
}
MYSQL *db = mysql_init(NULL);
if(db == NULL)
{
nlwarning ("mysql_init() failed");
return;
}
DatabaseConnection = mysql_real_connect(db, DatabaseHost.c_str(), DatabaseLogin.c_str(), DatabasePassword.c_str(), DatabaseName.c_str(),0,NULL,0);
if (DatabaseConnection == NULL || DatabaseConnection != db)
{
mysql_close(db);
nlerror ("mysql_real_connect() failed to '%s' with login '%s' and database name '%s'", DatabaseHost.c_str(), DatabaseLogin.c_str(), DatabaseName.c_str());
return;
}
}
void disconnectFromDatabase()
{
if (DatabaseConnection)
{
mysql_close(DatabaseConnection);
DatabaseConnection = NULL;
}
}
// ***************************************************************************
// SERVICE CLASS
// ***************************************************************************
class CMonitorService : public NLNET::IService
{
public:
bool LoginRequired;
public:
CMonitorService() : LoginRequired(false) {}
void init();
bool update();
void release();
};
// get instanceof the service
static CMonitorService &getMonitorService()
{
return *NLMISC::safe_cast<CMonitorService *>(IService::getInstance());
}
// callback for the tick service 'tick' message
void cbTick();
// ***************************************************************************
void clientWantsToConnect ( TSockId from, void *arg )
{
// Called when a client wants to connect
nlinfo ("Add client %d", Clients.size());
Clients.push_back (new CMonitorClient(from));
CMonitorService &ms = getMonitorService();
// send params about this sever the client
CMessage msgout;
msgout.setType("SERVER_PARAMS");
uint32 version = 0;
msgout.serial(version);
msgout.serial(ms.LoginRequired);
Server->send(msgout, from);
Clients.back()->Authentificated = !ms.LoginRequired;
// Send all the string in cache to the client
uint i;
for (i=0; i<Clients.size(); i++)
{
std::map<TYPE_NAME_STRING_ID, std::string>::iterator ite = StringMap.begin ();
while (ite != StringMap.end ())
{
Clients[i]->Str.push_back (ite->first);
ite++;
}
}
}
// ***************************************************************************
void clientWantsToDisconnect ( TSockId from, void *arg )
{
// Called when a client wants to disconnect
for (uint i = 0; i < Clients.size(); ++i)
{
if (Clients[i]->getSock() == from)
{
nlinfo ("Remove client %d", i);
Clients.erase(Clients.begin()+i);
return;
}
}
nlwarning ("Client not found for remove");
}
// ***************************************************************************
void clientSetWindow (CMessage &msgin, TSockId from, CCallbackNetBase &netbase)
{
// Called when a client sent a WINDOW message
float xmin, ymin, xmax, ymax;
msgin.serial(xmin);
msgin.serial(ymin);
msgin.serial(xmax);
msgin.serial(ymax);
for (uint i = 0; i < Clients.size(); ++i)
{
if (Clients[i]->getSock() == from && Clients[i]->Authentificated)
{
nlinfo ("Client %d sets window (%.0f,%.0f) (%.0f,%.0f)", i, xmin, ymin, xmax, ymax);
Clients[i]->setWindow(xmin,ymin,xmax,ymax);
Clients[i]->resetVision();
return;
}
}
}
// ***************************************************************************
void clientSetBandwidth (CMessage &msgin, TSockId from, CCallbackNetBase &netbase)
{
// Called when a client sent a WINDOW message
uint32 bandw;
msgin.serial(bandw);
for (uint i = 0; i < Clients.size(); ++i)
{
if (Clients[i]->getSock() == from && Clients[i]->Authentificated)
{
nlinfo ("Client %d sets bandwidth to %.1f kB/s", i, bandw/1024.0);
Clients[i]->AllowedUploadBandwidth = bandw;
return;
}
}
}
// ***************************************************************************
void clientAuthentication(CMessage &msgin, TSockId from, CCallbackNetBase &netbase)
{
std::string login;
std::string password;
sint version = msgin.serialVersion(0);
msgin.serial(login);
msgin.serial(password);
for (uint i = 0; i < Clients.size(); ++i)
{
if (!Clients[i]->Authentificated && Clients[i]->getSock() == from)
{
if (!Clients[i]->BadLogin) // don't allow new login attempt while thisflag is set
{
// make a db request to to db to see if password is valid
std::string queryStr = toString("SELECT Password FROM user where Login='%s'", login.c_str());
int result = mysql_query(DatabaseConnection, queryStr.c_str());
if (result == 0)
{
CMySQLResult sqlResult(DatabaseConnection);
if (sqlResult.success() && sqlResult.numRows() == 1)
{
MYSQL_ROW row = sqlResult.fetchRow();
if (sqlResult.numFields() == 1)
{
if (strlen(row[0]) > 2)
{
std::string salt;
if (row[0][0] == '$')
{
salt = std::string(row[0], row[0] + 19);
}
else
{
salt = std::string(row[0], row[0] + 2);
}
std::string cryptedVersion = CCrypt::crypt(password, salt);
if (cryptedVersion == row[0])
{
Clients[i]->Authentificated = true;
// password is good
CMessage msgout;
msgout.setType("AUTHENT_VALID");
Server->send(msgout, from);
return;
}
}
}
}
}
// fail the authentication
// Do not send result immediatly to avoid a potential hacker
// to try a dictionnary or that dort of things
BadLoginClients.insert(std::pair<NLMISC::TTime, NLMISC::CRefPtr<CMonitorClient> >(
NLMISC::CTime::getLocalTime() + LOGIN_RETRY_DELAY_IN_MILLISECONDS,
(NLMISC::CRefPtr<CMonitorClient>)Clients[i]));
Clients[i]->BadLogin =true;
return;
}
}
}
}
// ***************************************************************************
void cbReceiveString( CMessage& msgin, const string &serviceName, TServiceId serviceId )
{
uint32 nameIndex;
ucstring ucs;
msgin.serial( nameIndex );
msgin.serial( ucs );
// Add the string to the map
StringMap.insert (std::map<TYPE_NAME_STRING_ID, std::string>::value_type (nameIndex, ucs.toString()));
StringAsked.erase (nameIndex);
// Add string a id to send to the clients
uint i;
for (i=0; i<Clients.size(); i++)
{
Clients[i]->Str.push_back (nameIndex);
}
}
// ***************************************************************************
TCallbackItem CallbackArray[] =
{
{ "WINDOW", clientSetWindow },
{ "BANDW", clientSetBandwidth },
{ "AUTHENT", clientAuthentication }
};
TUnifiedCallbackItem CallbackArray5[] =
{
{ "RECV_STRING", cbReceiveString },
};
// ***************************************************************************
// SERVICE INIT & RELEASE
// ***************************************************************************
static void cbServiceMirrorUp( const std::string& serviceName, TServiceId serviceId, void * )
{
if ( serviceName == "IOS" )
IOSHasMirrorReady = true;
if ( serviceName == "EGS" )
EGSHasMirrorReady = true;
}
// ***************************************************************************
static void cbServiceDown( const std::string& serviceName, TServiceId serviceId, void * )
{
if ( serviceName == "IOS" )
IOSHasMirrorReady = false;
if ( serviceName == "EGS" )
EGSHasMirrorReady = false;
}
// ***************************************************************************
void CMonitorService::init ()
{
setVersion (RYZOM_VERSION);
// Init the server on port
Server = new CCallbackServer();
Server->init (48888);
Server->setConnectionCallback (clientWantsToConnect, NULL);
Server->setDisconnectionCallback (clientWantsToDisconnect, NULL);
Server->addCallbackArray (CallbackArray, sizeof(CallbackArray)/sizeof(CallbackArray[0]));
// setup the update systems
setUpdateTimeout(100);
// read sheet_id.bin and don't prune out unknown files
CSheetId::init(false);
// init sub systems
CMirrors::init(cbTick);
// CMessages::init();
// register the service up and service down callbacks
CMirrors::Mirror.setServiceMirrorUpCallback("*", cbServiceMirrorUp, 0);
CUnifiedNetwork::getInstance()->setServiceDownCallback( "*", cbServiceDown, 0);
LoginRequired = false;
// if password are required for that service, then connect to db
CConfigFile::CVar *loginRequiredVar = getMonitorService().ConfigFile.getVarPtr("LoginRequired");
LoginRequired = loginRequiredVar ? loginRequiredVar->asInt() != 0 : false;
if (LoginRequired)
{
connectToDatabase();
}
}
// ***************************************************************************
void CMonitorService::release ()
{
disconnectFromDatabase();
// release sub systems
// CMessages::release();
CMirrors::release();
if (Server)
{
delete Server;
Server = NULL;
}
}
// ***************************************************************************
// SERVICE UPDATES
// ***************************************************************************
///update called on each 'tick' message from tick service
void cbTick()
{
}
uint ForceTicks=0;
///update called every complete cycle of service loop
bool CMonitorService::update ()
{
Server->update();
uint iclient;
for (iclient=0; iclient<Clients.size(); ++iclient)
{
CMonitorClient &client = *Clients[iclient];
if (client.Authentificated)
{
client.update();
}
}
// Sent bad login msg to clients at the right time
NLMISC::TTime currentTime = NLMISC::CTime::getLocalTime();
while (!BadLoginClients.empty() && BadLoginClients.begin()->first <= currentTime)
{
CMonitorClient *client = BadLoginClients.begin()->second;
if (client != NULL)
{
CMessage msgout;
msgout.setType("AUTHENT_INVALID");
Server->send(msgout, client->getSock());
client->BadLogin = false; // allow to accept login again for that client
}
BadLoginClients.erase(BadLoginClients.begin());
}
/*
if (!Clients.empty() && !Entites.empty())
{
// Update some primitive
static uint primitiveToUpdate = 0;
CConfigFile::CVar *var = ConfigFile.getVarPtr ("UpdatePerTick");
uint count = 10;
if (var && (var->Type == CConfigFile::CVar::T_INT))
count = var->asInt();
// Loop to the beginning
if (primitiveToUpdate >= Entites.size())
primitiveToUpdate = 0;
// Resize the client array
// For each client
uint i;
for (i=0; i<Clients.size(); i++)
{
nlassert (Clients[i]->Entites.size() <= Entites.size());
Clients[i]->Entites.resize (Entites.size());
}
// For each primitive
uint firstPrimitiveToUpdate = primitiveToUpdate;
while (count)
{
// Present ?
if (Entites[primitiveToUpdate].Flags & CEntityEntry::Present)
{
// One more
count--;
// Get the primitive position
TDataSetRow entityIndex = TDataSetRow::createFromRawIndex (primitiveToUpdate);
CMirrorPropValueRO<TYPE_POSX> valueX( TheDataset, entityIndex, DSPropertyPOSX );
CMirrorPropValueRO<TYPE_POSY> valueY( TheDataset, entityIndex, DSPropertyPOSY );
CMonitorClient::CPosData posData;
posData.X = (float)valueX / 1000.f;
posData.Y = (float)valueY / 1000.f;
// For each client
for (i=0; i<Clients.size(); i++)
{
// The client
CMonitorClient &client = *Clients[i];
// Send position ?
bool sendPos = false;
// Clipped ?
const NLMISC::CVector &topLeft = client.getTopLeft();
const NLMISC::CVector &bottomRight = client.getBottomRight();
if ((posData.X>=topLeft.x) && (posData.Y>=topLeft.y) && (posData.X<=bottomRight.x) && (posData.Y<=bottomRight.y))
{
// Inside
if (client.Entites[primitiveToUpdate].Flags & CMonitorClient::CEntityEntry::Present)
{
// Send a POS message
sendPos = true;
}
else
{
// Send a ADD and a POS message
CMirrorPropValueRO<TYPE_NAME_STRING_ID> stringId( TheDataset, entityIndex, DSPropertyNAME_STRING_ID);
CMonitorClient::CAddData addData;
addData.Id = primitiveToUpdate;
addData.StringId = stringId;
addData.EntityId = TheDataset.getEntityId (entityIndex);
client.Add.push_back (addData);
sendPos = true;
}
}
else
{
// Outside
// Inside
if (client.Entites[primitiveToUpdate].Flags & CMonitorClient::CEntityEntry::Present)
{
// Send a RMV message
client.Rmv.push_back (primitiveToUpdate);
}
}
// Send position ?
if (sendPos)
{
CMirrorPropValueRO<TYPE_ORIENTATION> valueT( TheDataset, entityIndex, DSPropertyORIENTATION );
posData.Id = primitiveToUpdate;
posData.Tetha = valueT;
client.Pos.push_back (posData);
}
}
}
else
{
// Not present
for (i=0; i<Clients.size(); i++)
{
// The client
if (Clients[i]->Entites[primitiveToUpdate].Flags & CMonitorClient::CEntityEntry::Present)
{
// One more
count--;
// Send a RMV message
Clients[i]->Rmv.push_back (primitiveToUpdate);
}
}
}
// Next primitive
primitiveToUpdate++;
// Loop to the beginning
if (primitiveToUpdate >= Entites.size())
primitiveToUpdate = 0;
// Return to the first ?
if (firstPrimitiveToUpdate == primitiveToUpdate)
break;
}
// For each client
for (i=0; i<Clients.size(); i++)
Clients[i].update ();
}
*/
return true;
}
// ***************************************************************************
// NLNET_SERVICE_MAIN
// ***************************************************************************
NLNET_SERVICE_MAIN (CMonitorService, "MOS", "monitor_service", 0, CallbackArray5, "", "")