zeroc-ice 3.7.11 → 3.8.1

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

@@ -1,78 +1,63 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-// Generated by makeprops.py from file ../config/PropertyNames.xml, Thu Jan 22 11:21:15 2026
+// Copyright (c) ZeroC, Inc.
+
+// Generated by makeprops.py from PropertyNames.xml
 
 // IMPORTANT: Do not edit this file -- any edits made here will be lost!
 
-#ifndef ICE_INTERNAL_PropertyNames_H
-#define ICE_INTERNAL_PropertyNames_H
+#ifndef ICE_INTERNAL_PROPERTY_NAMES_H
+#define ICE_INTERNAL_PROPERTY_NAMES_H
 
-#include <Ice/Config.h>
+#include <array>
 
 namespace IceInternal
 {
-
-struct Property
-{
-    const char* pattern;
-    bool deprecated;
-    const char* deprecatedBy;
-
-    Property(const char* n, bool d, const char* b) :
-        pattern(n),
-        deprecated(d),
-        deprecatedBy(b)
+    struct PropertyArray;
+    struct Property
     {
-    }
-
-    Property() :
-        pattern(0),
-        deprecated(false),
-        deprecatedBy(0)
-    {
-    }
-
-};
+        const char* pattern;
+        const char* defaultValue;
+        const bool usesRegex;
+        const bool deprecated;
+        const PropertyArray* propertyArray;
 
-struct PropertyArray
-{
-    const Property* properties;
-    const int length;
+    };
 
-    PropertyArray(const Property* p, size_t len) :
-        properties(p),
-        length(static_cast<int>(len))
+    struct PropertyArray
     {
-    }
-};
-
-class PropertyNames
-{
-public:
-
-    static const PropertyArray IceProps;
-    static const PropertyArray IceMXProps;
-    static const PropertyArray IceDiscoveryProps;
-    static const PropertyArray IceLocatorDiscoveryProps;
-    static const PropertyArray IceBoxProps;
-    static const PropertyArray IceBoxAdminProps;
-    static const PropertyArray IceBridgeProps;
-    static const PropertyArray IceGridAdminProps;
-    static const PropertyArray IceGridProps;
-    static const PropertyArray IcePatch2Props;
-    static const PropertyArray IcePatch2ClientProps;
-    static const PropertyArray IceSSLProps;
-    static const PropertyArray IceStormAdminProps;
-    static const PropertyArray IceBTProps;
-    static const PropertyArray Glacier2Props;
-    static const PropertyArray Glacier2CryptPermissionsVerifierProps;
-    static const PropertyArray FreezeProps;
-
-    static const PropertyArray validProps[];
-    static const char * clPropNames[];
-};
-
+        const char* name;
+        const bool prefixOnly;
+        const bool isOptIn;
+        const Property* properties;
+        const int length;
+    };
+
+    class PropertyNames
+    {
+    public:
+        static const PropertyArray ProxyProps;
+        static const PropertyArray ConnectionProps;
+        static const PropertyArray ThreadPoolProps;
+        static const PropertyArray ObjectAdapterProps;
+        static const PropertyArray IceProps;
+        static const PropertyArray IceMXProps;
+        static const PropertyArray IceDiscoveryProps;
+        static const PropertyArray IceLocatorDiscoveryProps;
+        static const PropertyArray IceBoxProps;
+        static const PropertyArray IceBoxAdminProps;
+        static const PropertyArray IceBridgeProps;
+        static const PropertyArray IceGridAdminProps;
+        static const PropertyArray IceGridProps;
+        static const PropertyArray IceGridGUIProps;
+        static const PropertyArray IceSSLProps;
+        static const PropertyArray IceStormProps;
+        static const PropertyArray IceStormAdminProps;
+        static const PropertyArray IceBTProps;
+        static const PropertyArray Glacier2Props;
+        static const PropertyArray DataStormProps;
+
+        /// Property arrays defined using sections in PropertyNames.xml.
+        static const std::array<PropertyArray, 16> validProps;
+    };
 }
 
 #endif

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

@@ -1,124 +1,159 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
-#include <Ice/Protocol.h>
-#include <Ice/LocalException.h>
+#include "Protocol.h"
+#include "Ice/LocalExceptions.h"
 
