zeroc-ice 3.8.1 → 3.8.3

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

@@ -4,145 +4,181 @@
 
 #    include "SysLoggerI.h"
 #    include "Ice/LocalExceptions.h"
+
+#    include <mutex>
 #    include <syslog.h>
 
 using namespace std;
 using namespace Ice;
 using namespace IceInternal;
 
-Ice::SysLoggerI::SysLoggerI(string prefix, string_view facilityString) : _facility(0), _prefix(std::move(prefix))
+namespace
 {
-    if (facilityString == "LOG_KERN")
-    {
-        _facility = LOG_KERN;
-    }
-    else if (facilityString == "LOG_USER")
-    {
-        _facility = LOG_USER;
-    }
-    else if (facilityString == "LOG_MAIL")
-    {
-        _facility = LOG_MAIL;
-    }
-    else if (facilityString == "LOG_DAEMON")
-    {
-        _facility = LOG_DAEMON;
-    }
-    else if (facilityString == "LOG_AUTH")
-    {
-        _facility = LOG_AUTH;
-    }
-    else if (facilityString == "LOG_SYSLOG")
-    {
-        _facility = LOG_SYSLOG;
-    }
-    else if (facilityString == "LOG_LPR")
-    {
-        _facility = LOG_LPR;
-    }
-    else if (facilityString == "LOG_NEWS")
-    {
-        _facility = LOG_NEWS;
-    }
-    else if (facilityString == "LOG_UUCP")
-    {
-        _facility = LOG_UUCP;
-    }
-    else if (facilityString == "LOG_CRON")
-    {
-        _facility = LOG_CRON;
-    }
+    // openlog/closelog and the syslog ident are process-global, and openlog retains the ident pointer rather than
+    // copying it. All SysLoggerI instances therefore share a single openlog call: the first instance donates its
+    // prefix as the process-wide ident, and the last instance to be destroyed calls closelog. sysLogMutex guards
+    // this state and serializes the syslog calls.
+    mutex sysLogMutex;
+    int sysLogCount = 0;
+
+    // Intentionally leaked: openlog retains the ident pointer, and a logger stored in a global can still call syslog
+    // during static destruction, so this buffer must never be freed.
+    string& sysLogIdent = *new string; // NOLINT(cert-err58-cpp)
+
+    int parseFacility(string_view facilityString)
+    {
+        if (facilityString == "LOG_KERN")
+        {
+            return LOG_KERN;
+        }
+        else if (facilityString == "LOG_USER")
+        {
+            return LOG_USER;
+        }
+        else if (facilityString == "LOG_MAIL")
+        {
+            return LOG_MAIL;
+        }
+        else if (facilityString == "LOG_DAEMON")
+        {
+            return LOG_DAEMON;
+        }
+        else if (facilityString == "LOG_AUTH")
+        {
+            return LOG_AUTH;
+        }
+        else if (facilityString == "LOG_SYSLOG")
+        {
+            return LOG_SYSLOG;
+        }
+        else if (facilityString == "LOG_LPR")
+        {
+            return LOG_LPR;
+        }
+        else if (facilityString == "LOG_NEWS")
+        {
+            return LOG_NEWS;
+        }
+        else if (facilityString == "LOG_UUCP")
+        {
+            return LOG_UUCP;
+        }
+        else if (facilityString == "LOG_CRON")
+        {
+            return LOG_CRON;
+        }
 #    ifdef LOG_AUTHPRIV
-    else if (facilityString == "LOG_AUTHPRIV")
-    {
-        _facility = LOG_AUTHPRIV;
-    }
+        else if (facilityString == "LOG_AUTHPRIV")
+        {
+            return LOG_AUTHPRIV;
+        }
 #    endif
 #    ifdef LOG_FTP
-    else if (facilityString == "LOG_FTP")
-    {
-        _facility = LOG_FTP;
-    }
+        else if (facilityString == "LOG_FTP")
+        {
+            return LOG_FTP;
+        }
 #    endif
-    else if (facilityString == "LOG_LOCAL0")
-    {
-        _facility = LOG_LOCAL0;
-    }
-    else if (facilityString == "LOG_LOCAL1")
-    {
-        _facility = LOG_LOCAL1;
-    }
-    else if (facilityString == "LOG_LOCAL2")
-    {
-        _facility = LOG_LOCAL2;
-    }
-    else if (facilityString == "LOG_LOCAL3")
-    {
-        _facility = LOG_LOCAL3;
-    }
-    else if (facilityString == "LOG_LOCAL4")
-    {
-        _facility = LOG_LOCAL4;
-    }
-    else if (facilityString == "LOG_LOCAL5")
-    {
-        _facility = LOG_LOCAL5;
-    }
-    else if (facilityString == "LOG_LOCAL6")
-    {
-        _facility = LOG_LOCAL6;
+        else if (facilityString == "LOG_LOCAL0")
+        {
+            return LOG_LOCAL0;
+        }
+        else if (facilityString == "LOG_LOCAL1")
+        {
+            return LOG_LOCAL1;
+        }
+        else if (facilityString == "LOG_LOCAL2")
+        {
+            return LOG_LOCAL2;
+        }
+        else if (facilityString == "LOG_LOCAL3")
+        {
+            return LOG_LOCAL3;
+        }
+        else if (facilityString == "LOG_LOCAL4")
+        {
+            return LOG_LOCAL4;
+        }
+        else if (facilityString == "LOG_LOCAL5")
+        {
+            return LOG_LOCAL5;
+        }
+        else if (facilityString == "LOG_LOCAL6")
+        {
+            return LOG_LOCAL6;
+        }
+        else if (facilityString == "LOG_LOCAL7")
+        {
+            return LOG_LOCAL7;
+        }
+        else
+        {
+            throw InitializationException(
+                __FILE__,
+                __LINE__,
+                "Invalid value for Ice.SyslogFacility: " + string{facilityString});
+        }
     }
-    else if (facilityString == "LOG_LOCAL7")
+}
+
+Ice::SysLoggerI::SysLoggerI(string prefix, string_view facilityString)
+    : SysLoggerI(std::move(prefix), parseFacility(facilityString))
+{
+}
+
+Ice::SysLoggerI::SysLoggerI(string prefix, int facility) : _facility(facility), _prefix(std::move(prefix))
+{
+    lock_guard lock(sysLogMutex);
+    if (sysLogCount++ == 0)
     {
-        _facility = LOG_LOCAL7;
+        sysLogIdent = _prefix;
+        // The facility argument is only a default for syslog calls that don't specify one; each log method passes
+        // this logger's facility with the message priority.
+        openlog(sysLogIdent.c_str(), LOG_PID | LOG_CONS, 0);
     }
-    else
+    if (!_prefix.empty() && _prefix != sysLogIdent)
     {
-        throw InitializationException(
-            __FILE__,
-            __LINE__,
-            "Invalid value for Ice.SyslogFacility: " + string{facilityString});
+        _bodyPrefix = _prefix + ": ";
     }
-
-    int logopt = LOG_PID | LOG_CONS;
-    openlog(_prefix.c_str(), logopt, _facility);
 }
 
-Ice::SysLoggerI::SysLoggerI(string prefix, int facility) : _facility(facility), _prefix(std::move(prefix))
+Ice::SysLoggerI::~SysLoggerI()
 {
-    int logopt = LOG_PID | LOG_CONS;
-    openlog(_prefix.c_str(), logopt, facility);
+    lock_guard lock(sysLogMutex);
+    if (--sysLogCount == 0)
+    {
+        closelog();
+    }
 }
 
-Ice::SysLoggerI::~SysLoggerI() { closelog(); }
-
 void
 Ice::SysLoggerI::print(const string& message)
 {
-    lock_guard lock(_mutex);
-    syslog(LOG_INFO, "%s", message.c_str());
+    // The Logger contract requires these methods not to throw, so we let syslog do the formatting instead of
+    // building a std::string that could throw bad_alloc.
+    lock_guard lock(sysLogMutex);
+    syslog(_facility | LOG_INFO, "%s%s", _bodyPrefix.c_str(), message.c_str());
 }
 
 void
 Ice::SysLoggerI::trace(const string& category, const string& message)
 {
-    lock_guard lock(_mutex);
-    string s = category + ": " + message;
-    syslog(LOG_INFO, "%s", s.c_str());
+    lock_guard lock(sysLogMutex);
+    syslog(_facility | LOG_INFO, "%s%s: %s", _bodyPrefix.c_str(), category.c_str(), message.c_str());
 }
 
 void
 Ice::SysLoggerI::warning(const string& message)
 {
-    lock_guard lock(_mutex);
-    syslog(LOG_WARNING, "%s", message.c_str());
+    lock_guard lock(sysLogMutex);
+    syslog(_facility | LOG_WARNING, "%s%s", _bodyPrefix.c_str(), message.c_str());
 }
 
 void
 Ice::SysLoggerI::error(const string& message)
 {
-    lock_guard lock(_mutex);
-    syslog(LOG_ERR, "%s", message.c_str());
+    lock_guard lock(sysLogMutex);
+    syslog(_facility | LOG_ERR, "%s%s", _bodyPrefix.c_str(), message.c_str());
 }
 
 string

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

@@ -5,7 +5,6 @@
 
 #include "Ice/Logger.h"
 
-#include <mutex>
 #include <string_view>
 
 namespace Ice
@@ -17,6 +16,9 @@ namespace Ice
         SysLoggerI(std::string prefix, int facility);
         ~SysLoggerI() override;
 
+        SysLoggerI(const SysLoggerI&) = delete;
+        SysLoggerI& operator=(const SysLoggerI&) = delete;
+
         void print(const std::string&) final;
         void trace(const std::string&, const std::string&) final;
         void warning(const std::string&) final;
@@ -25,9 +27,11 @@ namespace Ice
         LoggerPtr cloneWithPrefix(std::string) final;
 
     private:
-        int _facility;
+        const int _facility;
         const std::string _prefix;
-        std::mutex _mutex;
+
+        // Prepended to each message when this logger's prefix differs from the process-wide syslog ident.
+        std::string _bodyPrefix;
     };
 }
 

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

