zeroc-ice 3.7.9.1 → 3.8.0

data/dist/ice/cpp/include/Ice/IconvStringConverter.h

@@ -0,0 +1,216 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_ICONV_STRING_CONVERTER
+#define ICE_ICONV_STRING_CONVERTER
+
+//
+// For all platforms except Windows
+//
+#ifndef _WIN32
+#    include "Config.h"
+#    include "LocalExceptions.h"
+#    include "StringConverter.h"
+#    include "StringUtil.h"
+
+#    include <algorithm>
+#    include <cassert>
+#    include <iconv.h>
+#    include <langinfo.h>
+#    include <memory>
+#    include <sstream>
+
+namespace IceInternal
+{
+    //
+    // Converts charT encoded with internalCode to and from UTF-8 byte sequences
+    //
+    // The implementation allocates a pair of iconv_t on each thread, to avoid
+    // opening / closing iconv_t objects all the time.
+    //
+    //
+    template<typename charT> class IconvStringConverter final : public Ice::BasicStringConverter<charT>
+    {
+    public:
+        IconvStringConverter(const std::string&);
+
+        std::byte* toUTF8(const charT*, const charT*, Ice::UTF8Buffer&) const final;
+
+        void fromUTF8(const std::byte*, const std::byte*, std::basic_string<charT>&) const final;
+
+    private:
+        struct DescriptorHolder
+        {
+            std::pair<iconv_t, iconv_t> descriptor;
+
+            // NOLINTNEXTLINE(performance-no-int-to-ptr)
+            DescriptorHolder(const std::string& internalCode) : descriptor(iconv_t(-1), iconv_t(-1))
+            {
+                const char* externalCode = "UTF-8";
+
+                descriptor.first = iconv_open(internalCode.c_str(), externalCode);
+                if (descriptor.first == iconv_t(-1)) // NOLINT(performance-no-int-to-ptr)
+                {
+                    std::ostringstream os;
+                    os << "iconv cannot convert from " << externalCode << " to " << internalCode;
+                    throw Ice::FeatureNotSupportedException{__FILE__, __LINE__, os.str()};
+                }
+
+                descriptor.second = iconv_open(externalCode, internalCode.c_str());
+                if (descriptor.second == iconv_t(-1)) // NOLINT(performance-no-int-to-ptr)
+                {
+                    iconv_close(descriptor.first);
+                    std::ostringstream os;
+                    os << "iconv cannot convert from " << internalCode << " to " << externalCode;
+                    throw Ice::FeatureNotSupportedException{__FILE__, __LINE__, os.str()};
+                }
+            }
+
+            ~DescriptorHolder()
+            {
+                [[maybe_unused]] int rs = iconv_close(descriptor.first);
+                assert(rs == 0);
+
+                rs = iconv_close(descriptor.second);
+                assert(rs == 0);
+            }
+
+            DescriptorHolder(const DescriptorHolder&) = delete;
+            DescriptorHolder& operator=(const DescriptorHolder&) = delete;
+        };
+
+        [[nodiscard]] std::pair<iconv_t, iconv_t> getDescriptors() const;
+
+        const std::string _internalCode;
+    };
+
+    //
+    // Implementation
+    //
+
+    template<typename charT>
+    IconvStringConverter<charT>::IconvStringConverter(const std::string& internalCode) : _internalCode(internalCode)
+    {
+        //
+        // Verify that iconv supports conversion to/from internalCode
+        //
+        const DescriptorHolder descriptorHolder(internalCode);
+    }
+
+    template<typename charT> std::pair<iconv_t, iconv_t> IconvStringConverter<charT>::getDescriptors() const
+    {
+        static const thread_local DescriptorHolder descriptorHolder(_internalCode);
+        return descriptorHolder.descriptor;
+    }
+
+    template<typename charT>
+    std::byte*
+    IconvStringConverter<charT>::toUTF8(const charT* sourceStart, const charT* sourceEnd, Ice::UTF8Buffer& buf) const
+    {
+        iconv_t cd = getDescriptors().second;
+
+        //
+        // Reset cd
+        //
+        [[maybe_unused]] size_t rs = iconv(cd, nullptr, nullptr, nullptr, nullptr);
+
+        char* inbuf = reinterpret_cast<char*>(const_cast<charT*>(sourceStart));
+        size_t inbytesleft = static_cast<size_t>(sourceEnd - sourceStart) * sizeof(charT);
+        std::byte* outbuf = nullptr;
+
+        size_t count = 0;
+        //
+        // Loop while we need more buffer space
+        //
+        do
+        {
+            size_t howMany = std::max(inbytesleft, size_t(4));
+            outbuf = buf.getMoreBytes(howMany, outbuf);
+            count = iconv(cd, &inbuf, &inbytesleft, reinterpret_cast<char**>(&outbuf), &howMany);
+        } while (count == size_t(-1) && errno == E2BIG);
+
+        if (count == size_t(-1))
+        {
+            int errorCode = errno;
+            std::ostringstream os;
+            os << "iconv failed with: " << (errorCode == 0 ? "unknown error" : IceInternal::errorToString(errorCode));
+            throw Ice::IllegalConversionException(__FILE__, __LINE__, os.str());
+        }
+        return outbuf;
+    }
+
+    template<typename charT>
+    void IconvStringConverter<charT>::fromUTF8(
+        const std::byte* sourceStart,
+        const std::byte* sourceEnd,
+        std::basic_string<charT>& target) const
+    {
+        iconv_t cd = getDescriptors().first;
+
+        //
+        // Reset cd
+        //
+        [[maybe_unused]] size_t rs = iconv(cd, nullptr, nullptr, nullptr, nullptr);
+        assert(rs == 0);
+        char* inbuf = reinterpret_cast<char*>(const_cast<std::byte*>(sourceStart));
+        assert(sourceEnd > sourceStart);
+        auto inbytesleft = static_cast<size_t>(sourceEnd - sourceStart);
+
+        char* outbuf = nullptr;
+        size_t outbytesleft = 0;
+        size_t count = 0;
+
+        //
+        // Loop while we need more buffer space
+        //
+        do
+        {
+            size_t bytesUsed = 0;
+            if (outbuf)
+            {
+                bytesUsed = static_cast<size_t>(outbuf - reinterpret_cast<const char*>(target.data()));
+            }
+
+            const size_t increment = std::max<size_t>(inbytesleft, 4);
+            target.resize(target.size() + increment);
+            outbuf = const_cast<char*>(reinterpret_cast<const char*>(target.data())) + bytesUsed;
+            outbytesleft += increment * sizeof(charT);
+
+            count = iconv(cd, &inbuf, &inbytesleft, &outbuf, &outbytesleft);
+
+        } while (count == size_t(-1) && errno == E2BIG);
+
+        if (count == size_t(-1))
+        {
+            int errorCode = errno;
+            std::ostringstream os;
+            os << "iconv failed with: " << (errorCode == 0 ? "unknown error" : IceInternal::errorToString(errorCode));
+            throw Ice::IllegalConversionException(__FILE__, __LINE__, os.str());
+        }
+
+        target.resize(target.size() - (outbytesleft / sizeof(charT)));
+    }
+}
+
+namespace Ice
+{
+    /// Creates a string converter for the given code.
+    /// @param internalCodeWithDefault The desired code. If empty or not provided, a default code is used.
+    /// @return The converter object.
+    /// @throws FeatureNotSupportedException If the code is not supported.
+    template<typename charT>
+    std::shared_ptr<Ice::BasicStringConverter<charT>>
+    createIconvStringConverter(const std::string& internalCodeWithDefault = "")
+    {
+        std::string internalCode = internalCodeWithDefault;
+
+        if (internalCode.empty())
+        {
+            internalCode = nl_langinfo(CODESET);
+        }
+
+        return std::make_shared<IceInternal::IconvStringConverter<charT>>(internalCode);
+    }
+}
+
+#endif
+#endif

