zeroc-ice 3.6b1

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

@@ -0,0 +1,67 @@
+// **********************************************************************
+//
+// 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 ICE_TCP_ACCEPTOR_H
+#define ICE_TCP_ACCEPTOR_H
+
+#include <Ice/TransceiverF.h>
+#include <Ice/ProtocolInstanceF.h>
+#include <Ice/Acceptor.h>
+#include <Ice/Network.h>
+
+namespace IceInternal
+{
+
+class TcpEndpoint;
+
+class TcpAcceptor : public Acceptor, public NativeInfo
+{
+public:
+
+    virtual NativeInfoPtr getNativeInfo();
+#ifdef ICE_USE_IOCP
+    virtual AsyncInfo* getAsyncInfo(SocketOperation);
+#endif
+
+    virtual void close();
+    virtual EndpointIPtr listen();
+#ifdef ICE_USE_IOCP
+    virtual void startAccept();
+    virtual void finishAccept();
+#endif
+
+    virtual TransceiverPtr accept();
+    virtual std::string protocol() const;
+    virtual std::string toString() const;
+    virtual std::string toDetailedString() const;
+
+    int effectivePort() const;
+
+private:
+
+    TcpAcceptor(const TcpEndpointIPtr&, const ProtocolInstancePtr&, const std::string&, int);
+    virtual ~TcpAcceptor();
+    friend class TcpEndpointI;
+
+    TcpEndpointIPtr _endpoint;
+    const ProtocolInstancePtr _instance;
+    const Address _addr;
+
+    int _backlog;
+#ifdef ICE_USE_IOCP
+    SOCKET _acceptFd;
+    int _acceptError;
+    std::vector<char> _acceptBuf;
+    AsyncInfo _info;
+#endif
+};
+
+}
+#endif
+

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

@@ -0,0 +1,133 @@
+// **********************************************************************
+//
+// 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 <Ice/TcpConnector.h>
+#include <Ice/TcpTransceiver.h>
+#include <Ice/TcpEndpointI.h>
+#include <Ice/ProtocolInstance.h>
+#include <Ice/LoggerUtil.h>
+#include <Ice/Network.h>
+#include <Ice/NetworkProxy.h>
+#include <Ice/StreamSocket.h>
+#include <Ice/Exception.h>
+
+using namespace std;
+using namespace Ice;
+using namespace IceInternal;
+
+TransceiverPtr
+IceInternal::TcpConnector::connect()
+{
+    return new TcpTransceiver(_instance, new StreamSocket(_instance, _proxy, _addr, _sourceAddr));
+}
+
+Short
+IceInternal::TcpConnector::type() const
+{
+    return _instance->type();
+}
+
+string
+IceInternal::TcpConnector::toString() const
+{
+    return addrToString(!_proxy ? _addr : _proxy->getAddress());
+}
+
+bool
+IceInternal::TcpConnector::operator==(const Connector& r) const
+{
+    const TcpConnector* p = dynamic_cast<const TcpConnector*>(&r);
+    if(!p)
+    {
+        return false;
+    }
+
+    if(compareAddress(_addr, p->_addr) != 0)
+    {
+        return false;
+    }
+
+    if(_timeout != p->_timeout)
+    {
+        return false;
+    }
+
+    if(compareAddress(_sourceAddr, p->_sourceAddr) != 0)
+    {
+        return false;
+    }
+
+    if(_connectionId != p->_connectionId)
+    {
+        return false;
+    }
+
+    return true;
+}
+
+bool
+IceInternal::TcpConnector::operator!=(const Connector& r) const
+{
+    return !operator==(r);
+}
+
+bool
+IceInternal::TcpConnector::operator<(const Connector& r) const
+{
+    const TcpConnector* p = dynamic_cast<const TcpConnector*>(&r);
+    if(!p)
+    {
+        return type() < r.type();
+    }
+
+    if(_timeout < p->_timeout)
+    {
+        return true;
+    }
+    else if(p->_timeout < _timeout)
+    {
+        return false;
+    }
+
+    int rc = compareAddress(_sourceAddr, p->_sourceAddr);
+    if(rc < 0)
+    {
+        return true;
+    }
+    else if(rc > 0)
+    {
+        return false;
+    }
+
+    if(_connectionId < p->_connectionId)
+    {
+        return true;
+    }
+    else if(p->_connectionId < _connectionId)
+    {
+        return false;
+    }
+    return compareAddress(_addr, p->_addr) < 0;
+}
+
+IceInternal::TcpConnector::TcpConnector(const ProtocolInstancePtr& instance, const Address& addr,
+                                        const NetworkProxyPtr& proxy, const Address& sourceAddr,
+                                        Ice::Int timeout, const string& connectionId) :
+    _instance(instance),
+    _addr(addr),
+    _proxy(proxy),
+    _sourceAddr(sourceAddr),
+    _timeout(timeout),
+    _connectionId(connectionId)
+{
+}
+
+IceInternal::TcpConnector::~TcpConnector()
+{
+}

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

