mediasoup 3.19.21 → 3.19.22

package/worker/include/Shared.hpp

@@ -0,0 +1,40 @@
+#ifndef MS_SHARED_HPP
+#define MS_SHARED_HPP
+
+#include "SharedInterface.hpp"
+#include "Channel/ChannelMessageRegistrator.hpp"
+#include "Channel/ChannelNotifier.hpp"
+#include "handles/BackoffTimerHandleInterface.hpp"
+#include "handles/TimerHandleInterface.hpp"
+
+class Shared : public SharedInterface
+{
+public:
+	explicit Shared(
+	  Channel::ChannelMessageRegistrator* channelMessageRegistrator,
+	  Channel::ChannelNotifier* channelNotifier);
+
+	~Shared() override;
+
+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::ChannelMessageRegistrator> channelMessageRegistrator;
+	std::unique_ptr<Channel::ChannelNotifier> channelNotifier;
+};
+
+#endif

package/worker/include/SharedInterface.hpp

@@ -0,0 +1,44 @@
+#ifndef MS_SHARED_INTERFACE_HPP
+#define MS_SHARED_INTERFACE_HPP
+
+#include "Channel/ChannelMessageRegistratorInterface.hpp"
+// TODO: We should have a ChannelNotifierInterface class instead.
+#include "Channel/ChannelNotifier.hpp"
+#include "handles/BackoffTimerHandleInterface.hpp"
+#include "handles/TimerHandleInterface.hpp"
+
+class SharedInterface
+{
+public:
+	virtual ~SharedInterface() = default;
+
+public:
+	/**
+	 * @todo We should have a ChannelMessageRegistratorInterface class instead.
+	 */
+	virtual Channel::ChannelMessageRegistratorInterface* GetChannelMessageRegistrator() const = 0;
+
+	/**
+	 * @todo We should have a ChannelNotifierInterface class instead.
+	 */
+	virtual Channel::ChannelNotifier* GetChannelNotifier() const = 0;
+
+	/**
+	 * Creates a TimerHandle timer.
+	 *
+	 * @remarks
+	 * - The caller is responsible for freeing it.
+	 */
+	virtual TimerHandleInterface* CreateTimer(TimerHandleInterface::Listener* listener) const = 0;
+
+	/**
+	 * Creates a BackoffTimerHandle timer.
+	 *
+	 * @remarks
+	 * - The caller is responsible for freeing it.
+	 */
+	virtual BackoffTimerHandleInterface* CreateBackoffTimer(
+	  const BackoffTimerHandleInterface::BackoffTimerHandleOptions& options) const = 0;
+};
+
+#endif

package/worker/include/Utils.hpp

@@ -212,6 +212,12 @@ namespace Utils
 			return (size + 3) & ~static_cast<T>(0x03);
 		}
 