data/dist/ice/cpp/include/Ice/ImplicitContext.h

@@ -0,0 +1,76 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_IMPLICIT_CONTEXT_H
+#define ICE_IMPLICIT_CONTEXT_H
+
+#include "Config.h"
+#include "Ice/Context.h"
+
+#include <memory>
+#include <mutex>
+#include <string>
+
+namespace Ice
+{
+    class OutputStream;
+
+    /// Represents the request context associated with a communicator.
+    /// When you make a remote invocation without an explicit request context parameter, Ice uses the per-proxy request
+    /// context (if any) combined with the `ImplicitContext` associated with your communicator. The property
+    /// `Ice.ImplicitContext` controls if your communicator has an associated implicit context, and when it does,
+    /// whether this implicit context is per-thread or shared by all threads.
+    /// @headerfile Ice/Ice.h
+    class ICE_API ImplicitContext final
+    {
+    public:
+        /// Gets a copy of the request context maintained by this object.
+        /// @return A copy of the request context.
+        [[nodiscard]] Context getContext() const;
+
+        /// Sets the request context.
+        /// @param newContext The new request context.
+        void setContext(Context newContext);
+
+        /// Checks if the specified key has an associated value in the request context.
+        /// @param key The key.
+        /// @return `true` if the key has an associated value, `false` otherwise.
+        [[nodiscard]] bool containsKey(std::string_view key) const;
+
+        /// Gets the value associated with the specified key in the request context.
+        /// @param key The key.
+        /// @return The value associated with the key, or the empty string if no value is associated with the key.
+        [[nodiscard]] std::string get(std::string_view key) const;
+
+        /// Creates or updates a key/value entry in the request context.
+        /// @param key The key.
+        /// @param value The value.
+        /// @return The previous value associated with the key, if any.
+        std::string put(std::string key, std::string value);
+
+        /// Removes the entry for the specified key in the request context.
+        /// @param key The key.
+        /// @return The value associated with the key, if any.
+        std::string remove(std::string_view key);
+
+        /// Marshals this request context plus the specified request context. Entries in @p context overwrite entries
+        /// in this request context.
+        /// @param context The request context to write to the output stream.
+        /// @param os The output stream.
+        void write(const Context& context, Ice::OutputStream* os) const;
+
+        /// Combines this request context plus the specified request context. Entries in @p context overwrite entries in
+        /// this request context.
+        /// @param context The request context to combine with this request context.
+        /// @param combined The combined request context.
+        void combine(const Context& context, Context& combined) const;
+
+    private:
+        mutable std::mutex _mutex;
+        Context _context;
+    };
+
+    /// A shared pointer to an ImplicitContext.
+    using ImplicitContextPtr = std::shared_ptr<ImplicitContext>;
+}
+
+#endif

