zeroc-ice 3.7.10 → 3.8.0

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

@@ -0,0 +1,216 @@
+// Copyright (c) ZeroC, Inc.
+
+#include "DynamicLibrary.h"
+#include "Ice/StringConverter.h"
+#include "Ice/StringUtil.h"
+
+#include <cassert>
+#include <sstream>
+
+#ifndef _WIN32
+#    include <dlfcn.h>
+#endif
+
+using namespace Ice;
+using namespace IceInternal;
+using namespace std;
+
+// Closing the library here can cause a crash at program exit if the application holds references to library resources
+// in global or static variables. Instead, we let the process discard the library.
+IceInternal::DynamicLibrary::~DynamicLibrary() = default;
+
+IceInternal::DynamicLibrary::symbol_type
+IceInternal::DynamicLibrary::loadEntryPoint(const string& entryPoint, bool useIceVersion)
+{
+    string::size_type colon = entryPoint.rfind(':');
+
+#ifdef _WIN32
+    const string driveLetters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+    if (colon == 1 && driveLetters.find(entryPoint[0]) != string::npos &&
+        (entryPoint[2] == '\\' || entryPoint[2] == '/'))
+    {
+        //
+        // The only colon we found is in the drive specification, as in "C:\MyDir".
+        // This means the function name is missing.
+        //
+        colon = string::npos;
+    }
+#endif
+
+    if (colon == string::npos || colon == entryPoint.size() - 1)
+    {
+        _err = "invalid entry point format '" + entryPoint + "'";
+        return nullptr;
+    }
+
+    string libSpec = entryPoint.substr(0, colon);
+    string funcName = entryPoint.substr(colon + 1);
+    string libPath, libName, version, debug;
+
+#ifdef _WIN32
+    string::size_type separator = libSpec.find_last_of("/\\");
+#else
+    string::size_type separator = libSpec.rfind('/');
+#endif
+    if (separator != string::npos)
+    {
+        libPath = libSpec.substr(0, separator + 1);
+        libSpec = libSpec.substr(separator + 1);
+    }
+
+    string::size_type comma = libSpec.find(',');
+    if (comma == string::npos)
+    {
+        libName = libSpec;
+        if (useIceVersion)
+        {
+            int majorVersion = (ICE_INT_VERSION / 10000);
+            int minorVersion = (ICE_INT_VERSION / 100) - majorVersion * 100;
+            int patchVersion = ICE_INT_VERSION % 100;
+            ostringstream os;
+            os << majorVersion * 10 + minorVersion;
+            if (patchVersion >= 60)
+            {
+                os << 'b' << (patchVersion - 60);
+            }
+            else if (patchVersion >= 50)
+            {
+                os << 'a' << (patchVersion - 50);
+            }
+            version = os.str();
+        }
+    }
+    else
+    {
+        if (comma == libSpec.size() - 1)
+        {
+            _err = "invalid entry point format '" + entryPoint + "'";
+            return nullptr;
+        }
+        libName = libSpec.substr(0, comma);
+        version = libSpec.substr(comma + 1);
+    }
+
+    string lib = libPath;
+
+#ifdef _WIN32
+    lib += libName;
+    lib += version;
+
+#    if defined(_DEBUG)
+    lib += 'd';
+#    endif
+
+#    ifdef COMPSUFFIX
+    lib += COMPSUFFIX;
+#    endif
+
+    lib += ".dll";
+#elif defined(__APPLE__)
+    lib += "lib" + libName;
+    if (!version.empty())
+    {
+        lib += "." + version;
+    }
+#else
+    lib += "lib" + libName + ".so";
+    if (!version.empty())
+    {
+        lib += "." + version;
+    }
+#endif
+
+#ifdef __APPLE__
+    //
+    // On macOS fallback to .so and .bundle extensions, if the default
+    // .dylib fails.
+    //
+    if (!load(lib + ".dylib"))
+    {
+        string errMsg = _err;
+        if (!load(lib + ".so"))
+        {
+            errMsg += "; " + _err;
+            if (!load(lib + ".bundle"))
+            {
+                _err = errMsg + "; " + _err;
+                return nullptr;
+            }
+        }
+        _err = "";
+    }
+#else
+    if (!load(lib))
+    {
+        return nullptr;
+    }
+#endif
+
+    return getSymbol(funcName);
+}
+
+bool
+IceInternal::DynamicLibrary::load(const string& lib)
+{
+    //
+    // Don't need to use a wide string converter as the wide string is passed
+    // to Windows API.
+    //
+#if defined(_WIN32)
+    _hnd = LoadLibraryW(stringToWstring(lib, getProcessStringConverter()).c_str());
+#else
+    int flags = RTLD_NOW | RTLD_GLOBAL;
+    _hnd = dlopen(lib.c_str(), flags);
+#endif
+    if (_hnd == nullptr)
+    {
+        //
+        // Remember the most recent error in _err.
+        //
+#if defined(_WIN32)
+        _err = "LoadLibraryW on '" + lib + "' failed with '" + IceInternal::lastErrorToString() + "'";
+#else
+        const char* err = dlerror();
+        if (err)
+        {
+            _err = err;
+        }
+#endif
+    }
+
+    return _hnd != nullptr;
+}
+
+IceInternal::DynamicLibrary::symbol_type
+IceInternal::DynamicLibrary::getSymbol(const string& name)
+{
+    assert(_hnd != nullptr);
+#ifdef _WIN32
+    symbol_type result = GetProcAddress(_hnd, name.c_str());
+#else
+    symbol_type result = dlsym(_hnd, name.c_str());
+#endif
+
+    if (result == nullptr)
+    {
+        //
+        // Remember the most recent error in _err.
+        //
+#ifdef _WIN32
+        _err = "GetProcAddress for '" + name + "' failed with '" + IceInternal::lastErrorToString() + "'";
+#else
+        const char* err = dlerror();
+        if (err)
+        {
+            _err = err;
+        }
+#endif
+    }
+    return result;
+}
+
+const string&
+IceInternal::DynamicLibrary::getErrorMessage() const
+{
+    return _err;
+}

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

