zeroc-ice 3.7.11 → 3.8.1

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

@@ -1,152 +1,95 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef ICE_ROUTER_INFO_H
 #define ICE_ROUTER_INFO_H
 
-#include <IceUtil/Mutex.h>
-#include <Ice/RouterInfoF.h>
-#include <Ice/Router.h>
-#include <Ice/ProxyF.h>
-#include <Ice/ReferenceF.h>
-#include <Ice/EndpointIF.h>
-#include <Ice/BuiltinSequences.h>
-#include <Ice/Identity.h>
-#include <Ice/Comparable.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 IceInternal
-{
-
-class RouterManager : public IceUtil::Shared, public IceUtil::Mutex
+namespace Ice
 {
-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::RouterPrxPtr&);
-    RouterInfoPtr erase(const Ice::RouterPrxPtr&);
-
-private:
-
-#ifdef ICE_CPP11_MAPPING
-    using RouterInfoTable = std::map<std::shared_ptr<Ice::RouterPrx>,
-                                     RouterInfoPtr,
-                                     Ice::TargetCompare<std::shared_ptr<Ice::RouterPrx>, std::less>>;
-#else
-    typedef std::map<Ice::RouterPrx, RouterInfoPtr> RouterInfoTable;
-#endif
-
-    RouterInfoTable _table;
-    RouterInfoTable::iterator _tableHint;
-};
+    class ObjectPrx;
+}
 
-class RouterInfo : public IceUtil::Shared, public IceUtil::Mutex
+namespace IceInternal
 {
-public:
-
-    class GetClientEndpointsCallback : public virtual Ice::LocalObject
+    class RouterManager final
     {
     public:
+        RouterManager();
 
-        virtual void setEndpoints(const std::vector<EndpointIPtr>&) = 0;
-        virtual void setException(const Ice::LocalException&) = 0;
-    };
-    typedef IceUtil::Handle<GetClientEndpointsCallback> GetClientEndpointsCallbackPtr;
+        void destroy();
 
-    class AddProxyCallback
-#ifndef ICE_CPP11_MAPPING
-        : public virtual IceUtil::Shared
-#endif
-    {
-    public:
-
-        virtual void addedProxy() = 0;
-        virtual void setException(const Ice::LocalException&) = 0;
-    };
-    ICE_DEFINE_PTR(AddProxyCallbackPtr, AddProxyCallback);
-
-    RouterInfo(const Ice::RouterPrxPtr&);
+        //
+        // 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&);
 
-    void destroy();
+    private:
+        using RouterInfoTable = std::map<Ice::RouterPrx, RouterInfoPtr>;
 
-    bool operator==(const RouterInfo&) const;
-    bool operator<(const RouterInfo&) const;
+        RouterInfoTable _table;
+        RouterInfoTable::iterator _tableHint;
+        std::mutex _mutex;
+    };
 
-    const Ice::RouterPrxPtr& getRouter() const
-    {
-        //
-        // No mutex lock necessary, _router is immutable.
-        //
-        return _router;
-    }
-    void getClientProxyResponse(const Ice::ObjectPrxPtr&, const IceUtil::Optional<bool>&,
-                                const GetClientEndpointsCallbackPtr&);
-    void getClientProxyException(const Ice::Exception&, const GetClientEndpointsCallbackPtr&);
-    std::vector<EndpointIPtr> getClientEndpoints();
-    void getClientEndpoints(const GetClientEndpointsCallbackPtr&);
-    std::vector<EndpointIPtr> getServerEndpoints();
-
-    class AddProxyCookie : public Ice::LocalObject
+    class RouterInfo final : public std::enable_shared_from_this<RouterInfo>
     {
     public:
+        RouterInfo(Ice::RouterPrx);
 
-        AddProxyCookie(const AddProxyCallbackPtr cb, const Ice::ObjectPrxPtr& proxy) :
-            _cb(cb),
-            _proxy(proxy)
-        {
-        }
+        void destroy();
 
-        AddProxyCallbackPtr cb() const
-        {
-            return _cb;
-        }
+        bool operator==(const RouterInfo&) const;
+        bool operator<(const RouterInfo&) const;
 
-        Ice::ObjectPrxPtr proxy() const
+        [[nodiscard]] Ice::RouterPrx getRouter() const
         {
-            return _proxy;
+            //
+            // No mutex lock necessary, _router is immutable.
+            //
+            return _router;
         }
 
-    private:
+        std::vector<EndpointIPtr> getClientEndpoints();
 
-        const AddProxyCallbackPtr _cb;
-        const Ice::ObjectPrxPtr _proxy;
-    };
-    typedef IceUtil::Handle<AddProxyCookie> AddProxyCookiePtr;
+        void getClientEndpointsAsync(
+            std::function<void(std::vector<EndpointIPtr>)> response,
+            std::function<void(std::exception_ptr)> ex);
 
