IXWebSocketTransport::setReadyState(): Run under lock

When setReadyState(CLOSED) is executed from two different threads (the
server's thread, detecting a close trying to receive and a separate
sending thread), there is a race where both see _readyState as non-CLOSED
and both execute the _onCloseCallback().  Worse, the server's thread might
be returning from ->run(), unsetting the callback while the other thread
is still about to call the _onCloseCallback(), resulting in a crash
rather than "just" a duplicate invocation of the callback.

This change ensures that setReadyState() *and* the_onCloseCallback()
are executed by a single thread till completion, by introducing a new
_setReadyStateMutex instance held during setReadyState() execution.

Author: awelzel

ixwebsocket/IXWebSocketTransport.cpp

@@ -205,6 +205,12 @@ namespace ix
 
     void WebSocketTransport::setReadyState(ReadyState readyState)
     {
+        // Lock the _setReadyStateMutex for the duration of this
+        // method. This ensures that only a single thread runs the
+        // logic below avoiding concurrent execution of the
+        // close callback my multiple threads at the same time.
+        std::lock_guard<std::mutex> lock(_setReadyStateMutex);
+
         // No state change, return
         if (_readyState == readyState) return;
 

ixwebsocket/IXWebSocketTransport.h

@@ -185,6 +185,8 @@ namespace ix
 
         // Hold the state of the connection (OPEN, CLOSED, etc...)
         std::atomic<ReadyState> _readyState;
+        // Mutex to serialize setReadyState() execution.
+        std::mutex _setReadyStateMutex;
 
         OnCloseCallback _onCloseCallback;
         std::string _closeReason;