zeroc-ice 3.6b1

data/ext/ice/cpp/src/IceDiscovery/LookupI.h

@@ -0,0 +1,183 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 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 LOOKUPI_H
+#define LOOKUPI_H
+
+#include <IceDiscovery/IceDiscovery.h>
+#include <IceDiscovery/LocatorI.h>
+
+#include <IceUtil/Timer.h>
+#include <Ice/Properties.h>
+
+namespace IceDiscovery
+{
+
+class LookupI;
+
+class Request : public IceUtil::TimerTask
+{
+public:
+
+    Request(const LookupIPtr&, int);
+
+    virtual bool retry();
+
+protected:
+
+    LookupIPtr _lookup;
+    int _nRetry;
+};
+
+template<class T, class CB> class RequestT : public Request
+{
+public:
+    
+    RequestT(LookupI* lookup, T id, int retryCount) : Request(lookup, retryCount), _id(id)
+    {
+    }
+
+    T getId() const
+    {
+        return _id;
+    }
+
+    bool addCallback(CB cb)
+    {
+        _callbacks.push_back(cb);
+        return _callbacks.size() == 1;
+    }
+
+    virtual void finished(const Ice::ObjectPrx& proxy)
+    {
+        for(typename std::vector<CB>::const_iterator p = _callbacks.begin(); p != _callbacks.end(); ++p)
+        {
+            (*p)->ice_response(proxy);
+        }
+        _callbacks.clear();
+    }
+
+protected:
+
+    const T _id;
+    std::vector<CB> _callbacks;
+};
+
+class ObjectRequest : public RequestT<Ice::Identity, Ice::AMD_Locator_findObjectByIdPtr>
+{
+public:
+
+    ObjectRequest(LookupI* lookup, const Ice::Identity& id, int retryCount) : 
+        RequestT<Ice::Identity, Ice::AMD_Locator_findObjectByIdPtr>(lookup, id, retryCount)
+    {
+    }
+
+    void response(const Ice::ObjectPrx&);
+
+private:
+
+    virtual void runTimerTask();
+};
+typedef IceUtil::Handle<ObjectRequest> ObjectRequestPtr;
+
+class AdapterRequest : public RequestT<std::string, Ice::AMD_Locator_findAdapterByIdPtr>
+{
+public:
+
+    AdapterRequest(LookupI* lookup, const std::string& adapterId, int retryCount) : 
+        RequestT<std::string, Ice::AMD_Locator_findAdapterByIdPtr>(lookup, adapterId, retryCount),
+        _start(IceUtil::Time::now())
+    {
+    }
+
+    bool response(const Ice::ObjectPrx&, bool);
+
+    virtual bool retry();
+    virtual void finished(const Ice::ObjectPrx&);
+
+private:
+
+    virtual void runTimerTask();
+    std::vector<Ice::ObjectPrx> _proxies;
+    IceUtil::Time _start;
+    IceUtil::Time _latency;
+};
+typedef IceUtil::Handle<AdapterRequest> AdapterRequestPtr;
+
+class LookupI : public Lookup, private IceUtil::Mutex
+{
+public:
+
+    LookupI(const LocatorRegistryIPtr&, const LookupPrx&, const Ice::PropertiesPtr&);
+    virtual ~LookupI();
+
+    void destroy();
+
+    void setLookupReply(const LookupReplyPrx&);
+
+    virtual void findObjectById(const std::string&, const Ice::Identity&, const IceDiscovery::LookupReplyPrx&, 
+                                const Ice::Current&);
+    virtual void findAdapterById(const std::string&, const std::string&, const IceDiscovery::LookupReplyPrx&, 
+                                 const Ice::Current&);
+
+    void findObject(const Ice::AMD_Locator_findObjectByIdPtr&, const Ice::Identity&);
+    void findAdapter(const Ice::AMD_Locator_findAdapterByIdPtr&, const std::string&);
+
+    void foundObject(const Ice::Identity&, const Ice::ObjectPrx&);
+    void foundAdapter(const std::string&, const Ice::ObjectPrx&, bool);
+
+    void adapterRequestTimedOut(const AdapterRequestPtr&);
+    void objectRequestTimedOut(const ObjectRequestPtr&);
+
+    const IceUtil::TimerPtr&
+    timer()
+    {
+        return _timer;
+    }
+
+    int
+    latencyMultiplier()
+    {
+        return _latencyMultiplier;
+    }
+
+private:
+
+    LocatorRegistryIPtr _registry;
+    const LookupPrx _lookup;
+    LookupReplyPrx _lookupReply;
+    const IceUtil::Time _timeout;
+    const int _retryCount;
+    const int _latencyMultiplier;
+    const std::string _domainId;
+
+    IceUtil::TimerPtr _timer;
+    Ice::ObjectPrx _wellKnownProxy;
+
+    std::map<Ice::Identity, ObjectRequestPtr> _objectRequests;
+    std::map<std::string, AdapterRequestPtr> _adapterRequests;
+};
+
+class LookupReplyI : public LookupReply
+{
+public:
+
+    LookupReplyI(const LookupIPtr&);
+
+    virtual void foundObjectById(const Ice::Identity&, const Ice::ObjectPrx&, const Ice::Current&);
+    virtual void foundAdapterById(const std::string&, const Ice::ObjectPrx&, bool, const Ice::Current&);
+
+private:
+
+    const LookupIPtr _lookup;
+};
+
+};
+
+#endif