-    void addProxyResponse(const Ice::ObjectProxySeq&, const AddProxyCookiePtr&);
-    void addProxyException(const Ice::Exception&, const AddProxyCookiePtr&);
-    bool addProxy(const Ice::ObjectPrxPtr&, const AddProxyCallbackPtr&);
+        std::vector<EndpointIPtr> getServerEndpoints();
 
-    void setAdapter(const Ice::ObjectAdapterPtr&);
-    Ice::ObjectAdapterPtr getAdapter() const;
+        bool addProxyAsync(
+            const ReferencePtr& proxy,
+            std::function<void()> response,
+            std::function<void(std::exception_ptr)> ex);
 
-    void clearCache(const ReferencePtr&);
+        void setAdapter(const Ice::ObjectAdapterPtr&);
+        [[nodiscard]] Ice::ObjectAdapterPtr getAdapter() const;
 
-    //
-    // The following methods need to be public for access by AMI callbacks.
-    //
-    std::vector<EndpointIPtr> setClientEndpoints(const Ice::ObjectPrxPtr&, bool);
-    void addAndEvictProxies(const Ice::ObjectPrxPtr&, const Ice::ObjectProxySeq&);
-
-private:
-
-    const Ice::RouterPrxPtr _router;
-    std::vector<EndpointIPtr> _clientEndpoints;
-    bool _hasRoutingTable;
-    Ice::ObjectAdapterPtr _adapter;
-    std::set<Ice::Identity> _identities;
-    std::multiset<Ice::Identity> _evictedIdentities;
-};
+        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

@@ -1,25 +1,17 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef ICE_ROUTER_INFO_F_H
 #define ICE_ROUTER_INFO_F_H
 
-#include <IceUtil/Shared.h>
-
-#include <Ice/Handle.h>
+#include <memory>
 
 namespace IceInternal
 {
+    class RouterManager;
+    using RouterManagerPtr = std::shared_ptr<RouterManager>;
 
-class RouterManager;
-IceUtil::Shared* upCast(RouterManager*);
-typedef Handle<RouterManager> RouterManagerPtr;
-
-class RouterInfo;
-IceUtil::Shared* upCast(RouterInfo*);
-typedef Handle<RouterInfo> RouterInfoPtr;
-
+    class RouterInfo;
+    using RouterInfoPtr = std::shared_ptr<RouterInfo>;
 }
 
 #endif

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

@@ -1,109 +1,96 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
-#include <Ice/SHA1.h>
+#include "SHA1.h"
 
 #if defined(_WIN32)
-#   include <Wincrypt.h>
-#   include <IceUtil/Exception.h>
+#    include "Ice/LocalExceptions.h"
+// clang-format off
+#    include <windows.h>
+#    include <Wincrypt.h>
+// clang-format on
 #elif defined(__APPLE__)
-#   include <CommonCrypto/CommonDigest.h>
+#    include <CommonCrypto/CommonDigest.h>
 #else
-#   include <openssl/sha.h>
-#   // Ignore OpenSSL 3.0 deprecation warning
-#   pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#    include <openssl/sha.h>
+#    // Ignore OpenSSL 3.0 deprecation warning
+#    pragma GCC diagnostic ignored "-Wdeprecated-declarations"
 #endif
 
 using namespace std;
