zeroc-ice 3.7.11 → 3.8.1

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

@@ -1,90 +1,86 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef ICE_TCP_ENDPOINT_I_H
 #define ICE_TCP_ENDPOINT_I_H
 
-#include <IceUtil/Config.h>
-#include <Ice/IPEndpointI.h>
-#include <Ice/EndpointFactory.h>
-#include <Ice/Network.h> // for IceIternal::Address
+#include "EndpointFactory.h"
+#include "IPEndpointI.h"
+#include "Ice/Config.h"
+#include "Ice/SSL/ServerAuthenticationOptions.h"
+#include "Network.h" // for IceIternal::Address
 
 namespace IceInternal
 {
-
-class TcpEndpointI : public IPEndpointI
-{
-public:
-
-    TcpEndpointI(const ProtocolInstancePtr&, const std::string&, Ice::Int, const Address&, Ice::Int, const std::string&,
-                 bool);
-    TcpEndpointI(const ProtocolInstancePtr&);
-    TcpEndpointI(const ProtocolInstancePtr&, Ice::InputStream*);
-
-    virtual void streamWriteImpl(Ice::OutputStream*) const;
-
-    virtual Ice::EndpointInfoPtr getInfo() const ICE_NOEXCEPT;
-
-    virtual Ice::Int timeout() const;
-    virtual EndpointIPtr timeout(Ice::Int) const;
-    virtual bool compress() const;
-    virtual EndpointIPtr compress(bool) const;
-    virtual bool datagram() const;
-
-    virtual TransceiverPtr transceiver() const;
-    virtual AcceptorPtr acceptor(const std::string&) const;
-    virtual std::string options() const;
-
-#ifdef ICE_CPP11_MAPPING
-    virtual bool operator==(const Ice::Endpoint&) const;
-    virtual bool operator<(const Ice::Endpoint&) const;
-#else
-    virtual bool operator==(const Ice::LocalObject&) const;
-    virtual bool operator<(const Ice::LocalObject&) const;
-#endif
-    TcpEndpointIPtr endpoint(const TcpAcceptorPtr&) const;
-
-    using IPEndpointI::connectionId;
-
-protected:
-
-    virtual void hashInit(Ice::Int&) const;
-    virtual void fillEndpointInfo(Ice::IPEndpointInfo*) const;
-    virtual bool checkOption(const std::string&, const std::string&, const std::string&);
-
-    virtual ConnectorPtr createConnector(const Address&, const NetworkProxyPtr&) const;
-    virtual IPEndpointIPtr createEndpoint(const std::string&, int, const std::string&) const;
-
-private:
-
-    //
-    // All members are const, because endpoints are immutable.
-    //
-    const Ice::Int _timeout;
-    const bool _compress;
-};
-
-class TcpEndpointFactory : public EndpointFactory
-{
-public:
-
-    TcpEndpointFactory(const ProtocolInstancePtr&);
-    virtual ~TcpEndpointFactory();
-
-    virtual Ice::Short type() const;
-    virtual std::string protocol() const;
-    virtual EndpointIPtr create(std::vector<std::string>&, bool) const;
-    virtual EndpointIPtr read(Ice::InputStream*) const;
-    virtual void destroy();
-
-    virtual EndpointFactoryPtr clone(const ProtocolInstancePtr&) const;
-
-private:
-
-    ProtocolInstancePtr _instance;
-};
-
+    class TcpEndpointI final : public IPEndpointI
+    {
+    public:
+        TcpEndpointI(
+            const ProtocolInstancePtr&,
+            const std::string&,
+            std::int32_t,
+            const Address&,
+            std::int32_t,
+            const std::string&,
+            bool);
+        TcpEndpointI(const ProtocolInstancePtr&);
+        TcpEndpointI(const ProtocolInstancePtr&, Ice::InputStream*);
+
+        void streamWriteImpl(Ice::OutputStream*) const final;
+
+        [[nodiscard]] Ice::EndpointInfoPtr getInfo() const noexcept final;
+
+        [[nodiscard]] std::int32_t timeout() const final;
+        [[nodiscard]] EndpointIPtr timeout(std::int32_t) const final;
+        [[nodiscard]] bool compress() const final;
+        [[nodiscard]] EndpointIPtr compress(bool) const final;
+        [[nodiscard]] bool datagram() const final;
+
+        [[nodiscard]] std::shared_ptr<EndpointI> toPublishedEndpoint(std::string publishedHost) const final;
+
+        [[nodiscard]] TransceiverPtr transceiver() const final;
+        [[nodiscard]] AcceptorPtr
+        acceptor(const std::string&, const std::optional<Ice::SSL::ServerAuthenticationOptions>&) const final;
+        [[nodiscard]] std::string options() const final;
+
+        bool operator==(const Ice::Endpoint&) const final;
+        bool operator<(const Ice::Endpoint&) const final;
+
+        [[nodiscard]] std::size_t hash() const noexcept final;
+
+        [[nodiscard]] TcpEndpointIPtr endpoint(const TcpAcceptorPtr&) const;
+
+        using IPEndpointI::connectionId;
+
+    protected:
+        bool checkOption(const std::string&, const std::string&, const std::string&) final;
+
+        [[nodiscard]] ConnectorPtr createConnector(const Address&, const NetworkProxyPtr&) const final;
+        [[nodiscard]] IPEndpointIPtr createEndpoint(const std::string&, int, const std::string&) const final;
+
+    private:
+        //
+        // All members are const, because endpoints are immutable.
+        //
+        const std::int32_t _timeout;
+        const bool _compress;
+    };
+
+    class TcpEndpointFactory final : public EndpointFactory
+    {
+    public:
+        TcpEndpointFactory(ProtocolInstancePtr);
+        ~TcpEndpointFactory() override;
+
+        [[nodiscard]] std::int16_t type() const final;
+        [[nodiscard]] std::string protocol() const final;
+        EndpointIPtr create(std::vector<std::string>&, bool) const final;
+        EndpointIPtr read(Ice::InputStream*) const final;
+
+        [[nodiscard]] EndpointFactoryPtr clone(const ProtocolInstancePtr&) const final;
+
+    private:
+        const ProtocolInstancePtr _instance;
+    };
 }
 
 #endif

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