data/dist/ice/cpp/include/Ice/IncomingRequest.h

@@ -0,0 +1,75 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_INCOMING_REQUEST_H
+#define ICE_INCOMING_REQUEST_H
+
+#include "Config.h"
+#include "ConnectionF.h"
+#include "Current.h"
+#include "ObjectAdapterF.h"
+
+namespace Ice
+{
+    class InputStream;
+
+    /// Represents a request received by a connection. It's the argument to the dispatch function on Object.
+    /// @remark IncomingRequest is neither copyable nor movable. It can be used only on the dispatch thread.
+    /// @see Object::dispatch
+    /// @headerfile Ice/Ice.h
+    class ICE_API IncomingRequest final
+    {
+    public:
+        /// Constructs an IncomingRequest object.
+        /// @param requestId The request ID. It's `0` for one-way requests.
+        /// @param connection The connection that received the request. It's nullptr for collocated invocations.
+        /// @param adapter The object adapter to set in Current.
+        /// @param inputStream The input stream buffer over the incoming Ice protocol request message. The stream is
+        /// positioned at the beginning of the request header - the next data to read is the identity of the target.
+        /// @param requestCount The number of requests remaining in @p inputStream. This value is always `1` for
+        /// non-batched requests.
+        /// @remark This constructor reads the request header from @p inputStream. When it completes, the input stream
+        /// is positioned at the beginning of encapsulation carried by the request.
+        /// @remark The Ice runtime calls this constructor when it dispatches an incoming request. You may want to call
+        /// it in a middleware unit test.
+        IncomingRequest(
+            int32_t requestId,
+            ConnectionPtr connection,
+            ObjectAdapterPtr adapter,
+            InputStream& inputStream,
+            std::int32_t requestCount);
+
+        IncomingRequest(const IncomingRequest&) = delete;
+        IncomingRequest(IncomingRequest&&) noexcept = delete;
+        IncomingRequest& operator=(const IncomingRequest&) = delete;
+        IncomingRequest& operator=(IncomingRequest&&) = delete;
+
+        /// Gets the Current object of the request.
+        /// @return A reference to the current object of the request.
+        Current& current() noexcept { return _current; }
+
+        /// Gets the Current object of the request.
+        /// @return A const reference to the current object of the request.
+        [[nodiscard]] const Ice::Current& current() const noexcept { return _current; }
+
+        /// Gets the input stream buffer of the request.
+        /// @return A reference to the input stream buffer.
+        InputStream& inputStream() noexcept { return _inputStream; }
+
+        /// Gets the number of bytes in the request.
+        /// @return The number of bytes in the request. These are all the bytes starting with the identity of the
+        /// target object.
+        [[nodiscard]] std::int32_t size() const { return _requestSize; }
+
+        /// Gets the request count.
+        /// @return The number of requests remaining in the input stream when this IncomingRequest was constructed.
+        [[nodiscard]] std::int32_t requestCount() const noexcept { return _requestCount; }
+
+    private:
+        InputStream& _inputStream;
+        Current _current;
+        std::int32_t _requestSize;
+        std::int32_t _requestCount;
+    };
+}
+
+#endif

