zeroc-ice 3.7.10 → 3.8.0

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

@@ -0,0 +1,275 @@
+// Copyright (c) ZeroC, Inc.
+
+#include "RouterInfo.h"
+#include "Ice/Connection.h" // For ice_connection()->timeout().
+#include "Ice/LocalExceptions.h"
+#include "Ice/ProxyFunctions.h"
+#include "Ice/Router.h"
+#include "Reference.h"
+
+#include <cassert>
+
+using namespace std;
+using namespace Ice;
+using namespace IceInternal;
+
+IceInternal::RouterManager::RouterManager() : _tableHint(_table.end()) {}
+
+void
+IceInternal::RouterManager::destroy()
+{
+    lock_guard lock(_mutex);
+    for (const auto& [_, routerInfo] : _table)
+    {
+        routerInfo->destroy();
+    }
+    _table.clear();
+    _tableHint = _table.end();
+}
+
+RouterInfoPtr
+IceInternal::RouterManager::get(const RouterPrx& rtr)
+{
+    RouterPrx router = rtr->ice_router(nullopt); // The router cannot be routed.
+
+    lock_guard lock(_mutex);
+
+    auto p = _table.end();
+
+    if (_tableHint != _table.end())
+    {
+        if (_tableHint->first == router)
+        {
+            p = _tableHint;
+        }
+    }
+
+    if (p == _table.end())
+    {
+        p = _table.find(router);
+    }
+
+    if (p == _table.end())
+    {
+        _tableHint = _table.insert(_tableHint, pair<const RouterPrx, RouterInfoPtr>(router, new RouterInfo(router)));
+    }
+    else
+    {
+        _tableHint = p;
+    }
+
+    return _tableHint->second;
+}
+
+void
+IceInternal::RouterManager::erase(const RouterPrx& router)
+{
+    assert(!router->ice_getRouter()); // The router cannot be routed.
+
+    lock_guard lock(_mutex);
+
+    auto p = _table.end();
+    if (_tableHint != _table.end() && _tableHint->first == router)
+    {
+        p = _tableHint;
+        _tableHint = _table.end();
+    }
+
+    if (p == _table.end())
+    {
+        p = _table.find(router);
+    }
+
+    if (p != _table.end())
+    {
+        _table.erase(p);
+    }
+}
+
+IceInternal::RouterInfo::RouterInfo(RouterPrx router) : _router(std::move(router)) {}
+
+void
+IceInternal::RouterInfo::destroy()
+{
+    lock_guard lock(_mutex);
+
+    _clientEndpoints.clear();
+    _adapter = nullptr;
+    _identities.clear();
+}
+
+bool
+IceInternal::RouterInfo::operator==(const RouterInfo& rhs) const
+{
+    return _router == rhs._router;
+}
+
+bool
+IceInternal::RouterInfo::operator<(const RouterInfo& rhs) const
+{
+    return _router < rhs._router;
+}
+
+vector<EndpointIPtr>
+IceInternal::RouterInfo::getClientEndpoints()
+{
+    {
+        lock_guard lock(_mutex);
+        if (!_clientEndpoints.empty())
+        {
+            return _clientEndpoints;
+        }
+    }
+
+    optional<bool> hasRoutingTable;
+    optional<ObjectPrx> proxy = _router->getClientProxy(hasRoutingTable);
+    return setClientEndpoints(proxy, hasRoutingTable ? hasRoutingTable.value() : true);
+}
+
+void
+IceInternal::RouterInfo::getClientEndpointsAsync(
+    std::function<void(vector<EndpointIPtr>)> response,
+    std::function<void(std::exception_ptr)> ex)
+{
+    vector<EndpointIPtr> clientEndpoints;
+    {
+        lock_guard lock(_mutex);
+        clientEndpoints = _clientEndpoints;
+    }
+
+    if (!clientEndpoints.empty())
+    {
+        response(std::move(clientEndpoints));
+        return;
+    }
+
+    RouterInfoPtr self = shared_from_this();
+    _router->getClientProxyAsync(
+        [self, response = std::move(response)](const optional<Ice::ObjectPrx>& proxy, optional<bool> hasRoutingTable)
+        { response(self->setClientEndpoints(proxy, hasRoutingTable.value_or(true))); },
+        std::move(ex));
+}
+
+vector<EndpointIPtr>
+IceInternal::RouterInfo::getServerEndpoints()
+{
+    optional<ObjectPrx> serverProxy = _router->getServerProxy();
+    if (!serverProxy)
+    {
+        throw NoEndpointException{__FILE__, __LINE__, "Router::getServerProxy returned a null proxy"};
+    }
+    serverProxy = serverProxy->ice_router(nullopt); // The server proxy cannot be routed.
+    return serverProxy->_getReference()->getEndpoints();
+}
+
+bool
+IceInternal::RouterInfo::addProxyAsync(
+    const ReferencePtr& reference,
+    function<void()> response,
+    function<void(exception_ptr)> ex)
+{
+    assert(reference);
+    Identity identity = reference->getIdentity();
+
+    {
+        lock_guard lock(_mutex);
+        if (!_hasRoutingTable)
+        {
+            return true; // The router implementation doesn't maintain a routing table.
+        }
+        else if (_identities.find(identity) != _identities.end())
+        {
+            //
+            // Only add the proxy to the router if it's not already in our local map.
+            //
+            return true;
+        }
+    }
+
+    Ice::ObjectProxySeq proxies;
+    proxies.emplace_back(ObjectPrx::_fromReference(reference));
+
+    _router->addProxiesAsync(
+        proxies,
+        [response = std::move(response), self = shared_from_this(), identity = std::move(identity)](
+            const Ice::ObjectProxySeq& evictedProxies)
+        {
+            self->addAndEvictProxies(identity, evictedProxies);
+            response();
+        },
+        std::move(ex));
+    return false;
+}
+
+void
+IceInternal::RouterInfo::setAdapter(const ObjectAdapterPtr& adapter)
+{
+    lock_guard lock(_mutex);
+    _adapter = adapter;
+}
+
+ObjectAdapterPtr
+IceInternal::RouterInfo::getAdapter() const
+{
+    lock_guard lock(_mutex);
+    return _adapter;
+}
+
+void
+IceInternal::RouterInfo::clearCache(const ReferencePtr& ref)
+{
+    lock_guard lock(_mutex);
+    _identities.erase(ref->getIdentity());
+}
+
+vector<EndpointIPtr>
+IceInternal::RouterInfo::setClientEndpoints(const optional<ObjectPrx>& proxy, bool hasRoutingTable)
+{
+    lock_guard lock(_mutex);
+    if (_clientEndpoints.empty())
+    {
+        _hasRoutingTable = hasRoutingTable;
+        _clientEndpoints = proxy ? proxy->_getReference()->getEndpoints() : _router->_getReference()->getEndpoints();
+    }
+    return _clientEndpoints;
+}
+
+void
+IceInternal::RouterInfo::addAndEvictProxies(const Identity& identity, const Ice::ObjectProxySeq& evictedProxies)
+{
+    lock_guard lock(_mutex);
+
+    //
+    // Check if the proxy hasn't already been evicted by a concurrent addProxies call.
+    // If it's the case, don't add it to our local map.
+    //
+    auto p = _evictedIdentities.find(identity);
+    if (p != _evictedIdentities.end())
+    {
+        _evictedIdentities.erase(p);
+    }
+    else
+    {
+        //
+        // If we successfully added the proxy to the router,
+        // we add it to our local map.
+        //
+        _identities.insert(identity);
+    }
+
+    //
+    // We also must remove whatever proxies the router evicted.
+    //
+    for (const auto& evictedProxy : evictedProxies)
+    {
+        if (_identities.erase(evictedProxy->ice_getIdentity()) == 0)
+        {
+            //
+            // It's possible for the proxy to not have been
+            // added yet in the local map if two threads
+            // concurrently call addProxies.
+            //
+            _evictedIdentities.insert(evictedProxy->ice_getIdentity());
+        }
+    }
+}

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

