zeroc-ice 3.7.11 → 3.8.1

data/dist/ice/cpp/src/Ice/Service.cpp

@@ -1,54 +1,43 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
-#include <IceUtil/CtrlCHandler.h>
-#include <IceUtil/StringUtil.h>
-#include <IceUtil/Thread.h>
-#include <IceUtil/Monitor.h>
-#include <IceUtil/Mutex.h>
-#include <Ice/ArgVector.h>
-#include <IceUtil/FileUtil.h>
-#include <Ice/ConsoleUtil.h>
-#include <Ice/StringConverter.h>
-#include <Ice/Service.h>
-#include <Ice/LoggerI.h>
-#include <Ice/Initialize.h>
-#include <Ice/Communicator.h>
-#include <Ice/LocalException.h>
-#include <Ice/Properties.h>
-#include <Ice/Instance.h>
-#include <Ice/LoggerUtil.h>
+#include "Ice/Service.h"
+#include "ArgVector.h"
+#include "ConsoleUtil.h"
+#include "Ice/StringUtil.h"
+#include "LoggerI.h"
 
 #ifdef _WIN32
-#   include <winsock2.h>
-#   include <Ice/EventLoggerMsg.h>
+#    include "Ice/EventLoggerMsg.h"
+#    include <winsock2.h>
 #else
-#   include <Ice/Logger.h>
-#   include <Ice/Network.h>
-#   include <sys/types.h>
-#   include <sys/stat.h>
-#   include <csignal>
-#   ifdef ICE_USE_SYSTEMD
-#       include <systemd/sd-daemon.h>
-#   endif
+#    include "Network.h"
+#    include <csignal>
+#    include <sys/stat.h>
+#    include <sys/types.h>
+#    ifdef ICE_USE_SYSTEMD
+#        include <systemd/sd-daemon.h>
+#    endif
 #endif
 
 using namespace std;
 using namespace Ice;
 using namespace IceInternal;
 
-Ice::Service* Ice::Service::_instance = 0;
-static IceUtil::CtrlCHandler* _ctrlCHandler = 0;
+Ice::Service* Ice::Service::_instance = nullptr;
+
+namespace
+{
+    CtrlCHandler* ctrlCHandler = nullptr;
+}
 
 //
-// Callback for IceUtil::CtrlCHandler.
+// Callback for CtrlCHandler.
 //
 static void
 ctrlCHandlerCallback(int sig)
 {
     Ice::Service* service = Ice::Service::instance();
-    assert(service != 0);
+    assert(service != nullptr);
     service->handleInterrupt(sig);
 }
 