@@ -1,17 +1,17 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
-#include <Ice/Config.h>
+#include "Ice/Config.h"
 
 #if !defined(__APPLE__) || TARGET_OS_IPHONE == 0
 
-#include <Ice/TcpTransceiver.h>
-#include <Ice/Connection.h>
-#include <Ice/ProtocolInstance.h>
-#include <Ice/LoggerUtil.h>
-#include <Ice/Buffer.h>
-#include <Ice/LocalException.h>
+#    include "Ice/Buffer.h"
+#    include "Ice/Connection.h"
+#    include "Ice/LocalExceptions.h"
+#    include "Ice/LoggerUtil.h"
+#    include "ProtocolInstance.h"
+#    include "TcpTransceiver.h"
+
+#    include <utility>
 
 using namespace std;
 using namespace Ice;
@@ -30,7 +30,7 @@ IceInternal::TcpTransceiver::initialize(Buffer& readBuffer, Buffer& writeBuffer)
 }
 
 SocketOperation
-IceInternal::TcpTransceiver::closing(bool initiator, const Ice::LocalException&)
+IceInternal::TcpTransceiver::closing(bool initiator, exception_ptr)
 {
     // If we are initiating the connection closure, wait for the peer
     // to close the TCP/IP connection. Otherwise, close immediately.
@@ -55,7 +55,7 @@ IceInternal::TcpTransceiver::read(Buffer& buf)
     return _stream->read(buf);
 }
 
-#if defined(ICE_USE_IOCP)
+#    if defined(ICE_USE_IOCP)
 bool
 IceInternal::TcpTransceiver::startWrite(Buffer& buf)
 {
@@ -79,7 +79,7 @@ IceInternal::TcpTransceiver::finishRead(Buffer& buf)
 {
     _stream->finishRead(buf);
 }
-#endif
+#    endif
 
 string
 IceInternal::TcpTransceiver::protocol() const
@@ -100,16 +100,30 @@ IceInternal::TcpTransceiver::toDetailedString() const
 }
 
 Ice::ConnectionInfoPtr
-IceInternal::TcpTransceiver::getInfo() const
+IceInternal::TcpTransceiver::getInfo(bool incoming, string adapterName, string connectionId) const
 {
-    TCPConnectionInfoPtr info = ICE_MAKE_SHARED(TCPConnectionInfo);
-    fdToAddressAndPort(_stream->fd(), info->localAddress, info->localPort, info->remoteAddress, info->remotePort);
-    if(_stream->fd() != INVALID_SOCKET)
+    if (_stream->fd() == INVALID_SOCKET)
+    {
+        return make_shared<TCPConnectionInfo>(incoming, std::move(adapterName), std::move(connectionId));
+    }
+    else
     {
-        info->rcvSize = getRecvBufferSize(_stream->fd());
-        info->sndSize = getSendBufferSize(_stream->fd());
+        string localAddress;
+        int localPort;
+        string remoteAddress;
+        int remotePort;
+        fdToAddressAndPort(_stream->fd(), localAddress, localPort, remoteAddress, remotePort);
+        return make_shared<TCPConnectionInfo>(
+            incoming,
+            std::move(adapterName),
+            std::move(connectionId),
+            std::move(localAddress),
+            localPort,
+            std::move(remoteAddress),
+            remotePort,
+            getRecvBufferSize(_stream->fd()),
+            getSendBufferSize(_stream->fd()));
     }
-    return info;
 }
 
 void
