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 taking a new mutex
that's used to synchronize access to _readyState.

I've first tried _readyState.exchange() which seemed promising, but still
crashed once in a while as racing threads do not wait for the
_onCloseCallback() to complete.

Author: awelzel

ixwebsocket/IXWebSocketTransport.cpp

@@ -200,11 +200,14 @@ namespace ix
 
     WebSocketTransport::ReadyState WebSocketTransport::getReadyState() const
     {
+        std::lock_guard<std::mutex> lock(_setReadyStateMutex);
         return _readyState;
     }
 
     void WebSocketTransport::setReadyState(ReadyState readyState)
     {
+        std::lock_guard<std::mutex> lock(_setReadyStateMutex);
+
         // No state change, return
         if (_readyState == readyState) return;
 

ixwebsocket/IXWebSocketTransport.h

@@ -184,7 +184,9 @@ namespace ix
         std::mutex _socketMutex;
 
         // Hold the state of the connection (OPEN, CLOSED, etc...)
-        std::atomic<ReadyState> _readyState;
+        ReadyState _readyState;
+        // Mutex to prevent racing in setReadyState()
+        mutable std::mutex _setReadyStateMutex;
 
         OnCloseCallback _onCloseCallback;
         std::string _closeReason;