@@ -78,444 +67,392 @@ Ice_Service_CtrlHandler(DWORD ctrl)
 
 namespace
 {
+    class ServiceStatusManager
+    {
+    public:
+        ServiceStatusManager(SERVICE_STATUS_HANDLE);
 
-class ServiceStatusManager : public IceUtil::Monitor<IceUtil::Mutex>
-{
-public:
+        //
+        // Start a thread to provide regular status updates to the SCM.
+        //
+        void startUpdate(DWORD);
 
-    ServiceStatusManager(SERVICE_STATUS_HANDLE);
+        //
+        // Stop the update thread.
+        //
+        void stopUpdate();
 
-    //
-    // Start a thread to provide regular status updates to the SCM.
-    //
-    void startUpdate(DWORD);
+        //
+        // Change the service status and report it (once).
+        //
+        void changeStatus(DWORD, DWORD);
 
-    //
-    // Stop the update thread.
-    //
-    void stopUpdate();
+        //
+        // Report the current status.
+        //
+        void reportStatus();
 
-    //
-    // Change the service status and report it (once).
-    //
-    void changeStatus(DWORD, DWORD);
+    private:
+        void run();
+
+        SERVICE_STATUS_HANDLE _handle;
+        SERVICE_STATUS _status;
+        std::thread _thread;
+        bool _stopped;
+        std::mutex _mutex;
+        std::condition_variable _conditionVariable;
+    };
+
+    static ServiceStatusManager* serviceStatusManager;
 
     //
-    // Report the current status.
+    // Interface implemented by SMEventLoggerI and called from
+    // SMEventLoggerIWrapper.
     //
-    void reportStatus();
-
-private:
-
-    void run();
-
-    class StatusThread : public IceUtil::Thread
+    class SMEventLogger
     {
     public:
+        virtual void print(const string&, const string&) = 0;
+        virtual void trace(const string&, const string&, const string&) = 0;
+        virtual void warning(const string&, const string&) = 0;
+        virtual void error(const string&, const string&) = 0;
+    };
+    using SMEventLoggerPtr = std::shared_ptr<SMEventLogger>;
 
-        StatusThread(ServiceStatusManager* manager) :
-            IceUtil::Thread("Ice service status manager thread"),
-            _manager(manager)
-        {
-        }
-
-        virtual void run()
+    class SMEventLoggerIWrapper final : public Ice::Logger
+    {
+    public:
+        SMEventLoggerIWrapper(const SMEventLoggerPtr& logger, string prefix)
+            : _logger(logger),
+              _prefix(std::move(prefix))
         {
-            _manager->run();
+            assert(_logger);
         }
 
-    private:
-
-        ServiceStatusManager* _manager;
-    };
-    friend class StatusThread;
-
-    SERVICE_STATUS_HANDLE _handle;
-    SERVICE_STATUS _status;
-    IceUtil::ThreadPtr _thread;
-    bool _stopped;
-};
+        void print(const string& message) final { _logger->print(_prefix, message); }
 
-static ServiceStatusManager* serviceStatusManager;
+        void trace(const string& category, const string& message) final { _logger->trace(_prefix, category, message); }
 
-//
-// Interface implemented by SMEventLoggerI and called from
-// SMEventLoggerIWrapper.
-//
-class SMEventLogger : public IceUtil::Shared
-{
-public:
-    virtual void print(const string&, const string&) = 0;
-    virtual void trace(const string&, const string&, const string&) = 0;
-    virtual void warning(const string&, const string&) = 0;
-    virtual void error(const string&, const string&) = 0;
-};
-typedef IceUtil::Handle<SMEventLogger> SMEventLoggerPtr;
-
-class SMEventLoggerIWrapper : public Ice::Logger
-{
-public:
+        void warning(const string& message) final { _logger->warning(_prefix, message); }
 
-    SMEventLoggerIWrapper(const SMEventLoggerPtr& logger, const string& prefix) :
-        _logger(logger),
-        _prefix(prefix)
-    {
-        assert(_logger);
-    }
+        void error(const string& message) final { _logger->error(_prefix, message); }
 
-    virtual void
-    print(const string& message)
-    {
-        _logger->print(_prefix, message);
-    }
+        string getPrefix() final { return _prefix; }
 
-    void
-    trace(const string& category, const string& message)
-    {
-        _logger->trace(_prefix, category, message);
-    }
-
-    virtual void
-    warning(const string& message)
-    {
-        _logger->warning(_prefix, message);
-    }
+        Ice::LoggerPtr cloneWithPrefix(string prefix) final
+        {
+            return make_shared<SMEventLoggerIWrapper>(_logger, std::move(prefix));
+        }
 
-    virtual void
-    error(const string& message)
-    {
-        _logger->error(_prefix, message);
-    }
+    private:
+        SMEventLoggerPtr _logger;
+        const string _prefix;
+    };
 
-    virtual string
-    getPrefix()
+    class SMEventLoggerI : public SMEventLogger
     {
-        return _prefix;
-    }
+    public:
+        SMEventLoggerI(const string& source, const StringConverterPtr& stringConverter)
+            : _stringConverter(stringConverter)
+        {
+            //
+            // Don't need to use a wide string converter as the wide string is passed
+            // to Windows API.
+            //
+            _source = RegisterEventSourceW(0, stringToWstring(mangleSource(source), _stringConverter).c_str());
+            if (_source == 0)
+            {
+                throw SyscallException{__FILE__, __LINE__, "RegisterEventSourceW failed", GetLastError()};
+            }
+        }
 
-    virtual Ice::LoggerPtr
-    cloneWithPrefix(const string& prefix)
-    {
-        return ICE_MAKE_SHARED(SMEventLoggerIWrapper, _logger, prefix);
-    }
+        ~SMEventLoggerI()
+        {
+            assert(_source != 0);
+            DeregisterEventSource(_source);
+        }
 
-private:
+        static void addKeys(const string& source, const StringConverterPtr& stringConverter)
+        {
+            HKEY hKey;
+            DWORD d;
+            //
+            // Don't need to use a wide string converter as the wide string is passed
+            // to Windows API.
+            //
+            LSTATUS err = RegCreateKeyExW(
+                HKEY_LOCAL_MACHINE,
+                stringToWstring(createKey(source), stringConverter).c_str(),
+                0,
+                const_cast<wchar_t*>(L"REG_SZ"),
+                REG_OPTION_NON_VOLATILE,
+                KEY_ALL_ACCESS,
+                0,
+                &hKey,
+                &d);
+
+            if (err != ERROR_SUCCESS)
+            {
+                throw SyscallException{__FILE__, __LINE__, "RegCreateKeyExW failed", static_cast<DWORD>(err)};
+            }
 
-    SMEventLoggerPtr _logger;
-    const string _prefix;
-};
+            //
+            // Get the filename of this DLL.
+            //
+            wchar_t path[_MAX_PATH];
+            assert(_module != 0);
+            if (!GetModuleFileNameW(_module, path, _MAX_PATH))
+            {
+                DWORD error = GetLastError();
+                RegCloseKey(hKey);
+                throw SyscallException{__FILE__, __LINE__, "GetModuleFileNameW failed", error};
+            }
 
-class SMEventLoggerI : public SMEventLogger
-{
-public:
+            //
+            // The event resources are bundled into this DLL, therefore
+            // the "EventMessageFile" key should contain the path to this
+            // DLL.
+            //
+            err = RegSetValueExW(
+                hKey,
+                L"EventMessageFile",
+                0,
+                REG_EXPAND_SZ,
+                reinterpret_cast<unsigned char*>(path),
+                static_cast<DWORD>((wcslen(path) * sizeof(wchar_t)) + 1));
+
+            if (err == ERROR_SUCCESS)
+            {
+                //
+                // The "TypesSupported" key indicates the supported event
+                // types.
+                //
+                DWORD typesSupported = EVENTLOG_ERROR_TYPE | EVENTLOG_WARNING_TYPE | EVENTLOG_INFORMATION_TYPE;
+                err = RegSetValueExW(
+                    hKey,
+                    L"TypesSupported",
+                    0,
+                    REG_DWORD,
+                    reinterpret_cast<unsigned char*>(&typesSupported),
+                    sizeof(typesSupported));
+            }
+            if (err != ERROR_SUCCESS)
+            {
+                RegCloseKey(hKey);
+                throw SyscallException{__FILE__, __LINE__, "RegSetValueExW failed", static_cast<DWORD>(err)};
+            }
 
-    SMEventLoggerI(const string& source, const StringConverterPtr& stringConverter) :
-        _stringConverter(stringConverter)
-    {
-        //
-        // Don't need to use a wide string converter as the wide string is passed
-        // to Windows API.
-        //
-        _source = RegisterEventSourceW(0, stringToWstring(mangleSource(source), _stringConverter).c_str());
-        if(_source == 0)
-        {
-            throw SyscallException(__FILE__, __LINE__, GetLastError());
+            RegCloseKey(hKey);
         }
-    }
-
-    ~SMEventLoggerI()
-    {
-        assert(_source != 0);
-        DeregisterEventSource(_source);
-    }
-
-    static void
-    addKeys(const string& source, const StringConverterPtr& stringConverter)
-    {
-        HKEY hKey;
-        DWORD d;
-        //
-        // Don't need to use a wide string converter as the wide string is passed
-        // to Windows API.
-        //
-        LONG err = RegCreateKeyExW(HKEY_LOCAL_MACHINE,
-                                   stringToWstring(createKey(source), stringConverter).c_str(),
-                                   0, const_cast<wchar_t*>(L"REG_SZ"), REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, 0, &hKey, &d);
 
-        if(err != ERROR_SUCCESS)
+        static void removeKeys(const string& source, const StringConverterPtr& stringConverter)
         {
-            throw SyscallException(__FILE__, __LINE__, err);
+            //
+            // Don't need to use a wide string converter as the wide string is passed
+            // to Windows API.
+            //
+            LSTATUS err =
+                RegDeleteKeyW(HKEY_LOCAL_MACHINE, stringToWstring(createKey(source), stringConverter).c_str());
+            if (err != ERROR_SUCCESS)
+            {
+                throw SyscallException{__FILE__, __LINE__, "RegDeleteKeyW failed", static_cast<DWORD>(err)};
+            }
         }
 
-        //
-        // Get the filename of this DLL.
-        //
-        wchar_t path[_MAX_PATH];
-        assert(_module != 0);
-        if(!GetModuleFileNameW(_module, path, _MAX_PATH))
+        virtual void print(const string& prefix, const string& message)
         {
-            RegCloseKey(hKey);
-            throw SyscallException(__FILE__, __LINE__, GetLastError());
+            string s;
+            if (!prefix.empty())
+            {
+                s = prefix;
+                s.append(": ");
+            }
+            s.append(message);
+            print(s);
         }
 
-        //
-        // The event resources are bundled into this DLL, therefore
-        // the "EventMessageFile" key should contain the path to this
-        // DLL.
-        //
-        err = RegSetValueExW(hKey, L"EventMessageFile", 0, REG_EXPAND_SZ, reinterpret_cast<unsigned char*>(path),
-                             static_cast<DWORD>((wcslen(path) * sizeof(wchar_t)) + 1));
-
-        if(err == ERROR_SUCCESS)
+        void print(const string& message)
         {
             //
-            // The "TypesSupported" key indicates the supported event
-            // types.
+            // Don't need to use a wide string converter as the wide string is passed
+            // to Windows API.
             //
-            DWORD typesSupported = EVENTLOG_ERROR_TYPE | EVENTLOG_WARNING_TYPE | EVENTLOG_INFORMATION_TYPE;
-            err = RegSetValueExW(hKey, L"TypesSupported", 0, REG_DWORD,
-                                 reinterpret_cast<unsigned char*>(&typesSupported), sizeof(typesSupported));
+            const wstring msg = stringToWstring(message, _stringConverter);
+            const wchar_t* messages[1];
+            messages[0] = msg.c_str();
+            //
+            // We ignore any failures from ReportEvent since there isn't
+            // anything we can do about it.
+            //
+            ReportEventW(_source, EVENTLOG_INFORMATION_TYPE, 0, EVENT_LOGGER_MSG, 0, 1, 0, messages, 0);
         }
-        if(err != ERROR_SUCCESS)
+
+        virtual void trace(const string& prefix, const string& category, const string& message)
         {
-            RegCloseKey(hKey);
-            throw SyscallException(__FILE__, __LINE__, err);
+            string s;
+            if (!category.empty())
+            {
+                s = category;
+                s.append(": ");
+            }
+            s.append(message);
+            trace(prefix, s);
         }
 
-        RegCloseKey(hKey);
-    }
-
-    static void
-    removeKeys(const string& source, const StringConverterPtr& stringConverter)
-    {
-        //
-        // Don't need to use a wide string converter as the wide string is passed
-        // to Windows API.
-        //
-        LONG err = RegDeleteKeyW(HKEY_LOCAL_MACHINE,
-            stringToWstring(createKey(source), stringConverter).c_str());
-        if(err != ERROR_SUCCESS)
+        void trace(const string& category, const string& message)
         {
-            throw SyscallException(__FILE__, __LINE__, err);
+            string s;
+            if (!category.empty())
+            {
+                s = category;
+                s.append(": ");
+            }
+            s.append(message);
+
+            //
+            // Don't need to use a wide string converter as the wide string is passed
+            // to Windows API.
+            //
+            wstring msg = stringToWstring(s, _stringConverter);
+            const wchar_t* messages[1];
+            messages[0] = msg.c_str();
+            //
+            // We ignore any failures from ReportEvent since there isn't
+            // anything we can do about it.
+            //
+            ReportEventW(_source, EVENTLOG_INFORMATION_TYPE, 0, EVENT_LOGGER_MSG, 0, 1, 0, messages, 0);
         }
-    }
 
-    virtual void
-    print(const string& prefix, const string& message)
-    {
-        string s;
-        if(!prefix.empty())
+        virtual void warning(const string& prefix, const string& message)
         {
-            s = prefix;
-            s.append(": ");
+            string s;
+            if (!prefix.empty())
+            {
+                s = prefix;
+                s.append(": ");
+            }
+            s.append(message);
+            warning(s);
         }
-        s.append(message);
-        print(s);
-    }
 
-    void
-    print(const string& message)
-    {
-        //
-        // Don't need to use a wide string converter as the wide string is passed
-        // to Windows API.
-        //
-        const wstring msg = stringToWstring(message, _stringConverter);
-        const wchar_t* messages[1];
-        messages[0] = msg.c_str();
-        //
-        // We ignore any failures from ReportEvent since there isn't
-        // anything we can do about it.
-        //
-        ReportEventW(_source, EVENTLOG_INFORMATION_TYPE, 0, EVENT_LOGGER_MSG, 0, 1, 0, messages, 0);
-    }
-
-    virtual void
-    trace(const string& prefix, const string& category, const string& message)
-    {
-        string s;
-        if(!category.empty())
+        void warning(const string& message)
         {
-            s = category;
-            s.append(": ");
+            //
+            // Don't need to use a wide string converter as the wide string is passed
+            // to Windows API.
+            //
+            wstring msg = stringToWstring(message, _stringConverter);
+            const wchar_t* messages[1];
+            messages[0] = msg.c_str();
+            //
+            // We ignore any failures from ReportEvent since there isn't
+            // anything we can do about it.
+            //
+            ReportEventW(_source, EVENTLOG_WARNING_TYPE, 0, EVENT_LOGGER_MSG, 0, 1, 0, messages, 0);
         }
-        s.append(message);
-        trace(prefix, s);
-    }
 
-    void
-    trace(const string& category, const string& message)
-    {
-        string s;
-        if(!category.empty())
+        virtual void error(const string& prefix, const string& message)
         {
-            s = category;
-            s.append(": ");
+            string s;
+            if (!prefix.empty())
+            {
+                s = prefix;
+                s.append(": ");
+            }
+            s.append(message);
+            error(s);
         }
-        s.append(message);
-
-        //
-        // Don't need to use a wide string converter as the wide string is passed
-        // to Windows API.
-        //
-        wstring msg = stringToWstring(s, _stringConverter);
-        const wchar_t* messages[1];
-        messages[0] = msg.c_str();
-        //
-        // We ignore any failures from ReportEvent since there isn't
-        // anything we can do about it.
-        //
-        ReportEventW(_source, EVENTLOG_INFORMATION_TYPE, 0, EVENT_LOGGER_MSG, 0, 1, 0, messages, 0);
-    }
 
-    virtual void
-    warning(const string& prefix, const string& message)
-    {
-        string s;
-        if(!prefix.empty())
+        void error(const string& message)
         {
-            s = prefix;
-            s.append(": ");
+            //
+            // Don't need to use a wide string converter as the wide string is passed
+            // to Windows API.
+            //
+            wstring msg = stringToWstring(message, _stringConverter);
+            const wchar_t* messages[1];
+            messages[0] = msg.c_str();
+            //
+            // We ignore any failures from ReportEvent since there isn't
+            // anything we can do about it.
+            //
+            ReportEventW(_source, EVENTLOG_ERROR_TYPE, 0, EVENT_LOGGER_MSG, 0, 1, 0, messages, 0);
         }
-        s.append(message);
-        warning(s);
-    }
 
-    void
-    warning(const string& message)
-    {
-        //
-        // Don't need to use a wide string converter as the wide string is passed
-        // to Windows API.
-        //
-        wstring msg = stringToWstring(message, _stringConverter);
-        const wchar_t* messages[1];
-        messages[0] = msg.c_str();
-        //
-        // We ignore any failures from ReportEvent since there isn't
-        // anything we can do about it.
-        //
-        ReportEventW(_source, EVENTLOG_WARNING_TYPE, 0, EVENT_LOGGER_MSG, 0, 1, 0, messages, 0);
-    }
+        static void setModuleHandle(HMODULE module) { _module = module; }
 
-    virtual void
-    error(const string& prefix, const string& message)
-    {
-        string s;
-        if(!prefix.empty())
+    private:
+        static string mangleSource(string name)
         {
-            s = prefix;
-            s.append(": ");
+            //
+            // The source name cannot contain backslashes.
+            //
+            string::size_type pos = 0;
+            while ((pos = name.find('\\', pos)) != string::npos)
+            {
+                name[pos] = '/';
+            }
+            return name;
         }
-        s.append(message);
-        error(s);
-    }
-
-    void
-    error(const string& message)
-    {
-        //
-        // Don't need to use a wide string converter as the wide string is passed
-        // to Windows API.
-        //
-        wstring msg = stringToWstring(message, _stringConverter);
-        const wchar_t* messages[1];
-        messages[0] = msg.c_str();
-        //
-        // We ignore any failures from ReportEvent since there isn't
-        // anything we can do about it.
-        //
-        ReportEventW(_source, EVENTLOG_ERROR_TYPE, 0, EVENT_LOGGER_MSG, 0, 1, 0, messages, 0);
-    }
-
-    static void
-    setModuleHandle(HMODULE module)
-    {
-        _module = module;
-    }
-
-private:
 
-    static string
-    mangleSource(string name)
-    {
-        //
-        // The source name cannot contain backslashes.
-        //
-        string::size_type pos = 0;
-        while((pos = name.find('\\', pos)) != string::npos)
+        static string createKey(string name)
         {
-            name[pos] = '/';
+            //
+            // The registry key is:
+            //
+            // HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\EventLog\Application.
+            //
+            return "SYSTEM\\CurrentControlSet\\Services\\EventLog\\Application\\" + mangleSource(name);
         }
-        return name;
-    }
-
-    static string
-    createKey(string name)
-    {
-        //
-        // The registry key is:
-        //
-        // HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\EventLog\Application.
-        //
-        return "SYSTEM\\CurrentControlSet\\Services\\EventLog\\Application\\" + mangleSource(name);
-    }
-
-    StringConverterPtr _stringConverter;
-    HANDLE _source;
-    static HMODULE _module;
-};
 
-HMODULE SMEventLoggerI::_module = 0;
+        StringConverterPtr _stringConverter;
+        HANDLE _source;
+        static HMODULE _module;
+    };
 
