zeroc-ice 3.7.10 → 3.8.0

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

@@ -0,0 +1,90 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_UDP_TRANSCEIVER_H
+#define ICE_UDP_TRANSCEIVER_H
+
+#include "Network.h"
+#include "ProtocolInstanceF.h"
+#include "Transceiver.h"
+
+namespace IceInternal
+{
+    class UdpEndpoint;
+
+    class UdpTransceiver final : public Transceiver,
+                                 public NativeInfo,
+                                 public std::enable_shared_from_this<UdpTransceiver>
+    {
+        enum State
+        {
+            StateNeedConnect,
+            StateConnectPending,
+            StateConnected,
+            StateNotConnected
+        };
+
+    public:
+        UdpTransceiver(ProtocolInstancePtr, const Address&, const Address&, const std::string&, int);
+        UdpTransceiver(UdpEndpointIPtr, const ProtocolInstancePtr&, const std::string&, int, std::string);
+
+        ~UdpTransceiver() final;
+
+        NativeInfoPtr getNativeInfo() final;
+#if defined(ICE_USE_IOCP)
+        AsyncInfo* getAsyncInfo(SocketOperation) final;
+#endif
+
+        SocketOperation initialize(Buffer&, Buffer&) final;
+        SocketOperation closing(bool, std::exception_ptr) final;
+        void close() final;
+        EndpointIPtr bind() final;
+        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&) final;
+#endif
+        [[nodiscard]] std::string protocol() const final;
+        [[nodiscard]] std::string toString() const final;
+        [[nodiscard]] std::string toDetailedString() const final;
+        [[nodiscard]] Ice::ConnectionInfoPtr
+        getInfo(bool incoming, std::string adapterName, std::string connectionId) const final;
+        void checkSendSize(const Buffer&) final;
+        void setBufferSize(int rcvSize, int sndSize) final;
+
+        [[nodiscard]] int effectivePort() const;
+
+    private:
+        void setBufSize(int, int);
+
+        UdpEndpointIPtr _endpoint;
+        const ProtocolInstancePtr _instance;
+        const bool _incoming;
+        bool _bound;
+
+        const Address _addr;
+        Address _mcastAddr;
+        const std::string _mcastInterface;
+        Address _peerAddr;
+
+#if defined(_WIN32)
+        int _port;
+#endif
+
+        State _state;
+        int _rcvSize;
+        int _sndSize;
+        static const int _udpOverhead;
+        static const int _maxPacketSize;
+
+#if defined(ICE_USE_IOCP)
+        AsyncInfo _read;
+        AsyncInfo _write;
+        Address _readAddr;
+        socklen_t _readAddrLen;
+#endif
+    };
+}
+#endif

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

@@ -0,0 +1,37 @@
+// Copyright (c) ZeroC, Inc.
+
+/*! \file
+    \hideincludedbygraph
+*/
+
+#ifndef ICE_UNDEF_SYS_MACROS_H
+#define ICE_UNDEF_SYS_MACROS_H
+
+// This header includes macros that can end up being dragged into
+// the generated code from system headers, such as major().
+// If a Slice symbol has the same name as a macro, the generated
+// code most likely won't compile (but, depending how the macro is
+// defined, may even compile).
+//
+// Here, we undefine symbols that cause such problems.
+//
+// The #ifdef ... #endif protection is necessary to prevent
+// warnings on some platforms.
+
+#ifdef major
+#    undef major
+#endif
+
+#ifdef minor
+#    undef minor
+#endif
+
+#ifdef min
+#    undef min
+#endif
+
+#ifdef max
+#    undef max
+#endif
+
+#endif

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