+		template<typename T>
+		typename std::enable_if<std::is_unsigned<T>::value, T>::type static PadDownTo4Bytes(T size)
+		{
+			return size & ~static_cast<T>(0x03);
+		}
+
 		template<typename T>
 		typename std::enable_if<std::is_unsigned<T>::value, T>::type static PadTo8Bytes(T size)
 		{

package/worker/include/Worker.hpp

@@ -1,11 +1,11 @@
 #ifndef MS_WORKER_HPP
 #define MS_WORKER_HPP
 
+#include "SharedInterface.hpp"
 #include "Channel/ChannelRequest.hpp"
 #include "Channel/ChannelSocket.hpp"
 #include "FBS/worker.h"
 #include "RTC/Router.hpp"
-#include "RTC/Shared.hpp"
 #include "RTC/WebRtcServer.hpp"
 #include "handles/SignalHandle.hpp"
 #include <flatbuffers/flatbuffer_builder.h>
@@ -17,7 +17,7 @@ class Worker : public Channel::ChannelSocket::Listener,
                public RTC::Router::Listener
 {
 public:
-	explicit Worker(Channel::ChannelSocket* channel);
+	explicit Worker(Channel::ChannelSocket* channel, SharedInterface* shared);
 	~Worker() override;
 
 private:
@@ -53,7 +53,7 @@ private:
 	Channel::ChannelSocket* channel{ nullptr };
 	// Allocated by this.
 	SignalHandle* signalHandle{ nullptr };
-	RTC::Shared* shared{ nullptr };
+	SharedInterface* shared{ nullptr };
 	absl::flat_hash_map<std::string, RTC::WebRtcServer*> mapWebRtcServers;
 	absl::flat_hash_map<std::string, RTC::Router*> mapRouters;
 	// Others.

package/worker/include/common.hpp

@@ -1,7 +1,7 @@
 #ifndef MS_COMMON_HPP
 #define MS_COMMON_HPP
 
-#include <algorithm> // IWYU pragma: export  std::transform(), std::find(), std::min(), std::max(), std::copy(), std::clamp()
+#include <algorithm> // IWYU pragma: export  std::transform(), std::find(), std::min(), std::max(), std::copy(), std::clamp(), std::ranges
 #include <cinttypes> // IWYU pragma: export  PRIu64, etc
 #include <cstddef>   // IWYU pragma: export  size_t
 #include <cstdint>   // IWYU pragma: export  uint8_t, etc

package/worker/include/handles/BackoffTimerHandle.hpp

@@ -2,68 +2,29 @@
 #define MS_BACKOFF_TIMER_HANDLE_HPP
 
 #include "common.hpp"
+#include "handles/BackoffTimerHandleInterface.hpp"
 #include "handles/TimerHandle.hpp"
-#include <limits> // std::numeric_limits()
+#include "handles/TimerHandleInterface.hpp"
 
-class BackoffTimerHandle : public TimerHandle::Listener
+// Forward declaration.
+class Shared;
+// TODO: Temporal until we have MockBackoffTimerHandle.
+namespace mocks
 {
-public:
-	class Listener
-	{
-	public:
-		virtual ~Listener() = default;
-
-	public:
-		/**
-		 * Invoked on timeout expiration. The parent can modify the base
-		 * timeout given as reference and affect the next timeout duration.
-		 *
-		 * @remarks
-		 * - If the caller deletes this BackoffTimer instance within the callback
-		 *   it must signal it be setting `stop` to true.
-		 */
-		virtual void OnTimer(BackoffTimerHandle* backoffTimer, uint64_t& baseTimeoutMs, bool& stop) = 0;
-	};
+	class MockShared;
+}
 
-public:
-	enum class BackoffAlgorithm : uint8_t
-	{
-		// The base duration will be used for any restart.
-		FIXED,
-		// An exponential backoff is used for restarts, with a 2x multiplier,
-		// meaning that every restart will use a duration that is twice as long as
-		// the previous.
-		EXPONENTIAL,
-	};
+class BackoffTimerHandle : public BackoffTimerHandleInterface, public TimerHandleInterface::Listener
+{
+	// Only Shared class can invoke the constructor.
+	friend class Shared;
+	// TODO: Temporal until we have MockBackoffTimerHandle.
+	friend class mocks::MockShared;
 
-public:
-	static constexpr uint64_t MaxTimeoutMs{ std::numeric_limits<uint64_t>::max() / 2 };
+private:
+	explicit BackoffTimerHandle(const BackoffTimerHandleOptions& options);
 
 public:
-	explicit BackoffTimerHandle(
-	  /**
-	   * Listener on which OnTimer() callback will be invoked.
-	   */
-	  Listener* listener,
-	  /**
-	   * Base timeout duration (ms).
-	   */
-	  uint64_t baseTimeoutMs,
-	  /**
-	   * Backoff algorithm.
-	   */
-	  BackoffAlgorithm backoffAlgorithm,
-	  /**
-	   * Maximum duration of the backoff timeout (ms). If no value is given, no
-	   * limit is set.
-	   */
-	  std::optional<uint64_t> maxBackoffTimeoutMs,
-	  /**
-	   * Maximum number of restarts. If no value is given, it will restart
-	   * forever until stopped.
-	   */
-	  std::optional<size_t> maxRestarts);
-
 	BackoffTimerHandle& operator=(const BackoffTimerHandle&) = delete;
 
 	BackoffTimerHandle(const BackoffTimerHandle&) = delete;
@@ -75,24 +36,24 @@ public:
 	 * Start the BackoffTimer (if it's stopped) or restart it (if already
 	 * running). It will reset the timeout count.
 	 */
-	void Start();
+	void Start() override;
 
 	/**
 	 * Stop the BackoffTimer. It will reset the timeout count.
 	 */
-	void Stop();
+	void Stop() override;
 
 	/**
 	 * Set the base timeout duration. It will be applied after the next timeout
 	 * and effective duration can be larger if backoff algorithm is exponential.
 	 */
-	void SetBaseTimeoutMs(uint64_t baseTimeoutMs);
+	void SetBaseTimeoutMs(uint64_t baseTimeoutMs) override;
 
 	/**
 	 * Whether the BackoffTimer is running. Useful to check if this BackoffTimer
 	 * will timeout again within the OnTimer() callback.
 	 */
-	bool IsRunning() const
+	bool IsRunning() const override
 	{
 		return this->running;
 	}
@@ -101,9 +62,10 @@ public:
 	 * Maximum number of restarts.
 	 *
 	 * @remarks
-	 * - If `maxRestarts` was not given in the constructor, this method returns 0.
+	 * - If `maxRestarts` was not given in the constructor, this method returns
+	 *   `std::nullopt`.
 	 */
-	std::optional<size_t> GetMaxRestarts() const
+	std::optional<size_t> GetMaxRestarts() const override
 	{
 		return this->maxRestarts;
 	}
@@ -111,7 +73,7 @@ public:
 	/**
 	 * Number of times the timer has expired.
 	 */
-	size_t GetExpirationCount() const
+	size_t GetExpirationCount() const override
 	{
 		return this->expirationCount;
 	}
@@ -119,13 +81,13 @@ public:
 private:
 	uint64_t ComputeNextTimeoutMs() const;
 
-	/* Pure virtual methods inherited from TimerHandle::Listener. */
+	/* Pure virtual methods inherited from TimerHandleInterface::Listener. */
 public:
-	void OnTimer(TimerHandle* timer) override;
+	void OnTimer(TimerHandleInterface* timer) override;
 
 private:
 	// Passed by argument.
-	Listener* listener{ nullptr };
+	BackoffTimerHandleInterface::Listener* listener{ nullptr };
 	uint64_t baseTimeoutMs{ 0 };
 	BackoffAlgorithm backoffAlgorithm;
 	std::optional<uint64_t> maxBackoffTimeoutMs;

package/worker/include/handles/BackoffTimerHandleInterface.hpp

@@ -0,0 +1,116 @@
+#ifndef MS_BACKOFF_TIMER_HANDLE_INTERFACE_HPP
+#define MS_BACKOFF_TIMER_HANDLE_INTERFACE_HPP
+
+#include "common.hpp"
+#include <limits> // std::numeric_limits()
+
+class BackoffTimerHandleInterface
+{
+public:
+	class Listener
+	{
+	public:
+		virtual ~Listener() = default;
+
+	public:
+		/**
+		 * Invoked on timeout expiration. The parent can modify the base
+		 * timeout given as reference and affect the next timeout duration.
+		 *
+		 * @remarks
+		 * - If the caller deletes this BackoffTimer instance within the callback
+		 *   it must signal it be setting `stop` to true.
+		 */
+		virtual void OnTimer(
+		  BackoffTimerHandleInterface* backoffTimer, uint64_t& baseTimeoutMs, bool& stop) = 0;
+	};
+
+public:
+	enum class BackoffAlgorithm : uint8_t
+	{
+		// The base duration will be used for any restart.
+		FIXED,
+		// An exponential backoff is used for restarts, with a 2x multiplier,
+		// meaning that every restart will use a duration that is twice as long as
+		// the previous.
+		EXPONENTIAL,
+	};
+
+public:
+	struct BackoffTimerHandleOptions
+	{
+		/**
+		 * Listener on which OnTimer() callback will be invoked.
+		 */
+		BackoffTimerHandleInterface::Listener* listener;
+		/**
+		 * Base timeout duration (ms).
+		 */
+		uint64_t baseTimeoutMs;
+		/**
+		 * Backoff algorithm.
+		 */
+		BackoffAlgorithm backoffAlgorithm;
+		/**
+		 * Maximum duration of the backoff timeout (ms). If no value is given, no
+		 * limit is set.
+		 */
+		std::optional<uint64_t> maxBackoffTimeoutMs;
+		/**
+		 * Maximum number of restarts. If no value is given, it will restart
+		 * forever until stopped.
+		 */
+		std::optional<size_t> maxRestarts;
+	};
+
+public:
+	static constexpr uint64_t MaxTimeoutMs{ std::numeric_limits<uint64_t>::max() / 2 };
+
+public:
+	BackoffTimerHandleInterface() = default;
+
+	BackoffTimerHandleInterface& operator=(const BackoffTimerHandleInterface&) = delete;
+
+	BackoffTimerHandleInterface(const BackoffTimerHandleInterface&) = delete;
+
+	virtual ~BackoffTimerHandleInterface() = default;
+
+public:
+	/**
+	 * Start the BackoffTimer (if it's stopped) or restart it (if already
+	 * running). It will reset the timeout count.
+	 */
+	virtual void Start() = 0;
+
+	/**
+	 * Stop the BackoffTimer. It will reset the timeout count.
+	 */
+	virtual void Stop() = 0;
+
+	/**
+	 * Set the base timeout duration. It will be applied after the next timeout
+	 * and effective duration can be larger if backoff algorithm is exponential.
+	 */
+	virtual void SetBaseTimeoutMs(uint64_t baseTimeoutMs) = 0;
+
+	/**
+	 * Whether the BackoffTimer is running. Useful to check if this BackoffTimer
+	 * will timeout again within the OnTimer() callback.
+	 */
+	virtual bool IsRunning() const = 0;
+
+	/**
+	 * Maximum number of restarts.
+	 *
+	 * @remarks
+	 * - If `maxRestarts` was not given in the constructor, this method returns 0.
+	 */
+	virtual std::optional<size_t> GetMaxRestarts() const = 0;
+
+	/**
+	 * Number of times the timer has expired.
+	 */
+	virtual size_t GetExpirationCount() const = 0;
+};
+
+#endif

package/worker/include/handles/TimerHandle.hpp

@@ -2,40 +2,56 @@
 #define MS_TIMER_HANDLE_HPP
 
 #include "common.hpp"
+#include "handles/TimerHandleInterface.hpp"
 #include <uv.h>
 
-class TimerHandle
+// Forward declaration.
+class Shared;
+class BackoffTimerHandle;
+// TODO: Temporal until we have MockBackoffTimerHandle.
+namespace mocks
 {
-public:
-	class Listener
-	{
-	public:
-		virtual ~Listener() = default;
+	class MockShared;
+}
 
-	public:
-		virtual void OnTimer(TimerHandle* timer) = 0;
-	};
+class TimerHandle : public TimerHandleInterface
+{
+	// Only Shared and BackoffTimerHandle classes can invoke the constructor.
+	friend class Shared;
+	friend class BackoffTimerHandle;
+	// TODO: Temporal until we have MockBackoffTimerHandle.
+	friend class mocks::MockShared;
+
+private:
+	explicit TimerHandle(TimerHandleInterface::Listener* listener);
 
 public:
-	explicit TimerHandle(Listener* listener);
 	TimerHandle& operator=(const TimerHandle&) = delete;
-	TimerHandle(const TimerHandle&)            = delete;
-	~TimerHandle();
+
+	TimerHandle(const TimerHandle&) = delete;
+
+	~TimerHandle() override;
 
 public:
-	void Start(uint64_t timeout, uint64_t repeat = 0);
-	void Stop();
-	void Restart();
-	void Restart(uint64_t timeout, uint64_t repeat = 0);
-	uint64_t GetTimeout() const
+	void Start(uint64_t timeout, uint64_t repeat = 0) override;
+
+	void Stop() override;
+
+	void Restart() override;
+
+	void Restart(uint64_t timeout, uint64_t repeat = 0) override;
+
+	uint64_t GetTimeout() const override
 	{
 		return this->timeout;
 	}
-	uint64_t GetRepeat() const
+
+	uint64_t GetRepeat() const override
 	{
 		return this->repeat;
 	}
-	bool IsActive() const
+
+	bool IsActive() const override
 	{
 		return uv_is_active(reinterpret_cast<uv_handle_t*>(this->uvHandle)) != 0;
 	}
@@ -49,7 +65,7 @@ public:
 
 private:
 	// Passed by argument.
-	Listener* listener{ nullptr };
+	TimerHandleInterface::Listener* listener{ nullptr };
 	// Allocated by this.
 	uv_timer_t* uvHandle{ nullptr };
 	// Others.

package/worker/include/handles/TimerHandleInterface.hpp

@@ -0,0 +1,43 @@
+#ifndef MS_TIMER_HANDLE_INTERFACE_HPP
+#define MS_TIMER_HANDLE_INTERFACE_HPP
+
+#include "common.hpp"
+
+class TimerHandleInterface
+{
+public:
+	class Listener
+	{
+	public:
+		virtual ~Listener() = default;
+
+	public:
+		virtual void OnTimer(TimerHandleInterface* timer) = 0;
+	};
+
+public:
+	TimerHandleInterface() = default;
+
+	TimerHandleInterface& operator=(const TimerHandleInterface&) = delete;
+
+	TimerHandleInterface(const TimerHandleInterface&) = delete;
+
+	virtual ~TimerHandleInterface() = default;
+
+public:
+	virtual void Start(uint64_t timeout, uint64_t repeat = 0) = 0;
+
+	virtual void Stop() = 0;
+
+	virtual void Restart() = 0;
+
+	virtual void Restart(uint64_t timeout, uint64_t repeat = 0) = 0;
+
+	virtual uint64_t GetTimeout() const = 0;
+
+	virtual uint64_t GetRepeat() const = 0;
+
+	virtual bool IsActive() const = 0;
+};
+
+#endif

package/worker/meson.build

@@ -33,6 +33,13 @@ if get_option('ms_build_tests')
   ]
 endif
 
+if get_option('ms_build_fuzzer')
+  cpp_args += [
+    '-DMS_FUZZER',
+    '-DMS_LOG_STD'
+  ]
+endif
+
 if get_option('ms_log_trace')
   cpp_args += [
     '-DMS_LOG_TRACE',
@@ -86,8 +93,8 @@ common_sources = [
   'src/Logger.cpp',
   'src/MediaSoupErrors.cpp',
   'src/Settings.cpp',
+  'src/Shared.cpp',
   'src/Worker.cpp',
-  'src/ChannelMessageRegistrator.cpp',
   'src/Utils/BitStream.cpp',
   'src/Utils/Crypto.cpp',
   'src/Utils/File.cpp',
@@ -102,6 +109,7 @@ common_sources = [
   'src/handles/UnixStreamSocketHandle.cpp',
   'src/Channel/ChannelNotifier.cpp',
   'src/Channel/ChannelRequest.cpp',
+  'src/Channel/ChannelMessageRegistrator.cpp',
   'src/Channel/ChannelNotification.cpp',
   'src/Channel/ChannelSocket.cpp',
   'src/RTC/ActiveSpeakerObserver.cpp',
@@ -129,7 +137,6 @@ common_sources = [
   'src/RTC/SenderBandwidthEstimator.cpp',
   'src/RTC/SeqManager.cpp',
   'src/RTC/Serializable.cpp',
-  'src/RTC/Shared.cpp',
   'src/RTC/SimpleConsumer.cpp',
   'src/RTC/SimulcastConsumer.cpp',
   'src/RTC/SrtpSession.cpp',
@@ -208,7 +215,9 @@ common_sources = [
   'src/RTC/SCTP/association/StreamResetHandler.cpp',
   'src/RTC/SCTP/association/TransmissionControlBlock.cpp',
   'src/RTC/SCTP/tx/RetransmissionErrorCounter.cpp',
+  'src/RTC/SCTP/tx/RetransmissionQueue.cpp',
   'src/RTC/SCTP/tx/RetransmissionTimeout.cpp',
+  'src/RTC/SCTP/tx/OutstandingData.cpp',
   'src/RTC/SCTP/packet/Packet.cpp',
   'src/RTC/SCTP/packet/TLV.cpp',
   'src/RTC/SCTP/packet/UserData.cpp',
@@ -485,6 +494,7 @@ test_sources = [
   'test/src/RTC/SCTP/common/TestUnwrappedSequenceNumber.cpp',
   'test/src/RTC/SCTP/tx/TestRetransmissionErrorCounter.cpp',
   'test/src/RTC/SCTP/tx/TestRetransmissionTimeout.cpp',
+  'test/src/RTC/SCTP/tx/TestOutstandingData.cpp',
   'test/src/RTC/SCTP/packet/TestPacket.cpp',
   'test/src/RTC/SCTP/packet/TestChunk.cpp',
   'test/src/RTC/SCTP/packet/TestParameter.cpp',
@@ -545,6 +555,8 @@ test_sources = [
   'test/src/Utils/TestNumber.cpp',
   'test/src/Utils/TestString.cpp',
   'test/src/Utils/TestTime.cpp',
+  'mocks/src/MockShared.cpp',
+  'mocks/src/Channel/MockChannelMessageRegistrator.cpp',
 ]
 
 mediasoup_worker_test = executable(
@@ -557,6 +569,7 @@ mediasoup_worker_test = executable(
   include_directories: include_directories(
     'include',
     'test/include',
+    'mocks/include',
   ),
   cpp_args: cpp_args,
 )
@@ -577,6 +590,7 @@ mediasoup_worker_test_asan_address = executable(
   include_directories: include_directories(
     'include',
     'test/include',
+    'mocks/include',
   ),
   cpp_args: cpp_args + [
     '-g',
@@ -605,6 +619,7 @@ mediasoup_worker_test_asan_undefined = executable(
   include_directories: include_directories(
     'include',
     'test/include',
+    'mocks/include',
   ),
   cpp_args: cpp_args + [
     '-g',
@@ -665,7 +680,9 @@ fuzzer_sources = common_sources + [
   'fuzzer/src/RTC/RTCP/FuzzerSenderReport.cpp',
   'fuzzer/src/RTC/RTCP/FuzzerXr.cpp',
   'fuzzer/src/RTC/SCTP/association/FuzzerStateCookie.cpp',
-  'fuzzer/src/RTC/SCTP/packet/FuzzerPacket.cpp'
+  'fuzzer/src/RTC/SCTP/packet/FuzzerPacket.cpp',
+  'mocks/src/MockShared.cpp',
+  'mocks/src/Channel/MockChannelMessageRegistrator.cpp',
 ]
 
 executable(
@@ -678,9 +695,9 @@ executable(
   include_directories: include_directories(
     'include',
     'fuzzer/include',
+    'mocks/include',
   ),
   cpp_args: cpp_args + [
-    '-DMS_LOG_STD',
     '-g',
     '-O3',
     '-fno-omit-frame-pointer',

package/worker/meson_options.txt

@@ -1,7 +1,8 @@
-option('ms_build_tests', type: 'boolean', value: false, description: 'Whether to build mediasoup worker tests')
 option('ms_log_trace', type: 'boolean', value: false, description: 'Logs the current method/function if current log level is "debug"')
 option('ms_log_file_line', type: 'boolean', value: false, description: 'Logging macros print more verbose information, including current file and line')
 option('ms_rtc_logger_rtp', type: 'boolean', value: false, description: 'Prints a line with information for each processed RTP packet')
 option('ms_dump_rtp_payload_descriptor', type: 'boolean', value: false, description: 'RTC::RTP::Packet::Dump() method also dumps payload descriptor details')
 option('ms_dump_rtp_shared_packet_memory_usage', type: 'boolean', value: false, description: 'prints information about total memory allocated by RTC::RTP::SharedPacket instances')
 option('ms_disable_liburing', type: 'boolean', value: false, description: 'When set to true, disables liburing integration despite current host supports it')
+option('ms_build_tests', type: 'boolean', value: false, description: 'Must be enabled when building mediasoup worker tests')
+option('ms_build_fuzzer', type: 'boolean', value: false, description: 'Must be enabled when building mediasoup worker fuzzer')