zeroc-ice 3.6.5 → 3.7.4

data/ext/ice/cpp/src/Ice/StreamSocket.h

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) ZeroC, Inc. All rights reserved.
 //
-// This copy of Ice is licensed to you under the terms described in the
-// ICE_LICENSE file included in this distribution.
-//
-// **********************************************************************
 
 #ifndef ICE_STREAM_SOCKET_H
 #define ICE_STREAM_SOCKET_H
@@ -36,11 +31,16 @@ public:
     SocketOperation read(Buffer&);
     SocketOperation write(Buffer&);
 
+#if !defined(ICE_OS_UWP)
     ssize_t read(char*, size_t);
     ssize_t write(const char*, size_t);
+#endif
 
-#ifdef ICE_USE_IOCP
+#if defined(ICE_USE_IOCP) || defined(ICE_OS_UWP)
     AsyncInfo* getAsyncInfo(SocketOperation);
+#endif
+
+#if defined(ICE_USE_IOCP) || defined(ICE_OS_UWP)
     bool startWrite(Buffer&);
     void finishWrite(Buffer&);
     void startRead(Buffer&);
@@ -73,16 +73,20 @@ private:
     State _state;
     std::string _desc;
 
-#ifdef ICE_USE_IOCP
+#if defined(ICE_USE_IOCP) || defined(ICE_OS_UWP)
     size_t _maxSendPacketSize;
     size_t _maxRecvPacketSize;
     AsyncInfo _read;
     AsyncInfo _write;
 #endif
+
+#if defined(ICE_OS_UWP)
+    Windows::Storage::Streams::DataReader^ _reader;
+    Windows::Storage::Streams::DataWriter^ _writer;
+#endif
 };
 typedef IceUtil::Handle<StreamSocket> StreamSocketPtr;
 
 }
 
 #endif
-

data/ext/ice/cpp/src/Ice/StringConverterPlugin.cpp

@@ -1,30 +1,56 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) ZeroC, Inc. All rights reserved.
 //
-// This copy of Ice is licensed to you under the terms described in the
-// ICE_LICENSE file included in this distribution.
-//
-// **********************************************************************
 
 #include <Ice/Config.h>
 
-// For deprecated StringConverterPlugin
-#include <IceUtil/DisableWarnings.h>
-#include <Ice/DeprecatedStringConverter.h>
-
-#include <IceUtil/IceUtil.h>
-#include <IceUtil/StringUtil.h>
-
-#include <Ice/Communicator.h>
+#include <Ice/StringConverter.h>
+#include <Ice/IconvStringConverter.h>
 #include <Ice/Initialize.h>
-#include <Ice/LocalException.h>
+#include <Ice/Communicator.h>
 #include <Ice/LoggerUtil.h>
+#include <IceUtil/StringUtil.h>
 
-using namespace IceUtilInternal;
 using namespace Ice;
 using namespace std;
 
+namespace
+{
+
+class StringConverterPlugin : public Plugin
+{
+public:
+
+    StringConverterPlugin(const CommunicatorPtr&,
+                          const StringConverterPtr&, const WstringConverterPtr&);
+
+    virtual void initialize();
+
+    virtual void destroy();
+};
+
+StringConverterPlugin::StringConverterPlugin(const CommunicatorPtr& /*notused*/,
+                                             const StringConverterPtr& stringConverter,
+                                             const WstringConverterPtr& wstringConverter)
+{
+    setProcessStringConverter(stringConverter);
+    setProcessWstringConverter(wstringConverter);
+}
+
+void
+StringConverterPlugin::initialize()
+{
+    // no op
+}
+
+void
+StringConverterPlugin::destroy()
+{
+    // no op
+}
+
+}
+
 //
 // The entry point for the string converter plugin built-in the Ice library
 //
@@ -78,7 +104,7 @@ createStringConverter(const CommunicatorPtr& communicator, const string& name, c
             return 0;
         }
 
-        stringConverter = new IceUtil::WindowsStringConverter(static_cast<unsigned int>(cp));
+        stringConverter = createWindowsStringConverter(static_cast<unsigned int>(cp));
 #else
         StringSeq iconvArgs;
 
