zeroc-ice 3.7.9.1 → 3.8.0

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

@@ -0,0 +1,265 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_NETWORK_H
+#define ICE_NETWORK_H
+
+#include "Ice/Config.h"
+#include "Ice/EndpointTypes.h"
+#include "Ice/Logger.h"      // For setTcpBufSize
+#include "Ice/PropertiesF.h" // For setTcpBufSize
+#include "Ice/StringUtil.h"  // For ErrorCode
+#include "NetworkF.h"
+#include "NetworkProxyF.h"
+#include "Protocol.h"
+#include "ProtocolInstanceF.h"
+
+#include <cassert>
+#include <cstring>
+
+#if defined(_WIN32)
+#    define NOMINMAX
+#    include <windows.h>
+#    include <winsock2.h>
+#    include <ws2tcpip.h>
+typedef int ssize_t;
+#else
+#    include <arpa/inet.h>
+#    include <fcntl.h>
+#    include <netdb.h>
+#    include <netinet/in.h>
+#    include <netinet/tcp.h>
+#    include <sys/poll.h>
+#    include <sys/socket.h>
+#    include <unistd.h>
+#endif
+
+#if defined(__linux__)
+#    define ICE_USE_EPOLL 1
+#elif defined(__APPLE__) && TARGET_OS_IPHONE != 0
+#    define ICE_USE_CFSTREAM 1
+#elif defined(__APPLE__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
+#    define ICE_USE_KQUEUE 1
+#elif defined(_WIN32)
+#    define ICE_USE_IOCP 1
+#else
+#    error "Unsupported platform"
+#endif
+
+#if defined(_WIN32) || defined(__osf__)
+typedef int socklen_t;
+#endif
+
+#if !defined(_WIN32)
+#    define SOCKET int
+#    define INVALID_SOCKET -1
+#    define SOCKET_ERROR -1
+#endif
+
+#ifndef SHUT_RD
+#    define SHUT_RD 0
+#endif
+
+#ifndef SHUT_WR
+#    define SHUT_WR 1
+#endif
+
+#ifndef SHUT_RDWR
+#    define SHUT_RDWR 2
+#endif
+
+#ifndef NETDB_INTERNAL
+#    define NETDB_INTERNAL -1
+#endif
+
+#ifndef NETDB_SUCCESS
+#    define NETDB_SUCCESS 0
+#endif
+
+namespace IceInternal
+{
+    union Address
+    {
+        Address()
+        {
+            memset(&saStorage, 0, sizeof(sockaddr_storage));
+            saStorage.ss_family = AF_UNSPEC;
+        }
+
+        sockaddr sa;
+        sockaddr_in saIn;
+        sockaddr_in6 saIn6;
+        sockaddr_storage saStorage;
+    };
+
+    enum SocketOperation
+    {
+        SocketOperationNone = 0,
+        SocketOperationRead = 1,
+        // With BSD sockets, write and connect readiness are the same so
+        // we use the same value for both.
+        SocketOperationWrite = 2,
+#ifdef ICE_USE_CFSTREAM
+        SocketOperationConnect = 4
+#else
+        SocketOperationConnect = 2
+#endif
+    };
+
+//
+// AsyncInfo struct for Windows IOCP holds the result of
+// asynchronous operations after it completed.
+//
+#if defined(ICE_USE_IOCP)
+    struct ICE_API AsyncInfo : WSAOVERLAPPED
+    {
+        AsyncInfo(SocketOperation);
+
+        SocketOperation status;
+        WSABUF buf;
+        DWORD flags;
+        DWORD count;
+        DWORD error;
+    };
+#endif
+
+    class ICE_API ReadyCallback
+    {
+    public:
+        virtual ~ReadyCallback();
+
+        virtual void ready(SocketOperation, bool) = 0;
+    };
+    using ReadyCallbackPtr = std::shared_ptr<ReadyCallback>;
+
+    class ICE_API NativeInfo
+    {
+    public:
+        virtual ~NativeInfo();
+
+        NativeInfo(SOCKET socketFd = INVALID_SOCKET)
+            : _fd(socketFd)
+#if !defined(ICE_USE_IOCP)
+              ,
+              _newFd(INVALID_SOCKET)
+#endif
+        {
+        }
+
+        [[nodiscard]] SOCKET fd() const { return _fd; }
+
+        void setReadyCallback(const ReadyCallbackPtr& callback);
+
+        void ready(SocketOperation operation, bool value)
+        {
+            assert(_readyCallback);
+            _readyCallback->ready(operation, value);
+        }
+
+        //
+        // This is implemented by transceiver and acceptor implementations.
+        //
+#if defined(ICE_USE_IOCP)
+        virtual AsyncInfo* getAsyncInfo(SocketOperation) = 0;
+        void initialize(HANDLE, ULONG_PTR);
+        void completed(SocketOperation);
+#else
+        bool newFd();
+        void setNewFd(SOCKET);
+#endif
+
+    protected:
+        SOCKET _fd;
+        ReadyCallbackPtr _readyCallback;
+
+#if defined(ICE_USE_IOCP)
+        HANDLE _handle;
+        ULONG_PTR _key;
+#else
+        SOCKET _newFd;
+#endif
+    };
+    using NativeInfoPtr = std::shared_ptr<NativeInfo>;
+
+    ICE_API std::string errorToStringDNS(ErrorCode);
+
+    ICE_API std::vector<Address>
+    getAddresses(const std::string& host, int port, ProtocolSupport protocol, bool preferIPv6, bool canBlock);
+
+    ICE_API ProtocolSupport getProtocolSupport(const Address&);
+    ICE_API Address getAddressForServer(const std::string&, int, ProtocolSupport, bool, bool);
+    ICE_API int compareAddress(const Address&, const Address&);
+
+    ICE_API bool isIPv6Supported();
+    ICE_API SOCKET createSocket(bool, const Address&);
+    ICE_API SOCKET createServerSocket(bool, const Address&, ProtocolSupport);
+    ICE_API void closeSocketNoThrow(SOCKET);
+    ICE_API void closeSocket(SOCKET);
+
+    ICE_API std::string addrToString(const Address&);
+    ICE_API void fdToLocalAddress(SOCKET, Address&);
+    ICE_API bool fdToRemoteAddress(SOCKET, Address&);
+    ICE_API std::string fdToString(SOCKET, const NetworkProxyPtr&, const Address&);
+    ICE_API std::string fdToString(SOCKET);
+    ICE_API void fdToAddressAndPort(SOCKET, std::string&, int&, std::string&, int&);
+    ICE_API void addrToAddressAndPort(const Address&, std::string&, int&);
+    ICE_API std::string addressesToString(const Address&, const Address&, bool);
+    ICE_API bool isAddressValid(const Address&);
+
+    ICE_API std::vector<std::string> getInterfacesForMulticast(const std::string&, ProtocolSupport);
+
+    ICE_API std::string inetAddrToString(const Address&);
+    ICE_API int getPort(const Address&);
+    ICE_API void setPort(Address&, int);
+
+    ICE_API bool isMulticast(const Address&);
+    ICE_API void setTcpBufSize(SOCKET, const ProtocolInstancePtr&);
+    ICE_API void setTcpBufSize(SOCKET, int, int, const ProtocolInstancePtr&);
+
+    ICE_API void setBlock(SOCKET, bool);
+    ICE_API void setSendBufferSize(SOCKET, int);
+    ICE_API int getSendBufferSize(SOCKET);
+    ICE_API void setRecvBufferSize(SOCKET, int);
+    ICE_API int getRecvBufferSize(SOCKET);
+
+    ICE_API void setMcastGroup(SOCKET, const Address&, const std::string&);
+    ICE_API void setMcastInterface(SOCKET, const std::string&, const Address&);
+    ICE_API void setMcastTtl(SOCKET, int, const Address&);
+    ICE_API void setReuseAddress(SOCKET, bool);
+    ICE_API Address doBind(SOCKET, const Address&, const std::string& intf = "");
+    ICE_API void doListen(SOCKET, int);
+
+    ICE_API bool interrupted();
+    ICE_API bool acceptInterrupted();
+    ICE_API bool noBuffers();
+    ICE_API bool wouldBlock();
+    ICE_API bool notConnected();
+    ICE_API bool recvTruncated();
+
+    ICE_API bool connectFailed();
+    ICE_API bool connectionRefused();
+    ICE_API bool connectInProgress();
+    ICE_API bool connectionLost();
+
+    ICE_API bool doConnect(SOCKET, const Address&, const Address&);
+    ICE_API void doFinishConnect(SOCKET);
+    ICE_API SOCKET doAccept(SOCKET);
+
+    ICE_API void createPipe(SOCKET fds[2]);
+
+    ICE_API Ice::SyscallException::ErrorCode getSocketErrno();
+
+    ICE_API Address getNumericAddress(const std::string&);
+    ICE_API std::string normalizeIPv6Address(const std::string&);
+
+#if defined(ICE_USE_IOCP)
+    ICE_API void doConnectAsync(SOCKET, const Address&, const Address&, AsyncInfo&);
+    ICE_API void doFinishConnectAsync(SOCKET, AsyncInfo&);
+#endif
+
+    ICE_API bool isIpAddress(const std::string&);
+    ICE_API bool isLoopbackOrMulticastAddress(const std::string&);
+
+    ICE_API std::string getHostName();
+}
+
+#endif

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

