mediasoup 3.13.21 → 3.13.23

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "mediasoup",
-	"version": "3.13.21",
+	"version": "3.13.23",
 	"description": "Cutting Edge WebRTC Video Conferencing",
 	"contributors": [
 		"Iñaki Baz Castillo <ibc@aliax.net> (https://inakibaz.me)",
@@ -110,10 +110,10 @@
 		"@octokit/rest": "^20.0.2",
 		"@types/debug": "^4.1.12",
 		"@types/jest": "^29.5.12",
-		"@types/node": "^20.11.19",
-		"@typescript-eslint/eslint-plugin": "^7.0.2",
-		"@typescript-eslint/parser": "^7.0.2",
-		"eslint": "^8.56.0",
+		"@types/node": "^20.11.20",
+		"@typescript-eslint/eslint-plugin": "^7.1.0",
+		"@typescript-eslint/parser": "^7.1.0",
+		"eslint": "^8.57.0",
 		"eslint-config-prettier": "^9.1.0",
 		"eslint-plugin-jest": "^27.9.0",
 		"eslint-plugin-prettier": "^5.1.3",

package/worker/include/RTC/DtlsTransport.hpp

@@ -152,6 +152,8 @@ namespace RTC
 			return this->localRole;
 		}
 		void SendApplicationData(const uint8_t* data, size_t len);
+		// This method must be public since it's called within an OpenSSL callback.
+		void SendDtlsData(const uint8_t* data, size_t len);
 
 	private:
 		bool IsRunning() const
@@ -173,7 +175,6 @@ namespace RTC
 		}
 		void Reset();
 		bool CheckStatus(int returnCode);
-		void SendPendingOutgoingDtlsData();
 		bool SetTimeout();
 		bool ProcessHandshake();
 		bool CheckRemoteFingerprint();

package/worker/src/RTC/Codecs/H264.cpp

@@ -161,7 +161,7 @@ namespace RTC
 		{
 			MS_TRACE();
 
-			MS_DUMP("<PayloadDescriptor>");
+			MS_DUMP("<H264::PayloadDescriptor>");
 			MS_DUMP(
 			  "  s:%" PRIu8 "|e:%" PRIu8 "|i:%" PRIu8 "|d:%" PRIu8 "|b:%" PRIu8,
 			  this->s,
@@ -171,18 +171,18 @@ namespace RTC
 			  this->b);
 			if (this->hasTid)
 			{
-				MS_DUMP("  tid        : %" PRIu8, this->tid);
+				MS_DUMP("  tid: %" PRIu8, this->tid);
 			}
 			if (this->hasLid)
 			{
-				MS_DUMP("  lid        : %" PRIu8, this->lid);
+				MS_DUMP("  lid: %" PRIu8, this->lid);
 			}
 			if (this->hasTl0picidx)
 			{
-				MS_DUMP("  tl0picidx  : %" PRIu8, this->tl0picidx);
+				MS_DUMP("  tl0picidx: %" PRIu8, this->tl0picidx);
 			}
-			MS_DUMP("  isKeyFrame : %s", this->isKeyFrame ? "true" : "false");
-			MS_DUMP("</PayloadDescriptor>");
+			MS_DUMP("  isKeyFrame: %s", this->isKeyFrame ? "true" : "false");
+			MS_DUMP("</H264::PayloadDescriptor>");
 		}
 
 		H264::PayloadDescriptorHandler::PayloadDescriptorHandler(H264::PayloadDescriptor* payloadDescriptor)

package/worker/src/RTC/Codecs/H264_SVC.cpp