@@ -105,18 +131,18 @@ createStringConverter(const CommunicatorPtr& communicator, const string& name, c
         {
             case 0:
             {
-                stringConverter = new IceUtil::IconvStringConverter<char>;
+                stringConverter = createIconvStringConverter<char>();
                 break;
             }
             case 1:
             {
-                stringConverter = new IceUtil::IconvStringConverter<char>(iconvArgs[0].c_str());
+                stringConverter = createIconvStringConverter<char>(iconvArgs[0]);
                 break;
             }
             case 2:
             {
-                stringConverter = new IceUtil::IconvStringConverter<char>(iconvArgs[0].c_str());
-                wstringConverter = new IceUtil::IconvStringConverter<wchar_t>(iconvArgs[1].c_str());
+                stringConverter = createIconvStringConverter<char>(iconvArgs[0]);
+                wstringConverter = createIconvStringConverter<wchar_t>(iconvArgs[1]);
                 break;
             }
             default:
@@ -151,7 +177,16 @@ namespace Ice
 ICE_API void
 registerIceStringConverter(bool loadOnInitialize)
 {
-    Ice::registerPluginFactory("IceStringConverter", createStringConverter, loadOnInitialize);
+    registerPluginFactory("IceStringConverter", createStringConverter, loadOnInitialize);
+}
+
 }
 
+//
+// Objective-C function to allow Objective-C programs to register plugin.
+//
+extern "C" ICE_API void
+ICEregisterIceStringConverter(bool loadOnInitialize)
+{
+    Ice::registerIceStringConverter(loadOnInitialize);
 }

data/ext/ice/cpp/src/Ice/StringUtil.h

@@ -0,0 +1,30 @@
+//
+// Copyright (c) ZeroC, Inc. All rights reserved.
+//
+
+#ifndef ICE_STRING_UTIL_H
+#define ICE_STRING_UTIL_H
+
+#include <Ice/Initialize.h>
+#include <IceUtil/StringUtil.h>
+
+namespace IceInternal
+{
+
+//
+// Adapter for ToStringMode
+//
+inline std::string
+escapeString(const std::string& s, const std::string& special, Ice::ToStringMode mode)
+{
+    return IceUtilInternal::escapeString(s, special, static_cast<IceUtilInternal::ToStringMode>(mode));
+}
+
+//
+// Provided for consistency with escapeString
+//
+using IceUtilInternal::unescapeString;
+
+}
+
+#endif

data/ext/ice/cpp/src/Ice/SysLoggerI.cpp

@@ -1,11 +1,8 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) ZeroC, Inc. All rights reserved.
 //
-// This copy of Ice is licensed to you under the terms described in the
-// ICE_LICENSE file included in this distribution.
-//
-// **********************************************************************
+
+#ifndef _WIN32
 
 #include <Ice/SysLoggerI.h>
 #include <Ice/LocalException.h>
@@ -163,5 +160,7 @@ Ice::SysLoggerI::getPrefix()
 Ice::LoggerPtr
 Ice::SysLoggerI::cloneWithPrefix(const string& prefix)
 {
-    return new SysLoggerI(prefix, _facility);
+    return ICE_MAKE_SHARED(SysLoggerI, prefix, _facility);
 }
+
+#endif

data/ext/ice/cpp/src/Ice/SysLoggerI.h

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) ZeroC, Inc. All rights reserved.
 //
-// This copy of Ice is licensed to you under the terms described in the
-// ICE_LICENSE file included in this distribution.
-//
-// **********************************************************************
 
 #ifndef ICE_SYS_LOGGER_I_H
 #define ICE_SYS_LOGGER_I_H
@@ -21,6 +16,7 @@ class SysLoggerI : public Logger, public ::IceUtil::Mutex
 public:
 
     SysLoggerI(const std::string&, const std::string&);
+    SysLoggerI(const std::string&, int);
     ~SysLoggerI();
 
     virtual void print(const std::string&);
@@ -32,8 +28,6 @@ public:
 
 private:
 
-    SysLoggerI(const std::string&, int);
-
     int _facility;
     const std::string _prefix;
 };

data/ext/ice/cpp/src/Ice/SystemdJournalI.cpp