@@ -0,0 +1,11 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_NETWORK_F_H
+#define ICE_NETWORK_F_H
+
+namespace IceInternal
+{
+    union Address;
+}
+
+#endif

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

@@ -0,0 +1,306 @@
+// Copyright (c) ZeroC, Inc.
+
+#include "NetworkProxy.h"
+#include "HttpParser.h"
+#include "Ice/LocalExceptions.h"
+#include "Ice/Properties.h"
+
+#include <sstream>
+
+using namespace std;
+using namespace IceInternal;
+
+NetworkProxy::~NetworkProxy() = default; // Out of line to avoid weak vtable
+
+namespace
+{
+    class SOCKSNetworkProxy final : public NetworkProxy
+    {
+    public:
+        SOCKSNetworkProxy(string, int);
+        SOCKSNetworkProxy(const Address&);
+
+        void beginWrite(const Address&, Buffer&) final;
+        SocketOperation endWrite(Buffer&) final;
+        void beginRead(Buffer&) final;
+        SocketOperation endRead(Buffer&) final;
+        void finish(Buffer&, Buffer&) final;
+        [[nodiscard]] NetworkProxyPtr resolveHost(ProtocolSupport) const final;
+        [[nodiscard]] Address getAddress() const final;
+        [[nodiscard]] string getName() const final;
+        [[nodiscard]] ProtocolSupport getProtocolSupport() const final;
+
+    private:
+        string _host;
+        int _port;
+        Address _address;
+    };
+
+    class HTTPNetworkProxy final : public NetworkProxy
+    {
+    public:
+        HTTPNetworkProxy(string, int);
+        HTTPNetworkProxy(const Address&, ProtocolSupport);
+
+        void beginWrite(const Address&, Buffer&) final;
+        SocketOperation endWrite(Buffer&) final;
+        void beginRead(Buffer&) final;
+        SocketOperation endRead(Buffer&) final;
+        void finish(Buffer&, Buffer&) final;
+        [[nodiscard]] NetworkProxyPtr resolveHost(ProtocolSupport) const final;
+        [[nodiscard]] Address getAddress() const final;
+        [[nodiscard]] string getName() const final;
+        [[nodiscard]] ProtocolSupport getProtocolSupport() const final;
+
+    private:
+        string _host;
+        int _port;
+        Address _address;
+        ProtocolSupport _protocol;
+    };
+}
+
+SOCKSNetworkProxy::SOCKSNetworkProxy(string host, int port) : _host(std::move(host)), _port(port)
+{
+    assert(!_host.empty());
+}
+
+SOCKSNetworkProxy::SOCKSNetworkProxy(const Address& addr) : _port(0), _address(addr) {}
+
+void
+SOCKSNetworkProxy::beginWrite(const Address& addr, Buffer& buf)
+{
+    //
+    // SOCKS connect request
+    //
+    buf.b.resize(9);
+    buf.i = buf.b.begin();
+    byte* dest = &buf.b[0];
+    *dest++ = byte{0x04}; // SOCKS version 4.
+    *dest++ = byte{0x01}; // Command, establish a TCP/IP stream connection
+
+    const byte* src;
+
+    //
+    // Port (already in big-endian order)
+    //
+    src = reinterpret_cast<const byte*>(&addr.saIn.sin_port);
+    *dest++ = *src++;
+    *dest++ = *src;
+
+    //
+    // IPv4 address (already in big-endian order)
+    //
+    src = reinterpret_cast<const byte*>(&addr.saIn.sin_addr.s_addr);
+    *dest++ = *src++;
+    *dest++ = *src++;
+    *dest++ = *src++;
+    *dest++ = *src;
+
+    *dest = byte{0x00}; // User ID.
+}
+
+SocketOperation
+SOCKSNetworkProxy::endWrite(Buffer& buf)
+{
+    // Once the request is sent, read the response
+    return buf.i != buf.b.end() ? SocketOperationWrite : SocketOperationRead;
+}
+
+void
+SOCKSNetworkProxy::beginRead(Buffer& buf)
+{
+    //
+    // Read the SOCKS4 response whose size is 8 bytes.
+    //
+    buf.b.resize(8);
+    buf.i = buf.b.begin();
+}
+
+SocketOperation
+SOCKSNetworkProxy::endRead(Buffer& buf)
+{
+    // We're done once we read the response
+    return buf.i != buf.b.end() ? SocketOperationRead : SocketOperationNone;
+}
+
+void
+SOCKSNetworkProxy::finish(Buffer& readBuffer, Buffer&)
+{
+    readBuffer.i = readBuffer.b.begin();
+
+    if (readBuffer.b.end() - readBuffer.i < 2)
+    {
+        throw Ice::MarshalException{__FILE__, __LINE__, "attempting to unmarshal past the end of the buffer"};
+    }
+
+    const byte* src = &(*readBuffer.i);
+    const byte b1 = *src++;
+    const byte b2 = *src++;
+    if (b1 != byte{0x00} || b2 != byte{0x5a})
+    {
+        throw Ice::ConnectFailedException{
+            __FILE__,
+            __LINE__,
+            "connection establishment failed due to an HTTP proxy error"};
+    }
+}
+
+NetworkProxyPtr
+SOCKSNetworkProxy::resolveHost(ProtocolSupport protocol) const
+{
+    assert(!_host.empty());
+    return make_shared<SOCKSNetworkProxy>(getAddresses(_host, _port, protocol, false, true)[0]);
+}
+
+Address
+SOCKSNetworkProxy::getAddress() const
+{
+    assert(_host.empty()); // Host must be resolved.
+    return _address;
+}
+
+string
+SOCKSNetworkProxy::getName() const
+{
+    return "SOCKS";
+}
+
+ProtocolSupport
+SOCKSNetworkProxy::getProtocolSupport() const
+{
+    return EnableIPv4;
+}
+
+HTTPNetworkProxy::HTTPNetworkProxy(string host, int port) : _host(std::move(host)), _port(port), _protocol(EnableBoth)
+{
+    assert(!_host.empty());
+}
+
+HTTPNetworkProxy::HTTPNetworkProxy(const Address& addr, ProtocolSupport protocol)
+    : _port(0),
+      _address(addr),
+      _protocol(protocol)
+{
+}
+
+void
+HTTPNetworkProxy::beginWrite(const Address& addr, Buffer& buf)
+{
+    //
+    // HTTP connect request
+    //
+    ostringstream out;
+    out << "CONNECT " << addrToString(addr) << " HTTP/1.1\r\n"
+        << "Host: " << addrToString(addr) << "\r\n\r\n";
+    string str = out.str();
+    buf.b.resize(str.size());
+    memcpy(&buf.b[0], str.c_str(), str.size());
+    buf.i = buf.b.begin();
+}
+
+SocketOperation
+HTTPNetworkProxy::endWrite(Buffer& buf)
+{
+    // Once the request is sent, read the response
+    return buf.i != buf.b.end() ? SocketOperationWrite : SocketOperationRead;
+}
+
+void
+HTTPNetworkProxy::beginRead(Buffer& buf)
+{
+    //
+    // Read the Http response
+    //
+    buf.b.resize(7); // Enough space for reading at least HTTP1.1
+    buf.i = buf.b.begin();
+}
+
+SocketOperation
+HTTPNetworkProxy::endRead(Buffer& buf)
+{
+    //
+    // Check if we received the full HTTP response, if not, continue
+    // reading otherwise we're done.
+    //
+    const byte* end = HttpParser().isCompleteMessage(buf.b.begin(), buf.i);
+    if (!end && buf.i == buf.b.end())
+    {
+        //
+        // Read one more byte, we can't easily read bytes in advance
+        // since the transport implementation might be be able to read
+        // the data from the memory instead of the socket. This is for
+        // instance the case with the OpenSSL transport (or we would
+        // have to use a buffering BIO).
+        //
+        buf.b.resize(buf.b.size() + 1);
+        buf.i = buf.b.begin() + buf.b.size() - 1;
+        return SocketOperationRead;
+    }
+    return SocketOperationNone;
+}
+
+void
+HTTPNetworkProxy::finish(Buffer& readBuffer, Buffer&)
+{
+    HttpParser parser;
+    parser.parse(readBuffer.b.begin(), readBuffer.b.end());
+    if (parser.status() != 200)
+    {
+        throw Ice::ConnectFailedException{
+            __FILE__,
+            __LINE__,
+            "connection establishment failed due to an HTTP proxy error: " + to_string(parser.status())};
+    }
+}
+
+NetworkProxyPtr
+HTTPNetworkProxy::resolveHost(ProtocolSupport protocol) const
+{
+    assert(!_host.empty());
+    return make_shared<HTTPNetworkProxy>(getAddresses(_host, _port, protocol, false, true)[0], protocol);
+}
+
+Address
+HTTPNetworkProxy::getAddress() const
+{
+    assert(_host.empty()); // Host must be resolved.
+    return _address;
+}
+
+string
+HTTPNetworkProxy::getName() const
+{
+    return "HTTP";
+}
+
+ProtocolSupport
+HTTPNetworkProxy::getProtocolSupport() const
+{
+    return _protocol;
+}
+
+NetworkProxyPtr
+IceInternal::createNetworkProxy(const Ice::PropertiesPtr& properties, ProtocolSupport protocolSupport)
+{
+    string proxyHost;
+
+    proxyHost = properties->getIceProperty("Ice.SOCKSProxyHost");
+    if (!proxyHost.empty())
+    {
+        if (protocolSupport == EnableIPv6)
+        {
+            throw Ice::InitializationException(__FILE__, __LINE__, "IPv6 only is not supported with SOCKS4 proxies");
+        }
+        int proxyPort = properties->getIcePropertyAsInt("Ice.SOCKSProxyPort");
+        return make_shared<SOCKSNetworkProxy>(proxyHost, proxyPort);
+    }
+
+    proxyHost = properties->getIceProperty("Ice.HTTPProxyHost");
+    if (!proxyHost.empty())
+    {
+        return make_shared<HTTPNetworkProxy>(proxyHost, properties->getIcePropertyAsInt("Ice.HTTPProxyPort"));
+    }
+
+    return nullptr;
+}

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