data/dist/ice/cpp/include/Ice/Initialize.h

@@ -0,0 +1,143 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_INITIALIZE_H
+#define ICE_INITIALIZE_H
+
+#include "BatchRequest.h"
+#include "CommunicatorF.h"
+#include "Connection.h"
+#include "Ice/BuiltinSequences.h"
+#include "InstanceF.h"
+#include "Instrumentation.h"
+#include "Logger.h"
+#include "Plugin.h"
+#include "PluginFactory.h"
+#include "Properties.h"
+#include "SSL/ClientAuthenticationOptions.h"
+#include "SliceLoader.h"
+#include "StringUtil.h"
+#include "TimerTask.h"
+
+#include <algorithm>
+
+namespace Ice
+{
+    /// Represents a set of options that you can specify when initializing a communicator.
+    /// @headerfile Ice/Ice.h
+    struct InitializationData
+    {
+        /// The properties for the communicator.
+        /// When non-null, this corresponds to the object returned by the Communicator::getProperties function.
+        PropertiesPtr properties{};
+
+        /// The logger for the communicator.
+        LoggerPtr logger{};
+
+        /// The communicator observer used by the Ice runtime.
+        Instrumentation::CommunicatorObserverPtr observer{};
+
+#if defined(__clang__)
+#    pragma clang diagnostic push
+#    pragma clang diagnostic ignored "-Wdocumentation" // param/return is not recognized for std::function data members
+#endif
+
+        /// A function that the communicator calls when it starts a new thread.
+        std::function<void()> threadStart{};
+
+        /// A function that the communicator calls when it destroys a thread.
+        std::function<void()> threadStop{};
+
+        /// A function that the communicator calls to execute dispatches and async invocation callbacks.
+        /// @param call Represents the function to execute. The executor must eventually execute this function.
+        /// @param con The connection associated with this call. May be null.
+        std::function<void(std::function<void()> call, const Ice::ConnectionPtr& con)> executor{};
+
+        /// The batch request interceptor, which is called by the Ice runtime to enqueue a batch request.
+        /// @param req An object representing the batch request.
+        /// @param count The number of requests currently in the queue.
+        /// @param size The number of bytes consumed by the requests currently in the queue.
+        std::function<void(const Ice::BatchRequest& req, int count, int size)> batchRequestInterceptor{};
+
+#if defined(__clang__)
+#    pragma clang diagnostic pop
+#endif
+
+        /// The authentication options for SSL client connections. When set, the SSL transport ignores all IceSSL
+        /// configuration properties and uses these options.
+        /// @see SSL::OpenSSLClientAuthenticationOptions
+        /// @see SSL::SecureTransportClientAuthenticationOptions
+        /// @see SSL::SchannelClientAuthenticationOptions
+        std::optional<SSL::ClientAuthenticationOptions> clientAuthenticationOptions{};
+
+        /// A list of plug-in factories. The corresponding plug-ins are created during communicator initialization,
+        /// in order, before all other plug-ins.
+        std::vector<PluginFactory> pluginFactories{};
+
+        /// The Slice loader, used to unmarshal Slice classes and exceptions.
+        SliceLoaderPtr sliceLoader{};
+    };
+
+    /// Creates a new communicator.
+    /// @param initData Options for the new communicator.
+    /// @return The new communicator.
+    /// @remark This is the main initialize function. All other overloads are provided for convenience and call this
+    /// function.
+    ICE_API CommunicatorPtr initialize(InitializationData initData = {});
+
+    /// Creates a new communicator, using Ice properties parsed from the command-line arguments.
+    /// @tparam ArgvT The type of the argument vector, such as char**, const char**, or wchar_t** (on Windows).
+    /// @param[in,out] argc The number of arguments in @p argv. When this function parses properties from @p argv, it
+    /// reshuffles the arguments so that the remaining arguments start at the beginning of @p argv, and updates @p argc
+    /// accordingly.
+    /// @param argv The command-line arguments. This function parses arguments starting with `--` and one of the
+    /// reserved prefixes (Ice, IceSSL, etc.) as properties for the new communicator. If there is an argument starting
+    /// with `--Ice.Config`, this function loads the specified configuration file. When the same property is set in a
+    /// configuration file and through a command-line argument, the command-line setting takes precedence.
+    /// @return The new communicator.
+    template<typename ArgvT> inline CommunicatorPtr initialize(int& argc, ArgvT argv)
+    {
+        auto properties = std::make_shared<Properties>(argc, argv);
+        if (properties->getProperty("Ice.ProgramName").empty() && argc > 0)
+        {
+            StringSeq args = argsToStringSeq(argc, argv);
+            std::string programName = args[0];
+            // Replace any backslashes in this value with forward slashes, in case this value is used by the event
+            // logger.
+            std::replace(programName.begin(), programName.end(), '\\', '/');
+            properties->setProperty("Ice.ProgramName", std::move(programName));
+        }
+
+        InitializationData initData;
+        initData.properties = properties;
+        return initialize(std::move(initData));
+    }
+
+    /// Gets the per-process logger. This logger is used by all communicators that do not have their own specific logger
+    /// configured at the time the communicator is created.
+    /// @return The current per-process logger instance.
+    ICE_API LoggerPtr getProcessLogger();
+
+    /// Sets the per-process logger. This logger is used by all communicators that do not have their own specific logger
+    /// configured at the time the communicator is created.
+    /// @param logger The new per-process logger instance.
+    ICE_API void setProcessLogger(const LoggerPtr& logger);
+
+    /// Converts a stringified identity into an Identity.
+    /// @param str The stringified identity.
+    /// @return An Identity containing the name and category components.
+    ICE_API Identity stringToIdentity(std::string_view str);
+
+    /// Converts an Identity into a string using the specified mode.
+    /// @param id The identity.
+    /// @param mode Specifies how to handle non-ASCII characters and non-printable ASCII characters.
+    /// @return The stringified identity.
+    ICE_API std::string identityToString(const Identity& id, ToStringMode mode = ToStringMode::Unicode);
+}
+
+namespace IceInternal
+{
+    ICE_API InstancePtr getInstance(const Ice::CommunicatorPtr&);
+    ICE_API TimerPtr getInstanceTimer(const Ice::CommunicatorPtr&);
+}
+
+#endif