zeroc-ice 3.7.11 → 3.8.1

data/dist/ice/cpp/src/Ice/ConnectionOptions.h

@@ -0,0 +1,22 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_CONNECTION_OPTIONS_H
+#define ICE_CONNECTION_OPTIONS_H
+
+#include <chrono>
+
+namespace Ice
+{
+    /// Represents a property bag used to configure client and server connections.
+    struct ConnectionOptions
+    {
+        std::chrono::seconds connectTimeout;
+        std::chrono::seconds closeTimeout;
+        std::chrono::seconds idleTimeout;
+        bool enableIdleCheck;
+        std::chrono::seconds inactivityTimeout;
+        int maxDispatches;
+    };
+}
+
+#endif

data/dist/ice/cpp/src/Ice/Connector.h

@@ -1,32 +1,38 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef ICE_CONNECTOR_H
 #define ICE_CONNECTOR_H
 
-#include <IceUtil/Shared.h>
-#include <Ice/ConnectorF.h>
-#include <Ice/TransceiverF.h>
+#include "ConnectorF.h"
+#include "TransceiverF.h"
 
-namespace IceInternal
-{
+#include <cstdint>
+#include <string>
 
-class ICE_API Connector : public ::IceUtil::Shared
-{
-public:
-
-    virtual ~Connector();
+#ifdef __clang__
+#    pragma clang diagnostic push
+#    pragma clang diagnostic ignored "-Wweak-vtables"
+#endif
 
-    virtual TransceiverPtr connect() = 0;
+namespace IceInternal
+{
+    class Connector
+    {
+    public:
+        virtual ~Connector() = default;
 
-    virtual Ice::Short type() const = 0;
-    virtual std::string toString() const = 0;
+        virtual TransceiverPtr connect() = 0;
 
-    virtual bool operator==(const Connector&) const = 0;
-    virtual bool operator<(const Connector&) const = 0;
-};
+        [[nodiscard]] virtual std::int16_t type() const = 0;
+        [[nodiscard]] virtual std::string toString() const = 0;
 
+        virtual bool operator==(const Connector&) const = 0;
+        virtual bool operator<(const Connector&) const = 0;
+    };
 }
 
+#ifdef __clang__
+#    pragma clang diagnostic pop
+#endif
+
 #endif

data/dist/ice/cpp/src/Ice/ConnectorF.h

@@ -1,21 +1,14 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef ICE_CONNECTOR_F_H
 #define ICE_CONNECTOR_F_H
 
-#include <IceUtil/Shared.h>
-
-#include <Ice/Handle.h>
+#include <memory>
 
 namespace IceInternal
 {
-
-class Connector;
-ICE_API IceUtil::Shared* upCast(Connector*);
-typedef Handle<Connector> ConnectorPtr;
-
+    class Connector;
+    using ConnectorPtr = std::shared_ptr<Connector>;
 }
 
 #endif

data/dist/ice/cpp/src/{IceUtil → Ice}/ConsoleUtil.cpp

@@ -1,64 +1,42 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
-#include <IceUtil/ConsoleUtil.h>
-#include <IceUtil/MutexPtrLock.h>
-#include <IceUtil/Mutex.h>
+#include "ConsoleUtil.h"
 
-using namespace IceUtilInternal;
+#ifdef _WIN32
+#    include <mutex>
+#    include <windows.h>
+#endif
+
+#include <iostream>
+
+using namespace IceInternal;
 using namespace std;
 
 #if defined(_WIN32)
 namespace
 {
-
-IceUtil::Mutex* consoleMutex = 0;
-ConsoleUtil* consoleUtil = 0;
-
-class Init
-{
-public:
-
-    Init()
-    {
-        consoleMutex = new IceUtil::Mutex;
-    }
-
-    ~Init()
-    {
-        //
-        // We leak consoleUtil object to ensure that is available
-        // during static destruction.
-        //
-        //delete consoleUtil;
-        //consoleUtil = 0;
-        delete consoleMutex;
-        consoleMutex = 0;
-    }
-};
-
-Init init;
-
+    mutex consoleMutex;
+    // We leak consoleUtil object to ensure that is available during static destruction.
+    ConsoleUtil* consoleUtil = 0;
 }
 
 const ConsoleUtil&
-IceUtilInternal::getConsoleUtil()
+IceInternal::getConsoleUtil()
 {
-    IceUtilInternal::MutexPtrLock<IceUtil::Mutex> sync(consoleMutex);
-    if(consoleUtil == 0)
+    lock_guard sync(consoleMutex);
+    if (consoleUtil == 0)
     {
         consoleUtil = new ConsoleUtil();
     }
     return *consoleUtil;
 }
 
-ConsoleOut IceUtilInternal::consoleOut;
-ConsoleErr IceUtilInternal::consoleErr;
+ConsoleOut IceInternal::consoleOut;
+ConsoleErr IceInternal::consoleErr;
 
-ConsoleUtil::ConsoleUtil() :
-    _converter(IceUtil::getProcessStringConverter()),
-    _consoleConverter(IceUtil::createWindowsStringConverter(GetConsoleOutputCP()))
+ConsoleUtil::ConsoleUtil()
+    : _converter(Ice::getProcessStringConverter()),
+      _consoleConverter(Ice::createWindowsStringConverter(GetConsoleOutputCP()))
 {
 }
 
@@ -72,13 +50,14 @@ ConsoleUtil::toConsoleEncoding(const string& message) const
 
         // Then from UTF-8 to console CP
         string consoleString;
-        _consoleConverter->fromUTF8(reinterpret_cast<const IceUtil::Byte* > (u8s.data()),
-                                    reinterpret_cast<const IceUtil::Byte*>(u8s.data() + u8s.size()),
-                                    consoleString);
+        _consoleConverter->fromUTF8(
+            reinterpret_cast<const byte*>(u8s.data()),
+            reinterpret_cast<const byte*>(u8s.data() + u8s.size()),
+            consoleString);
 
         return consoleString;
     }
