mediasoup 3.9.2 → 3.9.3

package/worker/src/Channel/ChannelNotifier.cpp

@@ -19,6 +19,20 @@ namespace Channel
 		ChannelNotifier::channel = channel;
 	}
 
+	void ChannelNotifier::Emit(uint64_t targetId, const char* event)
+	{
+		MS_TRACE();
+
+		MS_ASSERT(ChannelNotifier::channel, "channel unset");
+
+		json jsonNotification = json::object();
+
+		jsonNotification["targetId"] = targetId;
+		jsonNotification["event"]    = event;
+
+		ChannelNotifier::channel->Send(jsonNotification);
+	}
+
 	void ChannelNotifier::Emit(const std::string& targetId, const char* event)
 	{
 		MS_TRACE();

package/worker/src/Channel/ChannelSocket.cpp

@@ -2,6 +2,7 @@
 // #define MS_LOG_DEV_LEVEL 3
 
 #include "Channel/ChannelSocket.hpp"
+#include "DepLibUV.hpp"
 #include "Logger.hpp"
 #include "MediaSoupErrors.hpp"
 #include <cmath>   // std::ceil()
@@ -10,7 +11,19 @@
 
 namespace Channel
 {
-	/* Static. */
+	/* Static methods for UV callbacks. */
+	inline static void onAsync(uv_handle_t* handle)
+	{
+		while (static_cast<ChannelSocket*>(handle->data)->CallbackRead())
+		{
+			// Read while there are new messages.
+		}
+	}
+
+	inline static void onClose(uv_handle_t* handle)
+	{
+		delete handle;
+	}
 
 	// Binary length for a 4194304 bytes payload.
 	static constexpr size_t MessageMaxLen{ 4194308 };
@@ -18,11 +31,48 @@ namespace Channel
 
 	/* Instance methods. */
 	ChannelSocket::ChannelSocket(int consumerFd, int producerFd)
-	  : consumerSocket(consumerFd, MessageMaxLen, this), producerSocket(producerFd, MessageMaxLen)
+	  : consumerSocket(new ConsumerSocket(consumerFd, MessageMaxLen, this)),
+	    producerSocket(new ProducerSocket(producerFd, MessageMaxLen)),
+	    writeBuffer(static_cast<uint8_t*>(std::malloc(MessageMaxLen)))
 	{
 		MS_TRACE_STD();
+	}
+
+	ChannelSocket::ChannelSocket(
+	  ChannelReadFn channelReadFn,
+	  ChannelReadCtx channelReadCtx,
+	  ChannelWriteFn channelWriteFn,
+	  ChannelWriteCtx channelWriteCtx)
+	  : channelReadFn(channelReadFn), channelReadCtx(channelReadCtx), channelWriteFn(channelWriteFn),
+	    channelWriteCtx(channelWriteCtx)
+	{
+		MS_TRACE_STD();
+
+		int err;
+
+		this->uvReadHandle       = new uv_async_t;
+		this->uvReadHandle->data = static_cast<void*>(this);
+
+		err =
+		  uv_async_init(DepLibUV::GetLoop(), this->uvReadHandle, reinterpret_cast<uv_async_cb>(onAsync));
 
-		this->writeBuffer = static_cast<uint8_t*>(std::malloc(MessageMaxLen));
+		if (err != 0)
+		{
+			delete this->uvReadHandle;
+			this->uvReadHandle = nullptr;
+
+			MS_THROW_ERROR_STD("uv_async_init() failed: %s", uv_strerror(err));
+		}
+
+		err = uv_async_send(this->uvReadHandle);
+
+		if (err != 0)
+		{
+			delete this->uvReadHandle;
+			this->uvReadHandle = nullptr;
+
+			MS_THROW_ERROR_STD("uv_async_send() failed: %s", uv_strerror(err));
+		}
 	}
 
 	ChannelSocket::~ChannelSocket()
@@ -33,6 +83,9 @@ namespace Channel
 
 		if (!this->closed)
 			Close();
+
+		delete this->consumerSocket;
+		delete this->producerSocket;
 	}
 
 	void ChannelSocket::Close()
@@ -44,8 +97,20 @@ namespace Channel
 
 		this->closed = true;
 
-		this->consumerSocket.Close();
-		this->producerSocket.Close();
+		if (this->uvReadHandle)
+		{
+			uv_close(reinterpret_cast<uv_handle_t*>(this->uvReadHandle), static_cast<uv_close_cb>(onClose));
+		}
+
+		if (this->consumerSocket)
+		{
+			this->consumerSocket->Close();
+		}
+
+		if (this->producerSocket)
+		{
+			this->producerSocket->Close();
+		}
 	}
 
 	void ChannelSocket::SetListener(Listener* listener)