@@ -0,0 +1,91 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_DYNAMIC_LIBRARY_H
+#define ICE_DYNAMIC_LIBRARY_H
+
+#include "Ice/Config.h"
+
+#ifdef _WIN32
+#    include <windows.h>
+#endif
+
+#include <string>
+
+namespace IceInternal
+{
+    class ICE_API DynamicLibrary final
+    {
+    public:
+        DynamicLibrary() = default;
+        ~DynamicLibrary();
+
+        DynamicLibrary(const DynamicLibrary&) = delete;
+        DynamicLibrary& operator=(const DynamicLibrary&) = delete;
+
+#ifdef _WIN32
+        using symbol_type = FARPROC;
+#else
+        using symbol_type = void*;
+#endif
+
+        //
+        // Load an entry point. This is really a convenience function
+        // which combines calls to load() and getSymbol(). However, it
+        // does add some value.
+        //
+        // An entry point has the following format:
+        //
+        // name[,version]:function
+        //
+        // The name of the library is constructed from the given
+        // information. If no version is supplied and the boolean
+        // argument is true, the Ice version (10 * major + minor) is
+        // used instead.
+        //
+        // For example, consider the following entry point:
+        //
+        // foo:create
+        //
+        // This would result in libfoo.so.11 (Unix) and foo11.dll
+        // (Windows), where the Ice version is 1.1.x.
+        //
+        // Now consider this entry point:
+        //
+        // foo,12:create
+        //
+        // The library names in this case are libfoo.so.12 (Unix) and
+        // foo12.dll (Windows).
+        //
+        // On Windows platforms, a 'd' is appended to the version for
+        // debug builds.
+        //
+        // Returns 0 if a failure occurred.
+        //
+        symbol_type loadEntryPoint(const std::string&, bool = true);
+
+        //
+        // Open a library with the given path.
+        //
+        bool load(const std::string&);
+
+        //
+        // Retrieve a symbol from the library. Returns 0 if no match is found.
+        //
+        symbol_type getSymbol(const std::string&);
+
+        //
+        // Get the error message for the last failure.
+        //
+        [[nodiscard]] const std::string& getErrorMessage() const;
+
+    private:
+#ifdef _WIN32
+        HINSTANCE _hnd{nullptr};
+#else
+        void* _hnd{nullptr};
+#endif
+        std::string _err;
+    };
+}
+
+#endif

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

@@ -0,0 +1,40 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_ENDIAN_H
+#define ICE_ENDIAN_H
+
+#if __has_include(<bit>)
+#    include <bit>
+#endif
+
+#ifndef __cpp_lib_endian
+
+// NOLINTBEGIN(cert-dcl58-cpp)
+
+// Provide a minimal implementation of std::endian for C++17.
+namespace std
+{
+#    ifdef _MSC_VER
+    // Always little-endian on Windows.
+    enum class endian
+    {
+        little = 0,
+        big = 1,
+        native = little
+    };
+#    else
+    // Use macros predefined by gcc/clang to determine the endianness.
+    enum class endian
+    {
+        little = __ORDER_LITTLE_ENDIAN__,
+        big = __ORDER_BIG_ENDIAN__,
+        native = __BYTE_ORDER__
+    };
+#    endif
+}
+
+// NOLINTEND(cert-dcl58-cpp)
+
+#endif
+
+#endif

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