-    catch(const IceUtil::IllegalConversionException&)
+    catch (const Ice::IllegalConversionException&)
     {
         //
         // If there is a problem with the encoding conversions we just
@@ -109,7 +88,7 @@ ConsoleUtil::error(const string& message) const
 }
 
 ConsoleOut&
-IceUtilInternal::endl(ConsoleOut& out)
+IceInternal::endl(ConsoleOut& out)
 {
     fprintf_s(stdout, "\n");
     fflush(stdout);
@@ -117,7 +96,7 @@ IceUtilInternal::endl(ConsoleOut& out)
 }
 
 ConsoleOut&
-IceUtilInternal::flush(ConsoleOut& out)
+IceInternal::flush(ConsoleOut& out)
 {
     fflush(stdout);
     return out;
@@ -131,7 +110,7 @@ ConsoleOut::operator<<(ConsoleOut& (*pf)(ConsoleOut&))
 }
 
 ConsoleErr&
-IceUtilInternal::endl(ConsoleErr& err)
+IceInternal::endl(ConsoleErr& err)
 {
     fprintf_s(stderr, "\n");
     fflush(stderr);
@@ -139,7 +118,7 @@ IceUtilInternal::endl(ConsoleErr& err)
 }
 
 ConsoleErr&
-IceUtilInternal::flush(ConsoleErr& err)
+IceInternal::flush(ConsoleErr& err)
 {
     fflush(stderr);
     return err;
@@ -152,6 +131,6 @@ ConsoleErr::operator<<(ConsoleErr& (*pf)(ConsoleErr&))
     return *this;
 }
 #else
-std::ostream& IceUtilInternal::consoleOut = cout;
-std::ostream& IceUtilInternal::consoleErr = cerr;
+std::ostream& IceInternal::consoleOut = cout;
+std::ostream& IceInternal::consoleErr = cerr;
 #endif

data/dist/ice/cpp/src/Ice/ConsoleUtil.h

