zeroc-ice 3.7.9.1 → 3.8.0

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

@@ -0,0 +1,180 @@
+// Copyright (c) ZeroC, Inc.
+
+#include "EndpointFactoryManager.h"
+#include "DefaultsAndOverrides.h"
+#include "Ice/InputStream.h"
+#include "Ice/LocalExceptions.h"
+#include "Ice/OutputStream.h"
+#include "Ice/StringUtil.h"
+#include "Instance.h"
+#include "OpaqueEndpointI.h"
+
+using namespace std;
+using namespace Ice;
+using namespace IceInternal;
+
+IceInternal::EndpointFactoryManager::EndpointFactoryManager(InstancePtr instance) : _instance(std::move(instance)) {}
+
+void
+IceInternal::EndpointFactoryManager::initialize() const
+{
+    for (const auto& fact : _factories)
+    {
+        fact->initialize();
+    }
+}
+
+void
+IceInternal::EndpointFactoryManager::add(const EndpointFactoryPtr& factory)
+{
+    lock_guard lock(_mutex);
+    //
+    // TODO: Optimize with a map?
+    //
+    for (const auto& fact : _factories)
+    {
+        if (fact->type() == factory->type())
+        {
+            assert(false); // TODO: Exception?
+        }
+    }
+    _factories.push_back(factory);
+}
+
+EndpointFactoryPtr
+IceInternal::EndpointFactoryManager::get(int16_t type) const
+{
+    lock_guard lock(_mutex);
+    //
+    // TODO: Optimize with a map?
+    //
+    for (const auto& fact : _factories)
+    {
+        if (fact->type() == type)
+        {
+            return fact;
+        }
+    }
+    return nullptr;
+}
+
+EndpointIPtr
+IceInternal::EndpointFactoryManager::create(string_view str, bool oaEndpoint) const
+{
+    vector<string> v;
+    bool b = IceInternal::splitString(str, " \t\n\r", v);
+    if (!b)
+    {
+        throw ParseException(__FILE__, __LINE__, "mismatched quotes in endpoint '" + string{str} + "'");
+    }
+
+    if (v.empty())
+    {
+        throw ParseException(__FILE__, __LINE__, "endpoint '" + string{str} + "' has no non-whitespace characters");
+    }
+
+    string protocol = v.front();
+    v.erase(v.begin());
+
+    if (protocol == "default")
+    {
+        protocol = _instance->defaultsAndOverrides()->defaultProtocol;
+    }
+
+    EndpointFactoryPtr factory;
+    {
+        lock_guard lock(_mutex);
+        //
+        // TODO: Optimize with a map?
+        //
+        for (const auto& fact : _factories)
+        {
+            if (fact->protocol() == protocol)
+            {
+                factory = fact;
+            }
+        }
+    }
+
+    if (factory)
+    {
+        EndpointIPtr e = factory->create(v, oaEndpoint);
+        if (!v.empty())
+        {
+            throw ParseException(
+                __FILE__,
+                __LINE__,
+                "unrecognized argument '" + v.front() + "' in endpoint '" + string{str} + "'");
+        }
+        return e;
+    }
+
+    //
+    // If the stringified endpoint is opaque, create an unknown endpoint,
+    // then see whether the type matches one of the known endpoints.
+    //
+    if (protocol == "opaque")
+    {
+        EndpointIPtr ue = make_shared<OpaqueEndpointI>(v);
+        if (!v.empty())
+        {
+            throw ParseException(
+                __FILE__,
+                __LINE__,
+                "unrecognized argument '" + v.front() + "' in endpoint '" + string{str} + "'");
+        }
+        factory = get(ue->type());
+        if (factory)
+        {
+            //
+            // Make a temporary stream, write the opaque endpoint data into the stream,
+            // and ask the factory to read the endpoint data from that stream to create
+            // the actual endpoint.
+            //
+            OutputStream bs;
+            bs.write(ue->type());
+            ue->streamWrite(&bs);
+            InputStream is{_instance.get(), bs.getEncoding(), bs, false};
+            short type;
+            is.read(type);
+            is.startEncapsulation();
+            EndpointIPtr e = factory->read(&is);
+            is.endEncapsulation();
+            return e;
+        }
+        return ue; // Endpoint is opaque, but we don't have a factory for its type.
+    }
+
+    return nullptr;
+}
+
+EndpointIPtr
+IceInternal::EndpointFactoryManager::read(InputStream* s) const
+{
+    int16_t type;
+    s->read(type);
+
+    EndpointFactoryPtr factory = get(type);
+    EndpointIPtr e;
+
+    s->startEncapsulation();
+
+    if (factory)
+    {
+        e = factory->read(s);
+    }
+    //
+    // If the factory failed to read the endpoint, return an opaque endpoint. This can
+    // occur if for example the factory delegates to another factory and this factory
+    // isn't available. In this case, the factory needs to make sure the stream position
+    // is preserved for reading the opaque endpoint.
+    //
+    if (!e)
+    {
+        e = make_shared<OpaqueEndpointI>(type, s);
+    }
+
+    s->endEncapsulation();
+
+    return e;
+}

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