@@ -71,10 +136,11 @@ namespace Channel
 			return;
 		}
 
-		SendImpl(message.c_str(), static_cast<uint32_t>(message.length()));
+		SendImpl(
+		  reinterpret_cast<const uint8_t*>(message.c_str()), static_cast<uint32_t>(message.length()));
 	}
 
-	void ChannelSocket::SendLog(char* message, uint32_t messageLen)
+	void ChannelSocket::SendLog(const char* message, uint32_t messageLen)
 	{
 		MS_TRACE_STD();
 
@@ -88,23 +154,84 @@ namespace Channel
 			return;
 		}
 
-		SendImpl(message, messageLen);
+		SendImpl(reinterpret_cast<const uint8_t*>(message), messageLen);
 	}
 
-	inline void ChannelSocket::SendImpl(const void* payload, uint32_t payloadLen)
+	bool ChannelSocket::CallbackRead()
 	{
 		MS_TRACE_STD();
 
-		std::memcpy(this->writeBuffer, &payloadLen, sizeof(uint32_t));
+		if (this->closed)
+			return false;
+
+		uint8_t* message{ nullptr };
+		uint32_t messageLen;
+		size_t messageCtx;
+
+		auto free = this->channelReadFn(
+		  &message, &messageLen, &messageCtx, this->uvReadHandle, this->channelReadCtx);
+
+		if (free)
+		{
+			try
+			{
+				json jsonMessage = json::parse(message, message + static_cast<size_t>(messageLen));
+				auto* request    = new Channel::ChannelRequest(this, jsonMessage);
+
+				// Notify the listener.
+				try
+				{
+					this->listener->OnChannelRequest(this, request);
+				}
+				catch (const MediaSoupTypeError& error)
+				{
+					request->TypeError(error.what());
+				}
+				catch (const MediaSoupError& error)
+				{
+					request->Error(error.what());
+				}
+
+				// Delete the Request.
+				delete request;
+			}
+			catch (const json::parse_error& error)
+			{
+				MS_ERROR_STD("JSON parsing error: %s", error.what());
+			}
+			catch (const MediaSoupError& error)
+			{
+				MS_ERROR_STD("discarding wrong Channel request");
+			}
+
+			free(message, messageLen, messageCtx);
+		}
+
+		return free != nullptr;
+	}
+
+	inline void ChannelSocket::SendImpl(const uint8_t* payload, uint32_t payloadLen)
+	{
+		MS_TRACE_STD();
 
-		if (payloadLen != 0)
+		// Write using function call if provided.
+		if (this->channelWriteFn)
 		{
-			std::memcpy(this->writeBuffer + sizeof(uint32_t), payload, payloadLen);
+			this->channelWriteFn(payload, payloadLen, this->channelWriteCtx);
 		}
+		else
+		{
+			std::memcpy(this->writeBuffer, &payloadLen, sizeof(uint32_t));
 
-		size_t len = sizeof(uint32_t) + payloadLen;
+			if (payloadLen != 0)
+			{
+				std::memcpy(this->writeBuffer + sizeof(uint32_t), payload, payloadLen);
+			}
+
+			size_t len = sizeof(uint32_t) + payloadLen;
 
-		this->producerSocket.Write(this->writeBuffer, len);
+			this->producerSocket->Write(this->writeBuffer, len);
+		}
 	}
 
 	void ChannelSocket::OnConsumerSocketMessage(ConsumerSocket* /*consumerSocket*/, char* msg, size_t msgLen)

package/worker/src/DepOpenSSL.cpp