@@ -251,7 +251,7 @@ namespace RTC
 		{
 			MS_TRACE();
 
-			MS_DUMP("<PayloadDescriptor>");
+			MS_DUMP("<H264_SVC::PayloadDescriptor>");
 			MS_DUMP(
 			  "  s:%" PRIu8 "|e:%" PRIu8 "|i:%" PRIu8 "|d:%" PRIu8 "|b:%" PRIu8,
 			  this->s,
@@ -259,12 +259,12 @@ namespace RTC
 			  this->i,
 			  this->d,
 			  this->b);
-			MS_DUMP("  hasSlIndex           : %s", this->hasSlIndex ? "true" : "false");
-			MS_DUMP("  hasTlIndex           : %s", this->hasTlIndex ? "true" : "false");
-			MS_DUMP("  tl0picidx            : %" PRIu8, this->tl0picidx);
-			MS_DUMP("  noIntLayerPredFlag   : %" PRIu8, this->noIntLayerPredFlag);
-			MS_DUMP("  isKeyFrame           : %s", this->isKeyFrame ? "true" : "false");
-			MS_DUMP("</PayloadDescriptor>");
+			MS_DUMP("  hasSlIndex: %s", this->hasSlIndex ? "true" : "false");
+			MS_DUMP("  hasTlIndex: %s", this->hasTlIndex ? "true" : "false");
+			MS_DUMP("  tl0picidx: %" PRIu8, this->tl0picidx);
+			MS_DUMP("  noIntLayerPredFlag: %" PRIu8, this->noIntLayerPredFlag);
+			MS_DUMP("  isKeyFrame: %s", this->isKeyFrame ? "true" : "false");
+			MS_DUMP("</H264_SVC::PayloadDescriptor>");
 		}
 
 		H264_SVC::PayloadDescriptorHandler::PayloadDescriptorHandler(

package/worker/src/RTC/Codecs/Opus.cpp

@@ -45,9 +45,9 @@ namespace RTC
 		{
 			MS_TRACE();
 
-			MS_DUMP("<PayloadDescriptor>");
-			MS_DUMP("  isDtx : %s", this->isDtx ? "true" : "false");
-			MS_DUMP("</PayloadDescriptor>");
+			MS_DUMP("<Opus::PayloadDescriptor>");
+			MS_DUMP("  isDtx: %s", this->isDtx ? "true" : "false");
+			MS_DUMP("</Opus::PayloadDescriptor>");
 		}
 
 		Opus::PayloadDescriptorHandler::PayloadDescriptorHandler(Opus::PayloadDescriptor* payloadDescriptor)

package/worker/src/RTC/Codecs/VP8.cpp

@@ -167,25 +167,25 @@ namespace RTC
 		{
 			MS_TRACE();
 
-			MS_DUMP("<PayloadDescriptor>");
+			MS_DUMP("<VP8::PayloadDescriptor>");
 			MS_DUMP(
 			  "  i:%" PRIu8 "|l:%" PRIu8 "|t:%" PRIu8 "|k:%" PRIu8, this->i, this->l, this->t, this->k);
-			MS_DUMP("  extended             : %" PRIu8, this->extended);
-			MS_DUMP("  nonReference         : %" PRIu8, this->nonReference);
-			MS_DUMP("  start                : %" PRIu8, this->start);
-			MS_DUMP("  partitionIndex       : %" PRIu8, this->partitionIndex);
-			MS_DUMP("  pictureId            : %" PRIu16, this->pictureId);
-			MS_DUMP("  tl0PictureIndex      : %" PRIu8, this->tl0PictureIndex);
-			MS_DUMP("  tlIndex              : %" PRIu8, this->tlIndex);
-			MS_DUMP("  y                    : %" PRIu8, this->y);
-			MS_DUMP("  keyIndex             : %" PRIu8, this->keyIndex);
-			MS_DUMP("  isKeyFrame           : %s", this->isKeyFrame ? "true" : "false");
-			MS_DUMP("  hasPictureId         : %s", this->hasPictureId ? "true" : "false");
-			MS_DUMP("  hasOneBytePictureId  : %s", this->hasOneBytePictureId ? "true" : "false");
-			MS_DUMP("  hasTwoBytesPictureId : %s", this->hasTwoBytesPictureId ? "true" : "false");
-			MS_DUMP("  hasTl0PictureIndex   : %s", this->hasTl0PictureIndex ? "true" : "false");
-			MS_DUMP("  hasTlIndex           : %s", this->hasTlIndex ? "true" : "false");
-			MS_DUMP("</PayloadDescriptor>");
+			MS_DUMP("  extended: %" PRIu8, this->extended);
+			MS_DUMP("  nonReference: %" PRIu8, this->nonReference);
+			MS_DUMP("  start: %" PRIu8, this->start);
+			MS_DUMP("  partitionIndex: %" PRIu8, this->partitionIndex);
+			MS_DUMP("  pictureId: %" PRIu16, this->pictureId);
+			MS_DUMP("  tl0PictureIndex: %" PRIu8, this->tl0PictureIndex);
+			MS_DUMP("  tlIndex: %" PRIu8, this->tlIndex);
+			MS_DUMP("  y: %" PRIu8, this->y);
+			MS_DUMP("  keyIndex: %" PRIu8, this->keyIndex);
+			MS_DUMP("  isKeyFrame: %s", this->isKeyFrame ? "true" : "false");
+			MS_DUMP("  hasPictureId: %s", this->hasPictureId ? "true" : "false");
+			MS_DUMP("  hasOneBytePictureId: %s", this->hasOneBytePictureId ? "true" : "false");
+			MS_DUMP("  hasTwoBytesPictureId: %s", this->hasTwoBytesPictureId ? "true" : "false");
+			MS_DUMP("  hasTl0PictureIndex: %s", this->hasTl0PictureIndex ? "true" : "false");
+			MS_DUMP("  hasTlIndex: %s", this->hasTlIndex ? "true" : "false");
+			MS_DUMP("</VP8::PayloadDescriptor>");
 		}
 
 		void VP8::PayloadDescriptor::Encode(uint8_t* data, uint16_t pictureId, uint8_t tl0PictureIndex) const

package/worker/src/RTC/Codecs/VP9.cpp

@@ -146,7 +146,7 @@ namespace RTC
 		{
 			MS_TRACE();
 
-			MS_DUMP("<PayloadDescriptor>");
+			MS_DUMP("<VP9::PayloadDescriptor>");
 			MS_DUMP(
 			  "  i:%" PRIu8 "|p:%" PRIu8 "|l:%" PRIu8 "|f:%" PRIu8 "|b:%" PRIu8 "|e:%" PRIu8 "|v:%" PRIu8,
 			  this->i,
@@ -156,20 +156,20 @@ namespace RTC
 			  this->b,
 			  this->e,
 			  this->v);
-			MS_DUMP("  pictureId            : %" PRIu16, this->pictureId);
-			MS_DUMP("  slIndex              : %" PRIu8, this->slIndex);
-			MS_DUMP("  tlIndex              : %" PRIu8, this->tlIndex);
-			MS_DUMP("  tl0PictureIndex      : %" PRIu8, this->tl0PictureIndex);
-			MS_DUMP("  interLayerDependency : %" PRIu8, this->interLayerDependency);
-			MS_DUMP("  switchingUpPoint     : %" PRIu8, this->switchingUpPoint);
-			MS_DUMP("  isKeyFrame           : %s", this->isKeyFrame ? "true" : "false");
-			MS_DUMP("  hasPictureId         : %s", this->hasPictureId ? "true" : "false");
-			MS_DUMP("  hasOneBytePictureId  : %s", this->hasOneBytePictureId ? "true" : "false");
-			MS_DUMP("  hasTwoBytesPictureId : %s", this->hasTwoBytesPictureId ? "true" : "false");
-			MS_DUMP("  hasTl0PictureIndex   : %s", this->hasTl0PictureIndex ? "true" : "false");
-			MS_DUMP("  hasSlIndex           : %s", this->hasSlIndex ? "true" : "false");
-			MS_DUMP("  hasTlIndex           : %s", this->hasTlIndex ? "true" : "false");
-			MS_DUMP("</PayloadDescriptor>");
+			MS_DUMP("  pictureId: %" PRIu16, this->pictureId);
+			MS_DUMP("  slIndex: %" PRIu8, this->slIndex);
+			MS_DUMP("  tlIndex: %" PRIu8, this->tlIndex);
+			MS_DUMP("  tl0PictureIndex: %" PRIu8, this->tl0PictureIndex);
+			MS_DUMP("  interLayerDependency: %" PRIu8, this->interLayerDependency);
+			MS_DUMP("  switchingUpPoint: %" PRIu8, this->switchingUpPoint);
+			MS_DUMP("  isKeyFrame: %s", this->isKeyFrame ? "true" : "false");
+			MS_DUMP("  hasPictureId: %s", this->hasPictureId ? "true" : "false");
+			MS_DUMP("  hasOneBytePictureId: %s", this->hasOneBytePictureId ? "true" : "false");
+			MS_DUMP("  hasTwoBytesPictureId: %s", this->hasTwoBytesPictureId ? "true" : "false");
+			MS_DUMP("  hasTl0PictureIndex: %s", this->hasTl0PictureIndex ? "true" : "false");
+			MS_DUMP("  hasSlIndex: %s", this->hasSlIndex ? "true" : "false");
+			MS_DUMP("  hasTlIndex: %s", this->hasTlIndex ? "true" : "false");
+			MS_DUMP("</VP9::PayloadDescriptor>");
 		}
 
 		VP9::PayloadDescriptorHandler::PayloadDescriptorHandler(VP9::PayloadDescriptor* payloadDescriptor)

package/worker/src/RTC/DtlsTransport.cpp

@@ -12,23 +12,25 @@
 #include <cstdio>  // std::snprintf(), std::fopen()
 #include <cstring> // std::memcpy(), std::strcmp()
 
-#define LOG_OPENSSL_ERROR(desc)                                                                    \
-	do                                                                                               \
-	{                                                                                                \
-		if (ERR_peek_error() == 0)                                                                     \
-		{                                                                                              \
-			MS_ERROR("OpenSSL error [desc:'%s']", desc);                                                 \
-		}                                                                                              \
-		else                                                                                           \
-		{                                                                                              \
-			int64_t err;                                                                                 \
-			while ((err = ERR_get_error()) != 0)                                                         \
-			{                                                                                            \
-				MS_ERROR("OpenSSL error [desc:'%s', error:'%s']", desc, ERR_error_string(err, nullptr));   \
-			}                                                                                            \
-			ERR_clear_error();                                                                           \
-		}                                                                                              \
+// clang-format off
+#define LOG_OPENSSL_ERROR(desc) \
+	do \
+	{ \
+		if (ERR_peek_error() == 0) \
+		{ \
+			MS_ERROR("OpenSSL error [desc:'%s']", desc); \
+		} \
+		else \
+		{ \
+			int64_t err; \
+			while ((err = ERR_get_error()) != 0) \
+			{ \
+				MS_ERROR("OpenSSL error [desc:'%s', error:'%s']", desc, ERR_error_string(err, nullptr)); \
+			} \
+			ERR_clear_error(); \
+		} \
 	} while (false)
+// clang-format on
 
 /* Static methods for OpenSSL callbacks. */
 
@@ -45,15 +47,49 @@ inline static void onSslInfo(const SSL* ssl, int where, int ret)
 	static_cast<RTC::DtlsTransport*>(SSL_get_ex_data(ssl, 0))->OnSslInfo(where, ret);
 }
 
+/**
+ * This callback is called by OpenSSL when it wants to send DTLS data to the
+ * endpoint. Such a data could be a full DTLS message, various DTLS messages,
+ * a DTLS message fragment, various DTLS message fragments or a combination of
+ * these. It's guaranteed (by observation) that |len| argument corresponds to
+ * the entire content of our BIO mem buffer |this->sslBioToNetwork| and it
+ * never exceeds our |DtlsMtu| limit.
+ */
+inline static long onSslBioOut(
+  BIO* bio,
+  int operationType,
+  const char* argp,
+  size_t len,
+  int /*argi*/,
+  long /*argl*/,
+  int ret,
+  size_t* /*processed*/)
+{
+	long resultOfcallback = (operationType == BIO_CB_RETURN) ? static_cast<long>(ret) : 1;
+
+	// This callback is called twice for write operations:
+	// - First one with operationType = BIO_CB_WRITE.
+	// - Second one with operationType = BIO_CB_RETURN | BIO_CB_WRITE.
+	// We only care about the former.
+	if ((operationType == BIO_CB_WRITE) && argp && len > 0)
+	{
+		auto* dtlsTransport = reinterpret_cast<RTC::DtlsTransport*>(BIO_get_callback_arg(bio));
+
+		dtlsTransport->SendDtlsData(reinterpret_cast<const uint8_t*>(argp), len);
+	}
+
+	return resultOfcallback;
+}
+
 inline static unsigned int onSslDtlsTimer(SSL* /*ssl*/, unsigned int timerUs)
 {
-	if (timerUs == 0)
+	if (timerUs == 0u)
 	{
-		return 100000;
+		return 100000u;
 	}
-	else if (timerUs >= 4000000)
+	else if (timerUs >= 4000000u)
 	{
-		return 4000000;
+		return 4000000u;
 	}
 	else
 	{
@@ -69,15 +105,15 @@ namespace RTC
 	static constexpr int DtlsMtu{ 1350 };
 	static constexpr int SslReadBufferSize{ 65536 };
 	// AES-HMAC: http://tools.ietf.org/html/rfc3711
-	static constexpr size_t SrtpMasterKeyLength{ 16 };
-	static constexpr size_t SrtpMasterSaltLength{ 14 };
+	static constexpr size_t SrtpMasterKeyLength{ 16u };
+	static constexpr size_t SrtpMasterSaltLength{ 14u };
 	static constexpr size_t SrtpMasterLength{ SrtpMasterKeyLength + SrtpMasterSaltLength };
 	// AES-GCM: http://tools.ietf.org/html/rfc7714
-	static constexpr size_t SrtpAesGcm256MasterKeyLength{ 32 };
-	static constexpr size_t SrtpAesGcm256MasterSaltLength{ 12 };
+	static constexpr size_t SrtpAesGcm256MasterKeyLength{ 32u };
+	static constexpr size_t SrtpAesGcm256MasterSaltLength{ 12u };
 	static constexpr size_t SrtpAesGcm256MasterLength{ SrtpAesGcm256MasterKeyLength + SrtpAesGcm256MasterSaltLength };
-	static constexpr size_t SrtpAesGcm128MasterKeyLength{ 16 };
-	static constexpr size_t SrtpAesGcm128MasterSaltLength{ 12 };
+	static constexpr size_t SrtpAesGcm128MasterKeyLength{ 16u };
+	static constexpr size_t SrtpAesGcm128MasterSaltLength{ 12u };
 	static constexpr size_t SrtpAesGcm128MasterLength{ SrtpAesGcm128MasterKeyLength + SrtpAesGcm128MasterSaltLength };
 	// clang-format on
 
@@ -706,15 +742,19 @@ namespace RTC
 			goto error;
 		}
 
-		SSL_set_bio(this->ssl, this->sslBioFromNetwork, this->sslBioToNetwork);
-
 		// Set the MTU so that we don't send packets that are too large with no
 		// fragmentation.
-		// TODO: This is not honored, see issue:
-		//   https://github.com/versatica/mediasoup/issues/1100
 		SSL_set_mtu(this->ssl, DtlsMtu);
 		DTLS_set_link_mtu(this->ssl, DtlsMtu);
 
+		// We want to monitor OpenSSL write operations into our |sslBioToNetwork|
+		// buffer so we can immediately send those DTLS bytes (containing full DTLS
+		// messages, or valid DTLS fragment messages, or combination of them) to
+		// the endpoint, and hence we honor the configured DTLS MTU.
+		BIO_set_callback_ex(this->sslBioToNetwork, onSslBioOut);
+		BIO_set_callback_arg(this->sslBioToNetwork, reinterpret_cast<char*>(this));
+		SSL_set_bio(this->ssl, this->sslBioFromNetwork, this->sslBioToNetwork);
+
 		// Set callback handler for setting DTLS timer interval.
 		DTLS_set_timer_cb(this->ssl, onSslDtlsTimer);
 
@@ -755,7 +795,6 @@ namespace RTC
 		{
 			// Send close alert to the peer.
 			SSL_shutdown(this->ssl);
-			SendPendingOutgoingDtlsData();
 		}
 
 		if (this->ssl)
@@ -832,9 +871,9 @@ namespace RTC
 		}
 
 		MS_DUMP("<DtlsTransport>");
-		MS_DUMP("  state           : %s", state.c_str());
-		MS_DUMP("  role            : %s", role.c_str());
-		MS_DUMP("  handshake done: : %s", this->handshakeDone ? "yes" : "no");
+		MS_DUMP("  state: %s", state.c_str());
+		MS_DUMP("  role: %s", role.c_str());
+		MS_DUMP("  handshake done: %s", this->handshakeDone ? "yes" : "no");
 		MS_DUMP("</DtlsTransport>");
 	}
 