data/ext/ice/cpp/src/IceDiscovery/Makefile

@@ -0,0 +1,61 @@
+# **********************************************************************
+#
+# Copyright (c) 2003-2014 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.
+#
+# **********************************************************************
+
+top_srcdir	= ../..
+
+LIBFILENAME     = $(call mklibfilename,IceDiscovery,$(VERSION))
+SONAME          = $(call mksoname,IceDiscovery,$(SOVERSION))
+LIBNAME		= $(call mklibname,IceDiscovery)
+
+TARGETS		= $(call mklibtargets,$(libdir)/$(LIBFILENAME),$(libdir)/$(SONAME),$(libdir)$(cpp11libdirsuffix)/$(LIBNAME))
+
+SLICE_OBJS      = IceDiscovery.o
+
+OBJS		= LocatorI.o \
+		  LookupI.o \
+		  PluginI.o \
+		  $(SLICE_OBJS)
+
+HDIR		= $(headerdir)/IceDiscovery
+SDIR		= $(slicedir)/IceDiscovery
+
+include $(top_srcdir)/config/Make.rules
+
+CPPFLAGS	:= -I.. $(CPPFLAGS)
+SLICE2CPPFLAGS	:= --ice --include-dir IceDiscovery $(SLICE2CPPFLAGS)
+
+LINKWITH        := -lIce -lIceUtil $(CXXLIBS)
+
+ifeq ($(STATICLIBS),yes)
+$(libdir)/$(LIBNAME): $(OBJS)
+	@mkdir -p $(dir $@)
+	rm -f $@
+	$(call mklib,$@,$(OBJS))
+else
+$(libdir)/$(LIBFILENAME): $(OBJS)
+	@mkdir -p $(dir $@)
+	rm -f $@
+	$(call mkshlib,$@,$(SONAME),$(OBJS),$(LINKWITH))
+
+$(libdir)/$(SONAME): $(libdir)/$(LIBFILENAME)
+	rm -f $@
+	ln -s $(LIBFILENAME) $@
+
+$(libdir)$(cpp11libdirsuffix)/$(LIBNAME): $(libdir)/$(SONAME)
+	@mkdir -p $(libdir)$(cpp11libdirsuffix)
+	rm -f $@
+	ln -s $(cpp11sonamedir)$(SONAME) $@
+endif
+
+../IceDiscovery/IceDiscovery.h IceDiscovery.cpp: $(slicedir)/IceDiscovery/IceDiscovery.ice $(SLICE2CPP) $(SLICEPARSERLIB)
+	rm -f IceDiscovery.h IceDiscovery.cpp
+	$(SLICE2CPP) $(SLICE2CPPFLAGS) $(slicedir)/IceDiscovery/IceDiscovery.ice
+
+install:: all
+	$(call installlib,$(DESTDIR)$(install_libdir),$(libdir),$(LIBFILENAME),$(SONAME),$(LIBNAME))

