zeroc-ice 3.7.11 → 3.8.1

data/dist/ice/cpp/src/Ice/StreamSocket.cpp

@@ -1,30 +1,31 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
-#include <Ice/StreamSocket.h>
-#include <Ice/NetworkProxy.h>
-#include <Ice/ProtocolInstance.h>
+#include "StreamSocket.h"
+#include "NetworkProxy.h"
+#include "ProtocolInstance.h"
 
 using namespace IceInternal;
 
-StreamSocket::StreamSocket(const ProtocolInstancePtr& instance,
-                           const NetworkProxyPtr& proxy,
-                           const Address& addr,
-                           const Address& sourceAddr) :
-    NativeInfo(createSocket(false, proxy ? proxy->getAddress() : addr)),
-    _instance(instance),
-    _proxy(proxy),
-    _addr(addr),
-    _sourceAddr(sourceAddr),
-    _state(StateNeedConnect)
+StreamSocket::StreamSocket(
+    ProtocolInstancePtr instance,
+    const NetworkProxyPtr& proxy,
+    const Address& addr,
+    const Address& sourceAddr)
+    : NativeInfo(createSocket(false, proxy ? proxy->getAddress() : addr)),
+      _instance(std::move(instance)),
+      _proxy(proxy),
+      _addr(addr),
+      _sourceAddr(sourceAddr),
+      _state(StateNeedConnect)
 #if defined(ICE_USE_IOCP)
