zeroc-ice 3.6.5 → 3.7.4

data/ext/ice/cpp/src/Ice/HashUtil.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_HASH_UTIL_H
 #define ICE_HASH_UTIL_H
@@ -16,7 +11,7 @@ namespace IceInternal
 inline void
 hashAdd(Ice::Int& hashCode, Ice::Int value)
 {
-    hashCode = ((hashCode << 5) + hashCode) ^ (2654435761u * value);
+    hashCode = ((hashCode << 5) + hashCode) ^ static_cast<Ice::Int>(2654435761u) * value;
 }
 
 inline void
@@ -31,7 +26,7 @@ hashAdd(Ice::Int& hashCode, const std::string& value)
     for(std::string::const_iterator p = value.begin(); p != value.end(); ++p)
     {
         hashCode = ((hashCode << 5) + hashCode) ^ *p;
-    }    
+    }
 }
 
 template<typename T> void
@@ -56,4 +51,3 @@ hashAdd(Ice::Int& hashCode, const std::map& map)
 }
 
 #endif
-

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

@@ -1,15 +1,9 @@
-// **********************************************************************
 //
-// 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 <IceUtil/Config.h>
 #include <Ice/HttpParser.h>
-#include <Ice/BasicStream.h>
 #include <Ice/LocalException.h>
 #include <IceUtil/StringUtil.h>
 

data/ext/ice/cpp/src/Ice/HttpParser.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_HTTP_PARSER_H
 #define ICE_HTTP_PARSER_H

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

@@ -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.
-//
-// **********************************************************************
 
 #include <Ice/IPEndpointI.h>
 #include <Ice/ProtocolInstance.h>
@@ -18,6 +13,7 @@
 #include <IceUtil/MutexPtrLock.h>
 
 using namespace std;
+using namespace Ice;
 using namespace Ice::Instrumentation;
 using namespace IceInternal;
 
@@ -46,7 +42,9 @@ Init init;
 
 }
 
+#ifndef ICE_CPP11_MAPPING
 IceUtil::Shared* IceInternal::upCast(IPEndpointI* p) { return p; }
+#endif
 IceUtil::Shared* IceInternal::upCast(EndpointHostResolver* p) { return p; }
 
 IceInternal::IPEndpointInfoI::IPEndpointInfoI(const EndpointIPtr& endpoint) : _endpoint(endpoint)
@@ -58,32 +56,31 @@ IceInternal::IPEndpointInfoI::~IPEndpointInfoI()
 }
 
 Ice::Short
-IceInternal::IPEndpointInfoI::type() const
+IceInternal::IPEndpointInfoI::type() const ICE_NOEXCEPT
 {
     return _endpoint->type();
 }
 
 bool
-IceInternal::IPEndpointInfoI::datagram() const
+IceInternal::IPEndpointInfoI::datagram() const ICE_NOEXCEPT
 {
     return _endpoint->datagram();
 }
 
 bool
-IceInternal::IPEndpointInfoI::secure() const
+IceInternal::IPEndpointInfoI::secure() const ICE_NOEXCEPT
 {
     return _endpoint->secure();
 }
 
 Ice::EndpointInfoPtr
-IceInternal::IPEndpointI::getInfo() const
+IceInternal::IPEndpointI::getInfo() const ICE_NOEXCEPT
 {
-    Ice::IPEndpointInfoPtr info = new IPEndpointInfoI(const_cast<IPEndpointI*>(this));
+    Ice::IPEndpointInfoPtr info = ICE_MAKE_SHARED(IPEndpointInfoI, ICE_SHARED_FROM_CONST_THIS(IPEndpointI));
     fillEndpointInfo(info.get());
     return info;
 }
 
-
 Ice::Short
 IceInternal::IPEndpointI::type() const
 {
@@ -103,11 +100,10 @@ IceInternal::IPEndpointI::secure() const
 }
 
 void
-IceInternal::IPEndpointI::streamWrite(BasicStream* s) const
+IceInternal::IPEndpointI::streamWriteImpl(OutputStream* s) const
 {
-    s->startWriteEncaps();
-    streamWriteImpl(s);
-    s->endWriteEncaps();
+    s->write(_host, false);
+    s->write(_port);
 }
 
 const string&
@@ -121,7 +117,7 @@ IceInternal::IPEndpointI::connectionId(const string& connectionId) const
 {
     if(connectionId == _connectionId)
     {
-        return const_cast<IPEndpointI*>(this);
+        return ICE_SHARED_FROM_CONST_THIS(IPEndpointI);
     }
     else
     {
@@ -129,32 +125,20 @@ IceInternal::IPEndpointI::connectionId(const string& connectionId) const
     }
 }
 