-namespace IceInternal
-{
+#include <sstream>
 
-const Ice::Byte magic[] = { 0x49, 0x63, 0x65, 0x50 };   // 'I', 'c', 'e', 'P'
+using namespace std;
+using namespace Ice;
 
-const Ice::Byte requestHdr[] =
-{
-    magic[0],
-    magic[1],
-    magic[2],
-    magic[3],
-    protocolMajor,
-    protocolMinor,
-    protocolEncodingMajor,
-    protocolEncodingMinor,
-    requestMsg,
-    0, // Compression status
-    0, 0, 0, 0, // Message size (placeholder)
-    0, 0, 0, 0 // Request id (placeholder)
-};
-
-const Ice::Byte requestBatchHdr[] =
+namespace
 {
-    magic[0],
-    magic[1],
-    magic[2],
-    magic[3],
-    protocolMajor,
-    protocolMinor,
-    protocolEncodingMajor,
-    protocolEncodingMinor,
-    requestBatchMsg,
-    0, // Compression status
-    0, 0, 0, 0, // Message size (place holder)
-    0, 0, 0, 0  // Number of requests in batch (placeholder)
-};
-
-const Ice::Byte replyHdr[] =
-{
-    magic[0],
-    magic[1],
-    magic[2],
-    magic[3],
-    protocolMajor,
-    protocolMinor,
-    protocolEncodingMajor,
-    protocolEncodingMinor,
-    replyMsg,
-    0, // Compression status
-    0, 0, 0, 0 // Message size (placeholder)
-};
-
-void
-stringToMajorMinor(const std::string& str, Ice::Byte& major, Ice::Byte& minor)
-{
-    std::string::size_type pos = str.find_first_of(".");
-    if(pos == std::string::npos)
+    template<typename T> std::string versionToString(const T& v)
     {
-        throw Ice::VersionParseException(__FILE__, __LINE__, "malformed version value `" + str + "'");
+        std::ostringstream os;
+        os << v;
+        return os.str();
     }
 
-    std::istringstream majStr(str.substr(0, pos));
-    Ice::Int majVersion;
-    if(!(majStr >> majVersion) || !majStr.eof())
+    template<typename T> T stringToVersion(std::string_view str)
     {
-        throw Ice::VersionParseException(__FILE__, __LINE__, "invalid major version value `" + str + "'");
+        T v;
+        IceInternal::stringToMajorMinor(str, v.major, v.minor);
+        return v;
     }
+}
 
-    std::istringstream minStr(str.substr(pos + 1, std::string::npos));
-    Ice::Int minVersion;
-    if(!(minStr >> minVersion) || !minStr.eof())
-    {
-        throw Ice::VersionParseException(__FILE__, __LINE__, "invalid minor version value `" + str + "'");
-    }
+string
+IceInternal::protocolVersionToString(const ProtocolVersion& v)
+{
+    return versionToString<ProtocolVersion>(v);
+}
 
-    if(majVersion < 1 || majVersion > 255 || minVersion < 0 || minVersion > 255)
-    {
-        throw Ice::VersionParseException(__FILE__, __LINE__, "range error in version `" + str + "'");
-    }
+ProtocolVersion
+IceInternal::stringToProtocolVersion(string_view v)
+{
+    return stringToVersion<ProtocolVersion>(v);
+}
 
-    major = static_cast<Ice::Byte>(majVersion);
-    minor = static_cast<Ice::Byte>(minVersion);
+string
+IceInternal::encodingVersionToString(const EncodingVersion& v)
+{
+    return versionToString<EncodingVersion>(v);
 }
 
-void
-throwUnsupportedProtocolException(const char* f, int l, const Ice::ProtocolVersion& v, const Ice::ProtocolVersion& s)
+EncodingVersion
+IceInternal::stringToEncodingVersion(string_view v)
 {
-    throw Ice::UnsupportedProtocolException(f, l, "", v, s);
+    return stringToVersion<EncodingVersion>(v);
 }
 
-void
-throwUnsupportedEncodingException(const char* f, int l, const Ice::EncodingVersion& v, const Ice::EncodingVersion& s)
+ostream&
+Ice::operator<<(ostream& out, const ProtocolVersion& version)
 {
-    throw Ice::UnsupportedEncodingException(f, l, "", v, s);
+    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);
 }
 
-namespace Ice
+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 + "'");
+    }
 
-const EncodingVersion currentEncoding = { IceInternal::encodingMajor, IceInternal::encodingMinor };
-const ProtocolVersion currentProtocol = { IceInternal::protocolMajor, IceInternal::protocolMinor };
-//
-// The encoding to use for protocol messages, this version is tied to
-// the protocol version.
-//
+    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 + "'");
+    }
 
-const EncodingVersion currentProtocolEncoding = { IceInternal::protocolEncodingMajor,
-                                                  IceInternal::protocolEncodingMinor };
+    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 + "'");
+    }
 
-const ProtocolVersion Protocol_1_0 = { 1, 0 };
+    if (majVersion < 1 || majVersion > 255 || minVersion < 0 || minVersion > 255)
+    {
+        throw ParseException(__FILE__, __LINE__, "range error in version '" + str + "'");
+    }
 
-const EncodingVersion Encoding_1_0 = { 1, 0 };
-const EncodingVersion Encoding_1_1 = { 1, 1 };
+    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