@@ -0,0 +1,165 @@
+// Copyright (c) ZeroC, Inc.
+
+#include "EndpointFactory.h"
+#include "EndpointFactoryManager.h"
+#include "Instance.h"
+#include "ProtocolInstance.h"
+
+using namespace std;
+using namespace Ice;
+using namespace IceInternal;
+
+IceInternal::EndpointFactory::EndpointFactory() = default;
+
+IceInternal::EndpointFactory::~EndpointFactory() = default;
+
+void
+IceInternal::EndpointFactory::initialize()
+{
+    // Nothing to do, can be overridden by specialization to finish initialization.
+}
+
+IceInternal::EndpointFactoryPlugin::EndpointFactoryPlugin(
+    const CommunicatorPtr& communicator,
+    const EndpointFactoryPtr& factory)
+{
+    assert(communicator);
+    getInstance(communicator)->endpointFactoryManager()->add(factory);
+}
+
+void
+IceInternal::EndpointFactoryPlugin::initialize()
+{
+}
+
+void
+IceInternal::EndpointFactoryPlugin::destroy()
+{
+}
+
+IceInternal::EndpointFactoryWithUnderlying::EndpointFactoryWithUnderlying(ProtocolInstancePtr instance, int16_t type)
+    : _instance(std::move(instance)),
+      _type(type)
+{
+}
+
+void
+IceInternal::EndpointFactoryWithUnderlying::initialize()
+{
+    //
+    // Get the endpoint factory for the underlying type and clone it with
+    // our protocol instance.
+    //
+    EndpointFactoryPtr factory = _instance->getEndpointFactory(_type);
+    if (factory)
+    {
+        _underlying = factory->clone(_instance);
+        _underlying->initialize();
+    }
+}
+
+int16_t
+IceInternal::EndpointFactoryWithUnderlying::type() const
+{
+    return _instance->type();
+}
+
+string
+IceInternal::EndpointFactoryWithUnderlying::protocol() const
+{
+    return _instance->protocol();
+}
+
+EndpointIPtr
+IceInternal::EndpointFactoryWithUnderlying::create(vector<string>& args, bool oaEndpoint) const
+{
+    if (!_underlying)
+    {
+        return nullptr; // Can't create an endpoint without underlying factory.
+    }
+    return createWithUnderlying(_underlying->create(args, oaEndpoint), args, oaEndpoint);
+}
+
+EndpointIPtr
+IceInternal::EndpointFactoryWithUnderlying::read(InputStream* s) const
+{
+    if (!_underlying)
+    {
+        return nullptr; // Can't create an endpoint without underlying factory.
+    }
+    return readWithUnderlying(_underlying->read(s), s);
+}
+
+EndpointFactoryPtr
+IceInternal::EndpointFactoryWithUnderlying::clone(const ProtocolInstancePtr& instance) const
+{
+    return cloneWithUnderlying(instance, _type);
+}
+
+IceInternal::UnderlyingEndpointFactory::UnderlyingEndpointFactory(
+    ProtocolInstancePtr instance,
+    int16_t type,
+    int16_t underlying)
+    : _instance(std::move(instance)),
+      _type(type),
+      _underlying(underlying)
+{
+}
+
+void
+IceInternal::UnderlyingEndpointFactory::initialize()
+{
+    //
+    // Get the endpoint factory of the given endpoint type. If it's a factory that
+    // delegates to an underlying endpoint, clone it and instruct it to delegate to
+    // our underlying factory.
+    //
+    EndpointFactoryPtr factory = _instance->getEndpointFactory(_type);
+    if (factory)
+    {
+        auto f = dynamic_pointer_cast<EndpointFactoryWithUnderlying>(factory);
+        if (f)
+        {
+            _factory = f->cloneWithUnderlying(_instance, _underlying);
+            _factory->initialize();
+        }
+    }
+}
+
+int16_t
+IceInternal::UnderlyingEndpointFactory::type() const
+{
+    return _instance->type();
+}
+
+string
+IceInternal::UnderlyingEndpointFactory::protocol() const
+{
+    return _instance->protocol();
+}
+
+EndpointIPtr
+IceInternal::UnderlyingEndpointFactory::create(vector<string>& args, bool oaEndpoint) const
+{
+    if (!_factory)
+    {
+        return nullptr;
+    }
+    return _factory->create(args, oaEndpoint);
+}
+
+EndpointIPtr
+IceInternal::UnderlyingEndpointFactory::read(InputStream* s) const
+{
+    if (!_factory)
+    {
+        return nullptr;
+    }
+    return _factory->read(s);
+}
+
+EndpointFactoryPtr
+IceInternal::UnderlyingEndpointFactory::clone(const ProtocolInstancePtr& instance) const
+{
+    return make_shared<UnderlyingEndpointFactory>(instance, _type, _underlying);
+}

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