@@ -17,10 +17,13 @@ void DepOpenSSL::ClassInit()
 {
 	MS_TRACE();
 
-	std::call_once(globalInitOnce, [] {
-		MS_DEBUG_TAG(info, "openssl version: \"%s\"", OpenSSL_version(OPENSSL_VERSION));
+	std::call_once(
+	  globalInitOnce,
+	  []
+	  {
+		  MS_DEBUG_TAG(info, "openssl version: \"%s\"", OpenSSL_version(OPENSSL_VERSION));
 
-		// Initialize some crypto stuff.
-		RAND_poll();
-	});
+		  // Initialize some crypto stuff.
+		  RAND_poll();
+	  });
 }

package/worker/src/Logger.cpp

@@ -6,7 +6,7 @@
 
 /* Class variables. */
 
-const int64_t Logger::pid{ static_cast<int64_t>(uv_os_getpid()) };
+const uint64_t Logger::pid{ static_cast<uint64_t>(uv_os_getpid()) };
 thread_local Channel::ChannelSocket* Logger::channel{ nullptr };
 thread_local char Logger::buffer[Logger::bufferSize];
 

package/worker/src/PayloadChannel/PayloadChannelSocket.cpp

@@ -2,6 +2,7 @@
 // #define MS_LOG_DEV_LEVEL 3
 
 #include "PayloadChannel/PayloadChannelSocket.hpp"
+#include "DepLibUV.hpp"
 #include "Logger.hpp"
 #include "MediaSoupErrors.hpp"
 #include "PayloadChannel/PayloadChannelRequest.hpp"
@@ -12,6 +13,18 @@
 namespace PayloadChannel
 {
 	/* Static. */
+	inline static void onAsync(uv_handle_t* handle)
+	{
+		while (static_cast<PayloadChannelSocket*>(handle->data)->CallbackRead())
+		{
+			// Read while there are new messages.
+		}
+	}
+
+	inline static void onClose(uv_handle_t* handle)
+	{
+		delete handle;
+	}
 
 	// Binary length for a 4194304 bytes payload.
 	static constexpr size_t MessageMaxLen{ 4194308 };
@@ -19,11 +32,48 @@ namespace PayloadChannel
 
 	/* Instance methods. */
 	PayloadChannelSocket::PayloadChannelSocket(int consumerFd, int producerFd)
-	  : consumerSocket(consumerFd, MessageMaxLen, this), producerSocket(producerFd, MessageMaxLen)
+	  : consumerSocket(new ConsumerSocket(consumerFd, MessageMaxLen, this)),
+	    producerSocket(new ProducerSocket(producerFd, MessageMaxLen)),
+	    writeBuffer(static_cast<uint8_t*>(std::malloc(MessageMaxLen)))
+	{
+		MS_TRACE();
+	}
+
+	PayloadChannelSocket::PayloadChannelSocket(
+	  PayloadChannelReadFn payloadChannelReadFn,
+	  PayloadChannelReadCtx payloadChannelReadCtx,
+	  PayloadChannelWriteFn payloadChannelWriteFn,
+	  PayloadChannelWriteCtx payloadChannelWriteCtx)
+	  : payloadChannelReadFn(payloadChannelReadFn), payloadChannelReadCtx(payloadChannelReadCtx),
+	    payloadChannelWriteFn(payloadChannelWriteFn), payloadChannelWriteCtx(payloadChannelWriteCtx)
 	{
 		MS_TRACE();
 
-		this->writeBuffer = (uint8_t*)std::malloc(MessageMaxLen);
+		int err;
+
+		this->uvReadHandle       = new uv_async_t;
+		this->uvReadHandle->data = static_cast<void*>(this);
+
+		err =
+		  uv_async_init(DepLibUV::GetLoop(), this->uvReadHandle, reinterpret_cast<uv_async_cb>(onAsync));
+
+		if (err != 0)
+		{
+			delete this->uvReadHandle;
+			this->uvReadHandle = nullptr;
+
+			MS_THROW_ERROR("uv_async_init() failed: %s", uv_strerror(err));
+		}
+
+		err = uv_async_send(this->uvReadHandle);
+
+		if (err != 0)
+		{
+			delete this->uvReadHandle;
+			this->uvReadHandle = nullptr;
+
+			MS_THROW_ERROR("uv_async_send() failed: %s", uv_strerror(err));
+		}
 	}
 
 	PayloadChannelSocket::~PayloadChannelSocket()
@@ -35,6 +85,9 @@ namespace PayloadChannel
 
 		if (!this->closed)
 			Close();
+
+		delete this->consumerSocket;
+		delete this->producerSocket;
 	}
 
 	void PayloadChannelSocket::Close()