@@ -878,7 +917,6 @@ namespace RTC
 
 				SSL_set_connect_state(this->ssl);
 				SSL_do_handshake(this->ssl);
-				SendPendingOutgoingDtlsData();
 				SetTimeout();
 
 				break;
@@ -949,9 +987,6 @@ namespace RTC
 		// Must call SSL_read() to process received DTLS data.
 		read = SSL_read(this->ssl, static_cast<void*>(DtlsTransport::sslReadBuffer), SslReadBufferSize);
 
-		// Send data if it's ready.
-		SendPendingOutgoingDtlsData();
-
 		// Check SSL status and return if it is bad/closed.
 		if (!CheckStatus(read))
 		{
@@ -1020,9 +1055,31 @@ namespace RTC
 			MS_WARN_TAG(
 			  dtls, "OpenSSL SSL_write() wrote less (%d bytes) than given data (%zu bytes)", written, len);
 		}
+	}
+
+	/**
+	 * This method is called within our |onSslBioOut| callback above. As told
+	 * there, it's guaranteed that OpenSSL invokes that callback with all the
+	 * bytes currently written in our BIO mem buffer |this->sslBioToNetwork| so
+	 * we can safely reset/clear that buffer once we have sent the data to the
+	 * endpoint.
+	 */
+	void DtlsTransport::SendDtlsData(const uint8_t* data, size_t len)
+	{
+		MS_TRACE();
+
+		MS_DEBUG_DEV("%zu bytes of DTLS data ready to be sent", len);
 
-		// Send data.
-		SendPendingOutgoingDtlsData();
+		// Notify the listener.
+		this->listener->OnDtlsTransportSendData(this, data, len);
+
+		// Clear the BIO buffer.
+		auto ret = BIO_reset(this->sslBioToNetwork);
+
+		if (ret != 1)
+		{
+			MS_ERROR("BIO_reset() failed [ret:%d]", ret);
+		}
 	}
 
 	void DtlsTransport::Reset()