@@ -0,0 +1,95 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_ROUTER_INFO_H
+#define ICE_ROUTER_INFO_H
+
+#include "EndpointIF.h"
+#include "Ice/BuiltinSequences.h"
+#include "Ice/Identity.h"
+#include "Ice/ReferenceF.h"
+#include "Ice/Router.h"
+#include "RouterInfoF.h"
+
+#include <mutex>
+#include <set>
+
+namespace Ice
+{
+    class ObjectPrx;
+}
+
+namespace IceInternal
+{
+    class RouterManager final
+    {
+    public:
+        RouterManager();
+
+        void destroy();
+
+        //
+        // Returns router info for a given router. Automatically creates
+        // the router info if it doesn't exist yet.
+        //
+        RouterInfoPtr get(const Ice::RouterPrx&);
+        void erase(const Ice::RouterPrx&);
+
+    private:
+        using RouterInfoTable = std::map<Ice::RouterPrx, RouterInfoPtr>;
+
+        RouterInfoTable _table;
+        RouterInfoTable::iterator _tableHint;
+        std::mutex _mutex;
+    };
+
+    class RouterInfo final : public std::enable_shared_from_this<RouterInfo>
+    {
+    public:
+        RouterInfo(Ice::RouterPrx);
+
+        void destroy();
+
+        bool operator==(const RouterInfo&) const;
+        bool operator<(const RouterInfo&) const;
+
+        [[nodiscard]] Ice::RouterPrx getRouter() const
+        {
+            //
+            // No mutex lock necessary, _router is immutable.
+            //
+            return _router;
+        }
+
+        std::vector<EndpointIPtr> getClientEndpoints();
+
+        void getClientEndpointsAsync(
+            std::function<void(std::vector<EndpointIPtr>)> response,
+            std::function<void(std::exception_ptr)> ex);
+
+        std::vector<EndpointIPtr> getServerEndpoints();
+
+        bool addProxyAsync(
+            const ReferencePtr& proxy,
+            std::function<void()> response,
+            std::function<void(std::exception_ptr)> ex);
+
+        void setAdapter(const Ice::ObjectAdapterPtr&);
+        [[nodiscard]] Ice::ObjectAdapterPtr getAdapter() const;
+
+        void clearCache(const ReferencePtr&);
+
+    private:
+        void addAndEvictProxies(const Ice::Identity&, const Ice::ObjectProxySeq&);
+        std::vector<EndpointIPtr> setClientEndpoints(const std::optional<Ice::ObjectPrx>&, bool);
+
+        const Ice::RouterPrx _router;
+        std::vector<EndpointIPtr> _clientEndpoints;
+        bool _hasRoutingTable{false};
+        Ice::ObjectAdapterPtr _adapter;
+        std::set<Ice::Identity> _identities;
+        std::multiset<Ice::Identity> _evictedIdentities;
+        mutable std::mutex _mutex;
+    };
+}
+
+#endif

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

