You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2428 lines
70 KiB
C++
2428 lines
70 KiB
C++
// NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
|
|
// 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 "stdnet.h"
|
|
#include "nel/net/module_gateway.h"
|
|
#include "nel/net/module.h"
|
|
#include "nel/net/module_manager.h"
|
|
#include "nel/net/module_socket.h"
|
|
#include "nel/net/module_message.h"
|
|
#include "nel/net/callback_client.h"
|
|
#include "nel/net/callback_server.h"
|
|
|
|
using namespace std;
|
|
using namespace NLMISC;
|
|
|
|
|
|
|
|
namespace NLNET
|
|
{
|
|
struct TSecurityDataDesc
|
|
{
|
|
TSecurityData *SecurityData;
|
|
|
|
TSecurityDataDesc()
|
|
: SecurityData(NULL)
|
|
{
|
|
}
|
|
|
|
void serial(CMemStream &s)
|
|
{
|
|
if (!s.isReading())
|
|
{
|
|
// write mode
|
|
TSecurityData *sd = SecurityData;
|
|
|
|
uint32 nbSecBlock = 0;
|
|
sint32 tagCountPos = s.reserve(4);
|
|
while (sd != NULL)
|
|
{
|
|
if (sd->DataTag == 0xff)
|
|
{
|
|
TUnknownSecurityData *usd = safe_cast<TUnknownSecurityData *>(sd);
|
|
s.serial(usd->RealDataTag);
|
|
}
|
|
else
|
|
{
|
|
s.serial(sd->DataTag);
|
|
}
|
|
// reserve a place to store the size of the next element
|
|
sint32 pos = s.reserve(4);
|
|
s.serial(*sd);
|
|
// store the size
|
|
uint32 size = s.getPos()-pos-4;
|
|
s.poke(size, pos);
|
|
|
|
nbSecBlock++;
|
|
sd = sd->NextItem;
|
|
}
|
|
|
|
// store the number of item
|
|
s.poke(nbSecBlock, tagCountPos);
|
|
}
|
|
else
|
|
{
|
|
nlassert(SecurityData == NULL);
|
|
TSecurityData **pLastSd = &SecurityData;
|
|
// read mode
|
|
uint32 nbSecBlock;
|
|
s.serial(nbSecBlock);
|
|
|
|
if (nbSecBlock == 0)
|
|
SecurityData = NULL;
|
|
|
|
for (uint i=0; i<nbSecBlock; ++i)
|
|
{
|
|
uint8 dataTag;
|
|
s.serial(dataTag);
|
|
uint32 blockSize;
|
|
s.serial(blockSize);
|
|
sint32 pos = s.getPos();
|
|
TSecurityData *sd;
|
|
|
|
try
|
|
{
|
|
TSecurityData::TCtorParam param(dataTag);
|
|
sd = NLMISC_GET_FACTORY(TSecurityData, uint8).createObject(dataTag, param);
|
|
|
|
if (sd == NULL)
|
|
{
|
|
// we don't know this type, create an unknow security block
|
|
sd = new TUnknownSecurityData(dataTag, blockSize);
|
|
sd->serial(s);
|
|
}
|
|
else
|
|
{
|
|
sd->serial(s);
|
|
}
|
|
}
|
|
catch(const EStreamOverflow &)
|
|
{
|
|
// FAILED to read the security block, rewind to old pos and serial as unknow
|
|
nlwarning("Error while reading stream for security data type %u", dataTag);
|
|
|
|
s.seek(pos, NLMISC::IStream::begin);
|
|
sd = new TUnknownSecurityData(dataTag, blockSize);
|
|
sd->serial(s);
|
|
}
|
|
|
|
*pLastSd = sd;
|
|
pLastSd = &(sd->NextItem);
|
|
}
|
|
}
|
|
|
|
}
|
|
};
|
|
|
|
/// Sub message for module description
|
|
struct TModuleDescCodec
|
|
{
|
|
TModuleId ModuleProxyId;
|
|
uint32 ModuleDistance;
|
|
string ModuleFullName;
|
|
string ModuleClass;
|
|
string ModuleManifest;
|
|
TSecurityDataDesc SecDesc;
|
|
|
|
|
|
TModuleDescCodec()
|
|
{
|
|
}
|
|
|
|
TModuleDescCodec(IModuleProxy *proxy)
|
|
{
|
|
ModuleProxyId = proxy->getModuleProxyId();
|
|
ModuleDistance = proxy->getModuleDistance()+1;
|
|
ModuleFullName = proxy->getModuleName();
|
|
ModuleClass = proxy->getModuleClassName();
|
|
ModuleManifest = proxy->getModuleManifest();
|
|
SecDesc.SecurityData = const_cast<TSecurityData*>(proxy->getFirstSecurityData());
|
|
}
|
|
|
|
void serial(NLMISC::CMemStream &s)
|
|
{
|
|
s.serial(ModuleProxyId);
|
|
s.serial(ModuleDistance);
|
|
s.serial(ModuleFullName);
|
|
s.serial(ModuleManifest);
|
|
s.serial(ModuleClass);
|
|
s.serial(SecDesc);
|
|
}
|
|
};
|
|
|
|
/// message for module distance update
|
|
struct TModuleDistanceChangeMsg
|
|
{
|
|
TModuleId ModuleId;
|
|
uint32 NewDistance;
|
|
|
|
void serial(NLMISC::IStream &s)
|
|
{
|
|
s.serial(ModuleId);
|
|
s.serial(NewDistance);
|
|
}
|
|
};
|
|
|
|
/// message for module security update
|
|
struct TModuleSecurityChangeMsg
|
|
{
|
|
TModuleId ModuleId;
|
|
|
|
TSecurityDataDesc SecDesc;
|
|
|
|
void serial(NLMISC::CMemStream &s)
|
|
{
|
|
s.serial(ModuleId);
|
|
s.serial(SecDesc);
|
|
}
|
|
};
|
|
/// Message for module removing
|
|
struct TModuleRemMsg
|
|
{
|
|
vector<TModuleId> RemovedModules;
|
|
|
|
void serial(NLMISC::IStream &s)
|
|
{
|
|
s.serialCont(RemovedModules);
|
|
}
|
|
};
|
|
|
|
/// Message for module operation
|
|
struct TModuleOperationMsg
|
|
{
|
|
TModuleId ModuleId;
|
|
string OperationName;
|
|
|
|
CMessage MessageBody;
|
|
|
|
void serial(NLMISC::IStream &s)
|
|
{
|
|
s.serial(ModuleId);
|
|
s.serial(OperationName);
|
|
s.serial(MessageBody);
|
|
}
|
|
};
|
|
|
|
|
|
/// message waiting next update for local dispatching
|
|
struct TLocalMessage
|
|
{
|
|
TModuleId SenderProxyId;
|
|
TModuleId AddresseProxyId;
|
|
CMessage Message;
|
|
};
|
|
|
|
|
|
/** Register the gateway in the module manager gateway registry
|
|
*/
|
|
void CModuleGateway::registerGateway()
|
|
{
|
|
IModuleManager::getInstance().registerModuleGateway(this);
|
|
}
|
|
/** Unregister the gateway in the module manager gateway registry
|
|
*/
|
|
void CModuleGateway::unregisterGateway()
|
|
{
|
|
IModuleManager::getInstance().unregisterModuleGateway(this);
|
|
}
|
|
|
|
|
|
/** The standard gateway that interconnect module
|
|
* across process.
|
|
*/
|
|
class CStandardGateway :
|
|
public CModuleBase,
|
|
public CModuleGateway,
|
|
public CModuleSocket
|
|
{
|
|
typedef map<TModuleId, TModuleProxyPtr> TModuleProxies;
|
|
/// Module proxies managed by this gateway. The map key is the module proxy id
|
|
TModuleProxies _ModuleProxies;
|
|
|
|
typedef CTwinMap<TStringId, TModuleProxyPtr> TNamedProxyIdx;
|
|
/// Index of name to proxy id
|
|
TNamedProxyIdx _NameToProxyIdx;
|
|
|
|
/// A structure to hold foreign proxy information
|
|
struct TKnownModuleInfo
|
|
{
|
|
TModuleId ForeignProxyId;
|
|
CGatewayRoute *Route;
|
|
uint32 ModuleDistance;
|
|
TStringId ModuleClassId;
|
|
};
|
|
|
|
typedef multimap<TStringId, TKnownModuleInfo> TKnownModuleInfos;
|
|
/** List of known foreign module info.
|
|
*/
|
|
TKnownModuleInfos _KnownModules;
|
|
|
|
typedef map<TModuleId, TModuleId> TLocalModuleIndex;
|
|
/// Translation table to find module proxies for locally plugged module
|
|
/// The map key is the local module id, the data is the associated proxy id
|
|
TLocalModuleIndex _LocalModuleIndex;
|
|
|
|
typedef map<std::string, IGatewayTransport*> TTransportList;
|
|
/// the list of active transport
|
|
TTransportList _Transports;
|
|
|
|
typedef set<CGatewayRoute*> TRouteList;
|
|
// the list of available routes
|
|
TRouteList _Routes;
|
|
|
|
/// The security plug-in (if any)
|
|
CGatewaySecurity *_SecurityPlugin;
|
|
|
|
/// Ping counter for debug purpose
|
|
uint32 _PingCounter;
|
|
|
|
typedef std::list<TLocalMessage> TLocalMessageList;
|
|
/// List of local message waiting dispatching at next update
|
|
TLocalMessageList _LocalMessages;
|
|
|
|
public:
|
|
|
|
CStandardGateway()
|
|
: _SecurityPlugin(NULL),
|
|
_PingCounter(0)
|
|
{
|
|
}
|
|
|
|
~CStandardGateway()
|
|
{
|
|
// we need to unplug any plugged module
|
|
while (!_PluggedModules.getAToBMap().empty())
|
|
{
|
|
_PluggedModules.getAToBMap().begin()->second->unplugModule(this);
|
|
}
|
|
|
|
// delete all transport
|
|
while (!_Transports.empty())
|
|
{
|
|
deleteTransport(_Transports.begin()->first);
|
|
}
|
|
|
|
// delete security plug-in
|
|
if (_SecurityPlugin != NULL)
|
|
removeSecurityPlugin();
|
|
|
|
// must be done before the other destructors are called
|
|
unregisterSocket();
|
|
unregisterGateway();
|
|
}
|
|
|
|
CModuleProxy *getModuleProxy(TModuleId proxyId)
|
|
{
|
|
TModuleProxies::iterator it(_ModuleProxies.find(proxyId));
|
|
if (it == _ModuleProxies.end())
|
|
return NULL;
|
|
return static_cast<CModuleProxy*>(it->second.getPtr());
|
|
}
|
|
|
|
/***********************************************************
|
|
** Gateway methods
|
|
***********************************************************/
|
|
virtual const std::string &getGatewayName() const
|
|
{
|
|
return getModuleName();
|
|
}
|
|
virtual const std::string &getFullyQualifiedGatewayName() const
|
|
{
|
|
return getModuleFullyQualifiedName();
|
|
}
|
|
|
|
/// Create and bind to this gateway a new transport
|
|
virtual void createTransport(const std::string &transportClass, const std::string &instanceName)
|
|
{
|
|
if (_Transports.find(instanceName) != _Transports.end())
|
|
{
|
|
nlwarning("A transport with the name '%s' already exist in this gateway", instanceName.c_str());
|
|
return;
|
|
}
|
|
|
|
IGatewayTransport::TCtorParam param;
|
|
param.Gateway = this;
|
|
IGatewayTransport *transport = NLMISC_GET_FACTORY(IGatewayTransport, std::string).createObject(transportClass, param);
|
|
|
|
if (transport == NULL)
|
|
{
|
|
nlwarning("Failed to create a transport with the class '%s'", transportClass.c_str());
|
|
return;
|
|
}
|
|
|
|
// Store the transport
|
|
// TTransportInfo *ti = new TTransportInfo(transport);
|
|
_Transports.insert(make_pair(instanceName, transport));
|
|
// _TransportPtrIdx.insert(make_pair(transport, ti));
|
|
|
|
nldebug("NETL6: Gateway transport %s (%s) created", instanceName.c_str(), transportClass.c_str());
|
|
}
|
|
|
|
/// Delete a transport (this will close any open route)
|
|
virtual void deleteTransport(const std::string &instanceName)
|
|
{
|
|
TTransportList::iterator it(_Transports.find(instanceName));
|
|
if (it == _Transports.end())
|
|
{
|
|
nlwarning("Unknown transport named '%s'", instanceName.c_str());
|
|
return;
|
|
}
|
|
|
|
nldebug("NETL6: Gateway transport '%s' deleted", instanceName.c_str());
|
|
// delete the transport
|
|
IGatewayTransport *transport = it->second;
|
|
// nlassert(_TransportPtrIdx.find(transport) != _TransportPtrIdx.end());
|
|
// _TransportPtrIdx.erase(transport);
|
|
delete transport;
|
|
// delete it->second;
|
|
_Transports.erase(it);
|
|
}
|
|
|
|
/// Activate/stop peer invisible mode on a transport
|
|
virtual void setTransportPeerInvisible(const std::string &transportInstanceName, bool peerInvisible)
|
|
{
|
|
TTransportList::iterator it(_Transports.find(transportInstanceName));
|
|
if (it == _Transports.end())
|
|
{
|
|
nlwarning("Unknown transport named '%s'", transportInstanceName.c_str());
|
|
return;
|
|
}
|
|
|
|
IGatewayTransport *transport= it->second;
|
|
|
|
if (peerInvisible == transport->PeerInvisible)
|
|
// nothing more to do
|
|
return;
|
|
|
|
// set the mode
|
|
transport->PeerInvisible = peerInvisible;
|
|
|
|
nldebug("NETL6: Gateway transport %s peer invisible mode %s", transportInstanceName.c_str(), peerInvisible? "ON" : "OFF");
|
|
|
|
|
|
// For each route of this transport, we need to disclose/undisclose peer modules
|
|
TRouteList::iterator first(_Routes.begin()), last(_Routes.end());
|
|
for (; first != last; ++first)
|
|
{
|
|
CGatewayRoute *route = *first;
|
|
|
|
if (route->getTransport() == transport)
|
|
{
|
|
// this route need to be filtered
|
|
TModuleProxies::iterator first(_ModuleProxies.begin()), last(_ModuleProxies.end());
|
|
for (; first != last; ++first)
|
|
{
|
|
IModuleProxy *proxy = first->second;
|
|
if (proxy->getGatewayRoute() != NULL
|
|
&& proxy->getGatewayRoute() != route
|
|
&& proxy->getGatewayRoute()->getTransport() == transport)
|
|
{
|
|
// this module is on the same transport, but another route, remove/add it from the
|
|
// route
|
|
if (peerInvisible)
|
|
undiscloseModuleToRoute(route, proxy);
|
|
else
|
|
{
|
|
// check firewall rules
|
|
if (!route->getTransport()->Firewalled)
|
|
discloseModuleToRoute(route, proxy);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Activate/stop firewalling mode on a transport
|
|
virtual void setTransportFirewallMode(const std::string &transportInstanceName, bool firewalled)
|
|
throw (EGatewayFirewallBreak)
|
|
{
|
|
TTransportList::iterator it(_Transports.find(transportInstanceName));
|
|
if (it == _Transports.end())
|
|
{
|
|
nlwarning("Unknown transport named '%s'", transportInstanceName.c_str());
|
|
return;
|
|
}
|
|
|
|
IGatewayTransport *transport = it->second;
|
|
|
|
if (firewalled == transport->Firewalled)
|
|
// nothing to do
|
|
return;
|
|
|
|
if (firewalled && transport->getRouteCount() != 0)
|
|
throw EGatewayFirewallBreak();
|
|
|
|
/// set the firewall mode
|
|
transport->Firewalled = firewalled;
|
|
|
|
nldebug("NETL6: Gateway transport %s firewall mode %s", transportInstanceName.c_str(), firewalled? "ON" : "OFF");
|
|
|
|
if (firewalled == false)
|
|
{
|
|
// we need to disclose all module not disclosed yet
|
|
TRouteList::iterator first(_Routes.begin()), last(_Routes.end());
|
|
for (; first != last; ++first)
|
|
{
|
|
CGatewayRoute *route = *first;
|
|
|
|
if (route->getTransport() == transport)
|
|
{
|
|
// this route need to be unfiltered
|
|
TModuleProxies::iterator first(_ModuleProxies.begin()), last(_ModuleProxies.end());
|
|
for (; first != last; ++first)
|
|
{
|
|
IModuleProxy *proxy = first->second;
|
|
if (proxy->getGatewayRoute() == NULL || (proxy->getGatewayRoute() != route ))
|
|
{
|
|
// this module is on another route, disclose it if needed
|
|
if (route->FirewallDisclosed.find(proxy->getModuleProxyId()) == route->FirewallDisclosed.end())
|
|
discloseModuleToRoute(route, proxy);
|
|
}
|
|
}
|
|
}
|
|
// clear the firewall disclosed table
|
|
route->FirewallDisclosed.clear();
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Send a command to a transport
|
|
virtual void transportCommand(const TParsedCommandLine &commandLine)
|
|
{
|
|
for (uint i=1; i<commandLine.SubParams.size(); ++i)
|
|
{
|
|
const TParsedCommandLine * subParam = commandLine.SubParams[i];
|
|
|
|
std::string transportName = subParam->ParamName;
|
|
TTransportList::const_iterator it(_Transports.find(transportName));
|
|
if (it == _Transports.end())
|
|
{
|
|
nlwarning("Unknown transport named '%s', ignoring command.", transportName.c_str());
|
|
}
|
|
else if (subParam->SubParams.empty())
|
|
{
|
|
nlwarning("Can't find sub param list for transport '%s' command", transportName.c_str());
|
|
}
|
|
else
|
|
{
|
|
nldebug("NETL6: Gateway transport %s, sending command '%s'", transportName.c_str(), commandLine.toString().c_str());
|
|
// ok, we have a valid transport, send the command
|
|
IGatewayTransport *transport = it->second;
|
|
if (!transport->onCommand(*subParam))
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
virtual IGatewayTransport *getGatewayTransport(const std::string &transportName) const
|
|
{
|
|
TTransportList::const_iterator it(_Transports.find(transportName));
|
|
|
|
if (it == _Transports.end())
|
|
return NULL;
|
|
else
|
|
return it->second;
|
|
}
|
|
|
|
virtual uint32 getTransportCount() const
|
|
{
|
|
return (uint32)_Transports.size();
|
|
}
|
|
|
|
virtual uint32 getRouteCount() const
|
|
{
|
|
return (uint32)_Routes.size();
|
|
}
|
|
|
|
virtual uint32 getReceivedPingCount() const
|
|
{
|
|
return _PingCounter;
|
|
}
|
|
|
|
virtual void onRouteAdded(CGatewayRoute *route)
|
|
{
|
|
nlassert(route != NULL);
|
|
// Remember the new route
|
|
nlassert(_Routes.find(route) == _Routes.end());
|
|
_Routes.insert(route);
|
|
|
|
// a new route is available, disclose known modules
|
|
{
|
|
TModuleProxies::iterator first(_ModuleProxies.begin()), last(_ModuleProxies.end());
|
|
for (; first != last; ++first)
|
|
{
|
|
IModuleProxy *modProx = first->second;
|
|
|
|
// only transmit module desc coming from other routes
|
|
// and other transport if peer invisible
|
|
if (isModuleProxyVisible(modProx, route))
|
|
{
|
|
discloseModuleToRoute(route, modProx);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// A route is removed by a transport
|
|
virtual void onRouteRemoved(CGatewayRoute *route)
|
|
{
|
|
nlassert(route != NULL);
|
|
nlassert(_Routes.find(route) != _Routes.end());
|
|
// we need to remove all the proxy that come from this route
|
|
// CGatewayRoute::TForeignToLocalIdx::TAToBMap::const_iterator first(route->ForeignToLocalIdx.getAToBMap().begin()), last(route->ForeignToLocalIdx.getAToBMap().end());
|
|
// for (; first != last; ++first)
|
|
while (!route->ForeignToLocalIdx.getAToBMap().empty())
|
|
{
|
|
removeForeignModule(route, route->ForeignToLocalIdx.getAToBMap().begin()->first);
|
|
// TModuleId localProxyId = first->second;
|
|
// TModuleProxies::iterator it(_ModuleProxies.find(localProxyId));
|
|
// nlassert(it != _ModuleProxies.end());
|
|
//
|
|
// IModuleProxy *modProx = it->second;
|
|
//
|
|
// // trigger an event in the gateway
|
|
// onRemoveModuleProxy(modProx);
|
|
//
|
|
// // remove proxy record from the proxy list
|
|
// _ModuleProxies.erase(it);
|
|
// _NameToProxyIdx.removeWithB(modProx);
|
|
//
|
|
// // Release the proxy object
|
|
// IModuleManager::getInstance().releaseModuleProxy(modProx->getModuleProxyId());
|
|
}
|
|
// cleanup the translation table
|
|
// route->ForeignToLocalIdx.clear();
|
|
|
|
// clear the route tracker
|
|
_Routes.erase(route);
|
|
|
|
// cleanup route state
|
|
route->ForeignToLocalIdx.clear();
|
|
route->PendingEvents.clear();
|
|
route->FirewallDisclosed.clear();
|
|
route->NextMessageType = CModuleMessageHeaderCodec::mt_invalid;
|
|
route->NextSenderProxyId = 0;
|
|
route->NextAddresseeProxyId = 0;
|
|
}
|
|
|
|
/// A transport have received a message
|
|
virtual void onReceiveMessage(CGatewayRoute *from, const CMessage &msgin)
|
|
{
|
|
H_AUTO(CModuleGetaway_onReceiveMessage);
|
|
// dispatch the message
|
|
if (from->NextMessageType != CModuleMessageHeaderCodec::mt_invalid)
|
|
{
|
|
// this message must be dispatched to a module
|
|
onReceiveModuleMessage(from, msgin);
|
|
}
|
|
// Not a module message, dispatch the gateway message
|
|
else if (msgin.getName() == "MOD_OP")
|
|
{
|
|
onReceiveModuleMessageHeader(from, msgin);
|
|
}
|
|
else if (msgin.getName() == "MOD_UPD")
|
|
{
|
|
onReceiveModuleUpdate(from, msgin);
|
|
}
|
|
// else if (msgin.getName() == "MOD_ADD")
|
|
// {
|
|
// onReceiveModuleAdd(from, msgin);
|
|
// }
|
|
// else if (msgin.getName() == "MOD_REM")
|
|
// {
|
|
// onReceiveModuleRemove(from, msgin);
|
|
// }
|
|
// else if (msgin.getName() == "MOD_DST_UPD")
|
|
// {
|
|
// onReceiveModuleDistanceUpdate(from, msgin);
|
|
// }
|
|
}
|
|
|
|
|
|
/***********************************/
|
|
/* security plug-in management*/
|
|
/***********************************/
|
|
/** create a security plug-in.
|
|
* There must be no security plug-in currently created.
|
|
*/
|
|
virtual void createSecurityPlugin(const std::string &className)
|
|
{
|
|
if (_SecurityPlugin != NULL)
|
|
{
|
|
nlwarning("NLNETL5 : CStandardGateway::createSecurityPlugin : plug-in already created ");
|
|
return;
|
|
}
|
|
|
|
CGatewaySecurity::TCtorParam params;
|
|
params.Gateway = this;
|
|
CGatewaySecurity *gs = NLMISC_GET_FACTORY(CGatewaySecurity, std::string).createObject(className, params);
|
|
if (gs == NULL)
|
|
{
|
|
nlwarning("NLNETL5 : CStandardGateway::createSecurityPlugin : can't create a security plug-in for class '%s'", className.c_str());
|
|
return;
|
|
}
|
|
|
|
// store the security plug-in
|
|
_SecurityPlugin = gs;
|
|
|
|
// update security for all existing proxies
|
|
TModuleProxies::iterator first(_ModuleProxies.begin()), last(_ModuleProxies.end());
|
|
for (; first != last; ++first)
|
|
{
|
|
IModuleProxy *proxy = first->second;
|
|
_SecurityPlugin->onNewProxy(proxy);
|
|
}
|
|
}
|
|
/** Send a command to the security plug-in */
|
|
virtual void sendSecurityCommand(const TParsedCommandLine &command)
|
|
{
|
|
if (_SecurityPlugin != NULL)
|
|
{
|
|
nlwarning("NLNETL5 : CStandardGateway::sendSecurityCommand : plug-in NOT created ");
|
|
return;
|
|
}
|
|
|
|
_SecurityPlugin->onCommand(command);
|
|
}
|
|
|
|
/** Remove the security plug-in.
|
|
*/
|
|
virtual void removeSecurityPlugin()
|
|
{
|
|
if (_SecurityPlugin == NULL)
|
|
{
|
|
nlwarning("NLNETL5 : CStandardGateway::removeSecurityPlugin : plug-in not created");
|
|
return;
|
|
}
|
|
|
|
// delete the plug-in (this can remove some security data)
|
|
_SecurityPlugin->onDelete();
|
|
delete _SecurityPlugin;
|
|
_SecurityPlugin = NULL;
|
|
}
|
|
|
|
/** Set a security data block. If a bloc of the same type
|
|
* already exist in the list, the new one will replace the
|
|
* existing one.
|
|
*/
|
|
void setSecurityData(IModuleProxy *proxy, TSecurityData *securityData)
|
|
{
|
|
nlassert(proxy->getModuleGateway() == this);
|
|
nlassert(securityData->NextItem == NULL);
|
|
|
|
CModuleProxy *modProx = dynamic_cast<CModuleProxy*>(proxy);
|
|
nlassert(modProx != NULL);
|
|
|
|
// look in the existing security for a matching type and remove it
|
|
removeSecurityData(proxy, securityData->DataTag);
|
|
|
|
// now, store the security data
|
|
securityData->NextItem = modProx->_SecurityData;
|
|
modProx->_SecurityData = securityData;
|
|
|
|
|
|
}
|
|
|
|
/** Clear a block of security data
|
|
* The block is identified by the data tag
|
|
*/
|
|
bool removeSecurityData(IModuleProxy *proxy, uint8 dataTag)
|
|
{
|
|
nlassert(proxy->getModuleGateway() == this);
|
|
|
|
CModuleProxy *modProx = dynamic_cast<CModuleProxy*>(proxy);
|
|
nlassert(modProx != NULL);
|
|
|
|
bool ret = false;
|
|
TSecurityData *prevSec = NULL;
|
|
TSecurityData *currentSec = modProx->_SecurityData;
|
|
while (currentSec != NULL)
|
|
{
|
|
if (currentSec->DataTag == dataTag)
|
|
{
|
|
if (prevSec != NULL)
|
|
prevSec->NextItem = currentSec->NextItem;
|
|
else
|
|
modProx->_SecurityData = currentSec->NextItem;
|
|
|
|
TSecurityData *toDelete = currentSec;
|
|
currentSec = currentSec->NextItem;
|
|
toDelete->NextItem = NULL;
|
|
delete toDelete;
|
|
ret = true;
|
|
}
|
|
else
|
|
{
|
|
prevSec = currentSec;
|
|
currentSec = currentSec->NextItem;
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
void replaceAllSecurityDatas(IModuleProxy *proxy, TSecurityData *securityData)
|
|
{
|
|
nlassert(proxy->getModuleGateway() == this);
|
|
|
|
CModuleProxy *modProx = dynamic_cast<CModuleProxy*>(proxy);
|
|
nlassert(modProx != NULL);
|
|
nlassert(modProx->_SecurityData != securityData);
|
|
|
|
if (modProx->_SecurityData != NULL)
|
|
delete modProx->_SecurityData;
|
|
|
|
modProx->_SecurityData = securityData;
|
|
}
|
|
|
|
/** Ask the gateway to resend the security data.
|
|
* The plug-in call this method after having changed
|
|
* the security info for a plug-in outside of the
|
|
* onNewProxy call.
|
|
*/
|
|
void forceSecurityUpdate(IModuleProxy *proxy)
|
|
{
|
|
TRouteList::iterator first(_Routes.begin()), last(_Routes.end());
|
|
for (; first != last; ++first)
|
|
{
|
|
CGatewayRoute *route = *first;
|
|
|
|
if (isModuleProxyVisible(proxy, route))
|
|
{
|
|
updateModuleSecurityDataToRoute(route, proxy);
|
|
}
|
|
}
|
|
}
|
|
|
|
/***********************************/
|
|
/* Inter gateway message reception */
|
|
/***********************************/
|
|
|
|
/** A gateway receive module operation */
|
|
void onReceiveModuleMessage(CGatewayRoute *from, const CMessage &msgin)
|
|
{
|
|
H_AUTO(CModuleGetaway_onReceiveModuleMessage);
|
|
// clean the message type now, any return path will be safe
|
|
from->NextMessageType = CModuleMessageHeaderCodec::mt_invalid;
|
|
|
|
// Retrieve sender and destination proxy and recall gateway send method
|
|
IModuleProxy *senderProxy;
|
|
IModuleProxy *addresseeProxy;
|
|
|
|
TModuleProxies::iterator it;
|
|
|
|
// sender proxy
|
|
it = _ModuleProxies.find(from->NextSenderProxyId);
|
|
if (it == _ModuleProxies.end())
|
|
{
|
|
nlwarning("Can't dispatch the module message, sender proxy %u is not in this gateway", from->NextSenderProxyId);
|
|
return;
|
|
}
|
|
senderProxy = it->second;
|
|
// addressee proxy
|
|
it = _ModuleProxies.find(from->NextAddresseeProxyId);
|
|
if (it == _ModuleProxies.end())
|
|
{
|
|
nlwarning("Can't dispatch the module message '%s', sender proxy %u is not in this gateway", msgin.getName().c_str(), from->NextAddresseeProxyId);
|
|
return;
|
|
}
|
|
addresseeProxy = it->second;
|
|
|
|
// give the message to the gateway (either for local dispatch or for forwarding)
|
|
sendModuleMessage(senderProxy, addresseeProxy, msgin);
|
|
}
|
|
|
|
// A gateway receive a module message header
|
|
void onReceiveModuleMessageHeader(CGatewayRoute *from, const CMessage &msgin)
|
|
{
|
|
H_AUTO(CModuleGetaway_onReceiveModuleMessageHeader);
|
|
if (from->NextMessageType != CModuleMessageHeaderCodec::mt_invalid)
|
|
{
|
|
// juste warn (but that is VERY BAD)
|
|
nlwarning("Receiving a new module message header without having received the previous module message !");
|
|
}
|
|
|
|
// store the message information in the route
|
|
CModuleMessageHeaderCodec::decode(
|
|
msgin,
|
|
from->NextMessageType,
|
|
from->NextSenderProxyId,
|
|
from->NextAddresseeProxyId);
|
|
|
|
// translate sender id
|
|
const TModuleId *pmoduleId = from->ForeignToLocalIdx.getB(from->NextSenderProxyId);
|
|
if (pmoduleId == NULL)
|
|
{
|
|
nlwarning("The sender proxy %u is unknown in the translation table, can't dispatch the message !", from->NextSenderProxyId);
|
|
from->NextMessageType = CModuleMessageHeaderCodec::mt_invalid;
|
|
return;
|
|
}
|
|
from->NextSenderProxyId = *pmoduleId;
|
|
// now, wait the message body
|
|
}
|
|
|
|
/** A gateway receive a general update message */
|
|
void onReceiveModuleUpdate(CGatewayRoute *from, const CMessage &msgin)
|
|
{
|
|
H_AUTO(CModuleGetaway_onReceiveModuleUpdate);
|
|
while (uint32(msgin.getPos()) != msgin.length())
|
|
{
|
|
CGatewayRoute::TPendingEventType type = CGatewayRoute::pet_disclose_module;
|
|
// msgin.serialShortEnum(type);
|
|
nlRead(msgin, serialShortEnum, type);
|
|
|
|
switch (type)
|
|
{
|
|
case CGatewayRoute::pet_disclose_module:
|
|
|
|
onReceiveModuleAdd(from, msgin);
|
|
|
|
break;
|
|
case CGatewayRoute::pet_undisclose_module:
|
|
|
|
onReceiveModuleRemove(from, msgin);
|
|
|
|
break;
|
|
case CGatewayRoute::pet_update_distance:
|
|
|
|
onReceiveModuleDistanceUpdate(from, msgin);
|
|
|
|
break;
|
|
case CGatewayRoute::pet_update_security:
|
|
|
|
onReceiveModuleSecurityUpdate(from, msgin);
|
|
|
|
break;
|
|
default:
|
|
// should not append
|
|
nlstop;
|
|
}
|
|
}
|
|
}
|
|
|
|
/** A gateway send new modules information */
|
|
void onReceiveModuleAdd(CGatewayRoute *from, const CMessage &msgin)
|
|
{
|
|
H_AUTO(CModuleGetaway_onReceiveModuleAdd);
|
|
TModuleDescCodec modDesc;
|
|
nlRead(msgin, serial, modDesc);
|
|
|
|
// for each received module info
|
|
TStringId modNameId = CStringMapper::map(modDesc.ModuleFullName);
|
|
/// store the module information
|
|
TKnownModuleInfo modInfo;
|
|
modInfo.ForeignProxyId = modDesc.ModuleProxyId;
|
|
modInfo.ModuleClassId = CStringMapper::map(modDesc.ModuleClass);
|
|
modInfo.ModuleDistance = modDesc.ModuleDistance;
|
|
modInfo.Route = from;
|
|
|
|
nldebug("Gateway '%s' : store module info for '%s' (foreign ID %u) @ %u hop",
|
|
getGatewayName().c_str(),
|
|
modDesc.ModuleFullName.c_str(),
|
|
modDesc.ModuleProxyId,
|
|
modDesc.ModuleDistance);
|
|
|
|
// Store module information
|
|
_KnownModules.insert(make_pair(modNameId, modInfo));
|
|
|
|
if (_NameToProxyIdx.getB(modNameId) != NULL)
|
|
{
|
|
// a proxy for this module already exist,
|
|
IModuleProxy *modProx = *(_NameToProxyIdx.getB(modNameId));
|
|
|
|
// fill the id translation table
|
|
// from->ForeignToLocalIdx.insert(make_pair(modDesc.ModuleProxyId, modProx->getModuleProxyId()));
|
|
from->ForeignToLocalIdx.add(modDesc.ModuleProxyId, modProx->getModuleProxyId());
|
|
|
|
// check if this route is better
|
|
if (modProx->getModuleDistance() > modInfo.ModuleDistance)
|
|
{
|
|
// update module distance and swap route
|
|
CModuleProxy *proxy = static_cast<CModuleProxy*>(modProx);
|
|
|
|
nldebug("Gateway '%s' : Use a shorter path for '%s' from %u to %u hops",
|
|
getGatewayName().c_str(),
|
|
modDesc.ModuleFullName.c_str(),
|
|
proxy->_Distance,
|
|
modInfo.ModuleDistance);
|
|
|
|
proxy->_Distance = modInfo.ModuleDistance;
|
|
proxy->_Route = modInfo.Route;
|
|
|
|
sendModuleDistanceUpdate(proxy);
|
|
}
|
|
|
|
// update the security if needed
|
|
if (modDesc.SecDesc.SecurityData != NULL)
|
|
{
|
|
CModuleProxy *proxy = static_cast<CModuleProxy *>(modProx);
|
|
if (_SecurityPlugin != NULL)
|
|
{
|
|
_SecurityPlugin->onNewSecurityData(from, proxy, modDesc.SecDesc.SecurityData);
|
|
}
|
|
else
|
|
{
|
|
if (proxy->_SecurityData != NULL)
|
|
delete proxy->_SecurityData;
|
|
proxy->_SecurityData = modDesc.SecDesc.SecurityData;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// we need to create a new proxy
|
|
// create a module proxy
|
|
IModuleProxy *modProx = IModuleManager::getInstance().createModuleProxy(
|
|
this,
|
|
from,
|
|
modDesc.ModuleDistance,
|
|
NULL,
|
|
modDesc.ModuleClass,
|
|
modDesc.ModuleFullName,
|
|
modDesc.ModuleManifest,
|
|
modDesc.ModuleProxyId);
|
|
|
|
// set the module security
|
|
CModuleProxy *proxy = static_cast<CModuleProxy *>(modProx);
|
|
proxy->_SecurityData = modDesc.SecDesc.SecurityData;
|
|
// let the security plug-in add/remove security data
|
|
if (_SecurityPlugin != NULL)
|
|
_SecurityPlugin->onNewProxy(proxy);
|
|
|
|
// store the proxy in the proxy list
|
|
_ModuleProxies.insert(make_pair(modProx->getModuleProxyId(), modProx));
|
|
_NameToProxyIdx.add(modNameId, modProx);
|
|
|
|
// Fill the proxy id translation table for this route
|
|
// from->ForeignToLocalIdx.insert(make_pair(modDesc.ModuleProxyId, modProx->getModuleProxyId()));
|
|
from->ForeignToLocalIdx.add(modDesc.ModuleProxyId, modProx->getModuleProxyId());
|
|
|
|
// trigger an event in the gateway
|
|
onAddModuleProxy(modProx);
|
|
}
|
|
}
|
|
|
|
void onReceiveModuleRemove(CGatewayRoute *from, const CMessage &msgin)
|
|
{
|
|
H_AUTO(CModuleGetaway_onReceiveModuleRemove);
|
|
TModuleId moduleId;
|
|
nlRead(msgin, serial, moduleId);
|
|
|
|
removeForeignModule(from, moduleId);
|
|
}
|
|
|
|
void onReceiveModuleDistanceUpdate(CGatewayRoute *from, const CMessage &msgin)
|
|
{
|
|
H_AUTO(CModuleGetaway_onReceiveModuleDistanceUpdate);
|
|
TModuleId moduleId;
|
|
uint32 newDistance;
|
|
|
|
nlRead(msgin, serial, moduleId);
|
|
nlRead(msgin, serial, newDistance);
|
|
|
|
// translate the module id
|
|
const TModuleId *pModuleId = from->ForeignToLocalIdx.getB(moduleId);
|
|
if (pModuleId == NULL)
|
|
{
|
|
nlwarning("Receive a module distance update for foreign module %u, but no translation available", moduleId);
|
|
return;
|
|
}
|
|
|
|
TModuleId localId = *pModuleId;
|
|
|
|
// now, retrieve the module info and update
|
|
TModuleProxies::iterator it2(_ModuleProxies.find(localId));
|
|
nlassert(it2 != _ModuleProxies.end());
|
|
CModuleProxy *proxy = static_cast<CModuleProxy*>(it2->second.getPtr());
|
|
|
|
pair<TKnownModuleInfos::iterator, TKnownModuleInfos::iterator> range;
|
|
range = _KnownModules.equal_range(proxy->_FullyQualifiedModuleName);
|
|
|
|
for (; range.first != range.second; ++range.first)
|
|
{
|
|
TKnownModuleInfo &kmi = range.first->second;
|
|
if (kmi.Route == from)
|
|
{
|
|
// we found the module info, update the data
|
|
nldebug("Gateway '%s' : updating distance from %u to %u hop for module '%s'",
|
|
getGatewayName().c_str(),
|
|
kmi.ModuleDistance,
|
|
newDistance,
|
|
CStringMapper::unmap(range.first->first).c_str());
|
|
kmi.ModuleDistance = newDistance;
|
|
break;
|
|
}
|
|
}
|
|
nlassert(range.first != range.second);
|
|
|
|
// check if the changed module is the one currently in use
|
|
if (proxy->_Route == from)
|
|
{
|
|
// two task : first, if the new distance is greater, look
|
|
// in available route for a shorter path,
|
|
// second, send a module distance update for this module.
|
|
if (proxy->_Distance < newDistance)
|
|
{
|
|
// look for a shorter path
|
|
range = _KnownModules.equal_range(proxy->_FullyQualifiedModuleName);
|
|
|
|
for (; range.first != range.second; ++range.first)
|
|
{
|
|
TKnownModuleInfo &kmi = range.first->second;
|
|
if (kmi.ModuleDistance < proxy->_Distance)
|
|
{
|
|
nldebug("Gateway '%s' : proxy '%s' use a new path from %u to %u hop",
|
|
getGatewayName().c_str(),
|
|
proxy->getModuleName().c_str(),
|
|
proxy->_Distance,
|
|
kmi.ModuleDistance);
|
|
// this path is shorter, use it now
|
|
proxy->_Route = kmi.Route;
|
|
proxy->_ForeignModuleId = kmi.ForeignProxyId;
|
|
proxy->_Distance = kmi.ModuleDistance;
|
|
break;
|
|
}
|
|
}
|
|
if (range.first == range.second)
|
|
{
|
|
// no shorter path found, update the proxy
|
|
nldebug("Gateway '%s' : proxy '%s' path distance changed from %u to %u hop",
|
|
getGatewayName().c_str(),
|
|
proxy->getModuleName().c_str(),
|
|
proxy->_Distance,
|
|
newDistance);
|
|
|
|
proxy->_Distance = newDistance;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// the new distance is shorter, just update
|
|
nldebug("Gateway '%s' : proxy '%s' path distance reduced from %u to %u hop",
|
|
getGatewayName().c_str(),
|
|
proxy->getModuleName().c_str(),
|
|
proxy->_Distance,
|
|
newDistance);
|
|
|
|
proxy->_Distance = newDistance;
|
|
}
|
|
|
|
// send the distance update
|
|
sendModuleDistanceUpdate(proxy);
|
|
}
|
|
}
|
|
|
|
void onReceiveModuleSecurityUpdate(CGatewayRoute *from, const CMessage &msgin)
|
|
{
|
|
H_AUTO(CModuleGetaway_onReceiveModuleSecurityUpdate);
|
|
// TModuleId foreignModuleId;
|
|
// TSecurityData *modSec;
|
|
TModuleSecurityChangeMsg secChg;
|
|
|
|
nlRead(msgin, serial, secChg);
|
|
// msgin.serial(foreignModuleId);
|
|
// msgin.serialPolyPtr(modSec);
|
|
|
|
const TModuleId *pModuleId = from->ForeignToLocalIdx.getB(secChg.ModuleId);
|
|
if (pModuleId == NULL)
|
|
{
|
|
nlwarning("LNETL6 : receive module security update for unknown module foreign proxy %u", secChg.ModuleId);
|
|
return;
|
|
}
|
|
|
|
TModuleId moduleId = *pModuleId;
|
|
|
|
CModuleProxy *modProx = getModuleProxy(moduleId);
|
|
if (modProx == NULL)
|
|
{
|
|
nlwarning("LNETL6 : receive module security update for unknown module proxy %u, foreign %u", moduleId, secChg.ModuleId);
|
|
return;
|
|
}
|
|
|
|
// allow the security plug-in to affect the data
|
|
if( _SecurityPlugin != NULL)
|
|
{
|
|
// let the plug-in update the security data
|
|
_SecurityPlugin->onNewSecurityData(from, modProx, secChg.SecDesc.SecurityData);
|
|
}
|
|
else
|
|
{
|
|
// update the security data in the proxy
|
|
replaceAllSecurityDatas(modProx, secChg.SecDesc.SecurityData);
|
|
}
|
|
|
|
// warn local module about new security data
|
|
{
|
|
TPluggedModules::TAToBMap::const_iterator first(_PluggedModules.getAToBMap().begin()), last(_PluggedModules.getAToBMap().end());
|
|
for (; first != last; ++first)
|
|
{
|
|
IModule *module = first->second;
|
|
|
|
module->onModuleSecurityChange(modProx);
|
|
}
|
|
}
|
|
|
|
// update the security to peers
|
|
{
|
|
TRouteList::iterator first(_Routes.begin()), last(_Routes.end());
|
|
for (; first != last; ++first)
|
|
{
|
|
CGatewayRoute *route = *first;
|
|
if (isModuleProxyVisible(modProx, route))
|
|
{
|
|
updateModuleSecurityDataToRoute(route, modProx);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
virtual void onAddModuleProxy(IModuleProxy *addedModule)
|
|
{
|
|
H_AUTO(CModuleGetaway_onAddmoduleProxy);
|
|
// disclose module to local modules
|
|
discloseModule(addedModule);
|
|
|
|
// and send module info to any route
|
|
|
|
// for each route
|
|
TRouteList::iterator first(_Routes.begin()), last(_Routes.end());
|
|
for (; first != last; ++first)
|
|
{
|
|
CGatewayRoute *route = *first;
|
|
// only send info to other routes
|
|
if (isModuleProxyVisible(addedModule, route))
|
|
{
|
|
discloseModuleToRoute(route, addedModule);
|
|
}
|
|
}
|
|
}
|
|
|
|
virtual void onRemoveModuleProxy(IModuleProxy *removedModule)
|
|
{
|
|
H_AUTO(CModuleGetaway_onRemoveModuleProxy);
|
|
// for each route
|
|
{
|
|
// for each route
|
|
TRouteList::iterator first(_Routes.begin()), last(_Routes.end());
|
|
for (; first != last; ++first)
|
|
{
|
|
CGatewayRoute *route = *first;
|
|
// only send info to other routes
|
|
if (isModuleProxyVisible(removedModule, route))
|
|
{
|
|
undiscloseModuleToRoute(route, removedModule);
|
|
}
|
|
}
|
|
}
|
|
|
|
// warn any locally plugged module
|
|
{
|
|
TPluggedModules::TAToBMap::const_iterator first(_PluggedModules.getAToBMap().begin()), last(_PluggedModules.getAToBMap().end());
|
|
for (; first != last; ++first)
|
|
{
|
|
IModule *module = first->second;
|
|
if (removedModule->getGatewayRoute() != NULL
|
|
|| module->getModuleId() != removedModule->getForeignModuleId())
|
|
{
|
|
module->_onModuleDown(removedModule);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
virtual void discloseModule(IModuleProxy *moduleProxy)
|
|
throw (EGatewayNotConnected)
|
|
{
|
|
nlassert(moduleProxy->getModuleGateway() == this);
|
|
|
|
// warn any plugged module
|
|
TPluggedModules::TAToBMap::const_iterator first(_PluggedModules.getAToBMap().begin()), last(_PluggedModules.getAToBMap().end());
|
|
for (; first != last; ++first)
|
|
{
|
|
IModule *module = first->second;
|
|
if (moduleProxy->getGatewayRoute() != NULL
|
|
|| module->getModuleId() != moduleProxy->getForeignModuleId())
|
|
{
|
|
module->_onModuleUp(moduleProxy);
|
|
}
|
|
}
|
|
}
|
|
|
|
virtual IModuleProxy *getPluggedModuleProxy(IModule *pluggedModule)
|
|
{
|
|
TLocalModuleIndex::iterator it(_LocalModuleIndex.find(pluggedModule->getModuleId()));
|
|
|
|
if (it == _LocalModuleIndex.end())
|
|
return NULL;
|
|
else
|
|
{
|
|
TModuleProxies::iterator it2(_ModuleProxies.find(it->second));
|
|
nlassert(it2 != _ModuleProxies.end());
|
|
return it2->second;
|
|
}
|
|
}
|
|
|
|
virtual uint32 getProxyCount() const
|
|
{
|
|
return (uint32)_ModuleProxies.size();
|
|
}
|
|
|
|
/// Fill a vector with the list of proxies managed here. The module are filled in ascending proxy id order.
|
|
virtual void getModuleProxyList(std::vector<IModuleProxy*> &resultList) const
|
|
{
|
|
TModuleProxies::const_iterator first(_ModuleProxies.begin()), last(_ModuleProxies.end());
|
|
for (; first != last; ++first)
|
|
{
|
|
resultList.push_back(first->second);
|
|
}
|
|
}
|
|
|
|
|
|
virtual void sendModuleMessage(IModuleProxy *senderProxy, IModuleProxy *addresseeProxy, const NLNET::CMessage &message)
|
|
{
|
|
H_AUTO(CModuleGetaway_sendModuleMessage);
|
|
// manage firewall
|
|
if (addresseeProxy->getGatewayRoute()
|
|
&& addresseeProxy->getGatewayRoute()->getTransport()->Firewalled)
|
|
{
|
|
CGatewayRoute *route = addresseeProxy->getGatewayRoute();
|
|
// the destination route is firewalled, we need to
|
|
// disclose the sender module if it's not already done
|
|
if (route->FirewallDisclosed.find(senderProxy->getModuleProxyId()) == route->FirewallDisclosed.end())
|
|
{
|
|
discloseModuleToRoute(route, senderProxy);
|
|
route->FirewallDisclosed.insert(senderProxy->getModuleProxyId());
|
|
}
|
|
}
|
|
|
|
// check for visibility rules
|
|
if (!isModuleProxyVisible(addresseeProxy, senderProxy->getGatewayRoute()))
|
|
{
|
|
nlwarning("Module %u '%s' try to send message to %u '%s' but addressee is not visible, message discarded",
|
|
senderProxy->getModuleProxyId(),
|
|
senderProxy->getModuleName().c_str(),
|
|
addresseeProxy->getModuleProxyId(),
|
|
addresseeProxy->getModuleName().c_str());
|
|
return;
|
|
}
|
|
|
|
if (addresseeProxy->getGatewayRoute() == NULL)
|
|
{
|
|
// the module is local, just forward the call to the dispatcher
|
|
nlassert(senderProxy != NULL);
|
|
nlassert(_ModuleProxies.find(senderProxy->getModuleProxyId()) != _ModuleProxies.end());
|
|
|
|
// invert the message for immediate dispatching if needed
|
|
if (!message.isReading())
|
|
const_cast<CMessage&>(message).invert();
|
|
|
|
// check if the module support immediate dispatching
|
|
TModuleId addresseeModId = addresseeProxy->getForeignModuleId();
|
|
|
|
const TModulePtr *adrcp = _PluggedModules.getB(addresseeModId);
|
|
if (adrcp == NULL)
|
|
{
|
|
nlwarning("sendModuleMessage : can't find addressee module %u that is not plugged here !", addresseeModId);
|
|
return;
|
|
}
|
|
|
|
IModule *addreseeMod = *adrcp;
|
|
if (!addreseeMod->isImmediateDispatchingSupported())
|
|
{
|
|
// dispatch the message at next gateway update
|
|
// this provide a coherent behavior between local and distant module message exchange
|
|
|
|
_LocalMessages.push_back(TLocalMessage());
|
|
TLocalMessage &lm = _LocalMessages.back();
|
|
lm.SenderProxyId = senderProxy->getModuleProxyId();
|
|
lm.AddresseProxyId = addresseeProxy->getModuleProxyId();
|
|
|
|
nldebug("NETL6 : gateway '%s' : queuing local message '%s' from proxy %u to proxy %u",
|
|
getModuleName().c_str(),
|
|
message.getName().c_str(),
|
|
lm.SenderProxyId,
|
|
lm.AddresseProxyId);
|
|
|
|
if (message.hasLockedSubMessage())
|
|
{
|
|
lm.Message.assignFromSubMessage(message);
|
|
}
|
|
else
|
|
{
|
|
lm.Message = message;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// immediate dispatching
|
|
dispatchModuleMessage(senderProxy, addresseeProxy, message);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// the module is distant, send the message via the route
|
|
// create a message for sending
|
|
CMessage msgHeader("MOD_OP");
|
|
CModuleMessageHeaderCodec::encode(
|
|
msgHeader,
|
|
CModuleMessageHeaderCodec::mt_oneway,
|
|
senderProxy->getModuleProxyId(),
|
|
addresseeProxy->getForeignModuleId());
|
|
|
|
// send any pending module info
|
|
sendPendingModuleUpdate(addresseeProxy->getGatewayRoute());
|
|
|
|
// send the header
|
|
addresseeProxy->getGatewayRoute()->sendMessage(msgHeader);
|
|
// send the message
|
|
addresseeProxy->getGatewayRoute()->sendMessage(message);
|
|
}
|
|
}
|
|
virtual void dispatchModuleMessage(IModuleProxy *senderProxy, IModuleProxy *addresseeProxy, const CMessage &message)
|
|
{
|
|
H_AUTO(CModuleGetaway_dispatchModuleMessage);
|
|
CMessage::TMessageType msgType = message.getType();
|
|
// retrieve the address module from the proxy
|
|
nlassert(addresseeProxy->getGatewayRoute() == NULL);
|
|
// As the addressee is local, the foreign proxy id is the local module id (a bit triky...)
|
|
TModuleId addresseeModId = addresseeProxy->getForeignModuleId();
|
|
|
|
const TModulePtr *adrcp = _PluggedModules.getB(addresseeModId);
|
|
if (adrcp == NULL)
|
|
{
|
|
nlwarning("dispatchModuleMessage : dispatching a message to module %u that is not plugged here !", addresseeModId);
|
|
return;
|
|
}
|
|
|
|
IModule *addreseeMod = *adrcp;
|
|
|
|
// finally, transmit the message to the module
|
|
// addreseeMod->onProcessModuleMessage(senderProxy, message);
|
|
try
|
|
{
|
|
addreseeMod->onReceiveModuleMessage(senderProxy, message);
|
|
}
|
|
catch(...)
|
|
{
|
|
nlwarning("An exception was thrown while dispatching message '%s' from '%s' to '%s'",
|
|
message.getName().c_str(),
|
|
senderProxy->getModuleName().c_str(),
|
|
addresseeProxy->getModuleName().c_str());
|
|
|
|
if (msgType == CMessage::Request)
|
|
{
|
|
// send back an exception message
|
|
CMessage except;
|
|
except.setType("EXCEPT", CMessage::Except);
|
|
senderProxy->sendModuleMessage(addreseeMod, except);
|
|
}
|
|
}
|
|
}
|
|
/***********************************************************
|
|
** Module methods
|
|
***********************************************************/
|
|
bool initModule(const TParsedCommandLine &initInfo)
|
|
{
|
|
bool ret = CModuleBase::initModule(initInfo);
|
|
|
|
// no options for now
|
|
|
|
registerSocket();
|
|
registerGateway();
|
|
|
|
return ret;
|
|
}
|
|
|
|
std::string buildModuleManifest() const
|
|
{
|
|
return string();
|
|
}
|
|
|
|
|
|
void onServiceUp(const std::string &/* serviceName */, NLNET::TServiceId /* serviceId */)
|
|
{
|
|
}
|
|
void onServiceDown(const std::string &/* serviceName */, NLNET::TServiceId /* serviceId */)
|
|
{
|
|
}
|
|
void onModuleUpdate()
|
|
{
|
|
H_AUTO(CModuleGetaway_onModuleUpdate);
|
|
// send waiting local messages
|
|
while (!_LocalMessages.empty())
|
|
{
|
|
TLocalMessage &lm = _LocalMessages.front();
|
|
|
|
IModuleProxy *senderProx = getModuleProxy(lm.SenderProxyId);
|
|
IModuleProxy *addresseeProx = getModuleProxy(lm.AddresseProxyId);
|
|
|
|
if (senderProx == NULL)
|
|
{
|
|
nlwarning("CStandardGateway : local message dispatching : Failed to retrieve proxy for sender module %u while dispatching message '%s' to %u",
|
|
lm.SenderProxyId,
|
|
lm.Message.getName().c_str(),
|
|
lm.AddresseProxyId);
|
|
}
|
|
else if (addresseeProx == NULL)
|
|
{
|
|
nlwarning("CStandardGateway : local message dispatching : Failed to retrieve proxy for addressee module %u while dispatching message '%s' from %u",
|
|
lm.AddresseProxyId,
|
|
lm.Message.getName().c_str(),
|
|
lm.SenderProxyId);
|
|
}
|
|
else
|
|
{
|
|
// we can dispatch the message
|
|
dispatchModuleMessage(senderProx, addresseeProx, lm.Message);
|
|
}
|
|
|
|
_LocalMessages.pop_front();
|
|
}
|
|
|
|
// send pending module un/disclosure
|
|
{
|
|
TRouteList::iterator first(_Routes.begin()), last(_Routes.end());
|
|
for (; first != last; ++first)
|
|
{
|
|
CGatewayRoute *route = *first;
|
|
sendPendingModuleUpdate(route);
|
|
}
|
|
}
|
|
// update the transports
|
|
{
|
|
TTransportList::iterator first(_Transports.begin()), last(_Transports.end());
|
|
for (; first != last; ++first)
|
|
{
|
|
IGatewayTransport *transport = first->second;
|
|
|
|
transport->update();
|
|
}
|
|
}
|
|
}
|
|
|
|
void onApplicationExit()
|
|
{
|
|
// delete all transport
|
|
while (!_Transports.empty())
|
|
{
|
|
deleteTransport(_Transports.begin()->first);
|
|
}
|
|
}
|
|
|
|
void onModuleUp(IModuleProxy * /* moduleProxy */)
|
|
{
|
|
}
|
|
void onModuleDown(IModuleProxy * /* moduleProxy */)
|
|
{
|
|
}
|
|
bool onProcessModuleMessage(IModuleProxy * /* senderModuleProxy */, const CMessage &message)
|
|
{
|
|
// simple message for debug and unit testing
|
|
if (message.getName() == "DEBUG_MOD_PING")
|
|
{
|
|
_PingCounter++;
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void onModuleSecurityChange(IModuleProxy * /* moduleProxy */)
|
|
{
|
|
}
|
|
|
|
void onModuleSocketEvent(IModuleSocket * /* moduleSocket */, TModuleSocketEvent /* eventType */)
|
|
{
|
|
}
|
|
|
|
/***********************************************************
|
|
** Socket methods
|
|
***********************************************************/
|
|
|
|
const std::string &getSocketName()
|
|
{
|
|
return getModuleName();
|
|
}
|
|
|
|
void _sendModuleMessage(IModule *senderModule, TModuleId destModuleProxyId, const NLNET::CMessage &message )
|
|
throw (EModuleNotReachable, EModuleNotPluggedHere)
|
|
{
|
|
// the socket implementation already checked that the module is plugged here
|
|
// just check that the destination module effectively from here
|
|
TLocalModuleIndex::iterator it(_LocalModuleIndex.find(senderModule->getModuleId()));
|
|
nlassert(it != _LocalModuleIndex.end());
|
|
|
|
// get the sender proxy
|
|
TModuleProxies::iterator it2(_ModuleProxies.find(it->second));
|
|
nlassert(it2 != _ModuleProxies.end());
|
|
|
|
IModuleProxy *senderProx = it2->second;
|
|
|
|
// get the addressee proxy
|
|
it2 = _ModuleProxies.find(destModuleProxyId);
|
|
nlassert(it2 != _ModuleProxies.end());
|
|
|
|
IModuleProxy *destProx = it2->second;
|
|
|
|
|
|
sendModuleMessage(senderProx, destProx, message);
|
|
}
|
|
|
|
virtual void _broadcastModuleMessage(IModule *senderModule, const NLNET::CMessage &message)
|
|
throw (EModuleNotPluggedHere)
|
|
{
|
|
H_AUTO(CModuleGetaway__broadcastModuleMessage);
|
|
// send the message to all proxies (except the sender module)
|
|
TLocalModuleIndex::iterator it(_LocalModuleIndex.find(senderModule->getModuleId()));
|
|
nlassert(it != _LocalModuleIndex.end());
|
|
|
|
TModuleProxies::iterator first(_ModuleProxies.begin()), last(_ModuleProxies.end());
|
|
for (; first != last; ++first)
|
|
{
|
|
IModuleProxy *proxy = first->second;
|
|
|
|
proxy->sendModuleMessage(senderModule, message);
|
|
}
|
|
}
|
|
|
|
void onModulePlugged(IModule *pluggedModule)
|
|
{
|
|
nldebug("NETL6: Gateway %s : plugging module '%s' id=%u",
|
|
getModuleName().c_str(),
|
|
pluggedModule->getModuleName().c_str(),
|
|
pluggedModule->getModuleId());
|
|
|
|
// A module has just been plugged here, we need to disclose it to the
|
|
// other module, and disclose other module to it.
|
|
|
|
// create a proxy for this module
|
|
IModuleProxy *modProx = IModuleManager::getInstance().createModuleProxy(
|
|
this,
|
|
NULL, // the module is local, so there is no route
|
|
0, // the module is local, distance is 0
|
|
pluggedModule, // the module is local, so store the module pointer
|
|
pluggedModule->getModuleClassName(),
|
|
pluggedModule->getModuleFullyQualifiedName(),
|
|
pluggedModule->getModuleManifest(),
|
|
pluggedModule->getModuleId() // the module is local, foreign id is the module id
|
|
);
|
|
|
|
// and store it in the proxies container
|
|
_ModuleProxies.insert(make_pair(modProx->getModuleProxyId(), modProx));
|
|
_NameToProxyIdx.add(CStringMapper::map(modProx->getModuleName()), modProx);
|
|
|
|
// and also in the local module index
|
|
_LocalModuleIndex.insert(make_pair(pluggedModule->getModuleId(), modProx->getModuleProxyId()));
|
|
|
|
|
|
// trigger the new module proxy event
|
|
onAddModuleProxy(modProx);
|
|
// // disclose the new module to other modules
|
|
// discloseModule(modProx);
|
|
//
|
|
// second, disclose already known proxies in the gateway to the plugged module
|
|
{
|
|
TModuleProxies::iterator first(_ModuleProxies.begin()), last(_ModuleProxies.end());
|
|
for (; first != last; ++first)
|
|
{
|
|
IModuleProxy *modProx = first->second;
|
|
|
|
// do not send a moduleUp on the module himself !
|
|
// either the gateway is non null (distant module), or the
|
|
// foreign module id is different of the local module (for local proxy,
|
|
// the foreign module id store the local module id).
|
|
if (modProx->getGatewayRoute() != NULL || modProx->getForeignModuleId() != pluggedModule->getModuleId())
|
|
{
|
|
pluggedModule->_onModuleUp(modProx);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
/// Called just after a module as been effectively unplugged from a socket
|
|
void onModuleUnplugged(IModule *unpluggedModule)
|
|
{
|
|
nldebug("NETL6: Gateway %s : unplugging module '%s' id=%u",
|
|
getModuleName().c_str(),
|
|
unpluggedModule->getModuleName().c_str(),
|
|
unpluggedModule->getModuleId());
|
|
|
|
// remove the proxy info
|
|
TLocalModuleIndex::iterator it(_LocalModuleIndex.find(unpluggedModule->getModuleId()));
|
|
nlassert(it != _LocalModuleIndex.end());
|
|
TModuleProxies::iterator it2(_ModuleProxies.find(it->second));
|
|
nlassert(it2 != _ModuleProxies.end());
|
|
|
|
IModuleProxy *modProx = it2->second;
|
|
|
|
// warn the unplugged module that all proxies in this gateway become unavailable
|
|
{
|
|
TModuleProxies::iterator first(_ModuleProxies.begin()), last(_ModuleProxies.end());
|
|
for (; first != last; ++first)
|
|
{
|
|
IModuleProxy *modProx = first->second;
|
|
|
|
if (modProx->getGatewayRoute() != NULL
|
|
|| modProx->getForeignModuleId() != unpluggedModule->getModuleId())
|
|
{
|
|
unpluggedModule->_onModuleDown(modProx);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// the gateway do the rest of the job
|
|
onRemoveModuleProxy(modProx);
|
|
|
|
TModuleId localProxyId = modProx->getModuleProxyId();
|
|
// remove reference to the proxy
|
|
_ModuleProxies.erase(it2);
|
|
_NameToProxyIdx.removeWithB(modProx);
|
|
_LocalModuleIndex.erase(it);
|
|
|
|
// check in the local message queue if some message are to/from
|
|
// this module
|
|
TLocalMessageList::iterator first(_LocalMessages.begin()), last(_LocalMessages.end());
|
|
for (; first != last; ++first)
|
|
{
|
|
TLocalMessage &lm = *first;
|
|
if (lm.AddresseProxyId == localProxyId
|
|
|| lm.SenderProxyId == localProxyId)
|
|
{
|
|
// erase this message !
|
|
nlwarning("CStandardGateway : while unplugging module %u from the gateway, locale message '%s' from proxy %u to proxy %u is lost",
|
|
unpluggedModule->getModuleId(),
|
|
lm.Message.getName().c_str(),
|
|
lm.SenderProxyId,
|
|
lm.AddresseProxyId);
|
|
TLocalMessageList::iterator next = first;
|
|
++next;
|
|
if (next == last)
|
|
{
|
|
_LocalMessages.erase(first);
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
_LocalMessages.erase(first);
|
|
first = next;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// release the module proxy
|
|
IModuleManager::getInstance().releaseModuleProxy(localProxyId);
|
|
|
|
}
|
|
|
|
////////////////////////////////////////////////////
|
|
// Gateway internal methods
|
|
////////////////////////////////////////////////////
|
|
|
|
void removeForeignModule(CGatewayRoute *route, TModuleId foreignModuleId)
|
|
{
|
|
// translate the module id
|
|
const TModuleId *pModuleId = route->ForeignToLocalIdx.getB(foreignModuleId);
|
|
if (pModuleId == NULL)
|
|
{
|
|
// oups !
|
|
nlwarning("removeForeignModule : unknown foreign module id %u", foreignModuleId);
|
|
return;
|
|
}
|
|
|
|
TModuleId proxyId = *pModuleId;
|
|
|
|
// retrieve the module proxy
|
|
TModuleProxies::iterator it2(_ModuleProxies.find(proxyId));
|
|
if (it2 == _ModuleProxies.end())
|
|
{
|
|
// oups !
|
|
nlwarning("Gateway '%s' : removeForeignModule : can't find proxy for id %u coming from foreign id %u",
|
|
getGatewayName().c_str(),
|
|
proxyId,
|
|
foreignModuleId);
|
|
|
|
// still remove the idx
|
|
route->ForeignToLocalIdx.removeWithA(foreignModuleId);
|
|
return;
|
|
}
|
|
CModuleProxy *modProx = static_cast<CModuleProxy *>(it2->second.getPtr());
|
|
|
|
// remove module information
|
|
pair<TKnownModuleInfos::iterator, TKnownModuleInfos::iterator> range;
|
|
range = _KnownModules.equal_range(modProx->_FullyQualifiedModuleName);
|
|
nlassert(range.first != range.second);
|
|
bool found = false;
|
|
for (;range.first != range.second; ++range.first)
|
|
{
|
|
TKnownModuleInfo &kmi = range.first->second;
|
|
|
|
if (kmi.Route == route)
|
|
{
|
|
nldebug("Gateway '%s' : removing foreign module info for '%s'",
|
|
getGatewayName().c_str(),
|
|
CStringMapper::unmap(range.first->first).c_str());
|
|
// we have found the info relative to this module
|
|
_KnownModules.erase(range.first);
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
nlassert(found == true);
|
|
// NB : stl debug mode don't allow to test with range.first when range;first is erased.
|
|
// nlassert(range.first != range.second);
|
|
|
|
// check if there is another view of this module
|
|
// if so, we keep the proxy and, eventually, we update the distance
|
|
range = _KnownModules.equal_range(modProx->_FullyQualifiedModuleName);
|
|
if (range.first != range.second)
|
|
{
|
|
// clean the translation table
|
|
route->ForeignToLocalIdx.removeWithA(foreignModuleId);
|
|
|
|
// we keep the proxy, choose the best route
|
|
TKnownModuleInfos::iterator best(_KnownModules.end());
|
|
|
|
for (; range.first != range.second; ++range.first)
|
|
{
|
|
if (best == _KnownModules.end()
|
|
|| best->second.ModuleDistance > range.first->second.ModuleDistance)
|
|
best = range.first;
|
|
}
|
|
nlassert(best != _KnownModules.end());
|
|
TKnownModuleInfo &kmi = best->second;
|
|
|
|
if (modProx->_Route != kmi.Route)
|
|
{
|
|
// the best route has changed, update the proxy
|
|
|
|
nldebug("Gateway '%s' : use a new route for module '%s' from %u to %u hop",
|
|
getGatewayName().c_str(),
|
|
modProx->getModuleName().c_str(),
|
|
modProx->_Distance,
|
|
kmi.ModuleDistance);
|
|
|
|
// update the proxy data
|
|
modProx->_Route = kmi.Route;
|
|
modProx->_ForeignModuleId = kmi.ForeignProxyId;
|
|
if (modProx->_Distance != kmi.ModuleDistance)
|
|
{
|
|
// the distance has changed, update and send the new distance to other gateway
|
|
modProx->_Distance = kmi.ModuleDistance;
|
|
sendModuleDistanceUpdate(modProx);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// do not remove proxy for local module from her !
|
|
if (modProx->_Route != NULL)
|
|
{
|
|
// this module is no longer reachable, remove the proxy
|
|
|
|
// trigger an event in the gateway
|
|
onRemoveModuleProxy(modProx);
|
|
|
|
// remove from the proxy list
|
|
_NameToProxyIdx.removeWithB(modProx);
|
|
_ModuleProxies.erase(it2);
|
|
// release the proxy
|
|
IModuleManager::getInstance().releaseModuleProxy(proxyId);
|
|
}
|
|
// clean the translation table
|
|
route->ForeignToLocalIdx.removeWithA(foreignModuleId);
|
|
}
|
|
}
|
|
|
|
void sendModuleDistanceUpdate(IModuleProxy *proxy)
|
|
{
|
|
// in fact, don't send immediately, store update in each
|
|
// route and wait the next update or module message sending
|
|
// to effectively send the update
|
|
|
|
// for each route
|
|
TRouteList::iterator first(_Routes.begin()), last(_Routes.end());
|
|
for (; first != last; ++first)
|
|
{
|
|
CGatewayRoute *route = *first;
|
|
if (isModuleProxyVisible(proxy, route))
|
|
{
|
|
updateModuleDistanceToRoute(route, proxy);
|
|
// // TODO : optimize by batch sending
|
|
// TModuleDistanceChangeMsg mdu;
|
|
//
|
|
// mdu.ModuleId = proxy->getModuleProxyId();
|
|
// mdu.NewDistance = proxy->getModuleDistance()+1;
|
|
//
|
|
// CMessage msg("MOD_DST_UPD");
|
|
// msg.serial(mdu);
|
|
//
|
|
// sendPendingModuleUpdate(route);
|
|
// route->sendMessage(msg);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Check if a module can be seen by a route
|
|
bool isModuleProxyVisible(IModuleProxy *proxy, CGatewayRoute *route)
|
|
{
|
|
if (route == NULL)
|
|
{
|
|
// no route, we can see the proxy
|
|
return true;
|
|
}
|
|
// check firewall rules
|
|
if (route->getTransport()->Firewalled)
|
|
{
|
|
if (route->FirewallDisclosed.find(proxy->getModuleProxyId()) == route->FirewallDisclosed.end())
|
|
return false;
|
|
}
|
|
|
|
// if the module is local, then, it can be seen
|
|
if (proxy->getGatewayRoute() == NULL)
|
|
return true;
|
|
|
|
// if the module is on the same route, it can't be seen (it is seen by the route outbound)
|
|
if (proxy->getGatewayRoute() == route)
|
|
return false;
|
|
|
|
IGatewayTransport *transport = route->getTransport();
|
|
// if the module is on a different transport, it can be seen
|
|
if (proxy->getGatewayRoute()->getTransport() != transport)
|
|
{
|
|
// we also need to check if this module is known in this route
|
|
// CGatewayRoute::TForeignToLocalIdx::iterator it(route->ForeignToLocalIdx.find(proxy->getForeignModuleId()));
|
|
if (route->ForeignToLocalIdx.getA(proxy->getModuleProxyId()) != NULL)
|
|
// this module is known in this route, so not invisible
|
|
return false;
|
|
|
|
// ok, we can see
|
|
return true;
|
|
}
|
|
|
|
// if the transport in not in peer invisible, it can be seen
|
|
if (!transport->PeerInvisible)
|
|
return true;
|
|
|
|
// not visible
|
|
return false;
|
|
}
|
|
|
|
/// Disclose module information to a gateway route
|
|
void discloseModuleToRoute(CGatewayRoute *route, IModuleProxy *proxy)
|
|
{
|
|
// route->PendingUndisclosure.erase(proxy->getModuleProxyId());
|
|
CGatewayRoute::TPendingEvent pe;
|
|
pe.EventType = CGatewayRoute::pet_disclose_module;
|
|
pe.ModuleId = proxy->getModuleProxyId();
|
|
route->PendingEvents.push_back(pe);
|
|
// route->PendingDisclosure.insert(proxy);
|
|
}
|
|
/// Undisclose module information to a gateway route
|
|
void undiscloseModuleToRoute(CGatewayRoute *route, IModuleProxy *proxy)
|
|
{
|
|
// route->PendingDisclosure.erase(proxy);
|
|
// route->PendingUndisclosure.insert(proxy->getModuleProxyId());
|
|
// route->FirewallDisclosed.erase(proxy->getModuleProxyId());
|
|
|
|
CGatewayRoute::TPendingEvent pe;
|
|
pe.EventType = CGatewayRoute::pet_undisclose_module;
|
|
pe.ModuleId = proxy->getModuleProxyId();
|
|
route->PendingEvents.push_back(pe);
|
|
|
|
route->FirewallDisclosed.erase(proxy->getModuleProxyId());
|
|
}
|
|
|
|
/// the distance of a module need to be update to peers
|
|
void updateModuleDistanceToRoute(CGatewayRoute *route, IModuleProxy *proxy)
|
|
{
|
|
CGatewayRoute::TPendingEvent pe;
|
|
pe.EventType = CGatewayRoute::pet_update_distance;
|
|
pe.ModuleId = proxy->getModuleProxyId();
|
|
route->PendingEvents.push_back(pe);
|
|
}
|
|
/// The security data need to be updated to peers
|
|
void updateModuleSecurityDataToRoute(CGatewayRoute *route, IModuleProxy *proxy)
|
|
{
|
|
CGatewayRoute::TPendingEvent pe;
|
|
pe.EventType = CGatewayRoute::pet_update_security;
|
|
pe.ModuleId = proxy->getModuleProxyId();
|
|
route->PendingEvents.push_back(pe);
|
|
}
|
|
|
|
void sendPendingModuleUpdate(CGatewayRoute *route)
|
|
{
|
|
if (route->PendingEvents.empty())
|
|
return;
|
|
|
|
CMessage updateMsg("MOD_UPD");
|
|
|
|
// compil all update in a single message
|
|
while (!route->PendingEvents.empty())
|
|
{
|
|
CGatewayRoute::TPendingEvent &pe = route->PendingEvents.front();
|
|
switch (pe.EventType)
|
|
{
|
|
case CGatewayRoute::pet_disclose_module:
|
|
{
|
|
IModuleProxy *proxy = getModuleProxy(pe.ModuleId);
|
|
if (proxy == NULL)
|
|
break;
|
|
|
|
// store the update type
|
|
updateMsg.serialShortEnum(pe.EventType);
|
|
|
|
// encode the message data
|
|
TModuleDescCodec modDesc(proxy);
|
|
updateMsg.serial(modDesc);
|
|
// modDesc.encode(proxy, updateMsg);
|
|
}
|
|
|
|
break;
|
|
case CGatewayRoute::pet_undisclose_module:
|
|
{
|
|
// store the update type
|
|
updateMsg.serialShortEnum(pe.EventType);
|
|
|
|
// store the module id
|
|
updateMsg.serial(pe.ModuleId);
|
|
}
|
|
|
|
break;
|
|
case CGatewayRoute::pet_update_distance:
|
|
{
|
|
IModuleProxy *proxy = getModuleProxy(pe.ModuleId);
|
|
if (proxy == NULL)
|
|
break;
|
|
|
|
// store the update type
|
|
updateMsg.serialShortEnum(pe.EventType);
|
|
|
|
// store module ID and distance
|
|
updateMsg.serial(pe.ModuleId);
|
|
uint32 distance = proxy->getModuleDistance()+1;
|
|
updateMsg.serial(distance);
|
|
}
|
|
break;
|
|
case CGatewayRoute::pet_update_security:
|
|
{
|
|
IModuleProxy *proxy = getModuleProxy(pe.ModuleId);
|
|
if (proxy == NULL)
|
|
break;
|
|
|
|
// store the update type
|
|
updateMsg.serialShortEnum(pe.EventType);
|
|
|
|
// store module ID and security data
|
|
TModuleSecurityChangeMsg secChg;
|
|
secChg.ModuleId = pe.ModuleId;
|
|
secChg.SecDesc.SecurityData = const_cast<TSecurityData*>(proxy->getFirstSecurityData());
|
|
updateMsg.serial(secChg);
|
|
// updateMsg.serial(pe.ModuleId);
|
|
// TSecurityData *modSec = const_cast<TSecurityData*>(proxy->getFirstSecurityData());
|
|
// updateMsg.serialPolyPtr(modSec);
|
|
}
|
|
break;
|
|
default:
|
|
// should not append
|
|
nlstop;
|
|
}
|
|
|
|
route->PendingEvents.pop_front();
|
|
}
|
|
|
|
// now send the message
|
|
route->sendMessage(updateMsg);
|
|
|
|
// // send pending module proxy un/disclosure
|
|
// if (!route->PendingDisclosure.empty())
|
|
// {
|
|
// // disclose new module
|
|
// TModuleAddMsg message;
|
|
// message.Modules.resize(route->PendingDisclosure.size());
|
|
//
|
|
// std::set<IModuleProxy*>::iterator first(route->PendingDisclosure.begin()), last(route->PendingDisclosure.end());
|
|
// for (uint i=0; first != last; ++i, ++first)
|
|
// {
|
|
// TModuleDescMsg &modDesc = message.Modules[i];
|
|
// IModuleProxy *addedModule = *first;
|
|
//
|
|
// modDesc.ModuleProxyId = addedModule->getModuleProxyId();
|
|
// modDesc.ModuleClass = addedModule->getModuleClassName();
|
|
// modDesc.ModuleFullName = addedModule->getModuleName();
|
|
// modDesc.ModuleDistance = addedModule->getModuleDistance()+1;
|
|
// }
|
|
// route->PendingDisclosure.clear();
|
|
//
|
|
// CMessage buffer("MOD_ADD");
|
|
// buffer.serial(message);
|
|
//
|
|
// route->sendMessage(buffer);
|
|
// }
|
|
// if (!route->PendingUndisclosure.empty())
|
|
// {
|
|
// // disclose new module
|
|
// TModuleRemMsg message;
|
|
// std::copy(route->PendingUndisclosure.begin(), route->PendingUndisclosure.end(), back_insert_iterator<vector<TModuleId> >(message.RemovedModules));
|
|
// route->PendingUndisclosure.clear();
|
|
//
|
|
// CMessage buffer("MOD_REM");
|
|
// buffer.serial(message);
|
|
//
|
|
// route->sendMessage(buffer);
|
|
// }
|
|
}
|
|
|
|
void getModuleList(std::vector<IModuleProxy*> &resultList)
|
|
{
|
|
TModuleProxies::iterator first(_ModuleProxies.begin()), last(_ModuleProxies.end());
|
|
for (; first != last; ++first)
|
|
{
|
|
resultList.push_back(first->second);
|
|
}
|
|
}
|
|
|
|
|
|
NLMISC_COMMAND_HANDLER_TABLE_EXTEND_BEGIN(CStandardGateway, CModuleBase)
|
|
NLMISC_COMMAND_HANDLER_ADD(CStandardGateway, dump, "dump various information about the gateway statue", "")
|
|
NLMISC_COMMAND_HANDLER_ADD(CStandardGateway, transportListAvailableClass, "list the available transport class", "no param")
|
|
NLMISC_COMMAND_HANDLER_ADD(CStandardGateway, transportAdd, "add a new transport to this gateway", "<transportClass> <instanceName>")
|
|
NLMISC_COMMAND_HANDLER_ADD(CStandardGateway, transportOptions, "set a gateway level option on a transport", "<transportClass> ( [PeerInvisible] [Firewalled] )")
|
|
NLMISC_COMMAND_HANDLER_ADD(CStandardGateway, transportCmd, "send a command to a transport", "[<transportName> ( <cmd specific to transport> )]*")
|
|
NLMISC_COMMAND_HANDLER_ADD(CStandardGateway, transportRemove, "remove an existing transport instance", "<transportName>")
|
|
NLMISC_COMMAND_HANDLER_ADD(CStandardGateway, securityListAvailableClass, "list the available security class", "no param")
|
|
NLMISC_COMMAND_HANDLER_ADD(CStandardGateway, securityCreate, "create a security plug-in", "<securityClassName>")
|
|
NLMISC_COMMAND_HANDLER_ADD(CStandardGateway, securityCommand, "send a command to the security plug-in", "<cmd specific to plug-in>")
|
|
NLMISC_COMMAND_HANDLER_ADD(CStandardGateway, securityRemove, "remove the security plug-in", "no parameter")
|
|
NLMISC_COMMAND_HANDLER_TABLE_END
|
|
|
|
NLMISC_CLASS_COMMAND_DECL(securityRemove)
|
|
{
|
|
nlunreferenced(rawCommandString);
|
|
nlunreferenced(args);
|
|
nlunreferenced(quiet);
|
|
nlunreferenced(human);
|
|
|
|
if (_SecurityPlugin == NULL)
|
|
{
|
|
log.displayNL("No security plug-in !");
|
|
return true;
|
|
}
|
|
|
|
removeSecurityPlugin();
|
|
|
|
return true;
|
|
}
|
|
|
|
NLMISC_CLASS_COMMAND_DECL(securityCommand)
|
|
{
|
|
nlunreferenced(args);
|
|
nlunreferenced(quiet);
|
|
nlunreferenced(human);
|
|
|
|
TParsedCommandLine command;
|
|
|
|
if (!command.parseParamList(rawCommandString))
|
|
{
|
|
log.displayNL("Invalid command line");
|
|
return false;
|
|
}
|
|
|
|
if (command.SubParams.size() < 2)
|
|
{
|
|
log.displayNL("Invalid command line");
|
|
return false;
|
|
}
|
|
|
|
if (_SecurityPlugin == NULL)
|
|
{
|
|
log.displayNL("No security plug-in !");
|
|
return true;
|
|
}
|
|
|
|
sendSecurityCommand(*command.SubParams[1]);
|
|
|
|
return true;
|
|
}
|
|
|
|
NLMISC_CLASS_COMMAND_DECL(securityCreate)
|
|
{
|
|
nlunreferenced(rawCommandString);
|
|
nlunreferenced(quiet);
|
|
nlunreferenced(human);
|
|
|
|
if (args.size() != 1)
|
|
return false;
|
|
|
|
if (_SecurityPlugin != NULL)
|
|
{
|
|
log.displayNL("The gateway already have a security plug-in ! Remove it first");
|
|
return true;
|
|
}
|
|
|
|
log.displayNL("Creating a security plug-in '%s' in gateway '%s'",
|
|
args[0].c_str(),
|
|
getModuleName().c_str());
|
|
createSecurityPlugin(args[0]);
|
|
|
|
return true;
|
|
|
|
}
|
|
NLMISC_CLASS_COMMAND_DECL(securityListAvailableClass)
|
|
{
|
|
nlunreferenced(rawCommandString);
|
|
nlunreferenced(quiet);
|
|
nlunreferenced(human);
|
|
|
|
if (args.size() != 0)
|
|
return false;
|
|
|
|
vector<string> list;
|
|
NLMISC_GET_FACTORY(CGatewaySecurity, std::string).fillFactoryList(list);
|
|
|
|
log.displayNL("List of %u available security class :", list.size());
|
|
|
|
for (uint i=0; i<list.size(); ++i)
|
|
{
|
|
log.displayNL(" '%s'", list[i].c_str());
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
NLMISC_CLASS_COMMAND_DECL(transportRemove)
|
|
{
|
|
nlunreferenced(rawCommandString);
|
|
nlunreferenced(log);
|
|
nlunreferenced(quiet);
|
|
nlunreferenced(human);
|
|
|
|
if (args.size() != 1)
|
|
return false;
|
|
|
|
deleteTransport(args[0]);
|
|
return true;
|
|
}
|
|
|
|
NLMISC_CLASS_COMMAND_DECL(transportCmd)
|
|
{
|
|
nlunreferenced(args);
|
|
nlunreferenced(quiet);
|
|
nlunreferenced(human);
|
|
|
|
TParsedCommandLine pcl;
|
|
if (!pcl.parseParamList(rawCommandString))
|
|
{
|
|
log.displayNL("Invalid parameter string, parse error");
|
|
return false;
|
|
}
|
|
|
|
transportCommand(pcl);
|
|
return true;
|
|
}
|
|
|
|
NLMISC_CLASS_COMMAND_DECL(transportOptions)
|
|
{
|
|
nlunreferenced(quiet);
|
|
nlunreferenced(human);
|
|
|
|
if (args.size() < 1)
|
|
return false;
|
|
|
|
// parse the params
|
|
TParsedCommandLine cl;
|
|
if (!cl.parseParamList(rawCommandString))
|
|
return false;
|
|
|
|
if (cl.SubParams.size() != 2)
|
|
return false;
|
|
|
|
string transName = cl.SubParams[1]->ParamName;
|
|
if (_Transports.find(transName) == _Transports.end())
|
|
{
|
|
log.displayNL("unknown transport '%s'", transName.c_str());
|
|
return false;
|
|
}
|
|
|
|
// IGatewayTransport *transport = _Transports.find(transName)->second;
|
|
|
|
// check for peer invisible
|
|
if (cl.SubParams[1]->getParam("PeerInvisible"))
|
|
setTransportPeerInvisible(transName, true);
|
|
else
|
|
setTransportPeerInvisible(transName, false);
|
|
|
|
// check for firewall mode
|
|
if (cl.SubParams[1]->getParam("Firewalled"))
|
|
setTransportFirewallMode(transName, true);
|
|
else
|
|
setTransportFirewallMode(transName, false);
|
|
|
|
return true;
|
|
}
|
|
|
|
NLMISC_CLASS_COMMAND_DECL(transportAdd)
|
|
{
|
|
nlunreferenced(rawCommandString);
|
|
nlunreferenced(quiet);
|
|
nlunreferenced(human);
|
|
|
|
if (args.size() != 2)
|
|
return false;
|
|
|
|
if (_Transports.find(args[1]) != _Transports.end())
|
|
{
|
|
log.displayNL("A transport with that name already exist !");
|
|
return true;
|
|
}
|
|
|
|
createTransport(args[0], args[1]);
|
|
return true;
|
|
}
|
|
|
|
NLMISC_CLASS_COMMAND_DECL(transportListAvailableClass)
|
|
{
|
|
nlunreferenced(rawCommandString);
|
|
nlunreferenced(quiet);
|
|
nlunreferenced(human);
|
|
|
|
if (args.size() != 0)
|
|
return false;
|
|
|
|
vector<string> list;
|
|
NLMISC_GET_FACTORY(IGatewayTransport, std::string).fillFactoryList(list);
|
|
|
|
log.displayNL("List of %u available transport class :", list.size());
|
|
|
|
for (uint i=0; i<list.size(); ++i)
|
|
{
|
|
log.displayNL(" '%s'", list[i].c_str());
|
|
}
|
|
return true;
|
|
}
|
|
|
|
NLMISC_CLASS_COMMAND_DECL(dump)
|
|
{
|
|
if (!args.empty())
|
|
return false;
|
|
|
|
// recall the dump for the module class
|
|
NLMISC_CLASS_COMMAND_CALL_BASE(CModuleBase, dump);
|
|
|
|
log.displayNL("-----------------------------");
|
|
log.displayNL("Dumping gateway information :");
|
|
log.displayNL("-----------------------------");
|
|
|
|
log.displayNL("The gateway has %u locally plugged module :", _PluggedModules.getAToBMap().size());
|
|
{
|
|
TPluggedModules::TAToBMap::const_iterator first(_PluggedModules.getAToBMap().begin()), last(_PluggedModules.getAToBMap().end());
|
|
for (; first != last; ++first)
|
|
{
|
|
IModule *module = first->second;
|
|
log.displayNL(" ID:%5u : \tName = '%s' \tclass = '%s'",
|
|
module->getModuleId(),
|
|
module->getModuleName().c_str(),
|
|
module->getModuleClassName().c_str());
|
|
}
|
|
}
|
|
|
|
|
|
log.displayNL("The gateway as %u transport activated :", _Transports.size());
|
|
{
|
|
TTransportList::iterator first(_Transports.begin()), last(_Transports.end());
|
|
for (; first != last; ++first)
|
|
{
|
|
const string &name = first->first;
|
|
IGatewayTransport *transport = first->second;
|
|
|
|
log.displayNL("Transport '%s' (transport class is '%s') :",
|
|
name.c_str(),
|
|
transport->getClassName().c_str());
|
|
log.displayNL(" * %s", transport->PeerInvisible ? "Peer module are NON visible" : "Peer modules are visible");
|
|
log.displayNL(" * %s", transport->Firewalled ? "Firewall ON" : "Firewall OFF");
|
|
transport->dump(log);
|
|
}
|
|
}
|
|
|
|
log.displayNL("------------------------------");
|
|
log.displayNL("------- End of dump ----------");
|
|
log.displayNL("------------------------------");
|
|
return true;
|
|
}
|
|
|
|
};
|
|
|
|
|
|
// register the module factory
|
|
NLNET_REGISTER_MODULE_FACTORY(CStandardGateway, "StandardGateway");
|
|
|
|
|
|
/** Set a security data block. If a bloc of the same type
|
|
* already exist in the list, the new one will replace the
|
|
* existing one.
|
|
*/
|
|
void CGatewaySecurity::setSecurityData(IModuleProxy *proxy, TSecurityData *securityData)
|
|
{
|
|
// forward the call to standard gateway
|
|
CStandardGateway *sg = static_cast<CStandardGateway*>(_Gateway);
|
|
sg->setSecurityData(proxy, securityData);
|
|
}
|
|
|
|
/** Clear a block of security data
|
|
* The block is identified by the data tag
|
|
*/
|
|
bool CGatewaySecurity::removeSecurityData(IModuleProxy *proxy, uint8 dataTag)
|
|
{
|
|
// forward the call to standard gateway
|
|
CStandardGateway *sg = static_cast<CStandardGateway*>(_Gateway);
|
|
return sg->removeSecurityData(proxy, dataTag);
|
|
}
|
|
|
|
/** Replace the complete set of security data with the new one.
|
|
* Security data allocated on the proxy are freed,
|
|
*/
|
|
void CGatewaySecurity::replaceAllSecurityDatas(IModuleProxy *proxy, TSecurityData *securityData)
|
|
{
|
|
// forward the call to standard gateway
|
|
CStandardGateway *sg = static_cast<CStandardGateway*>(_Gateway);
|
|
sg->replaceAllSecurityDatas(proxy, securityData);
|
|
}
|
|
|
|
/** Ask the gateway to resend the security data.
|
|
* The plug-in call this method after having changed
|
|
* the security info for a plug-in outside of the
|
|
* onNewProxy call.
|
|
*/
|
|
void CGatewaySecurity::forceSecurityUpdate(IModuleProxy *proxy)
|
|
{
|
|
// forward the call to standard gateway
|
|
CStandardGateway *sg = static_cast<CStandardGateway*>(_Gateway);
|
|
sg->forceSecurityUpdate(proxy);
|
|
}
|
|
|
|
|
|
|
|
void forceGatewayLink()
|
|
{
|
|
}
|
|
|
|
} // namespace NLNET
|
|
|