nelns/naming_service/naming_service.cpp

   1 // NeLNS - 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 #ifdef HAVE_CONFIG_H
  18 #include "config.h"
  19 #endif // HAVE_CONFIG_H
  20
  21 #ifndef NELNS_CONFIG
  22 #define NELNS_CONFIG ""
  23 #endif // NELNS_CONFIG
  24
  25 #ifndef NELNS_LOGS
  26 #define NELNS_LOGS ""
  27 #endif // NELNS_LOGS
  28
  29
  30 //
  31 // Includes
  32 //
  33
  34 #include "nel/misc/types_nl.h"
  35
  36 #include <list>
  37 #include <string>
  38
  39 #include "nel/misc/debug.h"
  40 #include "nel/misc/command.h"
  41 #include "nel/misc/variable.h"
  42 #include "nel/misc/displayer.h"
  43
  44 #include "nel/net/callback_server.h"
  45 #include "nel/net/service.h"
  46 #include "nel/net/module_manager.h"
  47
  48 //
  49 // Namespaces
  50 //
  51
  52 using namespace std;
  53
  54 using namespace NLMISC;
  55 using namespace NLNET;
  56
  57
  58 NLMISC_COMMAND(test, "none", "none")
  59 {
  60         log.displayNL("Raw cmd line : '%s'", rawCommandString.c_str());
  61         log.displayNL("Dumping %u parameters :", args.size());
  62         for (uint i=0; i<args.size(); ++i)
  63         {
  64                 log.displayNL("  %u : '%s'", i, args[i].c_str());
  65         }
  66         return true;
  67 }
  68
  69
  70 //
  71 // Structures
  72 //
  73
  74 struct CServiceEntry
  75 {
  76         CServiceEntry (TSockId sock, const vector<CInetAddress> &a, const string &n, TServiceId s) : SockId(sock), Addr(a), Name(n), SId (s), WaitingUnregistration(false) { }
  77
  78         TSockId                                         SockId;                 // the connection between the service and the naming service
  79         vector<CInetAddress>            Addr;                   // address to send to the service who wants to lookup this service
  80                                                                                                 // it s possible to have more than one addr, anyway, the naming service
  81                                                                                                 // will send good address depending of the sub net address of the service
  82         string                                          Name;                   // name of the service
  83         TServiceId                                      SId;                    // id of the service
  84
  85         bool                            WaitingUnregistration;                  // true if this service is in unregistration process (wait other service ACK)
  86         TTime                           WaitingUnregistrationTime;              // time of the beginning of the inregistration process
  87         list<TServiceId>        WaitingUnregistrationServices;  // list of service that we wait the answer
  88 };
  89
  90
  91
  92 // Helper that emulates layer5's send()
  93 //void sendToService( uint16 sid, CMessage& msgout );
  94
  95 // Helper that emulate layer5's getServiceName()
  96 string getServiceName( TServiceId  sid );
  97
  98 // Helper that returns the first address of a service
  99 CInetAddress getHostAddress( TServiceId  sid );
 100
 101 // Asks a service to stop and tell every one
 102 void doUnregisterService (TServiceId sid);
 103
 104
 105 /**
 106  * Manager for services instances
 107  * (Moved from the TICKS to the NS)
 108  * Implementable with layer 5, here implemented in NS (layer 3)
 109  * \author Olivier Cado
 110  * \author Nevrax France
 111  * \date 2003
 112  */
 113 class CServiceInstanceManager
 114 {
 115 public:
 116
 117         /// Constructor
 118         CServiceInstanceManager();
 119
 120         /** Add the name of a service which must not be duplicated
 121          * If uniqueOnShard is true, only one service is allowed.
 122          * If uniqueOnShard is false, one service is allowed by physical machine.
 123          */
 124         void            addUniqueService( const std::string& serviceName, bool uniqueOnShard )
 125         {
 126                 _UniqueServices.insert( std::make_pair( serviceName, uniqueOnShard ) );
 127         }
 128
 129         /// Check if a service is allowed to start (if so, add it)
 130         bool            queryStartService( const std::string& serviceName, TServiceId  serviceId, const std::vector<NLNET::CInetAddress> &addr, string& reason );
 131
 132         /// Release a service instance
 133         void            releaseService( NLNET::TServiceId serviceId );
 134
 135         /// Display information
 136         void            displayInfo( NLMISC::CLog *log = NLMISC::InfoLog ) const;
 137
 138         /// Make all controlled services quit
 139         void            killAllServices();
 140
 141 private:
 142
 143         /// List of restricted services
 144         std::map< std::string, bool >   _UniqueServices;
 145
 146         /// List of granted (online) services
 147         std::set< TServiceId >                          _OnlineServices;
 148 };
 149
 150
 151 CServiceInstanceManager *SIMInstance = NULL;
 152
 153
 154 /*
 155  * Constructor
 156  */
 157 CServiceInstanceManager::CServiceInstanceManager()
 158 {
 159         nlassert( ! SIMInstance );
 160         SIMInstance = this;
 161
 162         // Note: addCallbackArray() done in CRangeMirrorManager::init()
 163 }
 164
 165
 166 /*
 167  * Check if a service is allowed to start. Answer with a GSTS (Grant Start Service) message
 168  */
 169 bool            CServiceInstanceManager::queryStartService( const std::string& serviceName, TServiceId  serviceId, const vector<CInetAddress> &addr, string& reason )
 170 {
 171         bool grantStarting = true;
 172         std::map< std::string, bool >::iterator ius = _UniqueServices.find( serviceName );
 173         if ( ius != _UniqueServices.end() )
 174         {
 175                 // Service is restricted
 176                 set< TServiceId >::iterator ios;
 177                 bool uniqueOnShard = (*ius).second;
 178                 for ( ios=_OnlineServices.begin(); ios!=_OnlineServices.end(); ++ios )
 179                 {
 180                         string name = getServiceName( *ios );
 181                         if ( name == serviceName )
 182                         {
 183                                 if ( uniqueOnShard )
 184                                 {
 185                                         // Only one service by shard is allowed => deny
 186                                         grantStarting = false;
 187                                         reason = toString( "Service %s already found as %hu, must be unique on shard", serviceName.c_str(), ios->get() );
 188                                         nlinfo( reason.c_str() );
 189                                         break;
 190                                 }
 191                                 else
 192                                 {
 193                                         // Only one service by physical machine is allowed
 194
 195                                         // Implementation for layer5
 196                                         //TSockId hostid1, hostid2;
 197                                         /*CCallbackNetBase *cnb1 = CUnifiedNetwork::getInstance()->getNetBase( serviceId, hostid1 );
 198                                         CCallbackNetBase *cnb2 = CUnifiedNetwork::getInstance()->getNetBase( *ios, hostid2 );
 199                                         if ( cnb1->hostAddress( hostid1 ).internalIPAddress() == cnb2->hostAddress( hostid2 ).internalIPAddress() )*/
 200
 201                                         // Implementation for NS
 202                                         if ( addr[0].internalIPAddress() == getHostAddress( *ios ).internalIPAddress() )
 203                                         {
 204                                                 grantStarting = false;
 205                                                 reason = toString( "Service %s already found as %hu on same machine", serviceName.c_str(), ios->get() );
 206                                                 nlinfo( reason.c_str() );
 207                                                 break;
 208                                         }
 209                                 }
 210                         }
 211                 }
 212         }
 213
 214         if ( grantStarting )
 215         {
 216                 _OnlineServices.insert( serviceId );
 217         }
 218         return grantStarting;
 219 }
 220
 221
 222 /*
 223  * Release a service instance
 224  */
 225 void            CServiceInstanceManager::releaseService( NLNET::TServiceId serviceId )
 226 {
 227         _OnlineServices.erase( serviceId ); // not a problem if not found
 228 }
 229
 230
 231 /*
 232  * Display information
 233  */
 234 void            CServiceInstanceManager::displayInfo( NLMISC::CLog *log ) const
 235 {
 236         log->displayNL( "Restricted services:" );
 237         std::map< std::string, bool >::const_iterator ius;
 238         for ( ius=_UniqueServices.begin(); ius!=_UniqueServices.end(); ++ius )
 239         {
 240                 log->displayNL( "%s -> only one per %s", (*ius).first.c_str(), (*ius).second?"shard":"machine" );
 241         }
 242         log->displayNL( "Online registered services:" );
 243         std::set< TServiceId >::const_iterator ios;
 244         for ( ios=_OnlineServices.begin(); ios!=_OnlineServices.end(); ++ios )
 245         {
 246                 log->displayNL( "%s", CUnifiedNetwork::getInstance()->getServiceUnifiedName( *ios ).c_str() );
 247         }
 248 }
 249
 250
 251 /*
 252  * Make all controlled services quit
 253  */
 254 void            CServiceInstanceManager::killAllServices()
 255 {
 256         // Send to all known online services
 257         std::set< TServiceId >::const_iterator ios;
 258         for ( ios=_OnlineServices.begin(); ios!=_OnlineServices.end(); ++ios )
 259         {
 260                 doUnregisterService( (TServiceId)(*ios) );
 261         }
 262 }
 263
 264
 265
 266 //
 267 // Variables
 268 //
 269
 270 list<CServiceEntry>     RegisteredServices;             /// List of all registred services
 271
 272 uint16                          MinBasePort = 51000;    /// Ports begin at 51000
 273 uint16                          MaxBasePort = 52000;    /// (note: in this implementation there can be no more than 1000 services)
 274
 275 const TServiceId        BaseSId(128);                   /// Allocated SIds begin at 128 (except for Agent Service)
 276
 277 const TTime                     UnregisterTimeout = 10000;      /// After 10s we remove an unregister service if every server didn't ACK the message
 278
 279 CCallbackServer         *CallbackServer = NULL;
 280
 281 //
 282 // Functions
 283 //
 284
 285 bool canAccess (const vector<CInetAddress> &addr, const CServiceEntry &entry, vector<CInetAddress> &accessibleAddr)
 286 {
 287         accessibleAddr.clear ();
 288
 289         if (entry.WaitingUnregistration)
 290                 return false;
 291
 292         for (uint i = 0; i < addr.size(); i++)
 293         {
 294                 uint32 net = addr[i].internalNetAddress();
 295                 for (uint j = 0; j < entry.Addr.size(); j++)
 296                 {
 297                         if (net == entry.Addr[j].internalNetAddress())
 298                         {
 299                                 accessibleAddr.push_back (entry.Addr[j]);
 300                         }
 301                 }
 302         }
 303
 304         if (accessibleAddr.empty())
 305         {
 306                 nldebug ("service %s-%hu is not accessible by '%s'", entry.Name.c_str(), entry.SId.get(), vectorCInetAddressToString (addr).c_str ());
 307         }
 308         else
 309         {
 310                 nldebug ("service %s-%hu is accessible by '%s'", entry.Name.c_str(), entry.SId.get(), vectorCInetAddressToString (accessibleAddr).c_str ());
 311         }
 312
 313         return !accessibleAddr.empty ();
 314 }
 315
 316 void displayRegisteredServices (CLog *log = InfoLog)
 317 {
 318         log->displayNL ("Display the %d registered services :", RegisteredServices.size());
 319         for (list<CServiceEntry>::iterator it = RegisteredServices.begin(); it != RegisteredServices.end (); it++)
 320         {
 321                 TSockId id = (*it).SockId;
 322                 if (id == NULL)
 323                 {
 324                         log->displayNL ("> %s-%hu %s '%s' %s %d addr", (*it).Name.c_str(), it->SId.get(), "<NULL>", "<NULL>", (*it).WaitingUnregistration?"WaitUnreg":"", (*it).Addr.size());
 325                         for(uint i = 0; i < (*it).Addr.size(); i++)
 326                                 log->displayNL ("              '%s'", (*it).Addr[i].asString().c_str());
 327                 }
 328                 else
 329                 {
 330                         log->displayNL ("> %s-%hu %s '%s' %s %d addr", (*it).Name.c_str(), it->SId.get(), (*it).SockId->asString().c_str(), CallbackServer->hostAddress((*it).SockId).asString().c_str(), (*it).WaitingUnregistration?"WaitUnreg":"", (*it).Addr.size());
 331                         for(uint i = 0; i < (*it).Addr.size(); i++)
 332                                 log->displayNL ("              '%s'", (*it).Addr[i].asString().c_str());
 333                 }
 334         }
 335         log->displayNL ("End of the list");
 336 }
 337
 338
 339 list<CServiceEntry>::iterator effectivelyRemove (list<CServiceEntry>::iterator &it)
 340 {
 341         // remove the service from the registered service list
 342         nlinfo ("Effectively remove the service %s-%hu", (*it).Name.c_str(), it->SId.get());
 343         return RegisteredServices.erase (it);
 344 }
 345
 346 /*
 347  * Helper procedure for cbLookupAlternate and cbUnregister.
 348  * Note: name is used for a LOGS.
 349  */
 350 list<CServiceEntry>::iterator doRemove (list<CServiceEntry>::iterator it)
 351 {
 352         nldebug ("Unregister the service %s-%hu '%s'", (*it).Name.c_str(), it->SId.get(), (*it).Addr[0].asString().c_str());
 353
 354         // tell to everybody that this service is unregistered
 355
 356         CMessage msgout ("UNB");
 357         msgout.serial ((*it).Name);
 358         msgout.serial ((*it).SId);
 359
 360         vector<CInetAddress> accessibleAddress;
 361         nlinfo ("Broadcast the Unregistration of %s-%hu to all registered services", (*it).Name.c_str(), it->SId.get());
 362         for (list<CServiceEntry>::iterator it3 = RegisteredServices.begin(); it3 != RegisteredServices.end (); it3++)
 363         {
 364                 if (canAccess((*it).Addr, (*it3), accessibleAddress))
 365                 {
 366                         CallbackServer->send (msgout, (*it3).SockId);
 367                         //CNetManager::send ("NS", msgout, (*it3).SockId);
 368                         nldebug ("Broadcast to %s-%hu", (*it3).Name.c_str(), it3->SId.get());
 369                 }
 370         }
 371
 372         // new system, after the unregistation broadcast, we wait ACK from all services before really remove
 373         // the service, before, we tag the service as 'wait before unregister'
 374         // if everybody didn't answer before the time out, we remove it
 375
 376         (*it).SockId = NULL;
 377
 378         (*it).WaitingUnregistration = true;
 379         (*it).WaitingUnregistrationTime = CTime::getLocalTime();
 380
 381         // we remove all services awaiting his ACK because this service is down so it'll never ACK
 382         for (list<CServiceEntry>::iterator itr = RegisteredServices.begin(); itr != RegisteredServices.end (); itr++)
 383         {
 384                 for (list<TServiceId>::iterator itw = (*itr).WaitingUnregistrationServices.begin(); itw != (*itr).WaitingUnregistrationServices.end ();)
 385                 {
 386                         if ((*itw) == (*it).SId)
 387                         {
 388                                 itw = (*itr).WaitingUnregistrationServices.erase (itw);
 389                         }
 390                         else
 391                         {
 392                                 itw++;
 393                         }
 394                 }
 395         }
 396
 397         string res;
 398         for (list<CServiceEntry>::iterator it2 = RegisteredServices.begin(); it2 != RegisteredServices.end (); it2++)
 399         {
 400                 if (!(*it2).WaitingUnregistration)
 401                 {
 402                         (*it).WaitingUnregistrationServices.push_back ((*it2).SId);
 403                         res += toString((*it2).SId.get()) + " ";
 404                 }
 405         }
 406
 407         nlinfo ("Before removing the service %s-%hu, we wait the ACK of '%s'", (*it).Name.c_str(), (*it).SId.get(), res.c_str());
 408
 409         if ((*it).WaitingUnregistrationServices.empty())
 410         {
 411                 return effectivelyRemove (it);
 412         }
 413         else
 414         {
 415                 return ++it;
 416         }
 417
 418         // Release from the service instance manager
 419         SIMInstance->releaseService( (*it).SId );
 420 }
 421
 422 void doUnregisterService (TServiceId sid)
 423 {
 424         list<CServiceEntry>::iterator it;
 425         for (it = RegisteredServices.begin(); it != RegisteredServices.end (); it++)
 426         {
 427                 if ((*it).SId == sid)
 428                 {
 429                         // found it, remove it
 430                         doRemove (it);
 431                         return;
 432                 }
 433         }
 434         nlwarning ("Service %hu not found", sid.get());
 435 }
 436
 437 void doUnregisterService (TSockId from)
 438 {
 439         list<CServiceEntry>::iterator it;
 440         for (it = RegisteredServices.begin(); it != RegisteredServices.end ();)
 441         {
 442                 if ((*it).SockId == from)
 443                 {
 444                         // it's possible that one "from" have more than one registred service, so we have to find in all the list
 445                         // found it, remove it
 446                         it = doRemove (it);
 447                 }
 448                 else
 449                 {
 450                         it++;
 451                 }
 452         }
 453 }
 454
 455 /*void doUnregisterService (const CInetAddress &addr)
 456 {
 457         list<CServiceEntry>::iterator it;
 458         for (it = RegisteredServices.begin(); it != RegisteredServices.end (); it++)
 459         {
 460                 if ((*it).Addr == addr)
 461                 {
 462                         // found it, remove it
 463                         doRemove (it);
 464                         return;
 465                 }
 466         }
 467         nlwarning ("Service %s not found", addr.asString().c_str());
 468 }*/
 469
 470 /*
 471  * Helper function for cbRegister.
 472  * If alloc_sid is true, sid is ignored
 473  * Returns false in case of failure of sid allocation or bad sid provided
 474  * Note: the reply is included in this function, because it must be done before things such as syncUniTime()
 475  */
 476 bool doRegister (const string &name, const vector<CInetAddress> &addr, TServiceId sid, TSockId from, CCallbackNetBase &netbase, bool reconnection = false)
 477 {
 478         // Find if the service is not already registered
 479         string reason;
 480         uint8 ok = true;
 481         bool needRegister = true;
 482         /*for (list<CServiceEntry>::iterator it = RegisteredServices.begin(); it != RegisteredServices.end (); it++)
 483         {
 484                 if ((*it).Addr.asIPString() == addr.asIPString() )
 485                 {
 486                         // we already have a service on this address, remplace it if it's the same name
 487                         if ((*it).Name == name)
 488                         {
 489                                 // it's the same service, replace it
 490                                 (*it).SockId = from;
 491                                 sid = (*it).SId;
 492                                 nlinfo ("Replace the service %s", name.c_str());
 493                         }
 494                         else
 495                         {
 496                                 nlwarning ("Try to register %s to %s but the service %s already on this address. ignore it!", name.c_str(), addr.asIPString().c_str(), (*it).Name.c_str());
 497                                 ok = false;
 498                         }
 499                         needRegister = false;
 500                         break;
 501                 }
 502         }*/
 503
 504         if (needRegister)
 505         {
 506                 if (sid.get() == 0)
 507                 {
 508                         // we have to find a sid
 509                         sid = BaseSId;
 510                         bool found = false;
 511                         while (!found)
 512                         {
 513                                 list<CServiceEntry>::iterator it;
 514                                 for (it = RegisteredServices.begin(); it != RegisteredServices.end (); it++)
 515                                 {
 516                                         if ((*it).SId == sid)
 517                                         {
 518                                                 break;
 519                                         }
 520                                 }
 521                                 if (it == RegisteredServices.end ())
 522                                 {
 523                                         // ok, we have an empty sid
 524                                         found = true;
 525                                 }
 526                                 else
 527                                 {
 528                                         sid.set(sid.get()+1);
 529                                         if (sid.get() == 0) // round the clock
 530                                         {
 531                                                 nlwarning ("Service identifier allocation overflow");
 532                                                 ok = false;
 533                                                 break;
 534                                         }
 535                                 }
 536                         }
 537
 538                 }
 539                 else
 540                 {
 541                         // we have to check that the user provided sid is available
 542                         list<CServiceEntry>::iterator it;
 543                         for (it = RegisteredServices.begin(); it != RegisteredServices.end (); it++)
 544                         {
 545                                 if ((*it).SId == sid)
 546                                 {
 547                                         nlwarning ("Sid %d already used by another service", sid.get());
 548                                         ok = false;
 549                                         break;
 550                                 }
 551                         }
 552                         if (it != RegisteredServices.end ())
 553                         {
 554                                 ok = true;
 555                         }
 556                 }
 557
 558                 // if ok, register the service and send a broadcast to other people
 559                 if (ok)
 560                 {
 561                         // Check if the instance is allowed to start, according to the restriction in the config file
 562                         if ( SIMInstance->queryStartService( name, sid, addr, reason ) )
 563                         {
 564                                 // add him in the registered list
 565                                 RegisteredServices.push_back (CServiceEntry(from, addr, name, sid));
 566
 567                                 // tell to everybody but not him that this service is registered
 568                                 if (!reconnection)
 569                                 {
 570                                         CMessage msgout ("RGB");
 571                                         TServiceId::size_type s = 1;
 572                                         msgout.serial (s);
 573                                         msgout.serial (const_cast<string &>(name));
 574                                         msgout.serial (sid);
 575                                         // we need to send all addr to all services even if the service can't access because we use the address index
 576                                         // to know which connection comes.
 577                                         msgout.serialCont (const_cast<vector<CInetAddress> &>(addr));
 578                                         nlinfo ("The service is %s-%d, broadcast the Registration to everybody", name.c_str(), sid.get());
 579
 580                                         vector<CInetAddress> accessibleAddress;
 581                                         for (list<CServiceEntry>::iterator it3 = RegisteredServices.begin(); it3 != RegisteredServices.end (); it3++)
 582                                         {
 583                                                 // send only services that can be accessed and not itself
 584                                                 if ((*it3).SId != sid && canAccess(addr, (*it3), accessibleAddress))
 585                                                 {
 586                                                         CallbackServer->send (msgout, (*it3).SockId);
 587                                                         //CNetManager::send ("NS", msgout, (*it3).SockId);
 588                                                         nldebug ("Broadcast to %s-%hu", (*it3).Name.c_str(), it3->SId.get());
 589                                                 }
 590                                         }
 591                                 }
 592
 593                                 // set the sid only if it s ok
 594                                 from->setAppId (sid.get());
 595                         }
 596                         else
 597                         {
 598                                 // Reply "startup denied", and do not send registration to other services
 599                                 ok = false;
 600                         }
 601                 }
 602
 603                 // send the message to the service to say if it s ok or not
 604                 if (!reconnection)
 605                 {
 606                         // send the answer to the client
 607                         CMessage msgout ("RG");
 608                         msgout.serial (ok);
 609                         if (ok)
 610                         {
 611                                 msgout.serial (sid);
 612
 613                                 // send him all services available (also itself)
 614                                 TServiceId::size_type nb = 0;
 615
 616                                 vector<CInetAddress> accessibleAddress;
 617
 618                                 for (list<CServiceEntry>::iterator it2 = RegisteredServices.begin(); it2 != RegisteredServices.end (); it2++)
 619                                 {
 620                                         // send only services that are available
 621                                         if (canAccess(addr, (*it2), accessibleAddress))
 622                                                 nb++;
 623                                 }
 624                                 msgout.serial (nb);
 625
 626                                 for (list<CServiceEntry>::iterator it = RegisteredServices.begin(); it != RegisteredServices.end (); it++)
 627                                 {
 628                                         // send only services that are available
 629                                         if (canAccess(addr, (*it), accessibleAddress))
 630                                         {
 631                                                 msgout.serial ((*it).Name);
 632                                                 msgout.serial ((*it).SId);
 633                                                 msgout.serialCont ((*it).Addr);
 634                                         }
 635                                 }
 636                         }
 637                         else
 638                         {
 639                                 msgout.serial( reason );
 640                         }
 641
 642                         netbase.send (msgout, from);
 643                         netbase.flush (from);
 644                 }
 645         }
 646
 647         //displayRegisteredServices ();
 648
 649         return ok!=0;
 650 }
 651
 652 void checkWaitingUnregistrationServices ()
 653 {
 654         for (list<CServiceEntry>::iterator it = RegisteredServices.begin(); it != RegisteredServices.end ();)
 655         {
 656                 if ((*it).WaitingUnregistration && ((*it).WaitingUnregistrationServices.empty() || CTime::getLocalTime() > (*it).WaitingUnregistrationTime + UnregisterTimeout))
 657                 {
 658                         if ((*it).WaitingUnregistrationServices.empty())
 659                         {
 660                                 nlinfo ("Removing the service %s-%hu because all services ACKd the removal", (*it).Name.c_str(), (*it).SId.get());
 661                         }
 662                         else
 663                         {
 664                                 string res;
 665                                 for (list<TServiceId>::iterator it2 = (*it).WaitingUnregistrationServices.begin(); it2 != (*it).WaitingUnregistrationServices.end (); it2++)
 666                                 {
 667                                         res += toString(it2->get()) + " ";
 668                                 }
 669                                 nlwarning ("Removing the service %s-%hu because time out occurs (service numbers %s didn't ACK)", (*it).Name.c_str(), (*it).SId.get(), res.c_str());
 670                         }
 671                         it = effectivelyRemove (it);
 672                 }
 673                 else
 674                 {
 675                         it++;
 676                 }
 677         }
 678 }
 679
 680
 681 /**
 682  * Callback for service unregistration ACK. Mean that a service was ACK the unregistration broadcast
 683  */
 684 static void cbACKUnregistration (CMessage& msgin, TSockId from, CCallbackNetBase &netbase)
 685 {
 686         TServiceId sid;
 687         msgin.serial (sid);
 688
 689         for (list<CServiceEntry>::iterator it = RegisteredServices.begin(); it != RegisteredServices.end (); it++)
 690         {
 691                 if ((*it).SId == sid && (*it).WaitingUnregistration)
 692                 {
 693                         for (list<TServiceId>::iterator it2 = (*it).WaitingUnregistrationServices.begin(); it2 != (*it).WaitingUnregistrationServices.end (); it2++)
 694                         {
 695                                 if (*it2 == TServiceId(uint16(from->appId())))
 696                                 {
 697                                         // remove the acked service
 698                                         (*it).WaitingUnregistrationServices.erase (it2);
 699                                         checkWaitingUnregistrationServices ();
 700                                         return;
 701                                 }
 702                         }
 703                 }
 704         }
 705 }
 706
 707
 708 /**
 709  * Callback for service registration when the naming service goes down and up (don't need to broadcast)
 710  */
 711 static void cbResendRegisteration (CMessage& msgin, TSockId from, CCallbackNetBase &netbase)
 712 {
 713         string name;
 714         vector<CInetAddress> addr;
 715         TServiceId sid;
 716         msgin.serial (name);
 717         msgin.serialCont (addr);
 718         msgin.serial (sid);
 719
 720         doRegister (name, addr, sid, from, netbase, true);
 721 }
 722
 723
 724
 725 /**
 726  * Callback for service registration.
 727  *
 728  * Message expected : RG
 729  * - Name of service to register (string)
 730  * - Address of service (CInetAddress)
 731  *
 732  * Message emitted : RG
 733  * - Allocated service identifier (TServiceId) or 0 if failed
 734  */
 735 static void cbRegister (CMessage& msgin, TSockId from, CCallbackNetBase &netbase)
 736 {
 737         string name;
 738         vector<CInetAddress> addr;
 739         TServiceId sid;
 740         msgin.serial (name);
 741         msgin.serialCont (addr);
 742         msgin.serial (sid);
 743
 744         doRegister (name, addr, sid, from, netbase);
 745 }
 746
 747
 748 /**
 749  * Callback for service unregistration.
 750  *
 751  * Message expected : UNI
 752  * - Service identifier (TServiceId)
 753  */
 754 static void cbUnregisterSId (CMessage& msgin, TSockId from, CCallbackNetBase &netbase)
 755 {
 756         TServiceId sid;
 757         msgin.serial( sid );
 758
 759         doUnregisterService (sid);
 760         //displayRegisteredServices ();
 761 }
 762
 763
 764 /*
 765  * Helper function for cbQueryPort
 766  *
 767  * \warning QueryPort + Registration is not atomic so more than one service could ask a port before register
 768  */
 769 uint16 doAllocatePort (const CInetAddress &addr)
 770 {
 771         static uint16 nextAvailablePort = MinBasePort;
 772
 773         // check if nextavailableport is free
 774
 775         if (nextAvailablePort >= MaxBasePort) nextAvailablePort = MinBasePort;
 776
 777         bool ok;
 778         do
 779         {
 780                 ok = true;
 781                 list<CServiceEntry>::iterator it;
 782                 for (it = RegisteredServices.begin(); it != RegisteredServices.end (); it++)
 783                 {
 784                         if ((*it).Addr[0].port () == nextAvailablePort)
 785                         {
 786                                 nextAvailablePort++;
 787                                 ok = false;
 788                                 break;
 789                         }
 790                 }
 791         }
 792         while (!ok);
 793
 794         return nextAvailablePort++;
 795 }
 796
 797
 798 /**
 799  * Callback for port allocation
 800  * Note: if a service queries a port but does not register itself to the naming service, the
 801  * port will remain allocated and unused.
 802  *
 803  * Message expected : QP
 804  * - Name of service to register (string)
 805  * - Address of service (CInetAddress) (its port can be 0)
 806  *
 807  * Message emitted : QP
 808  * - Allocated port number (uint16)
 809  */
 810 static void cbQueryPort (CMessage& msgin, TSockId from, CCallbackNetBase &netbase)
 811 {
 812         // Allocate port
 813         uint16 port = doAllocatePort (netbase.hostAddress (from));
 814
 815         // Send port back
 816         CMessage msgout ("QP");
 817         msgout.serial (port);
 818         netbase.send (msgout, from);
 819
 820         nlinfo ("The service got port %hu", port);
 821 }
 822
 823
 824 /*
 825  * Unregisters a service if it has not been done before.
 826  * Note: this callback is called whenever someone disconnects from the NS.
 827  * May be there are too many calls if many clients perform many transactional lookups.
 828  */
 829 static void cbDisconnect /*(const string &serviceName, TSockId from, void *arg)*/ ( TSockId from, void *arg )
 830 {
 831         doUnregisterService (from);
 832         //displayRegisteredServices ();
 833 }
 834
 835 /*
 836  * a service is connected, send him all services infos
 837  */
 838 static void cbConnect /*(const string &serviceName, TSockId from, void *arg)*/ ( TSockId from, void *arg )
 839 {
 840         // we have to wait the registred services message to send all services because it this points, we can't know which sub net
 841         // the service can use
 842
 843         //displayRegisteredServices ();
 844
 845         // set the appid with a bad id (-1)
 846         from->setAppId (~0);
 847 }
 848
 849 /*// returns the list of accessible services with a list of address
 850 static void cbRegisteredServices(CMessage& msgin, TSockId from, CCallbackNetBase &netbase)
 851 {
 852         vector<CInetAddress> addr;
 853         msgin.serialCont (addr);
 854
 855         nlinfo ("New service ask me the available services, sending him all services available");
 856         // send to the new service the list of all services that this service can access (depending of his sub net)
 857
 858         CMessage msgout ("RGB");
 859
 860         uint8 nb = 0;
 861
 862         vector<CInetAddress> accessibleAddress;
 863
 864         for (list<CServiceEntry>::iterator it2 = RegisteredServices.begin(); it2 != RegisteredServices.end (); it2++)
 865         {
 866                 // send only services that are available
 867                 if (canAccess(addr, (*it2), accessibleAddress))
 868                         nb++;
 869         }
 870
 871         msgout.serial (nb);
 872
 873         for (list<CServiceEntry>::iterator it = RegisteredServices.begin(); it != RegisteredServices.end (); it++)
 874         {
 875                 // send only services that are available
 876                 if (canAccess(addr, (*it), accessibleAddress))
 877                 {
 878                         msgout.serial ((*it).Name);
 879                         msgout.serial ((*it).SId);
 880                         msgout.serialCont (accessibleAddress);
 881                 }
 882         }
 883
 884         CNetManager::send ("NS", msgout, from);
 885 }*/
 886
 887
 888 /*
 889  * Helper that emulates layer5 send()
 890  */
 891 /*void sendToService( uint16 sid, CMessage& msgout )
 892 {
 893         list<CServiceEntry>::iterator it;
 894         for (it = RegisteredServices.begin(); it != RegisteredServices.end (); it++)
 895         {
 896                 if ((*it).SId == sid)
 897                 {
 898                         CallbackServer->send (msgout, (*it).SockId);
 899                 }
 900         }
 901 }*/
 902
 903
 904 /*
 905  * Helper that emulate layer5's getServiceName()
 906  */
 907 string getServiceName( TServiceId  sid )
 908 {
 909         list<CServiceEntry>::iterator it;
 910         for (it = RegisteredServices.begin(); it != RegisteredServices.end (); it++)
 911         {
 912                 if ((*it).SId == sid)
 913                 {
 914                         return (*it).Name;
 915                 }
 916         }
 917         return ""; // not found
 918 }
 919
 920
 921 /*
 922  * Helper that returns the first address of a service
 923  */
 924 CInetAddress getHostAddress( TServiceId  sid )
 925 {
 926         list<CServiceEntry>::iterator it;
 927         for (it = RegisteredServices.begin(); it != RegisteredServices.end (); it++)
 928         {
 929                 if ((*it).SId == sid)
 930                 {
 931                         return (*it).Addr[0];
 932                 }
 933         }
 934         return CInetAddress();
 935 }
 936
 937
 938 //
 939 // Callback array
 940 //
 941
 942 TCallbackItem CallbackArray[] =
 943 {
 944         { "RG", cbRegister },
 945         { "RRG", cbResendRegisteration },
 946         { "QP", cbQueryPort },
 947         { "UNI", cbUnregisterSId },
 948         { "ACK_UNI", cbACKUnregistration },
 949 //      { "RS", cbRegisteredServices },
 950 };
 951
 952
 953 //
 954 // Service
 955 //
 956
 957 class CNamingService : public NLNET::IService
 958 {
 959 public:
 960
 961         /**
 962          * Init
 963          */
 964         void init()
 965         {
 966                 // if a baseport is available in the config file, get it
 967                 CConfigFile::CVar *var;
 968                 if ((var = ConfigFile.getVarPtr ("BasePort")) != NULL)
 969                 {
 970                         uint16 newBasePort = var->asInt ();
 971                         nlinfo ("Changing the MinBasePort number from %hu to %hu", MinBasePort, newBasePort);
 972                         sint32 delta = MaxBasePort - MinBasePort;
 973                         nlassert (delta > 0);
 974                         MinBasePort = newBasePort;
 975                         MaxBasePort = MinBasePort + uint16 (delta);
 976                 }
 977
 978                 // Parameters for the service instance manager
 979                 try
 980                 {
 981                         CConfigFile::CVar& uniqueServices = ConfigFile.getVar("UniqueOnShardServices");
 982                         for ( uint i=0; i!=uniqueServices.size(); ++i )
 983                         {
 984                                 _ServiceInstances.addUniqueService( uniqueServices.asString(i), true );
 985                         }
 986                 }
 987                 catch(Exception &)
 988                 {}
 989                 try
 990                 {
 991                         CConfigFile::CVar& uniqueServicesM = ConfigFile.getVar("UniqueByMachineServices");
 992                         for ( uint i=0; i!=uniqueServicesM.size(); ++i )
 993                         {
 994                                 _ServiceInstances.addUniqueService( uniqueServicesM.asString(i), false );
 995                         }
 996                 }
 997                 catch(Exception &)
 998                 {}
 999
1000 /*
1001                 // we don't try to associate message from client
1002                 CNetManager::getNetBase ("NS")->ignoreAllUnknownId (true);
1003
1004                 // add the callback in case of disconnection
1005                 CNetManager::setConnectionCallback ("NS", cbConnect, NULL);
1006
1007                 // add the callback in case of disconnection
1008                 CNetManager::setDisconnectionCallback ("NS", cbDisconnect, NULL);
1009 */
1010                 // DEBUG
1011                 // DebugLog->addDisplayer( new CStdDisplayer() );
1012
1013                 vector<CInetAddress> v = CInetAddress::localAddresses();
1014                 nlinfo ("%d detected local addresses:", v.size());
1015                 for (uint i = 0; i < v.size(); i++)
1016                 {
1017                         nlinfo (" %d - '%s'",i, v[i].asString().c_str());
1018                 }
1019
1020                 uint16 nsport = 50000;
1021                 if ((var = ConfigFile.getVarPtr ("NSPort")) != NULL)
1022                 {
1023                         nsport = var->asInt ();
1024                 }
1025
1026                 CallbackServer = new CCallbackServer;
1027                 CallbackServer->init(nsport);
1028                 CallbackServer->addCallbackArray(CallbackArray, sizeof(CallbackArray)/sizeof(CallbackArray[0]));
1029                 CallbackServer->setConnectionCallback(cbConnect, NULL);
1030                 CallbackServer->setDisconnectionCallback(cbDisconnect, NULL);
1031         }
1032
1033         /**
1034          * Update
1035          */
1036         bool update ()
1037         {
1038                 checkWaitingUnregistrationServices ();
1039
1040                 CallbackServer->update ();
1041
1042                 return true;
1043         }
1044
1045         void release()
1046         {
1047                 if (CallbackServer != NULL)
1048                         delete CallbackServer;
1049                 CallbackServer = NULL;
1050         }
1051
1052 private:
1053
1054         /// Service instance manager singleton
1055         CServiceInstanceManager         _ServiceInstances;
1056 };
1057
1058
1059 static const char* getCompleteServiceName(const IService* theService)
1060 {
1061         static std::string s;
1062         s= "naming_service";
1063
1064         if (theService->haveLongArg("nsname"))
1065         {
1066                 s+= "_"+theService->getLongArg("nsname");
1067         }
1068
1069         if (theService->haveLongArg("fullnsname"))
1070         {
1071                 s= theService->getLongArg("fullnsname");
1072         }
1073
1074         return s.c_str();
1075 }
1076
1077 static const char* getShortServiceName(const IService* theService)
1078 {
1079         static std::string s;
1080         s= "NS";
1081
1082         if (theService->haveLongArg("shortnsname"))
1083         {
1084                 s= theService->getLongArg("shortnsname");
1085         }
1086
1087         return s.c_str();
1088 }
1089 //
1090 /// Naming Service
1091 //
1092 NLNET_SERVICE_MAIN( CNamingService, getShortServiceName(scn), getCompleteServiceName(scn), 0, EmptyCallbackArray, NELNS_CONFIG, NELNS_LOGS)
1093
1094
1095 //
1096 // Commands
1097 //
1098
1099
1100 NLMISC_COMMAND (nsServices, "displays the list of all registered services", "")
1101 {
1102         if(args.size() != 0) return false;
1103
1104         displayRegisteredServices (&log);
1105
1106         return true;
1107 }
1108
1109 NLMISC_COMMAND (kill, "kill a service and send an unregister broadcast to other service", "<ServiceShortName>|<ServiceId>")
1110 {
1111         if(args.size() != 1) return false;
1112
1113         // try with number
1114
1115         TServiceId sid(atoi(args[0].c_str()));
1116
1117         if(sid.get() == 0)
1118         {
1119                 // not a number, try a name
1120                 list<CServiceEntry>::iterator it;
1121                 for (it = RegisteredServices.begin(); it != RegisteredServices.end (); it++)
1122                 {
1123                         if ((*it).Name == args[0])
1124                         {
1125                                 sid = (*it).SId;
1126                                 break;
1127                         }
1128                 }
1129                 if (it == RegisteredServices.end())
1130                 {
1131                         log.displayNL ("Bad service name or id '%s'", args[0].c_str());
1132                         return false;
1133                 }
1134         }
1135
1136         doUnregisterService (sid);
1137         return true;
1138 }
1139
1140 NLMISC_DYNVARIABLE(uint32, NbRegisteredServices, "display the number of service that are registered in naming service")
1141 {
1142         if (get) *pointer = (uint32)RegisteredServices.size();
1143 }
1144
1145 NLMISC_COMMAND( displayServiceInstances, "SIM: Display info on service instances", "" )
1146 {
1147         SIMInstance->displayInfo( &log );
1148         return true;
1149 }
1150
1151 NLMISC_COMMAND( killAllServices, "SIM: Make all the controlled services quit", "" )
1152 {
1153         SIMInstance->killAllServices();
1154         return true;
1155 }