-using namespace IceUtil;
 
 namespace IceInternal
 {
-
-class SHA1::Hasher
-{
-public:
-
-    Hasher();
+    class SHA1::Hasher
+    {
+    public:
+        Hasher();
+        Hasher(const Hasher&) = delete;
 #ifdef _WIN32
-    ~Hasher();
+        ~Hasher();
 #endif
+        Hasher operator=(const Hasher&) = delete;
 
-    void update(const unsigned char*, std::size_t);
-    void finalize(std::vector<unsigned char>&);
-
-private:
-
-    // noncopyable
-    Hasher(const Hasher&);
-    Hasher operator=(const Hasher&);
+        void update(const unsigned char*, std::size_t);
+        void finalize(std::vector<unsigned char>&);
+        void finalize(vector<byte>&);
 
-#if defined (_WIN32)
-    HCRYPTPROV _ctx;
-    HCRYPTHASH _hash;
+    private:
+#if defined(_WIN32)
+        HCRYPTPROV _ctx;
+        HCRYPTHASH _hash;
 #elif defined(__APPLE__)
-    CC_SHA1_CTX _ctx;
+        CC_SHA1_CTX _ctx;
 #else
-    SHA_CTX _ctx;
+        SHA_CTX _ctx;
 #endif
-};
-
+    };
 }
 
 #if defined(_WIN32)
 
 namespace
 {
-const int SHA_DIGEST_LENGTH = 20;
+    const int SHA_DIGEST_LENGTH = 20;
 }
 
-IceInternal::SHA1::Hasher::Hasher() :
-    _ctx(0),
-    _hash(0)
+IceInternal::SHA1::Hasher::Hasher() : _ctx(0), _hash(0)
 {
-    if(!CryptAcquireContext(&_ctx, 0, MS_DEF_PROV, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT))
+    if (!CryptAcquireContext(&_ctx, 0, MS_DEF_PROV, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT))
     {
-        throw IceUtil::SyscallException(__FILE__, __LINE__, GetLastError());
+        throw Ice::SyscallException{__FILE__, __LINE__, "CryptAcquireContext failed", GetLastError()};
     }
 
-    if(!CryptCreateHash(_ctx, CALG_SHA1, 0, 0, &_hash))
+    if (!CryptCreateHash(_ctx, CALG_SHA1, 0, 0, &_hash))
     {
-        throw IceUtil::SyscallException(__FILE__, __LINE__, GetLastError());
+        throw Ice::SyscallException{__FILE__, __LINE__, "CryptCreateHash failed", GetLastError()};
     }
 }
 
 IceInternal::SHA1::Hasher::~Hasher()
 {
-    if(_hash)
+    if (_hash)
     {
         CryptDestroyHash(_hash);
     }
 
-    if(_ctx)
+    if (_ctx)
     {
         CryptReleaseContext(_ctx, 0);
     }
 }
 #elif defined(__APPLE__)
-IceInternal::SHA1::Hasher::Hasher()
-{
-    CC_SHA1_Init(&_ctx);
-}
+IceInternal::SHA1::Hasher::Hasher() { CC_SHA1_Init(&_ctx); }
 #else
-IceInternal::SHA1::Hasher::Hasher()
-{
-    SHA1_Init(&_ctx);
-}
+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))
+    if (!CryptHashData(_hash, data, static_cast<DWORD>(length), 0))
     {
-        throw IceUtil::SyscallException(__FILE__, __LINE__, GetLastError());
+        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));
@@ -118,9 +105,9 @@ 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))
+    if (!CryptGetHashParam(_hash, HP_HASHVAL, &md[0], &length, 0))
     {
-        throw IceUtil::SyscallException(__FILE__, __LINE__, GetLastError());
+        throw Ice::SyscallException{__FILE__, __LINE__, "CryptGetHashParam failed", GetLastError()};
     }
 #elif defined(__APPLE__)
     md.resize(CC_SHA1_DIGEST_LENGTH);
@@ -131,14 +118,28 @@ IceInternal::SHA1::Hasher::finalize(vector<unsigned char>& md)
 #endif
 }
 