@@ -0,0 +1,79 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_CONSOLE_UTIL_H
+#define ICE_CONSOLE_UTIL_H
+
+#include "Ice/Config.h"
+#include "Ice/StringConverter.h"
+
+#include <ostream>
+#include <sstream>
+
+namespace IceInternal
+{
+#if defined(_WIN32)
+
+    class ConsoleUtil;
+    using ConsoleUtilPtr = std::shared_ptr<ConsoleUtil>;
+
+    class ICE_API ConsoleUtil
+    {
+    public:
+        ConsoleUtil();
+        void output(const std::string&) const;
+        void error(const std::string&) const;
+
+    private:
+        std::string toConsoleEncoding(const std::string&) const;
+        Ice::StringConverterPtr _converter;
+        Ice::StringConverterPtr _consoleConverter;
+    };
+
+    const ICE_API ConsoleUtil& getConsoleUtil();
+
+    class ICE_API ConsoleOut
+    {
+    public:
+        ConsoleOut& operator<<(ConsoleOut& (*pf)(ConsoleOut&));
+    };
+
+    class ICE_API ConsoleErr
+    {
+    public:
+        ConsoleErr& operator<<(ConsoleErr& (*pf)(ConsoleErr&));
+    };
+
+    template<typename T> ConsoleOut& operator<<(ConsoleOut& out, const T& val)
+    {
+        std::ostringstream s;
+        s << val;
+        getConsoleUtil().output(s.str());
+        return out;
+    }
+
+    ICE_API ConsoleOut& endl(ConsoleOut&);
+    ICE_API ConsoleOut& flush(ConsoleOut&);
+
+    template<typename T> ConsoleErr& operator<<(ConsoleErr& err, const T& val)
+    {
+        std::ostringstream s;
+        s << val;
+        getConsoleUtil().error(s.str());
+        return err;
+    }
+
+    ICE_API ConsoleErr& endl(ConsoleErr&);
+    ICE_API ConsoleErr& flush(ConsoleErr&);
+
+    extern ICE_API ConsoleOut consoleOut;
+    extern ICE_API ConsoleErr consoleErr;
+
+#else
+
+    ICE_API extern std::ostream& consoleOut;
+    ICE_API extern std::ostream& consoleErr;
+
+#endif
+}
+
+#endif

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