data/ext/ice/cpp/src/IceDiscovery/PluginI.cpp

@@ -0,0 +1,148 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 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/IceUtil.h>
+#include <Ice/Ice.h>
+
+#include <IceDiscovery/PluginI.h>
+#include <IceDiscovery/LocatorI.h>
+#include <IceDiscovery/LookupI.h>
+
+using namespace std;
+using namespace IceDiscovery;
+
+//
+// Plugin factory function.
+//
+extern "C"
+{
+
+ICE_DECLSPEC_EXPORT Ice::Plugin*
+createIceDiscovery(const Ice::CommunicatorPtr& communicator, const string&, const Ice::StringSeq&)
+{
+    return new PluginI(communicator);
+}
+
+}
+
+PluginI::PluginI(const Ice::CommunicatorPtr& communicator) : _communicator(communicator)
+{
+}
+
+void
+PluginI::initialize()
+{
+    Ice::PropertiesPtr properties = _communicator->getProperties();
+
+    bool ipv4 = properties->getPropertyAsIntWithDefault("Ice.IPv4", 1) > 0;
+    bool preferIPv6 = properties->getPropertyAsInt("Ice.PreferIPv6Address") > 0;
+    string address;
+    if(ipv4 && !preferIPv6)
+    {
+        address = properties->getPropertyWithDefault("IceDiscovery.Address", "239.255.0.1");
+    }
+    else
+    {
+        address = properties->getPropertyWithDefault("IceDiscovery.Address", "ff15::1");
+    }
+    int port = properties->getPropertyAsIntWithDefault("IceDiscovery.Port", 4061);
+    string interface = properties->getProperty("IceDiscovery.Interface");
+
+    if(properties->getProperty("IceDiscovery.Multicast.Endpoints").empty())
+    {
+        ostringstream os;
+        os << "udp -h \"" << address << "\" -p " << port;
+        if(!interface.empty())
+        {
+            os << " --interface \"" << interface << "\"";
+        }
+        properties->setProperty("IceDiscovery.Multicast.Endpoints", os.str());
+    }
+    if(properties->getProperty("IceDiscovery.Reply.Endpoints").empty())
+    {
+        ostringstream os;
+        os << "udp";
+        if(!interface.empty())
+        {
+            os << " -h \"" << interface << "\"";
+        }
+        properties->setProperty("IceDiscovery.Reply.Endpoints", os.str());
+    }
+    if(properties->getProperty("IceDiscovery.Locator.Endpoints").empty())
+    {
+        properties->setProperty("IceDiscovery.Locator.AdapterId", IceUtil::generateUUID());
+    }
+
+    _multicastAdapter = _communicator->createObjectAdapter("IceDiscovery.Multicast");
+    _replyAdapter = _communicator->createObjectAdapter("IceDiscovery.Reply");
+    _locatorAdapter = _communicator->createObjectAdapter("IceDiscovery.Locator");
+
+    //
+    // Setup locatory registry.
+    //
+    LocatorRegistryIPtr locatorRegistry = new LocatorRegistryI(_communicator);
+    Ice::LocatorRegistryPrx locatorRegistryPrx = 
+        Ice::LocatorRegistryPrx::uncheckedCast(_locatorAdapter->addWithUUID(locatorRegistry));
+
+    string lookupEndpoints = properties->getProperty("IceDiscovery.Lookup");
+    if(lookupEndpoints.empty())
+    {
+        ostringstream os;
+        os << "udp -h \"" << address << "\" -p " << port;
+        if(!interface.empty())
+        {
+            os << " --interface \"" << interface << "\"";
+        }
+        lookupEndpoints = os.str();
+    }
+
+    Ice::ObjectPrx lookupPrx = _communicator->stringToProxy("IceDiscovery/Lookup -d:" + lookupEndpoints);
+    lookupPrx = lookupPrx->ice_collocationOptimized(false); // No collocation optimization for the multicast proxy!
+    try
+    {
+        // Ensure we can establish a connection to the multicast proxy
+        lookupPrx->ice_getConnection();
+    }
+    catch(const Ice::LocalException& ex)
+    {
+        ostringstream os;
+        os << "unable to establish multicast connection, IceDiscovery will be disabled:\n";
+        os << "proxy = " << lookupPrx << '\n';
+        os << ex;
+        throw Ice::PluginInitializationException(__FILE__, __LINE__, os.str());
+    }
+
+    //
+    // Add lookup and lookup reply Ice objects
+    //
+    _lookup = new LookupI(locatorRegistry, LookupPrx::uncheckedCast(lookupPrx), properties);
+    _multicastAdapter->add(_lookup, _communicator->stringToIdentity("IceDiscovery/Lookup"));
+
+    Ice::ObjectPrx lookupReply = _replyAdapter->addWithUUID(new LookupReplyI(_lookup))->ice_datagram();
+    _lookup->setLookupReply(LookupReplyPrx::uncheckedCast(lookupReply));
+
+    //
+    // Setup locator on the communicator.
+    //
+    Ice::ObjectPrx loc = _locatorAdapter->addWithUUID(new LocatorI(_lookup, locatorRegistryPrx));
+    _communicator->setDefaultLocator(Ice::LocatorPrx::uncheckedCast(loc));
+    
+    _multicastAdapter->activate();
+    _replyAdapter->activate();
+    _locatorAdapter->activate();
+}
+
+void
+PluginI::destroy()
+{
+    _multicastAdapter->destroy();
+    _replyAdapter->destroy();
+    _locatorAdapter->destroy();
+    _lookup->destroy();
+}