-IceInternal::SHA1::SHA1() :
-    _hasher(new Hasher())
+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()
-{
-}
+IceInternal::SHA1::SHA1() : _hasher(new Hasher()) {}
+
+IceInternal::SHA1::~SHA1() = default;
 
 void
 IceInternal::SHA1::update(const unsigned char* data, std::size_t length)
@@ -152,6 +153,12 @@ 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)
 {
@@ -167,3 +174,22 @@ IceInternal::sha1(const unsigned char* data, size_t length, vector<unsigned char
     ::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);
+    }
+}

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

@@ -0,0 +1,87 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_SSL_DISTINGUISHED_NAME_H
+#define ICE_SSL_DISTINGUISHED_NAME_H
+
+#include "Ice/Config.h"
+
+#include <list>
+#include <string>
+
+namespace Ice::SSL
+{
+    /// This class represents a DistinguishedName, similar to the Java
+    /// type X500Principal and the .NET type X500DistinguishedName.
+    ///
+    /// For comparison purposes, the value of a relative distinguished
+    /// name (RDN) component is always unescaped before matching,
+    /// therefore "ZeroC, Inc." will match ZeroC\, Inc.
+    ///
+    /// toString() always returns exactly the same information as was
+    /// provided in the constructor (i.e., "ZeroC, Inc." will not turn
+    /// into ZeroC\, Inc.).
+    class DistinguishedName
+    {
+    public:
+        /// Creates a DistinguishedName from a string encoded using the rules in RFC2253.
+        /// @param name The encoded distinguished name.
+        /// @throws ParseException if parsing fails.
+        explicit DistinguishedName(const std::string& name);
+
+        /// Creates a DistinguishedName from a list of RDN pairs,
+        /// where each pair consists of the RDN's type and value.
+        /// For example, the RDN "O=ZeroC" is represented by the
+        /// pair ("O", "ZeroC").
+        /// @throws ParseException if parsing fails.
+        explicit DistinguishedName(const std::list<std::pair<std::string, std::string>>&);
+
+        /// Performs an exact match. The order of the RDN components is important.
+        friend bool operator==(const DistinguishedName&, const DistinguishedName&);
+
+        /// Performs an exact match. The order of the RDN components is important.
+        friend bool operator<(const DistinguishedName&, const DistinguishedName&);
+
+        /// Performs a partial match with another DistinguishedName.
+        /// @param dn The name to be matched.
+        /// @return `true` if all of the RDNs in the argument are present in this
+        /// DistinguishedName and they have the same values.
+        [[nodiscard]] bool match(const DistinguishedName& dn) const;
+
+        /// Performs a partial match with another DistinguishedName.
+        /// @param dn The name to be matched.
+        /// @return `true` if all of the RDNs in the argument are present in this
+        /// DistinguishedName and they have the same values.
+        [[nodiscard]] bool match(const std::string& dn) const;
+
+        /// Encodes the DN in RFC2253 format.
+        /// @return An encoded string.
+        [[nodiscard]] std::string toString() const;
+
+        /// Encodes the DN in RFC2253 format.
+        /// @return An encoded string.
+        operator std::string() const { return toString(); }
+
+    protected:
+        /// @cond INTERNAL
+        void unescape();
+        /// @endcond
+
+    private:
+        std::list<std::pair<std::string, std::string>> _rdns;
+        std::list<std::pair<std::string, std::string>> _unescaped;
+    };
+
+    /// Performs an exact match. The order of the RDN components is important.
+    inline bool operator>(const DistinguishedName& lhs, const DistinguishedName& rhs) { return rhs < lhs; }
+
+    /// Performs an exact match. The order of the RDN components is important.
+    inline bool operator<=(const DistinguishedName& lhs, const DistinguishedName& rhs) { return !(lhs > rhs); }
+
+    /// Performs an exact match. The order of the RDN components is important.
+    inline bool operator>=(const DistinguishedName& lhs, const DistinguishedName& rhs) { return !(lhs < rhs); }
+
+    /// Performs an exact match. The order of the RDN components is important.
+    inline bool operator!=(const DistinguishedName& lhs, const DistinguishedName& rhs) { return !(lhs == rhs); }
+}
+
+#endif