@@ -0,0 +1,51 @@
+// **********************************************************************
+//
+// 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 ICE_TCP_CONNECTOR_H
+#define ICE_TCP_CONNECTOR_H
+
+#include <Ice/TransceiverF.h>
+#include <Ice/ProtocolInstanceF.h>
+#include <Ice/Connector.h>
+#include <Ice/Network.h>
+
+namespace IceInternal
+{
+
+class TcpConnector : public Connector
+{
+public:
+
+    virtual TransceiverPtr connect();
+
+    virtual Ice::Short type() const;
+    virtual std::string toString() const;
+
+    virtual bool operator==(const Connector&) const;
+    virtual bool operator!=(const Connector&) const;
+    virtual bool operator<(const Connector&) const;
+
+private:
+
+    TcpConnector(const ProtocolInstancePtr&, const Address&, const NetworkProxyPtr&, const Address&, Ice::Int,
+                 const std::string&);
+    virtual ~TcpConnector();
+    friend class TcpEndpointI;
+
+    const ProtocolInstancePtr _instance;
+    const Address _addr;
+    const NetworkProxyPtr _proxy;
+    const Address _sourceAddr;
+    const Ice::Int _timeout;
+    const std::string _connectionId;
+};
+
+}
+
+#endif

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

@@ -0,0 +1,397 @@
+// **********************************************************************
+//
+// 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 <Ice/TcpEndpointI.h>
+#include <Ice/Network.h>
+#include <Ice/TcpAcceptor.h>
+#include <Ice/TcpConnector.h>
+#include <Ice/TcpTransceiver.h>
+#include <Ice/BasicStream.h>
+#include <Ice/LocalException.h>
+#include <Ice/ProtocolInstance.h>
+#include <Ice/HashUtil.h>
+
+using namespace std;
+using namespace Ice;
+using namespace IceInternal;
+
+IceUtil::Shared* IceInternal::upCast(TcpEndpointI* p) { return p; }
+
+IceInternal::TcpEndpointI::TcpEndpointI(const ProtocolInstancePtr& instance, const string& host, Int port,
+                                        const Address& sourceAddr, Int timeout, const string& connectionId,
+                                        bool compress) :
+    IPEndpointI(instance, host, port, sourceAddr, connectionId),
+    _timeout(timeout),
+    _compress(compress)
+{
+}
+
+IceInternal::TcpEndpointI::TcpEndpointI(const ProtocolInstancePtr& instance) :
+    IPEndpointI(instance),
+    _timeout(instance->defaultTimeout()),
+    _compress(false)
+{
+}
+
+IceInternal::TcpEndpointI::TcpEndpointI(const ProtocolInstancePtr& instance, BasicStream* s) :
+    IPEndpointI(instance, s),
+    _timeout(-1),
+    _compress(false)
+{
+    s->read(const_cast<Int&>(_timeout));
+    s->read(const_cast<bool&>(_compress));
+}
+
+EndpointInfoPtr
+IceInternal::TcpEndpointI::getInfo() const
+{
+    class InfoI : public Ice::TCPEndpointInfo
+    {
+    public:
+
+        InfoI(const EndpointIPtr& endpoint) : _endpoint(endpoint)
+        {
+        }
+
+        virtual Ice::Short
+        type() const
+        {
+            return _endpoint->type();
+        }
+
+        virtual bool
+        datagram() const
+        {
+            return _endpoint->datagram();
+        }
+
+        virtual bool
+        secure() const
+        {
+            return _endpoint->secure();
+        }
+
+    private:
+
+        const EndpointIPtr _endpoint;
+    };
+
+    TCPEndpointInfoPtr info = new InfoI(const_cast<TcpEndpointI*>(this));
+    fillEndpointInfo(info.get());
+    return info;
+}
+
+Int
+IceInternal::TcpEndpointI::timeout() const
+{
+    return _timeout;
+}
+
+EndpointIPtr
+IceInternal::TcpEndpointI::timeout(Int timeout) const
+{
+    if(timeout == _timeout)
+    {
+        return const_cast<TcpEndpointI*>(this);
+    }
+    else
+    {
+        return new TcpEndpointI(_instance, _host, _port, _sourceAddr, timeout, _connectionId, _compress);
+    }
+}
+
+bool
+IceInternal::TcpEndpointI::compress() const
+{
+    return _compress;
+}
+
+EndpointIPtr
+IceInternal::TcpEndpointI::compress(bool compress) const
+{
+    if(compress == _compress)
+    {
+        return const_cast<TcpEndpointI*>(this);
+    }
+    else
+    {
+        return new TcpEndpointI(_instance, _host, _port, _sourceAddr, _timeout, _connectionId, compress);
+    }
+}
+
+bool
+IceInternal::TcpEndpointI::datagram() const
+{
+    return false;
+}
+
+bool
+IceInternal::TcpEndpointI::secure() const
+{
+    return false;
+}
+
+TransceiverPtr
+IceInternal::TcpEndpointI::transceiver() const
+{
+    return 0;
+}
+
+AcceptorPtr
+IceInternal::TcpEndpointI::acceptor(const string&) const
+{
+    return new TcpAcceptor(const_cast<TcpEndpointI*>(this), _instance, _host, _port);
+}
+
+TcpEndpointIPtr
+IceInternal::TcpEndpointI::endpoint(const TcpAcceptorPtr& acceptor) const
+{
+    return new TcpEndpointI(_instance, _host, acceptor->effectivePort(), _sourceAddr, _timeout, _connectionId,
+                            _compress);
+}
+
+string
+IceInternal::TcpEndpointI::options() const
+{
+    //
+    // WARNING: Certain features, such as proxy validation in Glacier2,
+    // depend on the format of proxy strings. Changes to toString() and
+    // methods called to generate parts of the reference string could break
+    // these features. Please review for all features that depend on the
+    // format of proxyToString() before changing this and related code.
+    //
+    ostringstream s;
+
+    s << IPEndpointI::options();
+
+    if(_timeout == -1)
+    {
+        s << " -t infinite";
+    }
+    else
+    {
+        s << " -t " << _timeout;
+    }
+
+    if(_compress)
+    {
+        s << " -z";
+    }
+
+    return s.str();
+}
+
+bool
+IceInternal::TcpEndpointI::operator==(const LocalObject& r) const
+{
+    if(!IPEndpointI::operator==(r))
+    {
+        return false;
+    }
+
+    const TcpEndpointI* p = dynamic_cast<const TcpEndpointI*>(&r);
+    if(!p)
+    {
+        return false;
+    }
+
+    if(this == p)
+    {
+        return true;
+    }
+
+    if(_timeout != p->_timeout)
+    {
+        return false;
+    }
+
+    if(_compress != p->_compress)
+    {
+        return false;
+    }
+
+    return true;
+}
+
+bool
+IceInternal::TcpEndpointI::operator<(const LocalObject& r) const
+{
+    const TcpEndpointI* p = dynamic_cast<const TcpEndpointI*>(&r);
+    if(!p)
+    {
+        const EndpointI* e = dynamic_cast<const EndpointI*>(&r);
+        if(!e)
+        {
+            return false;
+        }
+        return type() < e->type();
+    }
+
+    if(this == p)
+    {
+        return false;
+    }
+
+    if(_timeout < p->_timeout)
+    {
+        return true;
+    }
+    else if(p->_timeout < _timeout)
+    {
+        return false;
+    }
+
+    if(!_compress && p->_compress)
+    {
+        return true;
+    }
+    else if(p->_compress < _compress)
+    {
+        return false;
+    }
+
+    return IPEndpointI::operator<(r);
+}
+
+void
+IceInternal::TcpEndpointI::streamWriteImpl(BasicStream* s) const
+{
+    IPEndpointI::streamWriteImpl(s);
+    s->write(_timeout);
+    s->write(_compress);
+}
+
+void
+IceInternal::TcpEndpointI::hashInit(Ice::Int& h) const
+{
+    IPEndpointI::hashInit(h);
+    hashAdd(h, _timeout);
+    hashAdd(h, _compress);
+}
+
+void
+IceInternal::TcpEndpointI::fillEndpointInfo(IPEndpointInfo* info) const
+{
+    IPEndpointI::fillEndpointInfo(info);
+    info->timeout = _timeout;
+    info->compress = _compress;
+}
+
+bool
+IceInternal::TcpEndpointI::checkOption(const string& option, const string& argument, const string& endpoint)
+{
+    if(IPEndpointI::checkOption(option, argument, endpoint))
+    {
+        return true;
+    }
+
+    switch(option[1])
+    {
+    case 't':
+    {
+        if(argument.empty())
+        {
+            EndpointParseException ex(__FILE__, __LINE__);
+            ex.str = "no argument provided for -t option in endpoint " + endpoint;
+            throw ex;
+        }
+
+        if(argument == "infinite")
+        {
+            const_cast<Int&>(_timeout) = -1;
+        }
+        else
+        {
+            istringstream t(argument);
+            if(!(t >> const_cast<Int&>(_timeout)) || !t.eof() || _timeout < 1)
+            {
+                EndpointParseException ex(__FILE__, __LINE__);
+                ex.str = "invalid timeout value `" + argument + "' in endpoint " + endpoint;
+                throw ex;
+            }
+        }
+        return true;
+    }
+
+    case 'z':
+    {
+        if(!argument.empty())
+        {
+            EndpointParseException ex(__FILE__, __LINE__);
+            ex.str = "unexpected argument `" + argument + "' provided for -z option in " + endpoint;
+            throw ex;
+        }
+        const_cast<bool&>(_compress) = true;
+        return true;
+    }
+
+    default:
+    {
+        return false;
+    }
+    }
+}
+
+ConnectorPtr
+IceInternal::TcpEndpointI::createConnector(const Address& address, const NetworkProxyPtr& proxy) const
+{
+    return new TcpConnector(_instance, address, proxy, _sourceAddr, _timeout, _connectionId);
+}
+
+IPEndpointIPtr
+IceInternal::TcpEndpointI::createEndpoint(const string& host, int port, const string& connectionId) const
+{
+    return new TcpEndpointI(_instance, host, port, _sourceAddr, _timeout, connectionId, _compress);
+}
+
+IceInternal::TcpEndpointFactory::TcpEndpointFactory(const ProtocolInstancePtr& instance) : _instance(instance)
+{
+}
+
+IceInternal::TcpEndpointFactory::~TcpEndpointFactory()
+{
+}
+
+Short
+IceInternal::TcpEndpointFactory::type() const
+{
+    return _instance->type();
+}
+
+string
+IceInternal::TcpEndpointFactory::protocol() const
+{
+    return _instance->protocol();
+}
+
+EndpointIPtr
+IceInternal::TcpEndpointFactory::create(vector<string>& args, bool oaEndpoint) const
+{
+    IPEndpointIPtr endpt = new TcpEndpointI(_instance);
+    endpt->initWithOptions(args, oaEndpoint);
+    return endpt;
+}
+
+EndpointIPtr
+IceInternal::TcpEndpointFactory::read(BasicStream* s) const
+{
+    return new TcpEndpointI(_instance, s);
+}
+
+void
+IceInternal::TcpEndpointFactory::destroy()
+{
+    _instance = 0;
+}
+
+EndpointFactoryPtr
+IceInternal::TcpEndpointFactory::clone(const ProtocolInstancePtr& instance) const
+{
+    return new TcpEndpointFactory(instance);
+}