@@ -46,8 +99,20 @@ namespace PayloadChannel
 
 		this->closed = true;
 
-		this->consumerSocket.Close();
-		this->producerSocket.Close();
+		if (this->uvReadHandle)
+		{
+			uv_close(reinterpret_cast<uv_handle_t*>(this->uvReadHandle), static_cast<uv_close_cb>(onClose));
+		}
+
+		if (this->consumerSocket)
+		{
+			this->consumerSocket->Close();
+		}
+
+		if (this->producerSocket)
+		{
+			this->producerSocket->Close();
+		}
 	}
 
 	void PayloadChannelSocket::SetListener(Listener* listener)
@@ -79,8 +144,11 @@ namespace PayloadChannel
 			return;
 		}
 
-		SendImpl(message.c_str(), static_cast<uint32_t>(message.length()));
-		SendImpl(payload, static_cast<uint32_t>(payloadLen));
+		SendImpl(
+		  reinterpret_cast<const uint8_t*>(message.c_str()),
+		  static_cast<uint32_t>(message.length()),
+		  payload,
+		  static_cast<uint32_t>(payloadLen));
 	}
 
 	void PayloadChannelSocket::Send(json& jsonMessage)
@@ -99,23 +167,166 @@ namespace PayloadChannel
 			return;
 		}
 
-		SendImpl(message.c_str(), static_cast<uint32_t>(message.length()));
+		SendImpl(
+		  reinterpret_cast<const uint8_t*>(message.c_str()), static_cast<uint32_t>(message.length()));
 	}
 