@@ -0,0 +1,66 @@
+//
+// Copyright (c) ZeroC, Inc. All rights reserved.
+//
+
+#ifdef ICE_USE_SYSTEMD
+
+#include <Ice/SystemdJournalI.h>
+#include <Ice/LocalException.h>
+#include <syslog.h>
+#include <systemd/sd-journal.h>
+
+using namespace std;
+using namespace Ice;
+using namespace IceInternal;
+
+Ice::SystemdJournalI::SystemdJournalI(const string& prefix) :
+    _prefix(prefix)
+{
+}
+
+void
+Ice::SystemdJournalI::print(const string& message)
+{
+    write(LOG_INFO, message);
+}
+
+void
+Ice::SystemdJournalI::trace(const string& category, const string& message)
+{
+    write(LOG_INFO, category + ": " + message);
+}
+
+void
+Ice::SystemdJournalI::warning(const string& message)
+{
+    write(LOG_WARNING, message);
+}
+
+void
+Ice::SystemdJournalI::error(const string& message)
+{
+    write(LOG_ERR, message);
+}
+
+string
+Ice::SystemdJournalI::getPrefix()
+{
+    return _prefix;
+}
+
+Ice::LoggerPtr
+Ice::SystemdJournalI::cloneWithPrefix(const string& prefix)
+{
+    return ICE_MAKE_SHARED(SystemdJournalI, prefix);
+}
+
+void
+Ice::SystemdJournalI::write(int priority, const string& message) const
+{
+    sd_journal_send("MESSAGE=%s", message.c_str(),
+                    "PRIORITY=%i", priority,
+                    "SYSLOG_IDENTIFIER=%s", _prefix.c_str(),
+                    NULL); // Using NULL is necessary for EL7, see #293
+}
+
+#endif

data/ext/ice/cpp/src/Ice/SystemdJournalI.h

@@ -0,0 +1,39 @@
+//
+// Copyright (c) ZeroC, Inc. All rights reserved.
+//
+
+#ifndef ICE_SYSTEMD_JOURNAL_I_H
+#define ICE_SYSTEMD_JOURNAL_I_H
+
+#ifdef ICE_USE_SYSTEMD
+
+#include <Ice/Logger.h>
+
+namespace Ice
+{
+
+class SystemdJournalI : public Logger
+{
+public:
+
+    SystemdJournalI(const std::string&);
+
+    virtual void print(const std::string&);
+    virtual void trace(const std::string&, const std::string&);
+    virtual void warning(const std::string&);
+    virtual void error(const std::string&);
+    virtual std::string getPrefix();
+    virtual LoggerPtr cloneWithPrefix(const std::string&);
+
+private:
+
+    void write(int, const std::string&) const;
+
+    const std::string _prefix;
+};
+
+}
+
+#endif
+
+#endif

data/ext/ice/cpp/src/Ice/TcpAcceptor.cpp

@@ -1,11 +1,10 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) ZeroC, Inc. All rights reserved.
 //
-// This copy of Ice is licensed to you under the terms described in the
-// ICE_LICENSE file included in this distribution.
-//
-// **********************************************************************
+
+#include <Ice/Config.h>
+
+#if !defined(__APPLE__) || TARGET_OS_IPHONE == 0
 
 #include <Ice/TcpAcceptor.h>
 #include <Ice/TcpTransceiver.h>
@@ -17,8 +16,21 @@
 #include <Ice/StreamSocket.h>
 #include <IceUtil/StringUtil.h>
 
-#ifdef ICE_USE_IOCP
+#if defined(ICE_USE_IOCP)
 #  include <Mswsock.h>
+#elif defined(ICE_OS_UWP)
+using namespace Platform;
+using namespace Windows::Foundation;
+using namespace Windows::Storage::Streams;
+using namespace Windows::Networking;
+using namespace Windows::Networking::Sockets;
+#endif
+
+//
+// Use the system default for the listen() backlog or 511 if not defined.
+//
+#ifndef SOMAXCONN
+#  define SOMAXCONN 511
 #endif
 
 using namespace std;
@@ -33,22 +45,35 @@ IceInternal::TcpAcceptor::getNativeInfo()
     return this;
 }
 