@@ -0,0 +1,77 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_UNIQUE_REF_H
+#define ICE_UNIQUE_REF_H
+
+#include <cassert>
+
+#ifdef __APPLE__
+
+#    include <CoreFoundation/CoreFoundation.h>
+
+namespace IceInternal
+{
+    //
+    // UniqueRef helper class for CoreFoundation classes, comparable to std::unique_ptr
+    //
+    template<typename R> class UniqueRef
+    {
+    public:
+        explicit UniqueRef(R ref = nullptr) : _ref(ref) {}
+
+        ~UniqueRef()
+        {
+            if (_ref != nullptr)
+            {
+                CFRelease(_ref);
+            }
+        }
+
+        UniqueRef(UniqueRef&) = delete;
+        UniqueRef& operator=(UniqueRef&) = delete;
+
+        R release()
+        {
+            R r = _ref;
+            _ref = nullptr;
+            return r;
+        }
+
+        void reset(R ref = nullptr)
+        {
+            //
+            // Support "self-reset" for CF objects. This is useful if CF allocation methods return
+            // the same object with an increased reference count.
+            //
+            // assert(ref == nullptr || ref != _ref);
+
+            if (_ref != nullptr)
+            {
+                CFRelease(_ref);
+            }
+            _ref = ref;
+        }
+
+        void retain(R ref) { reset(ref ? (R)CFRetain(ref) : ref); }
+
+        R& get() { return _ref; }
+
+        [[nodiscard]] R get() const { return _ref; }
+
+        operator bool() const { return _ref != nullptr; }
+
+        void swap(UniqueRef& a) noexcept
+        {
+            R tmp = a._ref;
+            a._ref = _ref;
+            _ref = tmp;
+        }
+
+    private:
+        R _ref;
+    };
+}
+
+#endif
+
+#endif

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

@@ -0,0 +1,58 @@
+// Copyright (c) ZeroC, Inc.
+
+#include "Ice/UserException.h"
+#include "Ice/Demangle.h"
+#include "Ice/InputStream.h"
+#include "Ice/OutputStream.h"
+
+using namespace std;
+using namespace Ice;
+using namespace IceInternal;
+
+const char*
+Ice::UserException::what() const noexcept
+{
+    return ice_id();
+}
+
+void
+Ice::UserException::ice_print(ostream& os) const
+{
+    string className{demangle(typeid(*this).name())};
+    // On Windows, the class name is prefixed with "class "; we removed it.
+    if (className.compare(0, 6, "class ") == 0)
+    {
+        className.erase(0, 6);
+    }
+
+    os << className << '{';
+    ice_printFields(os);
+    os << '}';
+}
+
+void
+Ice::UserException::ice_printFields(ostream&) const
+{
+}
+
+void
+Ice::UserException::_write(OutputStream* os) const
+{
+    os->startException();
+    _writeImpl(os);
+    os->endException();
+}
+
+void
+Ice::UserException::_read(InputStream* is)
+{
+    is->startException();
+    _readImpl(is);
+    is->endException();
+}
+
+bool
+Ice::UserException::_usesClasses() const
+{
+    return false;
+}

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

@@ -0,0 +1,145 @@
+// Copyright (c) ZeroC, Inc.
+
+#include "Ice/Value.h"
+#include "Ice/Demangle.h"
+#include "Ice/InputStream.h"
+#include "Ice/LocalExceptions.h"
+#include "Ice/OutputStream.h"
+#include "Ice/SlicedData.h"
+
+#include <algorithm>
+#include <deque>
+
+using namespace std;
+using namespace Ice;
+using namespace IceInternal;
+
+namespace
+{
+    // RAII helper class that detects cycles when printing class instances.
+    class CycleChecker final
+    {
+    public:
+        CycleChecker(const Value* value, ostream& os) : _os(os)
+        {
+            // Retrieve current stack, if any.
+            void*& currentVoidStar = _os.pword(_cycleCheckIndex);
+            if (currentVoidStar)
+            {
+                auto* currentStack = static_cast<deque<const Value*>*>(currentVoidStar);
+                if (find(currentStack->begin(), currentStack->end(), value) == currentStack->end())
+                {
+                    // No cycle detected.
+                    _currentStack = currentStack;
+                }
+                // else _currentStack remains null and CycleChecker doesn't do anything.
+            }
+            else // new stack
+            {
+                _currentStack = &_localStack;
+                currentVoidStar = _currentStack;
+            }
+
+            if (_currentStack)
+            {
+                _currentStack->push_front(value);
+            }
+        }
+
+        ~CycleChecker()
+        {
+            if (_currentStack)
+            {
+                _currentStack->pop_front();
+
+                if (_currentStack == &_localStack)
+                {
+                    // Clear value in os.
+                    _os.pword(_cycleCheckIndex) = nullptr;
+                }
+            }
+            assert(_localStack.size() == 0);
+        }
+
+        [[nodiscard]] bool good() const noexcept { return _currentStack; }
+
+    private:
+        ostream& _os;
+        deque<const Value*> _localStack;
+        deque<const Value*>* _currentStack{nullptr}; // may or may not point to _localStack
+
+        static const int _cycleCheckIndex;
+    };
+
+    const int CycleChecker::_cycleCheckIndex = ios_base::xalloc(); // NOLINT(cert-err58-cpp)
+}
+
+Ice::Value::~Value() = default;
+
+void
+Ice::Value::ice_print(ostream& os) const
+{
+    string className{demangle(typeid(*this).name())};
+    // On Windows, the class name is prefixed with "class "; we removed it.
+    if (className.compare(0, 6, "class ") == 0)
+    {
+        className.erase(0, 6);
+    }
+
+    os << className << '{';
+    const CycleChecker cycleChecker{this, os};
+    if (cycleChecker.good())
+    {
+        ice_printFields(os);
+    }
+    else
+    {
+        os << "...already printed...";
+    }
+    os << '}';
+}
+
+void
+Ice::Value::ice_printFields(ostream&) const
+{
+}
+
+void
+Ice::Value::_iceWrite(Ice::OutputStream* os) const
+{
+    os->startValue(_slicedData);
+    _iceWriteImpl(os);
+    os->endValue();
+}
+
+void
+Ice::Value::_iceRead(Ice::InputStream* is)
+{
+    is->startValue();
+    _iceReadImpl(is);
+    _slicedData = is->endValue();
+}
+
+const char*
+Ice::Value::ice_id() const noexcept
+{
+    return ice_staticId();
+}
+
+const char*
+Ice::Value::ice_staticId() noexcept
+{
+    return "::Ice::Object";
+}
+
+SlicedDataPtr
+Ice::Value::ice_getSlicedData() const
+{
+    return _slicedData;
+}
+
+Ice::ValuePtr
+Ice::Value::_iceCloneImpl() const
+{
+    throw std::logic_error("clone is not implemented for this class");
+}

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

