zeroc-ice 3.7.11 → 3.8.1

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

@@ -1,29 +1,20 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#include <Ice/WSTransceiver.h>
-#include <Ice/Endpoint.h>
-#include <Ice/Connection.h>
-#include <Ice/ProtocolInstance.h>
-#include <Ice/HttpParser.h>
-#include <Ice/Communicator.h>
-#include <Ice/LoggerUtil.h>
-#include <Ice/Buffer.h>
-#include <Ice/LocalException.h>
-#include <Ice/Base64.h>
-#include <IceUtil/Random.h>
-#include <Ice/SHA1.h>
-#include <IceUtil/StringUtil.h>
-
-// Python 2.7 under Windows.
-#if _MSC_VER == 1500
-typedef unsigned short uint16_t;
-#else
-#include <stdint.h>
-#endif
+// Copyright (c) ZeroC, Inc.
+
+#include "WSTransceiver.h"
+#include "Base64.h"
+#include "Endian.h"
+#include "HttpParser.h"
+#include "Ice/Buffer.h"
+#include "Ice/Connection.h"
+#include "Ice/LocalExceptions.h"
+#include "Ice/LoggerUtil.h"
+#include "Ice/StringUtil.h"
+#include "ProtocolInstance.h"
+#include "Random.h"
+#include "SHA1.h"
 
 #include <climits>
+#include <cstdint>
 
 using namespace std;
 using namespace Ice;
@@ -32,102 +23,105 @@ using namespace IceInternal;
 //
 // WebSocket opcodes
 //
-#define OP_CONT     0x0     // Continuation frame
-#define OP_TEXT     0x1     // Text frame
-#define OP_DATA     0x2     // Data frame
-#define OP_RES_0x3  0x3     // Reserved
-#define OP_RES_0x4  0x4     // Reserved
-#define OP_RES_0x5  0x5     // Reserved
-#define OP_RES_0x6  0x6     // Reserved
-#define OP_RES_0x7  0x7     // Reserved
-#define OP_CLOSE    0x8     // Connection close
-#define OP_PING     0x9     // Ping
-#define OP_PONG     0xA     // Pong
-#define OP_RES_0xB  0xB     // Reserved
-#define OP_RES_0xC  0xC     // Reserved
-#define OP_RES_0xD  0xD     // Reserved
-#define OP_RES_0xE  0xE     // Reserved
-#define OP_RES_0xF  0xF     // Reserved
-#define FLAG_FINAL  0x80    // Last frame
-#define FLAG_MASKED 0x80    // Payload is masked
-
-#define CLOSURE_NORMAL         1000
-#define CLOSURE_SHUTDOWN       1001
+#define OP_CONT 0x0      // Continuation frame
+#define OP_TEXT 0x1      // Text frame
+#define OP_DATA 0x2      // Data frame
+#define OP_RES_0x3 0x3   // Reserved
+#define OP_RES_0x4 0x4   // Reserved
+#define OP_RES_0x5 0x5   // Reserved
+#define OP_RES_0x6 0x6   // Reserved
+#define OP_RES_0x7 0x7   // Reserved
+#define OP_CLOSE 0x8     // Connection close
+#define OP_PING 0x9      // Ping
+#define OP_PONG 0xA      // Pong
+#define OP_RES_0xB 0xB   // Reserved
+#define OP_RES_0xC 0xC   // Reserved
+#define OP_RES_0xD 0xD   // Reserved
+#define OP_RES_0xE 0xE   // Reserved
+#define OP_RES_0xF 0xF   // Reserved
+#define FLAG_FINAL 0x80  // Last frame
+#define FLAG_MASKED 0x80 // Payload is masked
+
+#define CLOSURE_NORMAL 1000
+#define CLOSURE_SHUTDOWN 1001
 #define CLOSURE_PROTOCOL_ERROR 1002
-#define CLOSURE_TOO_BIG        1009
 
 namespace
 {
+    const string _iceProtocol = "ice.zeroc.com";                   // NOLINT(cert-err58-cpp)
+    const string _wsUUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"; // NOLINT(cert-err58-cpp)
 
-const string _iceProtocol = "ice.zeroc.com";
-const string _wsUUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
-
-//
-// Rename to avoid conflict with OS 10.10 htonll
-//
-void ice_htonll(Long v, Byte* dest)
-{
     //
-    // Transfer a 64-bit integer in network (big-endian) order.
+    // Rename to avoid conflict with OS 10.10 htonll
     //
-#ifdef ICE_BIG_ENDIAN
-    const Byte* src = reinterpret_cast<const Byte*>(&v);
-    *dest++ = *src++;
-    *dest++ = *src++;
-    *dest++ = *src++;
-    *dest++ = *src++;
-    *dest++ = *src++;
-    *dest++ = *src++;
-    *dest++ = *src++;
-    *dest = *src;
-#else
-    const Byte* src = reinterpret_cast<const Byte*>(&v) + sizeof(Long) - 1;
-    *dest++ = *src--;
-    *dest++ = *src--;
-    *dest++ = *src--;
-    *dest++ = *src--;
-    *dest++ = *src--;
-    *dest++ = *src--;
-    *dest++ = *src--;
-    *dest = *src;
-#endif
-}
-
-//
-// Rename to avoid conflict with OS 10.10 nlltoh
-//
-Long ice_nlltoh(const Byte* src)
-{
-    Long v;
+    void ice_htonll(int64_t v, byte* dest)
+    {
+        //
+        // Transfer a 64-bit integer in network (big-endian) order.
+        //
+        if constexpr (endian::native == endian::big)
+        {
+            const byte* src = reinterpret_cast<const byte*>(&v);
+            *dest++ = *src++;
+            *dest++ = *src++;
+            *dest++ = *src++;
+            *dest++ = *src++;
+            *dest++ = *src++;
+            *dest++ = *src++;
+            *dest++ = *src++;
+            *dest = *src;
+        }
+        else
+        {
+            const byte* src = reinterpret_cast<const byte*>(&v) + sizeof(int64_t) - 1;
+            *dest++ = *src--;
+            *dest++ = *src--;
+            *dest++ = *src--;
+            *dest++ = *src--;
+            *dest++ = *src--;
+            *dest++ = *src--;
+            *dest++ = *src--;
+            *dest = *src;
+        }
+    }
 
     //
-    // Extract a 64-bit integer in network (big-endian) order.
+    // Rename to avoid conflict with OS 10.10 nlltoh
     //
-#ifdef ICE_BIG_ENDIAN
-    Byte* dest = reinterpret_cast<Byte*>(&v);
-    *dest++ = *src++;
-    *dest++ = *src++;
-    *dest++ = *src++;
-    *dest++ = *src++;
-    *dest++ = *src++;
-    *dest++ = *src++;
-    *dest++ = *src++;
-    *dest = *src;
-#else
-    Byte* dest = reinterpret_cast<Byte*>(&v) + sizeof(Long) - 1;
-    *dest-- = *src++;
-    *dest-- = *src++;
-    *dest-- = *src++;
-    *dest-- = *src++;
-    *dest-- = *src++;
-    *dest-- = *src++;
-    *dest-- = *src++;
-    *dest = *src;
-#endif
+    int64_t ice_nlltoh(const byte* src)
+    {
+        int64_t v;
 
-    return v;
-}
+        //
+        // Extract a 64-bit integer in network (big-endian) order.
+        //
+        if constexpr (endian::native == endian::big)
+        {
+            byte* dest = reinterpret_cast<byte*>(&v);
+            *dest++ = *src++;
+            *dest++ = *src++;
+            *dest++ = *src++;
+            *dest++ = *src++;
+            *dest++ = *src++;
+            *dest++ = *src++;
+            *dest++ = *src++;
+            *dest = *src;
+        }
+        else
+        {
+            byte* dest = reinterpret_cast<byte*>(&v) + sizeof(int64_t) - 1;
+            *dest-- = *src++;
+            *dest-- = *src++;
+            *dest-- = *src++;
+            *dest-- = *src++;
+            *dest-- = *src++;
+            *dest-- = *src++;
+            *dest-- = *src++;
+            *dest = *src;
+        }
 
+        return v;
+    }
 }
 
 NativeInfoPtr
@@ -150,10 +144,10 @@ IceInternal::WSTransceiver::initialize(Buffer& readBuffer, Buffer& writeBuffer)
     //
     // Delegate logs exceptions that occur during initialize(), so there's no need to trap them here.
     //