-#ifdef ICE_USE_IOCP
-AsyncInfo*
-#  ifndef NDEBUG
-IceInternal::TcpAcceptor::getAsyncInfo(SocketOperation op)
-#  else
-IceInternal::TcpAcceptor::getAsyncInfo(SocketOperation)
-#  endif
-{
-    assert(op == SocketOperationRead);
-    return &_info;
-}
-#endif
-
 void
 IceInternal::TcpAcceptor::close()
 {
+#if defined(ICE_OS_UWP)
+    IceUtil::Mutex::Lock lock(_mutex);
+    if(_acceptPending)
+    {
+        assert(_accepted.empty());
+        completed(SocketOperationRead);
+        _acceptPending = false;
+    }
+    else if(!_accepted.empty())
+    {
+        for(deque<Windows::Networking::Sockets::StreamSocket^>::const_iterator p = _accepted.begin();
+            p != _accepted.end(); ++p)
+        {
+            closeSocket(*p);
+        }
+        _accepted.clear();
+    }
+#endif
+
+#if defined(ICE_USE_IOCP)
+    if(_acceptFd != INVALID_SOCKET)
+    {
+        closeSocketNoThrow(_acceptFd);
+        _acceptFd = INVALID_SOCKET;
+    }
+#endif
     if(_fd != INVALID_SOCKET)
     {
         closeSocketNoThrow(_fd);
@@ -62,7 +87,9 @@ IceInternal::TcpAcceptor::listen()
     try
     {
         const_cast<Address&>(_addr) = doBind(_fd, _addr);
+#if !defined(ICE_OS_UWP)
         doListen(_fd, _backlog);
+#endif
     }
     catch(...)
     {
@@ -73,11 +100,18 @@ IceInternal::TcpAcceptor::listen()
     return _endpoint;
 }
 
-#ifdef ICE_USE_IOCP
+#if defined(ICE_USE_IOCP)
+
+AsyncInfo*
+IceInternal::TcpAcceptor::getAsyncInfo(SocketOperation)
+{
+    return &_info;
+}
+
 void
 IceInternal::TcpAcceptor::startAccept()
 {
-    LPFN_ACCEPTEX AcceptEx = NULL; // a pointer to the 'AcceptEx()' function
+    LPFN_ACCEPTEX AcceptEx = ICE_NULLPTR; // a pointer to the 'AcceptEx()' function
     GUID GuidAcceptEx = WSAID_ACCEPTEX; // The Guid
     DWORD dwBytes;
     if(WSAIoctl(_fd,
@@ -87,24 +121,21 @@ IceInternal::TcpAcceptor::startAccept()
                 &AcceptEx,
                 sizeof(AcceptEx),
                 &dwBytes,
-                NULL,
-                NULL) == SOCKET_ERROR)
+                ICE_NULLPTR,
+                ICE_NULLPTR) == SOCKET_ERROR)
     {
-        SocketException ex(__FILE__, __LINE__);
-        ex.error = getSocketErrno();
-        throw ex;
+        throw SocketException(__FILE__, __LINE__, getSocketErrno());
     }
 
     assert(_acceptFd == INVALID_SOCKET);
     _acceptFd = createSocket(false, _addr);
     const int sz = static_cast<int>(_acceptBuf.size() / 2);
+    _info.error = ERROR_SUCCESS;
     if(!AcceptEx(_fd, _acceptFd, &_acceptBuf[0], 0, sz, sz, &_info.count, &_info))
     {
         if(!wouldBlock())
         {
-            SocketException ex(__FILE__, __LINE__);
-            ex.error = getSocketErrno();
-            throw ex;
+            throw SocketException(__FILE__, __LINE__, getSocketErrno());
         }
     }
 }
@@ -112,7 +143,7 @@ IceInternal::TcpAcceptor::startAccept()
 void
 IceInternal::TcpAcceptor::finishAccept()
 {
-    if(static_cast<int>(_info.count) == SOCKET_ERROR || _fd == INVALID_SOCKET)
+    if(_info.error != ERROR_SUCCESS || _fd == INVALID_SOCKET)
     {
         closeSocketNoThrow(_acceptFd);
         _acceptFd = INVALID_SOCKET;
@@ -120,37 +151,99 @@ IceInternal::TcpAcceptor::finishAccept()
     }
 }
 
-#endif
-
 TransceiverPtr
 IceInternal::TcpAcceptor::accept()
 {
-#ifdef ICE_USE_IOCP
     if(_acceptFd == INVALID_SOCKET)
     {
-        SocketException ex(__FILE__, __LINE__);
-        ex.error = _acceptError;
-        throw ex;
+        throw SocketException(__FILE__, __LINE__, _acceptError);
     }
     if(setsockopt(_acceptFd, SOL_SOCKET, SO_UPDATE_ACCEPT_CONTEXT, (char*)&_acceptFd, sizeof(_acceptFd)) ==
        SOCKET_ERROR)
     {
         closeSocketNoThrow(_acceptFd);
         _acceptFd = INVALID_SOCKET;
-        SocketException ex(__FILE__, __LINE__);
-        ex.error = getSocketErrno();
-        throw ex;
+        throw SocketException(__FILE__, __LINE__, getSocketErrno());
     }
 
     SOCKET fd = _acceptFd;
     _acceptFd = INVALID_SOCKET;
-#else
-    SOCKET fd = doAccept(_fd);
-#endif
+    return new TcpTransceiver(_instance, new StreamSocket(_instance, fd));
+}
+
+#elif defined(ICE_OS_UWP)
+
+AsyncInfo*
+IceInternal::TcpAcceptor::getAsyncInfo(SocketOperation)
+{
+    return 0; // Not used
+}
+
+void
+IceInternal::TcpAcceptor::startAccept()
+{
+    assert(_fd != INVALID_SOCKET);
+
+    //
+    // If there are already sockets waiting to be accepted, we just
+    // notify the selector that the acceptor is ready for acceting the
+    // new socket. Otherwise, we set the _acceptPending flag, when a
+    // new socket connection event is received, the message handler
+    // will notify the selector.
+    //
+    IceUtil::Mutex::Lock lock(_mutex);
+    assert(!_acceptPending);
+    if(!_accepted.empty())
+    {
+        completed(SocketOperationRead);
+    }
+    else
+    {
+        _acceptPending = true;
+    }
+}
+
+void
+IceInternal::TcpAcceptor::finishAccept()
+{
+    //
+    // Nothing to do, we just check there's at least one accepted
+    // socket or the acceptor was closed.
+    //
+    IceUtil::Mutex::Lock lock(_mutex);
+    assert(!_acceptPending && (!_accepted.empty() || _fd == INVALID_SOCKET));
+}
+
+TransceiverPtr
+IceInternal::TcpAcceptor::accept()
+{
+    if(_fd == INVALID_SOCKET) // Acceptor closed.
+    {
+        assert(_accepted.empty());
+        throw SocketException(__FILE__, __LINE__);
+    }
+
+    Windows::Networking::Sockets::StreamSocket^ fd;
+    {
+        IceUtil::Mutex::Lock lock(_mutex);
+        assert(!_accepted.empty());
+        fd = _accepted.front();
+        _accepted.pop_front();
+    }
 
     return new TcpTransceiver(_instance, new StreamSocket(_instance, fd));
 }
 
