zeroc-ice 3.7.9.1 → 3.8.0

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

@@ -0,0 +1,103 @@
+// Copyright (c) ZeroC, Inc.
+
+#include "PropertyUtil.h"
+#include "Ice/LocalExceptions.h"
+#include "Ice/Properties.h"
+#include "Ice/StringUtil.h"
+
+#include <sstream>
+
+using namespace std;
+using namespace Ice;
+using namespace IceInternal;
+
+optional<Property>
+IceInternal::findProperty(string_view key, const PropertyArray* propertyArray)
+{
+    assert(propertyArray);
+    assert(propertyArray->properties != nullptr || propertyArray->length == 0);
+
+    for (int i = 0; i < propertyArray->length; ++i)
+    {
+        auto prop = propertyArray->properties[i];
+
+        // If the key is an exact match, return the property unless it has a property class which is prefix only.
+        // If the key is a regex match, return the property. A property cannot have a property class and use regex.
+        if (key == prop.pattern)
+        {
+            if (prop.propertyArray && prop.propertyArray->prefixOnly)
+            {
+                return nullopt;
+            }
+            return prop;
+        }
+        else if (prop.usesRegex && match(string{key}, prop.pattern))
+        {
+            return prop;
+        }
+
+        // If the property has a property class, check if the key is a prefix of the property.
+        if (prop.propertyArray)
+        {
+            auto pattern = string{prop.pattern};
+            // Check if the key is a prefix of the property.
+            // The key must be:
+            // - shorter than the property pattern
+            // - the property pattern must start with the key
+            // - the pattern character after the key must be a dot
+            if (key.length() > pattern.length() && key.find(pattern) == 0 && key[pattern.length()] == '.')
+            {
+                // Plus one to skip the dot.
+                string_view substring = key.substr(pattern.length() + 1);
+                // Check if the suffix is a valid property. If so, return it. If it's not, continue searching
+                // the current property array.
+                if (auto subProp = findProperty(substring, prop.propertyArray))
+                {
+                    return subProp;
+                }
+            }
+        }
+    }
+
+    return nullopt;
+}
+
+void
+IceInternal::validatePropertiesWithPrefix(
+    string_view prefix,
+    const PropertiesPtr& properties,
+    const PropertyArray* propertyArray)
+{
+    // Do not check for unknown properties if Ice prefix, ie Ice, Glacier2, etc
+    for (const auto& props : PropertyNames::validProps)
+    {
+        string icePrefix = string(props.name) + ".";
+        if (prefix.find(icePrefix) == 0)
+        {
+            return;
+        }
+    }
+
+    vector<string> unknownProps;
+    PropertyDict props = properties->getPropertiesForPrefix(string{prefix} + ".");
+    for (const auto& p : props)
+    {
+        // Plus one to include the dot.
+        if (!findProperty(p.first.substr(prefix.size() + 1), propertyArray))
+        {
+            unknownProps.push_back(p.first);
+        }
+    }
+
+    if (!unknownProps.empty())
+    {
+        ostringstream os;
+        os << "found unknown properties for " << propertyArray->name << ": '" << prefix << "'";
+        for (const auto& prop : unknownProps)
+        {
+            os << "\n    " << prop;
+        }
+
+        throw PropertyException{__FILE__, __LINE__, os.str()};
+    }
+}

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

@@ -0,0 +1,31 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_PROPERTY_UTIL_H
+#define ICE_PROPERTY_UTIL_H
+
+#include "Ice/PropertiesF.h"
+#include "Ice/PropertyDict.h"
+#include "PropertyNames.h"
+
+#include <optional>
+
+namespace IceInternal
+{
+    /// Searches a property array for a property with the given key.
+    /// @param key The key to search for.
+    /// @param propertyArray The property array to search.
+    /// @return The property if found, nullopt otherwise.
+    std::optional<Property> findProperty(std::string_view key, const PropertyArray* propertyArray);
+
+    /// Validates the properties for a given prefix.
+    /// @param prefix The prefix to validate.
+    /// @param properties The properties to consider.
+    /// @param propertyArray The property array to search against.
+    /// @throws PropertyException Thrown when an unknown property is found.
+    void validatePropertiesWithPrefix(
+        std::string_view prefix,
+        const Ice::PropertiesPtr& properties,
+        const PropertyArray* propertyArray);
+}
+
+#endif

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

