zeroc-ice 3.7.11 → 3.8.1

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

@@ -1,152 +1,106 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef ICE_IP_ENDPOINT_I_H
 #define ICE_IP_ENDPOINT_I_H
 
-#include <IceUtil/Config.h>
-#include <IceUtil/Shared.h>
-#include <IceUtil/Thread.h>
-#include <IceUtil/Monitor.h>
-#include <Ice/IPEndpointIF.h>
-#include <Ice/EndpointI.h>
-#include <Ice/Network.h>
-#include <Ice/ProtocolInstanceF.h>
-#include <Ice/ObserverHelper.h>
+#include "EndpointI.h"
+#include "IPEndpointIF.h"
+#include "Ice/Config.h"
+#include "Ice/ObserverHelper.h"
+#include "Network.h"
+#include "ProtocolInstanceF.h"
 
+#include <condition_variable>
 #include <deque>
+#include <mutex>
 
 namespace IceInternal
 {
+    class IPEndpointI : public EndpointI, public std::enable_shared_from_this<IPEndpointI>
+    {
+    public:
+        void streamWriteImpl(Ice::OutputStream*) const override;
 
-class ICE_API IPEndpointInfoI : public Ice::IPEndpointInfo
-{
-public:
-
-    IPEndpointInfoI(const EndpointIPtr&);
-    virtual ~IPEndpointInfoI();
-
-    virtual Ice::Short type() const ICE_NOEXCEPT;
-    virtual bool datagram() const ICE_NOEXCEPT;
-    virtual bool secure() const ICE_NOEXCEPT;
-
-private:
-
-    const EndpointIPtr _endpoint;
-};
-
-class ICE_API IPEndpointI : public EndpointI
-#ifdef ICE_CPP11_MAPPING
-                          , public std::enable_shared_from_this<IPEndpointI>
-#endif
-{
-public:
-
-    virtual void streamWriteImpl(Ice::OutputStream*) const;
-
-    virtual Ice::EndpointInfoPtr getInfo() const ICE_NOEXCEPT;
-    virtual Ice::Short type() const;
-    virtual const std::string& protocol() const;
-    virtual bool secure() const;
-
-    virtual const std::string& connectionId() const;
-    virtual EndpointIPtr connectionId(const ::std::string&) const;
-
-    virtual void connectors_async(Ice::EndpointSelectionType, const EndpointI_connectorsPtr&) const;
-    virtual std::vector<EndpointIPtr> expandIfWildcard() const;
-    virtual std::vector<EndpointIPtr> expandHost(EndpointIPtr&) const;
-    virtual bool equivalent(const EndpointIPtr&) const;
-    virtual ::Ice::Int hash() const;
-    virtual std::string options() const;
-
-#ifdef ICE_CPP11_MAPPING
-    virtual bool operator==(const Ice::Endpoint&) const;
-    virtual bool operator<(const Ice::Endpoint&) const;
-#else
-    virtual bool operator==(const Ice::LocalObject&) const;
-    virtual bool operator<(const Ice::LocalObject&) const;
-#endif
-
-    virtual std::vector<ConnectorPtr> connectors(const std::vector<Address>&, const NetworkProxyPtr&) const;
-
-    virtual void hashInit(Ice::Int&) const;
-    virtual void fillEndpointInfo(Ice::IPEndpointInfo*) const;
-
-    using EndpointI::connectionId;
-
-    virtual void initWithOptions(std::vector<std::string>&, bool);
-
-protected:
-
-    friend class EndpointHostResolver;
-
-    virtual bool checkOption(const std::string&, const std::string&, const std::string&);
+        [[nodiscard]] std::int16_t type() const override;
+        [[nodiscard]] const std::string& protocol() const override;
+        [[nodiscard]] bool secure() const override;
 
-    virtual ConnectorPtr createConnector(const Address& address, const NetworkProxyPtr&) const = 0;
-    virtual IPEndpointIPtr createEndpoint(const std::string&, int, const std::string&) const = 0;
+        [[nodiscard]] const std::string& connectionId() const override;
+        [[nodiscard]] EndpointIPtr connectionId(const std::string&) const override;
+        void connectorsAsync(std::function<void(std::vector<ConnectorPtr>)>, std::function<void(std::exception_ptr)>)
+            const override;
+        [[nodiscard]] std::vector<EndpointIPtr> expandHost() const override;
+        [[nodiscard]] bool isLoopbackOrMulticast() const override;
+        [[nodiscard]] bool equivalent(const EndpointIPtr&) const override;
+        [[nodiscard]] std::size_t hash() const noexcept override;
+        [[nodiscard]] std::string options() const override;
 
-    IPEndpointI(const ProtocolInstancePtr&, const std::string&, int, const Address&, const std::string&);
-    IPEndpointI(const ProtocolInstancePtr&);
-    IPEndpointI(const ProtocolInstancePtr&, Ice::InputStream*);
+        bool operator==(const Ice::Endpoint&) const override;
+        bool operator<(const Ice::Endpoint&) const override;
 
-    const ProtocolInstancePtr _instance;
-    const std::string _host;
-    const int _port;
-    const Address _sourceAddr;
-    const std::string _connectionId;
+        [[nodiscard]] virtual std::vector<ConnectorPtr>
+        connectors(const std::vector<Address>&, const NetworkProxyPtr&) const;
 
-private:
+        using EndpointI::connectionId;
 
-    mutable bool _hashInitialized;
-    mutable Ice::Int _hashValue;
-};
+        virtual void initWithOptions(std::vector<std::string>&, bool);
 
-class ICE_API EndpointHostResolver : public IceUtil::Thread, public IceUtil::Monitor<IceUtil::Mutex>
-{
-public:
+    protected:
+        friend class EndpointHostResolver;
 
-    EndpointHostResolver(const InstancePtr&);
+        bool checkOption(const std::string&, const std::string&, const std::string&) override;
 
-    void resolve(const std::string&, int, Ice::EndpointSelectionType, const IPEndpointIPtr&,
-                 const EndpointI_connectorsPtr&);
-    void destroy();
+        [[nodiscard]] virtual ConnectorPtr createConnector(const Address& address, const NetworkProxyPtr&) const = 0;
+        [[nodiscard]] virtual IPEndpointIPtr createEndpoint(const std::string&, int, const std::string&) const = 0;
 
-    virtual void run();
-    void updateObserver();
+        IPEndpointI(ProtocolInstancePtr, std::string, int, const Address&, std::string);
+        IPEndpointI(ProtocolInstancePtr);
+        IPEndpointI(ProtocolInstancePtr, Ice::InputStream*);
 
-private:
+        const ProtocolInstancePtr _instance;
+        const std::string _host;
+        const std::string _normalizedHost;
+        const int _port;
+        const Address _sourceAddr;
+        const std::string _connectionId;
+    };
 
-    struct ResolveEntry
+    class EndpointHostResolver final
     {
-        std::string host;
-        int port;
-        Ice::EndpointSelectionType selType;
-        IPEndpointIPtr endpoint;
-        EndpointI_connectorsPtr callback;
-        Ice::Instrumentation::ObserverPtr observer;
+    public:
+        EndpointHostResolver(const InstancePtr&);
+
+        void resolve(
+            const std::string&,
+            int,
+            const IPEndpointIPtr&,
+            std::function<void(std::vector<ConnectorPtr>)>,
+            std::function<void(std::exception_ptr)>);
+        void destroy();
+
+        void run();
+        void updateObserver();
+
+    private:
+        struct ResolveEntry
+        {
+            std::string host;
+            int port;
+            IPEndpointIPtr endpoint;
+            std::function<void(std::vector<ConnectorPtr>)> response;
+            std::function<void(std::exception_ptr)> exception;
+            Ice::Instrumentation::ObserverPtr observer;
+        };
+
+        const InstancePtr _instance;
+        const IceInternal::ProtocolSupport _protocol;
+        const bool _preferIPv6;
+        bool _destroyed{false};
+        std::deque<ResolveEntry> _queue;
+        ObserverHelperT<Ice::Instrumentation::ThreadObserver> _observer;
+        std::mutex _mutex;
+        std::condition_variable _conditionVariable;
     };
-
-    const InstancePtr _instance;
-    const IceInternal::ProtocolSupport _protocol;
-    const bool _preferIPv6;
-    bool _destroyed;
-    std::deque<ResolveEntry> _queue;
-    ObserverHelperT<Ice::Instrumentation::ThreadObserver> _observer;
-};
-
-#ifndef ICE_CPP11_MAPPING
-inline bool operator==(const IPEndpointI& l, const IPEndpointI& r)
-{
-    return static_cast<const ::Ice::LocalObject&>(l) == static_cast<const ::Ice::LocalObject&>(r);
-}
-
-inline bool operator<(const IPEndpointI& l, const IPEndpointI& r)
-{
-    return static_cast<const ::Ice::LocalObject&>(l) < static_cast<const ::Ice::LocalObject&>(r);
-}
-#endif
-
 }
 
 #endif

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