@@ -0,0 +1,96 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_ENDPOINT_FACTORY_H
+#define ICE_ENDPOINT_FACTORY_H
+
+#include "EndpointFactoryF.h"
+#include "EndpointIF.h"
+#include "Ice/CommunicatorF.h"
+#include "Ice/Config.h"
+#include "Ice/Plugin.h"
+#include "ProtocolInstanceF.h"
+
+namespace Ice
+{
+    class InputStream;
+}
+
+namespace IceInternal
+{
+    class ICE_API EndpointFactory
+    {
+    public:
+        EndpointFactory();
+        virtual ~EndpointFactory();
+
+        virtual void initialize();
+        [[nodiscard]] virtual std::int16_t type() const = 0;
+        [[nodiscard]] virtual std::string protocol() const = 0;
+        virtual EndpointIPtr create(std::vector<std::string>&, bool) const = 0;
+        virtual EndpointIPtr read(Ice::InputStream*) const = 0;
+
+        [[nodiscard]] virtual EndpointFactoryPtr clone(const ProtocolInstancePtr&) const = 0;
+    };
+
+    /// This factory is used to create endpoints that delegate to an underlying endpoint.
+    /// For example, the SSL/WS endpoints are endpoints that always delegate to underlying endpoints.
+    class ICE_API EndpointFactoryWithUnderlying : public EndpointFactory
+    {
+    public:
+        EndpointFactoryWithUnderlying(ProtocolInstancePtr, std::int16_t);
+
+        void initialize() override;
+        [[nodiscard]] std::int16_t type() const override;
+        [[nodiscard]] std::string protocol() const override;
+        EndpointIPtr create(std::vector<std::string>&, bool) const override;
+        EndpointIPtr read(Ice::InputStream*) const override;
+
+        [[nodiscard]] EndpointFactoryPtr clone(const ProtocolInstancePtr&) const override;
+
+        [[nodiscard]] virtual EndpointFactoryPtr
+        cloneWithUnderlying(const ProtocolInstancePtr&, std::int16_t) const = 0;
+
+    protected:
+        virtual EndpointIPtr createWithUnderlying(const EndpointIPtr&, std::vector<std::string>&, bool) const = 0;
+        virtual EndpointIPtr readWithUnderlying(const EndpointIPtr&, Ice::InputStream*) const = 0;
+
+        const ProtocolInstancePtr _instance;
+        const std::int16_t _type;
+        EndpointFactoryPtr _underlying;
+    };
+
+    /// The underlying endpoint factory creates endpoints with a factory of the given type.
+    /// If this factory is of the @c EndpointFactoryWithUnderlying type,
+    /// it will delegate to the given underlying factory.
+    /// @remark This is used by IceIAP/IceBT plugins for the BTS/iAPS endpoint factories.
+    class ICE_API UnderlyingEndpointFactory : public EndpointFactory
+    {
+    public:
+        UnderlyingEndpointFactory(ProtocolInstancePtr, std::int16_t, std::int16_t);
+
+        void initialize() override;
+        [[nodiscard]] std::int16_t type() const override;
+        [[nodiscard]] std::string protocol() const override;
+        EndpointIPtr create(std::vector<std::string>&, bool) const override;
+        EndpointIPtr read(Ice::InputStream*) const override;
+
+        [[nodiscard]] EndpointFactoryPtr clone(const ProtocolInstancePtr&) const override;
+
+    private:
+        const ProtocolInstancePtr _instance;
+        const std::int16_t _type;
+        const std::int16_t _underlying;
+        EndpointFactoryPtr _factory;
+    };
+
+    class ICE_API EndpointFactoryPlugin : public Ice::Plugin
+    {
+    public:
+        EndpointFactoryPlugin(const Ice::CommunicatorPtr&, const EndpointFactoryPtr&);
+
+        void initialize() override;
+        void destroy() override;
+    };
+}
+
+#endif

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

@@ -0,0 +1,14 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_ENDPOINT_FACTORY_F_H
+#define ICE_ENDPOINT_FACTORY_F_H
+
+#include <memory>
+
+namespace IceInternal
+{
+    class EndpointFactory;
+    using EndpointFactoryPtr = std::shared_ptr<EndpointFactory>;
+}
+
+#endif