@@ -0,0 +1,159 @@
+// Copyright (c) ZeroC, Inc.
+
+#include "Protocol.h"
+#include "Ice/LocalExceptions.h"
+
+#include <sstream>
+
+using namespace std;
+using namespace Ice;
+
+namespace
+{
+    template<typename T> std::string versionToString(const T& v)
+    {
+        std::ostringstream os;
+        os << v;
+        return os.str();
+    }
+
+    template<typename T> T stringToVersion(std::string_view str)
+    {
+        T v;
+        IceInternal::stringToMajorMinor(str, v.major, v.minor);
+        return v;
+    }
+}
+
+string
+IceInternal::protocolVersionToString(const ProtocolVersion& v)
+{
+    return versionToString<ProtocolVersion>(v);
+}
+
+ProtocolVersion
+IceInternal::stringToProtocolVersion(string_view v)
+{
+    return stringToVersion<ProtocolVersion>(v);
+}
+
+string
+IceInternal::encodingVersionToString(const EncodingVersion& v)
+{
+    return versionToString<EncodingVersion>(v);
+}
+
+EncodingVersion
+IceInternal::stringToEncodingVersion(string_view v)
+{
+    return stringToVersion<EncodingVersion>(v);
+}
+
+ostream&
+Ice::operator<<(ostream& out, const ProtocolVersion& version)
+{
+    return out << static_cast<int>(version.major) << "." << static_cast<int>(version.minor);
+}
+
+ostream&
+Ice::operator<<(ostream& out, const EncodingVersion& version)
+{
+    return out << static_cast<int>(version.major) << "." << static_cast<int>(version.minor);
+}
+
+void
+IceInternal::stringToMajorMinor(string_view s, uint8_t& major, uint8_t& minor)
+{
+    string str{s};
+    std::string::size_type pos = str.find_first_of('.');
+    if (pos == std::string::npos)
+    {
+        throw ParseException(__FILE__, __LINE__, "malformed Ice version value '" + str + "'");
+    }
+
+    std::istringstream majStr(str.substr(0, pos));
+    int32_t majVersion;
+    if (!(majStr >> majVersion) || !majStr.eof())
+    {
+        throw ParseException(__FILE__, __LINE__, "invalid major Ice version value '" + str + "'");
+    }
+
+    std::istringstream minStr(str.substr(pos + 1, std::string::npos));
+    int32_t minVersion;
+    if (!(minStr >> minVersion) || !minStr.eof())
+    {
+        throw ParseException(__FILE__, __LINE__, "invalid minor Ice version value '" + str + "'");
+    }
+
+    if (majVersion < 1 || majVersion > 255 || minVersion < 0 || minVersion > 255)
+    {
+        throw ParseException(__FILE__, __LINE__, "range error in version '" + str + "'");
+    }
+
+    major = static_cast<uint8_t>(majVersion);
+    minor = static_cast<uint8_t>(minVersion);
+}
+
+namespace IceInternal
+{
+    const byte magic[] = {byte{0x49}, byte{0x63}, byte{0x65}, byte{0x50}}; // 'I', 'c', 'e', 'P'
+
+    const byte requestHdr[] = {
+        magic[0],
+        magic[1],
+        magic[2],
+        magic[3],
+        byte{currentProtocol.major},
+        byte{currentProtocol.minor},
+        byte{currentProtocolEncoding.major},
+        byte{currentProtocolEncoding.minor},
+        byte{requestMsg},
+        byte{0}, // Compression status
+        byte{0},
+        byte{0},
+        byte{0},
+        byte{0}, // Message size (placeholder)
+        byte{0},
+        byte{0},
+        byte{0},
+        byte{0} // Request id (placeholder)
+    };
+
+    const byte requestBatchHdr[] = {
+        magic[0],
+        magic[1],
+        magic[2],
+        magic[3],
+        byte{currentProtocol.major},
+        byte{currentProtocol.minor},
+        byte{currentProtocolEncoding.major},
+        byte{currentProtocolEncoding.minor},
+        byte{requestBatchMsg},
+        byte{0}, // Compression status
+        byte{0},
+        byte{0},
+        byte{0},
+        byte{0}, // Message size (place holder)
+        byte{0},
+        byte{0},
+        byte{0},
+        byte{0} // Number of requests in batch (placeholder)
+    };
+
+    const byte replyHdr[] = {
+        magic[0],
+        magic[1],
+        magic[2],
+        magic[3],
+        byte{currentProtocol.major},
+        byte{currentProtocol.minor},
+        byte{currentProtocolEncoding.major},
+        byte{currentProtocolEncoding.minor},
+        byte{replyMsg},
+        byte{0}, // Compression status
+        byte{0},
+        byte{0},
+        byte{0},
+        byte{0} // Message size (placeholder)
+    };
+}

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