@@ -0,0 +1,67 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_NETWORK_PROXY_H
+#define ICE_NETWORK_PROXY_H
+
+#include "Ice/Buffer.h"
+#include "Network.h"
+
+namespace IceInternal
+{
+    class NetworkProxy
+    {
+    public:
+        virtual ~NetworkProxy();
+
+        //
+        // Write the connection request on the connection established
+        // with the network proxy server. This is called right after
+        // the connection establishment succeeds.
+        //
+        virtual void beginWrite(const Address&, Buffer&) = 0;
+        virtual SocketOperation endWrite(Buffer&) = 0;
+
+        //
+        // Once the connection request has been sent, this is called
+        // to prepare and read the response from the proxy server.
+        //
+        virtual void beginRead(Buffer&) = 0;
+        virtual SocketOperation endRead(Buffer&) = 0;
+
+        //
+        // This is called when the response from the proxy has been
+        // read. The proxy should copy the extra read data (if any) in the
+        // given byte vector.
+        //
+        virtual void finish(Buffer&, Buffer&) = 0;
+
+        //
+        // If the proxy host needs to be resolved, this should return
+        // a new NetworkProxy containing the IP address of the proxy.
+        // This is called from the endpoint host resolver thread, so
+        // it's safe if this this method blocks.
+        //
+        [[nodiscard]] virtual NetworkProxyPtr resolveHost(ProtocolSupport) const = 0;
+
+        //
+        // Returns the IP address of the network proxy. This method
+        // must not block. It's only called on a network proxy object
+        // returned by resolveHost().
+        //
+        [[nodiscard]] virtual Address getAddress() const = 0;
+
+        //
+        // Returns the name of the proxy, used for tracing purposes.
+        //
+        [[nodiscard]] virtual std::string getName() const = 0;
+
+        //
+        // Returns the protocols supported by the proxy.
+        //
+        [[nodiscard]] virtual ProtocolSupport getProtocolSupport() const = 0;
+    };
+
+    NetworkProxyPtr createNetworkProxy(const Ice::PropertiesPtr&, ProtocolSupport);
+}
+
+#endif

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

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