@@ -59,7 +59,7 @@ Ice::SystemdJournalI::write(int priority, const string& message) const
         priority,
         "SYSLOG_IDENTIFIER=%s",
         _prefix.c_str(),
-        NULL); // Using NULL is necessary for EL7, see #293
+        NULL); // The sd_journal_send argument list must be NULL-terminated.
 }
 
 #endif

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

@@ -96,7 +96,7 @@ IceInternal::TcpAcceptor::startAccept()
     _acceptFd = createSocket(false, _addr);
     const int sz = static_cast<int>(_acceptBuf.size() / 2);
     _info.error = ERROR_SUCCESS;
-    if (!AcceptEx(_fd, _acceptFd, &_acceptBuf[0], 0, sz, sz, &_info.count, &_info))
+    if (!AcceptEx(_fd, _acceptFd, _acceptBuf.data(), 0, sz, sz, &_info.count, &_info))
     {
         if (!wouldBlock())
         {
@@ -123,8 +123,7 @@ IceInternal::TcpAcceptor::accept()
     {
         throw SocketException(__FILE__, __LINE__, _acceptError);
     }
-    if (setsockopt(_acceptFd, SOL_SOCKET, SO_UPDATE_ACCEPT_CONTEXT, (char*)&_acceptFd, sizeof(_acceptFd)) ==
-        SOCKET_ERROR)
+    if (setsockopt(_acceptFd, SOL_SOCKET, SO_UPDATE_ACCEPT_CONTEXT, (char*)&_fd, sizeof(_fd)) == SOCKET_ERROR)
     {
         closeSocketNoThrow(_acceptFd);
         _acceptFd = INVALID_SOCKET;
@@ -133,14 +132,14 @@ IceInternal::TcpAcceptor::accept()
 
     SOCKET fd = _acceptFd;
     _acceptFd = INVALID_SOCKET;
-    return make_shared<TcpTransceiver>(_instance, make_shared<StreamSocket>(_instance, fd));
+    return make_shared<TcpTransceiver>(_instance, make_shared<StreamSocket>(_instance, fd, _bufSize));
 }
 #    else
 
 TransceiverPtr
 IceInternal::TcpAcceptor::accept()
 {
-    return make_shared<TcpTransceiver>(_instance, make_shared<StreamSocket>(_instance, doAccept(_fd)));
+    return make_shared<TcpTransceiver>(_instance, make_shared<StreamSocket>(_instance, doAccept(_fd), _bufSize));
 }
 
 #    endif
@@ -178,7 +177,8 @@ IceInternal::TcpAcceptor::TcpAcceptor(
     int port)
     : _endpoint(std::move(endpoint)),
       _instance(instance),
-      _addr(getAddressForServer(host, port, _instance->protocolSupport(), instance->preferIPv6(), true))
+      _addr(getAddressForServer(host, port, _instance->protocolSupport(), instance->preferIPv6(), true)),
+      _bufSize(instance->properties())
 #    ifdef ICE_USE_IOCP
       ,
       _acceptFd(INVALID_SOCKET),
@@ -193,7 +193,7 @@ IceInternal::TcpAcceptor::TcpAcceptor(
 #    endif
 
     setBlock(_fd, false);
-    setTcpBufSize(_fd, _instance);
+    setTcpBufSize(_fd, _bufSize.rcvSize(), _bufSize.sndSize(), _instance);
 
 #    ifndef _WIN32
     // Set SO_REUSEADDR socket option on Unix platforms to allow re-using the address even if the socket remains in

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

@@ -6,11 +6,11 @@
 #include "Acceptor.h"
 #include "Network.h"
 #include "ProtocolInstanceF.h"
+#include "TcpBufSize.h"
 #include "TransceiverF.h"
 
 namespace IceInternal
 {
-    class TcpEndpoint;
 
     class TcpAcceptor final : public Acceptor, public NativeInfo, public std::enable_shared_from_this<TcpAcceptor>
     {
@@ -42,6 +42,7 @@ namespace IceInternal
         TcpEndpointIPtr _endpoint;
         const ProtocolInstancePtr _instance;
         const Address _addr;
+        const TcpBufSize _bufSize;
 
         int _backlog;
 #if defined(ICE_USE_IOCP)

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

@@ -0,0 +1,40 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_TCP_BUF_SIZE_H
+#define ICE_TCP_BUF_SIZE_H
+
+#include "Ice/Properties.h"
+
+#include <cstdint>
+
+namespace IceInternal
+{
+    // The TCP send and receive buffer sizes, as configured by the Ice.TCP.SndSize and Ice.TCP.RcvSize properties.
+    class TcpBufSize
+    {
+    public:
+        // Reads the Ice.TCP.RcvSize and Ice.TCP.SndSize properties. Throws PropertyException if a value is not a
+        // valid integer.
+        explicit TcpBufSize(const Ice::PropertiesPtr& properties)
+            : _rcvSize(properties->getPropertyAsIntWithDefault("Ice.TCP.RcvSize", dfltBufSize)),
+              _sndSize(properties->getPropertyAsIntWithDefault("Ice.TCP.SndSize", dfltBufSize))
+        {
+        }
+
+        [[nodiscard]] std::int32_t rcvSize() const noexcept { return _rcvSize; }
+        [[nodiscard]] std::int32_t sndSize() const noexcept { return _sndSize; }
+
+    private:
+        // By default, on Windows we use a 128KB buffer size. On Unix platforms, we use the system defaults.
+#ifdef _WIN32
+        static constexpr std::int32_t dfltBufSize = 128 * 1024;
+#else
+        static constexpr std::int32_t dfltBufSize = 0;
+#endif
+
+        std::int32_t _rcvSize;
+        std::int32_t _sndSize;
+    };
+}
+
+#endif

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

@@ -22,7 +22,9 @@ using namespace IceInternal;
 TransceiverPtr
 IceInternal::TcpConnector::connect()
 {
-    return make_shared<TcpTransceiver>(_instance, make_shared<StreamSocket>(_instance, _proxy, _addr, _sourceAddr));
+    return make_shared<TcpTransceiver>(
+        _instance,
+        make_shared<StreamSocket>(_instance, _proxy, _addr, _sourceAddr, _bufSize));
 }
 
 int16_t
@@ -120,7 +122,8 @@ IceInternal::TcpConnector::TcpConnector(
       _proxy(std::move(proxy)),
       _sourceAddr(sourceAddr),
       _timeout(timeout),
-      _connectionId(std::move(connectionId))
+      _connectionId(std::move(connectionId)),
+      _bufSize(_instance->properties())
 {
 }
 

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

@@ -6,6 +6,7 @@
 #include "Connector.h"
 #include "Network.h"
 #include "ProtocolInstanceF.h"
+#include "TcpBufSize.h"
 #include "TransceiverF.h"
 
 namespace IceInternal
@@ -30,6 +31,7 @@ namespace IceInternal
         const Address _sourceAddr;
         const std::int32_t _timeout;
         const std::string _connectionId;
+        const TcpBufSize _bufSize;
     };
 }
 

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

@@ -169,7 +169,7 @@ AcceptorPtr
 IceInternal::TcpEndpointI::acceptor(const string&, const optional<Ice::SSL::ServerAuthenticationOptions>&) const
 {
     return make_shared<TcpAcceptor>(
-        dynamic_pointer_cast<TcpEndpointI>(const_cast<TcpEndpointI*>(this)->shared_from_this()),
+        static_pointer_cast<TcpEndpointI>(const_cast<TcpEndpointI*>(this)->shared_from_this()),
         _instance,
         _host,
         _port);
@@ -181,7 +181,7 @@ IceInternal::TcpEndpointI::endpoint(const TcpAcceptorPtr& acceptor) const
     int port = acceptor->effectivePort();
     if (_port == port)
     {
-        return dynamic_pointer_cast<TcpEndpointI>(const_cast<TcpEndpointI*>(this)->shared_from_this());
+        return static_pointer_cast<TcpEndpointI>(const_cast<TcpEndpointI*>(this)->shared_from_this());
     }
     else
     {

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

@@ -113,6 +113,10 @@ IceInternal::TcpTransceiver::getInfo(bool incoming, string adapterName, string c
         string remoteAddress;
         int remotePort;
         fdToAddressAndPort(_stream->fd(), localAddress, localPort, remoteAddress, remotePort);
+
+        int rcvSize = getRecvBufferSizeNoThrow(_stream->fd());
+        int sndSize = getSendBufferSizeNoThrow(_stream->fd());
+
         return make_shared<TCPConnectionInfo>(
             incoming,
             std::move(adapterName),
@@ -121,8 +125,8 @@ IceInternal::TcpTransceiver::getInfo(bool incoming, string adapterName, string c
             localPort,
             std::move(remoteAddress),
             remotePort,
-            getRecvBufferSize(_stream->fd()),
-            getSendBufferSize(_stream->fd()));
+            rcvSize,
+            sndSize);
     }
 }
 

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

@@ -468,12 +468,6 @@ IceInternal::ThreadPool::joinWithAllThreads()
     _selector.destroy();
 }
 
-string
-IceInternal::ThreadPool::prefix() const
-{
-    return _prefix;
-}
-
 void
 IceInternal::ThreadPool::run(const EventHandlerThreadPtr& thread)
 {
@@ -554,7 +548,7 @@ IceInternal::ThreadPool::run(const EventHandlerThreadPtr& thread)
                 {
                     //
                     // If the handler called ioCompleted(), we re-enable the handler in
-                    // case it was disabled and we decrease the number of thread in use.
+                    // case it was disabled and we decrease the number of threads in use.
                     //
                     if (_serialize && current._handler.get() != _workQueue.get())
                     {
@@ -805,7 +799,7 @@ IceInternal::ThreadPool::ioCompleted(ThreadPoolCurrent& current)
         }
     }
 
-    return _serialize && current._handler.get() != _workQueue.get();
+    return _sizeMax > 1 && _serialize && current._handler.get() != _workQueue.get();
 }
 
 #if defined(ICE_USE_IOCP)

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

@@ -73,8 +73,6 @@ namespace IceInternal
 
         void joinWithAllThreads();
 
-        [[nodiscard]] std::string prefix() const;
-
     private:
         ThreadPool(const InstancePtr&, std::string, int);
         void initialize();

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

@@ -19,6 +19,10 @@ Timer::destroy()
     {
         throw std::runtime_error("a timer task cannot destroy the timer");
     }
+    // Destroy the tasks after the lock is released and the worker joined: a task's destructor can re-enter the timer
+    // via cancel() (e.g. when it holds the last reference to a connection), which would deadlock while _mutex is held.
+    std::set<Token> tokens;
+    std::map<TimerTaskPtr, std::chrono::steady_clock::time_point> tasks;
     {
         std::lock_guard lock(_mutex);
         if (_destroyed)
@@ -26,8 +30,8 @@ Timer::destroy()
             return;
         }
         _destroyed = true;
-        _tasks.clear();
-        _tokens.clear();
+        tokens.swap(_tokens);
+        tasks.swap(_tasks);
         _condition.notify_one();
     }
     _worker.join();
@@ -135,7 +139,7 @@ Timer::run()
             {
                 // If the task is not a repeated task, clear the task reference now rather than
                 // in the synchronization block above. Clearing the task reference might end up
-                // calling user code which could trigger a deadlock. See also issue #352.
+                // calling user code which could trigger a deadlock.
                 token.task = nullptr;
             }
         }

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

@@ -2,8 +2,7 @@
 
 #include "Ice/UUID.h"
 
-// We use a high quality random number generator
-// (std::random_device) to generate "version 4" UUIDs, as described in
+// We use the operating system's CSPRNG (see Random.h) to generate "version 4" UUIDs, as described in
 // http://www.ietf.org/internet-drafts/draft-mealling-uuid-urn-00.txt
 #include "Random.h"
 

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

@@ -162,7 +162,7 @@ TransceiverPtr
 IceInternal::UdpEndpointI::transceiver() const
 {
     return make_shared<UdpTransceiver>(
-        dynamic_pointer_cast<UdpEndpointI>(const_cast<UdpEndpointI*>(this)->shared_from_this()),
+        static_pointer_cast<UdpEndpointI>(const_cast<UdpEndpointI*>(this)->shared_from_this()),
         _instance,
         _host,
         _port,
@@ -181,7 +181,7 @@ IceInternal::UdpEndpointI::endpoint(const UdpTransceiverPtr& transceiver) const
     int port = transceiver->effectivePort();
     if (port == _port)
     {
-        return dynamic_pointer_cast<UdpEndpointI>(const_cast<UdpEndpointI*>(this)->shared_from_this());
+        return static_pointer_cast<UdpEndpointI>(const_cast<UdpEndpointI*>(this)->shared_from_this());
     }
     else
     {
@@ -227,7 +227,10 @@ IceInternal::UdpEndpointI::options() const
     if (_mcastInterface.length() > 0)
     {
         s << " --interface ";
-        bool addQuote = _mcastInterface.find(':') != string::npos;
+        // Quote the interface if it contains a character that would be re-parsed as a separator: whitespace, on
+        // which the endpoint parser splits options (e.g. a Windows adapter name like "Ethernet 2"), or ':', on
+        // which the proxy-string parser splits endpoints (e.g. an IPv6 interface address).
+        bool addQuote = _mcastInterface.find_first_of(" :\t\n\r") != string::npos;
         if (addQuote)
         {
             s << "\"";