@@ -1042,8 +1099,9 @@ namespace RTC
 		this->timer->Stop();
 
 		// NOTE: We need to reset the SSL instance so we need to "shutdown" it, but
-		// we don't want to send a Close Alert to the peer, so just don't call
-		// SendPendingOutgoingDTLSData().
+		// we don't want to send a DTLS Close Alert to the peer. However this is
+		// gonna happen since SSL_shutdown() will trigger a DTLS Close Alert and
+		// we'll have our onSslBioOut() callback called to deliver it.
 		SSL_shutdown(this->ssl);
 
 		this->localRole.reset();
@@ -1067,10 +1125,9 @@ namespace RTC
 	{
 		MS_TRACE();
 
-		int err;
 		const bool wasHandshakeDone = this->handshakeDone;
 
-		err = SSL_get_error(this->ssl, returnCode);
+		int err = SSL_get_error(this->ssl, returnCode);
 
 		switch (err)
 		{
@@ -1180,36 +1237,6 @@ namespace RTC
 		}
 	}
 
-	void DtlsTransport::SendPendingOutgoingDtlsData()
-	{
-		MS_TRACE();
-
-		if (BIO_eof(this->sslBioToNetwork))
-		{
-			return;
-		}
-
-		int64_t read;
-		char* data{ nullptr };
-
-		read = BIO_get_mem_data(this->sslBioToNetwork, &data); // NOLINT
-
-		if (read <= 0)
-		{
-			return;
-		}
-
-		MS_DEBUG_DEV("%" PRIu64 " bytes of DTLS data ready to sent to the peer", read);
-
-		// Notify the listener.
-		this->listener->OnDtlsTransportSendData(
-		  this, reinterpret_cast<uint8_t*>(data), static_cast<size_t>(read));
-
-		// Clear the BIO buffer.
-		// NOTE: the (void) avoids the -Wunused-value warning.
-		(void)BIO_reset(this->sslBioToNetwork);
-	}
-
 	bool DtlsTransport::SetTimeout()
 	{
 		MS_TRACE();
@@ -1682,9 +1709,6 @@ namespace RTC
 
 		if (ret == 1)
 		{
-			// If required, send DTLS data.
-			SendPendingOutgoingDtlsData();
-
 			// Set the DTLS timer again.
 			SetTimeout();
 		}

package/worker/src/RTC/RTCP/Bye.cpp

@@ -94,11 +94,11 @@ namespace RTC
 			MS_DUMP("<ByePacket>");
 			for (auto ssrc : this->ssrcs)
 			{
-				MS_DUMP("  ssrc   : %" PRIu32, ssrc);
+				MS_DUMP("  ssrc: %" PRIu32, ssrc);
 			}
 			if (!this->reason.empty())
 			{
-				MS_DUMP("  reason : %s", this->reason.c_str());
+				MS_DUMP("  reason: %s", this->reason.c_str());
 			}
 			MS_DUMP("</ByePacket>");
 		}

package/worker/src/RTC/RTCP/Feedback.cpp

@@ -87,9 +87,9 @@ namespace RTC
 		{
 			MS_TRACE();
 
-			MS_DUMP("  sender ssrc : %" PRIu32, GetSenderSsrc());
-			MS_DUMP("  media ssrc  : %" PRIu32, GetMediaSsrc());
-			MS_DUMP("  size        : %zu", this->GetSize());
+			MS_DUMP("  sender ssrc: %" PRIu32, GetSenderSsrc());
+			MS_DUMP("  media ssrc: %" PRIu32, GetMediaSsrc());
+			MS_DUMP("  size: %zu", this->GetSize());
 		}
 
 		/* Specialization for Ps class. */

package/worker/src/RTC/RTCP/FeedbackPsFir.cpp

@@ -41,8 +41,8 @@ namespace RTC
 			MS_TRACE();
 
 			MS_DUMP("<FeedbackPsFirItem>");
-			MS_DUMP("  ssrc            : %" PRIu32, this->GetSsrc());
-			MS_DUMP("  sequence number : %" PRIu8, this->GetSequenceNumber());
+			MS_DUMP("  ssrc: %" PRIu32, this->GetSsrc());
+			MS_DUMP("  sequence number: %" PRIu8, this->GetSequenceNumber());
 			MS_DUMP("</FeedbackPsFirItem>");
 		}
 	} // namespace RTCP

package/worker/src/RTC/RTCP/FeedbackPsLei.cpp

@@ -34,7 +34,7 @@ namespace RTC
 			MS_TRACE();
 
 			MS_DUMP("<FeedbackPsLeiItem>");
-			MS_DUMP("  ssrc : %" PRIu32, this->GetSsrc());
+			MS_DUMP("  ssrc: %" PRIu32, this->GetSsrc());
 			MS_DUMP("</FeedbackPsLeiItem>");
 		}
 	} // namespace RTCP

package/worker/src/RTC/RTCP/FeedbackPsRemb.cpp

@@ -147,10 +147,10 @@ namespace RTC
 
 			MS_DUMP("<FeedbackPsRembPacket>");
 			FeedbackPsPacket::Dump();
-			MS_DUMP("  bitrate (bps) : %" PRIu64, this->bitrate);
+			MS_DUMP("  bitrate (bps): %" PRIu64, this->bitrate);
 			for (auto ssrc : this->ssrcs)
 			{
-				MS_DUMP("  ssrc          : %" PRIu32, ssrc);
+				MS_DUMP("  ssrc: %" PRIu32, ssrc);
 			}
 			MS_DUMP("</FeedbackPsRembPacket>");
 		}

package/worker/src/RTC/RTCP/FeedbackPsRpsi.cpp

@@ -77,9 +77,9 @@ namespace RTC
 			MS_TRACE();
 
 			MS_DUMP("<FeedbackPsRpsiItem>");
-			MS_DUMP("  padding bits : %" PRIu8, this->header->paddingBits);
-			MS_DUMP("  payload type : %" PRIu8, this->GetPayloadType());
-			MS_DUMP("  length       : %zu", this->GetLength());
+			MS_DUMP("  padding bits %" PRIu8, this->header->paddingBits);
+			MS_DUMP("  payload type: %" PRIu8, this->GetPayloadType());
+			MS_DUMP("  length: %zu", this->GetLength());
 			MS_DUMP("</FeedbackPsRpsiItem>");
 		}
 	} // namespace RTCP