-    , _read(SocketOperationRead), _write(SocketOperationWrite)
+      ,
+      _read(SocketOperationRead),
+      _write(SocketOperationWrite)
 #endif
 {
     init();
 #if !defined(ICE_USE_IOCP)
-    if(doConnect(_fd, _proxy ? _proxy->getAddress() : _addr, sourceAddr))
+    if (doConnect(_fd, _proxy ? _proxy->getAddress() : _addr, sourceAddr))
     {
         _state = _proxy ? StateProxyWrite : StateConnected;
     }
@@ -33,21 +34,23 @@ StreamSocket::StreamSocket(const ProtocolInstancePtr& instance,
     {
         _desc = fdToString(_fd, _proxy, _addr);
     }
-    catch(const Ice::Exception&)
+    catch (const Ice::Exception&)
     {
         closeSocketNoThrow(_fd);
         throw;
     }
 }
 
-StreamSocket::StreamSocket(const ProtocolInstancePtr& instance, SOCKET fd) :
-    NativeInfo(fd),
-    _instance(instance),
-    _addr(),
-    _sourceAddr(),
-    _state(StateConnected)
+StreamSocket::StreamSocket(ProtocolInstancePtr instance, SOCKET fd)
+    : NativeInfo(fd),
+      _instance(std::move(instance)),
+      _addr(),
+      _sourceAddr(),
+      _state(StateConnected)
 #if defined(ICE_USE_IOCP)
-    , _read(SocketOperationRead), _write(SocketOperationWrite)
+      ,
+      _read(SocketOperationRead),
+      _write(SocketOperationWrite)
 #endif
 {
     init();
@@ -55,27 +58,24 @@ StreamSocket::StreamSocket(const ProtocolInstancePtr& instance, SOCKET fd) :
     {
         _desc = fdToString(fd);
     }
-    catch(const Ice::Exception&)
+    catch (const Ice::Exception&)
     {
         closeSocketNoThrow(fd);
         throw;
     }
 }
 
-StreamSocket::~StreamSocket()
-{
-    assert(_fd == INVALID_SOCKET);
-}
+StreamSocket::~StreamSocket() { assert(_fd == INVALID_SOCKET); }
 
 SocketOperation
 StreamSocket::connect(Buffer& readBuffer, Buffer& writeBuffer)
 {
-    if(_state == StateNeedConnect)
+    if (_state == StateNeedConnect)
     {
         _state = StateConnectPending;
         return SocketOperationConnect;
     }
-    else if(_state <= StateConnectPending)
+    else if (_state <= StateConnectPending)
     {
 #if defined(ICE_USE_IOCP)
         doFinishConnectAsync(_fd, _write);
@@ -86,17 +86,17 @@ StreamSocket::connect(Buffer& readBuffer, Buffer& writeBuffer)
         _state = _proxy ? StateProxyWrite : StateConnected;
     }
 
-    if(_state == StateProxyWrite)
+    if (_state == StateProxyWrite)
     {
         _proxy->beginWrite(_addr, writeBuffer);
         return IceInternal::SocketOperationWrite;
     }
-    else if(_state == StateProxyRead)
+    else if (_state == StateProxyRead)
     {
         _proxy->beginRead(readBuffer);
         return IceInternal::SocketOperationRead;
     }
-    else if(_state == StateProxyConnected)
+    else if (_state == StateProxyConnected)
     {
         _proxy->finish(readBuffer, writeBuffer);
 
@@ -119,26 +119,6 @@ StreamSocket::isConnected()
     return _state == StateConnected && _fd != INVALID_SOCKET;
 }
 
-size_t
-StreamSocket::getSendPacketSize(size_t length)
-{
-#if defined(ICE_USE_IOCP)
-    return _maxSendPacketSize > 0 ? std::min(length, _maxSendPacketSize) : length;
-#else
-    return length;
-#endif
-}
-
-size_t
-StreamSocket::getRecvPacketSize(size_t length)
-{
-#if defined(ICE_USE_IOCP)
-    return _maxRecvPacketSize > 0 ? std::min(length, _maxRecvPacketSize) : length;
-#else
-    return length;
-#endif
-}
-
 void
 StreamSocket::setBufferSize(int rcvSize, int sndSize)
 {
@@ -148,18 +128,18 @@ StreamSocket::setBufferSize(int rcvSize, int sndSize)
 SocketOperation
 StreamSocket::read(Buffer& buf)
 {
-    if(_state == StateProxyRead)
+    if (_state == StateProxyRead)
     {
-        while(true)
+        while (true)
         {
             ssize_t ret = read(reinterpret_cast<char*>(&*buf.i), static_cast<size_t>(buf.b.end() - buf.i));
-            if(ret == 0)
+            if (ret == 0)
             {
                 return SocketOperationRead;
             }
             buf.i += ret;
             _state = toState(_proxy->endRead(buf));
-            if(_state != StateProxyRead)
+            if (_state != StateProxyRead)
             {
                 return SocketOperationNone;
             }
@@ -172,18 +152,18 @@ StreamSocket::read(Buffer& buf)
 SocketOperation
 StreamSocket::write(Buffer& buf)
 {
-    if(_state == StateProxyWrite)
+    if (_state == StateProxyWrite)
     {
-        while(true)
+        while (true)
         {
             ssize_t ret = write(reinterpret_cast<const char*>(&*buf.i), static_cast<size_t>(buf.b.end() - buf.i));
-            if(ret == 0)
+            if (ret == 0)
             {
                 return SocketOperationWrite;
             }
             buf.i += ret;
             _state = toState(_proxy->endWrite(buf));
-            if(_state != StateProxyWrite)
+            if (_state != StateProxyWrite)
             {
                 return SocketOperationNone;
             }
@@ -201,38 +181,38 @@ StreamSocket::read(char* buf, size_t length)
     size_t packetSize = length;
     ssize_t read = 0;
 
-    while(length > 0)
+    while (length > 0)
     {
 #ifdef _WIN32
         ssize_t ret = ::recv(_fd, buf, static_cast<int>(packetSize), 0);
 #else
         ssize_t ret = ::recv(_fd, buf, packetSize, 0);
 #endif
-        if(ret == 0)
+        if (ret == 0)
         {
-            throw Ice::ConnectionLostException(__FILE__, __LINE__, 0);
+            throw Ice::ConnectionLostException(__FILE__, __LINE__, addrToString(_addr));
         }
-        else if(ret == SOCKET_ERROR)
+        else if (ret == SOCKET_ERROR)
         {
-            if(interrupted())
+            if (interrupted())
             {
                 continue;
             }
 
-            if(noBuffers() && packetSize > 1024)
+            if (noBuffers() && packetSize > 1024)
             {
                 packetSize /= 2;
                 continue;
             }
 
-            if(wouldBlock())
+            if (wouldBlock())
             {
                 return read;
             }
 
-            if(connectionLost())
+            if (connectionLost())
             {
-                throw Ice::ConnectionLostException(__FILE__, __LINE__, getSocketErrno());
+                throw Ice::ConnectionLostException(__FILE__, __LINE__, getSocketErrno(), addrToString(_addr));
             }
             else
             {
@@ -244,7 +224,7 @@ StreamSocket::read(char* buf, size_t length)
         read += ret;
         length -= static_cast<size_t>(ret);
 
-        if(packetSize > length)
+        if (packetSize > length)
         {
             packetSize = length;
         }
@@ -257,49 +237,40 @@ StreamSocket::write(const char* buf, size_t length)
 {
     assert(_fd != INVALID_SOCKET);
 
-#ifdef ICE_USE_IOCP
-    //
-    // On Windows, limiting the buffer size is important to prevent
-    // poor throughput performances when sending large amount of
-    // data. See Microsoft KB article KB823764.
-    //
-    size_t packetSize = _maxSendPacketSize > 0 ? std::min(length, _maxSendPacketSize / 2) : length;
-#else
     size_t packetSize = length;
-#endif
     ssize_t sent = 0;
-    while(length > 0)
+    while (length > 0)
     {
 #ifdef _WIN32
         ssize_t ret = ::send(_fd, buf, static_cast<int>(packetSize), 0);
 #else
         ssize_t ret = ::send(_fd, buf, packetSize, 0);
 #endif
-        if(ret == 0)
+        if (ret == 0)
         {
-            throw Ice::ConnectionLostException(__FILE__, __LINE__, 0);
+            throw Ice::ConnectionLostException(__FILE__, __LINE__, addrToString(_addr));
         }
-        else if(ret == SOCKET_ERROR)
+        else if (ret == SOCKET_ERROR)
         {
-            if(interrupted())
+            if (interrupted())
             {
                 continue;
             }
 
-            if(noBuffers() && packetSize > 1024)
+            if (noBuffers() && packetSize > 1024)
             {
                 packetSize /= 2;
                 continue;
             }
 
-            if(wouldBlock())
+            if (wouldBlock())
             {
                 return sent;
             }
 
-            if(connectionLost())
+            if (connectionLost())
             {
-                throw Ice::ConnectionLostException(__FILE__, __LINE__, getSocketErrno());
+                throw Ice::ConnectionLostException(__FILE__, __LINE__, getSocketErrno(), addrToString(_addr));
             }
             else
             {
@@ -311,7 +282,7 @@ StreamSocket::write(const char* buf, size_t length)
         sent += ret;
         length -= static_cast<size_t>(ret);
 
-        if(packetSize > length)
+        if (packetSize > length)
         {
             packetSize = length;
         }
@@ -323,25 +294,22 @@ StreamSocket::write(const char* buf, size_t length)
 AsyncInfo*
 StreamSocket::getAsyncInfo(SocketOperation op)
 {
-    switch(op)
+    switch (op)
     {
-    case SocketOperationRead:
-        return &_read;
-    case SocketOperationWrite:
-        return &_write;
-    default:
-        assert(false);
-        return 0;
+        case SocketOperationRead:
+            return &_read;
+        case SocketOperationWrite:
+            return &_write;
+        default:
+            assert(false);
+            return 0;
     }
 }
-#endif
-
-#if defined(ICE_USE_IOCP)
 
 bool
 StreamSocket::startWrite(Buffer& buf)
 {
-    if(_state == StateConnectPending)
+    if (_state == StateConnectPending)
     {
         doConnectAsync(_fd, _proxy ? _proxy->getAddress() : _addr, _sourceAddr, _write);
         return false;
@@ -349,19 +317,18 @@ StreamSocket::startWrite(Buffer& buf)
 
     size_t length = buf.b.end() - buf.i;
     assert(length > 0);
-    size_t packetSize = getSendPacketSize(length);
 
-    _write.buf.len = static_cast<DWORD>(packetSize);
+    _write.buf.len = static_cast<DWORD>(length);
     _write.buf.buf = reinterpret_cast<char*>(&*buf.i);
     _write.error = ERROR_SUCCESS;
-    int err = WSASend(_fd, &_write.buf, 1, &_write.count, 0, &_write, ICE_NULLPTR);
-    if(err == SOCKET_ERROR)
+    int err = WSASend(_fd, &_write.buf, 1, &_write.count, 0, &_write, nullptr);
+    if (err == SOCKET_ERROR)
     {
-        if(!wouldBlock())
+        if (!wouldBlock())
         {
-            if(connectionLost())
+            if (connectionLost())
             {
-                throw Ice::ConnectionLostException(__FILE__, __LINE__, getSocketErrno());
+                throw Ice::ConnectionLostException(__FILE__, __LINE__, getSocketErrno(), addrToString(_addr));
             }
             else
             {
@@ -369,21 +336,21 @@ StreamSocket::startWrite(Buffer& buf)
             }
         }
     }
-    return packetSize == length;
+    return true;
 }
 
 void
 StreamSocket::finishWrite(Buffer& buf)
 {
-    if(_fd == INVALID_SOCKET || (_state < StateConnected && _state != StateProxyWrite))
+    if (_fd == INVALID_SOCKET || (_state < StateConnected && _state != StateProxyWrite))
     {
         return;
     }
 
-    if(_write.error != ERROR_SUCCESS)
+    if (_write.error != ERROR_SUCCESS)
     {
         WSASetLastError(_write.error);
-        if(connectionLost())
+        if (connectionLost())
         {
             throw Ice::ConnectionLostException(__FILE__, __LINE__, getSocketErrno());
         }
@@ -394,7 +361,7 @@ StreamSocket::finishWrite(Buffer& buf)
     }
 
     buf.i += _write.count;
-    if(_state == StateProxyWrite)
+    if (_state == StateProxyWrite)
     {
         _state = toState(_proxy->endWrite(buf));
     }
@@ -406,16 +373,15 @@ StreamSocket::startRead(Buffer& buf)
     size_t length = buf.b.end() - buf.i;
     assert(length > 0);
 
-    size_t packetSize = getRecvPacketSize(length);
-    _read.buf.len = static_cast<DWORD>(packetSize);
+    _read.buf.len = static_cast<DWORD>(length);
     _read.buf.buf = reinterpret_cast<char*>(&*buf.i);
     _read.error = ERROR_SUCCESS;
-    int err = WSARecv(_fd, &_read.buf, 1, &_read.count, &_read.flags, &_read, ICE_NULLPTR);
-    if(err == SOCKET_ERROR)
+    int err = WSARecv(_fd, &_read.buf, 1, &_read.count, &_read.flags, &_read, nullptr);
+    if (err == SOCKET_ERROR)
     {
-        if(!wouldBlock())
+        if (!wouldBlock())
         {
-            if(connectionLost())
+            if (connectionLost())
             {
                 throw Ice::ConnectionLostException(__FILE__, __LINE__, getSocketErrno());
             }
@@ -430,35 +396,34 @@ StreamSocket::startRead(Buffer& buf)
 void
 StreamSocket::finishRead(Buffer& buf)
 {
-    if(_fd == INVALID_SOCKET)
+    if (_fd == INVALID_SOCKET)
     {
         return;
     }
 
-    if(_read.error != ERROR_SUCCESS)
+    if (_read.error != ERROR_SUCCESS)
     {
         WSASetLastError(_read.error);
-        if(connectionLost())
+        if (connectionLost())
         {
-            throw Ice::ConnectionLostException(__FILE__, __LINE__, getSocketErrno());
+            throw Ice::ConnectionLostException(__FILE__, __LINE__, getSocketErrno(), addrToString(_addr));
         }
         else
         {
             throw Ice::SocketException(__FILE__, __LINE__, getSocketErrno());
         }
     }
-    else if(_read.count == 0)
+    else if (_read.count == 0)
     {
-        throw Ice::ConnectionLostException(__FILE__, __LINE__, 0);
+        throw Ice::ConnectionLostException(__FILE__, __LINE__, addrToString(_addr));
     }
 
     buf.i += _read.count;
 
-    if(_state == StateProxyRead)
+    if (_state == StateProxyRead)
     {
         _state = toState(_proxy->endRead(buf));
     }
-
 }
 
 #endif
@@ -472,7 +437,7 @@ StreamSocket::close()
         closeSocket(_fd);
         _fd = INVALID_SOCKET;
     }
-    catch(const Ice::SocketException&)
+    catch (const Ice::SocketException&)
     {
         _fd = INVALID_SOCKET;
         throw;
@@ -490,30 +455,18 @@ StreamSocket::init()
 {
     setBlock(_fd, false);
     setTcpBufSize(_fd, _instance);
-
-#if defined(ICE_USE_IOCP)
-    //
-    // For timeouts to work properly, we need to receive or send the
-    // data in several chunks when using IOCP WSARecv or WSASend.
-    // Otherwise, we would only be notified when all the data is
-    // received or written.  The connection timeout could easily be
-    // triggered when receiging or sending large messages.
-    //
-    _maxSendPacketSize = std::max(512, IceInternal::getSendBufferSize(_fd));
-    _maxRecvPacketSize = std::max(512, IceInternal::getRecvBufferSize(_fd));
-#endif
 }
 
 StreamSocket::State
 StreamSocket::toState(SocketOperation operation) const
 {
-    switch(operation)
+    switch (operation)
     {
-    case SocketOperationRead:
-        return StateProxyRead;
-    case SocketOperationWrite:
-        return StateProxyWrite;
-    default:
-        return StateProxyConnected;
+        case SocketOperationRead:
+            return StateProxyRead;
+        case SocketOperationWrite:
+            return StateProxyWrite;
+        default:
+            return StateProxyConnected;
     }
 }

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

@@ -1,85 +1,73 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef ICE_STREAM_SOCKET_H
 #define ICE_STREAM_SOCKET_H
 
-#include <IceUtil/Shared.h>
-#include <Ice/Network.h>
-#include <Ice/Buffer.h>
-#include <Ice/ProtocolInstanceF.h>
+#include "Ice/Buffer.h"
+#include "Network.h"
+#include "ProtocolInstanceF.h"
 
-namespace IceInternal
-{
+#include <memory>
 
-class ICE_API StreamSocket : public NativeInfo
+namespace IceInternal
 {
-public:
-
-    StreamSocket(const ProtocolInstancePtr&, const NetworkProxyPtr&, const Address&, const Address&);
-    StreamSocket(const ProtocolInstancePtr&, SOCKET);
-    virtual ~StreamSocket();
+    class StreamSocket : public NativeInfo
+    {
+    public:
+        StreamSocket(ProtocolInstancePtr, const NetworkProxyPtr&, const Address&, const Address&);
+        StreamSocket(ProtocolInstancePtr, SOCKET);
+        ~StreamSocket() override;
 
-    SocketOperation connect(Buffer&, Buffer&);
-    bool isConnected();
-    size_t getSendPacketSize(size_t);
-    size_t getRecvPacketSize(size_t);
+        SocketOperation connect(Buffer&, Buffer&);
+        bool isConnected();
 
-    void setBufferSize(int rcvSize, int sndSize);
+        void setBufferSize(int rcvSize, int sndSize);
 
-    SocketOperation read(Buffer&);
-    SocketOperation write(Buffer&);
+        SocketOperation read(Buffer&);
+        SocketOperation write(Buffer&);
 
-    ssize_t read(char*, size_t);
-    ssize_t write(const char*, size_t);
+        ssize_t read(char*, size_t);
+        ssize_t write(const char*, size_t);
 
 #if defined(ICE_USE_IOCP)
-    AsyncInfo* getAsyncInfo(SocketOperation);
+        AsyncInfo* getAsyncInfo(SocketOperation);
+        bool startWrite(Buffer&);
+        void finishWrite(Buffer&);
+        void startRead(Buffer&);
+        void finishRead(Buffer&);
 #endif
 
-#if defined(ICE_USE_IOCP)
-    bool startWrite(Buffer&);
-    void finishWrite(Buffer&);
-    void startRead(Buffer&);
-    void finishRead(Buffer&);
-#endif
+        void close();
+        [[nodiscard]] const std::string& toString() const;
 
-    void close();
-    const std::string& toString() const;
+    private:
+        void init();
 
-private:
+        enum State
+        {
+            StateNeedConnect,
+            StateConnectPending,
+            StateProxyWrite,
+            StateProxyRead,
+            StateProxyConnected,
+            StateConnected
+        };
+        [[nodiscard]] State toState(SocketOperation) const;
 
-    void init();
+        const ProtocolInstancePtr _instance;
+        const NetworkProxyPtr _proxy;
+        const Address _addr;
+        const Address _sourceAddr;
 
-    enum State
-    {
-        StateNeedConnect,
-        StateConnectPending,
-        StateProxyWrite,
-        StateProxyRead,
-        StateProxyConnected,
-        StateConnected
-    };
-    State toState(SocketOperation) const;
-
-    const ProtocolInstancePtr _instance;
-    const NetworkProxyPtr _proxy;
-    const Address _addr;
-    const Address _sourceAddr;
-
-    State _state;
-    std::string _desc;
+        State _state;
+        std::string _desc;
 
 #if defined(ICE_USE_IOCP)
-    size_t _maxSendPacketSize;
-    size_t _maxRecvPacketSize;
-    AsyncInfo _read;
-    AsyncInfo _write;
+        AsyncInfo _read;
+        AsyncInfo _write;
 #endif
-};
-typedef IceUtil::Handle<StreamSocket> StreamSocketPtr;
-
+    };
+    using StreamSocketPtr = std::shared_ptr<StreamSocket>;
 }
 
 #endif