@@ -0,0 +1,116 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_PROTOCOL_H
+#define ICE_PROTOCOL_H
+
+#include "Ice/LocalExceptions.h"
+#include "Ice/Version.h"
+
+namespace IceInternal
+{
+    /// Identifies protocol version 1.0.
+    constexpr Ice::ProtocolVersion Protocol_1_0{1, 0};
+
+    /// Converts a protocol version into a string.
+    /// @param v The protocol version.
+    /// @return A string representing the protocol version.
+    std::string protocolVersionToString(const Ice::ProtocolVersion& v);
+
+    /// Converts a string into a protocol version.
+    /// @param v The string containing a stringified protocol version.
+    /// @return The protocol version.
+    /// @throws ParseException If the given string is not in the X.Y format.
+    Ice::ProtocolVersion stringToProtocolVersion(std::string_view v);
+
+    /// Converts an encoding version into a string.
+    /// @param v The encoding version.
+    /// @return A string representing the encoding version.
+    std::string encodingVersionToString(const Ice::EncodingVersion& v);
+
+    /// Converts a string into an encoding version.
+    /// @param v The string containing a stringified encoding version.
+    /// @return The encoding version.
+    /// @throws ParseException If the given string is not in the X.Y format.
+    Ice::EncodingVersion stringToEncodingVersion(std::string_view v);
+
+    void stringToMajorMinor(std::string_view, std::uint8_t&, std::uint8_t&);
+
+    /// Identifies the latest protocol version.
+    constexpr Ice::ProtocolVersion currentProtocol{Protocol_1_0};
+
+    /// Identifies the latest protocol encoding version.
+    constexpr Ice::EncodingVersion currentProtocolEncoding{Ice::Encoding_1_0};
+
+    //
+    // Size of the Ice protocol header
+    //
+    // Magic number (4 Bytes)
+    // Protocol version major (std::uint8_t)
+    // Protocol version minor (std::uint8_t)
+    // Encoding version major (std::uint8_t)
+    // Encoding version minor (std::uint8_t)
+    // Message type (std::uint8_t)
+    // Compression status (std::uint8_t)
+    // Message size (std::int32_t)
+    //
+    const std::int32_t headerSize = 14;
+
+    //
+    // The magic number at the front of each message
+    //
+    extern const std::byte magic[4];
+
+    //
+    // The Ice protocol message types
+    //
+    const std::uint8_t requestMsg = 0;
+    const std::uint8_t requestBatchMsg = 1;
+    const std::uint8_t replyMsg = 2;
+    const std::uint8_t validateConnectionMsg = 3;
+    const std::uint8_t closeConnectionMsg = 4;
+
+    //
+    // The request header, batch request header and reply header.
+    //
+    extern const std::byte requestHdr[headerSize + sizeof(std::int32_t)];
+    extern const std::byte requestBatchHdr[headerSize + sizeof(std::int32_t)];
+    extern const std::byte replyHdr[headerSize];
+
+    //
+    // IPv4/IPv6 support enumeration.
+    //
+    enum ProtocolSupport
+    {
+        EnableIPv4,
+        EnableIPv6,
+        EnableBoth
+    };
+
+    template<typename T> bool isSupported(const T& version, const T& supported)
+    {
+        return version.major == supported.major && version.minor <= supported.minor;
+    }
+
+    const std::uint8_t OPTIONAL_END_MARKER = 0xFF;
+
+    const std::uint8_t FLAG_HAS_TYPE_ID_STRING = (1 << 0);
+    const std::uint8_t FLAG_HAS_TYPE_ID_INDEX = (1 << 1);
+    const std::uint8_t FLAG_HAS_TYPE_ID_COMPACT = (1 << 0) | (1 << 1);
+    const std::uint8_t FLAG_HAS_OPTIONAL_MEMBERS = (1 << 2);
+    const std::uint8_t FLAG_HAS_INDIRECTION_TABLE = (1 << 3);
+    const std::uint8_t FLAG_HAS_SLICE_SIZE = (1 << 4);
+    const std::uint8_t FLAG_IS_LAST_SLICE = (1 << 5);
+
+    inline void checkSupportedEncoding(const Ice::EncodingVersion& v)
+    {
+        if (!isSupported(v, Ice::Encoding_1_1))
+        {
+            throw Ice::MarshalException{
+                __FILE__,
+                __LINE__,
+                "this Ice runtime does not support encoding version " + encodingVersionToString(v)};
+        }
+    }
+}
+
+#endif

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