package/worker/src/RTC/RTCP/FeedbackPsSli.cpp

@@ -39,9 +39,9 @@ namespace RTC
 			MS_TRACE();
 
 			MS_DUMP("<FeedbackPsSliItem>");
-			MS_DUMP("  first      : %" PRIu16, this->first);
-			MS_DUMP("  number     : %" PRIu16, this->number);
-			MS_DUMP("  picture id : %" PRIu8, this->pictureId);
+			MS_DUMP("  first: %" PRIu16, this->first);
+			MS_DUMP("  number: %" PRIu16, this->number);
+			MS_DUMP("  picture id: %" PRIu8, this->pictureId);
 			MS_DUMP("</FeedbackPsSliItem>");
 		}
 	} // namespace RTCP

package/worker/src/RTC/RTCP/FeedbackPsTst.cpp

@@ -41,9 +41,9 @@ namespace RTC
 			MS_TRACE();
 
 			MS_DUMP("<FeedbackPsTstItem>");
-			MS_DUMP("  ssrc            : %" PRIu32, this->GetSsrc());
-			MS_DUMP("  sequence number : %" PRIu32, this->GetSequenceNumber());
-			MS_DUMP("  index           : %" PRIu32, this->GetIndex());
+			MS_DUMP("  ssrc: %" PRIu32, this->GetSsrc());
+			MS_DUMP("  sequence number: %" PRIu32, this->GetSequenceNumber());
+			MS_DUMP("  index: %" PRIu32, this->GetIndex());
 			MS_DUMP("</FeedbackPsTstItem>");
 		}
 

package/worker/src/RTC/RTCP/FeedbackPsVbcm.cpp

@@ -51,10 +51,10 @@ namespace RTC
 			MS_TRACE();
 
 			MS_DUMP("<FeedbackPsVbcmItem>");
-			MS_DUMP("  ssrc            : %" PRIu32, this->GetSsrc());
-			MS_DUMP("  sequence number : %" PRIu8, this->GetSequenceNumber());
-			MS_DUMP("  payload type    : %" PRIu8, this->GetPayloadType());
-			MS_DUMP("  length          : %" PRIu16, this->GetLength());
+			MS_DUMP("  ssrc: %" PRIu32, this->GetSsrc());
+			MS_DUMP("  sequence number: %" PRIu8, this->GetSequenceNumber());
+			MS_DUMP("  payload type: %" PRIu8, this->GetPayloadType());
+			MS_DUMP("  length: %" PRIu16, this->GetLength());
 			MS_DUMP("</FeedbackPsVbcmItem>");
 		}
 	} // namespace RTCP

package/worker/src/RTC/RTCP/FeedbackRtpEcn.cpp

@@ -24,13 +24,13 @@ namespace RTC
 			MS_TRACE();
 
 			MS_DUMP("<FeedbackRtpEcnItem>");
-			MS_DUMP("  sequence number    : %" PRIu32, this->GetSequenceNumber());
-			MS_DUMP("  ect0 counter       : %" PRIu32, this->GetEct0Counter());
-			MS_DUMP("  ect1 counter       : %" PRIu32, this->GetEct1Counter());
-			MS_DUMP("  ecn ce counter     : %" PRIu16, this->GetEcnCeCounter());
-			MS_DUMP("  not ect counter    : %" PRIu16, this->GetNotEctCounter());
-			MS_DUMP("  lost packets       : %" PRIu16, this->GetLostPackets());
-			MS_DUMP("  duplicated packets : %" PRIu16, this->GetDuplicatedPackets());
+			MS_DUMP("  sequence number: %" PRIu32, this->GetSequenceNumber());
+			MS_DUMP("  ect0 counter: %" PRIu32, this->GetEct0Counter());
+			MS_DUMP("  ect1 counter: %" PRIu32, this->GetEct1Counter());
+			MS_DUMP("  ecn ce counter: %" PRIu16, this->GetEcnCeCounter());
+			MS_DUMP("  not ect counter: %" PRIu16, this->GetNotEctCounter());
+			MS_DUMP("  lost packets: %" PRIu16, this->GetLostPackets());
+			MS_DUMP("  duplicated packets: %" PRIu16, this->GetDuplicatedPackets());
 			MS_DUMP("</FeedbackRtpEcnItem>");
 		}
 	} // namespace RTCP

package/worker/src/RTC/RTCP/FeedbackRtpNack.cpp

@@ -37,8 +37,8 @@ namespace RTC
 			std::bitset<16> nackBitset(this->GetLostPacketBitmask());
 
 			MS_DUMP("<FeedbackRtpNackItem>");
-			MS_DUMP("  pid : %" PRIu16, this->GetPacketId());
-			MS_DUMP("  bpl : %s", nackBitset.to_string().c_str());
+			MS_DUMP("  pid: %" PRIu16, this->GetPacketId());
+			MS_DUMP("  bpl: %s", nackBitset.to_string().c_str());
 			MS_DUMP("</FeedbackRtpNackItem>");
 		}
 	} // namespace RTCP

package/worker/src/RTC/RTCP/FeedbackRtpTmmb.cpp

@@ -68,9 +68,9 @@ namespace RTC
 			MS_TRACE();
 
 			MS_DUMP("<FeedbackRtpTmmbItem>");
-			MS_DUMP("  ssrc     : %" PRIu32, this->GetSsrc());
-			MS_DUMP("  bitrate  : %" PRIu64, this->GetBitrate());
-			MS_DUMP("  overhead : %" PRIu16, this->GetOverhead());
+			MS_DUMP("  ssrc: %" PRIu32, this->GetSsrc());
+			MS_DUMP("  bitrate: %" PRIu64, this->GetBitrate());
+			MS_DUMP("  overhead: %" PRIu16, this->GetOverhead());
 			MS_DUMP("</FeedbackRtpTmmbItem>");
 		}
 

package/worker/src/RTC/RTCP/FeedbackRtpTransport.cpp

@@ -179,11 +179,11 @@ namespace RTC
 			MS_TRACE();
 
 			MS_DUMP("<FeedbackRtpTransportPacket>");
-			MS_DUMP("  base sequence         : %" PRIu16, this->baseSequenceNumber);
-			MS_DUMP("  packet status count   : %" PRIu16, this->packetStatusCount);
-			MS_DUMP("  reference time        : %" PRIi32, this->referenceTime);
-			MS_DUMP("  feedback packet count : %" PRIu8, this->feedbackPacketCount);
-			MS_DUMP("  size                  : %zu", GetSize());
+			MS_DUMP("  base sequence: %" PRIu16, this->baseSequenceNumber);
+			MS_DUMP("  packet status count: %" PRIu16, this->packetStatusCount);
+			MS_DUMP("  reference time: %" PRIi32, this->referenceTime);
+			MS_DUMP("  feedback packet count: %" PRIu8, this->feedbackPacketCount);
+			MS_DUMP("  size: %zu", GetSize());
 
 			for (auto* chunk : this->chunks)
 			{
@@ -728,8 +728,8 @@ namespace RTC
 			MS_TRACE();
 
 			MS_DUMP("  <RunLengthChunk>");
-			MS_DUMP("    status : %s", FeedbackRtpTransportPacket::status2String[this->status].c_str());
-			MS_DUMP("    count  : %" PRIu16, this->count);
+			MS_DUMP("    status: %s", FeedbackRtpTransportPacket::status2String[this->status].c_str());
+			MS_DUMP("    count: %" PRIu16, this->count);
 			MS_DUMP("  </RunLengthChunk>");
 		}
 