+#else
+
+TransceiverPtr
+IceInternal::TcpAcceptor::accept()
+{
+    return new TcpTransceiver(_instance, new StreamSocket(_instance, doAccept(_fd)));
+}
+
+#endif
+
 string
 IceInternal::TcpAcceptor::protocol() const
 {
@@ -189,25 +282,51 @@ IceInternal::TcpAcceptor::TcpAcceptor(const TcpEndpointIPtr& endpoint,
                                       int port) :
     _endpoint(endpoint),
     _instance(instance),
-    _addr(getAddressForServer(host, port, _instance->protocolSupport(), instance->preferIPv6()))
+    _addr(getAddressForServer(host, port, _instance->protocolSupport(), instance->preferIPv6(), true))
 #ifdef ICE_USE_IOCP
-    , _acceptFd(INVALID_SOCKET),
-    _info(SocketOperationRead)
+    , _acceptFd(INVALID_SOCKET), _info(SocketOperationRead)
 #endif
 {
-#ifdef SOMAXCONN
     _backlog = instance->properties()->getPropertyAsIntWithDefault("Ice.TCP.Backlog", SOMAXCONN);
+
+#if defined(ICE_OS_UWP)
+    _fd = ref new StreamSocketListener();
+    safe_cast<StreamSocketListener^>(_fd)->ConnectionReceived +=
+        ref new TypedEventHandler<StreamSocketListener^, StreamSocketListenerConnectionReceivedEventArgs^>(
+            [=](StreamSocketListener^, StreamSocketListenerConnectionReceivedEventArgs^ args)
+                {
+                    IceUtil::Mutex::Lock lock(_mutex);
+                    if(_fd == INVALID_SOCKET) // Acceptor was closed.
+                    {
+                        closeSocket(args->Socket);
+                        return;
+                    }
+                    _accepted.push_back(args->Socket);
+
+                    //
+                    // If the acceptor is waiting for a socket to be accepted, notify
+                    // the selector that the acceptor is ready for "read". This will
+                    // in turn caused finishAccept() and accept() to be called by the
+                    // thread pool. If the acceptor isn't ready to accept the socket,
+                    // it is just queued, when startAccept is called it will be dequed.
+                    //
+                    if(_acceptPending)
+                    {
+                        completed(SocketOperationRead);
+                        _acceptPending = false;
+                    }
+                });
 #else
-    _backlog = instance->properties()->getPropertyAsIntWithDefault("Ice.TCP.Backlog", 511);
+    _fd = createServerSocket(false, _addr, instance->protocolSupport());
 #endif
 
-    _fd = createServerSocket(false, _addr, instance->protocolSupport());
 #ifdef ICE_USE_IOCP
     _acceptBuf.resize((sizeof(sockaddr_storage) + 16) * 2);
 #endif
 
     setBlock(_fd, false);
     setTcpBufSize(_fd, _instance);
+
 #ifndef _WIN32
     //
     // Enable SO_REUSEADDR on Unix platforms to allow re-using the
@@ -233,3 +352,4 @@ IceInternal::TcpAcceptor::~TcpAcceptor()
 #endif
 }
 
+#endif