mediasoup 3.19.21 → 3.19.22

package/worker/mocks/include/Channel/MockChannelMessageRegistrator.hpp

@@ -0,0 +1,45 @@
+#ifndef MS_MOCKS_MOCK_CHANNEL_MESSAGE_REGISTRATOR_HPP
+#define MS_MOCKS_MOCK_CHANNEL_MESSAGE_REGISTRATOR_HPP
+
+#include "Channel/ChannelMessageRegistratorInterface.hpp"
+// TODO: We should have a ChannelSocketInterface class instead.
+#include "Channel/ChannelSocket.hpp"
+#include <string>
+#include <unordered_map>
+
+namespace mocks
+{
+	namespace Channel
+	{
+		class MockChannelMessageRegistrator : public ::Channel::ChannelMessageRegistratorInterface
+		{
+		public:
+			explicit MockChannelMessageRegistrator();
+
+			~MockChannelMessageRegistrator() override;
+
+		public:
+			flatbuffers::Offset<FBS::Worker::ChannelMessageHandlers> FillBuffer(
+			  flatbuffers::FlatBufferBuilder& builder) override;
+
+			void RegisterHandler(
+			  const std::string& id,
+			  ::Channel::ChannelSocket::RequestHandler* channelRequestHandler,
+			  ::Channel::ChannelSocket::NotificationHandler* channelNotificationHandler) override;
+
+			void UnregisterHandler(const std::string& id) override;
+
+			::Channel::ChannelSocket::RequestHandler* GetChannelRequestHandler(const std::string& id) override;
+
+			::Channel::ChannelSocket::NotificationHandler* GetChannelNotificationHandler(
+			  const std::string& id) override;
+
+		private:
+			std::unordered_map<std::string, ::Channel::ChannelSocket::RequestHandler*> mapChannelRequestHandlers;
+			std::unordered_map<std::string, ::Channel::ChannelSocket::NotificationHandler*>
+			  mapChannelNotificationHandlers;
+		};
+	} // namespace Channel
+} // namespace mocks
+
+#endif

package/worker/mocks/include/MockShared.hpp

@@ -0,0 +1,43 @@
+#ifndef MS_MOCKS_MOCK_SHARED_HPP
+#define MS_MOCKS_MOCK_SHARED_HPP
+
+#include "SharedInterface.hpp"
+#include "mocks/include/Channel/MockChannelMessageRegistrator.hpp"
+#include "Channel/ChannelNotifier.hpp"
+#include "Channel/ChannelSocket.hpp"
+#include "handles/BackoffTimerHandleInterface.hpp"
+#include "handles/TimerHandleInterface.hpp"
+
+namespace mocks
+{
+	class MockShared : public SharedInterface
+	{
+	public:
+		explicit MockShared();
+
+		~MockShared() override = default;
+
+	public:
+		::Channel::ChannelMessageRegistratorInterface* GetChannelMessageRegistrator() const override
+		{
+			return this->channelMessageRegistrator.get();
+		}
+
+		::Channel::ChannelNotifier* GetChannelNotifier() const override
+		{
+			return this->channelNotifier.get();
+		}
+
+		TimerHandleInterface* CreateTimer(TimerHandleInterface::Listener* listener) const override;
+
+		BackoffTimerHandleInterface* CreateBackoffTimer(
+		  const BackoffTimerHandleInterface::BackoffTimerHandleOptions& options) const override;
+
+	private:
+		std::unique_ptr<::Channel::ChannelSocket> channelSocket;
+		std::unique_ptr<mocks::Channel::MockChannelMessageRegistrator> channelMessageRegistrator;
+		std::unique_ptr<::Channel::ChannelNotifier> channelNotifier;
+	};
+} // namespace mocks
+
+#endif

package/worker/mocks/src/Channel/MockChannelMessageRegistrator.cpp