package/worker/src/RTC/RTCP/ReceiverReport.cpp

@@ -37,13 +37,13 @@ namespace RTC
 			MS_TRACE();
 
 			MS_DUMP("<ReceiverReport>");
-			MS_DUMP("  ssrc          : %" PRIu32, GetSsrc());
-			MS_DUMP("  fraction lost : %" PRIu8, GetFractionLost());
-			MS_DUMP("  total lost    : %" PRIu32, GetTotalLost());
-			MS_DUMP("  last seq      : %" PRIu32, GetLastSeq());
-			MS_DUMP("  jitter        : %" PRIu32, GetJitter());
-			MS_DUMP("  lsr           : %" PRIu32, GetLastSenderReport());
-			MS_DUMP("  dlsr          : %" PRIu32, GetDelaySinceLastSenderReport());
+			MS_DUMP("  ssrc: %" PRIu32, GetSsrc());
+			MS_DUMP("  fraction lost: %" PRIu8, GetFractionLost());
+			MS_DUMP("  total lost: %" PRIu32, GetTotalLost());
+			MS_DUMP("  last seq: %" PRIu32, GetLastSeq());
+			MS_DUMP("  jitter: %" PRIu32, GetJitter());
+			MS_DUMP("  lsr: %" PRIu32, GetLastSenderReport());
+			MS_DUMP("  dlsr: %" PRIu32, GetDelaySinceLastSenderReport());
 			MS_DUMP("</ReceiverReport>");
 		}
 

package/worker/src/RTC/RTCP/Sdes.cpp

@@ -92,9 +92,9 @@ namespace RTC
 			MS_TRACE();
 
 			MS_DUMP("<SdesItem>");
-			MS_DUMP("  type   : %s", SdesItem::Type2String(this->GetType()).c_str());
-			MS_DUMP("  length : %" PRIu8, this->header->length);
-			MS_DUMP("  value  : %.*s", this->header->length, this->header->value);
+			MS_DUMP("  type: %s", SdesItem::Type2String(this->GetType()).c_str());
+			MS_DUMP("  length: %" PRIu8, this->header->length);
+			MS_DUMP("  value: %.*s", this->header->length, this->header->value);
 			MS_DUMP("</SdesItem>");
 		}
 
@@ -240,7 +240,7 @@ namespace RTC
 			MS_TRACE();
 
 			MS_DUMP("<SdesChunk>");
-			MS_DUMP("  ssrc : %" PRIu32, this->ssrc);
+			MS_DUMP("  ssrc: %" PRIu32, this->ssrc);
 			for (auto* item : this->items)
 			{
 				item->Dump();

package/worker/src/RTC/RTCP/SenderReport.cpp

@@ -36,12 +36,12 @@ namespace RTC
 			MS_TRACE();
 
 			MS_DUMP("<SenderReport>");
-			MS_DUMP("  ssrc         : %" PRIu32, GetSsrc());
-			MS_DUMP("  ntp sec      : %" PRIu32, GetNtpSec());
-			MS_DUMP("  ntp frac     : %" PRIu32, GetNtpFrac());
-			MS_DUMP("  rtp ts       : %" PRIu32, GetRtpTs());
-			MS_DUMP("  packet count : %" PRIu32, GetPacketCount());
-			MS_DUMP("  octet count  : %" PRIu32, GetOctetCount());
+			MS_DUMP("  ssrc: %" PRIu32, GetSsrc());
+			MS_DUMP("  ntp sec: %" PRIu32, GetNtpSec());
+			MS_DUMP("  ntp frac: %" PRIu32, GetNtpFrac());
+			MS_DUMP("  rtp ts: %" PRIu32, GetRtpTs());
+			MS_DUMP("  packet count: %" PRIu32, GetPacketCount());
+			MS_DUMP("  octet count: %" PRIu32, GetOctetCount());
 			MS_DUMP("</SenderReport>");
 		}
 

package/worker/src/RTC/RTCP/XrDelaySinceLastRr.cpp

@@ -38,9 +38,9 @@ namespace RTC
 			MS_TRACE();
 
 			MS_DUMP("  <SsrcInfo>");
-			MS_DUMP("    ssrc : %" PRIu32, GetSsrc());
-			MS_DUMP("    lrr  : %" PRIu32, GetLastReceiverReport());
-			MS_DUMP("    dlrr : %" PRIu32, GetDelaySinceLastReceiverReport());
+			MS_DUMP("    ssrc: %" PRIu32, GetSsrc());
+			MS_DUMP("    lrr: %" PRIu32, GetLastReceiverReport());
+			MS_DUMP("    dlrr: %" PRIu32, GetDelaySinceLastReceiverReport());
 			MS_DUMP("  <SsrcInfo>");
 		}
 
@@ -117,10 +117,10 @@ namespace RTC
 			MS_TRACE();
 
 			MS_DUMP("<DelaySinceLastRr>");
-			MS_DUMP("  block type : %" PRIu8, (uint8_t)this->type);
-			MS_DUMP("  reserved   : 0");
+			MS_DUMP("  block type: %" PRIu8, (uint8_t)this->type);
+			MS_DUMP("  reserved: 0");
 			MS_DUMP(
-			  "  length     : %" PRIu16,
+			  "  length: %" PRIu16,
 			  static_cast<uint16_t>((SsrcInfo::BodySize * this->ssrcInfos.size() / 4)));
 			for (auto* ssrcInfo : this->ssrcInfos)
 			{

package/worker/src/RTC/RTCP/XrReceiverReferenceTime.cpp

@@ -35,11 +35,11 @@ namespace RTC
 			MS_TRACE();
 
 			MS_DUMP("<ReceiverReferenceTime>");
-			MS_DUMP("  block type : %" PRIu8, static_cast<uint8_t>(this->type));
-			MS_DUMP("  reserved   : 0");
-			MS_DUMP("  length     : 2");
-			MS_DUMP("  ntp sec    : %" PRIu32, GetNtpSec());
-			MS_DUMP("  ntp frac   : %" PRIu32, GetNtpFrac());
+			MS_DUMP("  block type: %" PRIu8, static_cast<uint8_t>(this->type));
+			MS_DUMP("  reserved: 0");
+			MS_DUMP("  length: 2");
+			MS_DUMP("  ntp sec: %" PRIu32, GetNtpSec());
+			MS_DUMP("  ntp frac: %" PRIu32, GetNtpFrac());
 			MS_DUMP("</ReceiverReferenceTime>");
 		}
 

package/worker/src/RTC/RtpPacket.cpp

@@ -166,21 +166,21 @@ namespace RTC
 		MS_TRACE();
 
 		MS_DUMP("<RtpPacket>");