-	inline void PayloadChannelSocket::SendImpl(const void* payload, uint32_t payloadLen)
+	bool PayloadChannelSocket::CallbackRead()
 	{
 		MS_TRACE();
 
-		std::memcpy(this->writeBuffer, &payloadLen, sizeof(uint32_t));
+		if (this->closed)
+			return false;
+
+		uint8_t* message{ nullptr };
+		uint32_t messageLen;
+		size_t messageCtx;
+
+		uint8_t* payload{ nullptr };
+		uint32_t payloadLen;
+		size_t payloadCapacity;
+
+		auto free = this->payloadChannelReadFn(
+		  &message,
+		  &messageLen,
+		  &messageCtx,
+		  &payload,
+		  &payloadLen,
+		  &payloadCapacity,
+		  this->uvReadHandle,
+		  this->payloadChannelReadCtx);
+
+		if (free)
+		{
+			try
+			{
+				json jsonData = json::parse(message, message + static_cast<size_t>(messageLen));
 
-		if (payloadLen != 0)
+				if (PayloadChannelRequest::IsRequest(jsonData))
+				{
+					try
+					{
+						auto* request = new PayloadChannel::PayloadChannelRequest(this, jsonData);
+						request->SetPayload(payload, payloadLen);
+
+						// Notify the listener.
+						try
+						{
+							this->listener->OnPayloadChannelRequest(this, request);
+						}
+						catch (const MediaSoupTypeError& error)
+						{
+							request->TypeError(error.what());
+						}
+						catch (const MediaSoupError& error)
+						{
+							request->Error(error.what());
+						}
+
+						// Delete the Request.
+						delete request;
+					}
+					catch (const json::parse_error& error)
+					{
+						MS_ERROR_STD("JSON parsing error: %s", error.what());
+					}
+					catch (const MediaSoupError& error)
+					{
+						MS_ERROR("discarding wrong Payload Channel notification");
+					}
+				}
+
+				else if (Notification::IsNotification(jsonData))
+				{
+					try
+					{
+						auto* notification = new PayloadChannel::Notification(jsonData);
+						notification->SetPayload(payload, payloadLen);
+
+						// Notify the listener.
+						try
+						{
+							this->listener->OnPayloadChannelNotification(this, notification);
+						}
+						catch (const MediaSoupError& error)
+						{
+							MS_ERROR("notification failed: %s", error.what());
+						}
+
+						// Delete the Notification.
+						delete notification;
+					}
+					catch (const json::parse_error& error)
+					{
+						MS_ERROR_STD("JSON parsing error: %s", error.what());
+					}
+					catch (const MediaSoupError& error)
+					{
+						MS_ERROR("discarding wrong Payload Channel notification");
+					}
+				}
+
+				else
+				{
+					MS_ERROR("discarding wrong Payload Channel data");
+				}
+			}
+			catch (const json::parse_error& error)
+			{
+				MS_ERROR("JSON parsing error: %s", error.what());
+			}
+			catch (const MediaSoupError& error)
+			{
+				MS_ERROR("discarding wrong Channel request");
+			}
+
+			free(message, messageLen, messageCtx);
+			free(payload, payloadLen, payloadCapacity);
+		}
+
+		return free != nullptr;
+	}
+
+	inline void PayloadChannelSocket::SendImpl(const uint8_t* message, uint32_t messageLen)
+	{
+		MS_TRACE();
+
+		// Write using function call if provided.
+		if (this->payloadChannelWriteFn)
 		{
-			std::memcpy(this->writeBuffer + sizeof(uint32_t), payload, payloadLen);
+			this->payloadChannelWriteFn(message, messageLen, nullptr, 0, this->payloadChannelWriteCtx);
 		}
+		else
+		{
+			std::memcpy(this->writeBuffer, &messageLen, sizeof(uint32_t));
 
-		size_t len = sizeof(uint32_t) + payloadLen;
+			if (messageLen != 0)
+			{
+				std::memcpy(this->writeBuffer + sizeof(uint32_t), message, messageLen);
+			}
+
+			size_t len = sizeof(uint32_t) + messageLen;
 
-		this->producerSocket.Write(this->writeBuffer, len);
+			this->producerSocket->Write(this->writeBuffer, len);
+		}
+	}
+
+	inline void PayloadChannelSocket::SendImpl(
+	  const uint8_t* message, uint32_t messageLen, const uint8_t* payload, uint32_t payloadLen)
+	{
+		MS_TRACE();
+
+		// Write using function call if provided.
+		if (this->payloadChannelWriteFn)
+		{
+			this->payloadChannelWriteFn(
+			  message, messageLen, payload, payloadLen, this->payloadChannelWriteCtx);
+		}
+		else
+		{
+			SendImpl(message, messageLen);
+			SendImpl(payload, payloadLen);
+		}
 	}
 
 	void PayloadChannelSocket::OnConsumerSocketMessage(
@@ -130,8 +341,7 @@ namespace PayloadChannel
 			{
 				try
 				{
-					json jsonMessage     = json::parse(msg, msg + msgLen);
-					this->ongoingRequest = new PayloadChannel::PayloadChannelRequest(this, jsonMessage);
+					this->ongoingRequest = new PayloadChannel::PayloadChannelRequest(this, jsonData);
 				}
 				catch (const json::parse_error& error)
 				{
@@ -147,8 +357,7 @@ namespace PayloadChannel
 			{
 				try
 				{
-					json jsonMessage          = json::parse(msg, msg + msgLen);
-					this->ongoingNotification = new PayloadChannel::Notification(jsonMessage);
+					this->ongoingNotification = new PayloadChannel::Notification(jsonData);
 				}
 				catch (const json::parse_error& error)
 				{

package/worker/src/RTC/ActiveSpeakerObserver.cpp

@@ -463,7 +463,7 @@ namespace RTC
 			size_t levelIndex = this->nextLevelIndex >= (i + 1)
 			                      ? this->nextLevelIndex - i - 1
 			                      : this->nextLevelIndex + LevelsBuffLen - i - 1;
-			uint8_t level = this->levels[levelIndex];
+			uint8_t level     = this->levels[levelIndex];
 
 			if (level < minLevel)
 			{

package/worker/src/RTC/DataConsumer.cpp

@@ -222,12 +222,15 @@ namespace RTC
 					return;
 				}
 
-				const auto* cb = new onQueuedCallback([&request](bool queued, bool sctpSendBufferFull) {
-					if (queued)
-						request->Accept();
-					else
-						request->Error(sctpSendBufferFull == true ? "sctpsendbufferfull" : "message send failed");
-				});
+				const auto* cb = new onQueuedCallback(
+				  [&request](bool queued, bool sctpSendBufferFull)
+				  {
+					  if (queued)
+						  request->Accept();
+					  else
+						  request->Error(
+						    sctpSendBufferFull == true ? "sctpsendbufferfull" : "message send failed");
+				  });
 
 				SendMessage(ppid, msg, len, cb);