zeroc-ice 3.7.11 → 3.8.1

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

@@ -1,20 +1,19 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#include <IceUtil/Mutex.h>
-#include <IceUtil/MutexPtrLock.h>
-#include <Ice/StringUtil.h>
-#include <Ice/TraceUtil.h>
-#include <Ice/Instance.h>
-#include <Ice/Object.h>
-#include <Ice/Proxy.h>
-#include <Ice/TraceLevels.h>
-#include <Ice/Logger.h>
-#include <Ice/OutputStream.h>
-#include <Ice/InputStream.h>
-#include <Ice/Protocol.h>
-#include <Ice/ReplyStatus.h>
+// Copyright (c) ZeroC, Inc.
+
+#include "TraceUtil.h"
+#include "ConnectionI.h"
+#include "EndpointI.h"
+#include "Ice/InputStream.h"
+#include "Ice/Logger.h"
+#include "Ice/Object.h"
+#include "Ice/OutputStream.h"
+#include "Ice/Proxy.h"
+#include "Ice/ReplyStatus.h"
+#include "Ice/StringUtil.h"
+#include "Instance.h"
+#include "TraceLevels.h"
+
+#include <mutex>
 #include <set>
 
 using namespace std;
@@ -24,11 +23,7 @@ using namespace IceInternal;
 static void
 printIdentityFacetOperation(ostream& s, InputStream& stream)
 {
-    ToStringMode toStringMode = ICE_ENUM(ToStringMode, Unicode);
-    if(stream.instance())
-    {
-        toStringMode = stream.instance()->toStringMode();
-    }
+    ToStringMode toStringMode = stream.instance()->toStringMode();
 
     Identity identity;
     stream.read(identity);
@@ -37,7 +32,7 @@ printIdentityFacetOperation(ostream& s, InputStream& stream)
     vector<string> facet;
     stream.read(facet);
     s << "\nfacet = ";
-    if(!facet.empty())
+    if (!facet.empty())
     {
         s << escapeString(facet[0], "", toStringMode);
     }
@@ -48,9 +43,9 @@ printIdentityFacetOperation(ostream& s, InputStream& stream)
 }
 
 static string