@@ -0,0 +1,186 @@
+// Copyright (c) ZeroC, Inc.
+
+#include "ProtocolInstance.h"
+#include "DefaultsAndOverrides.h"
+#include "EndpointFactoryManager.h"
+#include "IPEndpointI.h"
+#include "Ice/Initialize.h"
+#include "Instance.h"
+#include "TraceLevels.h"
+
+using namespace std;
+using namespace Ice;
+using namespace IceInternal;
+
+// Out of line to avoid weak vtable
+IceInternal::ProtocolInstance::~ProtocolInstance() = default;
+
+IceInternal::ProtocolInstance::ProtocolInstance(const CommunicatorPtr& com, int16_t type, string protocol, bool secure)
+    : _instance(getInstance(com)),
+      _traceLevel(_instance.lock()->traceLevels()->network),
+      _traceCategory(_instance.lock()->traceLevels()->networkCat),
+      _properties(_instance.lock()->initializationData().properties),
+      _protocol(std::move(protocol)),
+      _type(type),
+      _secure(secure)
+{
+}
+
+IceInternal::ProtocolInstance::ProtocolInstance(const InstancePtr& instance, int16_t type, string protocol, bool secure)
+    : _instance(instance),
+      _traceLevel(instance->traceLevels()->network),
+      _traceCategory(instance->traceLevels()->networkCat),
+      _properties(instance->initializationData().properties),
+      _protocol(std::move(protocol)),
+      _type(type),
+      _secure(secure)
+{
+}
+
+const LoggerPtr&
+IceInternal::ProtocolInstance::logger() const
+{
+    InstancePtr instance = _instance.lock();
+    if (!instance)
+    {
+        throw CommunicatorDestroyedException{__FILE__, __LINE__};
+    }
+    return instance->initializationData().logger;
+}
+
+EndpointFactoryPtr
+IceInternal::ProtocolInstance::getEndpointFactory(int16_t type) const
+{
+    InstancePtr instance = _instance.lock();
+    if (!instance)
+    {
+        throw CommunicatorDestroyedException{__FILE__, __LINE__};
+    }
+    return instance->endpointFactoryManager()->get(type);
+}
+
+BufSizeWarnInfo
+IceInternal::ProtocolInstance::getBufSizeWarn(int16_t type)
+{
+    InstancePtr instance = _instance.lock();
+    if (!instance)
+    {
+        throw CommunicatorDestroyedException{__FILE__, __LINE__};
+    }
+    return instance->getBufSizeWarn(type);
+}
+
+void
+IceInternal::ProtocolInstance::setSndBufSizeWarn(int16_t type, int size)
+{
+    InstancePtr instance = _instance.lock();
+    if (!instance)
+    {
+        throw CommunicatorDestroyedException{__FILE__, __LINE__};
+    }
+    instance->setSndBufSizeWarn(type, size);
+}
+
+void
+IceInternal::ProtocolInstance::setRcvBufSizeWarn(int16_t type, int size)
+{
+    InstancePtr instance = _instance.lock();
+    if (!instance)
+    {
+        throw CommunicatorDestroyedException{__FILE__, __LINE__};
+    }
+    instance->setRcvBufSizeWarn(type, size);
+}
+
+bool
+IceInternal::ProtocolInstance::preferIPv6() const
+{
+    InstancePtr instance = _instance.lock();
+    if (!instance)
+    {
+        throw CommunicatorDestroyedException{__FILE__, __LINE__};
+    }
+    return instance->preferIPv6();
+}
+
+ProtocolSupport
+IceInternal::ProtocolInstance::protocolSupport() const
+{
+    InstancePtr instance = _instance.lock();
+    if (!instance)
+    {
+        throw CommunicatorDestroyedException{__FILE__, __LINE__};
+    }
+    return instance->protocolSupport();
+}
+
+const string&
+IceInternal::ProtocolInstance::defaultHost() const
+{
+    InstancePtr instance = _instance.lock();
+    if (!instance)
+    {
+        throw CommunicatorDestroyedException{__FILE__, __LINE__};
+    }
+    return instance->defaultsAndOverrides()->defaultHost;
+}
+
+const Address&
+IceInternal::ProtocolInstance::defaultSourceAddress() const
+{
+    InstancePtr instance = _instance.lock();
+    if (!instance)
+    {
+        throw CommunicatorDestroyedException{__FILE__, __LINE__};
+    }
+    return instance->defaultsAndOverrides()->defaultSourceAddress;
+}
+
+const EncodingVersion&
+IceInternal::ProtocolInstance::defaultEncoding() const
+{
+    InstancePtr instance = _instance.lock();
+    if (!instance)
+    {
+        throw CommunicatorDestroyedException{__FILE__, __LINE__};
+    }
+    return instance->defaultsAndOverrides()->defaultEncoding;
+}
+
+NetworkProxyPtr
+IceInternal::ProtocolInstance::networkProxy() const
+{
+    InstancePtr instance = _instance.lock();
+    if (!instance)
+    {
+        throw CommunicatorDestroyedException{__FILE__, __LINE__};
+    }
+    return instance->networkProxy();
+}
+
+int32_t
+IceInternal::ProtocolInstance::messageSizeMax() const
+{
+    InstancePtr instance = _instance.lock();
+    if (!instance)
+    {
+        throw CommunicatorDestroyedException{__FILE__, __LINE__};
+    }
+    return instance->messageSizeMax();
+}
+
+void
+IceInternal::ProtocolInstance::resolve(
+    const string& host,
+    int port,
+    const IPEndpointIPtr& endpoint,
+    std::function<void(std::vector<ConnectorPtr>)> response,
+    std::function<void(exception_ptr)> exception) const
+{
+    InstancePtr instance = _instance.lock();
+    if (!instance)
+    {
+        throw CommunicatorDestroyedException{__FILE__, __LINE__};
+    }
+    instance->endpointHostResolver()->resolve(host, port, endpoint, std::move(response), std::move(exception));
+}

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