@@ -1,28 +1,17 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef ICE_IP_ENDPOINT_I_F_H
 #define ICE_IP_ENDPOINT_I_F_H
 
-#include <IceUtil/Shared.h>
-#include <Ice/Handle.h>
+#include <memory>
 
 namespace IceInternal
 {
+    class IPEndpointI;
+    using IPEndpointIPtr = std::shared_ptr<IPEndpointI>;
 
-class IPEndpointI;
-
-#ifdef ICE_CPP11_MAPPING
-using IPEndpointIPtr = ::std::shared_ptr<IPEndpointI>;
-#else
-ICE_API IceUtil::Shared* upCast(IPEndpointI*);
-typedef Handle<IPEndpointI> IPEndpointIPtr;
-#endif
-
-class EndpointHostResolver;
-ICE_API IceUtil::Shared* upCast(EndpointHostResolver*);
-typedef Handle<EndpointHostResolver> EndpointHostResolverPtr;
+    class EndpointHostResolver;
+    using EndpointHostResolverPtr = std::shared_ptr<EndpointHostResolver>;
 }
 
 #endif

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

@@ -0,0 +1,172 @@
+// Copyright (c) ZeroC, Inc.
+
+#include "IdleTimeoutTransceiverDecorator.h"
+
+#include <chrono>
+
+using namespace std;
+using namespace Ice;
+using namespace IceInternal;
+
+namespace
+{
+    class HeartbeatTimerTask final : public TimerTask
+    {
+    public:
+        HeartbeatTimerTask(const ConnectionIPtr& connection) : _connection(connection) {}
+
+        void runTimerTask() final
+        {
+            if (auto connection = _connection.lock())
+            {
+                connection->sendHeartbeat();
+            }
+            // else nothing to do, the connection is already gone.
+        }
+
+    private:
+        const weak_ptr<ConnectionI> _connection;
+    };
+
+    class IdleCheckTimerTask final : public TimerTask
+    {
+    public:
+        IdleCheckTimerTask(const ConnectionIPtr& connection, const chrono::seconds& idleTimeout)
+            : _connection(connection),
+              _idleTimeout(idleTimeout)
+        {
+        }
+
+        void runTimerTask() final
+        {
+            if (auto connection = _connection.lock())
+            {
+                connection->idleCheck(_idleTimeout);
+            }
+            // else nothing to do, the connection is already gone.
+        }
+
+    private:
+        const weak_ptr<ConnectionI> _connection;
+        const chrono::seconds _idleTimeout;
+    };
+}
+
+void
+IdleTimeoutTransceiverDecorator::decoratorInit(const ConnectionIPtr& connection, bool enableIdleCheck)
+{
+    _heartbeatTimerTask = make_shared<HeartbeatTimerTask>(connection);
+    if (enableIdleCheck)
+    {
+        _idleCheckTimerTask = make_shared<IdleCheckTimerTask>(connection, _idleTimeout);
+    }
+}
+
+SocketOperation
+IdleTimeoutTransceiverDecorator::initialize(Buffer& readBuffer, Buffer& writeBuffer)
+{
+    return _decoratee->initialize(readBuffer, writeBuffer);
+}
+
+IdleTimeoutTransceiverDecorator::~IdleTimeoutTransceiverDecorator()
+{
+    // Since ConnectionI is noexcept, decoratorInit always sets _heartbeatTimerTask.
+    assert(_heartbeatTimerTask);
+    _timer->cancel(_heartbeatTimerTask);
+    disableIdleCheck();
+}
+
+void
+IdleTimeoutTransceiverDecorator::close()
+{
+    _timer->cancel(_heartbeatTimerTask);
+    disableIdleCheck();
+    _decoratee->close();
+}
+
+SocketOperation
+IdleTimeoutTransceiverDecorator::write(Buffer& buf)
+{
+    _timer->cancel(_heartbeatTimerTask);
+
+    SocketOperation op = _decoratee->write(buf);
+    if (op == SocketOperationNone) // write completed
+    {
+        _timer->schedule(_heartbeatTimerTask, chrono::milliseconds(_idleTimeout) / 2);
+    }
+    return op;
+}
+
+#if defined(ICE_USE_IOCP)
+bool
+IdleTimeoutTransceiverDecorator::startWrite(Buffer& buf)
+{
+    // startWrite is called right after write returns SocketOperationWrite. The logic in write is sufficient.
+    return _decoratee->startWrite(buf);
+}
+
+void
+IdleTimeoutTransceiverDecorator::finishWrite(Buffer& buf)
+{
+    _decoratee->finishWrite(buf);
+    // We call write after finishWrite, so no need to do anything here.
+}
+
+void
+IdleTimeoutTransceiverDecorator::startRead(Buffer& buf)
+{
+    // We always call finishRead or read to actually read the data.
+    _decoratee->startRead(buf);
+}
+
+void
+IdleTimeoutTransceiverDecorator::finishRead(Buffer& buf)
+{
+    if (_idleCheckEnabled)
+    {
+        // We don't want the idle check to run while we're reading, so we reschedule it before reading.
+        _timer->reschedule(_idleCheckTimerTask, _idleTimeout);
+    }
+    _decoratee->finishRead(buf);
+}
+
+#endif
+
+SocketOperation
+IdleTimeoutTransceiverDecorator::read(Buffer& buf)
+{
+    if (_idleCheckEnabled)
+    {
+        // We don't want the idle check to run while we're reading, so we reschedule it before reading.
+        _timer->reschedule(_idleCheckTimerTask, _idleTimeout);
+    }
+    return _decoratee->read(buf);
+}
+
+void
+IdleTimeoutTransceiverDecorator::enableIdleCheck()
+{
+    if (!_idleCheckEnabled && _idleCheckTimerTask)
+    {
+        _timer->schedule(_idleCheckTimerTask, _idleTimeout);
+        _idleCheckEnabled = true;
+    }
+}
+
+void
+IdleTimeoutTransceiverDecorator::disableIdleCheck()
+{
+    if (_idleCheckEnabled && _idleCheckTimerTask)
+    {
+        _timer->cancel(_idleCheckTimerTask);
+        _idleCheckEnabled = false;
+    }
+}
+
+void
+IdleTimeoutTransceiverDecorator::scheduleHeartbeat()
+{
+    // Reschedule because the connection establishment may have already written to the connection and scheduled a
+    // heartbeat.
+    _timer->reschedule(_heartbeatTimerTask, chrono::milliseconds(_idleTimeout) / 2);
+}

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