@@ -0,0 +1,42 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_ENDPOINT_FACTORY_MANAGER_H
+#define ICE_ENDPOINT_FACTORY_MANAGER_H
+
+#include "EndpointFactoryF.h"
+#include "EndpointFactoryManagerF.h"
+#include "EndpointIF.h"
+#include "Ice/Config.h"
+#include "Ice/InstanceF.h"
+
+#include <mutex>
+#include <string_view>
+#include <vector>
+
+namespace Ice
+{
+    class InputStream;
+}
+
+namespace IceInternal
+{
+    class EndpointFactoryManager
+    {
+    public:
+        EndpointFactoryManager(InstancePtr);
+        void initialize() const;
+        void add(const EndpointFactoryPtr&);
+        [[nodiscard]] EndpointFactoryPtr get(std::int16_t) const;
+        [[nodiscard]] EndpointIPtr create(std::string_view, bool) const;
+        EndpointIPtr read(Ice::InputStream*) const;
+
+    private:
+        friend class Instance;
+
+        const InstancePtr _instance;
+        std::vector<EndpointFactoryPtr> _factories;
+        mutable std::mutex _mutex;
+    };
+}
+
+#endif

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

@@ -0,0 +1,14 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_ENDPOINT_FACTORY_MANAGER_F_H
+#define ICE_ENDPOINT_FACTORY_MANAGER_F_H
+
+#include <memory>
+
+namespace IceInternal
+{
+    class EndpointFactoryManager;
+    using EndpointFactoryManagerPtr = std::shared_ptr<EndpointFactoryManager>;
+}
+
+#endif

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

@@ -0,0 +1,128 @@
+// Copyright (c) ZeroC, Inc.
+
+#include "EndpointI.h"
+#include "Ice/LocalExceptions.h"
+#include "Ice/OutputStream.h"
+
+#include <set>
+#include <sstream>
+
+using namespace std;
+
+Ice::Endpoint::~Endpoint() = default; // Out of line to avoid weak vtable
+
+Ice::EndpointInfo::~EndpointInfo() = default; // Out of line to avoid weak vtable
+
+int16_t
+Ice::EndpointInfo::type() const noexcept
+{
+    return underlying ? underlying->type() : -1;
+}
+
+bool
+Ice::EndpointInfo::datagram() const noexcept
+{
+    return underlying ? underlying->datagram() : false;
+}
+
+bool
+Ice::EndpointInfo::secure() const noexcept
+{
+    return underlying ? underlying->secure() : false;
+}
+
+Ice::IPEndpointInfo::~IPEndpointInfo() = default;
+Ice::TCPEndpointInfo::~TCPEndpointInfo() = default;
+Ice::UDPEndpointInfo::~UDPEndpointInfo() = default;
+Ice::WSEndpointInfo::~WSEndpointInfo() = default;
+Ice::IAPEndpointInfo::~IAPEndpointInfo() = default;
+Ice::OpaqueEndpointInfo::~OpaqueEndpointInfo() = default;
+
+void
+IceInternal::EndpointI::streamWrite(Ice::OutputStream* s) const
+{
+    s->startEncapsulation();
+    streamWriteImpl(s);
+    s->endEncapsulation();
+}
+
+string
+IceInternal::EndpointI::toString() const noexcept
+{
+    //
+    // WARNING: Certain features, such as proxy validation in Glacier2,
+    // depend on the format of proxy strings. Changes to toString() and
+    // methods called to generate parts of the reference string could break
+    // these features. Please review for all features that depend on the
+    // format of proxyToString() before changing this and related code.
+    //
+    return protocol() + options();
+}
+
+void
+IceInternal::EndpointI::initWithOptions(vector<string>& args)
+{
+    vector<string> unknown;
+
+    ostringstream ostr;
+    ostr << "'" << protocol() << " "; // protocol means transport here
+    for (const auto& arg : args)
+    {
+        if (arg.find_first_of(" \t\n\r") != string::npos)
+        {
+            ostr << " \"" << arg << "\"";
+        }
+        else
+        {
+            ostr << " " << arg;
+        }
+    }
+    ostr << "'";
+    const string str = ostr.str();
+
+    set<string> knownOptions;
+
+    for (vector<string>::size_type n = 0; n < args.size(); ++n)
+    {
+        const string& option = args[n];
+        if (option.length() < 2 || option[0] != '-')
+        {
+            unknown.push_back(option);
+            continue;
+        }
+
+        string argument;
+        if (n + 1 < args.size() && args[n + 1][0] != '-')
+        {
+            argument = args[++n];
+        }
+
+        if (checkOption(option, argument, str))
+        {
+            if (!knownOptions.insert(option).second)
+            {
+                throw Ice::ParseException{__FILE__, __LINE__, "duplicate option '" + option + "' in endpoint " + str};
+            }
+        }
+        else
+        {
+            unknown.push_back(option);
+            if (!argument.empty())
+            {
+                unknown.push_back(argument);
+            }
+        }
+    }
+
+    //
+    // Replace argument vector with only those we didn't recognize.
+    //
+    args = unknown;
+}
+
+bool
+IceInternal::EndpointI::checkOption(const string&, const string&, const string&)
+{
+    // Must be overridden to check for options.
+    return false;
+}

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