data/ext/ice/cpp/src/IceDiscovery/PluginI.h

@@ -0,0 +1,39 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 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 PLUGIN_I_H
+#define PLUGIN_I_H
+
+#include <Ice/Plugin.h>
+#include <IceDiscovery/LookupI.h>
+
+namespace IceDiscovery
+{
+
+class PluginI : public Ice::Plugin
+{
+public:
+    
+    PluginI(const Ice::CommunicatorPtr&);
+
+    virtual void initialize();
+    virtual void destroy();
+
+private:
+
+    const Ice::CommunicatorPtr _communicator;
+    Ice::ObjectAdapterPtr _multicastAdapter;
+    Ice::ObjectAdapterPtr _replyAdapter;
+    Ice::ObjectAdapterPtr _locatorAdapter;
+    LookupIPtr _lookup;
+};
+
+};
+
+#endif

data/ext/ice/cpp/src/IceSSL/AcceptorI.cpp

@@ -0,0 +1,258 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 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 <IceSSL/AcceptorI.h>
+#include <IceSSL/EndpointI.h>
+#include <IceSSL/Instance.h>
+
+#include <IceSSL/OpenSSLTransceiverI.h>
+#include <IceSSL/SecureTransportTransceiverI.h>
+#include <IceSSL/SChannelTransceiverI.h>
+
+#include <IceSSL/Util.h>
+
+#include <Ice/Communicator.h>
+#include <Ice/Exception.h>
+#include <Ice/LocalException.h>
+#include <Ice/LoggerUtil.h>
+#include <Ice/Properties.h>
+#include <Ice/StreamSocket.h>
+#include <IceUtil/StringUtil.h>
+
+#ifdef ICE_USE_IOCP
+#  include <Mswsock.h>
+#endif
+
+using namespace std;
+using namespace Ice;
+using namespace IceSSL;
+
+IceUtil::Shared* IceSSL::upCast(AcceptorI* p) { return p; }
+
+IceInternal::NativeInfoPtr
+IceSSL::AcceptorI::getNativeInfo()
+{
+    return this;
+}
+
+
+#ifdef ICE_USE_IOCP
+IceInternal::AsyncInfo*
+IceSSL::AcceptorI::getAsyncInfo(IceInternal::SocketOperation)
+{
+    return &_info;
+}
+#endif
+
+void
+IceSSL::AcceptorI::close()
+{
+    SOCKET fd = _fd;
+    _fd = INVALID_SOCKET;
+    IceInternal::closeSocket(fd);
+}
+
+IceInternal::EndpointIPtr
+IceSSL::AcceptorI::listen()
+{
+    const_cast<IceInternal::Address&>(_addr) = IceInternal::doBind(_fd, _addr);
+
+    try
+    {
+        IceInternal::doListen(_fd, _backlog);
+    }
+    catch(...)
+    {
+        _fd = INVALID_SOCKET;
+        throw;
+    }
+
+    _endpoint = _endpoint->endpoint(this);
+    return _endpoint;
+}
+
+#ifdef ICE_USE_IOCP
+void
+IceSSL::AcceptorI::startAccept()
+{
+    LPFN_ACCEPTEX AcceptEx = NULL; // a pointer to the 'AcceptEx()' function
+    GUID GuidAcceptEx = WSAID_ACCEPTEX; // The Guid
+    DWORD dwBytes;
+    if(WSAIoctl(_fd,
+                SIO_GET_EXTENSION_FUNCTION_POINTER,
+                &GuidAcceptEx,
+                sizeof(GuidAcceptEx),
+                &AcceptEx,
+                sizeof(AcceptEx),
+                &dwBytes,
+                NULL,
+                NULL) == SOCKET_ERROR)
+    {
+        SocketException ex(__FILE__, __LINE__);
+        ex.error = IceInternal::getSocketErrno();
+        throw ex;
+    }
+
+    assert(_acceptFd == INVALID_SOCKET);
+    _acceptFd = IceInternal::createSocket(false, _addr);
+    const int sz = static_cast<int>(_acceptBuf.size() / 2);
+    if(!AcceptEx(_fd, _acceptFd, &_acceptBuf[0], 0, sz, sz, &_info.count, &_info))
+    {
+        if(!IceInternal::wouldBlock())
+        {
+            SocketException ex(__FILE__, __LINE__);
+            ex.error = IceInternal::getSocketErrno();
+            throw ex;
+        }
+    }
+}
+
+void
+IceSSL::AcceptorI::finishAccept()
+{
+    if(static_cast<int>(_info.count) == SOCKET_ERROR || _fd == INVALID_SOCKET)
+    {
+        IceInternal::closeSocketNoThrow(_acceptFd);
+        _acceptFd = INVALID_SOCKET;
+        _acceptError = _info.error;
+    }
+}
+#endif
+
+IceInternal::TransceiverPtr
+IceSSL::AcceptorI::accept()
+{
+    //
+    // The plug-in may not be initialized.
+    //
+    if(!_instance->initialized())
+    {
+        PluginInitializationException ex(__FILE__, __LINE__);
+        ex.reason = "IceSSL: plug-in is not initialized";
+        throw ex;
+    }
+
+#ifndef ICE_USE_IOCP
+    SOCKET fd = IceInternal::doAccept(_fd);
+#else
+    if(_acceptFd == INVALID_SOCKET)
+    {
+        SocketException ex(__FILE__, __LINE__);
+        ex.error = _acceptError;
+        throw ex;
+    }
+
+    if(setsockopt(_acceptFd, SOL_SOCKET, SO_UPDATE_ACCEPT_CONTEXT, (char*)&_acceptFd, sizeof(_acceptFd)) ==
+       SOCKET_ERROR)
+    {
+        IceInternal::closeSocketNoThrow(_acceptFd);
+        _acceptFd = INVALID_SOCKET;
+        SocketException ex(__FILE__, __LINE__);
+        ex.error = IceInternal::getSocketErrno();
+        throw ex;
+    }
+
+    SOCKET fd = _acceptFd;
+    _acceptFd = INVALID_SOCKET;
+#endif
+
+    //
+    // SSL handshaking is performed in TransceiverI::initialize, since
+    // accept must not block.
+    //
+    return new TransceiverI(_instance, new IceInternal::StreamSocket(_instance, fd), _adapterName, true);
+}
+
+string
+IceSSL::AcceptorI::protocol() const
+{
+    return _instance->protocol();
+}
+
+string
+IceSSL::AcceptorI::toString() const
+{
+    return IceInternal::addrToString(_addr);
+}
+
+string
+IceSSL::AcceptorI::toDetailedString() const
+{
+    ostringstream os;
+    os << "local address = " << toString();
+    vector<string> intfs = getHostsForEndpointExpand(inetAddrToString(_addr), _instance->protocolSupport(), true);
+    if(!intfs.empty())
+    {
+        os << "\nlocal interfaces = ";
+        os << IceUtilInternal::joinString(intfs, ", ");
+    }
+    return os.str();
+}
+
+int
+IceSSL::AcceptorI::effectivePort() const
+{
+    if(_addr.saStorage.ss_family == AF_INET)
+    {
+        return ntohs(_addr.saIn.sin_port);
+    }
+    else
+    {
+        return ntohs(_addr.saIn6.sin6_port);
+    }
+}
+
+IceSSL::AcceptorI::AcceptorI(const EndpointIPtr& endpoint, const InstancePtr& instance, const string& adapterName,
+                             const string& host, int port) :
+    _endpoint(endpoint),
+    _instance(instance),
+    _adapterName(adapterName),
+    _addr(IceInternal::getAddressForServer(host, port, instance->protocolSupport(), instance->preferIPv6()))
+#ifdef ICE_USE_IOCP
+    , _acceptFd(INVALID_SOCKET),
+    _info(IceInternal::SocketOperationRead)
+#endif
+{
+#ifdef SOMAXCONN
+    _backlog = instance->properties()->getPropertyAsIntWithDefault("Ice.TCP.Backlog", SOMAXCONN);
+#else
+    _backlog = instance->properties()->getPropertyAsIntWithDefault("Ice.TCP.Backlog", 511);
+#endif
+
+    IceInternal::ProtocolSupport protocol = instance->protocolSupport();
+    _fd = IceInternal::createServerSocket(false, _addr, protocol);
+#ifdef ICE_USE_IOCP
+    _acceptBuf.resize((sizeof(sockaddr_storage) + 16) * 2);
+#endif
+    IceInternal::setBlock(_fd, false);
+    IceInternal::setTcpBufSize(_fd, _instance->properties(), _instance->logger());
+#ifndef _WIN32
+    //
+    // Enable SO_REUSEADDR on Unix platforms to allow re-using the
+    // socket even if it's in the TIME_WAIT state. On Windows,
+    // this doesn't appear to be necessary and enabling
+    // SO_REUSEADDR would actually not be a good thing since it
+    // allows a second process to bind to an address even it's
+    // already bound by another process.
+    //
+    // TODO: using SO_EXCLUSIVEADDRUSE on Windows would probably
+    // be better but it's only supported by recent Windows
+    // versions (XP SP2, Windows Server 2003).
+    //
+    IceInternal::setReuseAddress(_fd, true);
+#endif
+}
+
+IceSSL::AcceptorI::~AcceptorI()
+{
+    assert(_fd == INVALID_SOCKET);
+#ifdef ICE_USE_IOCP
+    assert(_acceptFd == INVALID_SOCKET);
+#endif
+}