@@ -0,0 +1,87 @@
+// Copyright (c) ZeroC, Inc.
+
+#include "WSAcceptor.h"
+#include "WSEndpoint.h"
+#include "WSTransceiver.h"
+
+using namespace std;
+using namespace Ice;
+using namespace IceInternal;
+
+IceInternal::NativeInfoPtr
+IceInternal::WSAcceptor::getNativeInfo()
+{
+    return _delegate->getNativeInfo();
+}
+
+#if defined(ICE_USE_IOCP)
+IceInternal::AsyncInfo*
+IceInternal::WSAcceptor::getAsyncInfo(IceInternal::SocketOperation status)
+{
+    return _delegate->getNativeInfo()->getAsyncInfo(status);
+}
+#endif
+
+void
+IceInternal::WSAcceptor::close()
+{
+    _delegate->close();
+}
+
+EndpointIPtr
+IceInternal::WSAcceptor::listen()
+{
+    _endpoint = _endpoint->endpoint(_delegate->listen());
+    return _endpoint;
+}
+
+#if defined(ICE_USE_IOCP)
+void
+IceInternal::WSAcceptor::startAccept()
+{
+    _delegate->startAccept();
+}
+
+void
+IceInternal::WSAcceptor::finishAccept()
+{
+    _delegate->finishAccept();
+}
+#endif
+
+IceInternal::TransceiverPtr
+IceInternal::WSAcceptor::accept()
+{
+    //
+    // WebSocket handshaking is performed in TransceiverI::initialize, since
+    // accept must not block.
+    //
+    return make_shared<WSTransceiver>(_instance, _delegate->accept());
+}
+
+string
+IceInternal::WSAcceptor::protocol() const
+{
+    return _delegate->protocol();
+}
+
+string
+IceInternal::WSAcceptor::toString() const
+{
+    return _delegate->toString();
+}
+
+string
+IceInternal::WSAcceptor::toDetailedString() const
+{
+    return _delegate->toDetailedString();
+}
+
+IceInternal::WSAcceptor::WSAcceptor(WSEndpointPtr endpoint, ProtocolInstancePtr instance, AcceptorPtr del)
+    : _endpoint(std::move(endpoint)),
+      _instance(std::move(instance)),
+      _delegate(std::move(del))
+{
+}
+
+IceInternal::WSAcceptor::~WSAcceptor() = default;

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