@@ -123,13 +137,11 @@ IceInternal::TcpTransceiver::setBufferSize(int rcvSize, int sndSize)
     _stream->setBufferSize(rcvSize, sndSize);
 }
 
-IceInternal::TcpTransceiver::TcpTransceiver(const ProtocolInstancePtr& instance, const StreamSocketPtr& stream) :
-    _instance(instance),
-    _stream(stream)
+IceInternal::TcpTransceiver::TcpTransceiver(ProtocolInstancePtr instance, StreamSocketPtr stream)
+    : _instance(std::move(instance)),
+      _stream(std::move(stream))
 {
 }
 
-IceInternal::TcpTransceiver::~TcpTransceiver()
-{
-}
+IceInternal::TcpTransceiver::~TcpTransceiver() = default;
 #endif

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

@@ -1,58 +1,53 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef ICE_TCP_TRANSCEIVER_H
 #define ICE_TCP_TRANSCEIVER_H
 
-#include <Ice/ProtocolInstanceF.h>
-#include <Ice/Transceiver.h>
-#include <Ice/Network.h>
-#include <Ice/StreamSocket.h>
+#include "Network.h"
+#include "ProtocolInstanceF.h"
+#include "StreamSocket.h"
+#include "Transceiver.h"
 
 namespace IceInternal
 {
-
-class TcpConnector;
-class TcpAcceptor;
-
-class TcpTransceiver : public Transceiver
-{
-public:
-
-    virtual NativeInfoPtr getNativeInfo();
-
-    virtual SocketOperation initialize(Buffer&, Buffer&);
-    virtual SocketOperation closing(bool, const Ice::LocalException&);
-
-    virtual void close();
-    virtual SocketOperation write(Buffer&);
-    virtual SocketOperation read(Buffer&);
+    class TcpConnector;
+    class TcpAcceptor;
+
+    class TcpTransceiver final : public Transceiver
+    {
+    public:
+        TcpTransceiver(ProtocolInstancePtr, StreamSocketPtr);
+        ~TcpTransceiver();
+        NativeInfoPtr getNativeInfo() final;
+
+        SocketOperation initialize(Buffer&, Buffer&) final;
+        SocketOperation closing(bool, std::exception_ptr) final;
+
+        void close() final;
+        SocketOperation write(Buffer&) final;
+        SocketOperation read(Buffer&) final;
 #if defined(ICE_USE_IOCP)
-    virtual bool startWrite(Buffer&);
-    virtual void finishWrite(Buffer&);
-    virtual void startRead(Buffer&);
-    virtual void finishRead(Buffer&);
+        bool startWrite(Buffer&) final;
+        void finishWrite(Buffer&) final;
+        void startRead(Buffer&) final;
+        void finishRead(Buffer&) final;
 #endif
-    virtual std::string protocol() const;
-    virtual std::string toString() const;
-    virtual std::string toDetailedString() const;
-    virtual Ice::ConnectionInfoPtr getInfo() const;
-    virtual void checkSendSize(const Buffer&);
-    virtual void setBufferSize(int rcvSize, int sndSize);
-
-private:
-
-    TcpTransceiver(const ProtocolInstancePtr&, const StreamSocketPtr&);
-    virtual ~TcpTransceiver();
-
-    friend class TcpConnector;
-    friend class TcpAcceptor;
-
-    const ProtocolInstancePtr _instance;
-    const StreamSocketPtr _stream;
-};
 
+        [[nodiscard]] std::string protocol() const final;
+        [[nodiscard]] std::string toString() const final;
+        [[nodiscard]] std::string toDetailedString() const final;
+        [[nodiscard]] Ice::ConnectionInfoPtr
+        getInfo(bool incoming, std::string adapterName, std::string connectionId) const final;
+        void checkSendSize(const Buffer&) final;
+        void setBufferSize(int rcvSize, int sndSize) final;
+
+    private:
+        friend class TcpConnector;
+        friend class TcpAcceptor;
+
+        const ProtocolInstancePtr _instance;
+        const StreamSocketPtr _stream;
+    };
 }
 
 #endif