MbedTls-enabled rtc::WebSocketServer causes double mutex lock exception

[dmllr]

The library build with MbedTLS enabled leads to a double mutex lock if rtc::WebSocketServer used. The issue is discovered in libdatachannel v0.42.0.

Double lock only occurs in a moment of receiving the Ping-Pong message (size of the message is 0) as shown in a backtrace below:

	do {
-->		std::lock_guard lock(mSslMutex);  <-- Second lock here causing "device or resource busy" exception
		ret = mbedtls_ssl_write(&mSsl, reinterpret_cast<const unsigned char *>(message->data()),
		                        int(message->size()));
	} while (ret == MBEDTLS_ERR_SSL_WANT_WRITE);

rtc::impl::TlsTransport::send(shared_ptr<…>) tlstransport.cpp:401
rtc::impl::Transport::outgoing(shared_ptr<…>) transport.cpp:74
rtc::impl::WsTransport::sendFrame(const rtc::impl::WsTransport::Frame &) wstransport.cpp:412
rtc::impl::WsTransport::incoming(shared_ptr<…>) wstransport.cpp:148
rtc::synchronized_callback::call(shared_ptr<…>) utils.hpp:95
rtc::synchronized_callback::operator()(shared_ptr<…>) utils.hpp:81
rtc::impl::Transport::recv(shared_ptr<…>) transport.cpp:55
rtc::impl::TlsTransport::ReadCallback(void *, unsigned char *, unsigned long long) tlstransport.cpp:533
mbedtls_ssl_fetch_input(mbedtls_ssl_context *, unsigned long long) ssl_msg.c:2310
ssl_get_next_record(mbedtls_ssl_context *) ssl_msg.c:4859
mbedtls_ssl_read_record(mbedtls_ssl_context *, unsigned int) ssl_msg.c:4214
mbedtls_ssl_read(mbedtls_ssl_context *, unsigned char *, unsigned long long) ssl_msg.c:5846
rtc::impl::TlsTransport::doRecv() tlstransport.cpp:472
^^^ Ping (zero-zized) message is about to receive here
	{
-->		std::lock_guard lock(mSslMutex); <-- First lock occurs here
		ret = mbedtls_ssl_read(&mSsl, reinterpret_cast<unsigned char *>(buffer),
		                       bufferSize);
	}

How to reproduce:

WebSocket server's code depending on libdatachannel built with MbedTls enabled

  auto config = rtc::WebSocketServer::Configuration();
  config.certificatePemFile = "cert.pem";
  config.keyPemFile = "key.pem";
  config.enableTls = true;

  auto server = std::make_unique<rtc::WebSocketServer>(config);
  server->onClient([this](std::shared_ptr<rtc::WebSocket> ws) {
    // whatever HandleConnection(ws);
  });
  while (true) {
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
  }

WebSocket client's code depending on libdatachannel built with MbedTls enabled

  auto config = rtc::WebSocketConfiguration{};
  auto ws = std::make_unique<rtc::WebSocket>(config);
  ws->onOpen([]() {
    LOGI << "OnWebSocketOpen();";
  });
  ws->onClosed([]() {
    LOGI << "OnWebSocketClosed();";
  });
  ws->onError([](const std::string& error) {
    LOGI << "OnWebSocketError(error);";
  });
  ws->onMessage(nullptr, [](const std::string& data) {
    LOGI << "OnWebSocketMessage(data);";
  });
  ws->open("wss://127.0.0.1:8080");
  while (true) {
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
  }

After a few seconds, the server drops the connection.