@@ -0,0 +1,46 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_WS_ACCEPTOR_I_H
+#define ICE_WS_ACCEPTOR_I_H
+
+#include "Acceptor.h"
+#include "Ice/Logger.h"
+#include "Network.h"
+#include "ProtocolInstance.h"
+#include "TransceiverF.h"
+
+namespace IceInternal
+{
+    class WSEndpoint;
+
+    class WSAcceptor final : public Acceptor, public NativeInfo
+    {
+    public:
+        WSAcceptor(WSEndpointPtr, ProtocolInstancePtr, AcceptorPtr);
+        ~WSAcceptor() override;
+        NativeInfoPtr getNativeInfo() final;
+#if defined(ICE_USE_IOCP)
+        AsyncInfo* getAsyncInfo(SocketOperation) final;
+#endif
+
+        void close() final;
+        EndpointIPtr listen() final;
+#if defined(ICE_USE_IOCP)
+        void startAccept() final;
+        void finishAccept() final;
+#endif
+        TransceiverPtr accept() final;
+        [[nodiscard]] std::string protocol() const final;
+        [[nodiscard]] std::string toString() const final;
+        [[nodiscard]] std::string toDetailedString() const final;
+
+    private:
+        friend class WSEndpoint;
+
+        WSEndpointPtr _endpoint;
+        const ProtocolInstancePtr _instance;
+        const AcceptorPtr _delegate;
+    };
+}
+
+#endif

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

@@ -0,0 +1,87 @@
+// Copyright (c) ZeroC, Inc.
+
+#include "WSConnector.h"
+#include "HttpParser.h"
+#include "TargetCompare.h"
+#include "WSEndpoint.h"
+#include "WSTransceiver.h"
+
+using namespace std;
+using namespace Ice;
+using namespace IceInternal;
+
+TransceiverPtr
+IceInternal::WSConnector::connect()
+{
+    return make_shared<WSTransceiver>(_instance, _delegate->connect(), _host, _resource);
+}
+
+int16_t
+IceInternal::WSConnector::type() const
+{
+    return _delegate->type();
+}
+
+string
+IceInternal::WSConnector::toString() const
+{
+    return _delegate->toString();
+}
+
+bool
+IceInternal::WSConnector::operator==(const Connector& r) const
+{
+    const auto* p = dynamic_cast<const WSConnector*>(&r);
+    if (!p)
+    {
+        return false;
+    }
+
+    if (this == p)
+    {
+        return true;
+    }
+
+    if (_resource != p->_resource)
+    {
+        return false;
+    }
+
+    return Ice::targetEqualTo(_delegate, p->_delegate);
+}
+
+bool
+IceInternal::WSConnector::operator<(const Connector& r) const
+{
+    const auto* p = dynamic_cast<const WSConnector*>(&r);
+    if (!p)
+    {
+        return type() < r.type();
+    }
+
+    if (this == p)
+    {
+        return false;
+    }
+
+    if (_resource < p->_resource)
+    {
+        return true;
+    }
+    else if (p->_resource < _resource)
+    {
+        return false;
+    }
+
+    return Ice::targetLess(_delegate, p->_delegate);
+}
+
+IceInternal::WSConnector::WSConnector(ProtocolInstancePtr instance, ConnectorPtr del, string host, string resource)
+    : _instance(std::move(instance)),
+      _delegate(std::move(del)),
+      _host(std::move(host)),
+      _resource(std::move(resource))
+{
+}
+
+IceInternal::WSConnector::~WSConnector() = default;

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

@@ -0,0 +1,36 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_WSCONNECTOR_I_H
+#define ICE_WSCONNECTOR_I_H
+
+#include "Connector.h"
+#include "Ice/Logger.h"
+#include "ProtocolInstance.h"
+#include "TransceiverF.h"
+
+namespace IceInternal
+{
+    class WSEndpoint;
+
+    class WSConnector final : public Connector
+    {
+    public:
+        WSConnector(ProtocolInstancePtr, ConnectorPtr, std::string, std::string);
+        ~WSConnector() override;
+        TransceiverPtr connect() final;
+
+        [[nodiscard]] std::int16_t type() const final;
+        [[nodiscard]] std::string toString() const final;
+
+        bool operator==(const Connector&) const final;
+        bool operator<(const Connector&) const final;
+
+    private:
+        const ProtocolInstancePtr _instance;
+        const ConnectorPtr _delegate;
+        const std::string _host;
+        const std::string _resource;
+    };
+}
+
+#endif