@@ -0,0 +1,150 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_ENDPOINT_I_H
+#define ICE_ENDPOINT_I_H
+
+#include "AcceptorF.h"
+#include "ConnectorF.h"
+#include "EndpointIF.h"
+#include "Ice/Endpoint.h"
+#include "Ice/EndpointSelectionType.h"
+#include "Ice/SSL/ServerAuthenticationOptions.h"
+#include "TransceiverF.h"
+
+#include <optional>
+
+namespace Ice
+{
+    class OutputStream;
+    class InputStream;
+}
+
+namespace IceInternal
+{
+    class ICE_API EndpointI : public Ice::Endpoint
+    {
+    public:
+        //
+        // Marshal the endpoint.
+        //
+        virtual void streamWrite(Ice::OutputStream*) const;
+        virtual void streamWriteImpl(Ice::OutputStream*) const = 0;
+
+        //
+        // Return the endpoint type.
+        //
+        [[nodiscard]] virtual std::int16_t type() const = 0;
+
+        //
+        // Return the protocol name
+        //
+        [[nodiscard]] virtual const std::string& protocol() const = 0;
+
+        //
+        // Return the timeout for the endpoint in milliseconds. 0 means
+        // non-blocking, -1 means no timeout.
+        //
+        [[nodiscard]] virtual std::int32_t timeout() const = 0;
+
+        //
+        // Return a new endpoint with a different timeout value, provided
+        // that timeouts are supported by the endpoint. Otherwise the same
+        // endpoint is returned.
+        //
+        [[nodiscard]] virtual EndpointIPtr timeout(std::int32_t) const = 0;
+
+        //
+        // Returns the endpoint connection id.
+        //
+        [[nodiscard]] virtual const std::string& connectionId() const = 0;
+
+        //
+        // Return a new endpoint with a different connection id.
+        //
+        [[nodiscard]] virtual EndpointIPtr connectionId(const std::string&) const = 0;
+
+        //
+        // Return true if the endpoints support bzip2 compress, or false
+        // otherwise.
+        //
+        [[nodiscard]] virtual bool compress() const = 0;
+
+        //
+        // Return a new endpoint with a different compression value,
+        // provided that compression is supported by the
+        // endpoint. Otherwise the same endpoint is returned.
+        //
+        [[nodiscard]] virtual EndpointIPtr compress(bool) const = 0;
+
+        //
+        // Return true if the endpoint is datagram-based.
+        //
+        [[nodiscard]] virtual bool datagram() const = 0;
+
+        //
+        // Return true if the endpoint is secure.
+        //
+        [[nodiscard]] virtual bool secure() const = 0;
+
+        //
+        // Return a server side transceiver for this endpoint, or null if a
+        // transceiver can only be created by an acceptor.
+        //
+        [[nodiscard]] virtual TransceiverPtr transceiver() const = 0;
+
+        //
+        // Return connectors for this endpoint, or empty vector if no
+        // connector is available.
+        //
+        virtual void connectorsAsync(
+            std::function<void(std::vector<ConnectorPtr>)>,
+            std::function<void(std::exception_ptr)>) const = 0;
+
+        //
+        // Return an acceptor for this endpoint, or null if no acceptors
+        // is available.
+        //
+        [[nodiscard]] virtual AcceptorPtr
+        acceptor(const std::string&, const std::optional<Ice::SSL::ServerAuthenticationOptions>&) const = 0;
+
+        // Expand endpoint into separate endpoints for each IP address returned by the DNS resolver.
+        // Used only for server endpoints.
+        [[nodiscard]] virtual std::vector<EndpointIPtr> expandHost() const = 0;
+
+        // Returns true when the most underlying endpoint is an IP endpoint with a loopback or multicast address.
+        [[nodiscard]] virtual bool isLoopbackOrMulticast() const = 0;
+
+        // Returns a new endpoint with the specified host (if not empty) and all local options cleared. May return
+        // shared_from_this().
+        [[nodiscard]] virtual std::shared_ptr<EndpointI> toPublishedEndpoint(std::string publishedHost) const = 0;
+
+        //
+        // Check whether the endpoint is equivalent to another one.
+        //
+        [[nodiscard]] virtual bool equivalent(const EndpointIPtr&) const = 0;
+
+        [[nodiscard]] virtual std::size_t hash() const noexcept = 0;
+
+        //
+        // Returns the stringified options
+        //
+        [[nodiscard]] virtual std::string options() const = 0;
+
+        [[nodiscard]] std::string toString() const noexcept override;
+        void initWithOptions(std::vector<std::string>&);
+
+    protected:
+        virtual bool checkOption(const std::string&, const std::string&, const std::string&);
+    };
+}
+
+namespace std
+{
+    /// Specialization of std::hash for EndpointI.
+    template<> struct hash<IceInternal::EndpointI>
+    {
+        std::size_t operator()(const IceInternal::EndpointI& endpoint) const noexcept { return endpoint.hash(); }
+    };
+}
+
+#endif

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