-getMessageTypeAsString(Byte type)
+getMessageTypeAsString(uint8_t type)
 {
-    switch(type)
+    switch (type)
     {
         case requestMsg:
             return "request";
@@ -72,24 +67,26 @@ printRequestHeader(ostream& s, InputStream& stream)
 {
     printIdentityFacetOperation(s, stream);
 
-    Byte mode;
+    uint8_t mode;
     stream.read(mode);
     s << "\nmode = " << static_cast<int>(mode) << ' ';
-    switch(static_cast<OperationMode>(mode))
+    switch (static_cast<OperationMode>(mode))
     {
-        case ICE_ENUM(OperationMode, Normal):
+        case OperationMode::Normal:
         {
             s << "(normal)";
             break;
         }
 
-        case ICE_ENUM(OperationMode, Nonmutating):
+#include "PushDisableDeprecatedWarnings.h"
+        case OperationMode::Nonmutating:
         {
             s << "(nonmutating)";
             break;
         }
+#include "Ice/PopDisableWarnings.h"
 
-        case ICE_ENUM(OperationMode, Idempotent):
+        case OperationMode::Idempotent:
         {
             s << "(idempotent)";
             break;
@@ -102,59 +99,59 @@ printRequestHeader(ostream& s, InputStream& stream)
         }
     }
 
-    Int sz = stream.readSize();
+    int32_t sz = stream.readSize();
     s << "\ncontext = ";
-    while(sz--)
+    while (sz--)
     {
         pair<string, string> pair;
         stream.read(pair.first);
         stream.read(pair.second);
         s << pair.first << '/' << pair.second;
-        if(sz)
+        if (sz)
         {
             s << ", ";
         }
     }
 
     Ice::EncodingVersion v = stream.skipEncapsulation();
-    if(v > Ice::Encoding_1_0)
+    if (v > Ice::Encoding_1_0)
     {
         s << "\nencoding = " << v;
     }
 }
 
-static Byte
+static uint8_t
 printHeader(ostream& s, InputStream& stream)
 {
-    Byte magicNumber;
-    stream.read(magicNumber);   // Don't bother printing the magic number
+    uint8_t magicNumber;
+    stream.read(magicNumber); // Don't bother printing the magic number
     stream.read(magicNumber);
     stream.read(magicNumber);
     stream.read(magicNumber);
 
-    Byte pMajor;
-    Byte pMinor;
+    uint8_t pMajor;
+    uint8_t pMinor;
     stream.read(pMajor);
     stream.read(pMinor);
-//    s << "\nprotocol version = " << static_cast<unsigned>(pMajor)
-//      << "." << static_cast<unsigned>(pMinor);
+    //    s << "\nprotocol version = " << static_cast<unsigned>(pMajor)
+    //      << "." << static_cast<unsigned>(pMinor);
 
-    Byte eMajor;
-    Byte eMinor;
+    uint8_t eMajor;
+    uint8_t eMinor;
     stream.read(eMajor);
     stream.read(eMinor);
-//    s << "\nencoding version = " << static_cast<unsigned>(eMajor)
-//      << "." << static_cast<unsigned>(eMinor);
+    //    s << "\nencoding version = " << static_cast<unsigned>(eMajor)
+    //      << "." << static_cast<unsigned>(eMinor);
 
-    Byte type;
+    uint8_t type;
     stream.read(type);
-    s << "\nmessage type = "  << static_cast<int>(type) << " (" << getMessageTypeAsString(type) << ')';
+    s << "\nmessage type = " << static_cast<int>(type) << " (" << getMessageTypeAsString(type) << ')';
 
-    Byte compress;
+    uint8_t compress;
     stream.read(compress);
-    s << "\ncompression status = "  << static_cast<int>(compress) << ' ';
+    s << "\ncompression status = " << static_cast<int>(compress) << ' ';
 
-    switch(compress)
+    switch (compress)
     {
         case 0:
         {
@@ -181,7 +178,7 @@ printHeader(ostream& s, InputStream& stream)
         }
     }
 
-    Int size;
+    int32_t size;
     stream.read(size);
     s << "\nmessage size = " << size;
 
@@ -191,10 +188,10 @@ printHeader(ostream& s, InputStream& stream)
 static void
 printRequest(ostream& s, InputStream& stream)
 {
-    Int requestId;
+    int32_t requestId;
     stream.read(requestId);
     s << "\nrequest id = " << requestId;
-    if(requestId == 0)
+    if (requestId == 0)
     {
         s << " (oneway)";
     }
@@ -209,7 +206,7 @@ printBatchRequest(ostream& s, InputStream& stream)
     stream.read(batchRequestNum);
     s << "\nnumber of requests = " << batchRequestNum;
 
-    for(int i = 0; i < batchRequestNum; ++i)
+    for (int i = 0; i < batchRequestNum; ++i)
     {
         s << "\nrequest #" << i << ':';
         printRequestHeader(s, stream);
@@ -219,152 +216,97 @@ printBatchRequest(ostream& s, InputStream& stream)
 static void
 printReply(ostream& s, InputStream& stream)
 {
-    Int requestId;
+    int32_t requestId;
     stream.read(requestId);
     s << "\nrequest id = " << requestId;
 
-    Byte replyStatus;
-    stream.read(replyStatus);
-    s << "\nreply status = " << static_cast<int>(replyStatus) << ' ';
-    switch(replyStatus)
-    {
-    case replyOK:
-    {
-        s << "(ok)";
-        break;
-    }
-
-    case replyUserException:
-    {
-        s << "(user exception)";
-        break;
-    }
+    // We can't use the generated code to unmarshal a possibly unknown reply status enumerator.
+    uint8_t replyStatusByte;
+    stream.read(replyStatusByte);
+    ReplyStatus replyStatus{replyStatusByte};
 
-    case replyObjectNotExist:
-    case replyFacetNotExist:
-    case replyOperationNotExist:
+    s << "\nreply status = " << replyStatus;
+    switch (replyStatus)
     {
-        switch(replyStatus)
+        case ReplyStatus::Ok:
+        case ReplyStatus::UserException:
         {
-        case replyObjectNotExist:
-        {
-            s << "(object not exist)";
+            Ice::EncodingVersion v = stream.skipEncapsulation();
+            if (v > Ice::Encoding_1_0)
+            {
+                s << "\nencoding = " << v;
+            }
             break;
         }
 
-        case replyFacetNotExist:
-        {
-            s << "(facet not exist)";
+        case ReplyStatus::ObjectNotExist:
+        case ReplyStatus::FacetNotExist:
+        case ReplyStatus::OperationNotExist:
+            printIdentityFacetOperation(s, stream);
             break;
-        }
-
-        case replyOperationNotExist:
-        {
-            s << "(operation not exist)";
-            break;
-        }
 
         default:
-        {
-            assert(false);
+            string message;
+            stream.read(message, false);
+            s << "\nmessage = " << message;
             break;
-        }
-        }
-
-        printIdentityFacetOperation(s, stream);
-        break;
     }
+}
+
+static uint8_t
+printMessage(ostream& s, InputStream& stream, const ConnectionI* connection)
+{
+    uint8_t type = printHeader(s, stream);
 
-    case replyUnknownException:
-    case replyUnknownLocalException:
-    case replyUnknownUserException:
+    switch (type)
     {
-        switch(replyStatus)
+        case closeConnectionMsg:
+        case validateConnectionMsg:
         {
-        case replyUnknownException:
+            // We're done.
+            break;
+        }
+
+        case requestMsg:
         {
-            s << "(unknown exception)";
+            printRequest(s, stream);
             break;
         }
 
-        case replyUnknownLocalException:
+        case requestBatchMsg:
         {
-            s << "(unknown local exception)";
+            printBatchRequest(s, stream);
             break;
         }
 
-        case replyUnknownUserException:
+        case replyMsg:
         {
-            s << "(unknown user exception)";
+            printReply(s, stream);
             break;
         }
 
         default:
         {
-            assert(false);
             break;
         }
-        }
-
-        string unknown;
-        stream.read(unknown, false);
-        s << "\nunknown = " << unknown;
-        break;
     }
 
-    default:
+    if (connection)
     {
-        s << "(unknown)";
-        break;
-    }
-    }
+        s << "\ntransport = " << connection->type() << '\n';
 
-    if(replyStatus == replyOK || replyStatus == replyUserException)
-    {
-        Ice::EncodingVersion v = stream.skipEncapsulation();
-        if(v > Ice::Encoding_1_0)
+        // We can't get connectionInfo here: it results in a self-deadlock since this code is often executed with the
+        // non-recursive connection mutex locked.
+        const string& connectionId = connection->endpoint()->connectionId();
+        if (!connectionId.empty())
         {
-            s << "\nencoding = " << v;
+            s << "connection ID = " << connectionId << '\n';
         }
+        s << connection->toString();
     }
-}
-
-static Byte
-printMessage(ostream& s, InputStream& stream)
-{
-    Byte type = printHeader(s, stream);
-
-    switch(type)
-    {
-    case closeConnectionMsg:
-    case validateConnectionMsg:
-    {
-        // We're done.
-        break;
-    }
-
-    case requestMsg:
-    {
-        printRequest(s, stream);
-        break;
-    }
-
-    case requestBatchMsg:
+    else
     {
-        printBatchRequest(s, stream);
-        break;
-    }
-
-    case replyMsg:
-    {
-        printReply(s, stream);
-        break;
-    }
-
-    default:
-    {
-        break;
-    }
+        s << "\ncollocated = true";
     }
 
     return type;
@@ -372,70 +314,61 @@ printMessage(ostream& s, InputStream& stream)
 
 namespace
 {
-
-IceUtil::Mutex* slicingMutex = 0;
-
-class Init
-{
-public:
-
-    Init()
-    {
-        slicingMutex = new IceUtil::Mutex;
-    }
-
-    ~Init()
-    {
-        delete slicingMutex;
-        slicingMutex = 0;
-    }
-};
-
-Init init;
-
+    mutex slicingMutex;
 }
 
 void
-IceInternal::traceSlicing(const char* kind, const string& typeId, const char* slicingCat, const LoggerPtr& logger)
+IceInternal::traceSlicing(const char* kind, string_view typeId, const char* slicingCat, const LoggerPtr& logger)
 {
-    IceUtilInternal::MutexPtrLock<IceUtil::Mutex> lock(slicingMutex);
-    static set<string> slicingIds;
-    if(slicingIds.insert(typeId).second)
+    lock_guard lock(slicingMutex);
+    static set<string, std::less<>> slicingIds;
+    if (slicingIds.find(typeId) == slicingIds.end())
     {
+        string newTypeId(typeId);
+        slicingIds.insert(newTypeId);
         string s("unknown ");
         s += kind;
-        s += " type `" + typeId + "'";
+        s += " type '" + newTypeId + "'";
         logger->trace(slicingCat, s);
     }
 }
 
 void
-IceInternal::traceSend(const OutputStream& str, const LoggerPtr& logger, const TraceLevelsPtr& tl)
+IceInternal::traceSend(
+    const OutputStream& str,
+    const InstancePtr& instance,
+    const ConnectionI* connection,
+    const LoggerPtr& logger,
+    const TraceLevelsPtr& tl)
 {
-    if(tl->protocol >= 1)
+    if (tl->protocol >= 1)
     {
-        OutputStream& stream = const_cast<OutputStream&>(str);
-        InputStream is(stream.instance(), stream.getEncoding(), stream);
+        auto& stream = const_cast<OutputStream&>(str);
+        InputStream is{instance.get(), stream.getEncoding(), stream, false};
         is.i = is.b.begin();
 
         ostringstream s;
-        Byte type = printMessage(s, is);
+        uint8_t type = printMessage(s, is, connection);
 
         logger->trace(tl->protocolCat, "sending " + getMessageTypeAsString(type) + " " + s.str());
     }
 }
 
 void
-IceInternal::traceRecv(const InputStream& str, const LoggerPtr& logger, const TraceLevelsPtr& tl)
+IceInternal::traceRecv(
+    const InputStream& str,
+    const ConnectionI* connection,
+    const LoggerPtr& logger,
+    const TraceLevelsPtr& tl)
 {
-    if(tl->protocol >= 1)
+    if (tl->protocol >= 1)
     {
-        InputStream& stream = const_cast<InputStream&>(str);
+        auto& stream = const_cast<InputStream&>(str);
         InputStream::Container::iterator p = stream.i;
         stream.i = stream.b.begin();
 
         ostringstream s;
-        Byte type = printMessage(s, stream);
+        uint8_t type = printMessage(s, stream, connection);
 
         logger->trace(tl->protocolCat, "received " + getMessageTypeAsString(type) + " " + s.str());
         stream.i = p;
@@ -443,34 +376,22 @@ IceInternal::traceRecv(const InputStream& str, const LoggerPtr& logger, const Tr
 }
 
 void
-IceInternal::trace(const char* heading, const OutputStream& str, const LoggerPtr& logger, const TraceLevelsPtr& tl)
-{
-    if(tl->protocol >= 1)
-    {
-        OutputStream& stream = const_cast<OutputStream&>(str);
-        InputStream is(stream.instance(), stream.getEncoding(), stream);
-        is.i = is.b.begin();
-
-        ostringstream s;
-        s << heading;
-        printMessage(s, is);
-
-        logger->trace(tl->protocolCat, s.str());
-    }
-}
-
-void
-IceInternal::trace(const char* heading, const InputStream& str, const LoggerPtr& logger, const TraceLevelsPtr& tl)
+IceInternal::trace(
+    const char* heading,
+    const InputStream& str,
+    const ConnectionI* connection,
+    const LoggerPtr& logger,
+    const TraceLevelsPtr& tl)
 {
-    if(tl->protocol >= 1)
+    if (tl->protocol >= 1)
     {
-        InputStream& stream = const_cast<InputStream&>(str);
+        auto& stream = const_cast<InputStream&>(str);
         InputStream::Container::iterator p = stream.i;
         stream.i = stream.b.begin();
 
         ostringstream s;
         s << heading;
-        printMessage(s, stream);
+        printMessage(s, stream, connection);
 
         logger->trace(tl->protocolCat, s.str());
         stream.i = p;

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

@@ -1,30 +1,41 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef ICE_TRACE_UTIL_H
 #define ICE_TRACE_UTIL_H
 
-#include <Ice/LoggerF.h>
-#include <Ice/TraceLevelsF.h>
+#include "Ice/InstanceF.h"
+#include "Ice/Logger.h"
+#include "TraceLevelsF.h"
 
 namespace Ice
 {
-
-class OutputStream;
-class InputStream;
-
+    class OutputStream;
+    class InputStream;
+    class ConnectionI;
 }
 
 namespace IceInternal
 {
-
-void traceSend(const ::Ice::OutputStream&, const ::Ice::LoggerPtr&, const TraceLevelsPtr&);
-void traceRecv(const ::Ice::InputStream&, const ::Ice::LoggerPtr&, const TraceLevelsPtr&);
-void trace(const char*, const ::Ice::OutputStream&, const ::Ice::LoggerPtr&, const TraceLevelsPtr&);
-void trace(const char*, const ::Ice::InputStream&, const ::Ice::LoggerPtr&, const TraceLevelsPtr&);
-void traceSlicing(const char*, const ::std::string&, const char *, const ::Ice::LoggerPtr&);
-
+    class Instance;
+
+    void traceSend(
+        const Ice::OutputStream&,
+        const InstancePtr& instance,
+        const Ice::ConnectionI* connection,
+        const Ice::LoggerPtr&,
+        const TraceLevelsPtr&);
+    void traceRecv(
+        const Ice::InputStream&,
+        const Ice::ConnectionI* connection,
+        const Ice::LoggerPtr&,
+        const TraceLevelsPtr&);
+    void trace(
+        const char*,
+        const Ice::InputStream&,
+        const Ice::ConnectionI* connection,
+        const Ice::LoggerPtr&,
+        const TraceLevelsPtr&);
+    void traceSlicing(const char*, std::string_view, const char*, const Ice::LoggerPtr&);
 }
 
 #endif

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

@@ -1,18 +1,14 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
-#include <Ice/Transceiver.h>
+#include "Transceiver.h"
 
 using namespace std;
 using namespace Ice;
 using namespace IceInternal;
 
-IceUtil::Shared* IceInternal::upCast(Transceiver* p) { return p; }
-
 EndpointIPtr
 IceInternal::Transceiver::bind()
 {
     assert(false);
-    return 0;
+    return nullptr;
 }