@@ -0,0 +1,89 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_IDLE_TIMEOUT_TRANSCEIVER_DECORATOR_H
+#define ICE_IDLE_TIMEOUT_TRANSCEIVER_DECORATOR_H
+
+#include "ConnectionI.h"
+#include "Timer.h"
+#include "Transceiver.h"
+
+#include <cassert>
+
+namespace IceInternal
+{
+    // Decorates Transceiver to send heartbeats and optionally detect when no byte is received/read for a while.
+    // This decorator must not be applied on UDP connections.
+    class IdleTimeoutTransceiverDecorator final : public Transceiver
+    {
+    public:
+        IdleTimeoutTransceiverDecorator(
+            TransceiverPtr decoratee,
+            const std::chrono::seconds& idleTimeout,
+            IceInternal::TimerPtr timer)
+            : _decoratee(std::move(decoratee)),
+              _idleTimeout(idleTimeout),
+              _timer(std::move(timer))
+        {
+            assert(_decoratee->protocol() != "udp");
+        }
+
+        ~IdleTimeoutTransceiverDecorator();
+
+        // Set the timer tasks immediately after construction. Must be called only once.
+        void decoratorInit(const Ice::ConnectionIPtr& connection, bool enableIdleCheck);
+
+        NativeInfoPtr getNativeInfo() final { return _decoratee->getNativeInfo(); }
+
+        SocketOperation initialize(Buffer& readBuffer, Buffer& writeBuffer) final;
+
+        SocketOperation closing(bool initiator, std::exception_ptr ex) final
+        {
+            return _decoratee->closing(initiator, ex);
+        }
+
+        void close() final;
+
+        EndpointIPtr bind() final { return _decoratee->bind(); }
+
+        SocketOperation write(Buffer&) final;
+        SocketOperation read(Buffer&) final;
+
+#if defined(ICE_USE_IOCP)
+        bool startWrite(Buffer&) final;
+        void finishWrite(Buffer&) final;
+        void startRead(Buffer&) final;
+        void finishRead(Buffer& buf) final;
+#endif
+
+        [[nodiscard]] std::string protocol() const final { return _decoratee->protocol(); }
+        [[nodiscard]] std::string toString() const final { return _decoratee->toString(); }
+        [[nodiscard]] std::string toDetailedString() const final { return _decoratee->toDetailedString(); }
+
+        [[nodiscard]] Ice::ConnectionInfoPtr
+        getInfo(bool incoming, std::string adapterName, std::string connectionId) const final
+        {
+            return _decoratee->getInfo(incoming, std::move(adapterName), std::move(connectionId));
+        }
+
+        void checkSendSize(const Buffer& buf) final { _decoratee->checkSendSize(buf); };
+        void setBufferSize(int rcvSize, int sndSize) final { _decoratee->setBufferSize(rcvSize, sndSize); }
+
+        [[nodiscard]] bool idleCheckEnabled() const noexcept { return _idleCheckEnabled; }
+        void enableIdleCheck();
+        void disableIdleCheck();
+        void scheduleHeartbeat();
+
+    private:
+        const TransceiverPtr _decoratee;
+        const std::chrono::seconds _idleTimeout;
+        const IceInternal::TimerPtr _timer;
+
+        bool _idleCheckEnabled = false;
+
+        // Set by decoratorInit
+        IceInternal::TimerTaskPtr _heartbeatTimerTask;
+        IceInternal::TimerTaskPtr _idleCheckTimerTask;
+    };
+}
+
+#endif

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

