cpp/src/Ice/Instance.cpp

   1 // **********************************************************************
   2 //
   3 // Copyright (c) 2003-2011 ZeroC, Inc. All rights reserved.
   4 //
   5 // This copy of Ice is licensed to you under the terms described in the
   6 // ICE_LICENSE file included in this distribution.
   7 //
   8 // **********************************************************************
   9
  10 #include <IceUtil/DisableWarnings.h>
  11 #include <Ice/Instance.h>
  12 #include <Ice/TraceLevels.h>
  13 #include <Ice/DefaultsAndOverrides.h>
  14 #include <Ice/RouterInfo.h>
  15 #include <Ice/Router.h>
  16 #include <Ice/LocatorInfo.h>
  17 #include <Ice/Locator.h>
  18 #include <Ice/ReferenceFactory.h>
  19 #include <Ice/ProxyFactory.h>
  20 #include <Ice/ThreadPool.h>
  21 #include <Ice/ConnectionFactory.h>
  22 #include <Ice/ConnectionMonitor.h>
  23 #include <Ice/ObjectFactoryManager.h>
  24 #include <Ice/LocalException.h>
  25 #include <Ice/ObjectAdapterFactory.h>
  26 #include <Ice/Exception.h>
  27 #include <Ice/PropertiesI.h>
  28 #include <Ice/LoggerI.h>
  29 #include <Ice/Network.h>
  30 #include <Ice/EndpointFactoryManager.h>
  31 #include <Ice/RetryQueue.h>
  32 #include <Ice/TcpEndpointI.h>
  33 #include <Ice/UdpEndpointI.h>
  34 #include <Ice/DynamicLibrary.h>
  35 #include <Ice/PluginManagerI.h>
  36 #include <Ice/Initialize.h>
  37 #include <Ice/LoggerUtil.h>
  38 #include <IceUtil/StringUtil.h>
  39 #include <Ice/PropertiesI.h>
  40 #include <IceUtil/UUID.h>
  41 #include <Ice/Communicator.h>
  42 #include <IceUtil/Mutex.h>
  43 #include <IceUtil/MutexPtrLock.h>
  44
  45 #include <stdio.h>
  46
  47 #ifndef _WIN32
  48 #   include <Ice/SysLoggerI.h>
  49
  50 #   include <signal.h>
  51 #   include <syslog.h>
  52 #   include <pwd.h>
  53 #   include <sys/types.h>
  54 #endif
  55
  56 using namespace std;
  57 using namespace Ice;
  58 using namespace IceInternal;
  59
  60 namespace IceUtilInternal
  61 {
  62
  63 extern bool ICE_DECLSPEC_IMPORT nullHandleAbort;
  64 extern bool ICE_DECLSPEC_IMPORT printStackTraces;
  65
  66 };
  67
  68 namespace
  69 {
  70
  71 IceUtil::Mutex* staticMutex = 0;
  72 bool oneOffDone = false;
  73 int instanceCount = 0;
  74 #ifndef _WIN32
  75 struct sigaction oldAction;
  76 #endif
  77 bool printProcessIdDone = false;
  78 string identForOpenlog;
  79
  80 class Init
  81 {
  82 public:
  83
  84     Init()
  85     {
  86         staticMutex = new IceUtil::Mutex;
  87     }
  88
  89     ~Init()
  90     {
  91         delete staticMutex;
  92         staticMutex = 0;
  93     }
  94 };
  95
  96 Init init;
  97
  98 }
  99
 100 IceUtil::Shared* IceInternal::upCast(Instance* p) { return p; }
 101
 102 bool
 103 IceInternal::Instance::destroyed() const
 104 {
 105     IceUtil::RecMutex::Lock sync(*this);
 106     return _state == StateDestroyed;
 107 }
 108
 109 TraceLevelsPtr
 110 IceInternal::Instance::traceLevels() const
 111 {
 112     // No mutex lock, immutable.
 113     assert(_traceLevels);
 114     return _traceLevels;
 115 }
 116
 117 DefaultsAndOverridesPtr
 118 IceInternal::Instance::defaultsAndOverrides() const
 119 {
 120     // No mutex lock, immutable.
 121     assert(_defaultsAndOverrides);
 122     return _defaultsAndOverrides;
 123 }
 124
 125 RouterManagerPtr
 126 IceInternal::Instance::routerManager() const
 127 {
 128     IceUtil::RecMutex::Lock sync(*this);
 129
 130     if(_state == StateDestroyed)
 131     {
 132         throw CommunicatorDestroyedException(__FILE__, __LINE__);
 133     }
 134
 135     assert(_routerManager);
 136     return _routerManager;
 137 }
 138
 139 LocatorManagerPtr
 140 IceInternal::Instance::locatorManager() const
 141 {
 142     IceUtil::RecMutex::Lock sync(*this);
 143
 144     if(_state == StateDestroyed)
 145     {
 146         throw CommunicatorDestroyedException(__FILE__, __LINE__);
 147     }
 148
 149     assert(_locatorManager);
 150     return _locatorManager;
 151 }
 152
 153 ReferenceFactoryPtr
 154 IceInternal::Instance::referenceFactory() const
 155 {
 156     IceUtil::RecMutex::Lock sync(*this);
 157
 158     if(_state == StateDestroyed)
 159     {
 160         throw CommunicatorDestroyedException(__FILE__, __LINE__);
 161     }
 162
 163     assert(_referenceFactory);
 164     return _referenceFactory;
 165 }
 166
 167 ProxyFactoryPtr
 168 IceInternal::Instance::proxyFactory() const
 169 {
 170     IceUtil::RecMutex::Lock sync(*this);
 171
 172     if(_state == StateDestroyed)
 173     {
 174         throw CommunicatorDestroyedException(__FILE__, __LINE__);
 175     }
 176
 177     assert(_proxyFactory);
 178     return _proxyFactory;
 179 }
 180
 181 OutgoingConnectionFactoryPtr
 182 IceInternal::Instance::outgoingConnectionFactory() const
 183 {
 184     IceUtil::RecMutex::Lock sync(*this);
 185
 186     if(_state == StateDestroyed)
 187     {
 188         throw CommunicatorDestroyedException(__FILE__, __LINE__);
 189     }
 190
 191     assert(_outgoingConnectionFactory);
 192     return _outgoingConnectionFactory;
 193 }
 194
 195 ConnectionMonitorPtr
 196 IceInternal::Instance::connectionMonitor() const
 197 {
 198     IceUtil::RecMutex::Lock sync(*this);
 199
 200     if(_state == StateDestroyed)
 201     {
 202         throw CommunicatorDestroyedException(__FILE__, __LINE__);
 203     }
 204
 205     assert(_connectionMonitor);
 206     return _connectionMonitor;
 207 }
 208
 209 ObjectFactoryManagerPtr
 210 IceInternal::Instance::servantFactoryManager() const
 211 {
 212     IceUtil::RecMutex::Lock sync(*this);
 213
 214     if(_state == StateDestroyed)
 215     {
 216         throw CommunicatorDestroyedException(__FILE__, __LINE__);
 217     }
 218
 219     assert(_servantFactoryManager);
 220     return _servantFactoryManager;
 221 }
 222
 223 ObjectAdapterFactoryPtr
 224 IceInternal::Instance::objectAdapterFactory() const
 225 {
 226     IceUtil::RecMutex::Lock sync(*this);
 227
 228     if(_state == StateDestroyed)
 229     {
 230         throw CommunicatorDestroyedException(__FILE__, __LINE__);
 231     }
 232
 233     assert(_objectAdapterFactory);
 234     return _objectAdapterFactory;
 235 }
 236
 237 ProtocolSupport
 238 IceInternal::Instance::protocolSupport() const
 239 {
 240     IceUtil::RecMutex::Lock sync(*this);
 241
 242     if(_state == StateDestroyed)
 243     {
 244         throw CommunicatorDestroyedException(__FILE__, __LINE__);
 245     }
 246
 247     return _protocolSupport;
 248 }
 249
 250 ThreadPoolPtr
 251 IceInternal::Instance::clientThreadPool()
 252 {
 253     IceUtil::RecMutex::Lock sync(*this);
 254
 255     if(_state == StateDestroyed)
 256     {
 257         throw CommunicatorDestroyedException(__FILE__, __LINE__);
 258     }
 259
 260     assert(_clientThreadPool);
 261     return _clientThreadPool;
 262 }
 263
 264 ThreadPoolPtr
 265 IceInternal::Instance::serverThreadPool()
 266 {
 267     IceUtil::RecMutex::Lock sync(*this);
 268
 269     if(_state == StateDestroyed)
 270     {
 271         throw CommunicatorDestroyedException(__FILE__, __LINE__);
 272     }
 273
 274     if(!_serverThreadPool) // Lazy initialization.
 275     {
 276         int timeout = _initData.properties->getPropertyAsInt("Ice.ServerIdleTime");
 277         _serverThreadPool = new ThreadPool(this, "Ice.ThreadPool.Server", timeout);
 278     }
 279
 280     return _serverThreadPool;
 281 }
 282
 283 EndpointHostResolverPtr
 284 IceInternal::Instance::endpointHostResolver()
 285 {
 286     IceUtil::RecMutex::Lock sync(*this);
 287
 288     if(_state == StateDestroyed)
 289     {
 290         throw CommunicatorDestroyedException(__FILE__, __LINE__);
 291     }
 292
 293     assert(_endpointHostResolver);
 294     return _endpointHostResolver;
 295 }
 296
 297 RetryQueuePtr
 298 IceInternal::Instance::retryQueue()
 299 {
 300     IceUtil::RecMutex::Lock sync(*this);
 301
 302     if(_state == StateDestroyed)
 303     {
 304         throw CommunicatorDestroyedException(__FILE__, __LINE__);
 305     }
 306
 307     assert(_retryQueue);
 308     return _retryQueue;
 309 }
 310
 311 IceUtil::TimerPtr
 312 IceInternal::Instance::timer()
 313 {
 314     IceUtil::RecMutex::Lock sync(*this);
 315
 316     if(_state == StateDestroyed)
 317     {
 318         throw CommunicatorDestroyedException(__FILE__, __LINE__);
 319     }
 320     assert(_timer);
 321     return _timer;
 322 }
 323
 324 EndpointFactoryManagerPtr
 325 IceInternal::Instance::endpointFactoryManager() const
 326 {
 327     IceUtil::RecMutex::Lock sync(*this);
 328
 329     if(_state == StateDestroyed)
 330     {
 331         throw CommunicatorDestroyedException(__FILE__, __LINE__);
 332     }
 333
 334     assert(_endpointFactoryManager);
 335     return _endpointFactoryManager;
 336 }
 337
 338 DynamicLibraryListPtr
 339 IceInternal::Instance::dynamicLibraryList() const
 340 {
 341     IceUtil::RecMutex::Lock sync(*this);
 342
 343     if(_state == StateDestroyed)
 344     {
 345         throw CommunicatorDestroyedException(__FILE__, __LINE__);
 346     }
 347
 348     assert(_dynamicLibraryList);
 349     return _dynamicLibraryList;
 350 }
 351
 352 PluginManagerPtr
 353 IceInternal::Instance::pluginManager() const
 354 {
 355     IceUtil::RecMutex::Lock sync(*this);
 356
 357     if(_state == StateDestroyed)
 358     {
 359         throw CommunicatorDestroyedException(__FILE__, __LINE__);
 360     }
 361
 362     assert(_pluginManager);
 363     return _pluginManager;
 364 }
 365
 366 int
 367 IceInternal::Instance::clientACM() const
 368 {
 369     // No mutex lock, immutable.
 370     return _clientACM;
 371 }
 372
 373 int
 374 IceInternal::Instance::serverACM() const
 375 {
 376     // No mutex lock, immutable.
 377     return _serverACM;
 378 }
 379
 380 Identity
 381 IceInternal::Instance::stringToIdentity(const string& s) const
 382 {
 383     //
 384     // This method only accepts printable ascii. Since printable ascii is a subset
 385     // of all narrow string encodings, it is not necessary to convert the string
 386     // from the native string encoding. Any characters other than printable-ASCII
 387     // will cause an IllegalArgumentException. Note that it can contain Unicode
 388     // encoded in the escaped form which is the reason why we call fromUTF8 after
 389     // unespcaping the printable ASCII string.
 390     //
 391
 392     Identity ident;
 393
 394     //
 395     // Find unescaped separator.
 396     //
 397     string::size_type slash = string::npos, pos = 0;
 398     while((pos = s.find('/', pos)) != string::npos)
 399     {
 400         if(pos == 0 || s[pos - 1] != '\\')
 401         {
 402             if(slash == string::npos)
 403             {
 404                 slash = pos;
 405             }
 406             else
 407             {
 408                 //
 409                 // Extra unescaped slash found.
 410                 //
 411                 IdentityParseException ex(__FILE__, __LINE__);
 412                 ex.str = "unescaped backslash in identity `" + s + "'";
 413                 throw ex;
 414             }
 415         }
 416         pos++;
 417     }
 418
 419     if(slash == string::npos)
 420     {
 421         try
 422         {
 423             ident.name = IceUtilInternal::unescapeString(s, 0, s.size());
 424         }
 425         catch(const IceUtil::IllegalArgumentException& e)
 426         {
 427             IdentityParseException ex(__FILE__, __LINE__);
 428             ex.str = "invalid identity name `" + s + "': " + e.reason();
 429             throw ex;
 430         }
 431     }
 432     else
 433     {
 434         try
 435         {
 436             ident.category = IceUtilInternal::unescapeString(s, 0, slash);
 437         }
 438         catch(const IceUtil::IllegalArgumentException& e)
 439         {
 440             IdentityParseException ex(__FILE__, __LINE__);
 441             ex.str = "invalid category in identity `" + s + "': " + e.reason();
 442             throw ex;
 443         }
 444         if(slash + 1 < s.size())
 445         {
 446             try
 447             {
 448                 ident.name = IceUtilInternal::unescapeString(s, slash + 1, s.size());
 449             }
 450             catch(const IceUtil::IllegalArgumentException& e)
 451             {
 452                 IdentityParseException ex(__FILE__, __LINE__);
 453                 ex.str = "invalid name in identity `" + s + "': " + e.reason();
 454                 throw ex;
 455             }
 456         }
 457     }
 458
 459     ident.name = Ice::UTF8ToNative(_initData.stringConverter, ident.name);
 460     ident.category = Ice::UTF8ToNative(_initData.stringConverter, ident.category);
 461
 462     return ident;
 463 }
 464
 465 string
 466 IceInternal::Instance::identityToString(const Identity& ident) const
 467 {
 468     //
 469     // This method returns the stringified identity. The returned string only
 470     // contains printable ascii. It can contain UTF8 in the escaped form.
 471     //
 472     string name = Ice::nativeToUTF8(_initData.stringConverter, ident.name);
 473     string category = Ice::nativeToUTF8(_initData.stringConverter, ident.category);
 474
 475     if(category.empty())
 476     {
 477         return IceUtilInternal::escapeString(name, "/");
 478     }
 479     else
 480     {
 481         return IceUtilInternal::escapeString(category, "/") + '/' + IceUtilInternal::escapeString(name, "/");
 482     }
 483 }
 484
 485 Ice::ObjectPrx
 486 IceInternal::Instance::getAdmin()
 487 {
 488     IceUtil::RecMutex::Lock sync(*this);
 489
 490     if(_state == StateDestroyed)
 491     {
 492         throw CommunicatorDestroyedException(__FILE__, __LINE__);
 493     }
 494
 495     const string adminOA = "Ice.Admin";
 496
 497     if(_adminAdapter != 0)
 498     {
 499         return _adminAdapter->createProxy(_adminIdentity);
 500     }
 501     else if(_initData.properties->getProperty(adminOA + ".Endpoints") == "")
 502     {
 503         return 0;
 504     }
 505     else
 506     {
 507         string serverId = _initData.properties->getProperty("Ice.Admin.ServerId");
 508         string instanceName = _initData.properties->getProperty("Ice.Admin.InstanceName");
 509
 510         Ice::LocatorPrx defaultLocator = _referenceFactory->getDefaultLocator();
 511
 512         if((defaultLocator != 0 && serverId != "") || instanceName != "")
 513         {
 514             if(_adminIdentity.name == "")
 515             {
 516                 _adminIdentity.name = "admin";
 517                 if(instanceName == "")
 518                 {
 519                     instanceName = IceUtil::generateUUID();
 520                 }
 521                 _adminIdentity.category = instanceName;
 522
 523                 //
 524                 // Afterwards, _adminIdentity is read-only
 525                 //
 526             }
 527
 528             //
 529             // Create OA
 530             //
 531             _adminAdapter = _objectAdapterFactory->createObjectAdapter(adminOA, 0);
 532
 533             //
 534             // Add all facets to OA
 535             //
 536             FacetMap filteredFacets;
 537
 538             for(FacetMap::iterator p = _adminFacets.begin(); p != _adminFacets.end(); ++p)
 539             {
 540                 if(_adminFacetFilter.empty() || _adminFacetFilter.find(p->first) != _adminFacetFilter.end())
 541                 {
 542                     _adminAdapter->addFacet(p->second, _adminIdentity, p->first);
 543                 }
 544                 else
 545                 {
 546                     filteredFacets[p->first] = p->second;
 547                 }
 548             }
 549             _adminFacets.swap(filteredFacets);
 550
 551             ObjectAdapterPtr adapter = _adminAdapter;
 552             sync.release();
 553
 554             //
 555             // Activate OA
 556             //
 557             try
 558             {
 559                 adapter->activate();
 560             }
 561             catch(...)
 562             {
 563                 //
 564                 // We cleanup _adminAdapter, however this error is not recoverable
 565                 // (can't call again getAdmin() after fixing the problem)
 566                 // since all the facets (servants) in the adapter are lost
 567                 //
 568                 adapter->destroy();
 569                 sync.acquire();
 570                 _adminAdapter = 0;
 571                 throw;
 572             }
 573
 574             Ice::ObjectPrx admin = adapter->createProxy(_adminIdentity);
 575             if(defaultLocator != 0 && serverId != "")
 576             {
 577                 ProcessPrx process = ProcessPrx::uncheckedCast(admin->ice_facet("Process"));
 578                 try
 579                 {
 580                     //
 581                     // Note that as soon as the process proxy is registered, the communicator might be
 582                     // shutdown by a remote client and admin facets might start receiving calls.
 583                     //
 584                     defaultLocator->getRegistry()->setServerProcessProxy(serverId, process);
 585                 }
 586                 catch(const ServerNotFoundException&)
 587                 {
 588                     if(_traceLevels->location >= 1)
 589                     {
 590                         Trace out(_initData.logger, _traceLevels->locationCat);
 591                         out << "couldn't register server `" + serverId + "' with the locator registry:\n";
 592                         out << "the server is not known to the locator registry";
 593                     }
 594
 595                     throw InitializationException(__FILE__, __LINE__, "Locator knows nothing about server '" +
 596                                                                       serverId + "'");
 597                 }
 598                 catch(const LocalException& ex)
 599                 {
 600                     if(_traceLevels->location >= 1)
 601                     {
 602                         Trace out(_initData.logger, _traceLevels->locationCat);
 603                         out << "couldn't register server `" + serverId + "' with the locator registry:\n" << ex;
 604                     }
 605                     throw;
 606                 }
 607             }
 608
 609             if(_traceLevels->location >= 1)
 610             {
 611                 Trace out(_initData.logger, _traceLevels->locationCat);
 612                 out << "registered server `" + serverId + "' with the locator registry";
 613             }
 614
 615             return admin;
 616         }
 617         else
 618         {
 619             return 0;
 620         }
 621     }
 622 }
 623
 624 void
 625 IceInternal::Instance::addAdminFacet(const Ice::ObjectPtr& servant, const string& facet)
 626 {
 627     IceUtil::RecMutex::Lock sync(*this);
 628
 629     if(_state == StateDestroyed)
 630     {
 631         throw CommunicatorDestroyedException(__FILE__, __LINE__);
 632     }
 633
 634     if(_adminAdapter == 0 || (!_adminFacetFilter.empty() && _adminFacetFilter.find(facet) == _adminFacetFilter.end()))
 635     {
 636         if(_adminFacets.insert(FacetMap::value_type(facet, servant)).second == false)
 637         {
 638             throw AlreadyRegisteredException(__FILE__, __LINE__, "facet", facet);
 639         }
 640     }
 641     else
 642     {
 643         _adminAdapter->addFacet(servant, _adminIdentity, facet);
 644     }
 645 }
 646
 647 Ice::ObjectPtr
 648 IceInternal::Instance::removeAdminFacet(const string& facet)
 649 {
 650     IceUtil::RecMutex::Lock sync(*this);
 651
 652     if(_state == StateDestroyed)
 653     {
 654         throw CommunicatorDestroyedException(__FILE__, __LINE__);
 655     }
 656
 657     ObjectPtr result;
 658
 659     if(_adminAdapter == 0 || (!_adminFacetFilter.empty() && _adminFacetFilter.find(facet) == _adminFacetFilter.end()))
 660     {
 661         FacetMap::iterator p = _adminFacets.find(facet);
 662         if(p == _adminFacets.end())
 663         {
 664             throw NotRegisteredException(__FILE__, __LINE__, "facet", facet);
 665         }
 666         else
 667         {
 668             result = p->second;
 669             _adminFacets.erase(p);
 670         }
 671     }
 672     else
 673     {
 674         result = _adminAdapter->removeFacet(_adminIdentity, facet);
 675     }
 676     return result;
 677 }
 678
 679 void
 680 IceInternal::Instance::setDefaultLocator(const Ice::LocatorPrx& defaultLocator)
 681 {
 682     IceUtil::RecMutex::Lock sync(*this);
 683
 684     if(_state == StateDestroyed)
 685     {
 686         throw CommunicatorDestroyedException(__FILE__, __LINE__);
 687     }
 688
 689     _referenceFactory = _referenceFactory->setDefaultLocator(defaultLocator);
 690 }
 691
 692 void
 693 IceInternal::Instance::setDefaultRouter(const Ice::RouterPrx& defaultRouter)
 694 {
 695     IceUtil::RecMutex::Lock sync(*this);
 696
 697     if(_state == StateDestroyed)
 698     {
 699         throw CommunicatorDestroyedException(__FILE__, __LINE__);
 700     }
 701
 702     _referenceFactory = _referenceFactory->setDefaultRouter(defaultRouter);
 703 }
 704
 705 void
 706 IceInternal::Instance::setStringConverter(const Ice::StringConverterPtr& stringConverter)
 707 {
 708     //
 709     // No locking, as it can only be called during plug-in loading
 710     //
 711     _initData.stringConverter = stringConverter;
 712 }
 713
 714 void
 715 IceInternal::Instance::setWstringConverter(const Ice::WstringConverterPtr& wstringConverter)
 716 {
 717     //
 718     // No locking, as it can only be called during plug-in loading
 719     //
 720     _initData.wstringConverter = wstringConverter;
 721 }
 722
 723 void
 724 IceInternal::Instance::setLogger(const Ice::LoggerPtr& logger)
 725 {
 726     //
 727     // No locking, as it can only be called during plug-in loading
 728     //
 729     _initData.logger = logger;
 730 }
 731
 732 void
 733 IceInternal::Instance::setThreadHook(const Ice::ThreadNotificationPtr& threadHook)
 734 {
 735     //
 736     // No locking, as it can only be called during plug-in loading
 737     //
 738     _initData.threadHook = threadHook;
 739 }
 740
 741 IceInternal::Instance::Instance(const CommunicatorPtr& communicator, const InitializationData& initData) :
 742     _state(StateActive),
 743     _initData(initData),
 744     _messageSizeMax(0),
 745     _clientACM(0),
 746     _serverACM(0),
 747     _implicitContext(0)
 748 {
 749     try
 750     {
 751         __setNoDelete(true);
 752         {
 753             IceUtilInternal::MutexPtrLock<IceUtil::Mutex> sync(staticMutex);
 754             instanceCount++;
 755
 756             if(!_initData.properties)
 757             {
 758                 _initData.properties = createProperties();
 759             }
 760
 761             if(!oneOffDone)
 762             {
 763                 //
 764                 // StdOut and StdErr redirection
 765                 //
 766                 string stdOutFilename = _initData.properties->getProperty("Ice.StdOut");
 767                 string stdErrFilename = _initData.properties->getProperty("Ice.StdErr");
 768
 769                 if(stdOutFilename != "")
 770                 {
 771 #ifdef _LARGEFILE64_SOURCE
 772                     FILE* file = freopen64(stdOutFilename.c_str(), "a", stdout);
 773 #else
 774 #ifdef _WIN32
 775                     FILE* file = _wfreopen(IceUtil::stringToWstring(nativeToUTF8(_initData.stringConverter,
 776                                                                                  stdOutFilename)).c_str(),
 777                                            L"a", stdout);
 778 #else
 779                     FILE* file = freopen(stdOutFilename.c_str(), "a", stdout);
 780 #endif
 781 #endif
 782                     if(file == 0)
 783                     {
 784                         FileException ex(__FILE__, __LINE__);
 785                         ex.path = stdOutFilename;
 786                         ex.error = getSystemErrno();
 787                         throw ex;
 788                     }
 789                 }
 790
 791                 if(stdErrFilename != "")
 792                 {
 793 #ifdef _LARGEFILE64_SOURCE
 794                     FILE* file = freopen64(stdErrFilename.c_str(), "a", stderr);
 795 #else
 796 #ifdef _WIN32
 797                     FILE* file = _wfreopen(IceUtil::stringToWstring(nativeToUTF8(_initData.stringConverter,
 798                                                                                  stdErrFilename)).c_str(),
 799                                            L"a", stderr);
 800 #else
 801                     FILE* file = freopen(stdErrFilename.c_str(), "a", stderr);
 802 #endif
 803 #endif
 804                     if(file == 0)
 805                     {
 806                         FileException ex(__FILE__, __LINE__);
 807                         ex.path = stdErrFilename;
 808                         ex.error = getSystemErrno();
 809                         throw ex;
 810                     }
 811                 }
 812
 813                 if(_initData.properties->getPropertyAsInt("Ice.NullHandleAbort") > 0)
 814                 {
 815                     IceUtilInternal::nullHandleAbort = true;
 816                 }
 817
 818 #ifdef NDEBUG
 819                 if(_initData.properties->getPropertyAsIntWithDefault("Ice.PrintStackTraces", 0) > 0)
 820 #else
 821                 if(_initData.properties->getPropertyAsIntWithDefault("Ice.PrintStackTraces", 1) > 0)
 822 #endif
 823                 {
 824                     IceUtilInternal::printStackTraces = true;
 825                 }
 826
 827 #ifndef _WIN32
 828                 string newUser = _initData.properties->getProperty("Ice.ChangeUser");
 829                 if(!newUser.empty())
 830                 {
 831                     struct passwd* pw = getpwnam(newUser.c_str());
 832                     if(!pw)
 833                     {
 834                         SyscallException ex(__FILE__, __LINE__);
 835                         ex.error = getSystemErrno();
 836                         throw ex;
 837                     }
 838
 839                     if(setgid(pw->pw_gid) == -1)
 840                     {
 841                         SyscallException ex(__FILE__, __LINE__);
 842                         ex.error = getSystemErrno();
 843                         throw ex;
 844                     }
 845
 846                     if(setuid(pw->pw_uid) == -1)
 847                     {
 848                         SyscallException ex(__FILE__, __LINE__);
 849                         ex.error = getSystemErrno();
 850                         throw ex;
 851                     }
 852                 }
 853 #endif
 854                 oneOffDone = true;
 855             }
 856
 857             if(instanceCount == 1)
 858             {
 859
 860 #ifdef _WIN32
 861                 WORD version = MAKEWORD(1, 1);
 862                 WSADATA data;
 863                 if(WSAStartup(version, &data) != 0)
 864                 {
 865                     SocketException ex(__FILE__, __LINE__);
 866                     ex.error = getSocketErrno();
 867                     throw ex;
 868                 }
 869 #endif
 870
 871 #ifndef _WIN32
 872                 struct sigaction action;
 873                 action.sa_handler = SIG_IGN;
 874                 sigemptyset(&action.sa_mask);
 875                 action.sa_flags = 0;
 876                 sigaction(SIGPIPE, &action, &oldAction);
 877                 if(_initData.properties->getPropertyAsInt("Ice.UseSyslog") > 0)
 878                 {
 879                     identForOpenlog = _initData.properties->getProperty("Ice.ProgramName");
 880                     if(identForOpenlog.empty())
 881                     {
 882                         identForOpenlog = "<Unknown Ice Program>";
 883                     }
 884                     openlog(identForOpenlog.c_str(), LOG_PID, LOG_USER);
 885                 }
 886 #endif
 887             }
 888         }
 889
 890
 891         if(!_initData.logger)
 892         {
 893             string logfile = _initData.properties->getProperty("Ice.LogFile");
 894 #ifndef _WIN32
 895             if(_initData.properties->getPropertyAsInt("Ice.UseSyslog") > 0)
 896             {
 897                 if(!logfile.empty())
 898                 {
 899                     throw InitializationException(__FILE__, __LINE__, "Both syslog and file logger cannot be enabled.");
 900                 }
 901
 902                 _initData.logger =
 903                     new SysLoggerI(_initData.properties->getProperty("Ice.ProgramName"),
 904                                    _initData.properties->getPropertyWithDefault("Ice.SyslogFacility", "LOG_USER"));
 905             }
 906             else
 907 #endif
 908             if(!logfile.empty())
 909             {
 910                 _initData.logger = new LoggerI(_initData.properties->getProperty("Ice.ProgramName"),
 911                                                nativeToUTF8(_initData.stringConverter, logfile));
 912             }
 913             else
 914             {
 915                 _initData.logger = getProcessLogger();
 916             }
 917         }
 918
 919         const_cast<TraceLevelsPtr&>(_traceLevels) = new TraceLevels(_initData.properties);
 920
 921         const_cast<DefaultsAndOverridesPtr&>(_defaultsAndOverrides) = new DefaultsAndOverrides(_initData.properties);
 922
 923         {
 924             static const int defaultMessageSizeMax = 1024;
 925             Int num = _initData.properties->getPropertyAsIntWithDefault("Ice.MessageSizeMax", defaultMessageSizeMax);
 926             if(num < 1)
 927             {
 928                 const_cast<size_t&>(_messageSizeMax) = defaultMessageSizeMax * 1024; // Ignore non-sensical values.
 929             }
 930             else if(static_cast<size_t>(num) > (size_t)(0x7fffffff / 1024))
 931             {
 932                 const_cast<size_t&>(_messageSizeMax) = static_cast<size_t>(0x7fffffff);
 933             }
 934             else
 935             {
 936                 // Property is in kilobytes, _messageSizeMax in bytes.
 937                 const_cast<size_t&>(_messageSizeMax) = static_cast<size_t>(num) * 1024;
 938             }
 939         }
 940
 941         //
 942         // Client ACM enabled by default. Server ACM disabled by default.
 943         //
 944         const_cast<Int&>(_clientACM) = _initData.properties->getPropertyAsIntWithDefault("Ice.ACM.Client", 60);
 945         const_cast<Int&>(_serverACM) = _initData.properties->getPropertyAsInt("Ice.ACM.Server");
 946         const_cast<ImplicitContextIPtr&>(_implicitContext) =
 947             ImplicitContextI::create(_initData.properties->getProperty("Ice.ImplicitContext"));
 948
 949         _routerManager = new RouterManager;
 950
 951         _locatorManager = new LocatorManager(_initData.properties);
 952
 953         _referenceFactory = new ReferenceFactory(this, communicator);
 954
 955         _proxyFactory = new ProxyFactory(this);
 956
 957         bool ipv4 = _initData.properties->getPropertyAsIntWithDefault("Ice.IPv4", 1) > 0;
 958         bool ipv6 = _initData.properties->getPropertyAsIntWithDefault("Ice.IPv6", 0) > 0;
 959         if(!ipv4 && !ipv6)
 960         {
 961             throw InitializationException(__FILE__, __LINE__, "Both IPV4 and IPv6 support cannot be disabled.");
 962         }
 963         else if(ipv4 && ipv6)
 964         {
 965             _protocolSupport = EnableBoth;
 966         }
 967         else if(ipv4)
 968         {
 969             _protocolSupport = EnableIPv4;
 970         }
 971         else
 972         {
 973             _protocolSupport = EnableIPv6;
 974         }
 975         _endpointFactoryManager = new EndpointFactoryManager(this);
 976         EndpointFactoryPtr tcpEndpointFactory = new TcpEndpointFactory(this);
 977         _endpointFactoryManager->add(tcpEndpointFactory);
 978         EndpointFactoryPtr udpEndpointFactory = new UdpEndpointFactory(this);
 979         _endpointFactoryManager->add(udpEndpointFactory);
 980
 981         _dynamicLibraryList = new DynamicLibraryList;
 982
 983         _pluginManager = new PluginManagerI(communicator, _dynamicLibraryList);
 984
 985         _outgoingConnectionFactory = new OutgoingConnectionFactory(this);
 986
 987         _servantFactoryManager = new ObjectFactoryManager();
 988
 989         _objectAdapterFactory = new ObjectAdapterFactory(this, communicator);
 990
 991         _retryQueue = new RetryQueue(this);
 992
 993
 994         if(_initData.wstringConverter == 0)
 995         {
 996             _initData.wstringConverter = new UnicodeWstringConverter();
 997         }
 998
 999         //
1000         // Add Process and Properties facets
1001         //
1002
1003         StringSeq facetSeq = _initData.properties->getPropertyAsList("Ice.Admin.Facets");
1004
1005         if(!facetSeq.empty())
1006         {
1007             _adminFacetFilter.insert(facetSeq.begin(), facetSeq.end());
1008         }
1009
1010         _adminFacets.insert(FacetMap::value_type("Properties", new PropertiesAdminI(_initData.properties)));
1011         _adminFacets.insert(FacetMap::value_type("Process", new ProcessI(communicator)));
1012
1013         __setNoDelete(false);
1014     }
1015     catch(...)
1016     {
1017         {
1018             IceUtilInternal::MutexPtrLock<IceUtil::Mutex> sync(staticMutex);
1019             --instanceCount;
1020         }
1021         destroy();
1022         __setNoDelete(false);
1023         throw;
1024     }
1025 }
1026
1027 IceInternal::Instance::~Instance()
1028 {
1029     assert(_state == StateDestroyed);
1030     assert(!_referenceFactory);
1031     assert(!_proxyFactory);
1032     assert(!_outgoingConnectionFactory);
1033
1034     assert(!_connectionMonitor);
1035     assert(!_servantFactoryManager);
1036     assert(!_objectAdapterFactory);
1037     assert(!_clientThreadPool);
1038     assert(!_serverThreadPool);
1039     assert(!_endpointHostResolver);
1040     assert(!_retryQueue);
1041     assert(!_timer);
1042     assert(!_routerManager);
1043     assert(!_locatorManager);
1044     assert(!_endpointFactoryManager);
1045     assert(!_dynamicLibraryList);
1046     assert(!_pluginManager);
1047
1048     IceUtilInternal::MutexPtrLock<IceUtil::Mutex> sync(staticMutex);
1049     if(--instanceCount == 0)
1050     {
1051 #ifdef _WIN32
1052         WSACleanup();
1053 #endif
1054
1055 #ifndef _WIN32
1056         sigaction(SIGPIPE, &oldAction, 0);
1057
1058         if(!identForOpenlog.empty())
1059         {
1060             closelog();
1061             identForOpenlog.clear();
1062         }
1063 #endif
1064     }
1065 }
1066
1067 void
1068 IceInternal::Instance::finishSetup(int& argc, char* argv[])
1069 {
1070     //
1071     // Load plug-ins.
1072     //
1073     assert(!_serverThreadPool);
1074     PluginManagerI* pluginManagerImpl = dynamic_cast<PluginManagerI*>(_pluginManager.get());
1075     assert(pluginManagerImpl);
1076     pluginManagerImpl->loadPlugins(argc, argv);
1077
1078
1079     //
1080     // Create threads.
1081     //
1082     try
1083     {
1084         bool hasPriority = _initData.properties->getProperty("Ice.ThreadPriority") != "";
1085         int priority = _initData.properties->getPropertyAsInt("Ice.ThreadPriority");
1086         if(hasPriority)
1087         {
1088             _timer = new IceUtil::Timer(priority);
1089         }
1090         else
1091         {
1092             _timer = new IceUtil::Timer;
1093         }
1094     }
1095     catch(const IceUtil::Exception& ex)
1096     {
1097         Error out(_initData.logger);
1098         out << "cannot create thread for timer:\n" << ex;
1099         throw;
1100     }
1101
1102     try
1103     {
1104         _endpointHostResolver = new EndpointHostResolver(this);
1105     }
1106     catch(const IceUtil::Exception& ex)
1107     {
1108         Error out(_initData.logger);
1109         out << "cannot create thread for endpoint host resolver:\n" << ex;
1110         throw;
1111     }
1112
1113     _clientThreadPool = new ThreadPool(this, "Ice.ThreadPool.Client", 0);
1114
1115     //
1116     // Get default router and locator proxies. Don't move this
1117     // initialization before the plug-in initialization!!! The proxies
1118     // might depend on endpoint factories to be installed by plug-ins.
1119     //
1120     RouterPrx router = RouterPrx::uncheckedCast(_proxyFactory->propertyToProxy("Ice.Default.Router"));
1121     if(router)
1122     {
1123         _referenceFactory = _referenceFactory->setDefaultRouter(router);
1124     }
1125
1126     LocatorPrx locator = LocatorPrx::uncheckedCast(_proxyFactory->propertyToProxy("Ice.Default.Locator"));
1127     if(locator)
1128     {
1129         _referenceFactory = _referenceFactory->setDefaultLocator(locator);
1130     }
1131
1132     //
1133     // Show process id if requested (but only once).
1134     //
1135     bool printProcessId = false;
1136     if(!printProcessIdDone && _initData.properties->getPropertyAsInt("Ice.PrintProcessId") > 0)
1137     {
1138         //
1139         // Safe double-check locking (no dependent variable!)
1140         //
1141         IceUtilInternal::MutexPtrLock<IceUtil::Mutex> sync(staticMutex);
1142         printProcessId = !printProcessIdDone;
1143
1144         //
1145         // We anticipate: we want to print it once, and we don't care when.
1146         //
1147         printProcessIdDone = true;
1148     }
1149
1150     if(printProcessId)
1151     {
1152 #ifdef _MSC_VER
1153         cout << _getpid() << endl;
1154 #else
1155         cout << getpid() << endl;
1156 #endif
1157     }
1158
1159     //
1160     // Create the connection monitor and ensure the interval for
1161     // monitoring connections is appropriate for client & server
1162     // ACM.
1163     //
1164     _connectionMonitor = new ConnectionMonitor(this, _initData.properties->getPropertyAsInt("Ice.MonitorConnections"));
1165     _connectionMonitor->checkIntervalForACM(_clientACM);
1166     _connectionMonitor->checkIntervalForACM(_serverACM);
1167
1168     //
1169     // Server thread pool initialization is lazy in serverThreadPool().
1170     //
1171
1172     //
1173     // An application can set Ice.InitPlugins=0 if it wants to postpone
1174     // initialization until after it has interacted directly with the
1175     // plug-ins.
1176     //
1177     if(_initData.properties->getPropertyAsIntWithDefault("Ice.InitPlugins", 1) > 0)
1178     {
1179         pluginManagerImpl->initializePlugins();
1180     }
1181
1182     //
1183     // This must be done last as this call creates the Ice.Admin object adapter
1184     // and eventually register a process proxy with the Ice locator (allowing
1185     // remote clients to invoke on Ice.Admin facets as soon as it's registered).
1186     //
1187     if(_initData.properties->getPropertyAsIntWithDefault("Ice.Admin.DelayCreation", 0) <= 0)
1188     {
1189         getAdmin();
1190     }
1191 }
1192
1193 bool
1194 IceInternal::Instance::destroy()
1195 {
1196     {
1197         IceUtil::RecMutex::Lock sync(*this);
1198
1199         //
1200         // If the _state is not StateActive then the instance is
1201         // either being destroyed, or has already been destroyed.
1202         //
1203         if(_state != StateActive)
1204         {
1205             return false;
1206         }
1207
1208         //
1209         // We cannot set state to StateDestroyed otherwise instance
1210         // methods called during the destroy process (such as
1211         // outgoingConnectionFactory() from
1212         // ObjectAdapterI::deactivate() will cause an exception.
1213         //
1214         _state = StateDestroyInProgress;
1215     }
1216
1217     if(_objectAdapterFactory)
1218     {
1219         _objectAdapterFactory->shutdown();
1220     }
1221
1222     if(_outgoingConnectionFactory)
1223     {
1224         _outgoingConnectionFactory->destroy();
1225     }
1226
1227     if(_objectAdapterFactory)
1228     {
1229         _objectAdapterFactory->destroy();
1230     }
1231
1232     if(_outgoingConnectionFactory)
1233     {
1234         _outgoingConnectionFactory->waitUntilFinished();
1235     }
1236
1237     if(_retryQueue)
1238     {
1239         _retryQueue->destroy();
1240     }
1241
1242     ThreadPoolPtr serverThreadPool;
1243     ThreadPoolPtr clientThreadPool;
1244     EndpointHostResolverPtr endpointHostResolver;
1245
1246     {
1247         IceUtil::RecMutex::Lock sync(*this);
1248
1249         _objectAdapterFactory = 0;
1250         _outgoingConnectionFactory = 0;
1251         _retryQueue = 0;
1252
1253         if(_connectionMonitor)
1254         {
1255             _connectionMonitor->destroy();
1256             _connectionMonitor = 0;
1257         }
1258
1259         if(_serverThreadPool)
1260         {
1261             _serverThreadPool->destroy();
1262             std::swap(_serverThreadPool, serverThreadPool);
1263         }
1264
1265         if(_clientThreadPool)
1266         {
1267             _clientThreadPool->destroy();
1268             std::swap(_clientThreadPool, clientThreadPool);
1269         }
1270
1271         if(_endpointHostResolver)
1272         {
1273             _endpointHostResolver->destroy();
1274             std::swap(endpointHostResolver, _endpointHostResolver);
1275         }
1276
1277         if(_timer)
1278         {
1279             _timer->destroy();
1280             _timer = 0;
1281         }
1282
1283         if(_servantFactoryManager)
1284         {
1285             _servantFactoryManager->destroy();
1286             _servantFactoryManager = 0;
1287         }
1288
1289         //_referenceFactory->destroy(); // No destroy function defined.
1290         _referenceFactory = 0;
1291
1292         // _proxyFactory->destroy(); // No destroy function defined.
1293         _proxyFactory = 0;
1294
1295         if(_routerManager)
1296         {
1297             _routerManager->destroy();
1298             _routerManager = 0;
1299         }
1300
1301         if(_locatorManager)
1302         {
1303             _locatorManager->destroy();
1304             _locatorManager = 0;
1305         }
1306
1307         if(_endpointFactoryManager)
1308         {
1309             _endpointFactoryManager->destroy();
1310             _endpointFactoryManager = 0;
1311         }
1312
1313         if(_pluginManager)
1314         {
1315             _pluginManager->destroy();
1316             _pluginManager = 0;
1317         }
1318
1319         // No destroy function defined.
1320         // _dynamicLibraryList->destroy();
1321         _dynamicLibraryList = 0;
1322
1323         _adminAdapter = 0;
1324         _adminFacets.clear();
1325
1326         _state = StateDestroyed;
1327     }
1328
1329     //
1330     // Join with the thread pool threads outside the synchronization.
1331     //
1332     if(clientThreadPool)
1333     {
1334         clientThreadPool->joinWithAllThreads();
1335     }
1336     if(serverThreadPool)
1337     {
1338         serverThreadPool->joinWithAllThreads();
1339     }
1340     if(endpointHostResolver)
1341     {
1342         endpointHostResolver->getThreadControl().join();
1343     }
1344
1345     if(_initData.properties->getPropertyAsInt("Ice.Warn.UnusedProperties") > 0)
1346     {
1347         set<string> unusedProperties = static_cast<PropertiesI*>(_initData.properties.get())->getUnusedProperties();
1348         if(unusedProperties.size() != 0)
1349         {
1350             Warning out(_initData.logger);
1351             out << "The following properties were set but never read:";
1352             for(set<string>::const_iterator p = unusedProperties.begin(); p != unusedProperties.end(); ++p)
1353             {
1354                 out << "\n    " << *p;
1355             }
1356         }
1357     }
1358     return true;
1359 }
1360
1361 IceInternal::UTF8BufferI::UTF8BufferI() :
1362     _buffer(0),
1363     _offset(0)
1364 {
1365 }
1366
1367 IceInternal::UTF8BufferI::~UTF8BufferI()
1368 {
1369     free(_buffer);
1370 }
1371
1372 Byte*
1373 IceInternal::UTF8BufferI::getMoreBytes(size_t howMany, Byte* firstUnused)
1374 {
1375     if(_buffer == 0)
1376     {
1377         _buffer = (Byte*)malloc(howMany);
1378     }
1379     else
1380     {
1381         assert(firstUnused != 0);
1382         _offset = firstUnused - _buffer;
1383         _buffer = (Byte*)realloc(_buffer, _offset + howMany);
1384     }
1385
1386     return _buffer + _offset;
1387 }
1388
1389 Byte*
1390 IceInternal::UTF8BufferI::getBuffer()
1391 {
1392     return _buffer;
1393 }
1394
1395 void
1396 IceInternal::UTF8BufferI::reset()
1397 {
1398     free(_buffer);
1399     _buffer = 0;
1400     _offset = 0;
1401 }
1402
1403
1404 IceInternal::ProcessI::ProcessI(const CommunicatorPtr& communicator) :
1405     _communicator(communicator)
1406 {
1407 }
1408
1409 void
1410 IceInternal::ProcessI::shutdown(const Current&)
1411 {
1412     _communicator->shutdown();
1413 }
1414
1415 void
1416 IceInternal::ProcessI::writeMessage(const string& message, Int fd, const Current&)
1417 {
1418     switch(fd)
1419     {
1420         case 1:
1421         {
1422             cout << message << endl;
1423             break;
1424         }
1425         case 2:
1426         {
1427             cerr << message << endl;
1428             break;
1429         }
1430     }
1431 }