-		MS_DUMP("  padding           : %s", this->header->padding ? "true" : "false");
+		MS_DUMP("  padding: %s", this->header->padding ? "true" : "false");
 		if (HasHeaderExtension())
 		{
 			MS_DUMP(
-			  "  header extension  : id:%" PRIu16 ", length:%zu",
+			  "  header extension: id:%" PRIu16 ", length:%zu",
 			  GetHeaderExtensionId(),
 			  GetHeaderExtensionLength());
 		}
 		if (HasOneByteExtensions())
 		{
-			MS_DUMP("  RFC5285 ext style : One-Byte Header");
+			MS_DUMP("  RFC5285 ext style: One-Byte Header");
 		}
 		if (HasTwoBytesExtensions())
 		{
-			MS_DUMP("  RFC5285 ext style : Two-Bytes Header");
+			MS_DUMP("  RFC5285 ext style: Two-Bytes Header");
 		}
 		if (HasOneByteExtensions() || HasTwoBytesExtensions())
 		{
@@ -213,7 +213,7 @@ namespace RTC
 				  extIds.begin(), extIds.end() - 1, std::ostream_iterator<std::string>(extIdsStream, ","));
 				extIdsStream << extIds.back();
 
-				MS_DUMP("  RFC5285 ext ids   : %s", extIdsStream.str().c_str());
+				MS_DUMP("  RFC5285 ext ids: %s", extIdsStream.str().c_str());
 			}
 		}
 		if (this->midExtensionId != 0u)
@@ -222,8 +222,7 @@ namespace RTC
 
 			if (ReadMid(mid))
 			{
-				MS_DUMP(
-				  "  mid               : extId:%" PRIu8 ", value:'%s'", this->midExtensionId, mid.c_str());
+				MS_DUMP("  mid: extId:%" PRIu8 ", value:'%s'", this->midExtensionId, mid.c_str());
 			}
 		}
 		if (this->ridExtensionId != 0u)
@@ -232,8 +231,7 @@ namespace RTC
 
 			if (ReadRid(rid))
 			{
-				MS_DUMP(
-				  "  rid               : extId:%" PRIu8 ", value:'%s'", this->ridExtensionId, rid.c_str());
+				MS_DUMP("  rid: extId:%" PRIu8 ", value:'%s'", this->ridExtensionId, rid.c_str());
 			}
 		}
 		if (this->rridExtensionId != 0u)
@@ -242,13 +240,12 @@ namespace RTC
 
 			if (ReadRid(rid))
 			{
-				MS_DUMP(
-				  "  rrid              : extId:%" PRIu8 ", value:'%s'", this->rridExtensionId, rid.c_str());
+				MS_DUMP("  rrid: extId:%" PRIu8 ", value:'%s'", this->rridExtensionId, rid.c_str());
 			}
 		}
 		if (this->absSendTimeExtensionId != 0u)
 		{
-			MS_DUMP("  absSendTime       : extId:%" PRIu8, this->absSendTimeExtensionId);
+			MS_DUMP("  absSendTime: extId:%" PRIu8, this->absSendTimeExtensionId);
 		}
 		if (this->transportWideCc01ExtensionId != 0u)
 		{
@@ -257,7 +254,7 @@ namespace RTC
 			if (ReadTransportWideCc01(wideSeqNumber))
 			{
 				MS_DUMP(
-				  "  transportWideCc01 : extId:%" PRIu8 ", value:%" PRIu16,
+				  "  transportWideCc01: extId:%" PRIu8 ", value:%" PRIu16,
 				  this->transportWideCc01ExtensionId,
 				  wideSeqNumber);
 			}
@@ -265,11 +262,11 @@ namespace RTC
 		// Remove once it becomes RFC.
 		if (this->frameMarking07ExtensionId != 0u)
 		{
-			MS_DUMP("  frameMarking07    : extId:%" PRIu8, this->frameMarking07ExtensionId);
+			MS_DUMP("  frameMarking07: extId:%" PRIu8, this->frameMarking07ExtensionId);
 		}
 		if (this->frameMarkingExtensionId != 0u)
 		{
-			MS_DUMP("  frameMarking      : extId:%" PRIu8, this->frameMarkingExtensionId);
+			MS_DUMP("  frameMarking: extId:%" PRIu8, this->frameMarkingExtensionId);
 		}
 		if (this->ssrcAudioLevelExtensionId != 0u)
 		{
@@ -279,7 +276,7 @@ namespace RTC
 			if (ReadSsrcAudioLevel(volume, voice))
 			{
 				MS_DUMP(
-				  "  ssrcAudioLevel    : extId:%" PRIu8 ", volume:%" PRIu8 ", voice:%s",
+				  "  ssrcAudioLevel: extId:%" PRIu8 ", volume:%" PRIu8 ", voice:%s",
 				  this->ssrcAudioLevelExtensionId,
 				  volume,
 				  voice ? "true" : "false");
@@ -294,27 +291,27 @@ namespace RTC
 			if (ReadVideoOrientation(camera, flip, rotation))
 			{
 				MS_DUMP(
-				  "  videoOrientation  : extId:%" PRIu8 ", camera:%s, flip:%s, rotation:%" PRIu16,
+				  "  videoOrientation: extId:%" PRIu8 ", camera:%s, flip:%s, rotation:%" PRIu16,
 				  this->videoOrientationExtensionId,
 				  camera ? "true" : "false",
 				  flip ? "true" : "false",
 				  rotation);
 			}
 		}
-		MS_DUMP("  csrc count        : %" PRIu8, this->header->csrcCount);
-		MS_DUMP("  marker            : %s", HasMarker() ? "true" : "false");
-		MS_DUMP("  payload type      : %" PRIu8, GetPayloadType());
-		MS_DUMP("  sequence number   : %" PRIu16, GetSequenceNumber());
-		MS_DUMP("  timestamp         : %" PRIu32, GetTimestamp());
-		MS_DUMP("  ssrc              : %" PRIu32, GetSsrc());
-		MS_DUMP("  payload size      : %zu bytes", GetPayloadLength());
+		MS_DUMP("  csrc count: %" PRIu8, this->header->csrcCount);
+		MS_DUMP("  marker: %s", HasMarker() ? "true" : "false");
+		MS_DUMP("  payload type: %" PRIu8, GetPayloadType());
+		MS_DUMP("  sequence number: %" PRIu16, GetSequenceNumber());
+		MS_DUMP("  timestamp: %" PRIu32, GetTimestamp());
+		MS_DUMP("  ssrc: %" PRIu32, GetSsrc());
+		MS_DUMP("  payload size: %zu bytes", GetPayloadLength());
 		if (this->header->padding != 0u)
 		{
-			MS_DUMP("  padding size      : %" PRIu8 " bytes", this->payloadPadding);
+			MS_DUMP("  padding size: %" PRIu8 " bytes", this->payloadPadding);
 		}
-		MS_DUMP("  packet size       : %zu bytes", GetSize());
-		MS_DUMP("  spatial layer     : %" PRIu8, GetSpatialLayer());
-		MS_DUMP("  temporal layer    : %" PRIu8, GetTemporalLayer());
+		MS_DUMP("  packet size: %zu bytes", GetSize());
+		MS_DUMP("  spatial layer: %" PRIu8, GetSpatialLayer());
+		MS_DUMP("  temporal layer: %" PRIu8, GetTemporalLayer());
 		MS_DUMP("</RtpPacket>");
 	}
 

package/worker/src/RTC/StunPacket.cpp

@@ -421,7 +421,7 @@ namespace RTC
 		}
 		if (this->hasUseCandidate)
 		{
-			MS_DUMP("  useCandidate");
+			MS_DUMP("  useCandidate: yes");
 		}
 		if (!this->software.empty())
 		{
@@ -450,7 +450,7 @@ namespace RTC
 		}
 		if (this->hasFingerprint)
 		{
-			MS_DUMP("  has fingerprint");
+			MS_DUMP("  fingerprint: yes");
 		}
 
 		MS_DUMP("</StunPacket>");

