zeroc-ice 3.7.9.1 → 3.8.0

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

@@ -0,0 +1,106 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_IP_ENDPOINT_I_H
+#define ICE_IP_ENDPOINT_I_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;
+
+        [[nodiscard]] std::int16_t type() const override;
+        [[nodiscard]] const std::string& protocol() const override;
+        [[nodiscard]] bool secure() const override;
+
+        [[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;
+
+        bool operator==(const Ice::Endpoint&) const override;
+        bool operator<(const Ice::Endpoint&) const override;
+
+        [[nodiscard]] virtual std::vector<ConnectorPtr>
+        connectors(const std::vector<Address>&, const NetworkProxyPtr&) const;
+
+        using EndpointI::connectionId;
+
+        virtual void initWithOptions(std::vector<std::string>&, bool);
+
+    protected:
+        friend class EndpointHostResolver;
+
+        bool checkOption(const std::string&, const std::string&, const std::string&) override;
+
+        [[nodiscard]] virtual ConnectorPtr createConnector(const Address& address, const NetworkProxyPtr&) const = 0;
+        [[nodiscard]] virtual IPEndpointIPtr createEndpoint(const std::string&, int, const std::string&) const = 0;
+
+        IPEndpointI(ProtocolInstancePtr, std::string, int, const Address&, std::string);
+        IPEndpointI(ProtocolInstancePtr);
+        IPEndpointI(ProtocolInstancePtr, Ice::InputStream*);
+
+        const ProtocolInstancePtr _instance;
+        const std::string _host;
+        const std::string _normalizedHost;
+        const int _port;
+        const Address _sourceAddr;
+        const std::string _connectionId;
+    };
+
+    class EndpointHostResolver final
+    {
+    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;
+    };
+}
+
+#endif

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

@@ -0,0 +1,17 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_IP_ENDPOINT_I_F_H
+#define ICE_IP_ENDPOINT_I_F_H
+
+#include <memory>
+
+namespace IceInternal
+{
+    class IPEndpointI;
+    using IPEndpointIPtr = std::shared_ptr<IPEndpointI>;
+
+    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;
+}