zeroc-ice 3.8.2 → 3.8.3

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

@@ -10,7 +10,8 @@ StreamSocket::StreamSocket(
     ProtocolInstancePtr instance,
     const NetworkProxyPtr& proxy,
     const Address& addr,
-    const Address& sourceAddr)
+    const Address& sourceAddr,
+    const TcpBufSize& bufSize)
     : NativeInfo(createSocket(false, proxy ? proxy->getAddress() : addr)),
       _instance(std::move(instance)),
       _proxy(proxy),
@@ -23,25 +24,17 @@ StreamSocket::StreamSocket(
       _write(SocketOperationWrite)
 #endif
 {
-    init();
+    init(bufSize);
 #if !defined(ICE_USE_IOCP)
     if (doConnect(_fd, _proxy ? _proxy->getAddress() : _addr, sourceAddr))
     {
         _state = _proxy ? StateProxyWrite : StateConnected;
     }
 #endif
-    try
-    {
-        _desc = fdToString(_fd, _proxy, _addr);
-    }
-    catch (const Ice::Exception&)
-    {
-        closeSocketNoThrow(_fd);
-        throw;
-    }
+    _desc = fdToString(_fd, _proxy, _addr);
 }
 
-StreamSocket::StreamSocket(ProtocolInstancePtr instance, SOCKET fd)
+StreamSocket::StreamSocket(ProtocolInstancePtr instance, SOCKET fd, const TcpBufSize& bufSize)
     : NativeInfo(fd),
       _instance(std::move(instance)),
       _addr(),
@@ -53,16 +46,8 @@ StreamSocket::StreamSocket(ProtocolInstancePtr instance, SOCKET fd)
       _write(SocketOperationWrite)
 #endif
 {
-    init();
-    try
-    {
-        _desc = fdToString(fd);
-    }
-    catch (const Ice::Exception&)
-    {
-        closeSocketNoThrow(fd);
-        throw;
-    }
+    init(bufSize);
+    _desc = fdToString(fd);
 }
 
 StreamSocket::~StreamSocket() { assert(_fd == INVALID_SOCKET); }
@@ -113,16 +98,19 @@ StreamSocket::connect(Buffer& readBuffer, Buffer& writeBuffer)
     return IceInternal::SocketOperationNone;
 }
 
-bool
-StreamSocket::isConnected()
-{
-    return _state == StateConnected && _fd != INVALID_SOCKET;
-}
-
 void
 StreamSocket::setBufferSize(int rcvSize, int sndSize)
 {
-    setTcpBufSize(_fd, rcvSize, sndSize, _instance);
+    try
+    {
+        setTcpBufSize(_fd, rcvSize, sndSize, _instance);
+    }
+    catch (const Ice::SocketException&)
+    {
+        // The failing call closed the fd.
+        clearFd();
+        throw;
+    }
 }
 
 SocketOperation
@@ -431,16 +419,19 @@ StreamSocket::finishRead(Buffer& buf)
 void
 StreamSocket::close()
 {
-    assert(_fd != INVALID_SOCKET);
-    try
+    // _fd can be INVALID_SOCKET when a failed socket operation already closed the fd.
+    if (_fd != INVALID_SOCKET)
     {
-        closeSocket(_fd);
-        _fd = INVALID_SOCKET;
-    }
-    catch (const Ice::SocketException&)
-    {
-        _fd = INVALID_SOCKET;
-        throw;
+        try
+        {
+            closeSocket(_fd);
+            _fd = INVALID_SOCKET;
+        }
+        catch (const Ice::SocketException&)
+        {
+            _fd = INVALID_SOCKET;
+            throw;
+        }
     }
 }
 
@@ -451,10 +442,12 @@ StreamSocket::toString() const
 }
 
 void
-StreamSocket::init()
+StreamSocket::init(const TcpBufSize& bufSize)
 {
+    // Both calls close the fd before throwing a SocketException, so a failure cannot leak the fd — and since init
+    // is only called from constructors, the exception abandons the object and nothing uses the stale _fd afterward.
     setBlock(_fd, false);
-    setTcpBufSize(_fd, _instance);
+    setTcpBufSize(_fd, bufSize.rcvSize(), bufSize.sndSize(), _instance);
 }
 
 StreamSocket::State

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

@@ -6,6 +6,7 @@
 #include "Ice/Buffer.h"
 #include "Network.h"
 #include "ProtocolInstanceF.h"
+#include "TcpBufSize.h"
 
 #include <memory>
 
