zeroc-ice 3.8.1 → 3.8.3

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

@@ -1,29 +1,90 @@
 // Copyright (c) ZeroC, Inc.
 
+#ifdef _WIN32
+#    define _CRT_RAND_S
+#endif
+
 #include "Random.h"
 
+#include <array>
 #include <cassert>
+#include <cstdint>
+#include <cstdlib>
+#include <cstring>
+#include <system_error>
+
+#if defined(__linux__)
+#    include <cerrno>
+#    include <sys/random.h>
+#endif
 
 using namespace std;
 
+// Generate the random bytes with the operating system's CSPRNG, never with std::random_device: the C++
+// standard gives std::random_device no cryptographic guarantee, and some implementations draw from raw CPU
+// entropy instructions whose output defective hardware can make predictable.
 void
 IceInternal::generateRandom(char* buffer, size_t size)
 {
-    // We use the random_device directly here to get cryptographic random numbers when possible.
-    thread_local static std::random_device rd;
-    uniform_int_distribution<unsigned int> distribution(0, 255);
-    for (size_t i = 0; i < size; ++i, ++buffer)
+#if defined(_WIN32)
+    // rand_s is backed by the same system CSPRNG as BCryptGenRandom and requires no additional link
+    // dependency.
+    size_t index = 0;
+    while (index < size)
+    {
+        unsigned int r = 0;
+        errno_t err = rand_s(&r);
+        if (err != 0)
+        {
+            throw system_error(err, generic_category(), "rand_s failed");
+        }
+        size_t n = min(sizeof(r), size - index);
+        memcpy(buffer + index, &r, n);
+        index += n;
+    }
+#elif defined(__APPLE__) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__)
+    arc4random_buf(buffer, size);
+#elif defined(__linux__)
+    // getrandom with flags == 0 deliberately blocks until the kernel's entropy pool is initialized; don't
+    // "fix" this with GRND_NONBLOCK. There is also deliberately no /dev/urandom fallback here: getrandom is
+    // available in every supported glibc (2.25+), so a failure is a real error, not a missing feature.
+    size_t index = 0;
+    while (index < size)
     {
-        *buffer = static_cast<char>(distribution(rd));
+        ssize_t n = getrandom(buffer + index, size - index, 0);
+        if (n <= 0)
+        {
+            if (n < 0 && errno == EINTR)
+            {
+                continue;
+            }
+            if (n == 0)
+            {
+                throw system_error(EIO, generic_category(), "getrandom returned no data");
+            }
+            throw system_error(errno, generic_category(), "getrandom failed");
+        }
+        index += static_cast<size_t>(n);
     }
+#else
+#    error "unsupported platform: no OS CSPRNG binding"
+#endif
 }
 
 unsigned int
 IceInternal::random(unsigned int limit)
 {
     assert(limit > 0);
-    thread_local static std::random_device rd;
-    thread_local static std::mt19937 rng(rd());
+    thread_local static mt19937 rng = createMT19937();
     uniform_int_distribution<unsigned int> distribution(0, limit - 1);
     return distribution(rng);
 }
+
+mt19937
+IceInternal::createMT19937()
+{
+    array<uint32_t, 8> seedData;
+    generateRandom(reinterpret_cast<char*>(seedData.data()), sizeof(seedData));
+    seed_seq seq(seedData.begin(), seedData.end());
+    return mt19937(seq);
+}

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

@@ -9,13 +9,17 @@
 
 namespace IceInternal
 {
+    // Fills the buffer with cryptographically strong random bytes from the operating system's CSPRNG.
     ICE_API void generateRandom(char*, size_t);
+
     ICE_API unsigned int random(unsigned int = 0);
 
+    // Creates a std::mt19937 engine seeded from the operating system's CSPRNG.
+    ICE_API std::mt19937 createMT19937();
+
     template<class T> void shuffle(T first, T last)
     {
-        thread_local static std::random_device rd;
-        thread_local static std::mt19937 rng(rd());
+        thread_local static std::mt19937 rng = createMT19937();
         std::shuffle(first, last, rng);
     }
 }

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