@@ -0,0 +1,109 @@
+// Copyright (c) ZeroC, Inc.
+
+#include "Ice/ImplicitContext.h"
+#include "Ice/StreamHelpers.h"
+
+using namespace std;
+using namespace Ice;
+
+Context
+ImplicitContext::getContext() const
+{
+    lock_guard lock(_mutex);
+    return _context;
+}
+
+void
+ImplicitContext::setContext(Context newContext)
+{
+    lock_guard lock(_mutex);
+    _context = std::move(newContext);
+}
+
+bool
+ImplicitContext::containsKey(string_view key) const
+{
+    lock_guard lock(_mutex);
+    return _context.find(key) != _context.end();
+}
+
+string
+ImplicitContext::get(string_view key) const
+{
+    lock_guard lock(_mutex);
+    auto p = _context.find(key);
+    if (p == _context.end())
+    {
+        return "";
+    }
+    return p->second;
+}
+
+string
+ImplicitContext::put(string key, string value)
+{
+    lock_guard lock(_mutex);
+    string& val = _context[std::move(key)];
+
+    string oldVal = val;
+    val = std::move(value);
+    return oldVal;
+}
+
+string
+ImplicitContext::remove(string_view key)
+{
+    lock_guard lock(_mutex);
+    auto p = _context.find(key);
+    if (p == _context.end())
+    {
+        return "";
+    }
+    else
+    {
+        string oldVal = p->second;
+        _context.erase(p);
+        return oldVal;
+    }
+}
+
+void
+ImplicitContext::write(const Context& context, Ice::OutputStream* os) const
+{
+    unique_lock lock(_mutex);
+    if (context.size() == 0)
+    {
+        os->write(_context);
+    }
+    else if (_context.size() == 0)
+    {
+        lock.unlock();
+        os->write(context);
+    }
+    else
+    {
+        Context combined = context;
+        combined.insert(_context.begin(), _context.end());
+        lock.unlock();
+        os->write(combined);
+    }
+}
+
+void
+ImplicitContext::combine(const Context& context, Context& combined) const
+{
+    lock_guard lock(_mutex);
+    if (context.size() == 0)
+    {
+        combined = _context;
+    }
+    else if (_context.size() == 0)
+    {
+        combined = context;
+    }
+    else
+    {
+        combined = context;
+        combined.insert(_context.begin(), _context.end());
+    }
+}

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