@@ -0,0 +1,128 @@
+#define MS_CLASS "ChannelMessageRegistrator"
+// #define MS_LOG_DEV_LEVEL 3
+
+#include "mocks/include/Channel/MockChannelMessageRegistrator.hpp"
+#include "Logger.hpp"
+#include "MediaSoupErrors.hpp"
+#include <vector>
+
+namespace mocks
+{
+	namespace Channel
+	{
+		MockChannelMessageRegistrator::MockChannelMessageRegistrator()
+		{
+			MS_TRACE();
+		}
+
+		MockChannelMessageRegistrator::~MockChannelMessageRegistrator()
+		{
+			MS_TRACE();
+
+			this->mapChannelRequestHandlers.clear();
+			this->mapChannelNotificationHandlers.clear();
+		}
+
+		flatbuffers::Offset<FBS::Worker::ChannelMessageHandlers> MockChannelMessageRegistrator::FillBuffer(
+		  flatbuffers::FlatBufferBuilder& builder)
+		{
+			// Add channelRequestHandlerIds.
+			std::vector<flatbuffers::Offset<flatbuffers::String>> channelRequestHandlerIds;
+
+			for (const auto& kv : this->mapChannelRequestHandlers)
+			{
+				const auto& handlerId = kv.first;
+
+				channelRequestHandlerIds.push_back(builder.CreateString(handlerId));
+			}
+
+			// Add channelNotificationHandlerIds.
+			std::vector<flatbuffers::Offset<flatbuffers::String>> channelNotificationHandlerIds;
+
+			for (const auto& kv : this->mapChannelNotificationHandlers)
+			{
+				const auto& handlerId = kv.first;
+
+				channelNotificationHandlerIds.push_back(builder.CreateString(handlerId));
+			}
+
+			return FBS::Worker::CreateChannelMessageHandlersDirect(
+			  builder, &channelRequestHandlerIds, &channelNotificationHandlerIds);
+		}
+
+		void MockChannelMessageRegistrator::RegisterHandler(
+		  const std::string& id,
+		  ::Channel::ChannelSocket::RequestHandler* channelRequestHandler,
+		  ::Channel::ChannelSocket::NotificationHandler* channelNotificationHandler)
+		{
+			MS_TRACE();
+
+			if (channelRequestHandler)
+			{
+				if (this->mapChannelRequestHandlers.contains(id))
+				{
+					MS_THROW_ERROR("Channel request handler with ID %s already exists", id.c_str());
+				}
+
+				this->mapChannelRequestHandlers[id] = channelRequestHandler;
+			}
+
+			if (channelNotificationHandler)
+			{
+				if (this->mapChannelNotificationHandlers.contains(id))
+				{
+					if (channelRequestHandler)
+					{
+						this->mapChannelRequestHandlers.erase(id);
+					}
+
+					MS_THROW_ERROR("Channel notification handler with ID %s already exists", id.c_str());
+				}
+
+				this->mapChannelNotificationHandlers[id] = channelNotificationHandler;
+			}
+		}
+
+		void MockChannelMessageRegistrator::UnregisterHandler(const std::string& id)
+		{
+			MS_TRACE();
+
+			this->mapChannelRequestHandlers.erase(id);
+			this->mapChannelNotificationHandlers.erase(id);
+		}
+
+		::Channel::ChannelSocket::RequestHandler* MockChannelMessageRegistrator::GetChannelRequestHandler(
+		  const std::string& id)
+		{
+			MS_TRACE();
+
+			auto it = this->mapChannelRequestHandlers.find(id);
+
+			if (it != this->mapChannelRequestHandlers.end())
+			{
+				return it->second;
+			}
+			else
+			{
+				return nullptr;
+			}
+		}
+
+		::Channel::ChannelSocket::NotificationHandler* MockChannelMessageRegistrator::GetChannelNotificationHandler(
+		  const std::string& id)
+		{
+			MS_TRACE();
+
+			auto it = this->mapChannelNotificationHandlers.find(id);
+
+			if (it != this->mapChannelNotificationHandlers.end())
+			{
+				return it->second;
+			}
+			else
+			{
+				return nullptr;
+			}
+		}
+	} // namespace Channel
+} // namespace mocks

package/worker/mocks/src/MockShared.cpp

@@ -0,0 +1,26 @@
+#include "mocks/include/MockShared.hpp"
+// TODO: We need MockBackoffTimerHandle class.
+#include "handles/BackoffTimerHandle.hpp"
+// TODO: We need MockTimerHandle class.
+#include "handles/TimerHandle.hpp"
+
+namespace mocks
+{
+	MockShared::MockShared()
+	  : channelSocket(new ::Channel::ChannelSocket()),
+	    channelMessageRegistrator(new mocks::Channel::MockChannelMessageRegistrator()),
+	    channelNotifier(new ::Channel::ChannelNotifier(this->channelSocket.get()))
+	{
+	}
+
+	TimerHandleInterface* MockShared::CreateTimer(TimerHandleInterface::Listener* listener) const
+	{
+		return new TimerHandle(listener);
+	}
+
+	BackoffTimerHandleInterface* MockShared::CreateBackoffTimer(
+	  const BackoffTimerHandleInterface::BackoffTimerHandleOptions& options) const
+	{
+		return new BackoffTimerHandle(options);
+	}
+} // namespace mocks

package/worker/scripts/clang-scripts.mjs