package/worker/src/RTC/TransportTuple.cpp

@@ -74,22 +74,22 @@ namespace RTC
 
 		Utils::IP::GetAddressInfo(GetLocalAddress(), family, ip, port);
 
-		MS_DUMP("  localIp    : %s", ip.c_str());
-		MS_DUMP("  localPort  : %" PRIu16, port);
+		MS_DUMP("  localIp: %s", ip.c_str());
+		MS_DUMP("  localPort: %" PRIu16, port);
 
 		Utils::IP::GetAddressInfo(GetRemoteAddress(), family, ip, port);
 
-		MS_DUMP("  remoteIp   : %s", ip.c_str());
-		MS_DUMP("  remotePort : %" PRIu16, port);
+		MS_DUMP("  remoteIp: %s", ip.c_str());
+		MS_DUMP("  remotePort: %" PRIu16, port);
 
 		switch (GetProtocol())
 		{
 			case Protocol::UDP:
-				MS_DUMP("  protocol   : udp");
+				MS_DUMP("  protocol: udp");
 				break;
 
 			case Protocol::TCP:
-				MS_DUMP("  protocol   : tcp");
+				MS_DUMP("  protocol: tcp");
 				break;
 		}
 

package/worker/src/Settings.cpp

@@ -273,23 +273,20 @@ void Settings::PrintConfiguration()
 	MS_DEBUG_TAG(info, "<configuration>");
 
 	MS_DEBUG_TAG(
-	  info,
-	  "  logLevel             : %s",
-	  Settings::LogLevel2String[Settings::configuration.logLevel].c_str());
-	MS_DEBUG_TAG(info, "  logTags              : %s", logTagsStream.str().c_str());
-	MS_DEBUG_TAG(info, "  rtcMinPort           : %" PRIu16, Settings::configuration.rtcMinPort);
-	MS_DEBUG_TAG(info, "  rtcMaxPort           : %" PRIu16, Settings::configuration.rtcMaxPort);
+	  info, "  logLevel: %s", Settings::LogLevel2String[Settings::configuration.logLevel].c_str());
+	MS_DEBUG_TAG(info, "  logTags: %s", logTagsStream.str().c_str());
+	MS_DEBUG_TAG(info, "  rtcMinPort: %" PRIu16, Settings::configuration.rtcMinPort);
+	MS_DEBUG_TAG(info, "  rtcMaxPort: %" PRIu16, Settings::configuration.rtcMaxPort);
 	if (!Settings::configuration.dtlsCertificateFile.empty())
 	{
 		MS_DEBUG_TAG(
-		  info, "  dtlsCertificateFile  : %s", Settings::configuration.dtlsCertificateFile.c_str());
-		MS_DEBUG_TAG(
-		  info, "  dtlsPrivateKeyFile   : %s", Settings::configuration.dtlsPrivateKeyFile.c_str());
+		  info, "  dtlsCertificateFile: %s", Settings::configuration.dtlsCertificateFile.c_str());
+		MS_DEBUG_TAG(info, "  dtlsPrivateKeyFile: %s", Settings::configuration.dtlsPrivateKeyFile.c_str());
 	}
 	if (!Settings::configuration.libwebrtcFieldTrials.empty())
 	{
 		MS_DEBUG_TAG(
-		  info, "  libwebrtcFieldTrials : %s", Settings::configuration.libwebrtcFieldTrials.c_str());
+		  info, "  libwebrtcFieldTrials: %s", Settings::configuration.libwebrtcFieldTrials.c_str());
 	}
 
 	MS_DEBUG_TAG(info, "</configuration>");

package/worker/src/handles/TcpConnectionHandle.cpp

@@ -145,11 +145,11 @@ void TcpConnectionHandle::Close()
 void TcpConnectionHandle::Dump() const
 {
 	MS_DUMP("<TcpConnectionHandle>");
-	MS_DUMP("  localIp    : %s", this->localIp.c_str());
-	MS_DUMP("  localPort  : %" PRIu16, static_cast<uint16_t>(this->localPort));
-	MS_DUMP("  remoteIp   : %s", this->peerIp.c_str());
-	MS_DUMP("  remotePort : %" PRIu16, static_cast<uint16_t>(this->peerPort));
-	MS_DUMP("  closed     : %s", !this->closed ? "open" : "closed");
+	MS_DUMP("  localIp: %s", this->localIp.c_str());
+	MS_DUMP("  localPort: %" PRIu16, static_cast<uint16_t>(this->localPort));
+	MS_DUMP("  remoteIp: %s", this->peerIp.c_str());
+	MS_DUMP("  remotePort: %" PRIu16, static_cast<uint16_t>(this->peerPort));
+	MS_DUMP("  closed: %s", this->closed ? "yes" : "no");
 	MS_DUMP("</TcpConnectionHandle>");
 }
 

package/worker/src/handles/TcpServerHandle.cpp

@@ -96,12 +96,10 @@ void TcpServerHandle::Close()
 void TcpServerHandle::Dump() const
 {
 	MS_DUMP("<TcpServerHandle>");
-	MS_DUMP(
-	  "  [TCP, local:%s :%" PRIu16 ", status:%s, connections:%zu]",
-	  this->localIp.c_str(),
-	  static_cast<uint16_t>(this->localPort),
-	  (!this->closed) ? "open" : "closed",
-	  this->connections.size());
+	MS_DUMP("  localIp: %s", this->localIp.c_str());
+	MS_DUMP("  localPort: %" PRIu16, static_cast<uint16_t>(this->localPort));
+	MS_DUMP("  num connections: %zu", this->connections.size());
+	MS_DUMP("  closed: %s", this->closed ? "yes" : "no");
 	MS_DUMP("</TcpServerHandle>");
 }
 

package/worker/src/handles/UdpSocketHandle.cpp

@@ -135,9 +135,9 @@ void UdpSocketHandle::Close()
 void UdpSocketHandle::Dump() const
 {
 	MS_DUMP("<UdpSocketHandle>");
-	MS_DUMP("  localIp   : %s", this->localIp.c_str());
-	MS_DUMP("  localPort : %" PRIu16, static_cast<uint16_t>(this->localPort));
-	MS_DUMP("  closed    : %s", !this->closed ? "open" : "closed");
+	MS_DUMP("  localIp: %s", this->localIp.c_str());
+	MS_DUMP("  localPort: %" PRIu16, static_cast<uint16_t>(this->localPort));
+	MS_DUMP("  closed: %s", this->closed ? "yes" : "no");
 	MS_DUMP("</UdpSocketHandle>");
 }