@@ -549,7 +549,7 @@ IceInternal::FixedReference::changeConnectionId(string) const
 ReferencePtr
 IceInternal::FixedReference::changeConnection(Ice::ConnectionIPtr newConnection) const
 {
-    FixedReferencePtr r = dynamic_pointer_cast<FixedReference>(clone());
+    FixedReferencePtr r = static_pointer_cast<FixedReference>(clone());
     r->_fixedConnection = std::move(newConnection);
     return r;
 }
@@ -787,7 +787,7 @@ IceInternal::RoutableReference::changeEncoding(Ice::EncodingVersion encoding) co
     ReferencePtr r = Reference::changeEncoding(encoding);
     if (r.get() != const_cast<RoutableReference*>(this))
     {
-        LocatorInfoPtr& locInfo = dynamic_pointer_cast<RoutableReference>(r)->_locatorInfo;
+        LocatorInfoPtr& locInfo = static_pointer_cast<RoutableReference>(r)->_locatorInfo;
         if (locInfo && locInfo->getLocator()->ice_getEncodingVersion() != encoding)
         {
             locInfo = getInstance()->locatorManager()->get(locInfo->getLocator()->ice_encodingVersion(encoding));
@@ -809,7 +809,7 @@ IceInternal::RoutableReference::changeCompress(bool newCompress) const
         {
             newEndpoints.push_back(endpoint->compress(newCompress));
         }
-        dynamic_pointer_cast<RoutableReference>(r)->_endpoints = newEndpoints;
+        static_pointer_cast<RoutableReference>(r)->_endpoints = std::move(newEndpoints);
     }
     return r;
 }