@@ -0,0 +1,17 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_ROUTER_INFO_F_H
+#define ICE_ROUTER_INFO_F_H
+
+#include <memory>
+
+namespace IceInternal
+{
+    class RouterManager;
+    using RouterManagerPtr = std::shared_ptr<RouterManager>;
+
+    class RouterInfo;
+    using RouterInfoPtr = std::shared_ptr<RouterInfo>;
+}
+
+#endif

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

@@ -0,0 +1,195 @@
+// Copyright (c) ZeroC, Inc.
+
+#include "SHA1.h"
+
+#if defined(_WIN32)
+#    include "Ice/LocalExceptions.h"
+// clang-format off
+#    include <windows.h>
+#    include <Wincrypt.h>
+// clang-format on
+#elif defined(__APPLE__)
+#    include <CommonCrypto/CommonDigest.h>
+#else
+#    include <openssl/sha.h>
+#    // Ignore OpenSSL 3.0 deprecation warning
+#    pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+
+using namespace std;
+
+namespace IceInternal
+{
+    class SHA1::Hasher
+    {
+    public:
+        Hasher();
+        Hasher(const Hasher&) = delete;
+#ifdef _WIN32
+        ~Hasher();
+#endif
+        Hasher operator=(const Hasher&) = delete;
+
+        void update(const unsigned char*, std::size_t);
+        void finalize(std::vector<unsigned char>&);
+        void finalize(vector<byte>&);
+
+    private:
+#if defined(_WIN32)
+        HCRYPTPROV _ctx;
+        HCRYPTHASH _hash;
+#elif defined(__APPLE__)
+        CC_SHA1_CTX _ctx;
+#else
+        SHA_CTX _ctx;
+#endif
+    };
+}
+
+#if defined(_WIN32)
+
+namespace
+{
+    const int SHA_DIGEST_LENGTH = 20;
+}
+
+IceInternal::SHA1::Hasher::Hasher() : _ctx(0), _hash(0)
+{
+    if (!CryptAcquireContext(&_ctx, 0, MS_DEF_PROV, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT))
+    {
+        throw Ice::SyscallException{__FILE__, __LINE__, "CryptAcquireContext failed", GetLastError()};
+    }
+
+    if (!CryptCreateHash(_ctx, CALG_SHA1, 0, 0, &_hash))
+    {
+        throw Ice::SyscallException{__FILE__, __LINE__, "CryptCreateHash failed", GetLastError()};
+    }
+}
+
+IceInternal::SHA1::Hasher::~Hasher()
+{
+    if (_hash)
+    {
+        CryptDestroyHash(_hash);
+    }
+
+    if (_ctx)
+    {
+        CryptReleaseContext(_ctx, 0);
+    }
+}
+#elif defined(__APPLE__)
+IceInternal::SHA1::Hasher::Hasher() { CC_SHA1_Init(&_ctx); }
+#else
+IceInternal::SHA1::Hasher::Hasher() { SHA1_Init(&_ctx); }
+#endif
+
+void
+IceInternal::SHA1::Hasher::update(const unsigned char* data, size_t length)
+{
+#if defined(_WIN32)
+    if (!CryptHashData(_hash, data, static_cast<DWORD>(length), 0))
+    {
+        throw Ice::SyscallException{__FILE__, __LINE__, "CryptHashData failed", GetLastError()};
+    }
+#elif defined(__APPLE__)
+    CC_SHA1_Update(&_ctx, reinterpret_cast<const void*>(data), static_cast<CC_LONG>(length));
+#else
+    SHA1_Update(&_ctx, reinterpret_cast<const void*>(data), length);
+#endif
+}
+
+void
+IceInternal::SHA1::Hasher::finalize(vector<unsigned char>& md)
+{
+#if defined(_WIN32)
+    md.resize(SHA_DIGEST_LENGTH);
+    DWORD length = SHA_DIGEST_LENGTH;
+    if (!CryptGetHashParam(_hash, HP_HASHVAL, &md[0], &length, 0))
+    {
+        throw Ice::SyscallException{__FILE__, __LINE__, "CryptGetHashParam failed", GetLastError()};
+    }
+#elif defined(__APPLE__)
+    md.resize(CC_SHA1_DIGEST_LENGTH);
+    CC_SHA1_Final(&md[0], &_ctx);
+#else
+    md.resize(SHA_DIGEST_LENGTH);
+    SHA1_Final(&md[0], &_ctx);
+#endif
+}
+
+void
+IceInternal::SHA1::Hasher::finalize(vector<byte>& md)
+{
+#if defined(_WIN32)
+    md.resize(SHA_DIGEST_LENGTH);
+    DWORD length = SHA_DIGEST_LENGTH;
+    if (!CryptGetHashParam(_hash, HP_HASHVAL, reinterpret_cast<unsigned char*>(&md[0]), &length, 0))
+    {
+        throw Ice::SyscallException{__FILE__, __LINE__, "CryptGetHashParam failed", GetLastError()};
+    }
+#elif defined(__APPLE__)
+    md.resize(CC_SHA1_DIGEST_LENGTH);
+    CC_SHA1_Final(reinterpret_cast<unsigned char*>(&md[0]), &_ctx);
+#else
+    md.resize(SHA_DIGEST_LENGTH);
+    SHA1_Final(reinterpret_cast<unsigned char*>(&md[0]), &_ctx);
+#endif
+}
+
+IceInternal::SHA1::SHA1() : _hasher(new Hasher()) {}
+
+IceInternal::SHA1::~SHA1() = default;
+
+void
+IceInternal::SHA1::update(const unsigned char* data, std::size_t length)
+{
+    _hasher->update(data, length);
+}
+
+void
+IceInternal::SHA1::finalize(std::vector<unsigned char>& md)
+{
+    _hasher->finalize(md);
+}
+
+void
+IceInternal::SHA1::finalize(std::vector<byte>& md)
+{
+    _hasher->finalize(md);
+}
+
+void
+IceInternal::sha1(const unsigned char* data, size_t length, vector<unsigned char>& md)
+{
+#if defined(_WIN32)
+    SHA1 hasher;
+    hasher.update(data, length);
+    hasher.finalize(md);
+#elif defined(__APPLE__)
+    md.resize(CC_SHA1_DIGEST_LENGTH);
+    CC_SHA1(&data[0], static_cast<CC_LONG>(length), &md[0]);
+#else
+    md.resize(SHA_DIGEST_LENGTH);
+    ::SHA1(&data[0], length, &md[0]);
+#endif
+}
+
+void
+IceInternal::sha1(const byte* data, size_t length, vector<byte>& md)
+{
+#if defined(_WIN32)
+    SHA1 hasher;
+    hasher.update(reinterpret_cast<const unsigned char*>(data), length);
+    hasher.finalize(md);
+#elif defined(__APPLE__)
+    md.resize(CC_SHA1_DIGEST_LENGTH);
+    CC_SHA1(
+        reinterpret_cast<const unsigned char*>(&data[0]),
+        static_cast<CC_LONG>(length),
+        reinterpret_cast<unsigned char*>(&md[0]));
+#else
+    md.resize(SHA_DIGEST_LENGTH);
+    ::SHA1(reinterpret_cast<const unsigned char*>(&data[0]), length, reinterpret_cast<unsigned char*>(&md[0]));
+#endif
+}

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