-const std::string&
-IceInternal::IPEndpointI::host() const
-{
-    return _host;
-}
-
-int
-IceInternal::IPEndpointI::port() const
-{
-    return _port;
-}
-
 void
 IceInternal::IPEndpointI::connectors_async(Ice::EndpointSelectionType selType, const EndpointI_connectorsPtr& cb) const
 {
-    _instance->resolve(_host, _port, selType, const_cast<IPEndpointI*>(this), cb);
+    _instance->resolve(_host, _port, selType, ICE_SHARED_FROM_CONST_THIS(IPEndpointI), cb);
 }
 
 vector<EndpointIPtr>
-IceInternal::IPEndpointI::expand() const
+IceInternal::IPEndpointI::expandIfWildcard() const
 {
     vector<EndpointIPtr> endps;
     vector<string> hosts = getHostsForEndpointExpand(_host, _instance->protocolSupport(), false);
     if(hosts.empty())
     {
-        endps.push_back(const_cast<IPEndpointI*>(this));
+        endps.push_back(ICE_SHARED_FROM_CONST_THIS(IPEndpointI));
     }
     else
     {
@@ -166,6 +150,55 @@ IceInternal::IPEndpointI::expand() const
     return endps;
 }
 
+vector<EndpointIPtr>
+IceInternal::IPEndpointI::expandHost(EndpointIPtr& publish) const
+{
+    //
+    // If this endpoint has an empty host (wildcard address), don't expand, just return
+    // this endpoint.
+    //
+    if(_host.empty())
+    {
+        vector<EndpointIPtr> endpoints;
+        endpoints.push_back(ICE_SHARED_FROM_CONST_THIS(IPEndpointI));
+        return endpoints;
+    }
+
+    //
+    // If using a fixed port, this endpoint can be used as the published endpoint to
+    // access the returned endpoints. Otherwise, we'll publish each individual expanded
+    // endpoint.
+    //
+    if(_port > 0)
+    {
+        publish = ICE_SHARED_FROM_CONST_THIS(IPEndpointI);
+    }
+
+    vector<Address> addrs = getAddresses(_host,
+                                         _port,
+                                         _instance->protocolSupport(),
+                                         Ice::ICE_ENUM(EndpointSelectionType, Ordered),
+                                         _instance->preferIPv6(),
+                                         true);
+
+    vector<EndpointIPtr> endpoints;
+    if(addrs.size() == 1)
+    {
+        endpoints.push_back(ICE_SHARED_FROM_CONST_THIS(IPEndpointI));
+    }
+    else
+    {
+        for(vector<Address>::const_iterator p = addrs.begin(); p != addrs.end(); ++p)
+        {
+            string host;
+            int port;
+            addrToAddressAndPort(*p, host, port);
+            endpoints.push_back(createEndpoint(host, port, _connectionId));
+        }
+    }
+    return endpoints;
+}
+
 bool
 IceInternal::IPEndpointI::equivalent(const EndpointIPtr& endpoint) const
 {
@@ -222,14 +255,29 @@ IceInternal::IPEndpointI::options() const
 
     if(isAddressValid(_sourceAddr))
     {
-        s << " --sourceAddress " << inetAddrToString(_sourceAddr);
+        const string sourceAddr = inetAddrToString(_sourceAddr);
+        bool addQuote = sourceAddr.find(':') != string::npos;
+        s << " --sourceAddress ";
+        if(addQuote)
+        {
+            s << "\"";
+        }
+        s << sourceAddr;
+        if(addQuote)
+        {
+            s << "\"";
+        }
     }
 
     return s.str();
 }
 
 bool
+#ifdef ICE_CPP11_MAPPING
+IceInternal::IPEndpointI::operator==(const Endpoint& r) const
+#else
 IceInternal::IPEndpointI::operator==(const LocalObject& r) const
+#endif
 {
     const IPEndpointI* p = dynamic_cast<const IPEndpointI*>(&r);
     if(!p)
@@ -261,12 +309,15 @@ IceInternal::IPEndpointI::operator==(const LocalObject& r) const
     {
         return false;
     }
-
     return true;
 }
 
 bool
+#ifdef ICE_CPP11_MAPPING
+IceInternal::IPEndpointI::operator<(const Endpoint& r) const
+#else
 IceInternal::IPEndpointI::operator<(const LocalObject& r) const
+#endif
 {
     const IPEndpointI* p = dynamic_cast<const IPEndpointI*>(&r);
     if(!p)
@@ -344,13 +395,6 @@ IceInternal::IPEndpointI::connectors(const vector& addresses, const Net
     return connectors;
 }
 
-void
-IceInternal::IPEndpointI::streamWriteImpl(BasicStream* s) const
-{
-    s->write(_host, false);
-    s->write(_port);
-}
-
 void
 IceInternal::IPEndpointI::hashInit(Ice::Int& h) const
 {
@@ -388,9 +432,8 @@ IceInternal::IPEndpointI::initWithOptions(vector& args, bool oaEndpoint)
         }
         else
         {
-            Ice::EndpointParseException ex(__FILE__, __LINE__);
-            ex.str = "`-h *' not valid for proxy endpoint `" + toString() + "'";
-            throw ex;
+            throw Ice::EndpointParseException(__FILE__, __LINE__, "`-h *' not valid for proxy endpoint `" + toString() +
+                                              "'");
         }
     }
 
@@ -398,9 +441,9 @@ IceInternal::IPEndpointI::initWithOptions(vector& args, bool oaEndpoint)
     {
         if(oaEndpoint)
         {
-            Ice::EndpointParseException ex(__FILE__, __LINE__);
-            ex.str = "`--sourceAddress' not valid for object adapter endpoint `" + toString() + "'";
-            throw ex;
+            throw Ice::EndpointParseException(__FILE__, __LINE__,
+                                              "`--sourceAddress' not valid for object adapter endpoint `" + toString() +
+                                              "'");
         }
     }
     else if(!oaEndpoint)
@@ -416,9 +459,8 @@ IceInternal::IPEndpointI::checkOption(const string& option, const string& argume
     {
         if(argument.empty())
         {
-            Ice::EndpointParseException ex(__FILE__, __LINE__);
-            ex.str = "no argument provided for -h option in endpoint " + endpoint;
-            throw ex;
+            throw Ice::EndpointParseException(__FILE__, __LINE__, "no argument provided for -h option in endpoint " +
+                                              endpoint);
         }
         const_cast<string&>(_host) = argument;
     }
@@ -426,39 +468,36 @@ IceInternal::IPEndpointI::checkOption(const string& option, const string& argume
     {
         if(argument.empty())
         {
-            Ice::EndpointParseException ex(__FILE__, __LINE__);
-            ex.str = "no argument provided for -p option in endpoint " + endpoint;
-            throw ex;
+            throw Ice::EndpointParseException(__FILE__, __LINE__, "no argument provided for -p option in endpoint " +
+                                              endpoint);
         }
         istringstream p(argument);
         if(!(p >> const_cast<Ice::Int&>(_port)) || !p.eof())
         {
-            Ice::EndpointParseException ex(__FILE__, __LINE__);
-            ex.str = "invalid port value `" + argument + "' in endpoint " + endpoint;
-            throw ex;
+            throw Ice::EndpointParseException(__FILE__, __LINE__, "invalid port value `" + argument + "' in endpoint " +
+                                              endpoint);
         }
         else if(_port < 0 || _port > 65535)
         {
-            Ice::EndpointParseException ex(__FILE__, __LINE__);
-            ex.str = "port value `" + argument + "' out of range in endpoint " + endpoint;
-            throw ex;
+            throw Ice::EndpointParseException(__FILE__, __LINE__, "port value `" + argument +
+                                              "' out of range in endpoint " + endpoint);
         }
     }
     else if(option == "--sourceAddress")
     {
         if(argument.empty())
         {
-            Ice::EndpointParseException ex(__FILE__, __LINE__);
-            ex.str = "no argument provided for --sourceAddress option in endpoint " + endpoint;
-            throw ex;
+            throw Ice::EndpointParseException(__FILE__, __LINE__,
+                                              "no argument provided for --sourceAddress option in endpoint " +
+                                              endpoint);
         }
-#ifndef ICE_OS_WINRT
+#ifndef ICE_OS_UWP
         const_cast<Address&>(_sourceAddr) = getNumericAddress(argument);
         if(!isAddressValid(_sourceAddr))
         {
-            Ice::EndpointParseException ex(__FILE__, __LINE__);
-            ex.str = "invalid IP address provided for --sourceAddress option in endpoint " + endpoint;
-            throw ex;
+            throw Ice::EndpointParseException(__FILE__, __LINE__,
+                                              "invalid IP address provided for --sourceAddress option in endpoint " +
+                                              endpoint);
         }
 #endif
     }
@@ -487,7 +526,7 @@ IceInternal::IPEndpointI::IPEndpointI(const ProtocolInstancePtr& instance) :
 {
 }
 
-IceInternal::IPEndpointI::IPEndpointI(const ProtocolInstancePtr& instance, BasicStream* s) :
+IceInternal::IPEndpointI::IPEndpointI(const ProtocolInstancePtr& instance, InputStream* s) :
     _instance(instance),
     _port(0),
     _hashInitialized(false)
@@ -496,7 +535,7 @@ IceInternal::IPEndpointI::IPEndpointI(const ProtocolInstancePtr& instance, Basic
     s->read(const_cast<Ice::Int&>(_port));
 }
 
-#ifndef ICE_OS_WINRT
+#ifndef ICE_OS_UWP
 
 IceInternal::EndpointHostResolver::EndpointHostResolver(const InstancePtr& instance) :
     IceUtil::Thread("Ice.HostResolver"),
@@ -505,30 +544,7 @@ IceInternal::EndpointHostResolver::EndpointHostResolver(const InstancePtr& insta
     _preferIPv6(instance->preferIPv6()),
     _destroyed(false)
 {
-    __setNoDelete(true);
-    try
-    {
-        updateObserver();
-        bool hasPriority = _instance->initializationData().properties->getProperty("Ice.ThreadPriority") != "";
-        int priority = _instance->initializationData().properties->getPropertyAsInt("Ice.ThreadPriority");
-        if(hasPriority)
-        {
-            start(0, priority);
-        }
-        else
-        {
-            start();
-        }
-    }
-    catch(const IceUtil::Exception& ex)
-    {
-        {
-            Ice::Error out(_instance->initializationData().logger);
-            out << "cannot create thread for enpoint host resolver:\n" << ex;
-        }
-        throw;
-    }
-    __setNoDelete(false);
+    updateObserver();
 }
 
 void
@@ -617,7 +633,7 @@ IceInternal::EndpointHostResolver::run()
 
         if(threadObserver)
         {
-            threadObserver->stateChanged(ThreadStateIdle, ThreadStateInUseForOther);
+            threadObserver->stateChanged(ICE_ENUM(ThreadState, ThreadStateIdle), ICE_ENUM(ThreadState, ThreadStateInUseForOther));
         }
 
         try
@@ -633,33 +649,32 @@ IceInternal::EndpointHostResolver::run()
                 }
             }
 
-            r.callback->connectors(r.endpoint->connectors(getAddresses(r.host,
-                                                                       r.port,
-                                                                       protocol,
-                                                                       r.selType,
-                                                                       _preferIPv6,
-                                                                       true),
-                                                          networkProxy));
-
-            if(threadObserver)
+            vector<Address> addresses = getAddresses(r.host, r.port, protocol, r.selType, _preferIPv6, true);
+            if(r.observer)
             {
-                threadObserver->stateChanged(ThreadStateInUseForOther, ThreadStateIdle);
+                r.observer->detach();
+                r.observer = 0;
             }
 
-            if(r.observer)
+            r.callback->connectors(r.endpoint->connectors(addresses, networkProxy));
+
+            if(threadObserver)
             {
-                r.observer->detach();
+                threadObserver->stateChanged(ICE_ENUM(ThreadState, ThreadStateInUseForOther),
+                                             ICE_ENUM(ThreadState, ThreadStateIdle));
             }
+
         }
         catch(const Ice::LocalException& ex)
         {
             if(threadObserver)
             {
-                threadObserver->stateChanged(ThreadStateInUseForOther, ThreadStateIdle);
+                threadObserver->stateChanged(ICE_ENUM(ThreadState, ThreadStateInUseForOther),
+                                             ICE_ENUM(ThreadState, ThreadStateIdle));
             }
             if(r.observer)
             {
-                r.observer->failed(ex.ice_name());
+                r.observer->failed(ex.ice_id());
                 r.observer->detach();
             }
             r.callback->exception(ex);
@@ -671,7 +686,7 @@ IceInternal::EndpointHostResolver::run()
         Ice::CommunicatorDestroyedException ex(__FILE__, __LINE__);
         if(p->observer)
         {
-            p->observer->failed(ex.ice_name());
+            p->observer->failed(ex.ice_id());
             p->observer->detach();
         }
         p->callback->exception(ex);
@@ -691,7 +706,10 @@ IceInternal::EndpointHostResolver::updateObserver()
     const CommunicatorObserverPtr& obsv = _instance->initializationData().observer;
     if(obsv)
     {
-        _observer.attach(obsv->getThreadObserver("Communicator", name(), ThreadStateIdle, _observer.get()));
+        _observer.attach(obsv->getThreadObserver("Communicator",
+                                                 name(),
+                                                 ICE_ENUM(ThreadState, ThreadStateIdle),
+                                                 _observer.get()));
     }
 }
 
@@ -702,7 +720,6 @@ IceInternal::EndpointHostResolver::EndpointHostResolver(const InstancePtr& insta
 {
 }
 
-
 void
 IceInternal::EndpointHostResolver::resolve(const string& host,
                                            int port,
@@ -711,7 +728,7 @@ IceInternal::EndpointHostResolver::resolve(const string& host,
                                            const EndpointI_connectorsPtr& callback)
 {
     //
-    // No DNS lookup support with WinRT.
+    // No DNS lookup support with UWP.
     //
     callback->connectors(endpoint->connectors(getAddresses(host, port,
                                                            _instance->protocolSupport(),