@@ -0,0 +1,74 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_PROTOCOL_INSTANCE_H
+#define ICE_PROTOCOL_INSTANCE_H
+
+#include "ConnectorF.h"
+#include "EndpointFactory.h"
+#include "EndpointIF.h"
+#include "IPEndpointIF.h"
+#include "Ice/CommunicatorF.h"
+#include "Ice/Logger.h"
+#include "Ice/PropertiesF.h"
+#include "Instance.h"
+#include "NetworkF.h"
+#include "ProtocolInstanceF.h"
+
+namespace IceInternal
+{
+    class ICE_API ProtocolInstance
+    {
+    public:
+        virtual ~ProtocolInstance();
+
+        ProtocolInstance(const Ice::CommunicatorPtr&, std::int16_t, std::string, bool);
+
+        [[nodiscard]] int traceLevel() const { return _traceLevel; }
+
+        [[nodiscard]] const std::string& traceCategory() const { return _traceCategory; }
+
+        [[nodiscard]] const Ice::LoggerPtr& logger() const;
+
+        [[nodiscard]] const std::string& protocol() const { return _protocol; }
+
+        [[nodiscard]] std::int16_t type() const { return _type; }
+
+        [[nodiscard]] const Ice::PropertiesPtr& properties() const { return _properties; }
+
+        [[nodiscard]] bool secure() const { return _secure; }
+
+        [[nodiscard]] IceInternal::EndpointFactoryPtr getEndpointFactory(std::int16_t) const;
+        BufSizeWarnInfo getBufSizeWarn(std::int16_t type);
+        void setSndBufSizeWarn(std::int16_t type, int size);
+        void setRcvBufSizeWarn(std::int16_t type, int size);
+        [[nodiscard]] bool preferIPv6() const;
+        [[nodiscard]] ProtocolSupport protocolSupport() const;
+        [[nodiscard]] const std::string& defaultHost() const;
+        [[nodiscard]] const Address& defaultSourceAddress() const;
+        [[nodiscard]] const Ice::EncodingVersion& defaultEncoding() const;
+        [[nodiscard]] NetworkProxyPtr networkProxy() const;
+        [[nodiscard]] std::int32_t messageSizeMax() const;
+
+        void resolve(
+            const std::string&,
+            int,
+            const IPEndpointIPtr&,
+            std::function<void(std::vector<ConnectorPtr>)>,
+            std::function<void(std::exception_ptr)>) const;
+
+    protected:
+        ProtocolInstance(const InstancePtr&, std::int16_t, std::string, bool);
+        friend class Instance;
+        // Use a weak pointer to avoid circular references. The communicator owns the endpoint factory, which in
+        // turn own this protocol instance.
+        const std::weak_ptr<Instance> _instance;
+        const int _traceLevel;
+        const std::string _traceCategory;
+        const Ice::PropertiesPtr _properties;
+        const std::string _protocol;
+        const std::int16_t _type;
+        const bool _secure;
+    };
+}
+
+#endif

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

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