?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'fixes' into main/rendor-staging
[ryzomcore.git] / nel / src / net / module_gateway.cpp
blobd4d07ea610637caf716ef1b995233400659839a6
1 // NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
2 // Copyright (C) 2010 Winch Gate Property Limited
3 //
4 // This program is free software: you can redistribute it and/or modify
5 // it under the terms of the GNU Affero General Public License as
6 // published by the Free Software Foundation, either version 3 of the
7 // License, or (at your option) any later version.
8 //
9 // This program is distributed in the hope that it will be useful,
10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 // GNU Affero General Public License for more details.
13 //
14 // You should have received a copy of the GNU Affero General Public License
15 // along with this program. If not, see <http://www.gnu.org/licenses/>.
16
17 #include "stdnet.h"
18 #include "nel/net/module_gateway.h"
19 #include "nel/net/module.h"
20 #include "nel/net/module_manager.h"
21 #include "nel/net/module_socket.h"
22 #include "nel/net/module_message.h"
23 #include "nel/net/callback_client.h"
24 #include "nel/net/callback_server.h"
25
26 using namespace std;
27 using namespace NLMISC;
28
29
30
31 namespace NLNET
32 {
33 struct TSecurityDataDesc
34 {
35 TSecurityData *SecurityData;
36
37 TSecurityDataDesc()
38 : SecurityData(NULL)
39 {
40 }
41
42 void serial(CMemStream &s)
43 {
44 if (!s.isReading())
45 {
46 // write mode
47 TSecurityData *sd = SecurityData;
48
49 uint32 nbSecBlock = 0;
50 sint32 tagCountPos = s.reserve(4);
51 while (sd != NULL)
52 {
53 if (sd->DataTag == 0xff)
54 {
55 TUnknownSecurityData *usd = safe_cast<TUnknownSecurityData *>(sd);
56 s.serial(usd->RealDataTag);
57 }
58 else
59 {
60 s.serial(sd->DataTag);
61 }
62 // reserve a place to store the size of the next element
63 sint32 pos = s.reserve(4);
64 s.serial(*sd);
65 // store the size
66 uint32 size = s.getPos()-pos-4;
67 s.poke(size, pos);
68
69 nbSecBlock++;
70 sd = sd->NextItem;
71 }
72
73 // store the number of item
74 s.poke(nbSecBlock, tagCountPos);
75 }
76 else
77 {
78 nlassert(SecurityData == NULL);
79 TSecurityData **pLastSd = &SecurityData;
80 // read mode
81 uint32 nbSecBlock;
82 s.serial(nbSecBlock);
83
84 if (nbSecBlock == 0)
85 SecurityData = NULL;
86
87 for (uint i=0; i<nbSecBlock; ++i)
88 {
89 uint8 dataTag;
90 s.serial(dataTag);
91 uint32 blockSize;
92 s.serial(blockSize);
93 sint32 pos = s.getPos();
94 TSecurityData *sd;
95
96 try
97 {
98 TSecurityData::TCtorParam param(dataTag);
99 sd = NLMISC_GET_FACTORY(TSecurityData, uint8).createObject(dataTag, param);
100
101 if (sd == NULL)
102 {
103 // we don't know this type, create an unknow security block
104 sd = new TUnknownSecurityData(dataTag, blockSize);
105 sd->serial(s);
106 }
107 else
108 {
109 sd->serial(s);
110 }
111 }
112 catch(const EStreamOverflow &)
113 {
114 // FAILED to read the security block, rewind to old pos and serial as unknow
115 nlwarning("Error while reading stream for security data type %u", dataTag);
116
117 s.seek(pos, NLMISC::IStream::begin);
118 sd = new TUnknownSecurityData(dataTag, blockSize);
119 sd->serial(s);
120 }
121
122 *pLastSd = sd;
123 pLastSd = &(sd->NextItem);
124 }
125 }
126
127 }
128 };
129
130 /// Sub message for module description
131 struct TModuleDescCodec
132 {
133 TModuleId ModuleProxyId;
134 uint32 ModuleDistance;
135 string ModuleFullName;
136 string ModuleClass;
137 string ModuleManifest;
138 TSecurityDataDesc SecDesc;
139
140
141 TModuleDescCodec()
142 {
143 }
144
145 TModuleDescCodec(IModuleProxy *proxy)
146 {
147 ModuleProxyId = proxy->getModuleProxyId();
148 ModuleDistance = proxy->getModuleDistance()+1;
149 ModuleFullName = proxy->getModuleName();
150 ModuleClass = proxy->getModuleClassName();
151 ModuleManifest = proxy->getModuleManifest();
152 SecDesc.SecurityData = const_cast<TSecurityData*>(proxy->getFirstSecurityData());
153 }
154
155 void serial(NLMISC::CMemStream &s)
156 {
157 s.serial(ModuleProxyId);
158 s.serial(ModuleDistance);
159 s.serial(ModuleFullName);
160 s.serial(ModuleManifest);
161 s.serial(ModuleClass);
162 s.serial(SecDesc);
163 }
164 };
165
166 /// message for module distance update
167 struct TModuleDistanceChangeMsg
168 {
169 TModuleId ModuleId;
170 uint32 NewDistance;
171
172 void serial(NLMISC::IStream &s)
173 {
174 s.serial(ModuleId);
175 s.serial(NewDistance);
176 }
177 };
178
179 /// message for module security update
180 struct TModuleSecurityChangeMsg
181 {
182 TModuleId ModuleId;
183
184 TSecurityDataDesc SecDesc;
185
186 void serial(NLMISC::CMemStream &s)
187 {
188 s.serial(ModuleId);
189 s.serial(SecDesc);
190 }
191 };
192 /// Message for module removing
193 struct TModuleRemMsg
194 {
195 vector<TModuleId> RemovedModules;
196
197 void serial(NLMISC::IStream &s)
198 {
199 s.serialCont(RemovedModules);
200 }
201 };
202
203 /// Message for module operation
204 struct TModuleOperationMsg
205 {
206 TModuleId ModuleId;
207 string OperationName;
208
209 CMessage MessageBody;
210
211 void serial(NLMISC::IStream &s)
212 {
213 s.serial(ModuleId);
214 s.serial(OperationName);
215 s.serial(MessageBody);
216 }
217 };
218
219
220 /// message waiting next update for local dispatching
221 struct TLocalMessage
222 {
223 TModuleId SenderProxyId;
224 TModuleId AddresseProxyId;
225 CMessage Message;
226 };
227
228
229 /** Register the gateway in the module manager gateway registry
230 */
231 void CModuleGateway::registerGateway()
232 {
233 IModuleManager::getInstance().registerModuleGateway(this);
234 }
235 /** Unregister the gateway in the module manager gateway registry
236 */
237 void CModuleGateway::unregisterGateway()
238 {
239 IModuleManager::getInstance().unregisterModuleGateway(this);
240 }
241
242
243 /** The standard gateway that interconnect module
244 * across process.
245 */
246 class CStandardGateway :
247 public CModuleBase,
248 public CModuleGateway,
249 public CModuleSocket
250 {
251 typedef map<TModuleId, TModuleProxyPtr> TModuleProxies;
252 /// Module proxies managed by this gateway. The map key is the module proxy id
253 TModuleProxies _ModuleProxies;
254
255 typedef CTwinMap<TStringId, TModuleProxyPtr> TNamedProxyIdx;
256 /// Index of name to proxy id
257 TNamedProxyIdx _NameToProxyIdx;
258
259 /// A structure to hold foreign proxy information
260 struct TKnownModuleInfo
261 {
262 TModuleId ForeignProxyId;
263 CGatewayRoute *Route;
264 uint32 ModuleDistance;
265 TStringId ModuleClassId;
266 };
267
268 typedef multimap<TStringId, TKnownModuleInfo> TKnownModuleInfos;
269 /** List of known foreign module info.
270 */
271 TKnownModuleInfos _KnownModules;
272
273 typedef map<TModuleId, TModuleId> TLocalModuleIndex;
274 /// Translation table to find module proxies for locally plugged module
275 /// The map key is the local module id, the data is the associated proxy id
276 TLocalModuleIndex _LocalModuleIndex;
277
278 typedef map<std::string, IGatewayTransport*> TTransportList;
279 /// the list of active transport
280 TTransportList _Transports;
281
282 typedef set<CGatewayRoute*> TRouteList;
283 // the list of available routes
284 TRouteList _Routes;
285
286 /// The security plug-in (if any)
287 CGatewaySecurity *_SecurityPlugin;
288
289 /// Ping counter for debug purpose
290 uint32 _PingCounter;
291
292 typedef std::list<TLocalMessage> TLocalMessageList;
293 /// List of local message waiting dispatching at next update
294 TLocalMessageList _LocalMessages;
295
296 public:
297
298 CStandardGateway()
299 : _SecurityPlugin(NULL),
300 _PingCounter(0)
301 {
302 }
303
304 ~CStandardGateway()
305 {
306 // we need to unplug any plugged module
307 while (!_PluggedModules.getAToBMap().empty())
308 {
309 _PluggedModules.getAToBMap().begin()->second->unplugModule(this);
310 }
311
312 // delete all transport
313 while (!_Transports.empty())
314 {
315 deleteTransport(_Transports.begin()->first);
316 }
317
318 // delete security plug-in
319 if (_SecurityPlugin != NULL)
320 removeSecurityPlugin();
321
322 // must be done before the other destructors are called
323 unregisterSocket();
324 unregisterGateway();
325 }
326
327 CModuleProxy *getModuleProxy(TModuleId proxyId)
328 {
329 TModuleProxies::iterator it(_ModuleProxies.find(proxyId));
330 if (it == _ModuleProxies.end())
331 return NULL;
332 return static_cast<CModuleProxy*>(it->second.getPtr());
333 }
334
335 /***********************************************************
336 ** Gateway methods
337 ***********************************************************/
338 virtual const std::string &getGatewayName() const
339 {
340 return getModuleName();
341 }
342 virtual const std::string &getFullyQualifiedGatewayName() const
343 {
344 return getModuleFullyQualifiedName();
345 }
346
347 /// Create and bind to this gateway a new transport
348 virtual void createTransport(const std::string &transportClass, const std::string &instanceName)
349 {
350 if (_Transports.find(instanceName) != _Transports.end())
351 {
352 nlwarning("A transport with the name '%s' already exist in this gateway", instanceName.c_str());
353 return;
354 }
355
356 IGatewayTransport::TCtorParam param;
357 param.Gateway = this;
358 IGatewayTransport *transport = NLMISC_GET_FACTORY(IGatewayTransport, std::string).createObject(transportClass, param);
359
360 if (transport == NULL)
361 {
362 nlwarning("Failed to create a transport with the class '%s'", transportClass.c_str());
363 return;
364 }
365
366 // Store the transport
367 // TTransportInfo *ti = new TTransportInfo(transport);
368 _Transports.insert(make_pair(instanceName, transport));
369 // _TransportPtrIdx.insert(make_pair(transport, ti));
370
371 nldebug("NETL6: Gateway transport %s (%s) created", instanceName.c_str(), transportClass.c_str());
372 }
373
374 /// Delete a transport (this will close any open route)
375 virtual void deleteTransport(const std::string &instanceName)
376 {
377 TTransportList::iterator it(_Transports.find(instanceName));
378 if (it == _Transports.end())
379 {
380 nlwarning("Unknown transport named '%s'", instanceName.c_str());
381 return;
382 }
383
384 nldebug("NETL6: Gateway transport '%s' deleted", instanceName.c_str());
385 // delete the transport
386 IGatewayTransport *transport = it->second;
387 // nlassert(_TransportPtrIdx.find(transport) != _TransportPtrIdx.end());
388 // _TransportPtrIdx.erase(transport);
389 delete transport;
390 // delete it->second;
391 _Transports.erase(it);
392 }
393
394 /// Activate/stop peer invisible mode on a transport
395 virtual void setTransportPeerInvisible(const std::string &transportInstanceName, bool peerInvisible)
396 {
397 TTransportList::iterator it(_Transports.find(transportInstanceName));
398 if (it == _Transports.end())
399 {
400 nlwarning("Unknown transport named '%s'", transportInstanceName.c_str());
401 return;
402 }
403
404 IGatewayTransport *transport= it->second;
405
406 if (peerInvisible == transport->PeerInvisible)
407 // nothing more to do
408 return;
409
410 // set the mode
411 transport->PeerInvisible = peerInvisible;
412
413 nldebug("NETL6: Gateway transport %s peer invisible mode %s", transportInstanceName.c_str(), peerInvisible? "ON" : "OFF");
414
415
416 // For each route of this transport, we need to disclose/undisclose peer modules
417 TRouteList::iterator first(_Routes.begin()), last(_Routes.end());
418 for (; first != last; ++first)
419 {
420 CGatewayRoute *route = *first;
421
422 if (route->getTransport() == transport)
423 {
424 // this route need to be filtered
425 TModuleProxies::iterator first(_ModuleProxies.begin()), last(_ModuleProxies.end());
426 for (; first != last; ++first)
427 {
428 IModuleProxy *proxy = first->second;
429 if (proxy->getGatewayRoute() != NULL
430 && proxy->getGatewayRoute() != route
431 && proxy->getGatewayRoute()->getTransport() == transport)
432 {
433 // this module is on the same transport, but another route, remove/add it from the
434 // route
435 if (peerInvisible)
436 undiscloseModuleToRoute(route, proxy);
437 else
438 {
439 // check firewall rules
440 if (!route->getTransport()->Firewalled)
441 discloseModuleToRoute(route, proxy);
442 }
443 }
444 }
445 }
446 }
447 }
448
449 /// Activate/stop firewalling mode on a transport
450 virtual void setTransportFirewallMode(const std::string &transportInstanceName, bool firewalled)
451 {
452 TTransportList::iterator it(_Transports.find(transportInstanceName));
453 if (it == _Transports.end())
454 {
455 nlwarning("Unknown transport named '%s'", transportInstanceName.c_str());
456 return;
457 }
458
459 IGatewayTransport *transport = it->second;
460
461 if (firewalled == transport->Firewalled)
462 // nothing to do
463 return;
464
465 if (firewalled && transport->getRouteCount() != 0)
466 throw EGatewayFirewallBreak();
467
468 /// set the firewall mode
469 transport->Firewalled = firewalled;
470
471 nldebug("NETL6: Gateway transport %s firewall mode %s", transportInstanceName.c_str(), firewalled? "ON" : "OFF");
472
473 if (firewalled == false)
474 {
475 // we need to disclose all module not disclosed yet
476 TRouteList::iterator first(_Routes.begin()), last(_Routes.end());
477 for (; first != last; ++first)
478 {
479 CGatewayRoute *route = *first;
480
481 if (route->getTransport() == transport)
482 {
483 // this route need to be unfiltered
484 TModuleProxies::iterator first(_ModuleProxies.begin()), last(_ModuleProxies.end());
485 for (; first != last; ++first)
486 {
487 IModuleProxy *proxy = first->second;
488 if (proxy->getGatewayRoute() == NULL || (proxy->getGatewayRoute() != route ))
489 {
490 // this module is on another route, disclose it if needed
491 if (route->FirewallDisclosed.find(proxy->getModuleProxyId()) == route->FirewallDisclosed.end())
492 discloseModuleToRoute(route, proxy);
493 }
494 }
495 }
496 // clear the firewall disclosed table
497 route->FirewallDisclosed.clear();
498 }
499 }
500 }
501
502 /// Send a command to a transport
503 virtual void transportCommand(const TParsedCommandLine &commandLine)
504 {
505 for (uint i=1; i<commandLine.SubParams.size(); ++i)
506 {
507 const TParsedCommandLine * subParam = commandLine.SubParams[i];
508
509 std::string transportName = subParam->ParamName;
510 TTransportList::const_iterator it(_Transports.find(transportName));
511 if (it == _Transports.end())
512 {
513 nlwarning("Unknown transport named '%s', ignoring command.", transportName.c_str());
514 }
515 else if (subParam->SubParams.empty())
516 {
517 nlwarning("Can't find sub param list for transport '%s' command", transportName.c_str());
518 }
519 else
520 {
521 nldebug("NETL6: Gateway transport %s, sending command '%s'", transportName.c_str(), commandLine.toString().c_str());
522 // ok, we have a valid transport, send the command
523 IGatewayTransport *transport = it->second;
524 if (!transport->onCommand(*subParam))
525 return;
526 }
527 }
528 }
529
530 virtual IGatewayTransport *getGatewayTransport(const std::string &transportName) const
531 {
532 TTransportList::const_iterator it(_Transports.find(transportName));
533
534 if (it == _Transports.end())
535 return NULL;
536 else
537 return it->second;
538 }
539
540 virtual uint32 getTransportCount() const
541 {
542 return (uint32)_Transports.size();
543 }
544
545 virtual uint32 getRouteCount() const
546 {
547 return (uint32)_Routes.size();
548 }
549
550 virtual uint32 getReceivedPingCount() const
551 {
552 return _PingCounter;
553 }
554
555 virtual void onRouteAdded(CGatewayRoute *route)
556 {
557 nlassert(route != NULL);
558 // Remember the new route
559 nlassert(_Routes.find(route) == _Routes.end());
560 _Routes.insert(route);
561
562 // a new route is available, disclose known modules
563 {
564 TModuleProxies::iterator first(_ModuleProxies.begin()), last(_ModuleProxies.end());
565 for (; first != last; ++first)
566 {
567 IModuleProxy *modProx = first->second;
568
569 // only transmit module desc coming from other routes
570 // and other transport if peer invisible
571 if (isModuleProxyVisible(modProx, route))
572 {
573 discloseModuleToRoute(route, modProx);
574 }
575 }
576 }
577 }
578
579 /// A route is removed by a transport
580 virtual void onRouteRemoved(CGatewayRoute *route)
581 {
582 nlassert(route != NULL);
583 nlassert(_Routes.find(route) != _Routes.end());
584 // we need to remove all the proxy that come from this route
585 // CGatewayRoute::TForeignToLocalIdx::TAToBMap::const_iterator first(route->ForeignToLocalIdx.getAToBMap().begin()), last(route->ForeignToLocalIdx.getAToBMap().end());
586 // for (; first != last; ++first)
587 while (!route->ForeignToLocalIdx.getAToBMap().empty())
588 {
589 removeForeignModule(route, route->ForeignToLocalIdx.getAToBMap().begin()->first);
590 // TModuleId localProxyId = first->second;
591 // TModuleProxies::iterator it(_ModuleProxies.find(localProxyId));
592 // nlassert(it != _ModuleProxies.end());
593 //
594 // IModuleProxy *modProx = it->second;
595 //
596 // // trigger an event in the gateway
597 // onRemoveModuleProxy(modProx);
598 //
599 // // remove proxy record from the proxy list
600 // _ModuleProxies.erase(it);
601 // _NameToProxyIdx.removeWithB(modProx);
602 //
603 // // Release the proxy object
604 // IModuleManager::getInstance().releaseModuleProxy(modProx->getModuleProxyId());
605 }
606 // cleanup the translation table
607 // route->ForeignToLocalIdx.clear();
608
609 // clear the route tracker
610 _Routes.erase(route);
611
612 // cleanup route state
613 route->ForeignToLocalIdx.clear();
614 route->PendingEvents.clear();
615 route->FirewallDisclosed.clear();
616 route->NextMessageType = CModuleMessageHeaderCodec::mt_invalid;
617 route->NextSenderProxyId = 0;
618 route->NextAddresseeProxyId = 0;
619 }
620
621 /// A transport have received a message
622 virtual void onReceiveMessage(CGatewayRoute *from, const CMessage &msgin)
623 {
624 H_AUTO(CModuleGetaway_onReceiveMessage);
625 // dispatch the message
626 if (from->NextMessageType != CModuleMessageHeaderCodec::mt_invalid)
627 {
628 // this message must be dispatched to a module
629 onReceiveModuleMessageFromGateway(from, msgin);
630 }
631 // Not a module message, dispatch the gateway message
632 else if (msgin.getName() == "MOD_OP")
633 {
634 onReceiveModuleMessageHeader(from, msgin);
635 }
636 else if (msgin.getName() == "MOD_UPD")
637 {
638 onReceiveModuleUpdate(from, msgin);
639 }
640 // else if (msgin.getName() == "MOD_ADD")
641 // {
642 // onReceiveModuleAdd(from, msgin);
643 // }
644 // else if (msgin.getName() == "MOD_REM")
645 // {
646 // onReceiveModuleRemove(from, msgin);
647 // }
648 // else if (msgin.getName() == "MOD_DST_UPD")
649 // {
650 // onReceiveModuleDistanceUpdate(from, msgin);
651 // }
652 }
653
654
655 /***********************************/
656 /* security plug-in management*/
657 /***********************************/
658 /** create a security plug-in.
659 * There must be no security plug-in currently created.
660 */
661 virtual void createSecurityPlugin(const std::string &className)
662 {
663 if (_SecurityPlugin != NULL)
664 {
665 nlwarning("NLNETL5 : CStandardGateway::createSecurityPlugin : plug-in already created ");
666 return;
667 }
668
669 CGatewaySecurity::TCtorParam params;
670 params.Gateway = this;
671 CGatewaySecurity *gs = NLMISC_GET_FACTORY(CGatewaySecurity, std::string).createObject(className, params);
672 if (gs == NULL)
673 {
674 nlwarning("NLNETL5 : CStandardGateway::createSecurityPlugin : can't create a security plug-in for class '%s'", className.c_str());
675 return;
676 }
677
678 // store the security plug-in
679 _SecurityPlugin = gs;
680
681 // update security for all existing proxies
682 TModuleProxies::iterator first(_ModuleProxies.begin()), last(_ModuleProxies.end());
683 for (; first != last; ++first)
684 {
685 IModuleProxy *proxy = first->second;
686 _SecurityPlugin->onNewProxy(proxy);
687 }
688 }
689 /** Send a command to the security plug-in */
690 virtual void sendSecurityCommand(const TParsedCommandLine &command)
691 {
692 if (_SecurityPlugin != NULL)
693 {
694 nlwarning("NLNETL5 : CStandardGateway::sendSecurityCommand : plug-in NOT created ");
695 return;
696 }
697
698 _SecurityPlugin->onCommand(command);
699 }
700
701 /** Remove the security plug-in.
702 */
703 virtual void removeSecurityPlugin()
704 {
705 if (_SecurityPlugin == NULL)
706 {
707 nlwarning("NLNETL5 : CStandardGateway::removeSecurityPlugin : plug-in not created");
708 return;
709 }
710
711 // delete the plug-in (this can remove some security data)
712 _SecurityPlugin->onDelete();
713 delete _SecurityPlugin;
714 _SecurityPlugin = NULL;
715 }
716
717 /** Set a security data block. If a bloc of the same type
718 * already exist in the list, the new one will replace the
719 * existing one.
720 */
721 void setSecurityData(IModuleProxy *proxy, TSecurityData *securityData)
722 {
723 nlassert(proxy->getModuleGateway() == this);
724 nlassert(securityData->NextItem == NULL);
725
726 CModuleProxy *modProx = dynamic_cast<CModuleProxy*>(proxy);
727 nlassert(modProx != NULL);
728
729 // look in the existing security for a matching type and remove it
730 removeSecurityData(proxy, securityData->DataTag);
731
732 // now, store the security data
733 securityData->NextItem = modProx->_SecurityData;
734 modProx->_SecurityData = securityData;
735
736
737 }
738
739 /** Clear a block of security data
740 * The block is identified by the data tag
741 */
742 bool removeSecurityData(IModuleProxy *proxy, uint8 dataTag)
743 {
744 nlassert(proxy->getModuleGateway() == this);
745
746 CModuleProxy *modProx = dynamic_cast<CModuleProxy*>(proxy);
747 nlassert(modProx != NULL);
748
749 bool ret = false;
750 TSecurityData *prevSec = NULL;
751 TSecurityData *currentSec = modProx->_SecurityData;
752 while (currentSec != NULL)
753 {
754 if (currentSec->DataTag == dataTag)
755 {
756 if (prevSec != NULL)
757 prevSec->NextItem = currentSec->NextItem;
758 else
759 modProx->_SecurityData = currentSec->NextItem;
760
761 TSecurityData *toDelete = currentSec;
762 currentSec = currentSec->NextItem;
763 toDelete->NextItem = NULL;
764 delete toDelete;
765 ret = true;
766 }
767 else
768 {
769 prevSec = currentSec;
770 currentSec = currentSec->NextItem;
771 }
772 }
773
774 return ret;
775 }
776
777 void replaceAllSecurityDatas(IModuleProxy *proxy, TSecurityData *securityData)
778 {
779 nlassert(proxy->getModuleGateway() == this);
780
781 CModuleProxy *modProx = dynamic_cast<CModuleProxy*>(proxy);
782 nlassert(modProx != NULL);
783 nlassert(modProx->_SecurityData != securityData);
784
785 if (modProx->_SecurityData != NULL)
786 delete modProx->_SecurityData;
787
788 modProx->_SecurityData = securityData;
789 }
790
791 /** Ask the gateway to resend the security data.
792 * The plug-in call this method after having changed
793 * the security info for a plug-in outside of the
794 * onNewProxy call.
795 */
796 void forceSecurityUpdate(IModuleProxy *proxy)
797 {
798 TRouteList::iterator first(_Routes.begin()), last(_Routes.end());
799 for (; first != last; ++first)
800 {
801 CGatewayRoute *route = *first;
802
803 if (isModuleProxyVisible(proxy, route))
804 {
805 updateModuleSecurityDataToRoute(route, proxy);
806 }
807 }
808 }
809
810 /***********************************/
811 /* Inter gateway message reception */
812 /***********************************/
813
814 /** A gateway receive module operation */
815 void onReceiveModuleMessageFromGateway(CGatewayRoute *from, const CMessage &msgin)
816 {
817 H_AUTO(CModuleGetaway_onReceiveModuleMessage);
818 // clean the message type now, any return path will be safe
819 from->NextMessageType = CModuleMessageHeaderCodec::mt_invalid;
820
821 // Retrieve sender and destination proxy and recall gateway send method
822 IModuleProxy *senderProxy;
823 IModuleProxy *addresseeProxy;
824
825 TModuleProxies::iterator it;
826
827 // sender proxy
828 it = _ModuleProxies.find(from->NextSenderProxyId);
829 if (it == _ModuleProxies.end())
830 {
831 nlwarning("Can't dispatch the module message, sender proxy %u is not in this gateway", from->NextSenderProxyId);
832 return;
833 }
834 senderProxy = it->second;
835 // addressee proxy
836 it = _ModuleProxies.find(from->NextAddresseeProxyId);
837 if (it == _ModuleProxies.end())
838 {
839 nlwarning("Can't dispatch the module message '%s', sender proxy %u is not in this gateway", msgin.getName().c_str(), from->NextAddresseeProxyId);
840 return;
841 }
842 addresseeProxy = it->second;
843
844 // give the message to the gateway (either for local dispatch or for forwarding)
845 sendModuleProxyMessage(senderProxy, addresseeProxy, msgin);
846 }
847
848 // A gateway receive a module message header
849 void onReceiveModuleMessageHeader(CGatewayRoute *from, const CMessage &msgin)
850 {
851 H_AUTO(CModuleGetaway_onReceiveModuleMessageHeader);
852 if (from->NextMessageType != CModuleMessageHeaderCodec::mt_invalid)
853 {
854 // juste warn (but that is VERY BAD)
855 nlwarning("Receiving a new module message header without having received the previous module message !");
856 }
857
858 // store the message information in the route
859 CModuleMessageHeaderCodec::decode(
860 msgin,
861 from->NextMessageType,
862 from->NextSenderProxyId,
863 from->NextAddresseeProxyId);
864
865 // translate sender id
866 const TModuleId *pmoduleId = from->ForeignToLocalIdx.getB(from->NextSenderProxyId);
867 if (pmoduleId == NULL)
868 {
869 nlwarning("The sender proxy %u is unknown in the translation table, can't dispatch the message !", from->NextSenderProxyId);
870 from->NextMessageType = CModuleMessageHeaderCodec::mt_invalid;
871 return;
872 }
873 from->NextSenderProxyId = *pmoduleId;
874 // now, wait the message body
875 }
876
877 /** A gateway receive a general update message */
878 void onReceiveModuleUpdate(CGatewayRoute *from, const CMessage &msgin)
879 {
880 H_AUTO(CModuleGetaway_onReceiveModuleUpdate);
881 while (uint32(msgin.getPos()) != msgin.length())
882 {
883 CGatewayRoute::TPendingEventType type = CGatewayRoute::pet_disclose_module;
884 // msgin.serialShortEnum(type);
885 nlRead(msgin, serialShortEnum, type);
886
887 switch (type)
888 {
889 case CGatewayRoute::pet_disclose_module:
890
891 onReceiveModuleAdd(from, msgin);
892
893 break;
894 case CGatewayRoute::pet_undisclose_module:
895
896 onReceiveModuleRemove(from, msgin);
897
898 break;
899 case CGatewayRoute::pet_update_distance:
900
901 onReceiveModuleDistanceUpdate(from, msgin);
902
903 break;
904 case CGatewayRoute::pet_update_security:
905
906 onReceiveModuleSecurityUpdate(from, msgin);
907
908 break;
909 default:
910 // should not append
911 nlstop;
912 }
913 }
914 }
915
916 /** A gateway send new modules information */
917 void onReceiveModuleAdd(CGatewayRoute *from, const CMessage &msgin)
918 {
919 H_AUTO(CModuleGetaway_onReceiveModuleAdd);
920 TModuleDescCodec modDesc;
921 nlRead(msgin, serial, modDesc);
922
923 // for each received module info
924 TStringId modNameId = CStringMapper::map(modDesc.ModuleFullName);
925 /// store the module information
926 TKnownModuleInfo modInfo;
927 modInfo.ForeignProxyId = modDesc.ModuleProxyId;
928 modInfo.ModuleClassId = CStringMapper::map(modDesc.ModuleClass);
929 modInfo.ModuleDistance = modDesc.ModuleDistance;
930 modInfo.Route = from;
931
932 nldebug("Gateway '%s' : store module info for '%s' (foreign ID %u) @ %u hop",
933 getGatewayName().c_str(),
934 modDesc.ModuleFullName.c_str(),
935 modDesc.ModuleProxyId,
936 modDesc.ModuleDistance);
937
938 // Store module information
939 _KnownModules.insert(make_pair(modNameId, modInfo));
940
941 if (_NameToProxyIdx.getB(modNameId) != NULL)
942 {
943 // a proxy for this module already exist,
944 IModuleProxy *modProx = *(_NameToProxyIdx.getB(modNameId));
945
946 // fill the id translation table
947 // from->ForeignToLocalIdx.insert(make_pair(modDesc.ModuleProxyId, modProx->getModuleProxyId()));
948 from->ForeignToLocalIdx.add(modDesc.ModuleProxyId, modProx->getModuleProxyId());
949
950 // check if this route is better
951 if (modProx->getModuleDistance() > modInfo.ModuleDistance)
952 {
953 // update module distance and swap route
954 CModuleProxy *proxy = static_cast<CModuleProxy*>(modProx);
955
956 nldebug("Gateway '%s' : Use a shorter path for '%s' from %u to %u hops",
957 getGatewayName().c_str(),
958 modDesc.ModuleFullName.c_str(),
959 proxy->_Distance,
960 modInfo.ModuleDistance);
961
962 proxy->_Distance = modInfo.ModuleDistance;
963 proxy->_Route = modInfo.Route;
964
965 sendModuleDistanceUpdate(proxy);
966 }
967
968 // update the security if needed
969 if (modDesc.SecDesc.SecurityData != NULL)
970 {
971 CModuleProxy *proxy = static_cast<CModuleProxy *>(modProx);
972 if (_SecurityPlugin != NULL)
973 {
974 _SecurityPlugin->onNewSecurityData(from, proxy, modDesc.SecDesc.SecurityData);
975 }
976 else
977 {
978 if (proxy->_SecurityData != NULL)
979 delete proxy->_SecurityData;
980 proxy->_SecurityData = modDesc.SecDesc.SecurityData;
981 }
982 }
983 }
984 else
985 {
986 // we need to create a new proxy
987 // create a module proxy
988 IModuleProxy *modProx = IModuleManager::getInstance().createModuleProxy(
989 this,
990 from,
991 modDesc.ModuleDistance,
992 NULL,
993 modDesc.ModuleClass,
994 modDesc.ModuleFullName,
995 modDesc.ModuleManifest,
996 modDesc.ModuleProxyId);
997
998 // set the module security
999 CModuleProxy *proxy = static_cast<CModuleProxy *>(modProx);
1000 proxy->_SecurityData = modDesc.SecDesc.SecurityData;
1001 // let the security plug-in add/remove security data
1002 if (_SecurityPlugin != NULL)
1003 _SecurityPlugin->onNewProxy(proxy);
1004
1005 // store the proxy in the proxy list
1006 _ModuleProxies.insert(make_pair(modProx->getModuleProxyId(), modProx));
1007 _NameToProxyIdx.add(modNameId, modProx);
1008
1009 // Fill the proxy id translation table for this route
1010 // from->ForeignToLocalIdx.insert(make_pair(modDesc.ModuleProxyId, modProx->getModuleProxyId()));
1011 from->ForeignToLocalIdx.add(modDesc.ModuleProxyId, modProx->getModuleProxyId());
1012
1013 // trigger an event in the gateway
1014 onAddModuleProxy(modProx);
1015 }
1016 }
1017
1018 void onReceiveModuleRemove(CGatewayRoute *from, const CMessage &msgin)
1019 {
1020 H_AUTO(CModuleGetaway_onReceiveModuleRemove);
1021 TModuleId moduleId;
1022 nlRead(msgin, serial, moduleId);
1023
1024 removeForeignModule(from, moduleId);
1025 }
1026
1027 void onReceiveModuleDistanceUpdate(CGatewayRoute *from, const CMessage &msgin)
1028 {
1029 H_AUTO(CModuleGetaway_onReceiveModuleDistanceUpdate);
1030 TModuleId moduleId;
1031 uint32 newDistance;
1032
1033 nlRead(msgin, serial, moduleId);
1034 nlRead(msgin, serial, newDistance);
1035
1036 // translate the module id
1037 const TModuleId *pModuleId = from->ForeignToLocalIdx.getB(moduleId);
1038 if (pModuleId == NULL)
1039 {
1040 nlwarning("Receive a module distance update for foreign module %u, but no translation available", moduleId);
1041 return;
1042 }
1043
1044 TModuleId localId = *pModuleId;
1045
1046 // now, retrieve the module info and update
1047 TModuleProxies::iterator it2(_ModuleProxies.find(localId));
1048 nlassert(it2 != _ModuleProxies.end());
1049 CModuleProxy *proxy = static_cast<CModuleProxy*>(it2->second.getPtr());
1050
1051 pair<TKnownModuleInfos::iterator, TKnownModuleInfos::iterator> range;
1052 range = _KnownModules.equal_range(proxy->_FullyQualifiedModuleName);
1053
1054 for (; range.first != range.second; ++range.first)
1055 {
1056 TKnownModuleInfo &kmi = range.first->second;
1057 if (kmi.Route == from)
1058 {
1059 // we found the module info, update the data
1060 nldebug("Gateway '%s' : updating distance from %u to %u hop for module '%s'",
1061 getGatewayName().c_str(),
1062 kmi.ModuleDistance,
1063 newDistance,
1064 CStringMapper::unmap(range.first->first).c_str());
1065 kmi.ModuleDistance = newDistance;
1066 break;
1067 }
1068 }
1069 nlassert(range.first != range.second);
1070
1071 // check if the changed module is the one currently in use
1072 if (proxy->_Route == from)
1073 {
1074 // two task : first, if the new distance is greater, look
1075 // in available route for a shorter path,
1076 // second, send a module distance update for this module.
1077 if (proxy->_Distance < newDistance)
1078 {
1079 // look for a shorter path
1080 range = _KnownModules.equal_range(proxy->_FullyQualifiedModuleName);
1081
1082 for (; range.first != range.second; ++range.first)
1083 {
1084 TKnownModuleInfo &kmi = range.first->second;
1085 if (kmi.ModuleDistance < proxy->_Distance)
1086 {
1087 nldebug("Gateway '%s' : proxy '%s' use a new path from %u to %u hop",
1088 getGatewayName().c_str(),
1089 proxy->getModuleName().c_str(),
1090 proxy->_Distance,
1091 kmi.ModuleDistance);
1092 // this path is shorter, use it now
1093 proxy->_Route = kmi.Route;
1094 proxy->_ForeignModuleId = kmi.ForeignProxyId;
1095 proxy->_Distance = kmi.ModuleDistance;
1096 break;
1097 }
1098 }
1099 if (range.first == range.second)
1100 {
1101 // no shorter path found, update the proxy
1102 nldebug("Gateway '%s' : proxy '%s' path distance changed from %u to %u hop",
1103 getGatewayName().c_str(),
1104 proxy->getModuleName().c_str(),
1105 proxy->_Distance,
1106 newDistance);
1107
1108 proxy->_Distance = newDistance;
1109 }
1110 }
1111 else
1112 {
1113 // the new distance is shorter, just update
1114 nldebug("Gateway '%s' : proxy '%s' path distance reduced from %u to %u hop",
1115 getGatewayName().c_str(),
1116 proxy->getModuleName().c_str(),
1117 proxy->_Distance,
1118 newDistance);
1119
1120 proxy->_Distance = newDistance;
1121 }
1122
1123 // send the distance update
1124 sendModuleDistanceUpdate(proxy);
1125 }
1126 }
1127
1128 void onReceiveModuleSecurityUpdate(CGatewayRoute *from, const CMessage &msgin)
1129 {
1130 H_AUTO(CModuleGetaway_onReceiveModuleSecurityUpdate);
1131 // TModuleId foreignModuleId;
1132 // TSecurityData *modSec;
1133 TModuleSecurityChangeMsg secChg;
1134
1135 nlRead(msgin, serial, secChg);
1136 // msgin.serial(foreignModuleId);
1137 // msgin.serialPolyPtr(modSec);
1138
1139 const TModuleId *pModuleId = from->ForeignToLocalIdx.getB(secChg.ModuleId);
1140 if (pModuleId == NULL)
1141 {
1142 nlwarning("LNETL6 : receive module security update for unknown module foreign proxy %u", secChg.ModuleId);
1143 return;
1144 }
1145
1146 TModuleId moduleId = *pModuleId;
1147
1148 CModuleProxy *modProx = getModuleProxy(moduleId);
1149 if (modProx == NULL)
1150 {
1151 nlwarning("LNETL6 : receive module security update for unknown module proxy %u, foreign %u", moduleId, secChg.ModuleId);
1152 return;
1153 }
1154
1155 // allow the security plug-in to affect the data
1156 if( _SecurityPlugin != NULL)
1157 {
1158 // let the plug-in update the security data
1159 _SecurityPlugin->onNewSecurityData(from, modProx, secChg.SecDesc.SecurityData);
1160 }
1161 else
1162 {
1163 // update the security data in the proxy
1164 replaceAllSecurityDatas(modProx, secChg.SecDesc.SecurityData);
1165 }
1166
1167 // warn local module about new security data
1168 {
1169 TPluggedModules::TAToBMap::const_iterator first(_PluggedModules.getAToBMap().begin()), last(_PluggedModules.getAToBMap().end());
1170 for (; first != last; ++first)
1171 {
1172 IModule *module = first->second;
1173
1174 module->onModuleSecurityChange(modProx);
1175 }
1176 }
1177
1178 // update the security to peers
1179 {
1180 TRouteList::iterator first(_Routes.begin()), last(_Routes.end());
1181 for (; first != last; ++first)
1182 {
1183 CGatewayRoute *route = *first;
1184 if (isModuleProxyVisible(modProx, route))
1185 {
1186 updateModuleSecurityDataToRoute(route, modProx);
1187 }
1188 }
1189 }
1190 }
1191
1192
1193 virtual void onAddModuleProxy(IModuleProxy *addedModule)
1194 {
1195 H_AUTO(CModuleGetaway_onAddmoduleProxy);
1196 // disclose module to local modules
1197 discloseModule(addedModule);
1198
1199 // and send module info to any route
1200
1201 // for each route
1202 TRouteList::iterator first(_Routes.begin()), last(_Routes.end());
1203 for (; first != last; ++first)
1204 {
1205 CGatewayRoute *route = *first;
1206 // only send info to other routes
1207 if (isModuleProxyVisible(addedModule, route))
1208 {
1209 discloseModuleToRoute(route, addedModule);
1210 }
1211 }
1212 }
1213
1214 virtual void onRemoveModuleProxy(IModuleProxy *removedModule)
1215 {
1216 H_AUTO(CModuleGetaway_onRemoveModuleProxy);
1217 // for each route
1218 {
1219 // for each route
1220 TRouteList::iterator first(_Routes.begin()), last(_Routes.end());
1221 for (; first != last; ++first)
1222 {
1223 CGatewayRoute *route = *first;
1224 // only send info to other routes
1225 if (isModuleProxyVisible(removedModule, route))
1226 {
1227 undiscloseModuleToRoute(route, removedModule);
1228 }
1229 }
1230 }
1231
1232 // warn any locally plugged module
1233 {
1234 TPluggedModules::TAToBMap::const_iterator first(_PluggedModules.getAToBMap().begin()), last(_PluggedModules.getAToBMap().end());
1235 for (; first != last; ++first)
1236 {
1237 IModule *module = first->second;
1238 if (removedModule->getGatewayRoute() != NULL
1239 || module->getModuleId() != removedModule->getForeignModuleId())
1240 {
1241 module->_onModuleDown(removedModule);
1242 }
1243 }
1244 }
1245 }
1246
1247 virtual void discloseModule(IModuleProxy *moduleProxy)
1248 {
1249 nlassert(moduleProxy->getModuleGateway() == this);
1250
1251 // warn any plugged module
1252 TPluggedModules::TAToBMap::const_iterator first(_PluggedModules.getAToBMap().begin()), last(_PluggedModules.getAToBMap().end());
1253 for (; first != last; ++first)
1254 {
1255 IModule *module = first->second;
1256 if (moduleProxy->getGatewayRoute() != NULL
1257 || module->getModuleId() != moduleProxy->getForeignModuleId())
1258 {
1259 module->_onModuleUp(moduleProxy);
1260 }
1261 }
1262 }
1263
1264 virtual IModuleProxy *getPluggedModuleProxy(IModule *pluggedModule)
1265 {
1266 TLocalModuleIndex::iterator it(_LocalModuleIndex.find(pluggedModule->getModuleId()));
1267
1268 if (it == _LocalModuleIndex.end())
1269 return NULL;
1270 else
1271 {
1272 TModuleProxies::iterator it2(_ModuleProxies.find(it->second));
1273 nlassert(it2 != _ModuleProxies.end());
1274 return it2->second;
1275 }
1276 }
1277
1278 virtual uint32 getProxyCount() const
1279 {
1280 return (uint32)_ModuleProxies.size();
1281 }
1282
1283 /// Fill a vector with the list of proxies managed here. The module are filled in ascending proxy id order.
1284 virtual void getModuleProxyList(std::vector<IModuleProxy*> &resultList) const
1285 {
1286 TModuleProxies::const_iterator first(_ModuleProxies.begin()), last(_ModuleProxies.end());
1287 for (; first != last; ++first)
1288 {
1289 resultList.push_back(first->second);
1290 }
1291 }
1292
1293
1294 virtual void sendModuleProxyMessage(IModuleProxy *senderProxy, IModuleProxy *addresseeProxy, const NLNET::CMessage &message)
1295 {
1296 H_AUTO(CModuleGetaway_sendModuleMessage);
1297 // manage firewall
1298 if (addresseeProxy->getGatewayRoute()
1299 && addresseeProxy->getGatewayRoute()->getTransport()->Firewalled)
1300 {
1301 CGatewayRoute *route = addresseeProxy->getGatewayRoute();
1302 // the destination route is firewalled, we need to
1303 // disclose the sender module if it's not already done
1304 if (route->FirewallDisclosed.find(senderProxy->getModuleProxyId()) == route->FirewallDisclosed.end())
1305 {
1306 discloseModuleToRoute(route, senderProxy);
1307 route->FirewallDisclosed.insert(senderProxy->getModuleProxyId());
1308 }
1309 }
1310
1311 // check for visibility rules
1312 if (!isModuleProxyVisible(addresseeProxy, senderProxy->getGatewayRoute()))
1313 {
1314 nlwarning("Module %u '%s' try to send message to %u '%s' but addressee is not visible, message discarded",
1315 senderProxy->getModuleProxyId(),
1316 senderProxy->getModuleName().c_str(),
1317 addresseeProxy->getModuleProxyId(),
1318 addresseeProxy->getModuleName().c_str());
1319 return;
1320 }
1321
1322 if (addresseeProxy->getGatewayRoute() == NULL)
1323 {
1324 // the module is local, just forward the call to the dispatcher
1325 nlassert(senderProxy != NULL);
1326 nlassert(_ModuleProxies.find(senderProxy->getModuleProxyId()) != _ModuleProxies.end());
1327
1328 // invert the message for immediate dispatching if needed
1329 if (!message.isReading())
1330 const_cast<CMessage&>(message).invert();
1331
1332 // check if the module support immediate dispatching
1333 TModuleId addresseeModId = addresseeProxy->getForeignModuleId();
1334
1335 const TModulePtr *adrcp = _PluggedModules.getB(addresseeModId);
1336 if (adrcp == NULL)
1337 {
1338 nlwarning("sendModuleMessage : can't find addressee module %u that is not plugged here !", addresseeModId);
1339 return;
1340 }
1341
1342 IModule *addreseeMod = *adrcp;
1343 if (!addreseeMod->isImmediateDispatchingSupported())
1344 {
1345 // dispatch the message at next gateway update
1346 // this provide a coherent behavior between local and distant module message exchange
1347
1348 _LocalMessages.push_back(TLocalMessage());
1349 TLocalMessage &lm = _LocalMessages.back();
1350 lm.SenderProxyId = senderProxy->getModuleProxyId();
1351 lm.AddresseProxyId = addresseeProxy->getModuleProxyId();
1352
1353 nldebug("NETL6 : gateway '%s' : queuing local message '%s' from proxy %u to proxy %u",
1354 getModuleName().c_str(),
1355 message.getName().c_str(),
1356 lm.SenderProxyId,
1357 lm.AddresseProxyId);
1358
1359 if (message.hasLockedSubMessage())
1360 {
1361 lm.Message.assignFromSubMessage(message);
1362 }
1363 else
1364 {
1365 lm.Message = message;
1366 }
1367 }
1368 else
1369 {
1370 // immediate dispatching
1371 dispatchModuleMessage(senderProxy, addresseeProxy, message);
1372 }
1373 }
1374 else
1375 {
1376 // the module is distant, send the message via the route
1377 // create a message for sending
1378 CMessage msgHeader("MOD_OP");
1379 CModuleMessageHeaderCodec::encode(
1380 msgHeader,
1381 CModuleMessageHeaderCodec::mt_oneway,
1382 senderProxy->getModuleProxyId(),
1383 addresseeProxy->getForeignModuleId());
1384
1385 // send any pending module info
1386 sendPendingModuleUpdate(addresseeProxy->getGatewayRoute());
1387
1388 // send the header
1389 addresseeProxy->getGatewayRoute()->sendMessage(msgHeader);
1390 // send the message
1391 addresseeProxy->getGatewayRoute()->sendMessage(message);
1392 }
1393 }
1394 virtual void dispatchModuleMessage(IModuleProxy *senderProxy, IModuleProxy *addresseeProxy, const CMessage &message)
1395 {
1396 H_AUTO(CModuleGetaway_dispatchModuleMessage);
1397 CMessage::TMessageType msgType = message.getType();
1398 // retrieve the address module from the proxy
1399 nlassert(addresseeProxy->getGatewayRoute() == NULL);
1400 // As the addressee is local, the foreign proxy id is the local module id (a bit triky...)
1401 TModuleId addresseeModId = addresseeProxy->getForeignModuleId();
1402
1403 const TModulePtr *adrcp = _PluggedModules.getB(addresseeModId);
1404 if (adrcp == NULL)
1405 {
1406 nlwarning("dispatchModuleMessage : dispatching a message to module %u that is not plugged here !", addresseeModId);
1407 return;
1408 }
1409
1410 IModule *addreseeMod = *adrcp;
1411
1412 // finally, transmit the message to the module
1413 // addreseeMod->onProcessModuleMessage(senderProxy, message);
1414 try
1415 {
1416 addreseeMod->onReceiveModuleMessage(senderProxy, message);
1417 }
1418 catch(...)
1419 {
1420 nlwarning("An exception was thrown while dispatching message '%s' from '%s' to '%s'",
1421 message.getName().c_str(),
1422 senderProxy->getModuleName().c_str(),
1423 addresseeProxy->getModuleName().c_str());
1424
1425 if (msgType == CMessage::Request)
1426 {
1427 // send back an exception message
1428 CMessage except;
1429 except.setType("EXCEPT", CMessage::Except);
1430 senderProxy->sendModuleMessage(addreseeMod, except);
1431 }
1432 }
1433 }
1434 /***********************************************************
1435 ** Module methods
1436 ***********************************************************/
1437 bool initModule(const TParsedCommandLine &initInfo)
1438 {
1439 bool ret = CModuleBase::initModule(initInfo);
1440
1441 // no options for now
1442
1443 registerSocket();
1444 registerGateway();
1445
1446 return ret;
1447 }
1448
1449 std::string buildModuleManifest() const
1450 {
1451 return string();
1452 }
1453
1454
1455 void onServiceUp(const std::string &/* serviceName */, NLNET::TServiceId /* serviceId */)
1456 {
1457 }
1458 void onServiceDown(const std::string &/* serviceName */, NLNET::TServiceId /* serviceId */)
1459 {
1460 }
1461 void onModuleUpdate()
1462 {
1463 H_AUTO(CModuleGetaway_onModuleUpdate);
1464 // send waiting local messages
1465 while (!_LocalMessages.empty())
1466 {
1467 TLocalMessage &lm = _LocalMessages.front();
1468
1469 IModuleProxy *senderProx = getModuleProxy(lm.SenderProxyId);
1470 IModuleProxy *addresseeProx = getModuleProxy(lm.AddresseProxyId);
1471
1472 if (senderProx == NULL)
1473 {
1474 nlwarning("CStandardGateway : local message dispatching : Failed to retrieve proxy for sender module %u while dispatching message '%s' to %u",
1475 lm.SenderProxyId,
1476 lm.Message.getName().c_str(),
1477 lm.AddresseProxyId);
1478 }
1479 else if (addresseeProx == NULL)
1480 {
1481 nlwarning("CStandardGateway : local message dispatching : Failed to retrieve proxy for addressee module %u while dispatching message '%s' from %u",
1482 lm.AddresseProxyId,
1483 lm.Message.getName().c_str(),
1484 lm.SenderProxyId);
1485 }
1486 else
1487 {
1488 // we can dispatch the message
1489 dispatchModuleMessage(senderProx, addresseeProx, lm.Message);
1490 }
1491
1492 _LocalMessages.pop_front();
1493 }
1494
1495 // send pending module un/disclosure
1496 {
1497 TRouteList::iterator first(_Routes.begin()), last(_Routes.end());
1498 for (; first != last; ++first)
1499 {
1500 CGatewayRoute *route = *first;
1501 sendPendingModuleUpdate(route);
1502 }
1503 }
1504 // update the transports
1505 {
1506 TTransportList::iterator first(_Transports.begin()), last(_Transports.end());
1507 for (; first != last; ++first)
1508 {
1509 IGatewayTransport *transport = first->second;
1510
1511 transport->update();
1512 }
1513 }
1514 }
1515
1516 void onApplicationExit()
1517 {
1518 // delete all transport
1519 while (!_Transports.empty())
1520 {
1521 deleteTransport(_Transports.begin()->first);
1522 }
1523 }
1524
1525 void onModuleUp(IModuleProxy * /* moduleProxy */)
1526 {
1527 }
1528 void onModuleDown(IModuleProxy * /* moduleProxy */)
1529 {
1530 }
1531 bool onProcessModuleMessage(IModuleProxy * /* senderModuleProxy */, const CMessage &message)
1532 {
1533 // simple message for debug and unit testing
1534 if (message.getName() == "DEBUG_MOD_PING")
1535 {
1536 _PingCounter++;
1537
1538 return true;
1539 }
1540
1541 return false;
1542 }
1543
1544 void onModuleSecurityChange(IModuleProxy * /* moduleProxy */)
1545 {
1546 }
1547
1548 void onModuleSocketEvent(IModuleSocket * /* moduleSocket */, TModuleSocketEvent /* eventType */)
1549 {
1550 }
1551
1552 /***********************************************************
1553 ** Socket methods
1554 ***********************************************************/
1555
1556 const std::string &getSocketName()
1557 {
1558 return getModuleName();
1559 }
1560
1561 void _sendModuleMessage(IModule *senderModule, TModuleId destModuleProxyId, const NLNET::CMessage &message)
1562 {
1563 // the socket implementation already checked that the module is plugged here
1564 // just check that the destination module effectively from here
1565 TLocalModuleIndex::iterator it(_LocalModuleIndex.find(senderModule->getModuleId()));
1566 nlassert(it != _LocalModuleIndex.end());
1567
1568 // get the sender proxy
1569 TModuleProxies::iterator it2(_ModuleProxies.find(it->second));
1570 nlassert(it2 != _ModuleProxies.end());
1571
1572 IModuleProxy *senderProx = it2->second;
1573
1574 // get the addressee proxy
1575 it2 = _ModuleProxies.find(destModuleProxyId);
1576 nlassert(it2 != _ModuleProxies.end());
1577
1578 IModuleProxy *destProx = it2->second;
1579
1580
1581 sendModuleProxyMessage(senderProx, destProx, message);
1582 }
1583
1584 virtual void _broadcastModuleMessage(IModule *senderModule, const NLNET::CMessage &message)
1585 {
1586 H_AUTO(CModuleGetaway__broadcastModuleMessage);
1587 // send the message to all proxies (except the sender module)
1588 TLocalModuleIndex::iterator it(_LocalModuleIndex.find(senderModule->getModuleId()));
1589 nlassert(it != _LocalModuleIndex.end());
1590
1591 TModuleProxies::iterator first(_ModuleProxies.begin()), last(_ModuleProxies.end());
1592 for (; first != last; ++first)
1593 {
1594 IModuleProxy *proxy = first->second;
1595
1596 proxy->sendModuleMessage(senderModule, message);
1597 }
1598 }
1599
1600 void onModulePlugged(IModule *pluggedModule)
1601 {
1602 nldebug("NETL6: Gateway %s : plugging module '%s' id=%u",
1603 getModuleName().c_str(),
1604 pluggedModule->getModuleName().c_str(),
1605 pluggedModule->getModuleId());
1606
1607 // A module has just been plugged here, we need to disclose it to the
1608 // other module, and disclose other module to it.
1609
1610 // create a proxy for this module
1611 IModuleProxy *modProx = IModuleManager::getInstance().createModuleProxy(
1612 this,
1613 NULL, // the module is local, so there is no route
1614 0, // the module is local, distance is 0
1615 pluggedModule, // the module is local, so store the module pointer
1616 pluggedModule->getModuleClassName(),
1617 pluggedModule->getModuleFullyQualifiedName(),
1618 pluggedModule->getModuleManifest(),
1619 pluggedModule->getModuleId() // the module is local, foreign id is the module id
1620 );
1621
1622 // and store it in the proxies container
1623 _ModuleProxies.insert(make_pair(modProx->getModuleProxyId(), modProx));
1624 _NameToProxyIdx.add(CStringMapper::map(modProx->getModuleName()), modProx);
1625
1626 // and also in the local module index
1627 _LocalModuleIndex.insert(make_pair(pluggedModule->getModuleId(), modProx->getModuleProxyId()));
1628
1629
1630 // trigger the new module proxy event
1631 onAddModuleProxy(modProx);
1632 // // disclose the new module to other modules
1633 // discloseModule(modProx);
1634 //
1635 // second, disclose already known proxies in the gateway to the plugged module
1636 {
1637 TModuleProxies::iterator first(_ModuleProxies.begin()), last(_ModuleProxies.end());
1638 for (; first != last; ++first)
1639 {
1640 IModuleProxy *modProx = first->second;
1641
1642 // do not send a moduleUp on the module himself !
1643 // either the gateway is non null (distant module), or the
1644 // foreign module id is different of the local module (for local proxy,
1645 // the foreign module id store the local module id).
1646 if (modProx->getGatewayRoute() != NULL || modProx->getForeignModuleId() != pluggedModule->getModuleId())
1647 {
1648 pluggedModule->_onModuleUp(modProx);
1649 }
1650 }
1651 }
1652
1653
1654 }
1655 /// Called just after a module as been effectively unplugged from a socket
1656 void onModuleUnplugged(IModule *unpluggedModule)
1657 {
1658 nldebug("NETL6: Gateway %s : unplugging module '%s' id=%u",
1659 getModuleName().c_str(),
1660 unpluggedModule->getModuleName().c_str(),
1661 unpluggedModule->getModuleId());
1662
1663 // remove the proxy info
1664 TLocalModuleIndex::iterator it(_LocalModuleIndex.find(unpluggedModule->getModuleId()));
1665 nlassert(it != _LocalModuleIndex.end());
1666 TModuleProxies::iterator it2(_ModuleProxies.find(it->second));
1667 nlassert(it2 != _ModuleProxies.end());
1668
1669 IModuleProxy *modProx = it2->second;
1670
1671 // warn the unplugged module that all proxies in this gateway become unavailable
1672 {
1673 TModuleProxies::iterator first(_ModuleProxies.begin()), last(_ModuleProxies.end());
1674 for (; first != last; ++first)
1675 {
1676 IModuleProxy *modProx = first->second;
1677
1678 if (modProx->getGatewayRoute() != NULL
1679 || modProx->getForeignModuleId() != unpluggedModule->getModuleId())
1680 {
1681 unpluggedModule->_onModuleDown(modProx);
1682 }
1683 }
1684 }
1685
1686 /// the gateway do the rest of the job
1687 onRemoveModuleProxy(modProx);
1688
1689 TModuleId localProxyId = modProx->getModuleProxyId();
1690 // remove reference to the proxy
1691 _ModuleProxies.erase(it2);
1692 _NameToProxyIdx.removeWithB(modProx);
1693 _LocalModuleIndex.erase(it);
1694
1695 // check in the local message queue if some message are to/from
1696 // this module
1697 TLocalMessageList::iterator first(_LocalMessages.begin()), last(_LocalMessages.end());
1698 for (; first != last; ++first)
1699 {
1700 TLocalMessage &lm = *first;
1701 if (lm.AddresseProxyId == localProxyId
1702 || lm.SenderProxyId == localProxyId)
1703 {
1704 // erase this message !
1705 nlwarning("CStandardGateway : while unplugging module %u from the gateway, locale message '%s' from proxy %u to proxy %u is lost",
1706 unpluggedModule->getModuleId(),
1707 lm.Message.getName().c_str(),
1708 lm.SenderProxyId,
1709 lm.AddresseProxyId);
1710 TLocalMessageList::iterator next = first;
1711 ++next;
1712 if (next == last)
1713 {
1714 _LocalMessages.erase(first);
1715 break;
1716 }
1717 else
1718 {
1719 _LocalMessages.erase(first);
1720 first = next;
1721 }
1722 }
1723 }
1724
1725
1726 // release the module proxy
1727 IModuleManager::getInstance().releaseModuleProxy(localProxyId);
1728
1729 }
1730
1731 ////////////////////////////////////////////////////
1732 // Gateway internal methods
1733 ////////////////////////////////////////////////////
1734
1735 void removeForeignModule(CGatewayRoute *route, TModuleId foreignModuleId)
1736 {
1737 // translate the module id
1738 const TModuleId *pModuleId = route->ForeignToLocalIdx.getB(foreignModuleId);
1739 if (pModuleId == NULL)
1740 {
1741 // oups !
1742 nlwarning("removeForeignModule : unknown foreign module id %u", foreignModuleId);
1743 return;
1744 }
1745
1746 TModuleId proxyId = *pModuleId;
1747
1748 // retrieve the module proxy
1749 TModuleProxies::iterator it2(_ModuleProxies.find(proxyId));
1750 if (it2 == _ModuleProxies.end())
1751 {
1752 // oups !
1753 nlwarning("Gateway '%s' : removeForeignModule : can't find proxy for id %u coming from foreign id %u",
1754 getGatewayName().c_str(),
1755 proxyId,
1756 foreignModuleId);
1757
1758 // still remove the idx
1759 route->ForeignToLocalIdx.removeWithA(foreignModuleId);
1760 return;
1761 }
1762 CModuleProxy *modProx = static_cast<CModuleProxy *>(it2->second.getPtr());
1763
1764 // remove module information
1765 pair<TKnownModuleInfos::iterator, TKnownModuleInfos::iterator> range;
1766 range = _KnownModules.equal_range(modProx->_FullyQualifiedModuleName);
1767 nlassert(range.first != range.second);
1768 bool found = false;
1769 for (;range.first != range.second; ++range.first)
1770 {
1771 TKnownModuleInfo &kmi = range.first->second;
1772
1773 if (kmi.Route == route)
1774 {
1775 nldebug("Gateway '%s' : removing foreign module info for '%s'",
1776 getGatewayName().c_str(),
1777 CStringMapper::unmap(range.first->first).c_str());
1778 // we have found the info relative to this module
1779 _KnownModules.erase(range.first);
1780 found = true;
1781 break;
1782 }
1783 }
1784 nlassert(found == true);
1785 // NB : stl debug mode don't allow to test with range.first when range;first is erased.
1786 // nlassert(range.first != range.second);
1787
1788 // check if there is another view of this module
1789 // if so, we keep the proxy and, eventually, we update the distance
1790 range = _KnownModules.equal_range(modProx->_FullyQualifiedModuleName);
1791 if (range.first != range.second)
1792 {
1793 // clean the translation table
1794 route->ForeignToLocalIdx.removeWithA(foreignModuleId);
1795
1796 // we keep the proxy, choose the best route
1797 TKnownModuleInfos::iterator best(_KnownModules.end());
1798
1799 for (; range.first != range.second; ++range.first)
1800 {
1801 if (best == _KnownModules.end()
1802 || best->second.ModuleDistance > range.first->second.ModuleDistance)
1803 best = range.first;
1804 }
1805 nlassert(best != _KnownModules.end());
1806 TKnownModuleInfo &kmi = best->second;
1807
1808 if (modProx->_Route != kmi.Route)
1809 {
1810 // the best route has changed, update the proxy
1811
1812 nldebug("Gateway '%s' : use a new route for module '%s' from %u to %u hop",
1813 getGatewayName().c_str(),
1814 modProx->getModuleName().c_str(),
1815 modProx->_Distance,
1816 kmi.ModuleDistance);
1817
1818 // update the proxy data
1819 modProx->_Route = kmi.Route;
1820 modProx->_ForeignModuleId = kmi.ForeignProxyId;
1821 if (modProx->_Distance != kmi.ModuleDistance)
1822 {
1823 // the distance has changed, update and send the new distance to other gateway
1824 modProx->_Distance = kmi.ModuleDistance;
1825 sendModuleDistanceUpdate(modProx);
1826 }
1827 }
1828 }
1829 else
1830 {
1831 // do not remove proxy for local module from her !
1832 if (modProx->_Route != NULL)
1833 {
1834 // this module is no longer reachable, remove the proxy
1835
1836 // trigger an event in the gateway
1837 onRemoveModuleProxy(modProx);
1838
1839 // remove from the proxy list
1840 _NameToProxyIdx.removeWithB(modProx);
1841 _ModuleProxies.erase(it2);
1842 // release the proxy
1843 IModuleManager::getInstance().releaseModuleProxy(proxyId);
1844 }
1845 // clean the translation table
1846 route->ForeignToLocalIdx.removeWithA(foreignModuleId);
1847 }
1848 }
1849
1850 void sendModuleDistanceUpdate(IModuleProxy *proxy)
1851 {
1852 // in fact, don't send immediately, store update in each
1853 // route and wait the next update or module message sending
1854 // to effectively send the update
1855
1856 // for each route
1857 TRouteList::iterator first(_Routes.begin()), last(_Routes.end());
1858 for (; first != last; ++first)
1859 {
1860 CGatewayRoute *route = *first;
1861 if (isModuleProxyVisible(proxy, route))
1862 {
1863 updateModuleDistanceToRoute(route, proxy);
1864 // // TODO : optimize by batch sending
1865 // TModuleDistanceChangeMsg mdu;
1866 //
1867 // mdu.ModuleId = proxy->getModuleProxyId();
1868 // mdu.NewDistance = proxy->getModuleDistance()+1;
1869 //
1870 // CMessage msg("MOD_DST_UPD");
1871 // msg.serial(mdu);
1872 //
1873 // sendPendingModuleUpdate(route);
1874 // route->sendMessage(msg);
1875 }
1876 }
1877 }
1878
1879 /// Check if a module can be seen by a route
1880 bool isModuleProxyVisible(IModuleProxy *proxy, CGatewayRoute *route)
1881 {
1882 if (route == NULL)
1883 {
1884 // no route, we can see the proxy
1885 return true;
1886 }
1887 // check firewall rules
1888 if (route->getTransport()->Firewalled)
1889 {
1890 if (route->FirewallDisclosed.find(proxy->getModuleProxyId()) == route->FirewallDisclosed.end())
1891 return false;
1892 }
1893
1894 // if the module is local, then, it can be seen
1895 if (proxy->getGatewayRoute() == NULL)
1896 return true;
1897
1898 // if the module is on the same route, it can't be seen (it is seen by the route outbound)
1899 if (proxy->getGatewayRoute() == route)
1900 return false;
1901
1902 IGatewayTransport *transport = route->getTransport();
1903 // if the module is on a different transport, it can be seen
1904 if (proxy->getGatewayRoute()->getTransport() != transport)
1905 {
1906 // we also need to check if this module is known in this route
1907 // CGatewayRoute::TForeignToLocalIdx::iterator it(route->ForeignToLocalIdx.find(proxy->getForeignModuleId()));
1908 if (route->ForeignToLocalIdx.getA(proxy->getModuleProxyId()) != NULL)
1909 // this module is known in this route, so not invisible
1910 return false;
1911
1912 // ok, we can see
1913 return true;
1914 }
1915
1916 // if the transport in not in peer invisible, it can be seen
1917 if (!transport->PeerInvisible)
1918 return true;
1919
1920 // not visible
1921 return false;
1922 }
1923
1924 /// Disclose module information to a gateway route
1925 void discloseModuleToRoute(CGatewayRoute *route, IModuleProxy *proxy)
1926 {
1927 // route->PendingUndisclosure.erase(proxy->getModuleProxyId());
1928 CGatewayRoute::TPendingEvent pe;
1929 pe.EventType = CGatewayRoute::pet_disclose_module;
1930 pe.ModuleId = proxy->getModuleProxyId();
1931 route->PendingEvents.push_back(pe);
1932 // route->PendingDisclosure.insert(proxy);
1933 }
1934 /// Undisclose module information to a gateway route
1935 void undiscloseModuleToRoute(CGatewayRoute *route, IModuleProxy *proxy)
1936 {
1937 // route->PendingDisclosure.erase(proxy);
1938 // route->PendingUndisclosure.insert(proxy->getModuleProxyId());
1939 // route->FirewallDisclosed.erase(proxy->getModuleProxyId());
1940
1941 CGatewayRoute::TPendingEvent pe;
1942 pe.EventType = CGatewayRoute::pet_undisclose_module;
1943 pe.ModuleId = proxy->getModuleProxyId();
1944 route->PendingEvents.push_back(pe);
1945
1946 route->FirewallDisclosed.erase(proxy->getModuleProxyId());
1947 }
1948
1949 /// the distance of a module need to be update to peers
1950 void updateModuleDistanceToRoute(CGatewayRoute *route, IModuleProxy *proxy)
1951 {
1952 CGatewayRoute::TPendingEvent pe;
1953 pe.EventType = CGatewayRoute::pet_update_distance;
1954 pe.ModuleId = proxy->getModuleProxyId();
1955 route->PendingEvents.push_back(pe);
1956 }
1957 /// The security data need to be updated to peers
1958 void updateModuleSecurityDataToRoute(CGatewayRoute *route, IModuleProxy *proxy)
1959 {
1960 CGatewayRoute::TPendingEvent pe;
1961 pe.EventType = CGatewayRoute::pet_update_security;
1962 pe.ModuleId = proxy->getModuleProxyId();
1963 route->PendingEvents.push_back(pe);
1964 }
1965
1966 void sendPendingModuleUpdate(CGatewayRoute *route)
1967 {
1968 if (route->PendingEvents.empty())
1969 return;
1970
1971 CMessage updateMsg("MOD_UPD");
1972
1973 // compil all update in a single message
1974 while (!route->PendingEvents.empty())
1975 {
1976 CGatewayRoute::TPendingEvent &pe = route->PendingEvents.front();
1977 switch (pe.EventType)
1978 {
1979 case CGatewayRoute::pet_disclose_module:
1980 {
1981 IModuleProxy *proxy = getModuleProxy(pe.ModuleId);
1982 if (proxy == NULL)
1983 break;
1984
1985 // store the update type
1986 updateMsg.serialShortEnum(pe.EventType);
1987
1988 // encode the message data
1989 TModuleDescCodec modDesc(proxy);
1990 updateMsg.serial(modDesc);
1991 // modDesc.encode(proxy, updateMsg);
1992 }
1993
1994 break;
1995 case CGatewayRoute::pet_undisclose_module:
1996 {
1997 // store the update type
1998 updateMsg.serialShortEnum(pe.EventType);
1999
2000 // store the module id
2001 updateMsg.serial(pe.ModuleId);
2002 }
2003
2004 break;
2005 case CGatewayRoute::pet_update_distance:
2006 {
2007 IModuleProxy *proxy = getModuleProxy(pe.ModuleId);
2008 if (proxy == NULL)
2009 break;
2010
2011 // store the update type
2012 updateMsg.serialShortEnum(pe.EventType);
2013
2014 // store module ID and distance
2015 updateMsg.serial(pe.ModuleId);
2016 uint32 distance = proxy->getModuleDistance()+1;
2017 updateMsg.serial(distance);
2018 }
2019 break;
2020 case CGatewayRoute::pet_update_security:
2021 {
2022 IModuleProxy *proxy = getModuleProxy(pe.ModuleId);
2023 if (proxy == NULL)
2024 break;
2025
2026 // store the update type
2027 updateMsg.serialShortEnum(pe.EventType);
2028
2029 // store module ID and security data
2030 TModuleSecurityChangeMsg secChg;
2031 secChg.ModuleId = pe.ModuleId;
2032 secChg.SecDesc.SecurityData = const_cast<TSecurityData*>(proxy->getFirstSecurityData());
2033 updateMsg.serial(secChg);
2034 // updateMsg.serial(pe.ModuleId);
2035 // TSecurityData *modSec = const_cast<TSecurityData*>(proxy->getFirstSecurityData());
2036 // updateMsg.serialPolyPtr(modSec);
2037 }
2038 break;
2039 default:
2040 // should not append
2041 nlstop;
2042 }
2043
2044 route->PendingEvents.pop_front();
2045 }
2046
2047 // now send the message
2048 route->sendMessage(updateMsg);
2049
2050 // // send pending module proxy un/disclosure
2051 // if (!route->PendingDisclosure.empty())
2052 // {
2053 // // disclose new module
2054 // TModuleAddMsg message;
2055 // message.Modules.resize(route->PendingDisclosure.size());
2056 //
2057 // std::set<IModuleProxy*>::iterator first(route->PendingDisclosure.begin()), last(route->PendingDisclosure.end());
2058 // for (uint i=0; first != last; ++i, ++first)
2059 // {
2060 // TModuleDescMsg &modDesc = message.Modules[i];
2061 // IModuleProxy *addedModule = *first;
2062 //
2063 // modDesc.ModuleProxyId = addedModule->getModuleProxyId();
2064 // modDesc.ModuleClass = addedModule->getModuleClassName();
2065 // modDesc.ModuleFullName = addedModule->getModuleName();
2066 // modDesc.ModuleDistance = addedModule->getModuleDistance()+1;
2067 // }
2068 // route->PendingDisclosure.clear();
2069 //
2070 // CMessage buffer("MOD_ADD");
2071 // buffer.serial(message);
2072 //
2073 // route->sendMessage(buffer);
2074 // }
2075 // if (!route->PendingUndisclosure.empty())
2076 // {
2077 // // disclose new module
2078 // TModuleRemMsg message;
2079 // std::copy(route->PendingUndisclosure.begin(), route->PendingUndisclosure.end(), back_insert_iterator<vector<TModuleId> >(message.RemovedModules));
2080 // route->PendingUndisclosure.clear();
2081 //
2082 // CMessage buffer("MOD_REM");
2083 // buffer.serial(message);
2084 //
2085 // route->sendMessage(buffer);
2086 // }
2087 }
2088
2089 void getModuleList(std::vector<IModuleProxy*> &resultList)
2090 {
2091 TModuleProxies::iterator first(_ModuleProxies.begin()), last(_ModuleProxies.end());
2092 for (; first != last; ++first)
2093 {
2094 resultList.push_back(first->second);
2095 }
2096 }
2097
2098
2099 NLMISC_COMMAND_HANDLER_TABLE_EXTEND_BEGIN(CStandardGateway, CModuleBase)
2100 NLMISC_COMMAND_HANDLER_ADD(CStandardGateway, dump, "dump various information about the gateway statue", "")
2101 NLMISC_COMMAND_HANDLER_ADD(CStandardGateway, transportListAvailableClass, "list the available transport class", "no param")
2102 NLMISC_COMMAND_HANDLER_ADD(CStandardGateway, transportAdd, "add a new transport to this gateway", "<transportClass> <instanceName>")
2103 NLMISC_COMMAND_HANDLER_ADD(CStandardGateway, transportOptions, "set a gateway level option on a transport", "<transportClass> ( [PeerInvisible] [Firewalled] )")
2104 NLMISC_COMMAND_HANDLER_ADD(CStandardGateway, transportCmd, "send a command to a transport", "[<transportName> ( <cmd specific to transport> )]*")
2105 NLMISC_COMMAND_HANDLER_ADD(CStandardGateway, transportRemove, "remove an existing transport instance", "<transportName>")
2106 NLMISC_COMMAND_HANDLER_ADD(CStandardGateway, securityListAvailableClass, "list the available security class", "no param")
2107 NLMISC_COMMAND_HANDLER_ADD(CStandardGateway, securityCreate, "create a security plug-in", "<securityClassName>")
2108 NLMISC_COMMAND_HANDLER_ADD(CStandardGateway, securityCommand, "send a command to the security plug-in", "<cmd specific to plug-in>")
2109 NLMISC_COMMAND_HANDLER_ADD(CStandardGateway, securityRemove, "remove the security plug-in", "no parameter")
2110 NLMISC_COMMAND_HANDLER_TABLE_END
2111
2112 NLMISC_CLASS_COMMAND_DECL(securityRemove)
2113 {
2114 nlunreferenced(rawCommandString);
2115 nlunreferenced(args);
2116 nlunreferenced(quiet);
2117 nlunreferenced(human);
2118
2119 if (_SecurityPlugin == NULL)
2120 {
2121 log.displayNL("No security plug-in !");
2122 return true;
2123 }
2124
2125 removeSecurityPlugin();
2126
2127 return true;
2128 }
2129
2130 NLMISC_CLASS_COMMAND_DECL(securityCommand)
2131 {
2132 nlunreferenced(args);
2133 nlunreferenced(quiet);
2134 nlunreferenced(human);
2135
2136 TParsedCommandLine command;
2137
2138 if (!command.parseParamList(rawCommandString))
2139 {
2140 log.displayNL("Invalid command line");
2141 return false;
2142 }
2143
2144 if (command.SubParams.size() < 2)
2145 {
2146 log.displayNL("Invalid command line");
2147 return false;
2148 }
2149
2150 if (_SecurityPlugin == NULL)
2151 {
2152 log.displayNL("No security plug-in !");
2153 return true;
2154 }
2155
2156 sendSecurityCommand(*command.SubParams[1]);
2157
2158 return true;
2159 }
2160
2161 NLMISC_CLASS_COMMAND_DECL(securityCreate)
2162 {
2163 nlunreferenced(rawCommandString);
2164 nlunreferenced(quiet);
2165 nlunreferenced(human);
2166
2167 if (args.size() != 1)
2168 return false;
2169
2170 if (_SecurityPlugin != NULL)
2171 {
2172 log.displayNL("The gateway already have a security plug-in ! Remove it first");
2173 return true;
2174 }
2175
2176 log.displayNL("Creating a security plug-in '%s' in gateway '%s'",
2177 args[0].c_str(),
2178 getModuleName().c_str());
2179 createSecurityPlugin(args[0]);
2180
2181 return true;
2182
2183 }
2184 NLMISC_CLASS_COMMAND_DECL(securityListAvailableClass)
2185 {
2186 nlunreferenced(rawCommandString);
2187 nlunreferenced(quiet);
2188 nlunreferenced(human);
2189
2190 if (args.size() != 0)
2191 return false;
2192
2193 vector<string> list;
2194 NLMISC_GET_FACTORY(CGatewaySecurity, std::string).fillFactoryList(list);
2195
2196 log.displayNL("List of %u available security class :", list.size());
2197
2198 for (uint i=0; i<list.size(); ++i)
2199 {
2200 log.displayNL(" '%s'", list[i].c_str());
2201 }
2202
2203 return true;
2204 }
2205
2206 NLMISC_CLASS_COMMAND_DECL(transportRemove)
2207 {
2208 nlunreferenced(rawCommandString);
2209 nlunreferenced(log);
2210 nlunreferenced(quiet);
2211 nlunreferenced(human);
2212
2213 if (args.size() != 1)
2214 return false;
2215
2216 deleteTransport(args[0]);
2217 return true;
2218 }
2219
2220 NLMISC_CLASS_COMMAND_DECL(transportCmd)
2221 {
2222 nlunreferenced(args);
2223 nlunreferenced(quiet);
2224 nlunreferenced(human);
2225
2226 TParsedCommandLine pcl;
2227 if (!pcl.parseParamList(rawCommandString))
2228 {
2229 log.displayNL("Invalid parameter string, parse error");
2230 return false;
2231 }
2232
2233 transportCommand(pcl);
2234 return true;
2235 }
2236
2237 NLMISC_CLASS_COMMAND_DECL(transportOptions)
2238 {
2239 nlunreferenced(quiet);
2240 nlunreferenced(human);
2241
2242 if (args.size() < 1)
2243 return false;
2244
2245 // parse the params
2246 TParsedCommandLine cl;
2247 if (!cl.parseParamList(rawCommandString))
2248 return false;
2249
2250 if (cl.SubParams.size() != 2)
2251 return false;
2252
2253 string transName = cl.SubParams[1]->ParamName;
2254 if (_Transports.find(transName) == _Transports.end())
2255 {
2256 log.displayNL("unknown transport '%s'", transName.c_str());
2257 return false;
2258 }
2259
2260 // IGatewayTransport *transport = _Transports.find(transName)->second;
2261
2262 // check for peer invisible
2263 if (cl.SubParams[1]->getParam("PeerInvisible"))
2264 setTransportPeerInvisible(transName, true);
2265 else
2266 setTransportPeerInvisible(transName, false);
2267
2268 // check for firewall mode
2269 if (cl.SubParams[1]->getParam("Firewalled"))
2270 setTransportFirewallMode(transName, true);
2271 else
2272 setTransportFirewallMode(transName, false);
2273
2274 return true;
2275 }
2276
2277 NLMISC_CLASS_COMMAND_DECL(transportAdd)
2278 {
2279 nlunreferenced(rawCommandString);
2280 nlunreferenced(quiet);
2281 nlunreferenced(human);
2282
2283 if (args.size() != 2)
2284 return false;
2285
2286 if (_Transports.find(args[1]) != _Transports.end())
2287 {
2288 log.displayNL("A transport with that name already exist !");
2289 return true;
2290 }
2291
2292 createTransport(args[0], args[1]);
2293 return true;
2294 }
2295
2296 NLMISC_CLASS_COMMAND_DECL(transportListAvailableClass)
2297 {
2298 nlunreferenced(rawCommandString);
2299 nlunreferenced(quiet);
2300 nlunreferenced(human);
2301
2302 if (args.size() != 0)
2303 return false;
2304
2305 vector<string> list;
2306 NLMISC_GET_FACTORY(IGatewayTransport, std::string).fillFactoryList(list);
2307
2308 log.displayNL("List of %u available transport class :", list.size());
2309
2310 for (uint i=0; i<list.size(); ++i)
2311 {
2312 log.displayNL(" '%s'", list[i].c_str());
2313 }
2314 return true;
2315 }
2316
2317 NLMISC_CLASS_COMMAND_DECL(dump)
2318 {
2319 if (!args.empty())
2320 return false;
2321
2322 // recall the dump for the module class
2323 NLMISC_CLASS_COMMAND_CALL_BASE(CModuleBase, dump);
2324
2325 log.displayNL("-----------------------------");
2326 log.displayNL("Dumping gateway information :");
2327 log.displayNL("-----------------------------");
2328
2329 log.displayNL("The gateway has %u locally plugged module :", _PluggedModules.getAToBMap().size());
2330 {
2331 TPluggedModules::TAToBMap::const_iterator first(_PluggedModules.getAToBMap().begin()), last(_PluggedModules.getAToBMap().end());
2332 for (; first != last; ++first)
2333 {
2334 IModule *module = first->second;
2335 log.displayNL(" ID:%5u : \tName = '%s' \tclass = '%s'",
2336 module->getModuleId(),
2337 module->getModuleName().c_str(),
2338 module->getModuleClassName().c_str());
2339 }
2340 }
2341
2342
2343 log.displayNL("The gateway as %u transport activated :", _Transports.size());
2344 {
2345 TTransportList::iterator first(_Transports.begin()), last(_Transports.end());
2346 for (; first != last; ++first)
2347 {
2348 const string &name = first->first;
2349 IGatewayTransport *transport = first->second;
2350
2351 log.displayNL("Transport '%s' (transport class is '%s') :",
2352 name.c_str(),
2353 transport->getClassName().c_str());
2354 log.displayNL(" * %s", transport->PeerInvisible ? "Peer module are NON visible" : "Peer modules are visible");
2355 log.displayNL(" * %s", transport->Firewalled ? "Firewall ON" : "Firewall OFF");
2356 transport->dump(log);
2357 }
2358 }
2359
2360 log.displayNL("------------------------------");
2361 log.displayNL("------- End of dump ----------");
2362 log.displayNL("------------------------------");
2363 return true;
2364 }
2365
2366 };
2367
2368
2369 // register the module factory
2370 NLNET_REGISTER_MODULE_FACTORY(CStandardGateway, "StandardGateway");
2371
2372
2373 /** Set a security data block. If a bloc of the same type
2374 * already exist in the list, the new one will replace the
2375 * existing one.
2376 */
2377 void CGatewaySecurity::setSecurityData(IModuleProxy *proxy, TSecurityData *securityData)
2378 {
2379 // forward the call to standard gateway
2380 CStandardGateway *sg = static_cast<CStandardGateway*>(_Gateway);
2381 sg->setSecurityData(proxy, securityData);
2382 }
2383
2384 /** Clear a block of security data
2385 * The block is identified by the data tag
2386 */
2387 bool CGatewaySecurity::removeSecurityData(IModuleProxy *proxy, uint8 dataTag)
2388 {
2389 // forward the call to standard gateway
2390 CStandardGateway *sg = static_cast<CStandardGateway*>(_Gateway);
2391 return sg->removeSecurityData(proxy, dataTag);
2392 }
2393
2394 /** Replace the complete set of security data with the new one.
2395 * Security data allocated on the proxy are freed,
2396 */
2397 void CGatewaySecurity::replaceAllSecurityDatas(IModuleProxy *proxy, TSecurityData *securityData)
2398 {
2399 // forward the call to standard gateway
2400 CStandardGateway *sg = static_cast<CStandardGateway*>(_Gateway);
2401 sg->replaceAllSecurityDatas(proxy, securityData);
2402 }
2403
2404 /** Ask the gateway to resend the security data.
2405 * The plug-in call this method after having changed
2406 * the security info for a plug-in outside of the
2407 * onNewProxy call.
2408 */
2409 void CGatewaySecurity::forceSecurityUpdate(IModuleProxy *proxy)
2410 {
2411 // forward the call to standard gateway
2412 CStandardGateway *sg = static_cast<CStandardGateway*>(_Gateway);
2413 sg->forceSecurityUpdate(proxy);
2414 }
2415
2416
2417
2418 void forceGatewayLink()
2419 {
2420 }
2421
2422 } // namespace NLNET
2423