@@ -0,0 +1,189 @@
+// Copyright (c) ZeroC, Inc.
+
+#include "Ice/CtrlCHandler.h"
+#include "Ice/LocalException.h"
+
+#ifdef _WIN32
+#    include <windows.h>
+#else
+#    include <csignal>
+#endif
+
+#include <cassert>
+#include <mutex>
+
+using namespace Ice;
+using namespace std;
+
+namespace
+{
+    CtrlCHandlerCallback _callback = nullptr;
+
+    const CtrlCHandler* _handler = nullptr;
+
+    mutex globalMutex;
+}
+
+CtrlCHandler::CtrlCHandler() : CtrlCHandler(nullptr) {}
+
+CtrlCHandlerCallback
+CtrlCHandler::setCallback(CtrlCHandlerCallback callback)
+{
+    lock_guard lock(globalMutex);
+    CtrlCHandlerCallback oldCallback = std::move(_callback);
+    _callback = std::move(callback);
+    return oldCallback;
+}
+
+CtrlCHandlerCallback
+CtrlCHandler::getCallback() const
+{
+    lock_guard lock(globalMutex);
+    return _callback;
+}
+
+#ifdef _WIN32
+
+static BOOL WINAPI
+handlerRoutine(DWORD dwCtrlType)
+{
+    CtrlCHandlerCallback callback;
+    {
+        lock_guard lock(globalMutex);
+        if (!_handler) // The handler is destroyed.
+        {
+            return FALSE;
+        }
+        callback = _callback;
+    }
+    if (callback)
+    {
+        callback(dwCtrlType);
+    }
+    return TRUE;
+}
+
+CtrlCHandler::CtrlCHandler(CtrlCHandlerCallback callback)
+{
+    unique_lock lock(globalMutex);
+    if (_handler)
+    {
+        throw Ice::LocalException{__FILE__, __LINE__, "another CtrlCHandler was already created"};
+    }
+    else
+    {
+        _callback = std::move(callback);
+        _handler = this;
+        lock.unlock();
+
+        SetConsoleCtrlHandler(handlerRoutine, TRUE);
+    }
+}
+
+CtrlCHandler::~CtrlCHandler()
+{
+    SetConsoleCtrlHandler(handlerRoutine, FALSE);
+    lock_guard lock(globalMutex);
+    _handler = nullptr;
+    _callback = nullptr;
+}
+
+#else
+
+extern "C"
+{
+    static void* sigwaitThread(void*)
+    {
+        sigset_t ctrlCLikeSignals;
+        sigemptyset(&ctrlCLikeSignals);
+        sigaddset(&ctrlCLikeSignals, SIGHUP);
+        sigaddset(&ctrlCLikeSignals, SIGINT);
+        sigaddset(&ctrlCLikeSignals, SIGTERM);
+
+        // Run until the handler is destroyed (!_handler)
+        for (;;)
+        {
+            int signal = 0;
+            int rc = sigwait(&ctrlCLikeSignals, &signal);
+            if (rc == EINTR)
+            {
+                // Some sigwait() implementations incorrectly return EINTR when interrupted by an unblocked caught
+                // signal.
+                continue;
+            }
+            assert(rc == 0);
+
+            CtrlCHandlerCallback callback;
+            {
+                lock_guard lock(globalMutex);
+                if (!_handler) // The handler is destroyed.
+                {
+                    return nullptr;
+                }
+                callback = _callback;
+            }
+
+            if (callback)
+            {
+                callback(signal);
+            }
+        }
+        return nullptr;
+    }
+}
+
+namespace
+{
+    pthread_t _tid;
+}
+
+CtrlCHandler::CtrlCHandler(CtrlCHandlerCallback callback)
+{
+    unique_lock lock(globalMutex);
+    if (_handler)
+    {
+        throw Ice::LocalException{__FILE__, __LINE__, "another CtrlCHandler was already created"};
+    }
+    else
+    {
+        _callback = std::move(callback);
+        _handler = this;
+
+        lock.unlock();
+
+        // We block these CTRL+C like signals in the main thread, and by default all other threads will inherit this
+        // signal mask.
+
+        sigset_t ctrlCLikeSignals;
+        sigemptyset(&ctrlCLikeSignals);
+        sigaddset(&ctrlCLikeSignals, SIGHUP);
+        sigaddset(&ctrlCLikeSignals, SIGINT);
+        sigaddset(&ctrlCLikeSignals, SIGTERM);
+
+        [[maybe_unused]] int rc = pthread_sigmask(SIG_BLOCK, &ctrlCLikeSignals, nullptr);
+        assert(rc == 0);
+
+        // Joinable thread
+        rc = pthread_create(&_tid, nullptr, sigwaitThread, nullptr);
+        assert(rc == 0);
+    }
+}
+
+CtrlCHandler::~CtrlCHandler()
+{
+    // Clear the handler, the sigwaitThread will exit if _handler is null
+    {
+        lock_guard lock(globalMutex);
+        _handler = nullptr;
+        _callback = nullptr;
+    }
+
+    // Signal the sigwaitThread and join it.
+    void* status = nullptr;
+    [[maybe_unused]] int rc = pthread_kill(_tid, SIGTERM); // NOLINT(cert-pos44-c)
+    assert(rc == 0);
+    rc = pthread_join(_tid, &status);
+    assert(rc == 0);
+}
+
+#endif

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