@@ -19,12 +19,15 @@ const CLANG_FORMAT_PATHS = [
 	'../test/include/**/**.hpp',
 	'../fuzzer/src/**/*.cpp',
 	'../fuzzer/include/**/*.hpp',
+	'../mocks/src/**/*.cpp',
+	'../mocks/include/**/*.hpp',
 ];
 
 const CLANG_TIDY_PATHS = [
 	'../src/**/*.cpp',
 	'../test/src/**/*.cpp',
 	'../fuzzer/src/**/*.cpp',
+	'../mocks/src/**/*.cpp',
 ];
 
 const task = process.argv.slice(2).join(' ');
@@ -287,7 +290,7 @@ function getRootDir() {
 }
 
 function getBuildDir() {
-	const workerDir = path.join(ROOT_DIR, 'worker/');
+	const workerDir = path.join(ROOT_DIR, 'worker');
 	const workerOutDir = process.env.MEDIASOUP_OUT_DIR ?? `${workerDir}/out`;
 	const mediasoupBuildtype = process.env.MEDIASOUP_BUILDTYPE ?? 'Release';
 	const workerInstallDir =

package/worker/src/Channel/ChannelMessageRegistrator.cpp

@@ -0,0 +1,125 @@
+#define MS_CLASS "ChannelMessageRegistrator"
+// #define MS_LOG_DEV_LEVEL 3
+
+#include "Channel/ChannelMessageRegistrator.hpp"
+#include "Logger.hpp"
+#include "MediaSoupErrors.hpp"
+#include <vector>
+
+namespace Channel
+{
+	ChannelMessageRegistrator::ChannelMessageRegistrator()
+	{
+		MS_TRACE();
+	}
+
+	ChannelMessageRegistrator::~ChannelMessageRegistrator()
+	{
+		MS_TRACE();
+
+		this->mapChannelRequestHandlers.clear();
+		this->mapChannelNotificationHandlers.clear();
+	}
+
+	flatbuffers::Offset<FBS::Worker::ChannelMessageHandlers> ChannelMessageRegistrator::FillBuffer(
+	  flatbuffers::FlatBufferBuilder& builder)
+	{
+		// Add channelRequestHandlerIds.
+		std::vector<flatbuffers::Offset<flatbuffers::String>> channelRequestHandlerIds;
+
+		for (const auto& kv : this->mapChannelRequestHandlers)
+		{
+			const auto& handlerId = kv.first;
+
+			channelRequestHandlerIds.push_back(builder.CreateString(handlerId));
+		}
+
+		// Add channelNotificationHandlerIds.
+		std::vector<flatbuffers::Offset<flatbuffers::String>> channelNotificationHandlerIds;
+
+		for (const auto& kv : this->mapChannelNotificationHandlers)
+		{
+			const auto& handlerId = kv.first;
+
+			channelNotificationHandlerIds.push_back(builder.CreateString(handlerId));
+		}
+
+		return FBS::Worker::CreateChannelMessageHandlersDirect(
+		  builder, &channelRequestHandlerIds, &channelNotificationHandlerIds);
+	}
+
+	void ChannelMessageRegistrator::RegisterHandler(
+	  const std::string& id,
+	  ChannelSocket::RequestHandler* channelRequestHandler,
+	  ChannelSocket::NotificationHandler* channelNotificationHandler)
+	{
+		MS_TRACE();
+
+		if (channelRequestHandler)
+		{
+			if (this->mapChannelRequestHandlers.contains(id))
+			{
+				MS_THROW_ERROR("Channel request handler with ID %s already exists", id.c_str());
+			}
+
+			this->mapChannelRequestHandlers[id] = channelRequestHandler;
+		}
+
+		if (channelNotificationHandler)
+		{
+			if (this->mapChannelNotificationHandlers.contains(id))
+			{
+				if (channelRequestHandler)
+				{
+					this->mapChannelRequestHandlers.erase(id);
+				}
+
+				MS_THROW_ERROR("Channel notification handler with ID %s already exists", id.c_str());
+			}
+
+			this->mapChannelNotificationHandlers[id] = channelNotificationHandler;
+		}
+	}
+
+	void ChannelMessageRegistrator::UnregisterHandler(const std::string& id)
+	{
+		MS_TRACE();
+
+		this->mapChannelRequestHandlers.erase(id);
+		this->mapChannelNotificationHandlers.erase(id);
+	}
+
+	ChannelSocket::RequestHandler* ChannelMessageRegistrator::GetChannelRequestHandler(
+	  const std::string& id)
+	{
+		MS_TRACE();
+
+		auto it = this->mapChannelRequestHandlers.find(id);
+
+		if (it != this->mapChannelRequestHandlers.end())
+		{
+			return it->second;
+		}
+		else
+		{
+			return nullptr;
+		}
+	}
+
+	ChannelSocket::NotificationHandler* ChannelMessageRegistrator::GetChannelNotificationHandler(
+	  const std::string& id)
+	{
+		MS_TRACE();
+
+		auto it = this->mapChannelNotificationHandlers.find(id);
+
+		if (it != this->mapChannelNotificationHandlers.end())
+		{
+			return it->second;
+		}
+		else
+		{
+			return nullptr;
+		}
+	}
+} // namespace Channel

package/worker/src/Channel/ChannelSocket.cpp

@@ -30,7 +30,7 @@ namespace Channel
 
 	/* Instance methods. */
 
-#ifdef MS_TEST
+#if defined(MS_TEST) || defined(MS_FUZZER)
 	ChannelSocket::ChannelSocket()
 	{
 		MS_TRACE_STD();

package/worker/src/DepUsrSCTP.cpp

@@ -75,6 +75,12 @@ void DepUsrSCTP::ClassInit()
 	{
 		usrsctp_init_nothreads(0, onSendSctpData, sctpDebug);
 
+		// See https://github.com/sctplab/usrsctp/blob/master/Manual.md#usrsctp_sysctl_set_sctp_sendspace.
+		//
+		// TODO: This doesn't have any effect. So let's comment it.
+		// usrsctp_sysctl_set_sctp_sendspace(std::numeric_limits<uint32_t>::max());
+		// usrsctp_sysctl_set_sctp_recvspace(std::numeric_limits<uint32_t>::max());
+
 		// Disable explicit congestion notifications (ecn).
 		usrsctp_sysctl_set_sctp_ecn_enable(0);
 
@@ -105,13 +111,13 @@ void DepUsrSCTP::ClassDestroy()
 	}
 }
 
-void DepUsrSCTP::CreateChecker()
+void DepUsrSCTP::CreateChecker(SharedInterface* shared)
 {
 	MS_TRACE();
 
 	MS_ASSERT(DepUsrSCTP::checker == nullptr, "Checker already created");
 
-	DepUsrSCTP::checker = new DepUsrSCTP::Checker();
+	DepUsrSCTP::checker = new DepUsrSCTP::Checker(shared);
 }
 
 void DepUsrSCTP::CloseChecker()
@@ -210,7 +216,7 @@ RTC::SctpAssociation* DepUsrSCTP::RetrieveSctpAssociation(uintptr_t id)
 
 /* DepUsrSCTP::Checker instance methods. */
 
-DepUsrSCTP::Checker::Checker() : timer(new TimerHandle(this))
+DepUsrSCTP::Checker::Checker(SharedInterface* shared) : timer(shared->CreateTimer(this))
 {
 	MS_TRACE();
 }
@@ -244,7 +250,7 @@ void DepUsrSCTP::Checker::Stop()
 	this->timer->Stop();
 }
 