-    if(_state == StateInitializeDelegate)
+    if (_state == StateInitializeDelegate)
     {
         SocketOperation op = _delegate->initialize(readBuffer, writeBuffer);
-        if(op != SocketOperationNone)
+        if (op != SocketOperationNone)
         {
             return op;
         }
@@ -162,7 +156,7 @@ IceInternal::WSTransceiver::initialize(Buffer& readBuffer, Buffer& writeBuffer)
 
     try
     {
-        if(_state == StateConnected)
+        if (_state == StateConnected)
         {
             //
             // We don't know how much we'll need to read.
@@ -175,7 +169,7 @@ IceInternal::WSTransceiver::initialize(Buffer& readBuffer, Buffer& writeBuffer)
             // client sends the upgrade request.
             //
             _state = StateUpgradeRequestPending;
-            if(!_incoming)
+            if (!_incoming)
             {
                 //
                 // Compose the upgrade request.
@@ -193,8 +187,8 @@ IceInternal::WSTransceiver::initialize(Buffer& readBuffer, Buffer& writeBuffer)
                 // The value for Sec-WebSocket-Key is a 16-byte random number,
                 // encoded with Base64.
                 //
-                vector<unsigned char> key(16);
-                IceUtilInternal::generateRandom(reinterpret_cast<char*>(&key[0]), key.size());
+                vector<byte> key(16);
+                IceInternal::generateRandom(reinterpret_cast<char*>(&key[0]), key.size());
                 _key = IceInternal::Base64::encode(key);
                 out << _key << "\r\n\r\n"; // EOM
 
@@ -208,26 +202,32 @@ IceInternal::WSTransceiver::initialize(Buffer& readBuffer, Buffer& writeBuffer)
         //
         // Try to write the client's upgrade request.
         //
-        if(_state == StateUpgradeRequestPending && !_incoming)
+        if (_state == StateUpgradeRequestPending && !_incoming)
         {
-            if(_writeBuffer.i < _writeBuffer.b.end())
+            if (_writeBuffer.i < _writeBuffer.b.end())
             {
                 SocketOperation s = _delegate->write(_writeBuffer);
-                if(s)
+                if (s)
                 {
                     return s;
                 }
             }
             assert(_writeBuffer.i == _writeBuffer.b.end());
             _state = StateUpgradeResponsePending;
+
+            if (_instance->traceLevel() >= 1)
+            {
+                Trace out(_instance->logger(), _instance->traceCategory());
+                out << "sent " << protocol() << " connection HTTP upgrade request\n" << toString();
+            }
         }
 
-        while(true)
+        while (true)
         {
-            if(_readBuffer.i < _readBuffer.b.end())
+            if (_readBuffer.i < _readBuffer.b.end())
             {
                 SocketOperation s = _delegate->read(_readBuffer);
-                if(s == SocketOperationWrite || _readBuffer.i == _readBuffer.b.begin())
+                if (s == SocketOperationWrite || _readBuffer.i == _readBuffer.b.begin())
                 {
                     return s;
                 }
@@ -236,16 +236,16 @@ IceInternal::WSTransceiver::initialize(Buffer& readBuffer, Buffer& writeBuffer)
             //
             // Try to read the client's upgrade request or the server's response.
             //
-            if((_state == StateUpgradeRequestPending && _incoming) ||
-               (_state == StateUpgradeResponsePending && !_incoming))
+            if ((_state == StateUpgradeRequestPending && _incoming) ||
+                (_state == StateUpgradeResponsePending && !_incoming))
             {
                 //
                 // Check if we have enough data for a complete message.
                 //
-                const Ice::Byte* p = _parser->isCompleteMessage(&_readBuffer.b[0], _readBuffer.i);
-                if(!p)
+                const byte* p = _parser->isCompleteMessage(&_readBuffer.b[0], _readBuffer.i);
+                if (!p)
                 {
-                    if(_readBuffer.i < _readBuffer.b.end())
+                    if (_readBuffer.i < _readBuffer.b.end())
                     {
                         return SocketOperationRead;
                     }
@@ -253,10 +253,10 @@ IceInternal::WSTransceiver::initialize(Buffer& readBuffer, Buffer& writeBuffer)
                     //
                     // Enlarge the buffer and try to read more.
                     //
-                    const size_t oldSize = static_cast<size_t>(_readBuffer.i - _readBuffer.b.begin());
-                    if(oldSize + 1024 > _instance->messageSizeMax())
+                    const auto oldSize = static_cast<size_t>(_readBuffer.i - _readBuffer.b.begin());
+                    if (oldSize + 1024 > static_cast<size_t>(_instance->messageSizeMax()))
                     {
-                        throw MemoryLimitException(__FILE__, __LINE__);
+                        Ex::throwMemoryLimitException(__FILE__, __LINE__, oldSize + 1024, _instance->messageSizeMax());
                     }
                     _readBuffer.b.resize(oldSize + 1024);
                     _readBuffer.i = _readBuffer.b.begin() + oldSize;
@@ -280,9 +280,9 @@ IceInternal::WSTransceiver::initialize(Buffer& readBuffer, Buffer& writeBuffer)
             //
             // Parse the client's upgrade request.
             //
-            if(_state == StateUpgradeRequestPending && _incoming)
+            if (_state == StateUpgradeRequestPending && _incoming)
             {
-                if(_parser->parse(&_readBuffer.b[0], _readI))
+                if (_parser->parse(&_readBuffer.b[0], _readI))
                 {
                     handleRequest(_writeBuffer);
                     _state = StateUpgradeResponsePending;
@@ -293,14 +293,14 @@ IceInternal::WSTransceiver::initialize(Buffer& readBuffer, Buffer& writeBuffer)
                 }
             }
 
-            if(_state == StateUpgradeResponsePending)
+            if (_state == StateUpgradeResponsePending)
             {
-                if(_incoming)
+                if (_incoming)
                 {
-                    if(_writeBuffer.i < _writeBuffer.b.end())
+                    if (_writeBuffer.i < _writeBuffer.b.end())
                     {
                         SocketOperation s = _delegate->write(_writeBuffer);
-                        if(s)
+                        if (s)
                         {
                             return s;
                         }
@@ -311,7 +311,7 @@ IceInternal::WSTransceiver::initialize(Buffer& readBuffer, Buffer& writeBuffer)
                     //
                     // Parse the server's response
                     //
-                    if(_parser->parse(&_readBuffer.b[0], _readI))
+                    if (_parser->parse(&_readBuffer.b[0], _readI))
                     {
                         handleResponse();
                     }
@@ -322,7 +322,7 @@ IceInternal::WSTransceiver::initialize(Buffer& readBuffer, Buffer& writeBuffer)
                 }
             }
         }
-        catch(const WebSocketException& ex)
+        catch (const WebSocketException& ex)
         {
             throw ProtocolException(__FILE__, __LINE__, ex.reason);
         }
@@ -330,14 +330,14 @@ IceInternal::WSTransceiver::initialize(Buffer& readBuffer, Buffer& writeBuffer)
         _state = StateOpened;
         _nextState = StateOpened;
 
-        if(_readI < _readBuffer.i)
+        if (_readI < _readBuffer.i)
         {
             _delegate->getNativeInfo()->ready(SocketOperationRead, true);
         }
     }
-    catch(const Ice::LocalException& ex)
+    catch (const Ice::LocalException& ex)
     {
-        if(_instance->traceLevel() >= 2)
+        if (_instance->traceLevel() >= 2)
         {
             Trace out(_instance->logger(), _instance->traceCategory());
             out << protocol() << " connection HTTP upgrade request failed\n" << toString() << "\n" << ex;
@@ -345,10 +345,10 @@ IceInternal::WSTransceiver::initialize(Buffer& readBuffer, Buffer& writeBuffer)
         throw;
     }
 
-    if(_instance->traceLevel() >= 1)
+    if (_instance->traceLevel() >= 1)
     {
         Trace out(_instance->logger(), _instance->traceCategory());
-        if(_incoming)
+        if (_incoming)
         {
             out << "accepted " << protocol() << " connection HTTP upgrade request\n" << toString();
         }
@@ -362,9 +362,9 @@ IceInternal::WSTransceiver::initialize(Buffer& readBuffer, Buffer& writeBuffer)
 }
 
 SocketOperation
-IceInternal::WSTransceiver::closing(bool initiator, const Ice::LocalException& reason)
+IceInternal::WSTransceiver::closing(bool initiator, exception_ptr reason)
 {
-    if(_instance->traceLevel() >= 1)
+    if (_instance->traceLevel() >= 1)
     {
         Trace out(_instance->logger(), _instance->traceCategory());
         out << "gracefully closing " << protocol() << " connection\n" << toString();
@@ -372,7 +372,7 @@ IceInternal::WSTransceiver::closing(bool initiator, const Ice::LocalException& r
 
     State s = _nextState == StateOpened ? _state : _nextState;
 
-    if(s == StateClosingRequestPending && _closingInitiator)
+    if (s == StateClosingRequestPending && _closingInitiator)
     {
         //
         // If we initiated a close connection but also received a
@@ -386,32 +386,43 @@ IceInternal::WSTransceiver::closing(bool initiator, const Ice::LocalException& r
         _closingInitiator = false;
         return SocketOperationWrite;
     }
-    else if(s >= StateClosingRequestPending)
+    else if (s >= StateClosingRequestPending)
     {
         return SocketOperationNone;
     }
 
     _closingInitiator = initiator;
 
-    if(dynamic_cast<const Ice::CloseConnectionException*>(&reason))
+    try
+    {
+        rethrow_exception(reason);
+    }
+    catch (const Ice::CloseConnectionException&)
     {
         _closingReason = CLOSURE_NORMAL;
     }
-    else if(dynamic_cast<const Ice::ObjectAdapterDeactivatedException*>(&reason) ||
-            dynamic_cast<const Ice::CommunicatorDestroyedException*>(&reason))
+    catch (const Ice::ObjectAdapterDeactivatedException&)
     {
         _closingReason = CLOSURE_SHUTDOWN;
     }
-    else if(dynamic_cast<const Ice::ProtocolException*>(&reason))
+    catch (const Ice::ObjectAdapterDestroyedException&)
     {
-        _closingReason  = CLOSURE_PROTOCOL_ERROR;
+        _closingReason = CLOSURE_SHUTDOWN;
     }
-    else if(dynamic_cast<const Ice::MemoryLimitException*>(&reason))
+    catch (const Ice::CommunicatorDestroyedException&)
     {
-        _closingReason = CLOSURE_TOO_BIG;
+        _closingReason = CLOSURE_SHUTDOWN;
+    }
+    catch (const Ice::ProtocolException&)
+    {
+        _closingReason = CLOSURE_PROTOCOL_ERROR;
+    }
+    catch (...)
+    {
+        // no closing reason
     }
 
-    if(_state == StateOpened)
+    if (_state == StateOpened)
     {
         _state = StateClosingRequestPending;
         return initiator ? SocketOperationRead : SocketOperationWrite;
@@ -432,11 +443,11 @@ IceInternal::WSTransceiver::close()
     //
     // Clear the buffers now instead of waiting for destruction.
     //
-    if(!_writePending)
+    if (!_writePending)
     {
         _writeBuffer.b.clear();
     }
-    if(!_readPending)
+    if (!_readPending)
     {
         _readBuffer.b.clear();
     }
@@ -445,14 +456,14 @@ IceInternal::WSTransceiver::close()
 SocketOperation
 IceInternal::WSTransceiver::write(Buffer& buf)
 {
-    if(_writePending)
+    if (_writePending)
     {
         return SocketOperationWrite;
     }
 
-    if(_state < StateOpened)
+    if (_state < StateOpened)
     {
-        if(_state < StateConnected)
+        if (_state < StateConnected)
         {
             return _delegate->write(buf);
         }
@@ -464,29 +475,28 @@ IceInternal::WSTransceiver::write(Buffer& buf)
 
     do
     {
-        if(preWrite(buf))
+        if (preWrite(buf))
         {
-            if(_writeBuffer.i < _writeBuffer.b.end())
+            if (_writeBuffer.i < _writeBuffer.b.end())
             {
                 SocketOperation s = _delegate->write(_writeBuffer);
-                if(s)
+                if (s)
                 {
                     return s;
                 }
             }
-            else if(_incoming && !buf.b.empty() && _writeState == WriteStatePayload)
+            else if (_incoming && !buf.b.empty() && _writeState == WriteStatePayload)
             {
                 SocketOperation s = _delegate->write(buf);
-                if(s)
+                if (s)
                 {
                     return s;
                 }
             }
         }
-    }
-    while(postWrite(buf));
+    } while (postWrite(buf));
 
-    if(_state == StateClosingResponsePending && !_closingInitiator)
+    if (_state == StateClosingResponsePending && !_closingInitiator)
     {
         return SocketOperationRead;
     }
@@ -496,20 +506,20 @@ IceInternal::WSTransceiver::write(Buffer& buf)
 SocketOperation
 IceInternal::WSTransceiver::read(Buffer& buf)
 {
-    if(_readPending)
+    if (_readPending)
     {
         return SocketOperationRead;
     }
 
-    if(_state < StateOpened)
+    if (_state < StateOpened)
     {
-        if(_state < StateConnected)
+        if (_state < StateConnected)
         {
             return _delegate->read(buf);
         }
         else
         {
-            if(_delegate->read(_readBuffer) == SocketOperationWrite)
+            if (_delegate->read(_readBuffer) == SocketOperationWrite)
             {
                 return SocketOperationWrite;
             }
@@ -524,9 +534,9 @@ IceInternal::WSTransceiver::read(Buffer& buf)
     // If we read the full Ice message, handle it before trying
     // reading anymore data from the WS connection.
     //
-    if(buf.i == buf.b.end())
+    if (buf.i == buf.b.end())
     {
-        if(_readI < _readBuffer.i)
+        if (_readI < _readBuffer.i)
         {
             _delegate->getNativeInfo()->ready(SocketOperationRead, true);
         }
@@ -536,9 +546,9 @@ IceInternal::WSTransceiver::read(Buffer& buf)
     SocketOperation s = SocketOperationNone;
     do
     {
-        if(preRead(buf))
+        if (preRead(buf))
         {
-            if(_readState == ReadStatePayload)
+            if (_readState == ReadStatePayload)
             {
                 //
                 // If the payload length is smaller than what remains to be read, we read
@@ -546,7 +556,7 @@ IceInternal::WSTransceiver::read(Buffer& buf)
                 // sent over in another frame.
                 //
                 size_t readSz = _readPayloadLength - static_cast<size_t>(buf.i - _readStart); // Already read
-                if(static_cast<size_t>(buf.b.end() - buf.i) > readSz)
+                if (static_cast<size_t>(buf.b.end() - buf.i) > readSz)
                 {
                     size_t size = buf.b.size();
                     buf.b.resize(static_cast<size_t>(buf.i - buf.b.begin()) + readSz);
@@ -563,18 +573,17 @@ IceInternal::WSTransceiver::read(Buffer& buf)
                 s = _delegate->read(_readBuffer);
             }
 
-            if(s == SocketOperationWrite)
+            if (s == SocketOperationWrite)
             {
                 postRead(buf);
                 return s;
             }
         }
-    }
-    while(postRead(buf));
+    } while (postRead(buf));
 
-    if(buf.i == buf.b.end())
+    if (buf.i == buf.b.end())
     {
-        if(_readI < _readBuffer.i)
+        if (_readI < _readBuffer.i)
         {
             _delegate->getNativeInfo()->ready(SocketOperationRead, true);
         }
@@ -586,11 +595,10 @@ IceInternal::WSTransceiver::read(Buffer& buf)
         s = SocketOperationRead;
     }
 
-    if(((_state == StateClosingRequestPending && !_closingInitiator) ||
-        (_state == StateClosingResponsePending && _closingInitiator) ||
-        _state == StatePingPending ||
-        _state == StatePongPending) &&
-       _writeState == WriteStateHeader)
+    if (((_state == StateClosingRequestPending && !_closingInitiator) ||
+         (_state == StateClosingResponsePending && _closingInitiator) || _state == StatePingPending ||
+         _state == StatePongPending) &&
+        _writeState == WriteStateHeader)
     {
         // We have things to write, ask to be notified when writes are ready.
         s = static_cast<SocketOperation>(s | SocketOperationWrite);
@@ -603,9 +611,9 @@ bool
 IceInternal::WSTransceiver::startWrite(Buffer& buf)
 {
     _writePending = true;
-    if(_state < StateOpened)
+    if (_state < StateOpened)
     {
-        if(_state < StateConnected)
+        if (_state < StateConnected)
         {
             return _delegate->startWrite(buf);
         }
@@ -615,11 +623,11 @@ IceInternal::WSTransceiver::startWrite(Buffer& buf)
         }
     }
 
-    if(preWrite(buf))
+    if (preWrite(buf))
     {
-        if(_writeBuffer.i < _writeBuffer.b.end())
+        if (_writeBuffer.i < _writeBuffer.b.end())
         {
-            if(_delegate->startWrite(_writeBuffer))
+            if (_delegate->startWrite(_writeBuffer))
             {
                 return buf.b.size() == _writePayloadLength; // Return true only if we've written the whole buffer.
             }
@@ -643,9 +651,9 @@ IceInternal::WSTransceiver::finishWrite(Buffer& buf)
 {
     _writePending = false;
 
-    if(_state < StateOpened)
+    if (_state < StateOpened)
     {
-        if(_state < StateConnected)
+        if (_state < StateConnected)
         {
             _delegate->finishWrite(buf);
         }
@@ -656,17 +664,17 @@ IceInternal::WSTransceiver::finishWrite(Buffer& buf)
         return;
     }
 
-    if(_writeBuffer.i < _writeBuffer.b.end())
+    if (_writeBuffer.i < _writeBuffer.b.end())
     {
         _delegate->finishWrite(_writeBuffer);
     }
-    else if(!buf.b.empty() && buf.i != buf.b.end())
+    else if (!buf.b.empty() && buf.i != buf.b.end())
     {
         assert(_incoming);
         _delegate->finishWrite(buf);
     }
 
-    if(_state == StateClosed)
+    if (_state == StateClosed)
     {
         _writeBuffer.b.clear();
         return;
@@ -679,9 +687,9 @@ void
 IceInternal::WSTransceiver::startRead(Buffer& buf)
 {
     _readPending = true;
-    if(_state < StateOpened)
+    if (_state < StateOpened)
     {
-        if(_state < StateConnected)
+        if (_state < StateConnected)
         {
             _delegate->startRead(buf);
         }
@@ -692,17 +700,17 @@ IceInternal::WSTransceiver::startRead(Buffer& buf)
         return;
     }
 
-    if(preRead(buf))
+    if (preRead(buf))
     {
-        if(_readState == ReadStatePayload)
+        if (_readState == ReadStatePayload)
         {
             //
             // If the payload length is smaller than what remains to be read, we read
             // no more than the payload length. The remaining of the buffer will be
             // sent over in another frame.
             //
-            size_t readSz = _readPayloadLength  - (buf.i - _readStart);
-            if(static_cast<size_t>(buf.b.end() - buf.i) > readSz)
+            size_t readSz = _readPayloadLength - (buf.i - _readStart);
+            if (static_cast<size_t>(buf.b.end() - buf.i) > readSz)
             {
                 size_t size = buf.b.size();
                 buf.b.resize(buf.i - buf.b.begin() + readSz);
@@ -729,9 +737,9 @@ void
 IceInternal::WSTransceiver::finishRead(Buffer& buf)
 {
     _readPending = false;
-    if(_state < StateOpened)
+    if (_state < StateOpened)
     {
-        if(_state < StateConnected)
+        if (_state < StateConnected)
         {
             _delegate->finishRead(buf);
         }
@@ -742,11 +750,11 @@ IceInternal::WSTransceiver::finishRead(Buffer& buf)
         return;
     }
 
-    if(buf.b.empty() || buf.i == buf.b.end())
+    if (buf.b.empty() || buf.i == buf.b.end())
     {
         // Nothing to do.
     }
-    else if(_readState == ReadStatePayload)
+    else if (_readState == ReadStatePayload)
     {
         _delegate->finishRead(buf);
     }
@@ -755,7 +763,7 @@ IceInternal::WSTransceiver::finishRead(Buffer& buf)
         _delegate->finishRead(_readBuffer);
     }
 
-    if(_state == StateClosed)
+    if (_state == StateClosed)
     {
         _readBuffer.b.clear();
         return;
@@ -784,12 +792,11 @@ IceInternal::WSTransceiver::toDetailedString() const
 }
 
 Ice::ConnectionInfoPtr
-IceInternal::WSTransceiver::getInfo() const
+IceInternal::WSTransceiver::getInfo(bool incoming, string adapterName, string connectionId) const
 {
-    WSConnectionInfoPtr info = ICE_MAKE_SHARED(WSConnectionInfo);
-    info->underlying = _delegate->getInfo();
-    info->headers = _parser->getHeaders();
-    return info;
+    return make_shared<WSConnectionInfo>(
+        _delegate->getInfo(incoming, std::move(adapterName), std::move(connectionId)),
+        _parser->getHeaders());
 }
 
 void
@@ -804,27 +811,30 @@ IceInternal::WSTransceiver::setBufferSize(int rcvSize, int sndSize)
     _delegate->setBufferSize(rcvSize, sndSize);
 }
 
-IceInternal::WSTransceiver::WSTransceiver(const ProtocolInstancePtr& instance, const TransceiverPtr& del,
-                                          const string& host, const string& resource) :
-    _instance(instance),
-    _delegate(del),
-    _host(host),
-    _resource(resource),
-    _incoming(false),
-    _state(StateInitializeDelegate),
-    _parser(new HttpParser),
-    _readState(ReadStateOpcode),
-    _readBufferSize(1024),
-    _readLastFrame(true),
-    _readOpCode(0),
-    _readHeaderLength(0),
-    _readPayloadLength(0),
-    _writeState(WriteStateHeader),
-    _writeBufferSize(16 * 1024),
-    _readPending(false),
-    _writePending(false),
-    _closingInitiator(false),
-    _closingReason(CLOSURE_NORMAL)
+IceInternal::WSTransceiver::WSTransceiver(
+    ProtocolInstancePtr instance,
+    TransceiverPtr del,
+    string host,
+    string resource)
+    : _instance(std::move(instance)),
+      _delegate(std::move(del)),
+      _host(std::move(host)),
+      _resource(std::move(resource)),
+      _incoming(false),
+      _state(StateInitializeDelegate),
+      _parser(make_shared<HttpParser>()),
+      _readState(ReadStateOpcode),
+      _readBufferSize(1024),
+      _readLastFrame(true),
+      _readOpCode(0),
+      _readHeaderLength(0),
+      _readPayloadLength(0),
+      _writeState(WriteStateHeader),
+      _writeBufferSize(16 * 1024),
+      _readPending(false),
+      _writePending(false),
+      _closingInitiator(false),
+      _closingReason(CLOSURE_NORMAL)
 {
     //
     // Use 1KB read and 16KB write buffer sizes. We use 16KB for the
@@ -835,33 +845,31 @@ IceInternal::WSTransceiver::WSTransceiver(const ProtocolInstancePtr& instance, c
     //
 }
 
-IceInternal::WSTransceiver::WSTransceiver(const ProtocolInstancePtr& instance, const TransceiverPtr& del) :
-    _instance(instance),
-    _delegate(del),
-    _incoming(true),
-    _state(StateInitializeDelegate),
-    _parser(new HttpParser),
-    _readState(ReadStateOpcode),
-    _readBufferSize(1024),
-    _readLastFrame(true),
-    _readOpCode(0),
-    _readHeaderLength(0),
-    _readPayloadLength(0),
-    _writeState(WriteStateHeader),
-    _writeBufferSize(1024),
-    _readPending(false),
-    _writePending(false),
-    _closingInitiator(false),
-    _closingReason(CLOSURE_NORMAL)
+IceInternal::WSTransceiver::WSTransceiver(ProtocolInstancePtr instance, TransceiverPtr del)
+    : _instance(std::move(instance)),
+      _delegate(std::move(del)),
+      _incoming(true),
+      _state(StateInitializeDelegate),
+      _parser(make_shared<HttpParser>()),
+      _readState(ReadStateOpcode),
+      _readBufferSize(1024),
+      _readLastFrame(true),
+      _readOpCode(0),
+      _readHeaderLength(0),
+      _readPayloadLength(0),
+      _writeState(WriteStateHeader),
+      _writeBufferSize(1024),
+      _readPending(false),
+      _writePending(false),
+      _closingInitiator(false),
+      _closingReason(CLOSURE_NORMAL)
 {
     //
     // Use 1KB read and write buffer sizes.
     //
 }
 
-IceInternal::WSTransceiver::~WSTransceiver()
-{
-}
+IceInternal::WSTransceiver::~WSTransceiver() = default;
 
 void
 IceInternal::WSTransceiver::handleRequest(Buffer& responseBuffer)
@@ -871,7 +879,7 @@ IceInternal::WSTransceiver::handleRequest(Buffer& responseBuffer)
     //
     // HTTP/1.1
     //
-    if(_parser->versionMajor() != 1 || _parser->versionMinor() != 1)
+    if (_parser->versionMajor() != 1 || _parser->versionMinor() != 1)
     {
         throw WebSocketException("unsupported HTTP version");
     }
@@ -880,38 +888,38 @@ IceInternal::WSTransceiver::handleRequest(Buffer& responseBuffer)
     // "An |Upgrade| header field containing the value 'websocket',
     //  treated as an ASCII case-insensitive value."
     //
-    if(!_parser->getHeader("Upgrade", val, true))
+    if (!_parser->getHeader("Upgrade", val, true))
     {
         throw WebSocketException("missing value for Upgrade field");
     }
-    else if(val != "websocket")
+    else if (val != "websocket")
     {
-        throw WebSocketException("invalid value `" + val + "' for Upgrade field");
+        throw WebSocketException("invalid value '" + val + "' for Upgrade field");
     }
 
     //
     // "A |Connection| header field that includes the token 'Upgrade',
     //  treated as an ASCII case-insensitive value.
     //
-    if(!_parser->getHeader("Connection", val, true))
+    if (!_parser->getHeader("Connection", val, true))
     {
         throw WebSocketException("missing value for Connection field");
     }
-    else if(val.find("upgrade") == string::npos)
+    else if (val.find("upgrade") == string::npos)
     {
-        throw WebSocketException("invalid value `" + val + "' for Connection field");
+        throw WebSocketException("invalid value '" + val + "' for Connection field");
     }
 
     //
     // "A |Sec-WebSocket-Version| header field, with a value of 13."
     //
-    if(!_parser->getHeader("Sec-WebSocket-Version", val, false))
+    if (!_parser->getHeader("Sec-WebSocket-Version", val, false))
     {
         throw WebSocketException("missing value for WebSocket version");
     }
-    else if(val != "13")
+    else if (val != "13")
     {
-        throw WebSocketException("unsupported WebSocket version `" + val + "'");
+        throw WebSocketException("unsupported WebSocket version '" + val + "'");
     }
 
     //
@@ -920,18 +928,18 @@ IceInternal::WSTransceiver::handleRequest(Buffer& responseBuffer)
     //  speak, ordered by preference."
     //
     bool addProtocol = false;
-    if(_parser->getHeader("Sec-WebSocket-Protocol", val, true))
+    if (_parser->getHeader("Sec-WebSocket-Protocol", val, true))
     {
         vector<string> protocols;
-        if(!IceUtilInternal::splitString(val, ",", protocols))
+        if (!IceInternal::splitString(val, ",", protocols))
         {
-            throw WebSocketException("invalid value `" + val + "' for WebSocket protocol");
+            throw WebSocketException("invalid value '" + val + "' for WebSocket protocol");
         }
-        for(vector<string>::iterator p = protocols.begin(); p != protocols.end(); ++p)
+        for (const auto& protocol : protocols)
         {
-            if(IceUtilInternal::trim(*p) != _iceProtocol)
+            if (IceInternal::trim(protocol) != _iceProtocol)
             {
-                throw WebSocketException("unknown value `" + *p + "' for WebSocket protocol");
+                throw WebSocketException("unknown value '" + protocol + "' for WebSocket protocol");
             }
             addProtocol = true;
         }
@@ -942,15 +950,15 @@ IceInternal::WSTransceiver::handleRequest(Buffer& responseBuffer)
     //  value that, when decoded, is 16 bytes in length."
     //
     string key;
-    if(!_parser->getHeader("Sec-WebSocket-Key", key, false))
+    if (!_parser->getHeader("Sec-WebSocket-Key", key, false))
     {
         throw WebSocketException("missing value for WebSocket key");
     }
 
-    vector<unsigned char> decodedKey = Base64::decode(key);
-    if(decodedKey.size() != 16)
+    vector<byte> decodedKey = Base64::decode(key);
+    if (decodedKey.size() != 16)
     {
-        throw WebSocketException("invalid value `" + key + "' for WebSocket key");
+        throw WebSocketException("invalid value '" + key + "' for WebSocket key");
     }
 
     //
@@ -965,7 +973,7 @@ IceInternal::WSTransceiver::handleRequest(Buffer& responseBuffer)
     out << "HTTP/1.1 101 Switching Protocols\r\n"
         << "Upgrade: websocket\r\n"
         << "Connection: Upgrade\r\n";
-    if(addProtocol)
+    if (addProtocol)
     {
         out << "Sec-WebSocket-Protocol: " << _iceProtocol << "\r\n";
     }
@@ -982,9 +990,10 @@ IceInternal::WSTransceiver::handleRequest(Buffer& responseBuffer)
     //
     out << "Sec-WebSocket-Accept: ";
     string input = key + _wsUUID;
-    vector<unsigned char> hash;
-    sha1(reinterpret_cast<const unsigned char*>(&input[0]), input.size(), hash);
-    out << IceInternal::Base64::encode(hash) << "\r\n" << "\r\n"; // EOM
+    vector<byte> hash;
+    sha1(reinterpret_cast<const byte*>(&input[0]), input.size(), hash);
+    out << IceInternal::Base64::encode(hash) << "\r\n"
+        << "\r\n"; // EOM
 
     string str = out.str();
     responseBuffer.b.resize(str.size());
@@ -1000,7 +1009,7 @@ IceInternal::WSTransceiver::handleResponse()
     //
     // HTTP/1.1
     //
-    if(_parser->versionMajor() != 1 || _parser->versionMinor() != 1)
+    if (_parser->versionMajor() != 1 || _parser->versionMinor() != 1)
     {
         throw WebSocketException("unsupported HTTP version");
     }
@@ -1013,11 +1022,11 @@ IceInternal::WSTransceiver::handleResponse()
     //  using a 3xx status code (but clients are not required to follow
     //  them), etc."
     //
-    if(_parser->status() != 101)
+    if (_parser->status() != 101)
     {
         ostringstream out;
         out << "unexpected status value " << _parser->status();
-        if(!_parser->reason().empty())
+        if (!_parser->reason().empty())
         {
             out << ":" << endl << _parser->reason();
         }
@@ -1030,13 +1039,13 @@ IceInternal::WSTransceiver::handleResponse()
     //  insensitive match for the value "websocket", the client MUST
     //  _Fail the WebSocket Connection_."
     //
-    if(!_parser->getHeader("Upgrade", val, true))
+    if (!_parser->getHeader("Upgrade", val, true))
     {
         throw WebSocketException("missing value for Upgrade field");
     }
-    else if(val != "websocket")
+    else if (val != "websocket")
     {
-        throw WebSocketException("invalid value `" + val + "' for Upgrade field");
+        throw WebSocketException("invalid value '" + val + "' for Upgrade field");
     }
 
     //
@@ -1045,13 +1054,13 @@ IceInternal::WSTransceiver::handleResponse()
     //  ASCII case-insensitive match for the value "Upgrade", the client
     //  MUST _Fail the WebSocket Connection_."
     //
-    if(!_parser->getHeader("Connection", val, true))
+    if (!_parser->getHeader("Connection", val, true))
     {
         throw WebSocketException("missing value for Connection field");
     }
-    else if(val.find("upgrade") == string::npos)
+    else if (val.find("upgrade") == string::npos)
     {
-        throw WebSocketException("invalid value `" + val + "' for Connection field");
+        throw WebSocketException("invalid value '" + val + "' for Connection field");
     }
 
     //
@@ -1061,9 +1070,9 @@ IceInternal::WSTransceiver::handleResponse()
     //  subprotocol not requested by the client), the client MUST _Fail
     //  the WebSocket Connection_."
     //
-    if(_parser->getHeader("Sec-WebSocket-Protocol", val, true) && val != _iceProtocol)
+    if (_parser->getHeader("Sec-WebSocket-Protocol", val, true) && val != _iceProtocol)
     {
-        throw WebSocketException("invalid value `" + val + "' for WebSocket protocol");
+        throw WebSocketException("invalid value '" + val + "' for WebSocket protocol");
     }
 
     //
@@ -1075,30 +1084,30 @@ IceInternal::WSTransceiver::handleResponse()
     //  trailing whitespace, the client MUST _Fail the WebSocket
     //  Connection_."
     //
-    if(!_parser->getHeader("Sec-WebSocket-Accept", val, false))
+    if (!_parser->getHeader("Sec-WebSocket-Accept", val, false))
     {
         throw WebSocketException("missing value for Sec-WebSocket-Accept");
     }
     string input = _key + _wsUUID;
-    vector<unsigned char> hash;
-    sha1(reinterpret_cast<const unsigned char*>(&input[0]), input.size(), hash);
-    if(val != IceInternal::Base64::encode(hash))
+    vector<byte> hash;
+    sha1(reinterpret_cast<const byte*>(&input[0]), input.size(), hash);
+    if (val != IceInternal::Base64::encode(hash))
     {
-        throw WebSocketException("invalid value `" + val + "' for Sec-WebSocket-Accept");
+        throw WebSocketException("invalid value '" + val + "' for Sec-WebSocket-Accept");
     }
 }
 
 bool
 IceInternal::WSTransceiver::preRead(Buffer& buf)
 {
-    while(true)
+    while (true)
     {
-        if(_readState == ReadStateOpcode)
+        if (_readState == ReadStateOpcode)
         {
             //
             // Is there enough data available to read the opcode?
             //
-            if(!readBuffered(2))
+            if (!readBuffered(2))
             {
                 return true;
             }
@@ -1108,39 +1117,39 @@ IceInternal::WSTransceiver::preRead(Buffer& buf)
             // last frame. Least-significant four bits hold the
             // opcode.
             //
-            unsigned char ch = static_cast<unsigned char>(*_readI++);
-            _readOpCode = ch & 0xf;
+            byte ch = *_readI++;
+            _readOpCode = static_cast<int>(ch & byte{0xf});
 
             //
             // Remember if last frame if we're going to read a data or
             // continuation frame, this is only for protocol
             // correctness checking purpose.
             //
-            if(_readOpCode == OP_DATA)
+            if (_readOpCode == OP_DATA)
             {
-                if(!_readLastFrame)
+                if (!_readLastFrame)
                 {
                     throw ProtocolException(__FILE__, __LINE__, "invalid data frame, no FIN on previous frame");
                 }
-                _readLastFrame = (ch & FLAG_FINAL) == FLAG_FINAL;
+                _readLastFrame = (ch & byte{FLAG_FINAL}) == byte{FLAG_FINAL};
             }
-            else if(_readOpCode == OP_CONT)
+            else if (_readOpCode == OP_CONT)
             {
-                if(_readLastFrame)
+                if (_readLastFrame)
                 {
                     throw ProtocolException(__FILE__, __LINE__, "invalid continuation frame, previous frame FIN set");
                 }
-                _readLastFrame = (ch & FLAG_FINAL) == FLAG_FINAL;
+                _readLastFrame = (ch & byte{FLAG_FINAL}) == byte{FLAG_FINAL};
             }
 
-            ch = static_cast<unsigned char>(*_readI++);
+            ch = *_readI++;
 
             //
             // Check the MASK bit. Messages sent by a client must be masked;
             // messages sent by a server must not be masked.
             //
-            const bool masked = (ch & FLAG_MASKED) == FLAG_MASKED;
-            if(masked != _incoming)
+            const bool masked = (ch & byte{FLAG_MASKED}) == byte{FLAG_MASKED};
+            if (masked != _incoming)
             {
                 throw ProtocolException(__FILE__, __LINE__, "invalid masking");
             }
@@ -1152,12 +1161,12 @@ IceInternal::WSTransceiver::preRead(Buffer& buf)
             // 126:   The subsequent two bytes contain the payload length
             // 127:   The subsequent eight bytes contain the payload length
             //
-            _readPayloadLength = (ch & 0x7f);
-            if(_readPayloadLength < 126)
+            _readPayloadLength = static_cast<size_t>((ch & byte{0x7f}));
+            if (_readPayloadLength < 126)
             {
                 _readHeaderLength = 0;
             }
-            else if(_readPayloadLength == 126)
+            else if (_readPayloadLength == 126)
             {
                 _readHeaderLength = 2; // Need to read a 16-bit payload length.
             }
@@ -1165,7 +1174,7 @@ IceInternal::WSTransceiver::preRead(Buffer& buf)
             {
                 _readHeaderLength = 8; // Need to read a 64-bit payload length.
             }
-            if(masked)
+            if (masked)
             {
                 _readHeaderLength += 4; // Need to read a 32-bit mask.
             }
@@ -1173,27 +1182,27 @@ IceInternal::WSTransceiver::preRead(Buffer& buf)
             _readState = ReadStateHeader;
         }
 
-        if(_readState == ReadStateHeader)
+        if (_readState == ReadStateHeader)
         {
             //
             // Is there enough data available to read the header?
             //
-            if(_readHeaderLength > 0 && !readBuffered(_readHeaderLength))
+            if (_readHeaderLength > 0 && !readBuffered(_readHeaderLength))
             {
                 return true;
             }
 
-            if(_readPayloadLength == 126)
+            if (_readPayloadLength == 126)
             {
                 _readPayloadLength = static_cast<size_t>(ntohs(*reinterpret_cast<uint16_t*>(_readI)));
                 _readI += 2;
             }
-            else if(_readPayloadLength == 127)
+            else if (_readPayloadLength == 127)
             {
                 assert(_readPayloadLength == 127);
-                Long l = ice_nlltoh(_readI);
+                int64_t l = ice_nlltoh(_readI);
                 _readI += 8;
-                if(l < 0 || l > INT_MAX)
+                if (l < 0 || l > INT_MAX)
                 {
                     ostringstream ostr;
                     ostr << "invalid WebSocket payload length: " << l;
@@ -1205,111 +1214,111 @@ IceInternal::WSTransceiver::preRead(Buffer& buf)
             //
             // Read the mask if this is an incoming connection.
             //
-            if(_incoming)
+            if (_incoming)
             {
                 assert(_readBuffer.i - _readI >= 4); // We must have needed to read the mask.
-                memcpy(_readMask, _readI, 4); // Copy the mask.
+                memcpy(_readMask, _readI, 4);        // Copy the mask.
                 _readI += 4;
             }
 
-            switch(_readOpCode)
-            {
-            case OP_TEXT: // Text frame
-            {
-                throw ProtocolException(__FILE__, __LINE__, "text frames not supported");
-            }
-            case OP_DATA: // Data frame
-            case OP_CONT: // Continuation frame
+            switch (_readOpCode)
             {
-                if(_instance->traceLevel() >= 2)
+                case OP_TEXT: // Text frame
                 {
-                    Trace out(_instance->logger(), _instance->traceCategory());
-                    out << "received " << protocol() << (_readOpCode == OP_DATA ? " data" : " continuation");
-                    out << " frame with payload length of " << _readPayloadLength;
-                    out << " bytes\n" << toString();
-                }
-
-                if(_readPayloadLength <= 0)
-                {
-                    throw ProtocolException(__FILE__, __LINE__, "payload length is 0");
+                    throw ProtocolException(__FILE__, __LINE__, "text frames not supported");
                 }
-                _readState = ReadStatePayload;
-                assert(buf.i != buf.b.end());
-                _readFrameStart = buf.i;
-                break;
-            }
-            case OP_CLOSE: // Connection close
-            {
-                if(_instance->traceLevel() >= 2)
+                case OP_DATA: // Data frame
+                case OP_CONT: // Continuation frame
                 {
-                    Trace out(_instance->logger(), _instance->traceCategory());
-                    out << "received " << protocol() << " connection close frame\n" << toString();
-                }
+                    if (_instance->traceLevel() >= 2)
+                    {
+                        Trace out(_instance->logger(), _instance->traceCategory());
+                        out << "received " << protocol() << (_readOpCode == OP_DATA ? " data" : " continuation");
+                        out << " frame with payload length of " << _readPayloadLength;
+                        out << " bytes\n" << toString();
+                    }
 
-                State s = _nextState == StateOpened ? _state : _nextState;
-                if(s == StateClosingRequestPending)
+                    if (_readPayloadLength <= 0)
+                    {
+                        throw ProtocolException(__FILE__, __LINE__, "payload length is 0");
+                    }
+                    _readState = ReadStatePayload;
+                    assert(buf.i != buf.b.end());
+                    _readFrameStart = buf.i;
+                    break;
+                }
+                case OP_CLOSE: // Connection close
                 {
-                    //
-                    // If we receive a close frame while we were actually
-                    // waiting to send one, change the role and send a
-                    // close frame response.
-                    //
-                    if(!_closingInitiator)
+                    if (_instance->traceLevel() >= 2)
                     {
-                        _closingInitiator = true;
+                        Trace out(_instance->logger(), _instance->traceCategory());
+                        out << "received " << protocol() << " connection close frame\n" << toString();
                     }
-                    if(_state == StateClosingRequestPending)
+
+                    State s = _nextState == StateOpened ? _state : _nextState;
+                    if (s == StateClosingRequestPending)
                     {
-                        _state = StateClosingResponsePending;
+                        //
+                        // If we receive a close frame while we were actually
+                        // waiting to send one, change the role and send a
+                        // close frame response.
+                        //
+                        if (!_closingInitiator)
+                        {
+                            _closingInitiator = true;
+                        }
+                        if (_state == StateClosingRequestPending)
+                        {
+                            _state = StateClosingResponsePending;
+                        }
+                        else
+                        {
+                            _nextState = StateClosingResponsePending;
+                        }
+                        return false; // No longer interested in reading
                     }
                     else
                     {
-                        _nextState = StateClosingResponsePending;
+                        throw ConnectionLostException(__FILE__, __LINE__);
                     }
-                    return false; // No longer interested in reading
                 }
-                else
+                case OP_PING:
                 {
-                    throw ConnectionLostException(__FILE__, __LINE__, 0);
+                    if (_instance->traceLevel() >= 2)
+                    {
+                        Trace out(_instance->logger(), _instance->traceCategory());
+                        out << "received " << protocol() << " connection ping frame\n" << toString();
+                    }
+                    _readState = ReadStateControlFrame;
+                    break;
                 }
-            }
-            case OP_PING:
-            {
-                if(_instance->traceLevel() >= 2)
+                case OP_PONG: // Pong
                 {
-                    Trace out(_instance->logger(), _instance->traceCategory());
-                    out << "received " << protocol() << " connection ping frame\n" << toString();
+                    if (_instance->traceLevel() >= 2)
+                    {
+                        Trace out(_instance->logger(), _instance->traceCategory());
+                        out << "received " << protocol() << " connection pong frame\n" << toString();
+                    }
+                    _readState = ReadStateControlFrame;
+                    break;
                 }
-                _readState = ReadStateControlFrame;
-                break;
-            }
-            case OP_PONG: // Pong
-            {
-                if(_instance->traceLevel() >= 2)
+                default:
                 {
-                    Trace out(_instance->logger(), _instance->traceCategory());
-                    out << "received " << protocol() << " connection pong frame\n" << toString();
+                    ostringstream ostr;
+                    ostr << "unsupported opcode: " << _readOpCode;
+                    throw ProtocolException(__FILE__, __LINE__, ostr.str());
                 }
-                _readState = ReadStateControlFrame;
-                break;
-            }
-            default:
-            {
-                ostringstream ostr;
-                ostr << "unsupported opcode: " << _readOpCode;
-                throw ProtocolException(__FILE__, __LINE__, ostr.str());
-            }
             }
         }
 
-        if(_readState == ReadStateControlFrame)
+        if (_readState == ReadStateControlFrame)
         {
-            if(_readPayloadLength > 0 && !readBuffered(_readPayloadLength))
+            if (_readPayloadLength > 0 && !readBuffered(_readPayloadLength))
             {
                 return true;
             }
 
-            if(_readPayloadLength > 0 && _readOpCode == OP_PING)
+            if (_readPayloadLength > 0 && _readOpCode == OP_PING)
             {
                 _pingPayload.clear();
                 _pingPayload.resize(_readPayloadLength);
@@ -1319,13 +1328,13 @@ IceInternal::WSTransceiver::preRead(Buffer& buf)
             _readI += _readPayloadLength;
             _readPayloadLength = 0;
 
-            if(_readOpCode == OP_PING)
+            if (_readOpCode == OP_PING)
             {
-                if(_state == StateOpened)
+                if (_state == StateOpened)
                 {
                     _state = StatePongPending; // Send pong frame now
                 }
-                else if(_nextState < StatePongPending)
+                else if (_nextState < StatePongPending)
                 {
                     _nextState = StatePongPending; // Send pong frame next
                 }
@@ -1338,7 +1347,7 @@ IceInternal::WSTransceiver::preRead(Buffer& buf)
             _readState = ReadStateOpcode;
         }
 
-        if(_readState == ReadStatePayload)
+        if (_readState == ReadStatePayload)
         {
             //
             // This must be assigned before the check for the buffer. If the buffer is empty
@@ -1346,18 +1355,18 @@ IceInternal::WSTransceiver::preRead(Buffer& buf)
             //
             _readStart = buf.i;
 
-            if(buf.b.empty() || buf.i == buf.b.end())
+            if (buf.b.empty() || buf.i == buf.b.end())
             {
                 return false;
             }
 
             size_t n = min(static_cast<size_t>(_readBuffer.i - _readI), static_cast<size_t>(buf.b.end() - buf.i));
 
-            if(n > _readPayloadLength)
+            if (n > _readPayloadLength)
             {
                 n = _readPayloadLength;
             }
-            if(n > 0)
+            if (n > 0)
             {
                 memcpy(buf.i, _readI, n);
                 buf.i += n;
@@ -1375,24 +1384,24 @@ IceInternal::WSTransceiver::preRead(Buffer& buf)
 bool
 IceInternal::WSTransceiver::postRead(Buffer& buf)
 {
-    if(_readState != ReadStatePayload)
+    if (_readState != ReadStatePayload)
     {
         return _readStart < _readBuffer.i; // Returns true if data was read.
     }
 
-    if(_readStart == buf.i)
+    if (_readStart == buf.i)
     {
         return false; // Nothing was read or nothing to read.
     }
     assert(_readStart < buf.i);
 
-    if(_incoming)
+    if (_incoming)
     {
         //
         // Unmask the data we just read.
         //
         IceInternal::Buffer::Container::iterator p = _readStart;
-        for(size_t n = static_cast<size_t>(_readStart - _readFrameStart); p < buf.i; ++p, ++n)
+        for (auto n = static_cast<size_t>(_readStart - _readFrameStart); p < buf.i; ++p, ++n)
         {
             *p ^= _readMask[n % 4];
         }
@@ -1400,7 +1409,7 @@ IceInternal::WSTransceiver::postRead(Buffer& buf)
 
     _readPayloadLength -= static_cast<size_t>(buf.i - _readStart);
     _readStart = buf.i;
-    if(_readPayloadLength == 0)
+    if (_readPayloadLength == 0)
     {
         //
         // We've read the complete payload, we're ready to read a new frame.
@@ -1413,11 +1422,11 @@ IceInternal::WSTransceiver::postRead(Buffer& buf)
 bool
 IceInternal::WSTransceiver::preWrite(Buffer& buf)
 {
-    if(_writeState == WriteStateHeader)
+    if (_writeState == WriteStateHeader)
     {
-        if(_state == StateOpened)
+        if (_state == StateOpened)
         {
-            if(buf.b.empty() || buf.i == buf.b.end())
+            if (buf.b.empty() || buf.i == buf.b.end())
             {
                 return false;
             }
@@ -1427,7 +1436,7 @@ IceInternal::WSTransceiver::preWrite(Buffer& buf)
 
             _writeState = WriteStatePayload;
         }
-        else if(_state == StatePingPending)
+        else if (_state == StatePingPending)
         {
             prepareWriteHeader(OP_PING, 0); // Don't send any payload
 
@@ -1435,12 +1444,12 @@ IceInternal::WSTransceiver::preWrite(Buffer& buf)
             _writeState = WriteStateControlFrame;
             _writeBuffer.i = _writeBuffer.b.begin();
         }
-        else if(_state == StatePongPending)
+        else if (_state == StatePongPending)
         {
             prepareWriteHeader(OP_PONG, _pingPayload.size());
-            if(_pingPayload.size() > static_cast<size_t>(_writeBuffer.b.end() - _writeBuffer.i))
+            if (_pingPayload.size() > static_cast<size_t>(_writeBuffer.b.end() - _writeBuffer.i))
             {
-                size_t pos = static_cast<size_t>(_writeBuffer.i - _writeBuffer.b.begin());
+                auto pos = static_cast<size_t>(_writeBuffer.i - _writeBuffer.b.begin());
                 _writeBuffer.b.resize(pos + _pingPayload.size());
                 _writeBuffer.i = _writeBuffer.b.begin() + pos;
             }
@@ -1452,14 +1461,15 @@ IceInternal::WSTransceiver::preWrite(Buffer& buf)
             _writeState = WriteStateControlFrame;
             _writeBuffer.i = _writeBuffer.b.begin();
         }
-        else if((_state == StateClosingRequestPending && !_closingInitiator) ||
-                (_state == StateClosingResponsePending && _closingInitiator))
+        else if (
+            (_state == StateClosingRequestPending && !_closingInitiator) ||
+            (_state == StateClosingResponsePending && _closingInitiator))
         {
             prepareWriteHeader(OP_CLOSE, 2);
 
             // Write closing reason
             *reinterpret_cast<uint16_t*>(_writeBuffer.i) = htons(static_cast<uint16_t>(_closingReason));
-            if(!_incoming)
+            if (!_incoming)
             {
                 *_writeBuffer.i++ ^= _writeMask[0];
                 *_writeBuffer.i++ ^= _writeMask[1];
@@ -1482,7 +1492,7 @@ IceInternal::WSTransceiver::preWrite(Buffer& buf)
         _writePayloadLength = 0;
     }
 
-    if(_writeState == WriteStatePayload)
+    if (_writeState == WriteStatePayload)
     {
         //
         // For an outgoing connection, each message must be masked with a random
@@ -1493,34 +1503,35 @@ IceInternal::WSTransceiver::preWrite(Buffer& buf)
         // copying.
         //
 
-        if(!_incoming && (_writePayloadLength == 0 || _writeBuffer.i == _writeBuffer.b.end()))
+        if (!_incoming && (_writePayloadLength == 0 || _writeBuffer.i == _writeBuffer.b.end()))
         {
-            if(_writeBuffer.i == _writeBuffer.b.end())
+            if (_writeBuffer.i == _writeBuffer.b.end())
             {
                 _writeBuffer.i = _writeBuffer.b.begin();
             }
 
-            size_t n = static_cast<size_t>(buf.i - buf.b.begin());
-            for(; n < buf.b.size() && _writeBuffer.i < _writeBuffer.b.end(); ++_writeBuffer.i, ++n)
+            auto n = static_cast<size_t>(buf.i - buf.b.begin());
+            for (; n < buf.b.size() && _writeBuffer.i < _writeBuffer.b.end(); ++_writeBuffer.i, ++n)
             {
                 *_writeBuffer.i = buf.b[n] ^ _writeMask[n % 4];
             }
             _writePayloadLength = n;
-            if(_writeBuffer.i < _writeBuffer.b.end())
+            if (_writeBuffer.i < _writeBuffer.b.end())
             {
                 _writeBuffer.b.resize(static_cast<size_t>(_writeBuffer.i - _writeBuffer.b.begin()));
             }
             _writeBuffer.i = _writeBuffer.b.begin();
         }
-        else if(_writePayloadLength == 0)
+        else if (_writePayloadLength == 0)
         {
-            size_t n = min(static_cast<size_t>(_writeBuffer.b.end() - _writeBuffer.i),
-                           static_cast<size_t>(buf.b.end() - buf.i));
+            size_t n =
+                min(static_cast<size_t>(_writeBuffer.b.end() - _writeBuffer.i),
+                    static_cast<size_t>(buf.b.end() - buf.i));
             memcpy(_writeBuffer.i, buf.i, n);
             _writeBuffer.i += n;
             buf.i += n;
             _writePayloadLength = n;
-            if(_writeBuffer.i < _writeBuffer.b.end())
+            if (_writeBuffer.i < _writeBuffer.b.end())
             {
                 _writeBuffer.b.resize(static_cast<size_t>(_writeBuffer.i - _writeBuffer.b.begin()));
             }
@@ -1537,36 +1548,37 @@ IceInternal::WSTransceiver::preWrite(Buffer& buf)
 bool
 IceInternal::WSTransceiver::postWrite(Buffer& buf)
 {
-    if(_state > StateOpened && _writeState == WriteStateControlFrame)
+    if (_state > StateOpened && _writeState == WriteStateControlFrame)
     {
-        if(_writeBuffer.i == _writeBuffer.b.end())
+        if (_writeBuffer.i == _writeBuffer.b.end())
         {
-            if(_state == StatePingPending)
+            if (_state == StatePingPending)
             {
-                if(_instance->traceLevel() >= 2)
+                if (_instance->traceLevel() >= 2)
                 {
                     Trace out(_instance->logger(), _instance->traceCategory());
                     out << "sent " << protocol() << " connection ping frame\n" << toString();
                 }
             }
-            else if(_state == StatePongPending)
+            else if (_state == StatePongPending)
             {
-                if(_instance->traceLevel() >= 2)
+                if (_instance->traceLevel() >= 2)
                 {
                     Trace out(_instance->logger(), _instance->traceCategory());
                     out << "sent " << protocol() << " connection pong frame\n" << toString();
                 }
             }
-            else if((_state == StateClosingRequestPending && !_closingInitiator) ||
-                    (_state == StateClosingResponsePending && _closingInitiator))
+            else if (
+                (_state == StateClosingRequestPending && !_closingInitiator) ||
+                (_state == StateClosingResponsePending && _closingInitiator))
             {
-                if(_instance->traceLevel() >= 2)
+                if (_instance->traceLevel() >= 2)
                 {
                     Trace out(_instance->logger(), _instance->traceCategory());
                     out << "sent " << protocol() << " connection close frame\n" << toString();
                 }
 
-                if(_state == StateClosingRequestPending && !_closingInitiator)
+                if (_state == StateClosingRequestPending && !_closingInitiator)
                 {
                     _writeState = WriteStateHeader;
                     _state = StateClosingResponsePending;
@@ -1574,10 +1586,10 @@ IceInternal::WSTransceiver::postWrite(Buffer& buf)
                 }
                 else
                 {
-                    throw ConnectionLostException(__FILE__, __LINE__, 0);
+                    throw ConnectionLostException(__FILE__, __LINE__);
                 }
             }
-            else if(_state == StateClosed)
+            else if (_state == StateClosed)
             {
                 return false;
             }
@@ -1592,26 +1604,25 @@ IceInternal::WSTransceiver::postWrite(Buffer& buf)
         }
     }
 
-    if((!_incoming || buf.i == buf.b.begin()) && _writePayloadLength > 0)
+    if ((!_incoming || buf.i == buf.b.begin()) && _writePayloadLength > 0)
     {
-        if(_writeBuffer.i == _writeBuffer.b.end())
+        if (_writeBuffer.i == _writeBuffer.b.end())
         {
             buf.i = buf.b.begin() + _writePayloadLength;
         }
     }
 
-    if(buf.b.empty() || buf.i == buf.b.end())
+    if (buf.b.empty() || buf.i == buf.b.end())
     {
         _writeState = WriteStateHeader;
-        if(_state == StatePingPending ||
-           _state == StatePongPending ||
-           (_state == StateClosingRequestPending && !_closingInitiator) ||
-           (_state == StateClosingResponsePending && _closingInitiator))
+        if (_state == StatePingPending || _state == StatePongPending ||
+            (_state == StateClosingRequestPending && !_closingInitiator) ||
+            (_state == StateClosingResponsePending && _closingInitiator))
         {
             return true;
         }
     }
-    else if(_state == StateOpened)
+    else if (_state == StateOpened)
     {
         return true;
     }
@@ -1621,17 +1632,17 @@ IceInternal::WSTransceiver::postWrite(Buffer& buf)
 bool
 IceInternal::WSTransceiver::readBuffered(IceInternal::Buffer::Container::size_type sz)
 {
-    if(_readI == _readBuffer.i)
+    if (_readI == _readBuffer.i)
     {
         _readBuffer.b.resize(_readBufferSize);
         _readI = _readBuffer.i = _readBuffer.b.begin();
     }
     else
     {
-        size_t available = static_cast<size_t>(_readBuffer.i - _readI);
-        if(available < sz)
+        auto available = static_cast<size_t>(_readBuffer.i - _readI);
+        if (available < sz)
         {
-            if(_readI != &_readBuffer.b[0])
+            if (_readI != &_readBuffer.b[0])
             {
                 memmove(&_readBuffer.b[0], _readI, available);
             }
@@ -1642,7 +1653,7 @@ IceInternal::WSTransceiver::readBuffered(IceInternal::Buffer::Container::size_ty
     }
 
     _readStart = _readBuffer.i;
-    if(_readI + sz > _readBuffer.i)
+    if (_readI + sz > _readBuffer.i)
     {
         return false; // Not enough read.
     }
@@ -1651,7 +1662,7 @@ IceInternal::WSTransceiver::readBuffered(IceInternal::Buffer::Container::size_ty
 }
 
 void
-IceInternal::WSTransceiver::prepareWriteHeader(Byte opCode, IceInternal::Buffer::Container::size_type payloadLength)
+IceInternal::WSTransceiver::prepareWriteHeader(uint8_t opCode, IceInternal::Buffer::Container::size_type payloadLength)
 {
     //
     // We need to prepare the frame header.
@@ -1662,42 +1673,42 @@ IceInternal::WSTransceiver::prepareWriteHeader(Byte opCode, IceInternal::Buffer:
     //
     // Set the opcode - this is the one and only data frame.
     //
-    *_writeBuffer.i++ = static_cast<Byte>(opCode | FLAG_FINAL);
+    *_writeBuffer.i++ = static_cast<byte>(opCode | FLAG_FINAL);
 
     //
     // Set the payload length.
     //
-    if(payloadLength <= 125)
+    if (payloadLength <= 125)
     {
-        *_writeBuffer.i++ = static_cast<Byte>(payloadLength);
+        *_writeBuffer.i++ = static_cast<byte>(payloadLength);
     }
-    else if(payloadLength > 125 && payloadLength <= USHRT_MAX)
+    else if (payloadLength > 125 && payloadLength <= USHRT_MAX)
     {
         //
         // Use an extra 16 bits to encode the payload length.
         //
-        *_writeBuffer.i++ = static_cast<Byte>(126);
+        *_writeBuffer.i++ = byte{126};
         *reinterpret_cast<uint16_t*>(_writeBuffer.i) = htons(static_cast<uint16_t>(payloadLength));
         _writeBuffer.i += 2;
     }
-    else if(payloadLength > USHRT_MAX)
+    else if (payloadLength > USHRT_MAX)
     {
         //
         // Use an extra 64 bits to encode the payload length.
         //
-        *_writeBuffer.i++ = static_cast<Byte>(127);
-        ice_htonll(static_cast<Long>(payloadLength), _writeBuffer.i);
+        *_writeBuffer.i++ = byte{127};
+        ice_htonll(static_cast<int64_t>(payloadLength), _writeBuffer.i);
         _writeBuffer.i += 8;
     }
 
-    if(!_incoming)
+    if (!_incoming)
     {
         //
         // Add a random 32-bit mask to every outgoing frame, copy the payload data,
         // and apply the mask.
         //
-        _writeBuffer.b[1] |= FLAG_MASKED;
-        IceUtilInternal::generateRandom(reinterpret_cast<char*>(_writeMask), sizeof(_writeMask));
+        _writeBuffer.b[1] |= byte{FLAG_MASKED};
+        IceInternal::generateRandom(reinterpret_cast<char*>(_writeMask), sizeof(_writeMask));
         memcpy(_writeBuffer.i, _writeMask, sizeof(_writeMask));
         _writeBuffer.i += sizeof(_writeMask);
     }