@@ -817,7 +817,7 @@ IceInternal::RoutableReference::changeCompress(bool newCompress) const
 ReferencePtr
 IceInternal::RoutableReference::changeEndpoints(vector<EndpointIPtr> newEndpoints) const
 {
-    RoutableReferencePtr r = dynamic_pointer_cast<RoutableReference>(clone());
+    RoutableReferencePtr r = static_pointer_cast<RoutableReference>(clone());
     r->_endpoints = std::move(newEndpoints);
     r->applyOverrides(r->_endpoints);
     r->_adapterId.clear();
@@ -827,7 +827,7 @@ IceInternal::RoutableReference::changeEndpoints(vector<EndpointIPtr> newEndpoint
 ReferencePtr
 IceInternal::RoutableReference::changeAdapterId(string newAdapterId) const
 {
-    RoutableReferencePtr r = dynamic_pointer_cast<RoutableReference>(clone());
+    RoutableReferencePtr r = static_pointer_cast<RoutableReference>(clone());
     r->_adapterId = std::move(newAdapterId);
     r->_endpoints.clear();
     return r;
@@ -837,7 +837,7 @@ ReferencePtr
 IceInternal::RoutableReference::changeLocator(optional<LocatorPrx> newLocator) const
 {
     LocatorInfoPtr newLocatorInfo = newLocator ? getInstance()->locatorManager()->get(newLocator.value()) : nullptr;
-    RoutableReferencePtr r = dynamic_pointer_cast<RoutableReference>(clone());
+    RoutableReferencePtr r = static_pointer_cast<RoutableReference>(clone());
     r->_locatorInfo = std::move(newLocatorInfo);
     return r;
 }
@@ -846,7 +846,7 @@ ReferencePtr
 IceInternal::RoutableReference::changeRouter(optional<RouterPrx> newRouter) const
 {
     RouterInfoPtr newRouterInfo = newRouter ? getInstance()->routerManager()->get(newRouter.value()) : nullptr;
-    RoutableReferencePtr r = dynamic_pointer_cast<RoutableReference>(clone());
+    RoutableReferencePtr r = static_pointer_cast<RoutableReference>(clone());
     r->_routerInfo = std::move(newRouterInfo);
     return r;
 }
@@ -854,7 +854,7 @@ IceInternal::RoutableReference::changeRouter(optional<RouterPrx> newRouter) cons
 ReferencePtr
 IceInternal::RoutableReference::changeCollocationOptimized(bool newCollocationOptimized) const
 {
-    RoutableReferencePtr r = dynamic_pointer_cast<RoutableReference>(clone());
+    RoutableReferencePtr r = static_pointer_cast<RoutableReference>(clone());
     r->_collocationOptimized = newCollocationOptimized;
     return r;
 }
@@ -862,7 +862,7 @@ IceInternal::RoutableReference::changeCollocationOptimized(bool newCollocationOp
 ReferencePtr
 IceInternal::RoutableReference::changeCacheConnection(bool newCache) const
 {
-    RoutableReferencePtr r = dynamic_pointer_cast<RoutableReference>(clone());
+    RoutableReferencePtr r = static_pointer_cast<RoutableReference>(clone());
     r->_cacheConnection = newCache;
     return r;
 }
@@ -870,7 +870,7 @@ IceInternal::RoutableReference::changeCacheConnection(bool newCache) const
 ReferencePtr
 IceInternal::RoutableReference::changeEndpointSelection(EndpointSelectionType newType) const
 {
-    RoutableReferencePtr r = dynamic_pointer_cast<RoutableReference>(clone());
+    RoutableReferencePtr r = static_pointer_cast<RoutableReference>(clone());
     r->_endpointSelection = newType;
     return r;
 }
@@ -878,7 +878,7 @@ IceInternal::RoutableReference::changeEndpointSelection(EndpointSelectionType ne
 ReferencePtr
 IceInternal::RoutableReference::changeLocatorCacheTimeout(chrono::milliseconds timeout) const
 {
-    RoutableReferencePtr r = dynamic_pointer_cast<RoutableReference>(clone());
+    RoutableReferencePtr r = static_pointer_cast<RoutableReference>(clone());
     r->_locatorCacheTimeout = timeout;
     return r;
 }
@@ -886,7 +886,7 @@ IceInternal::RoutableReference::changeLocatorCacheTimeout(chrono::milliseconds t
 ReferencePtr
 IceInternal::RoutableReference::changeConnectionId(string id) const
 {
-    RoutableReferencePtr r = dynamic_pointer_cast<RoutableReference>(clone());
+    RoutableReferencePtr r = static_pointer_cast<RoutableReference>(clone());
     r->_connectionId = id;
     if (!_endpoints.empty()) // Also override the connection id on the endpoints.
     {
@@ -896,7 +896,7 @@ IceInternal::RoutableReference::changeConnectionId(string id) const
         {
             newEndpoints.push_back(endpoint->connectionId(id));
         }
-        r->_endpoints = newEndpoints;
+        r->_endpoints = std::move(newEndpoints);
     }
     return r;
 }
@@ -1013,9 +1013,15 @@ IceInternal::RoutableReference::toProperty(string prefix) const
     properties[prefix + ".ConnectionCached"] = _cacheConnection ? "1" : "0";
     properties[prefix + ".EndpointSelection"] =
         _endpointSelection == EndpointSelectionType::Random ? "Random" : "Ordered";
+    // An invocation timeout of zero or any negative timeout means infinite; a negative locator cache timeout also
+    // means infinite. We emit these as -1, the documented value for infinite. A positive timeout that is not a whole
+    // number of the property's unit is rounded up, to the next whole number.
+    // TODO: remove this normalization in 3.9, once the timeouts are always normalized: in 3.8, code compiled
+    // against older headers can still set non-normalized values.
     properties[prefix + ".LocatorCacheTimeout"] =
-        to_string(chrono::duration_cast<chrono::seconds>(_locatorCacheTimeout).count());
-    properties[prefix + ".InvocationTimeout"] = to_string(getInvocationTimeout().count());
+        _locatorCacheTimeout < 0ms ? "-1" : to_string(chrono::ceil<chrono::seconds>(_locatorCacheTimeout).count());
+    chrono::milliseconds invocationTimeout = getInvocationTimeout();
+    properties[prefix + ".InvocationTimeout"] = invocationTimeout <= 0ms ? "-1" : to_string(invocationTimeout.count());
 
     if (_routerInfo)
     {
@@ -1200,7 +1206,12 @@ IceInternal::RoutableReference::operator<(const Reference& r) const noexcept
     {
         return true;
     }
-    else if (rhs->_endpoints < _endpoints)
+    else if (lexicographical_compare(
+                 rhs->_endpoints.begin(),
+                 rhs->_endpoints.end(),
+                 _endpoints.begin(),
+                 _endpoints.end(),
+                 Ice::TargetCompare<shared_ptr<EndpointI>, std::less>()))
     {
         return false;
     }
@@ -1259,7 +1270,7 @@ IceInternal::RoutableReference::getConnectionAsync(
     if (_routerInfo)
     {
         // If we route, we send everything to the router's client proxy endpoints.
-        auto self = dynamic_pointer_cast<RoutableReference>(const_cast<RoutableReference*>(this)->shared_from_this());
+        auto self = static_pointer_cast<RoutableReference>(const_cast<RoutableReference*>(this)->shared_from_this());
 
         _routerInfo->getClientEndpointsAsync(
             [self = std::move(self), response = std::move(response), exception](vector<EndpointIPtr> endpoints) mutable
@@ -1364,7 +1375,7 @@ IceInternal::RoutableReference::getConnectionNoRouterInfoAsync(
     if (_locatorInfo)
     {
         RoutableReferencePtr self =
-            dynamic_pointer_cast<RoutableReference>(const_cast<RoutableReference*>(this)->shared_from_this());
+            static_pointer_cast<RoutableReference>(const_cast<RoutableReference*>(this)->shared_from_this());
         _locatorInfo->getEndpoints(
             self,
             _locatorCacheTimeout,
@@ -1398,7 +1409,7 @@ IceInternal::RoutableReference::createConnectionAsync(
     OutgoingConnectionFactoryPtr factory = getInstance()->outgoingConnectionFactory();
     auto self = static_pointer_cast<RoutableReference>(const_cast<RoutableReference*>(this)->shared_from_this());
 
-    auto createConnectionSucceded =
+    auto createConnectionSucceeded =
         [routerInfo = _routerInfo, response = std::move(response)](Ice::ConnectionIPtr connection, bool compress)
     {
         // If we have a router, set the object adapter for this router (if any) to the new connection, so that
@@ -1413,7 +1424,7 @@ IceInternal::RoutableReference::createConnectionAsync(
     if (getCacheConnection() || endpoints.size() == 1)
     {
         // Get an existing connection or create one if there's no existing connection to one of the given endpoints.
-        factory->createAsync(std::move(endpoints), false, std::move(createConnectionSucceded), std::move(exception));
+        factory->createAsync(std::move(endpoints), false, std::move(createConnectionSucceeded), std::move(exception));
     }
     else
     {
@@ -1427,11 +1438,11 @@ IceInternal::RoutableReference::createConnectionAsync(
             CreateConnectionState(
                 vector<EndpointIPtr> endpoints,
                 OutgoingConnectionFactoryPtr factory,
-                function<void(Ice::ConnectionIPtr, bool)> createConnectionSucceded,
+                function<void(Ice::ConnectionIPtr, bool)> createConnectionSucceeded,
                 function<void(exception_ptr)> exception)
                 : _endpoints(std::move(endpoints)),
                   _factory(std::move(factory)),
-                  _createConnectionSucceded(std::move(createConnectionSucceded)),
+                  _createConnectionSucceeded(std::move(createConnectionSucceeded)),
                   _createConnectionFailed(std::move(exception))
             {
             }
@@ -1441,7 +1452,7 @@ IceInternal::RoutableReference::createConnectionAsync(
                 _factory->createAsync(
                     {_endpoints[_endpointIndex]},
                     true,
-                    _createConnectionSucceded,
+                    _createConnectionSucceeded,
                     [self = shared_from_this()](exception_ptr e) { self->handleException(e); });
             }
 
@@ -1462,7 +1473,7 @@ IceInternal::RoutableReference::createConnectionAsync(
                 _factory->createAsync(
                     {_endpoints[_endpointIndex]},
                     more,
-                    _createConnectionSucceded,
+                    _createConnectionSucceeded,
                     [self = shared_from_this()](exception_ptr e) { self->handleException(e); });
             }
 
@@ -1471,14 +1482,14 @@ IceInternal::RoutableReference::createConnectionAsync(
             size_t _endpointIndex = 0;
             vector<EndpointIPtr> _endpoints;
             OutgoingConnectionFactoryPtr _factory;
-            std::function<void(Ice::ConnectionIPtr, bool)> _createConnectionSucceded;
+            std::function<void(Ice::ConnectionIPtr, bool)> _createConnectionSucceeded;
             std::function<void(exception_ptr)> _createConnectionFailed;
         };
 
         auto state = make_shared<CreateConnectionState>(
             std::move(endpoints),
             std::move(factory),
-            std::move(createConnectionSucceded),
+            std::move(createConnectionSucceeded),
             std::move(exception));
         state->createAsync();
     }

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

@@ -209,6 +209,9 @@ namespace IceInternal
         [[nodiscard]] RequestHandlerPtr getRequestHandler() const final;
         [[nodiscard]] const BatchRequestQueuePtr& getBatchRequestQueue() const noexcept final;
 
+        // The connection this fixed reference is bound to, whatever its state.
+        [[nodiscard]] const Ice::ConnectionIPtr& fixedConnection() const noexcept { return _fixedConnection; }
+
         bool operator==(const Reference&) const noexcept final;
         bool operator<(const Reference&) const noexcept final;
 

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

@@ -93,13 +93,14 @@ IceInternal::ReferenceFactory::create(string_view str, const string& propertyPre
         return nullptr;
     }
 
-    const string delim = " \t\r\n";
+    static constexpr const char* whitespace = " \t\r\n";
+    static constexpr const char* whitespaceOrSeparator = " \t\r\n:@";
 
-    string s(str);
+    string s{str};
     string::size_type beg;
     string::size_type end = 0;
 
-    beg = s.find_first_not_of(delim, end);
+    beg = s.find_first_not_of(whitespace, end);
     if (beg == string::npos)
     {
         throw ParseException(__FILE__, __LINE__, "no non-whitespace characters found in proxy string '" + s + "'");
@@ -117,7 +118,7 @@ IceInternal::ReferenceFactory::create(string_view str, const string& propertyPre
     }
     else if (end == 0)
     {
-        end = s.find_first_of(delim + ":@", beg);
+        end = s.find_first_of(whitespaceOrSeparator, beg);
         if (end == string::npos)
         {
             end = s.size();
@@ -144,7 +145,7 @@ IceInternal::ReferenceFactory::create(string_view str, const string& propertyPre
         // a null proxy, but only if nothing follows the
         // quotes.
         //
-        if (s.find_first_not_of(delim, end) != string::npos)
+        if (s.find_first_not_of(whitespace, end) != string::npos)
         {
             throw ParseException(__FILE__, __LINE__, "invalid characters after identity in proxy string '" + s + "'");
         }
@@ -167,7 +168,7 @@ IceInternal::ReferenceFactory::create(string_view str, const string& propertyPre
 
     while (true)
     {
-        beg = s.find_first_not_of(delim, end);
+        beg = s.find_first_not_of(whitespace, end);
         if (beg == string::npos)
         {
             break;
@@ -178,7 +179,7 @@ IceInternal::ReferenceFactory::create(string_view str, const string& propertyPre
             break;
         }
 
-        end = s.find_first_of(delim + ":@", beg);
+        end = s.find_first_of(whitespaceOrSeparator, beg);
         if (end == string::npos)
         {
             end = s.length();
@@ -204,7 +205,7 @@ IceInternal::ReferenceFactory::create(string_view str, const string& propertyPre
         // quotation marks.
         //
         string argument;
-        string::size_type argumentBeg = s.find_first_not_of(delim, end);
+        string::size_type argumentBeg = s.find_first_not_of(whitespace, end);
         if (argumentBeg != string::npos)
         {
             if (s[argumentBeg] != '@' && s[argumentBeg] != ':' && s[argumentBeg] != '-')
@@ -220,7 +221,7 @@ IceInternal::ReferenceFactory::create(string_view str, const string& propertyPre
                 }
                 else if (end == 0)
                 {
-                    end = s.find_first_of(delim + ":@", beg);
+                    end = s.find_first_of(whitespaceOrSeparator, beg);
                     if (end == string::npos)
                     {
                         end = s.size();
@@ -493,7 +494,7 @@ IceInternal::ReferenceFactory::create(string_view str, const string& propertyPre
         }
         case '@':
         {
-            beg = s.find_first_not_of(delim, beg + 1);
+            beg = s.find_first_not_of(whitespace, beg + 1);
             if (beg == string::npos)
             {
                 throw ParseException(__FILE__, __LINE__, "missing adapter id in proxy string '" + s + "'");
@@ -510,7 +511,7 @@ IceInternal::ReferenceFactory::create(string_view str, const string& propertyPre
             }
             else if (end == 0)
             {
-                end = s.find_first_of(delim, beg);
+                end = s.find_first_of(whitespace, beg);
                 if (end == string::npos)
                 {
                     end = s.size();
@@ -525,7 +526,7 @@ IceInternal::ReferenceFactory::create(string_view str, const string& propertyPre
             }
 
             // Check for trailing whitespace.
-            if (end != string::npos && s.find_first_not_of(delim, end) != string::npos)
+            if (end != string::npos && s.find_first_not_of(whitespace, end) != string::npos)
             {
                 throw ParseException(
                     __FILE__,
@@ -610,7 +611,9 @@ IceInternal::ReferenceFactory::create(Identity ident, InputStream* s)
     vector<EndpointIPtr> endpoints;
     string adapterId;
 
-    int32_t sz = s->readSize();
+    // Each endpoint occupies at least 8 bytes on the wire (a 2-byte type plus a 6-byte minimum
+    // encapsulation), so readAndCheckSeqSize rejects an oversized count before we allocate.
+    int32_t sz = s->readAndCheckSeqSize(8);
 
     if (sz > 0)
     {
@@ -792,10 +795,20 @@ IceInternal::ReferenceFactory::create(
         property = propertyPrefix + ".LocatorCacheTimeout";
         locatorCacheTimeout = chrono::seconds(
             properties->getPropertyAsIntWithDefault(property, static_cast<int32_t>(locatorCacheTimeout.count())));
+        if (locatorCacheTimeout < chrono::seconds::zero())
+        {
+            // Any negative timeout means infinite and is normalized to -1; 0 means no caching.
+            locatorCacheTimeout = chrono::seconds(-1);
+        }
 
         property = propertyPrefix + ".InvocationTimeout";
         invocationTimeout = chrono::milliseconds(
             properties->getPropertyAsIntWithDefault(property, static_cast<int32_t>(invocationTimeout.count())));
+        if (invocationTimeout <= chrono::milliseconds::zero())
+        {
+            // Zero or any negative timeout means infinite and is normalized to -1.
+            invocationTimeout = chrono::milliseconds(-1);
+        }
 
         property = propertyPrefix + ".Context.";
         PropertyDict contexts = properties->getPropertiesForPrefix(property);

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

@@ -42,7 +42,9 @@ namespace IceInternal
 
         virtual AsyncStatus sendAsyncRequest(const ProxyOutgoingAsyncBasePtr&) = 0;
 
-        virtual Ice::ConnectionIPtr getConnection() = 0;
+        // Returns this request handler's connection, or null if no connection is available. This function never
+        // throws.
+        virtual Ice::ConnectionIPtr getConnection() noexcept = 0;
 
     protected:
         const ReferencePtr _reference;

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

@@ -45,7 +45,7 @@ RequestHandlerCache::getRequestHandler()
 }
 
 ConnectionPtr
-RequestHandlerCache::getCachedConnection()
+RequestHandlerCache::getCachedConnection() noexcept
 {
     if (_cacheConnection)
     {

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

@@ -18,7 +18,7 @@ namespace IceInternal
 
         RequestHandlerPtr getRequestHandler();
 
-        Ice::ConnectionPtr getCachedConnection();
+        Ice::ConnectionPtr getCachedConnection() noexcept;
 
         void clearCachedRequestHandler(const RequestHandlerPtr& handler);
 

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

@@ -5,8 +5,8 @@
 
 #include "winver.h"
 
-#define ICE_VERSION 3, 8, 1, 0
-#define ICE_STRING_VERSION "3.8.1\0"
+#define ICE_VERSION 3, 8, 3, 0
+#define ICE_STRING_VERSION "3.8.3\0"
 #define ICE_SO_VERSION "38\0"
 #define ICE_COMPANY_NAME "ZeroC, Inc.\0"
 #define ICE_COPYRIGHT "\251 ZeroC, Inc.\0"
@@ -18,7 +18,7 @@
 #    define ICE_LIBNAME(NAME) NAME ICE_SO_VERSION ""
 #endif
 
-#ifndef DEBUG
+#ifndef _DEBUG
 #    define VER_DEBUG 0
 #else
 #    define VER_DEBUG VS_FF_DEBUG

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

@@ -26,8 +26,8 @@ IceInternal::RetryTask::runTimerTask()
     _outAsync->retry(); // Retry again the invocation.
 
     //
-    // NOTE: this must be called last, destroy() blocks until all task
-    // are removed to prevent the client thread pool to be destroyed
+    // NOTE: this must be called last, destroy() blocks until all tasks
+    // are removed to prevent the client thread pool from being destroyed
     // (we still need the client thread pool at this point to call
     // exception callbacks with CommunicatorDestroyedException).
     //
@@ -135,17 +135,13 @@ bool
 IceInternal::RetryQueue::cancel(const RetryTaskPtr& task)
 {
     lock_guard<mutex> lock(_mutex);
-    if (_requests.erase(task) > 0)
+    // Only remove the task if we cancel it in the timer before it runs. If timer()->cancel returns false, the
+    // task is already executing and runTimerTask will call remove() to erase it from _requests; erasing it
+    // here would make that remove() fail its assertion. When the queue is being destroyed (_instance is null)
+    // the timer is gone and every remaining task is running, so it is likewise removed by remove().
+    if (_instance && _instance->timer()->cancel(task))
     {
-        if (_instance)
-        {
-            return _instance->timer()->cancel(task);
-        }
-        else if (_requests.empty())
-        {
-            // If we are destroying the queue, destroy is probably waiting on the queue to be empty.
-            _conditionVariable.notify_one();
-        }
+        return _requests.erase(task) != 0;
     }
     return false;
 }

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

@@ -105,16 +105,16 @@ 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.data(), &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);
+    CC_SHA1_Final(md.data(), &_ctx);
 #else
     md.resize(SHA_DIGEST_LENGTH);
-    SHA1_Final(&md[0], &_ctx);
+    SHA1_Final(md.data(), &_ctx);
 #endif
 }
 
@@ -124,16 +124,16 @@ 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))
+    if (!CryptGetHashParam(_hash, HP_HASHVAL, reinterpret_cast<unsigned char*>(md.data()), &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);
+    CC_SHA1_Final(reinterpret_cast<unsigned char*>(md.data()), &_ctx);
 #else
     md.resize(SHA_DIGEST_LENGTH);
-    SHA1_Final(reinterpret_cast<unsigned char*>(&md[0]), &_ctx);
+    SHA1_Final(reinterpret_cast<unsigned char*>(md.data()), &_ctx);
 #endif
 }
 
@@ -168,10 +168,10 @@ IceInternal::sha1(const unsigned char* data, size_t length, vector<unsigned char
     hasher.finalize(md);
 #elif defined(__APPLE__)
     md.resize(CC_SHA1_DIGEST_LENGTH);
-    CC_SHA1(&data[0], static_cast<CC_LONG>(length), &md[0]);
+    CC_SHA1(data, static_cast<CC_LONG>(length), md.data());
 #else
     md.resize(SHA_DIGEST_LENGTH);
-    ::SHA1(&data[0], length, &md[0]);
+    ::SHA1(data, length, md.data());
 #endif
 }
 
@@ -185,11 +185,11 @@ IceInternal::sha1(const byte* data, size_t length, vector<byte>& md)
 #elif defined(__APPLE__)
     md.resize(CC_SHA1_DIGEST_LENGTH);
     CC_SHA1(
-        reinterpret_cast<const unsigned char*>(&data[0]),
+        reinterpret_cast<const unsigned char*>(data),
         static_cast<CC_LONG>(length),
-        reinterpret_cast<unsigned char*>(&md[0]));
+        reinterpret_cast<unsigned char*>(md.data()));
 #else
     md.resize(SHA_DIGEST_LENGTH);
-    ::SHA1(reinterpret_cast<const unsigned char*>(&data[0]), length, reinterpret_cast<unsigned char*>(&md[0]));
+    ::SHA1(reinterpret_cast<const unsigned char*>(data), length, reinterpret_cast<unsigned char*>(md.data()));
 #endif
 }

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

@@ -51,12 +51,6 @@ DistinguishedName::match(const DistinguishedName& other) const
     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.