+    HMODULE SMEventLoggerI::_module = 0;
 }
 
 #endif
 
 Ice::Service::Service()
 {
-    assert(_instance == 0);
-    _nohup = true;
-    _service = false;
+    assert(_instance == nullptr);
     _instance = this;
-#ifndef _WIN32
-    _changeDirectory = true;
-    _closeFiles = true;
-#endif
 }
 
 Ice::Service::~Service()
 {
-    _instance = 0;
-    delete _ctrlCHandler;
+    _instance = nullptr;
+    delete ctrlCHandler;
 }
 
 bool
 Ice::Service::shutdown()
 {
-    if(_communicator)
+    if (_communicator)
     {
         try
         {
             _communicator->shutdown();
         }
-        catch(const CommunicatorDestroyedException&)
+        catch (const CommunicatorDestroyedException&)
         {
             //
             // Expected if the service communicator is being destroyed.
             //
         }
-        catch(const Ice::Exception& ex)
+        catch (const Ice::Exception& ex)
         {
             ServiceWarning warn(this);
             warn << "exception during shutdown:\n" << ex;
         }
-        catch(const std::exception& ex)
+        catch (const std::exception& ex)
         {
             ServiceWarning warn(this);
             warn << "exception during shutdown:\n" << ex;
         }
-        catch(...)
+        catch (...)
         {
             warning("unknown exception during shutdown");
         }
@@ -530,10 +467,10 @@ Ice::Service::interrupt()
 }
 
 int
-Ice::Service::main(int argc, const char* const argv[], const InitializationData& initializationData, int version)
+Ice::Service::main(int argc, const char* const argv[], InitializationData initData)
 {
     _name = "";
-    if(argc > 0)
+    if (argc > 0)
     {
         _name = argv[0];
     }
@@ -544,12 +481,11 @@ Ice::Service::main(int argc, const char* const argv[], const InitializationData&
     // We parse the properties here to extract Ice.ProgramName and
     // Ice.EventLog.Source on Windows.
     //
-    InitializationData initData = initializationData;
     try
     {
         initData.properties = createProperties(av.argc, av.argv, initData.properties);
     }
-    catch(const Ice::Exception& ex)
+    catch (const Ice::Exception& ex)
     {
         ServiceError err(this);
         err << "createProperties failed: " << ex;
@@ -564,13 +500,13 @@ Ice::Service::main(int argc, const char* const argv[], const InitializationData&
     string name;
     int idx = 1;
     const StringConverterPtr stringConverter = getProcessStringConverter();
-    while(idx < av.argc)
+    while (idx < av.argc)
     {
-        if(strcmp(av.argv[idx], "--service") == 0)
+        if (strcmp(av.argv[idx], "--service") == 0)
         {
-            if(idx + 1 >= av.argc)
+            if (idx + 1 >= av.argc)
             {
-                error("service name argument expected for `" + string(av.argv[idx]) + "'");
+                error("service name argument expected for '" + string(av.argv[idx]) + "'");
                 return EXIT_FAILURE;
             }
 
@@ -581,14 +517,20 @@ Ice::Service::main(int argc, const char* const argv[], const InitializationData&
             // our own logger.
             //
             _logger = getProcessLogger();
-            if(ICE_DYNAMIC_CAST(LoggerI, _logger))
+            if (dynamic_pointer_cast<LoggerI>(_logger))
             {
-                string eventLogSource = initData.properties->getPropertyWithDefault("Ice.EventLog.Source", name);
-                _logger = ICE_MAKE_SHARED(SMEventLoggerIWrapper, new SMEventLoggerI(eventLogSource, stringConverter), "");
+                string eventLogSource = initData.properties->getIceProperty("Ice.EventLog.Source");
+                if (eventLogSource.empty())
+                {
+                    eventLogSource = name;
+                }
+                _logger = make_shared<SMEventLoggerIWrapper>(
+                    make_shared<SMEventLoggerI>(eventLogSource, stringConverter),
+                    "");
                 setProcessLogger(_logger);
             }
 
-            for(int i = idx; i + 2 < av.argc; ++i)
+            for (int i = idx; i + 2 < av.argc; ++i)
             {
                 av.argv[i] = av.argv[i + 2];
             }
@@ -600,7 +542,7 @@ Ice::Service::main(int argc, const char* const argv[], const InitializationData&
         }
     }
 
-    if(!name.empty())
+    if (!name.empty())
     {
         configureService(name);
     }
@@ -614,11 +556,11 @@ Ice::Service::main(int argc, const char* const argv[], const InitializationData&
     bool changeDirectory = true;
     string pidFile;
     int idx = 1;
-    while(idx < av.argc)
+    while (idx < av.argc)
     {
-        if(strcmp(av.argv[idx], "--daemon") == 0)
+        if (strcmp(av.argv[idx], "--daemon") == 0)
         {
-            for(int i = idx; i + 1 < av.argc; ++i)
+            for (int i = idx; i + 1 < av.argc; ++i)
             {
                 av.argv[i] = av.argv[i + 1];
             }
@@ -626,9 +568,9 @@ Ice::Service::main(int argc, const char* const argv[], const InitializationData&
 
             daemonize = true;
         }
-        else if(strcmp(av.argv[idx], "--noclose") == 0)
+        else if (strcmp(av.argv[idx], "--noclose") == 0)
         {
-            for(int i = idx; i + 1 < av.argc; ++i)
+            for (int i = idx; i + 1 < av.argc; ++i)
             {
                 av.argv[i] = av.argv[i + 1];
             }
@@ -636,9 +578,9 @@ Ice::Service::main(int argc, const char* const argv[], const InitializationData&
 
             closeFiles = false;
         }
-        else if(strcmp(av.argv[idx], "--nochdir") == 0)
+        else if (strcmp(av.argv[idx], "--nochdir") == 0)
         {
-            for(int i = idx; i + 1 < av.argc; ++i)
+            for (int i = idx; i + 1 < av.argc; ++i)
             {
                 av.argv[i] = av.argv[i + 1];
             }
@@ -646,15 +588,15 @@ Ice::Service::main(int argc, const char* const argv[], const InitializationData&
 
             changeDirectory = false;
         }
-        else if(strcmp(av.argv[idx], "--pidfile") == 0)
+        else if (strcmp(av.argv[idx], "--pidfile") == 0)
         {
-            if(idx + 1 < av.argc)
+            if (idx + 1 < av.argc)
             {
                 pidFile = av.argv[idx + 1];
             }
             else
             {
-                if(av.argv[0])
+                if (av.argv[0])
                 {
                     consoleErr << av.argv[0] << ": ";
                 }
@@ -662,7 +604,7 @@ Ice::Service::main(int argc, const char* const argv[], const InitializationData&
                 return EXIT_FAILURE;
             }
 
-            for(int i = idx; i + 2 < av.argc; ++i)
+            for (int i = idx; i + 2 < av.argc; ++i)
             {
                 av.argv[i] = av.argv[i + 2];
             }
@@ -674,9 +616,9 @@ Ice::Service::main(int argc, const char* const argv[], const InitializationData&
         }
     }
 
-    if(!closeFiles && !daemonize)
+    if (!closeFiles && !daemonize)
     {
-        if(av.argv[0])
+        if (av.argv[0])
         {
             consoleErr << av.argv[0] << ": ";
         }
@@ -684,9 +626,9 @@ Ice::Service::main(int argc, const char* const argv[], const InitializationData&
         return EXIT_FAILURE;
     }
 
-    if(pidFile.size() > 0 && !daemonize)
+    if (pidFile.size() > 0 && !daemonize)
     {
-        if(av.argv[0])
+        if (av.argv[0])
         {
             consoleErr << av.argv[0] << ": ";
         }
@@ -694,7 +636,7 @@ Ice::Service::main(int argc, const char* const argv[], const InitializationData&
         return EXIT_FAILURE;
     }
 
-    if(daemonize)
+    if (daemonize)
     {
         configureDaemon(changeDirectory, closeFiles, pidFile);
     }
@@ -705,36 +647,35 @@ Ice::Service::main(int argc, const char* const argv[], const InitializationData&
     // process logger is the default logger, we change it to a logger which is
     // using the program name for the prefix.
     //
-    if(!_logger)
+    if (!_logger)
     {
         _logger = getProcessLogger();
-        if(ICE_DYNAMIC_CAST(LoggerI, _logger))
+        if (dynamic_pointer_cast<LoggerI>(_logger))
         {
-            const bool convert =
-                initData.properties->getPropertyAsIntWithDefault("Ice.LogStdErr.Convert", 1) > 0 &&
-                initData.properties->getProperty("Ice.StdErr").empty();
+            const bool convert = initData.properties->getIcePropertyAsInt("Ice.LogStdErr.Convert") > 0 &&
+                                 initData.properties->getIceProperty("Ice.StdErr").empty();
 
-            _logger = ICE_MAKE_SHARED(LoggerI, initData.properties->getProperty("Ice.ProgramName"), "", convert);
+            _logger = make_shared<LoggerI>(initData.properties->getIceProperty("Ice.ProgramName"), "", convert);
             setProcessLogger(_logger);
         }
     }
 
-    return run(av.argc, av.argv, initData, version);
+    return run(av.argc, av.argv, std::move(initData));
 }
 
 #ifdef _WIN32
 int
-Ice::Service::main(int argc, const wchar_t* const argv[], const InitializationData& initializationData, int version)
+Ice::Service::main(int argc, const wchar_t* const argv[], InitializationData initData)
 {
-    return main(Ice::argsToStringSeq(argc, argv), initializationData, version);
+    return main(Ice::argsToStringSeq(argc, argv), std::move(initData));
 }
 #endif
 
 int
-Ice::Service::main(const StringSeq& args, const InitializationData& initData, int version)
+Ice::Service::main(const StringSeq& args, InitializationData initData)
 {
     IceInternal::ArgVector av(args);
-    return main(av.argc, av.argv, initData, version);
+    return main(av.argc, av.argv, std::move(initData));
 }
 
 Ice::CommunicatorPtr
@@ -761,27 +702,17 @@ Ice::Service::name() const
     return _name;
 }
 
-#ifdef _WIN32
 int
-Ice::Service::run(int argc, const wchar_t* const argv[], const InitializationData& initData, int version)
-{
-    StringSeq args = Ice::argsToStringSeq(argc, argv);
-    IceInternal::ArgVector av(args);
-    return run(av.argc, av.argv, initData, version);
-}
-#endif
-
-int
-Ice::Service::run(int argc, const char* const argv[], const InitializationData& initData, int version)
+Ice::Service::run(int argc, const char* const argv[], InitializationData initData)
 {
     IceInternal::ArgVector av(argc, argv); // copy args
 
-    if(_service)
+    if (_service)
     {
 #ifdef _WIN32
-        return runService(av.argc, av.argv, initData);
+        return runService(av.argc, av.argv, std::move(initData));
 #else
-        return runDaemon(av.argc, av.argv, initData, version);
+        return runDaemon(av.argc, av.argv, std::move(initData));
 #endif
     }
 
@@ -797,12 +728,12 @@ Ice::Service::run(int argc, const char* const argv[], const InitializationData&
         // communicator because we need to ensure that this is done before any
         // additional threads are created.
         //
-        _ctrlCHandler = new IceUtil::CtrlCHandler;
+        ctrlCHandler = new CtrlCHandler;
 
         //
         // Initialize the communicator.
         //
-        _communicator = initializeCommunicator(av.argc, av.argv, initData, version);
+        _communicator = initializeCommunicator(av.argc, av.argv, std::move(initData));
 
         //
         // Use the configured logger.
@@ -812,12 +743,12 @@ Ice::Service::run(int argc, const char* const argv[], const InitializationData&
         //
         // Determines whether we ignore SIGHUP/CTRL_LOGOFF_EVENT.
         //
-        _nohup = _communicator->getProperties()->getPropertyAsIntWithDefault("Ice.Nohup", 1) > 0;
+        _nohup = _communicator->getProperties()->getIcePropertyAsInt("Ice.Nohup") > 0;
 
         //
         // Start the service.
         //
-        if(start(av.argc, av.argv, status))
+        if (start(av.argc, av.argv, status))
         {
 #ifdef ICE_USE_SYSTEMD
             sd_notify(0, "READY=1");
@@ -836,13 +767,13 @@ Ice::Service::run(int argc, const char* const argv[], const InitializationData&
             //
             // Stop the service.
             //
-            if(stop())
+            if (stop())
             {
                 status = EXIT_SUCCESS;
             }
         }
     }
-    catch(const Ice::Exception& ex)
+    catch (const Ice::Exception& ex)
     {
         ServiceError err(this);
         err << "service terminating after catching exception:\n" << ex;
@@ -851,7 +782,7 @@ Ice::Service::run(int argc, const char* const argv[], const InitializationData&
         sd_notifyf(0, "STATUS=Failed service terminating after catching exception: %s", msg.c_str());
 #endif
     }
-    catch(const std::exception& ex)
+    catch (const std::exception& ex)
     {
         ServiceError err(this);
         err << "service terminating after catching exception:\n" << ex;
@@ -860,23 +791,7 @@ Ice::Service::run(int argc, const char* const argv[], const InitializationData&
         sd_notifyf(0, "STATUS=Failed service terminating after catching exception: %s", msg.c_str());
 #endif
     }
-    catch(const std::string& msg)
-    {
-        ServiceError err(this);
-        err << "service terminating after catching exception:\n" << msg;
-#ifdef ICE_USE_SYSTEMD
-        sd_notifyf(0, "STATUS=Failed service terminating after catching exception: %s", msg.c_str());
-#endif
-    }
-    catch(const char* msg)
-    {
-        ServiceError err(this);
-        err << "service terminating after catching exception:\n" << msg;
-#ifdef ICE_USE_SYSTEMD
-        sd_notifyf(0, "STATUS=Failed service terminating after catching exception: %s", msg);
-#endif
-    }
-    catch(...)
+    catch (...)
     {
         error("service terminating after catching unknown exception");
 #ifdef ICE_USE_SYSTEMD
@@ -884,7 +799,7 @@ Ice::Service::run(int argc, const char* const argv[], const InitializationData&
 #endif
     }
 
-    if(_communicator)
+    if (_communicator)
     {
         _communicator->destroy();
     }
@@ -924,12 +839,12 @@ void
 Ice::Service::handleInterrupt(int sig)
 {
 #ifdef _WIN32
-    if(_nohup && sig == CTRL_LOGOFF_EVENT)
+    if (_nohup && sig == CTRL_LOGOFF_EVENT)
     {
         return;
     }
 #else
-    if(_nohup && sig == SIGHUP)
+    if (_nohup && sig == SIGHUP)
     {
         return;
     }
@@ -941,7 +856,7 @@ Ice::Service::handleInterrupt(int sig)
 void
 Ice::Service::waitForShutdown()
 {
-    if(_communicator)
+    if (_communicator)
     {
         enableInterrupt();
         _communicator->waitForShutdown();
@@ -956,23 +871,24 @@ Ice::Service::stop()
 }
 
 Ice::CommunicatorPtr
-Ice::Service::initializeCommunicator(int& argc, char* argv[], const InitializationData& initData, int version)
+Ice::Service::initializeCommunicator(int& argc, char* argv[], InitializationData initData)
 {
-    return Ice::initialize(argc, argv, initData, version);
+    initData.properties = createProperties(argc, argv, initData.properties);
+    return Ice::initialize(std::move(initData));
 }
 
 void
 Ice::Service::syserror(const string& msg)
 {
-    string errmsg = IceUtilInternal::lastErrorToString();
-    if(_logger)
+    string errmsg = IceInternal::lastErrorToString();
+    if (_logger)
     {
         ostringstream ostr;
-        if(!msg.empty())
+        if (!msg.empty())
         {
             ostr << msg << endl;
         }
-        if(!errmsg.empty())
+        if (!errmsg.empty())
         {
             ostr << errmsg;
         }
@@ -980,15 +896,15 @@ Ice::Service::syserror(const string& msg)
     }
     else
     {
-        if(!_name.empty())
+        if (!_name.empty())
         {
             consoleErr << _name << ": ";
         }
-        if(!msg.empty())
+        if (!msg.empty())
         {
             consoleErr << msg << endl;
         }
-        if(!errmsg.empty())
+        if (!errmsg.empty())
         {
             consoleErr << errmsg;
         }
@@ -998,13 +914,13 @@ Ice::Service::syserror(const string& msg)
 void
 Ice::Service::error(const string& msg)
 {
-    if(_logger)
+    if (_logger)
     {
         _logger->error(msg);
     }
     else
     {
-        if(!_name.empty())
+        if (!_name.empty())
         {
             consoleErr << _name << ": ";
         }
@@ -1015,13 +931,13 @@ Ice::Service::error(const string& msg)
 void
 Ice::Service::warning(const string& msg)
 {
-    if(_logger)
+    if (_logger)
     {
         _logger->warning(msg);
     }
     else
     {
-        if(!_name.empty())
+        if (!_name.empty())
         {
             consoleErr << _name << ": ";
         }
@@ -1032,7 +948,7 @@ Ice::Service::warning(const string& msg)
 void
 Ice::Service::trace(const string& msg)
 {
-    if(_logger)
+    if (_logger)
     {
         _logger->trace("", msg);
     }
@@ -1045,7 +961,7 @@ Ice::Service::trace(const string& msg)
 void
 Ice::Service::print(const string& msg)
 {
-    if(_logger)
+    if (_logger)
     {
         _logger->print(msg);
     }
@@ -1058,23 +974,23 @@ Ice::Service::print(const string& msg)
 void
 Ice::Service::enableInterrupt()
 {
-    _ctrlCHandler->setCallback(ctrlCHandlerCallback);
+    ctrlCHandler->setCallback(ctrlCHandlerCallback);
 }
 
 void
 Ice::Service::disableInterrupt()
 {
-    _ctrlCHandler->setCallback(0);
+    ctrlCHandler->setCallback(nullptr);
 }
 
 #ifdef _WIN32
 
 int
-Ice::Service::runService(int argc, const char* const argv[], const InitializationData& initData)
+Ice::Service::runService(int argc, const char* const argv[], InitializationData initData)
 {
     assert(_service);
 
-    if(_name.empty())
+    if (_name.empty())
     {
         error("invalid name for Win32 service");
         return EXIT_FAILURE;
@@ -1084,28 +1000,27 @@ Ice::Service::runService(int argc, const char* const argv[], const Initializatio
     // Arguments passed to the executable are not passed to the service's main function,
     // so save them now and serviceMain will merge them later.
     //
-    for(int idx = 1; idx < argc; ++idx)
+    for (int idx = 1; idx < argc; ++idx)
     {
         _serviceArgs.push_back(argv[idx]);
     }
 
-    _initData = initData;
+    _initData = std::move(initData);
 
     //
     // Don't need to use a wide string converter as the wide string is passed
     // to Windows API.
     //
     const wstring serviceName = stringToWstring(_name, getProcessStringConverter());
-    SERVICE_TABLE_ENTRYW ste[] =
-    {
-        { const_cast<wchar_t*>(serviceName.c_str()), Ice_Service_ServiceMain },
-        { 0, 0 },
+    SERVICE_TABLE_ENTRYW ste[] = {
+        {const_cast<wchar_t*>(serviceName.c_str()), Ice_Service_ServiceMain},
+        {0, 0},
     };
 
     //
     // Start the service.
     //
-    if(!StartServiceCtrlDispatcherW(ste))
+    if (!StartServiceCtrlDispatcherW(ste))
     {
         syserror("unable to start service control dispatcher");
         return EXIT_FAILURE;
@@ -1126,7 +1041,7 @@ Ice::Service::terminateService(DWORD exitCode)
     status.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
     status.dwCurrentState = SERVICE_STOPPED;
     status.dwControlsAccepted = 0;
-    if(exitCode != 0)
+    if (exitCode != 0)
     {
         status.dwWin32ExitCode = ERROR_SERVICE_SPECIFIC_ERROR;
     }
@@ -1144,7 +1059,7 @@ Ice::Service::terminateService(DWORD exitCode)
 bool
 Ice::Service::waitForServiceState(SC_HANDLE hService, DWORD pendingState, SERVICE_STATUS& status)
 {
-    if(!QueryServiceStatus(hService, &status))
+    if (!QueryServiceStatus(hService, &status))
     {
         return false;
     }
@@ -1158,7 +1073,7 @@ Ice::Service::waitForServiceState(SC_HANDLE hService, DWORD pendingState, SERVIC
     //
     // Loop while the service is in the pending state.
     //
-    while(status.dwCurrentState == pendingState)
+    while (status.dwCurrentState == pendingState)
     {
         //
         // Do not wait longer than the wait hint. A good interval is
@@ -1168,11 +1083,11 @@ Ice::Service::waitForServiceState(SC_HANDLE hService, DWORD pendingState, SERVIC
 
         DWORD waitTime = status.dwWaitHint / 10;
 
-        if(waitTime < 1000)
+        if (waitTime < 1000)
         {
             waitTime = 1000;
         }
-        else if(waitTime > 10000)
+        else if (waitTime > 10000)
         {
             waitTime = 10000;
         }
@@ -1182,12 +1097,12 @@ Ice::Service::waitForServiceState(SC_HANDLE hService, DWORD pendingState, SERVIC
         //
         // Check the status again.
         //
-        if(!QueryServiceStatus(hService, &status))
+        if (!QueryServiceStatus(hService, &status))
         {
             return false;
         }
 
-        if(status.dwCheckPoint > oldCheckPoint)
+        if (status.dwCheckPoint > oldCheckPoint)
         {
             //
             // The service is making progress.
@@ -1197,7 +1112,7 @@ Ice::Service::waitForServiceState(SC_HANDLE hService, DWORD pendingState, SERVIC
         }
         else
         {
-            if(GetTickCount() - startTickCount > status.dwWaitHint)
+            if (GetTickCount() - startTickCount > status.dwWaitHint)
             {
                 //
                 // No progress made within the wait hint.
@@ -1214,53 +1129,50 @@ void
 Ice::Service::showServiceStatus(const string& msg, SERVICE_STATUS& status)
 {
     string state;
-    switch(status.dwCurrentState)
-    {
-    case SERVICE_STOPPED:
-        state = "STOPPED";
-        break;
-    case SERVICE_START_PENDING:
-        state = "START PENDING";
-        break;
-    case SERVICE_STOP_PENDING:
-        state = "STOP PENDING";
-        break;
-    case SERVICE_RUNNING:
-        state = "RUNNING";
-        break;
-    case SERVICE_CONTINUE_PENDING:
-        state = "CONTINUE PENDING";
-        break;
-    case SERVICE_PAUSE_PENDING:
-        state = "PAUSE PENDING";
-        break;
-    case SERVICE_PAUSED:
-        state = "PAUSED";
-        break;
-    default:
-        state = "UNKNOWN";
-        break;
+    switch (status.dwCurrentState)
+    {
+        case SERVICE_STOPPED:
+            state = "STOPPED";
+            break;
+        case SERVICE_START_PENDING:
+            state = "START PENDING";
+            break;
+        case SERVICE_STOP_PENDING:
+            state = "STOP PENDING";
+            break;
+        case SERVICE_RUNNING:
+            state = "RUNNING";
+            break;
+        case SERVICE_CONTINUE_PENDING:
+            state = "CONTINUE PENDING";
+            break;
+        case SERVICE_PAUSE_PENDING:
+            state = "PAUSE PENDING";
+            break;
+        case SERVICE_PAUSED:
+            state = "PAUSED";
+            break;
+        default:
+            state = "UNKNOWN";
+            break;
     }
 
     ServiceTrace tr(this);
-    tr << msg
-       << "\n  Current state: " << state
-       << "\n  Exit code: " << status.dwWin32ExitCode
+    tr << msg << "\n  Current state: " << state << "\n  Exit code: " << status.dwWin32ExitCode
        << "\n  Service specific exit code: " << status.dwServiceSpecificExitCode
-       << "\n  Check point: " << status.dwCheckPoint
-       << "\n  Wait hint: " << status.dwWaitHint;
+       << "\n  Check point: " << status.dwCheckPoint << "\n  Wait hint: " << status.dwWaitHint;
 }
 
 void
 Ice::Service::serviceMain(int argc, const wchar_t* const argv[])
 {
-    _ctrlCHandler = new IceUtil::CtrlCHandler;
+    ctrlCHandler = new CtrlCHandler;
 
     //
     // Register the control handler function.
     //
     _statusHandle = RegisterServiceCtrlHandlerW(argv[0], Ice_Service_CtrlHandler);
-    if(_statusHandle == 0)
+    if (_statusHandle == 0)
     {
         syserror("unable to register service control handler");
         return;
@@ -1279,7 +1191,7 @@ Ice::Service::serviceMain(int argc, const wchar_t* const argv[])
     // Don't need to pass a wide string converter in the argv conversions
     // as argv come from Windows API.
     //
-    const IceUtil::StringConverterPtr converter = IceUtil::getProcessStringConverter();
+    const Ice::StringConverterPtr converter = Ice::getProcessStringConverter();
 
     //
     // Merge the executable's arguments with the service's arguments.
@@ -1293,7 +1205,7 @@ Ice::Service::serviceMain(int argc, const wchar_t* const argv[])
     args[0] = const_cast<char*>(serviceName.c_str());
 
     int i = 1;
-    for(vector<string>::iterator p = _serviceArgs.begin(); p != _serviceArgs.end(); ++p)
+    for (vector<string>::iterator p = _serviceArgs.begin(); p != _serviceArgs.end(); ++p)
     {
         args[i++] = const_cast<char*>(p->c_str());
     }
@@ -1303,13 +1215,13 @@ Ice::Service::serviceMain(int argc, const wchar_t* const argv[])
     // the converted sequence into the args array.
     //
     vector<string> executableArgs;
-    for(int j = 1; j < argc; ++j)
+    for (int j = 1; j < argc; ++j)
     {
-        executableArgs.push_back(IceUtil::wstringToString(argv[j], converter));
+        executableArgs.push_back(Ice::wstringToString(argv[j], converter));
     }
-    for(vector<string>::iterator p = executableArgs.begin(); p != executableArgs.end(); ++p)
+    for (vector<string>::iterator p = executableArgs.begin(); p != executableArgs.end(); ++p)
     {
-         args[i++] = const_cast<char*>(p->c_str());
+        args[i++] = const_cast<char*>(p->c_str());
     }
     argc += static_cast<int>(_serviceArgs.size());
 
@@ -1318,9 +1230,9 @@ Ice::Service::serviceMain(int argc, const wchar_t* const argv[])
     //
     try
     {
-        _communicator = initializeCommunicator(argc, args, _initData, ICE_INT_VERSION);
+        _communicator = initializeCommunicator(argc, args, _initData);
     }
-    catch(const Ice::Exception& ex)
+    catch (const Ice::Exception& ex)
     {
         delete[] args;
         {
@@ -1330,7 +1242,7 @@ Ice::Service::serviceMain(int argc, const wchar_t* const argv[])
         terminateService(EXIT_FAILURE);
         return;
     }
-    catch(...)
+    catch (...)
     {
         delete[] args;
         error("unknown exception occurred while initializing a communicator");
@@ -1346,13 +1258,13 @@ Ice::Service::serviceMain(int argc, const wchar_t* const argv[])
     //
     // Determines whether we ignore SIGHUP/CTRL_LOGOFF_EVENT.
     //
-    _nohup = _communicator->getProperties()->getPropertyAsIntWithDefault("Ice.Nohup", 1) > 0;
+    _nohup = _communicator->getProperties()->getIcePropertyAsInt("Ice.Nohup") > 0;
 
     DWORD status = EXIT_FAILURE;
     try
     {
         int tmpStatus = EXIT_FAILURE;
-        if(start(argc, args, tmpStatus))
+        if (start(argc, args, tmpStatus))
         {
             trace("Service started successfully.");
 
@@ -1370,7 +1282,7 @@ Ice::Service::serviceMain(int argc, const wchar_t* const argv[])
             //
             // Give the service a chance to clean up.
             //
-            if(stop())
+            if (stop())
             {
                 status = EXIT_SUCCESS;
             }
@@ -1380,17 +1292,17 @@ Ice::Service::serviceMain(int argc, const wchar_t* const argv[])
             status = tmpStatus;
         }
     }
-    catch(const Ice::Exception& ex)
+    catch (const Ice::Exception& ex)
     {
         ServiceError err(this);
         err << "service terminating after catching exception:\n" << ex;
     }
-    catch(const std::exception& ex)
+    catch (const std::exception& ex)
     {
         ServiceError err(this);
         err << "service terminating after catching exception:\n" << ex;
     }
-    catch(...)
+    catch (...)
     {
         error("service terminating after catching unknown exception");
     }
@@ -1408,31 +1320,30 @@ Ice::Service::control(int ctrl)
 {
     assert(serviceStatusManager);
 
-    switch(ctrl)
-    {
-    case SERVICE_CONTROL_SHUTDOWN:
-    case SERVICE_CONTROL_STOP:
-    {
-        serviceStatusManager->startUpdate(SERVICE_STOP_PENDING);
-        shutdown();
-        break;
-    }
-    default:
+    switch (ctrl)
     {
-        if(ctrl != SERVICE_CONTROL_INTERROGATE)
+        case SERVICE_CONTROL_SHUTDOWN:
+        case SERVICE_CONTROL_STOP:
         {
-            ServiceError err(this);
-            err << "unrecognized service control code " << ctrl;
+            serviceStatusManager->startUpdate(SERVICE_STOP_PENDING);
+            shutdown();
+            break;
         }
+        default:
+        {
+            if (ctrl != SERVICE_CONTROL_INTERROGATE)
+            {
+                ServiceError err(this);
+                err << "unrecognized service control code " << ctrl;
+            }
 
-        serviceStatusManager->reportStatus();
-        break;
-    }
+            serviceStatusManager->reportStatus();
+            break;
+        }
     }
 }
 
-ServiceStatusManager::ServiceStatusManager(SERVICE_STATUS_HANDLE handle) :
-    _handle(handle), _stopped(false)
+ServiceStatusManager::ServiceStatusManager(SERVICE_STATUS_HANDLE handle) : _handle(handle), _stopped(false)
 {
     _status.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
     _status.dwControlsAccepted = 0;
@@ -1445,47 +1356,42 @@ ServiceStatusManager::ServiceStatusManager(SERVICE_STATUS_HANDLE handle) :
 void
 ServiceStatusManager::startUpdate(DWORD state)
 {
-    Lock sync(*this);
+    lock_guard lock(_mutex);
 
     assert(state == SERVICE_START_PENDING || state == SERVICE_STOP_PENDING);
-    assert(!_thread);
+    assert(!_thread.joinable());
 
     _status.dwCurrentState = state;
     _status.dwControlsAccepted = 0; // Don't accept any other control messages while pending.
 
     _stopped = false;
 
-    _thread = new StatusThread(this);
-    _thread->start();
+    _thread = std::thread(&ServiceStatusManager::run, this);
 }
 
 void
 ServiceStatusManager::stopUpdate()
 {
-    IceUtil::ThreadPtr thread;
+    std::thread thread;
 
     {
-        Lock sync(*this);
+        lock_guard lock(_mutex);
 
-        if(_thread)
+        if (_thread.joinable())
         {
             _stopped = true;
-            notify();
-            thread = _thread;
-            _thread = 0;
+            _conditionVariable.notify_one();
+            thread = std::move(_thread);
         }
     }
 
-    if(thread)
-    {
-        thread->getThreadControl().join();
-    }
+    thread.join();
 }
 
 void
 ServiceStatusManager::changeStatus(DWORD state, DWORD controlsAccepted)
 {
-    Lock sync(*this);
+    lock_guard lock(_mutex);
 
     _status.dwCurrentState = state;
     _status.dwControlsAccepted = controlsAccepted;
@@ -1496,7 +1402,7 @@ ServiceStatusManager::changeStatus(DWORD state, DWORD controlsAccepted)
 void
 ServiceStatusManager::reportStatus()
 {
-    Lock sync(*this);
+    lock_guard lock(_mutex);
 
     SetServiceStatus(_handle, &_status);
 }
@@ -1504,24 +1410,24 @@ ServiceStatusManager::reportStatus()
 void
 ServiceStatusManager::run()
 {
-    Lock sync(*this);
+    unique_lock lock(_mutex);
 
-    IceUtil::Time delay = IceUtil::Time::milliSeconds(1000);
+    auto delay = chrono::milliseconds(1000);
     _status.dwWaitHint = 2000;
     _status.dwCheckPoint = 0;
 
-    while(!_stopped)
+    while (!_stopped)
     {
         _status.dwCheckPoint++;
         SetServiceStatus(_handle, &_status);
-        timedWait(delay);
+        _conditionVariable.wait_for(lock, delay);
     }
 }
 
 #else
 
 int
-Ice::Service::runDaemon(int argc, char* argv[], const InitializationData& initData, int version)
+Ice::Service::runDaemon(int argc, char* argv[], InitializationData initData)
 {
     assert(_service);
 
@@ -1535,17 +1441,17 @@ Ice::Service::runDaemon(int argc, char* argv[], const InitializationData& initDa
     // Fork the child.
     //
     pid_t pid = fork();
-    if(pid < 0)
+    if (pid < 0)
     {
-        if(argv[0])
+        if (argv[0])
         {
             consoleErr << argv[0] << ": ";
         }
-        consoleErr << IceUtilInternal::errorToString(errno) << endl;
+        consoleErr << IceInternal::errorToString(errno) << endl;
         return EXIT_FAILURE;
     }
 
-    if(pid != 0)
+    if (pid != 0)
     {
         //
         // Parent process.
@@ -1561,26 +1467,26 @@ Ice::Service::runDaemon(int argc, char* argv[], const InitializationData& initDa
         // is ready to receive requests, or that an error occurred.
         //
         char c = 0;
-        while(true)
+        while (true)
         {
-            if(read(fds[0], &c, 1) == -1)
+            if (read(fds[0], &c, 1) == -1)
             {
-                if(IceInternal::interrupted())
+                if (IceInternal::interrupted())
                 {
                     continue;
                 }
 
-                if(argv[0])
+                if (argv[0])
                 {
                     consoleErr << argv[0] << ": ";
                 }
-                consoleErr << IceUtilInternal::errorToString(errno) << endl;
+                consoleErr << IceInternal::errorToString(errno) << endl;
                 _exit(EXIT_FAILURE);
             }
             break;
         }
 
-        if(c != 0)
+        if (c != 0)
         {
             //
             // Read an error message.
@@ -1588,24 +1494,25 @@ Ice::Service::runDaemon(int argc, char* argv[], const InitializationData& initDa
             ssize_t rs;
             char s[16];
             string message;
-            while((rs = read(fds[0], &s, 16)) > 0)
+            while ((rs = read(fds[0], &s, 16)) > 0)
             {
                 message.append(s, static_cast<size_t>(rs));
             }
 
-            if(argv[0])
+            if (argv[0])
             {
                 consoleErr << argv[0] << ": ";
             }
 
-            if(rs == -1)
+            if (rs == -1)
             {
-                consoleErr << "I/O error while reading error message from child:\n" << IceUtilInternal::errorToString(errno);
+                consoleErr << "I/O error while reading error message from child:\n"
+                           << IceInternal::errorToString(errno);
             }
             else
             {
                 consoleErr << "failure occurred in daemon";
-                if(!message.empty())
+                if (!message.empty())
                 {
                     consoleErr << ":\n" << message;
                 }
@@ -1628,43 +1535,43 @@ Ice::Service::runDaemon(int argc, char* argv[], const InitializationData& initDa
         //
         // Become a session and process group leader.
         //
-        if(setsid() == -1)
+        if (setsid() == -1)
         {
-            throw SyscallException(__FILE__, __LINE__, IceInternal::getSystemErrno());
+            throw SyscallException{__FILE__, __LINE__, "setsid failed", errno};
         }
 
         //
         // Ignore SIGHUP so that the grandchild process is not sent SIGHUP when this
         // process exits.
         //
-        signal(SIGHUP, SIG_IGN);
+        signal(SIGHUP, SIG_IGN); // NOLINT(cert-err33-c)
 
         //
         // Fork again to eliminate the possibility of acquiring a controlling terminal.
         //
         pid = fork();
-        if(pid < 0)
+        if (pid < 0)
         {
-            throw SyscallException(__FILE__, __LINE__, IceInternal::getSystemErrno());
+            throw SyscallException{__FILE__, __LINE__, "fork failed", errno};
         }
-        if(pid != 0)
+        if (pid != 0)
         {
             exit(0);
         }
 
-        if(_changeDirectory)
+        if (_changeDirectory)
         {
             //
             // Change the working directory.
             //
-            if(chdir("/") != 0)
+            if (chdir("/") != 0)
             {
-                throw SyscallException(__FILE__, __LINE__, IceInternal::getSystemErrno());
+                throw SyscallException{__FILE__, __LINE__, "chdir failed", errno};
             }
         }
 
         vector<int> fdsToClose;
-        if(_closeFiles)
+        if (_closeFiles)
         {
             //
             // Take a snapshot of the open file descriptors. We don't actually close these
@@ -1673,21 +1580,21 @@ Ice::Service::runDaemon(int argc, char* argv[], const InitializationData& initDa
             // conveniently allows the Ice.PrintProcessId property to work as expected.
             //
             int fdMax = static_cast<int>(sysconf(_SC_OPEN_MAX));
-            if(fdMax <= 0)
+            if (fdMax <= 0)
             {
-                throw SyscallException(__FILE__, __LINE__, IceInternal::getSystemErrno());
+                throw SyscallException{__FILE__, __LINE__, "sysconf failed", errno};
             }
 
-            for(int i = 0; i < fdMax; ++i)
+            for (int i = 0; i < fdMax; ++i)
             {
-                if(fcntl(i, F_GETFL) != -1)
+                if (fcntl(i, F_GETFL) != -1)
                 {
                     //
                     // Don't close the write end of the pipe.
                     //
-                    if(i != fds[1])
+                    if (i != fds[1])
                     {
-                       fdsToClose.push_back(i);
+                        fdsToClose.push_back(i);
                     }
                 }
             }
@@ -1700,32 +1607,32 @@ Ice::Service::runDaemon(int argc, char* argv[], const InitializationData& initDa
         // communicator thread pools currently use lazy initialization, but a thread can
         // be created to monitor connections.
         //
-        _ctrlCHandler = new IceUtil::CtrlCHandler;
+        ctrlCHandler = new CtrlCHandler;
 
         //
         // Initialize the communicator.
         //
-        _communicator = initializeCommunicator(argc, argv, initData, version);
+        _communicator = initializeCommunicator(argc, argv, std::move(initData));
 
-        if(_closeFiles)
+        if (_closeFiles)
         {
             //
             // Close unnecessary file descriptors.
             //
             PropertiesPtr properties = _communicator->getProperties();
-            string stdOut = properties->getProperty("Ice.StdOut");
-            string stdErr = properties->getProperty("Ice.StdErr");
+            string stdOut = properties->getIceProperty("Ice.StdOut");
+            string stdErr = properties->getIceProperty("Ice.StdErr");
 
-            for(vector<int>::const_iterator p = fdsToClose.begin(); p != fdsToClose.end(); ++p)
+            for (int& p : fdsToClose)
             {
                 //
                 // NOTE: Do not close stdout if Ice.StdOut is defined. Likewise for Ice.StdErr.
                 //
-                if((*p == 1 && !stdOut.empty()) || (*p == 2 && !stdErr.empty()))
+                if ((p == 1 && !stdOut.empty()) || (p == 2 && !stdErr.empty()))
                 {
                     continue;
                 }
-                close(*p);
+                close(p);
             }
 
             //
@@ -1733,26 +1640,26 @@ Ice::Service::runDaemon(int argc, char* argv[], const InitializationData& initDa
             //
             int fd = open("/dev/null", O_RDWR);
             assert(fd == 0);
-            if(fd != 0)
+            if (fd != 0)
             {
-                throw SyscallException(__FILE__, __LINE__, IceInternal::getSystemErrno());
+                throw SyscallException{__FILE__, __LINE__, "open /dev/null failed", errno};
             }
-            if(stdOut.empty())
+            if (stdOut.empty())
             {
                 fd = dup2(0, 1);
                 assert(fd == 1);
-                if(fd != 1)
+                if (fd != 1)
                 {
-                    throw SyscallException(__FILE__, __LINE__, IceInternal::getSystemErrno());
+                    throw SyscallException{__FILE__, __LINE__, "dup2(0, 1) failed", errno};
                 }
             }
-            if(stdErr.empty())
+            if (stdErr.empty())
             {
                 fd = dup2(1, 2);
                 assert(fd == 2);
-                if(fd != 2)
+                if (fd != 2)
                 {
-                    throw SyscallException(__FILE__, __LINE__, IceInternal::getSystemErrno());
+                    throw SyscallException{__FILE__, __LINE__, "dup2(1, 2) failed", errno};
                 }
             }
         }
@@ -1760,12 +1667,12 @@ Ice::Service::runDaemon(int argc, char* argv[], const InitializationData& initDa
         //
         // Write PID
         //
-        if(_pidFile.size() > 0)
+        if (_pidFile.size() > 0)
         {
             ofstream of(_pidFile.c_str());
             of << getpid() << endl;
 
-            if(!of)
+            if (!of)
             {
                 warning("Could not write PID file " + _pidFile);
             }
@@ -1779,17 +1686,17 @@ Ice::Service::runDaemon(int argc, char* argv[], const InitializationData& initDa
         //
         // Start the service.
         //
-        if(start(argc, argv, status))
+        if (start(argc, argv, status))
         {
             //
             // Notify the parent that the child is ready.
             //
             char c = 0;
-            while(true)
+            while (true)
             {
-                if(write(fds[1], &c, 1) == -1)
+                if (write(fds[1], &c, 1) == -1)
                 {
-                    if(IceInternal::interrupted())
+                    if (IceInternal::interrupted())
                     {
                         continue;
                     }
@@ -1807,25 +1714,25 @@ Ice::Service::runDaemon(int argc, char* argv[], const InitializationData& initDa
             //
             // Stop the service.
             //
-            if(stop())
+            if (stop())
             {
                 status = EXIT_SUCCESS;
             }
         }
     }
-    catch(const Ice::Exception& ex)
+    catch (const Ice::Exception& ex)
     {
         ServiceError err(this);
         err << "service terminating after catching exception:\n" << ex;
         errMsg = err.str();
     }
-    catch(const std::exception& ex)
+    catch (const std::exception& ex)
     {
         ServiceError err(this);
         err << "service terminating after catching exception:\n" << ex;
         errMsg = err.str();
     }
-    catch(...)
+    catch (...)
     {
         errMsg = "service terminating after catching unknown exception";
         error(errMsg);
@@ -1835,14 +1742,14 @@ Ice::Service::runDaemon(int argc, char* argv[], const InitializationData& initDa
     // If the service failed and the pipe to the parent is still open,
     // then send an error notification to the parent.
     //
-    if(status != EXIT_SUCCESS && fds[1] != -1)
+    if (status != EXIT_SUCCESS && fds[1] != -1)
     {
         char c = 1;
-        while(true)
+        while (true)
         {
-            if(write(fds[1], &c, 1) == -1)
+            if (write(fds[1], &c, 1) == -1)
             {
-                if(IceInternal::interrupted())
+                if (IceInternal::interrupted())
                 {
                     continue;
                 }
@@ -1852,12 +1759,12 @@ Ice::Service::runDaemon(int argc, char* argv[], const InitializationData& initDa
         const char* msg = errMsg.c_str();
         size_t len = strlen(msg) + 1; // Include null byte
         size_t pos = 0;
-        while(len > 0)
+        while (len > 0)
         {
             ssize_t n = write(fds[1], &msg[pos], len);
-            if(n == -1)
+            if (n == -1)
             {
-                if(IceInternal::interrupted())
+                if (IceInternal::interrupted())
                 {
                     continue;
                 }
@@ -1872,7 +1779,7 @@ Ice::Service::runDaemon(int argc, char* argv[], const InitializationData& initDa
         close(fds[1]);
     }
 
-    if(_communicator)
+    if (_communicator)
     {
         _communicator->destroy();
     }