@@ -0,0 +1,21 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_ENDPOINT_I_F_H
+#define ICE_ENDPOINT_I_F_H
+
+#include <memory>
+
+namespace IceInternal
+{
+    class EndpointI;
+    class TcpEndpointI;
+    class UdpEndpointI;
+    class WSEndpoint;
+
+    using EndpointIPtr = std::shared_ptr<EndpointI>;
+    using TcpEndpointIPtr = std::shared_ptr<TcpEndpointI>;
+    using UdpEndpointIPtr = std::shared_ptr<UdpEndpointI>;
+    using WSEndpointPtr = std::shared_ptr<WSEndpoint>;
+}
+
+#endif

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

@@ -0,0 +1,9 @@
+// Copyright (c) ZeroC, Inc.
+
+#include "EventHandler.h"
+
+using namespace std;
+using namespace Ice;
+using namespace IceInternal;
+
+IceInternal::EventHandler::~EventHandler() = default;

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

@@ -0,0 +1,71 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_EVENT_HANDLER_H
+#define ICE_EVENT_HANDLER_H
+
+#include "EventHandlerF.h"
+#include "Ice/InstanceF.h"
+#include "Network.h"
+#include "ThreadPoolF.h"
+
+#include <memory>
+
+namespace IceInternal
+{
+    class ThreadPoolCurrent;
+
+    class EventHandler : public std::enable_shared_from_this<EventHandler>
+    {
+    public:
+#if defined(ICE_USE_IOCP)
+        //
+        // Called to start a new asynchronous read or write operation.
+        //
+        virtual bool startAsync(SocketOperation) = 0;
+        virtual bool finishAsync(SocketOperation) = 0;
+#endif
+
+        //
+        // Called when there's a message ready to be processed.
+        //
+        virtual void message(ThreadPoolCurrent&) = 0;
+
+        //
+        // Called when the event handler is unregistered.
+        //
+        virtual void finished(ThreadPoolCurrent&, bool) = 0;
+
+        //
+        // Get a textual representation of the event handler.
+        //
+        [[nodiscard]] virtual std::string toString() const = 0;
+
+        //
+        // Get the native information of the handler, this is used by the selector.
+        //
+        virtual NativeInfoPtr getNativeInfo() = 0;
+
+    protected:
+        virtual ~EventHandler();
+
+#if defined(ICE_USE_IOCP)
+        SocketOperation _pending{SocketOperationNone};
+        SocketOperation _started{SocketOperationNone};
+        SocketOperation _completed{SocketOperationNone};
+        bool _finish{false};
+#else
+        SocketOperation _disabled{SocketOperationNone};
+#endif
+        SocketOperation _ready{SocketOperationNone};
+        SocketOperation _registered{SocketOperationNone};
+
+        friend class ThreadPool;
+        friend class ThreadPoolCurrent;
+        friend class Selector;
+#ifdef ICE_USE_CFSTREAM
+        friend class EventHandlerWrapper;
+#endif
+    };
+}
+
+#endif

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

@@ -0,0 +1,14 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_EVENT_HANDLER_F_H
+#define ICE_EVENT_HANDLER_F_H
+
+#include <memory>
+
+namespace IceInternal
+{
+    class EventHandler;
+    using EventHandlerPtr = std::shared_ptr<EventHandler>;
+}
+
+#endif

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

@@ -0,0 +1,5 @@
+// Copyright (c) ZeroC, Inc.
+
+#include "Ice/Exception.h"
+
+Ice::Exception::~Exception() = default; // avoid weak vtable