@@ -0,0 +1,29 @@
+// Copyright (c) ZeroC, Inc.
+
+#include "Ice/Current.h"
+#include "Ice/LocalExceptions.h"
+
+#include <sstream>
+
+using namespace std;
+
+#if defined(__GNUC__)
+#    pragma GCC diagnostic push
+#    pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+const Ice::Current Ice::emptyCurrent{};
+#if defined(__GNUC__)
+#    pragma GCC diagnostic pop
+#endif
+
+void
+Ice::checkNonIdempotent(const Current& current)
+{
+    if (current.mode != OperationMode::Normal)
+    {
+        ostringstream os;
+        os << "operation mode mismatch for operation '" << current.operation << "': received = " << current.mode
+           << " for non-idempotent operation";
+        throw MarshalException{__FILE__, __LINE__, os.str()};
+    }
+}

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

@@ -1,50 +1,40 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
-#include <Ice/ImplicitContextI.h>
-#include <Ice/Service.h>
+#include "Ice/Service.h"
 
 extern "C" BOOL WINAPI _CRT_INIT(HINSTANCE, DWORD, LPVOID);
 
 extern "C"
 {
-
-BOOL WINAPI
-ice_DLL_Main(HINSTANCE hDLL, DWORD reason, LPVOID reserved)
-{
-    //
-    // During ATTACH, we must call _CRT_INIT first.
-    //
-    if(reason == DLL_PROCESS_ATTACH || reason == DLL_THREAD_ATTACH)
+    BOOL WINAPI ice_DLL_Main(HINSTANCE hDLL, DWORD reason, LPVOID reserved)
     {
-        if(!_CRT_INIT(hDLL, reason, reserved))
+        //
+        // During ATTACH, we must call _CRT_INIT first.
+        //
+        if (reason == DLL_PROCESS_ATTACH || reason == DLL_THREAD_ATTACH)
         {
-            return FALSE;
+            if (!_CRT_INIT(hDLL, reason, reserved))
+            {
+                return FALSE;
+            }
         }
-    }
-
-    if(reason == DLL_PROCESS_ATTACH)
-    {
-        Ice::Service::setModuleHandle(hDLL);
-    }
-    else if(reason == DLL_THREAD_DETACH)
-    {
-        Ice::ImplicitContextI::cleanupThread();
-    }
 
-    //
-    // During DETACH, we must call _CRT_INIT last.
-    //
-    if(reason == DLL_PROCESS_DETACH || reason == DLL_THREAD_DETACH)
-    {
-        if(!_CRT_INIT(hDLL, reason, reserved))
+        if (reason == DLL_PROCESS_ATTACH)
         {
-            return FALSE;
+            Ice::Service::setModuleHandle(hDLL);
         }
-    }
 
-    return TRUE;
-}
+        //
+        // During DETACH, we must call _CRT_INIT last.
+        //
+        if (reason == DLL_PROCESS_DETACH || reason == DLL_THREAD_DETACH)
+        {
+            if (!_CRT_INIT(hDLL, reason, reserved))
+            {
+                return FALSE;
+            }
+        }
 
+        return TRUE;
+    }
 }

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

@@ -0,0 +1,39 @@
+// Copyright (c) ZeroC, Inc.
+
+#include "Ice/DefaultSliceLoader.h"
+#include "Ice/ValueF.h"
+
+using namespace std;
+
+IceInternal::DefaultSliceLoaderPtr
+IceInternal::DefaultSliceLoader::instance()
+{
+    static DefaultSliceLoaderPtr instance{new DefaultSliceLoader};
+    return instance;
+}
+
+IceInternal::DefaultSliceLoader::~DefaultSliceLoader() = default; // avoids weak vtable
+
+Ice::ValuePtr
+IceInternal::DefaultSliceLoader::newClassInstance(std::string_view typeId) const
+{
+    lock_guard lock{_mutex};
+    auto p = _classFactories.find(typeId);
+    if (p != _classFactories.end())
+    {
+        return p->second.first();
+    }
+    return nullptr;
+}
+
+std::exception_ptr
+IceInternal::DefaultSliceLoader::newExceptionInstance(std::string_view typeId) const
+{
+    lock_guard lock{_mutex};
+    auto p = _exceptionFactories.find(typeId);
+    if (p != _exceptionFactories.end())
+    {
+        return p->second.first();
+    }
+    return nullptr;
+}