zeroc-ice 3.6.5 → 3.7.0

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

@@ -1,6 +1,6 @@
 // **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 2003-2017 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.
@@ -36,11 +36,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 +78,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,6 +1,6 @@
 // **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 2003-2017 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.
@@ -9,22 +9,53 @@
 
 #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 +109,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 +136,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 +182,7 @@ namespace Ice
 ICE_API void
 registerIceStringConverter(bool loadOnInitialize)
 {
-    Ice::registerPluginFactory("IceStringConverter", createStringConverter, loadOnInitialize);
+    registerPluginFactory("IceStringConverter", createStringConverter, loadOnInitialize);
 }
 
 }

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

@@ -0,0 +1,35 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2017 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_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,12 +1,14 @@
 // **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 2003-2017 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>
 #include <syslog.h>
@@ -109,7 +111,7 @@ Ice::SysLoggerI::SysLoggerI(const string& prefix, const string& facilityString)
     }
 
     int logopt = LOG_PID | LOG_CONS;
-    openlog(_prefix.c_str(), logopt, _facility);
+    openlog(prefix.c_str(), logopt, _facility);
 }
 
 Ice::SysLoggerI::SysLoggerI(const string& prefix, int facility) :
@@ -117,7 +119,7 @@ Ice::SysLoggerI::SysLoggerI(const string& prefix, int facility) :
     _prefix(prefix)
 {
     int logopt = LOG_PID | LOG_CONS;
-    openlog(_prefix.c_str(), logopt, facility);
+    openlog(prefix.c_str(), logopt, facility);
 }
 
 Ice::SysLoggerI::~SysLoggerI()
@@ -163,5 +165,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,6 +1,6 @@
 // **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 2003-2017 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.
@@ -21,6 +21,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 +33,6 @@ public:
 
 private:
 
-    SysLoggerI(const std::string&, int);
-
     int _facility;
     const std::string _prefix;
 };

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

@@ -1,6 +1,6 @@
 // **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 2003-2017 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.
@@ -17,8 +17,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 +46,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 +88,9 @@ IceInternal::TcpAcceptor::listen()
     try
     {
         const_cast<Address&>(_addr) = doBind(_fd, _addr);
+#if !defined(ICE_OS_UWP)
         doListen(_fd, _backlog);
+#endif
     }
     catch(...)
     {
@@ -73,11 +101,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,8 +122,8 @@ IceInternal::TcpAcceptor::startAccept()
                 &AcceptEx,
                 sizeof(AcceptEx),
                 &dwBytes,
-                NULL,
-                NULL) == SOCKET_ERROR)
+                ICE_NULLPTR,
+                ICE_NULLPTR) == SOCKET_ERROR)
     {
         SocketException ex(__FILE__, __LINE__);
         ex.error = getSocketErrno();
@@ -120,12 +155,9 @@ IceInternal::TcpAcceptor::finishAccept()
     }
 }
 
-#endif
-
 TransceiverPtr
 IceInternal::TcpAcceptor::accept()
 {
-#ifdef ICE_USE_IOCP
     if(_acceptFd == INVALID_SOCKET)
     {
         SocketException ex(__FILE__, __LINE__);
@@ -144,13 +176,82 @@ IceInternal::TcpAcceptor::accept()
 
     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 +290,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
@@ -232,4 +359,3 @@ IceInternal::TcpAcceptor::~TcpAcceptor()
     assert(_acceptFd == INVALID_SOCKET);
 #endif
 }
-