@@ -14,12 +15,11 @@ namespace IceInternal
     class StreamSocket : public NativeInfo
     {
     public:
-        StreamSocket(ProtocolInstancePtr, const NetworkProxyPtr&, const Address&, const Address&);
-        StreamSocket(ProtocolInstancePtr, SOCKET);
+        StreamSocket(ProtocolInstancePtr, const NetworkProxyPtr&, const Address&, const Address&, const TcpBufSize&);
+        StreamSocket(ProtocolInstancePtr, SOCKET, const TcpBufSize&);
         ~StreamSocket() override;
 
         SocketOperation connect(Buffer&, Buffer&);
-        bool isConnected();
 
         void setBufferSize(int rcvSize, int sndSize);
 
@@ -41,7 +41,7 @@ namespace IceInternal
         [[nodiscard]] const std::string& toString() const;
 
     private:
-        void init();
+        void init(const TcpBufSize&);
 
         enum State
         {

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

@@ -483,7 +483,7 @@ namespace
         wstring wbuffer;
 
         //
-        // The following code pages doesn't support MB_ERR_INVALID_CHARS flag
+        // The following code pages don't support the MB_ERR_INVALID_CHARS flag
         // see http://msdn.microsoft.com/en-us/library/windows/desktop/dd319072(v=vs.85).aspx
         //
         DWORD flags = (_cp == 50220 || _cp == 50221 || _cp == 50222 || _cp == 50225 || _cp == 50227 || _cp == 50229 ||

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

@@ -337,6 +337,7 @@ namespace
     // end marks the one-past-the-end position of the substring to be scanned.
     // nextStart is set to the index of the first character following the decoded
     // character or escape sequence.
+    // Returns true if the decoded character is pure ASCII (<= 127), false otherwise.
     //
     bool decodeChar(
         const string& s,
@@ -353,6 +354,10 @@ namespace
 
         if (s[start] != '\\')
         {
+            if (static_cast<unsigned char>(s[start]) > 127)
+            {
+                pureASCII = false;
+            }
             result.push_back(checkChar(s, start++));
         }
         else if (start + 1 == end)
@@ -585,7 +590,7 @@ IceInternal::unescapeString(
         {
             checkChar(s, p++);
         }
-        return s.substr(start, end);
+        return s.substr(start, end - start);
     }
     else
     {
@@ -605,7 +610,7 @@ IceInternal::unescapeString(
 
             if (!inputIsPureASCII)
             {
-                u8s = nativeToUTF8(s.substr(start, end), stringConverter);
+                u8s = nativeToUTF8(s.substr(start, end - start), stringConverter);
                 inputStringPtr = &u8s;
                 start = 0;
                 end = u8s.size();
@@ -617,7 +622,7 @@ IceInternal::unescapeString(
         result.reserve(end - start);
         while (start < end)
         {
-            if (decodeChar(*inputStringPtr, start, end, start, special, result))
+            if (!decodeChar(*inputStringPtr, start, end, start, special, result))
             {
                 resultIsPureASCII = false;
             }
@@ -801,7 +806,7 @@ IceInternal::match(const string& s, const string& pat, bool emptyMatch)
     //
     // Make sure end of the strings match
     //
-    if (s.substr(endIndex, s.length()) != pat.substr(beginIndex + 1, pat.length()))
+    if (s.substr(endIndex) != pat.substr(beginIndex + 1))
     {
         return false;
     }
@@ -1032,10 +1037,10 @@ IceInternal::errorToString(int error)
         //
         // Use the XSI-compliant version of strerror_r
         //
-        int err = strerror_r(error, &buffer[0], buffer.size());
+        int err = strerror_r(error, buffer.data(), buffer.size());
         if (err == 0)
         {
-            return {&buffer[0]};
+            return {buffer.data()};
         }
 #    else
         //
@@ -1043,7 +1048,7 @@ IceInternal::errorToString(int error)
         //
         int oerrno = errno;
         errno = 0;
-        const char* msg = strerror_r(error, &buffer[0], buffer.size());
+        const char* msg = strerror_r(error, buffer.data(), buffer.size());
         int err = errno;
         errno = oerrno;
         if (err == 0)
@@ -1121,17 +1126,3 @@ IceInternal::isDigit(char c)
 {
     return c >= '0' && c <= '9';
 }
-
-string
-IceInternal::removeWhitespace(string_view s)
-{
-    string result;
-    for (unsigned int i = 0; i < s.length(); ++i)
-    {
-        if (!isspace(static_cast<unsigned char>(s[i])))
-        {
-            result += s[i];
-        }
-    }
-    return result;
-}

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)