-void DepUsrSCTP::Checker::OnTimer(TimerHandle* /*timer*/)
+void DepUsrSCTP::Checker::OnTimer(TimerHandleInterface* /*timer*/)
 {
 	MS_TRACE();
 

package/worker/src/RTC/ActiveSpeakerObserver.cpp

@@ -88,7 +88,7 @@ namespace RTC
 	}
 
 	ActiveSpeakerObserver::ActiveSpeakerObserver(
-	  RTC::Shared* shared,
+	  SharedInterface* shared,
 	  const std::string& id,
 	  RTC::RtpObserver::Listener* listener,
 	  const FBS::ActiveSpeakerObserver::ActiveSpeakerObserverOptions* options)
@@ -105,12 +105,12 @@ namespace RTC
 			this->interval = 5000;
 		}
 
-		this->periodicTimer = new TimerHandle(this);
+		this->periodicTimer = this->shared->CreateTimer(this);
 
 		this->periodicTimer->Start(interval, interval);
 
 		// NOTE: This may throw.
-		this->shared->channelMessageRegistrator->RegisterHandler(
+		this->shared->GetChannelMessageRegistrator()->RegisterHandler(
 		  this->id,
 		  /*channelRequestHandler*/ this,
 		  /*channelNotificationHandler*/ nullptr);
@@ -120,7 +120,7 @@ namespace RTC
 	{
 		MS_TRACE();
 
-		this->shared->channelMessageRegistrator->UnregisterHandler(this->id);
+		this->shared->GetChannelMessageRegistrator()->UnregisterHandler(this->id);
 
 		delete this->periodicTimer;
 
@@ -249,7 +249,7 @@ namespace RTC
 		this->periodicTimer->Restart();
 	}
 
-	void ActiveSpeakerObserver::OnTimer(TimerHandle* /*timer*/)
+	void ActiveSpeakerObserver::OnTimer(TimerHandleInterface* /*timer*/)
 	{
 		MS_TRACE();
 
@@ -275,9 +275,9 @@ namespace RTC
 		if (!this->mapProducerSpeakers.empty() && CalculateActiveSpeaker())
 		{
 			auto notification = FBS::ActiveSpeakerObserver::CreateDominantSpeakerNotificationDirect(
-			  this->shared->channelNotifier->GetBufferBuilder(), this->dominantId.c_str());
+			  this->shared->GetChannelNotifier()->GetBufferBuilder(), this->dominantId.c_str());
 
-			this->shared->channelNotifier->Emit(
+			this->shared->GetChannelNotifier()->Emit(
 			  this->id,
 			  FBS::Notification::Event::ACTIVESPEAKEROBSERVER_DOMINANT_SPEAKER,
 			  FBS::Notification::Body::ActiveSpeakerObserver_DominantSpeakerNotification,

package/worker/src/RTC/AudioLevelObserver.cpp

@@ -13,7 +13,7 @@ namespace RTC
 	/* Instance methods. */
 
 	AudioLevelObserver::AudioLevelObserver(
-	  RTC::Shared* shared,
+	  SharedInterface* shared,
 	  const std::string& id,
 	  RTC::RtpObserver::Listener* listener,
 	  const FBS::AudioLevelObserver::AudioLevelObserverOptions* options)
@@ -39,12 +39,12 @@ namespace RTC
 			this->interval = 5000;
 		}
 
-		this->periodicTimer = new TimerHandle(this);
+		this->periodicTimer = this->shared->CreateTimer(this);
 
 		this->periodicTimer->Start(this->interval, this->interval);
 
 		// NOTE: This may throw.
-		this->shared->channelMessageRegistrator->RegisterHandler(
+		this->shared->GetChannelMessageRegistrator()->RegisterHandler(
 		  this->id,
 		  /*channelRequestHandler*/ this,
 		  /*channelNotificationHandler*/ nullptr);
@@ -54,7 +54,7 @@ namespace RTC
 	{
 		MS_TRACE();
 
-		this->shared->channelMessageRegistrator->UnregisterHandler(this->id);
+		this->shared->GetChannelMessageRegistrator()->UnregisterHandler(this->id);
 
 		delete this->periodicTimer;
 	}
@@ -127,7 +127,7 @@ namespace RTC
 		{
 			this->silence = true;
 
-			this->shared->channelNotifier->Emit(
+			this->shared->GetChannelNotifier()->Emit(
 			  this->id, FBS::Notification::Event::AUDIOLEVELOBSERVER_SILENCE);
 		}
 	}
@@ -179,13 +179,15 @@ namespace RTC
 			{
 				volumes.emplace_back(
 				  FBS::AudioLevelObserver::CreateVolumeDirect(
-				    this->shared->channelNotifier->GetBufferBuilder(), rit->second->id.c_str(), rit->first));
+				    this->shared->GetChannelNotifier()->GetBufferBuilder(),
+				    rit->second->id.c_str(),
+				    rit->first));
 			}
 
 			auto notification = FBS::AudioLevelObserver::CreateVolumesNotificationDirect(
-			  this->shared->channelNotifier->GetBufferBuilder(), &volumes);
+			  this->shared->GetChannelNotifier()->GetBufferBuilder(), &volumes);
 
-			this->shared->channelNotifier->Emit(
+			this->shared->GetChannelNotifier()->Emit(
 			  this->id,
 			  FBS::Notification::Event::AUDIOLEVELOBSERVER_VOLUMES,
 			  FBS::Notification::Body::AudioLevelObserver_VolumesNotification,
@@ -195,7 +197,7 @@ namespace RTC
 		{
 			this->silence = true;
 
-			this->shared->channelNotifier->Emit(
+			this->shared->GetChannelNotifier()->Emit(
 			  this->id, FBS::Notification::Event::AUDIOLEVELOBSERVER_SILENCE);
 		}
 	}
@@ -213,7 +215,7 @@ namespace RTC
 		}
 	}
 
-	inline void AudioLevelObserver::OnTimer(TimerHandle* /*timer*/)
+	inline void AudioLevelObserver::OnTimer(TimerHandleInterface* /*timer*/)
 	{
 		MS_TRACE();