@@ -0,0 +1,35 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_SHA1_H
+#define ICE_SHA1_H
+
+#include "Ice/Config.h"
+
+#include <memory>
+#include <vector>
+
+namespace IceInternal
+{
+    ICE_API void sha1(const unsigned char*, std::size_t, std::vector<unsigned char>&);
+
+    ICE_API void sha1(const std::byte*, std::size_t, std::vector<std::byte>&);
+
+    class ICE_API SHA1
+    {
+    public:
+        SHA1();
+        ~SHA1();
+
+        SHA1(const SHA1&) = delete;
+        SHA1 operator=(const SHA1&) = delete;
+
+        void update(const unsigned char*, std::size_t);
+        void finalize(std::vector<unsigned char>&);
+        void finalize(std::vector<std::byte>&);
+
+    private:
+        class Hasher;
+        std::unique_ptr<Hasher> _hasher;
+    };
+}
+#endif

data/dist/ice/cpp/src/Ice/SSL/DistinguishedName.cpp

@@ -0,0 +1,89 @@
+// Copyright (c) ZeroC, Inc.
+
+#include "DistinguishedName.h"
+#include "RFC2253.h"
+
+#include <sstream>
+
+using namespace std;
+using namespace Ice;
+using namespace Ice::SSL;
+
+DistinguishedName::DistinguishedName(const string& dn) : _rdns(RFC2253::parseStrict(dn)) { unescape(); }
+
+DistinguishedName::DistinguishedName(const list<pair<string, string>>& rdns) : _rdns(rdns) { unescape(); }
+
+namespace Ice::SSL
+{
+    bool operator==(const DistinguishedName& lhs, const DistinguishedName& rhs)
+    {
+        return lhs._unescaped == rhs._unescaped;
+    }
+
+    bool operator<(const DistinguishedName& lhs, const DistinguishedName& rhs)
+    {
+        return lhs._unescaped < rhs._unescaped;
+    }
+}
+
+bool
+DistinguishedName::match(const DistinguishedName& other) const
+{
+    for (const auto& p : other._unescaped)
+    {
+        bool found = false;
+        for (const auto& q : _unescaped)
+        {
+            if (p.first == q.first)
+            {
+                found = true;
+                if (p.second != q.second)
+                {
+                    return false;
+                }
+            }
+        }
+        if (!found)
+        {
+            return false;
+        }
+    }
+    return true;
+}
+
+bool
+DistinguishedName::match(const string& other) const
+{
+    return match(DistinguishedName(other));
+}
+
+//
+// This always produces the same output as the input DN -- the type of
+// escaping is not changed.
+//
+std::string
+DistinguishedName::toString() const
+{
+    ostringstream os;
+    bool first = true;
+    for (const auto& rdn : _rdns)
+    {
+        if (!first)
+        {
+            os << ",";
+        }
+        first = false;
+        os << rdn.first << "=" << rdn.second;
+    }
+    return os.str();
+}
+
+void
+DistinguishedName::unescape()
+{
+    for (auto rdn : _rdns)
+    {
+        rdn.second = RFC2253::unescape(rdn.second);
+        _unescaped.push_back(rdn);
+    }
+}