@@ -0,0 +1,66 @@
+// Copyright (c) ZeroC, Inc.
+
+#include "Ice/IncomingRequest.h"
+#include "Ice/InputStream.h"
+#include "Ice/LocalExceptions.h"
+
+using namespace std;
+using namespace Ice;
+using namespace IceInternal;
+
+IncomingRequest::IncomingRequest(
+    int32_t requestId,
+    ConnectionPtr connection,
+    ObjectAdapterPtr adapter,
+    InputStream& inputStream,
+    int32_t requestCount)
+    : _inputStream(inputStream),
+      _requestCount(requestCount)
+{
+    _current.adapter = std::move(adapter);
+    _current.con = std::move(connection);
+    _current.requestId = requestId;
+
+    // Read everything else from the input stream.
+    auto start = inputStream.i;
+    inputStream.read(_current.id);
+
+    vector<string> facetPath;
+    inputStream.read(facetPath);
+    if (!facetPath.empty())
+    {
+        if (facetPath.size() > 1)
+        {
+            throw MarshalException{__FILE__, __LINE__, "received facet path with more than one element"};
+        }
+        _current.facet = facetPath[0];
+    }
+
+    inputStream.read(_current.operation, false);
+
+    uint8_t mode;
+    inputStream.read(mode);
+    _current.mode = static_cast<OperationMode>(mode);
+
+    int32_t sz = inputStream.readSize();
+    while (sz--)
+    {
+        string key;
+        string value;
+        inputStream.read(key);
+        inputStream.read(value);
+        _current.ctx.emplace(std::move(key), std::move(value));
+    }
+
+    int32_t encapsulationSize;
+    inputStream.read(encapsulationSize);
+    EncodingVersion encoding;
+    inputStream.read(encoding.major);
+    inputStream.read(encoding.minor);
+    _current.encoding = encoding;
+
+    // Rewind to the start of the encapsulation
+    inputStream.i -= 6;
+
+    _requestSize = static_cast<int32_t>(inputStream.i - start) + encapsulationSize;
+}