mediasoup 3.12.8 → 3.12.9

package/node/lib/Router.js

@@ -226,11 +226,11 @@ class Router extends EnhancedEventEmitter_1.EnhancedEventEmitter {
         transport.on('@producerclose', (producer) => this.#producers.delete(producer.id));
         transport.on('@newdataproducer', (dataProducer) => (this.#dataProducers.set(dataProducer.id, dataProducer)));
         transport.on('@dataproducerclose', (dataProducer) => (this.#dataProducers.delete(dataProducer.id)));
+        // Emit observer event.
+        this.#observer.safeEmit('newtransport', transport);
         if (webRtcServer) {
             webRtcServer.handleWebRtcTransport(transport);
         }
-        // Emit observer event.
-        this.#observer.safeEmit('newtransport', transport);
         return transport;
     }
     /**

package/node/lib/Worker.js

@@ -90,7 +90,7 @@ class Worker extends EnhancedEventEmitter_1.EnhancedEventEmitter {
         // options
         {
             env: {
-                MEDIASOUP_VERSION: '3.12.8',
+                MEDIASOUP_VERSION: '3.12.9',
                 // Let the worker process inherit all environment variables, useful
                 // if a custom and not in the path GCC is used so the user can set
                 // LD_LIBRARY_PATH environment variable for runtime.

package/node/lib/index.d.ts

@@ -10,7 +10,7 @@ export { types };
 /**
  * Expose mediasoup version.
  */
-export declare const version = "3.12.8";
+export declare const version = "3.12.9";
 /**
  * Expose parseScalabilityMode() function.
  */

package/node/lib/index.js

@@ -12,7 +12,7 @@ exports.types = types;
 /**
  * Expose mediasoup version.
  */
-exports.version = '3.12.8';
+exports.version = '3.12.9';
 /**
  * Expose parseScalabilityMode() function.
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mediasoup",
-  "version": "3.12.8",
+  "version": "3.12.9",
   "description": "Cutting Edge WebRTC Video Conferencing",
   "contributors": [
     "Iñaki Baz Castillo <ibc@aliax.net> (https://inakibaz.me)",
@@ -89,7 +89,7 @@
   "dependencies": {
     "debug": "^4.3.4",
     "h264-profile-level-id": "^1.0.1",
-    "node-fetch": "^3.3.1",
+    "node-fetch": "^3.3.2",
     "supports-color": "^9.4.0",
     "tar": "^6.1.15",
     "uuid": "^9.0.0"
@@ -98,14 +98,14 @@
     "@octokit/rest": "^20.0.1",
     "@types/debug": "^4.1.8",
     "@types/jest": "^29.5.3",
-    "@types/node": "^20.4.2",
+    "@types/node": "^20.4.9",
     "@types/uuid": "^9.0.2",
-    "@typescript-eslint/eslint-plugin": "^6.1.0",
-    "@typescript-eslint/parser": "^6.1.0",
-    "eslint": "^8.45.0",
+    "@typescript-eslint/eslint-plugin": "^6.3.0",
+    "@typescript-eslint/parser": "^6.3.0",
+    "eslint": "^8.46.0",
     "eslint-plugin-jest": "^27.2.3",
-    "jest": "^29.6.1",
-    "marked": "^5.1.1",
+    "jest": "^29.6.2",
+    "marked": "^7.0.1",
     "open-cli": "^7.2.0",
     "pick-port": "^1.0.1",
     "sctp": "^1.0.0",

package/worker/include/RTC/RTCP/Sdes.hpp

@@ -121,6 +121,9 @@ namespace RTC
 					size += item->GetSize();
 				}
 
+				// Add the mandatory null octet.
+				++size;
+
 				// Consider pading to 32 bits (4 bytes) boundary.
 				// http://stackoverflow.com/questions/11642210/computing-padding-required-for-n-byte-alignment
 				return (size + 3) & ~3;

package/worker/src/Channel/ChannelSocket.cpp

@@ -24,9 +24,9 @@ namespace Channel
 		}
 	}
 
-	inline static void onClose(uv_handle_t* handle)
+	inline static void onCloseAsync(uv_handle_t* handle)
 	{
-		delete handle;
+		delete reinterpret_cast<uv_async_t*>(handle);
 	}
 
 	/* Instance methods. */
@@ -100,7 +100,8 @@ namespace Channel
 
 		if (this->uvReadHandle)
 		{
-			uv_close(reinterpret_cast<uv_handle_t*>(this->uvReadHandle), static_cast<uv_close_cb>(onClose));
+			uv_close(
+			  reinterpret_cast<uv_handle_t*>(this->uvReadHandle), static_cast<uv_close_cb>(onCloseAsync));
 		}
 
 		if (this->consumerSocket)

package/worker/src/DepLibUV.cpp

@@ -11,9 +11,9 @@ thread_local uv_loop_t* DepLibUV::loop{ nullptr };
 
 /* Static methods for UV callbacks. */
 
-inline static void onClose(uv_handle_t* handle)
+inline static void onCloseLoop(uv_handle_t* handle)
 {
-	delete handle;
+	delete reinterpret_cast<uv_loop_t*>(handle);
 }
 
 inline static void onWalk(uv_handle_t* handle, void* /*arg*/)
@@ -27,7 +27,7 @@ inline static void onWalk(uv_handle_t* handle, void* /*arg*/)
 	  uv_has_ref(handle));
 
 	if (!uv_is_closing(handle))
-		uv_close(handle, onClose);
+		uv_close(handle, onCloseLoop);
 }
 
 /* Static methods. */

package/worker/src/PayloadChannel/PayloadChannelSocket.cpp

@@ -25,9 +25,9 @@ namespace PayloadChannel
 		}
 	}
 
-	inline static void onClose(uv_handle_t* handle)
+	inline static void onCloseAsync(uv_handle_t* handle)
 	{
-		delete handle;
+		delete reinterpret_cast<uv_async_t*>(handle);
 	}
 
 	/* Instance methods. */
@@ -102,7 +102,8 @@ namespace PayloadChannel
 
 		if (this->uvReadHandle)
 		{
-			uv_close(reinterpret_cast<uv_handle_t*>(this->uvReadHandle), static_cast<uv_close_cb>(onClose));
+			uv_close(
+			  reinterpret_cast<uv_handle_t*>(this->uvReadHandle), static_cast<uv_close_cb>(onCloseAsync));
 		}
 
 		if (this->consumerSocket)

package/worker/src/RTC/PortManager.cpp

@@ -12,9 +12,16 @@
 
 /* Static methods for UV callbacks. */
 
-static inline void onClose(uv_handle_t* handle)
+// NOTE: We have different onCloseXxx() callbacks to avoid an ASAN warning by
+// ensuring that we call `delete xxx` with same type as `new xxx` before.
+static inline void onCloseUdp(uv_handle_t* handle)
 {
-	delete handle;
+	delete reinterpret_cast<uv_udp_t*>(handle);
+}
+
+static inline void onCloseTcp(uv_handle_t* handle)
+{
+	delete reinterpret_cast<uv_tcp_t*>(handle);
 }
 
 inline static void onFakeConnection(uv_stream_t* /*handle*/, int /*status*/)
@@ -161,30 +168,44 @@ namespace RTC
 			switch (transport)
 			{
 				case Transport::UDP:
+				{
 					uvHandle = reinterpret_cast<uv_handle_t*>(new uv_udp_t());
 					err      = uv_udp_init_ex(
             DepLibUV::GetLoop(), reinterpret_cast<uv_udp_t*>(uvHandle), UV_UDP_RECVMMSG);
+
 					break;
+				}
 
 				case Transport::TCP:
+				{
 					uvHandle = reinterpret_cast<uv_handle_t*>(new uv_tcp_t());
 					err      = uv_tcp_init(DepLibUV::GetLoop(), reinterpret_cast<uv_tcp_t*>(uvHandle));
+
 					break;
+				}
 			}
 
 			if (err != 0)
 			{
-				delete uvHandle;
-
 				switch (transport)
 				{
 					case Transport::UDP:
+					{
+						delete reinterpret_cast<uv_udp_t*>(uvHandle);
+
 						MS_THROW_ERROR("uv_udp_init_ex() failed: %s", uv_strerror(err));
+
 						break;
+					}
 
 					case Transport::TCP:
+					{
+						delete reinterpret_cast<uv_tcp_t*>(uvHandle);
+
 						MS_THROW_ERROR("uv_tcp_init() failed: %s", uv_strerror(err));
+
 						break;
+					}
 				}
 			}
 
@@ -259,7 +280,22 @@ namespace RTC
 				break;
 
 			// If it failed, close the handle and check the reason.
-			uv_close(reinterpret_cast<uv_handle_t*>(uvHandle), static_cast<uv_close_cb>(onClose));
+			switch (transport)
+			{
+				case Transport::UDP:
+				{
+					uv_close(reinterpret_cast<uv_handle_t*>(uvHandle), static_cast<uv_close_cb>(onCloseUdp));
+
+					break;
+				};
+
+				case Transport::TCP:
+				{
+					uv_close(reinterpret_cast<uv_handle_t*>(uvHandle), static_cast<uv_close_cb>(onCloseTcp));
+
+					break;
+				}
+			}
 
 			switch (err)
 			{
@@ -400,17 +436,25 @@ namespace RTC
 
 		if (err != 0)
 		{
-			delete uvHandle;
-
 			switch (transport)
 			{
 				case Transport::UDP:
+				{
+					delete reinterpret_cast<uv_udp_t*>(uvHandle);
+
 					MS_THROW_ERROR("uv_udp_init_ex() failed: %s", uv_strerror(err));
+
 					break;
+				}
 
 				case Transport::TCP:
+				{
+					delete reinterpret_cast<uv_tcp_t*>(uvHandle);
+
 					MS_THROW_ERROR("uv_tcp_init() failed: %s", uv_strerror(err));
+
 					break;
+				}
 			}
 		}
 
@@ -426,7 +470,7 @@ namespace RTC
 				if (err != 0)
 				{
 					// If it failed, close the handle and check the reason.
-					uv_close(reinterpret_cast<uv_handle_t*>(uvHandle), static_cast<uv_close_cb>(onClose));
+					uv_close(reinterpret_cast<uv_handle_t*>(uvHandle), static_cast<uv_close_cb>(onCloseUdp));
 
 					MS_THROW_ERROR(
 					  "uv_udp_bind() failed [transport:%s, ip:'%s', port:%" PRIu16 "]: %s",
@@ -449,7 +493,7 @@ namespace RTC
 				if (err != 0)
 				{
 					// If it failed, close the handle and check the reason.
-					uv_close(reinterpret_cast<uv_handle_t*>(uvHandle), static_cast<uv_close_cb>(onClose));
+					uv_close(reinterpret_cast<uv_handle_t*>(uvHandle), static_cast<uv_close_cb>(onCloseTcp));
 
 					MS_THROW_ERROR(
 					  "uv_tcp_bind() failed [transport:%s, ip:'%s', port:%" PRIu16 "]: %s",
@@ -469,7 +513,7 @@ namespace RTC
 				if (err != 0)
 				{
 					// If it failed, close the handle and check the reason.
-					uv_close(reinterpret_cast<uv_handle_t*>(uvHandle), static_cast<uv_close_cb>(onClose));
+					uv_close(reinterpret_cast<uv_handle_t*>(uvHandle), static_cast<uv_close_cb>(onCloseTcp));
 
 					MS_THROW_ERROR(
 					  "uv_listen() failed [transport:%s, ip:'%s', port:%" PRIu16 "]: %s",

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

@@ -36,17 +36,21 @@ namespace RTC
 			// Get the header.
 			auto* header = const_cast<Header*>(reinterpret_cast<const Header*>(data));
 
+			// If item type is 0, there is no need for length field (unless padding
+			// is needed).
+			if (len > 0 && header->type == SdesItem::Type::END)
+			{
+				return nullptr;
+			}
+
 			// data size must be >= header + length value.
-			if (len < HeaderSize || len < (1u * 2) + header->length)
+			if (len < HeaderSize || len < HeaderSize + header->length)
 			{
 				MS_WARN_TAG(rtcp, "not enough space for SDES item, discarded");
 
 				return nullptr;
 			}
 
-			if (header->type == SdesItem::Type::END)
-				return nullptr;
-
 			return new SdesItem(header);
 		}
 
@@ -57,7 +61,9 @@ namespace RTC
 			auto it = SdesItem::type2String.find(type);
 
 			if (it == SdesItem::type2String.end())
+			{
 				return Unknown;
+			}
 
 			return it->second;
 		}
@@ -123,19 +129,77 @@ namespace RTC
 
 			std::unique_ptr<SdesChunk> chunk(new SdesChunk(ssrc));
 
-			size_t offset = 4u /* ssrc */;
+			size_t offset{ 4u }; /* ssrc */
+			size_t chunkLength{ 4u };
 
 			while (len > offset)
 			{
-				SdesItem* item = SdesItem::Parse(data + offset, len - offset);
+				auto* item = SdesItem::Parse(data + offset, len - offset);
 
 				if (!item)
+				{
 					break;
+				}
 
 				chunk->AddItem(item);
+				chunkLength += item->GetSize();
 				offset += item->GetSize();
 			}
 
+			// Once all items have been parsed, there must be 1, 2, 3 or 4 null octets
+			// (this is mandatory). The first one (AKA item type 0) means "end of
+			// items", and the others maybe needed for padding the chunk to 4 bytes.
+
+			// First ensure that there is at least one null octet.
+			if (offset == len || (offset < len && Utils::Byte::Get1Byte(data, offset) != 0u))
+			{
+				MS_WARN_TAG(rtcp, "invalid SDES chunk (missing mandatory null octet), discarded");
+
+				return nullptr;
+			}
+
+			// So we have the mandatory null octet.
+			++chunkLength;
+			++offset;
+
+			// Then check that there are 0, 1, 2 or 3 (no more) null octets that pad
+			// the chunk to 4 bytes.
+			uint16_t neededAdditionalNullOctets =
+			  Utils::Byte::PadTo4Bytes(static_cast<uint16_t>(chunkLength)) -
+			  static_cast<uint16_t>(chunkLength);
+			uint16_t foundAdditionalNullOctets{ 0u };
+
+			for (uint16_t i{ 0u }; len > offset && i < neededAdditionalNullOctets; ++i)
+			{
+				if (Utils::Byte::Get1Byte(data, offset) != 0u)
+				{
+					MS_WARN_TAG(
+					  rtcp,
+					  "invalid SDES chunk (missing additional null octets [needed:%" PRIu16 ", found:%" PRIu16
+					  "]), discarded",
+					  neededAdditionalNullOctets,
+					  foundAdditionalNullOctets);
+
+					return nullptr;
+				}
+
+				++foundAdditionalNullOctets;
+				++chunkLength;
+				++offset;
+			}
+
+			if (foundAdditionalNullOctets != neededAdditionalNullOctets)
+			{
+				MS_WARN_TAG(
+				  rtcp,
+				  "invalid SDES chunk (missing additional null octets [needed:%" PRIu16 ", found:%" PRIu16
+				  "]), discarded",
+				  neededAdditionalNullOctets,
+				  foundAdditionalNullOctets);
+
+				return nullptr;
+			}
+
 			return chunk.release();
 		}
 
@@ -155,10 +219,15 @@ namespace RTC
 				offset += item->Serialize(buffer + offset);
 			}
 
+			// Add the mandatory null octet.
+			buffer[offset] = 0;
+
+			++offset;
+
 			// 32 bits padding.
 			const size_t padding = (-offset) & 3;
 
-			for (size_t i{ 0 }; i < padding; ++i)
+			for (size_t i{ 0u }; i < padding; ++i)
 			{
 				buffer[offset + i] = 0;
 			}
@@ -195,9 +264,9 @@ namespace RTC
 			size_t offset = Packet::CommonHeaderSize;
 			uint8_t count = header->count;
 
-			while ((count-- != 0u) && (len > offset))
+			while (count-- && (len > offset))
 			{
-				SdesChunk* chunk = SdesChunk::Parse(data + offset, len - offset);
+				auto* chunk = SdesChunk::Parse(data + offset, len - offset);
 
 				if (chunk != nullptr)
 				{
@@ -206,10 +275,17 @@ namespace RTC
 				}
 				else
 				{
-					return packet.release();
+					break;
 				}
 			}
 
+			if (packet->GetCount() != header->count)
+			{
+				MS_WARN_TAG(rtcp, "RTCP count value doesn't match found number of chunks, discarded");
+
+				return nullptr;
+			}
+
 			return packet.release();
 		}
 
@@ -223,7 +299,7 @@ namespace RTC
 			size_t length   = 0;
 			uint8_t* header = { nullptr };
 
-			for (size_t i = 0; i < this->GetCount(); i++)
+			for (size_t i{ 0u }; i < this->GetCount(); ++i)
 			{
 				// Create a new SDES packet header for each 31 chunks.
 				if (i % MaxChunksPerPacket == 0)

package/worker/src/handles/SignalsHandler.cpp

@@ -13,9 +13,9 @@ inline static void onSignal(uv_signal_t* handle, int signum)
 	static_cast<SignalsHandler*>(handle->data)->OnUvSignal(signum);
 }
 
-inline static void onClose(uv_handle_t* handle)
+inline static void onCloseSignal(uv_handle_t* handle)
 {
-	delete handle;
+	delete reinterpret_cast<uv_signal_t*>(handle);
 }
 
 /* Instance methods. */
@@ -44,7 +44,7 @@ void SignalsHandler::Close()
 
 	for (auto* uvHandle : this->uvHandles)
 	{
-		uv_close(reinterpret_cast<uv_handle_t*>(uvHandle), static_cast<uv_close_cb>(onClose));
+		uv_close(reinterpret_cast<uv_handle_t*>(uvHandle), static_cast<uv_close_cb>(onCloseSignal));
 	}
 }
 

package/worker/src/handles/TcpConnectionHandler.cpp

@@ -40,9 +40,16 @@ inline static void onWrite(uv_write_t* req, int status)
 	delete writeData;
 }
 
-inline static void onClose(uv_handle_t* handle)
+// NOTE: We have different onCloseXxx() callbacks to avoid an ASAN warning by
+// ensuring that we call `delete xxx` with same type as `new xxx` before.
+inline static void onCloseTcp(uv_handle_t* handle)
 {
-	delete handle;
+	delete reinterpret_cast<uv_tcp_t*>(handle);
+}
+
+inline static void onCloseShutdown(uv_handle_t* handle)
+{
+	delete reinterpret_cast<uv_shutdown_t*>(handle);
 }
 
 inline static void onShutdown(uv_shutdown_t* req, int /*status*/)
@@ -52,7 +59,7 @@ inline static void onShutdown(uv_shutdown_t* req, int /*status*/)
 	delete req;
 
 	// Now do close the handle.
-	uv_close(reinterpret_cast<uv_handle_t*>(handle), static_cast<uv_close_cb>(onClose));
+	uv_close(reinterpret_cast<uv_handle_t*>(handle), static_cast<uv_close_cb>(onCloseShutdown));
 }
 
 /* Instance methods. */
@@ -114,7 +121,7 @@ void TcpConnectionHandler::Close()
 	// Otherwise directly close the socket.
 	else
 	{
-		uv_close(reinterpret_cast<uv_handle_t*>(this->uvHandle), static_cast<uv_close_cb>(onClose));
+		uv_close(reinterpret_cast<uv_handle_t*>(this->uvHandle), static_cast<uv_close_cb>(onCloseTcp));
 	}
 }
 

package/worker/src/handles/TcpServerHandler.cpp

@@ -20,9 +20,9 @@ inline static void onConnection(uv_stream_t* handle, int status)
 		server->OnUvConnection(status);
 }
 
-inline static void onClose(uv_handle_t* handle)
+inline static void onCloseTcp(uv_handle_t* handle)
 {
-	delete handle;
+	delete reinterpret_cast<uv_tcp_t*>(handle);
 }
 
 /* Instance methods. */
@@ -43,7 +43,7 @@ TcpServerHandler::TcpServerHandler(uv_tcp_t* uvHandle) : uvHandle(uvHandle)
 
 	if (err != 0)
 	{
-		uv_close(reinterpret_cast<uv_handle_t*>(this->uvHandle), static_cast<uv_close_cb>(onClose));
+		uv_close(reinterpret_cast<uv_handle_t*>(this->uvHandle), static_cast<uv_close_cb>(onCloseTcp));
 
 		MS_THROW_ERROR("uv_listen() failed: %s", uv_strerror(err));
 	}
@@ -51,7 +51,7 @@ TcpServerHandler::TcpServerHandler(uv_tcp_t* uvHandle) : uvHandle(uvHandle)
 	// Set local address.
 	if (!SetLocalAddress())
 	{
-		uv_close(reinterpret_cast<uv_handle_t*>(this->uvHandle), static_cast<uv_close_cb>(onClose));
+		uv_close(reinterpret_cast<uv_handle_t*>(this->uvHandle), static_cast<uv_close_cb>(onCloseTcp));
 
 		MS_THROW_ERROR("error setting local IP and port");
 	}
@@ -84,7 +84,7 @@ void TcpServerHandler::Close()
 		delete connection;
 	}
 
-	uv_close(reinterpret_cast<uv_handle_t*>(this->uvHandle), static_cast<uv_close_cb>(onClose));
+	uv_close(reinterpret_cast<uv_handle_t*>(this->uvHandle), static_cast<uv_close_cb>(onCloseTcp));
 }
 
 void TcpServerHandler::Dump() const

package/worker/src/handles/Timer.cpp

@@ -13,9 +13,9 @@ inline static void onTimer(uv_timer_t* handle)
 	static_cast<Timer*>(handle->data)->OnUvTimer();
 }
 
-inline static void onClose(uv_handle_t* handle)
+inline static void onCloseTimer(uv_handle_t* handle)
 {
-	delete handle;
+	delete reinterpret_cast<uv_timer_t*>(handle);
 }
 
 /* Instance methods. */
@@ -59,7 +59,7 @@ void Timer::Close()
 
 	this->closed = true;
 
-	uv_close(reinterpret_cast<uv_handle_t*>(this->uvHandle), static_cast<uv_close_cb>(onClose));
+	uv_close(reinterpret_cast<uv_handle_t*>(this->uvHandle), static_cast<uv_close_cb>(onCloseTimer));
 }
 
 void Timer::Start(uint64_t timeout, uint64_t repeat)

package/worker/src/handles/UdpSocketHandler.cpp

@@ -45,9 +45,9 @@ inline static void onSend(uv_udp_send_t* req, int status)
 	delete sendData;
 }
 
-inline static void onClose(uv_handle_t* handle)
+inline static void onCloseUdp(uv_handle_t* handle)
 {
-	delete handle;
+	delete reinterpret_cast<uv_udp_t*>(handle);
 }
 
 /* Instance methods. */
@@ -66,7 +66,7 @@ UdpSocketHandler::UdpSocketHandler(uv_udp_t* uvHandle) : uvHandle(uvHandle)
 
 	if (err != 0)
 	{
-		uv_close(reinterpret_cast<uv_handle_t*>(this->uvHandle), static_cast<uv_close_cb>(onClose));
+		uv_close(reinterpret_cast<uv_handle_t*>(this->uvHandle), static_cast<uv_close_cb>(onCloseUdp));
 
 		MS_THROW_ERROR("uv_udp_recv_start() failed: %s", uv_strerror(err));
 	}
@@ -74,7 +74,7 @@ UdpSocketHandler::UdpSocketHandler(uv_udp_t* uvHandle) : uvHandle(uvHandle)
 	// Set local address.
 	if (!SetLocalAddress())
 	{
-		uv_close(reinterpret_cast<uv_handle_t*>(this->uvHandle), static_cast<uv_close_cb>(onClose));
+		uv_close(reinterpret_cast<uv_handle_t*>(this->uvHandle), static_cast<uv_close_cb>(onCloseUdp));
 
 		MS_THROW_ERROR("error setting local IP and port");
 	}
@@ -106,7 +106,7 @@ void UdpSocketHandler::Close()
 	if (err != 0)
 		MS_ABORT("uv_udp_recv_stop() failed: %s", uv_strerror(err));
 
-	uv_close(reinterpret_cast<uv_handle_t*>(this->uvHandle), static_cast<uv_close_cb>(onClose));
+	uv_close(reinterpret_cast<uv_handle_t*>(this->uvHandle), static_cast<uv_close_cb>(onCloseUdp));
 }
 
 void UdpSocketHandler::Dump() const

package/worker/src/handles/UnixStreamSocket.cpp

@@ -44,9 +44,16 @@ inline static void onWrite(uv_write_t* req, int status)
 	delete writeData;
 }
 
-inline static void onClose(uv_handle_t* handle)
+// NOTE: We have different onCloseXxx() callbacks to avoid an ASAN warning by
+// ensuring that we call `delete xxx` with same type as `new xxx` before.
+inline static void onClosePipe(uv_handle_t* handle)
 {
-	delete handle;
+	delete reinterpret_cast<uv_pipe_t*>(handle);
+}
+
+inline static void onCloseShutdown(uv_handle_t* handle)
+{
+	delete reinterpret_cast<uv_shutdown_t*>(handle);
 }
 
 inline static void onShutdown(uv_shutdown_t* req, int /*status*/)
@@ -56,7 +63,7 @@ inline static void onShutdown(uv_shutdown_t* req, int /*status*/)
 	delete req;
 
 	// Now do close the handle.
-	uv_close(reinterpret_cast<uv_handle_t*>(handle), static_cast<uv_close_cb>(onClose));
+	uv_close(reinterpret_cast<uv_handle_t*>(handle), static_cast<uv_close_cb>(onCloseShutdown));
 }
 
 /* Instance methods. */
@@ -85,7 +92,7 @@ UnixStreamSocket::UnixStreamSocket(int fd, size_t bufferSize, UnixStreamSocket::
 
 	if (err != 0)
 	{
-		uv_close(reinterpret_cast<uv_handle_t*>(this->uvHandle), static_cast<uv_close_cb>(onClose));
+		uv_close(reinterpret_cast<uv_handle_t*>(this->uvHandle), static_cast<uv_close_cb>(onClosePipe));
 
 		MS_THROW_ERROR_STD("uv_pipe_open() failed: %s", uv_strerror(err));
 	}
@@ -100,7 +107,7 @@ UnixStreamSocket::UnixStreamSocket(int fd, size_t bufferSize, UnixStreamSocket::
 
 		if (err != 0)
 		{
-			uv_close(reinterpret_cast<uv_handle_t*>(this->uvHandle), static_cast<uv_close_cb>(onClose));
+			uv_close(reinterpret_cast<uv_handle_t*>(this->uvHandle), static_cast<uv_close_cb>(onClosePipe));
 
 			MS_THROW_ERROR_STD("uv_read_start() failed: %s", uv_strerror(err));
 		}
@@ -157,7 +164,7 @@ void UnixStreamSocket::Close()
 	// Otherwise directly close the socket.
 	else
 	{
-		uv_close(reinterpret_cast<uv_handle_t*>(this->uvHandle), static_cast<uv_close_cb>(onClose));
+		uv_close(reinterpret_cast<uv_handle_t*>(this->uvHandle), static_cast<uv_close_cb>(onClosePipe));
 	}
 }
 

package/worker/test/src/RTC/RTCP/TestSdes.cpp

@@ -11,68 +11,378 @@ namespace TestSdes
 	// RTCP Sdes Packet.
 
 	// clang-format off
-	uint8_t buffer[] =
+	uint8_t buffer1[] =
 	{
 		0x81, 0xca, 0x00, 0x06, // Type: 202 (SDES), Count: 1, Length: 6
 		0x9f, 0x65, 0xe7, 0x42, // SSRC: 0x9f65e742
+		// Chunk 1
 		0x01, 0x10, 0x74, 0x37, // Item Type: 1 (CNAME), Length: 16, Value: t7mkYnCm46OcINy/
 		0x6d, 0x6b, 0x59, 0x6e,
 		0x43, 0x6d, 0x34, 0x36,
 		0x4f, 0x63, 0x49, 0x4e,
-		0x79, 0x2f, 0x00, 0x00
+		0x79, 0x2f, 0x00, 0x00  // 2 null octets
 	};
 	// clang-format on
 
-	uint8_t* chunkBuffer = buffer + Packet::CommonHeaderSize;
+	// First chunk (chunk 1).
+	uint32_t ssrc1{ 0x9f65e742 };
+	// First item (item 1).
+	SdesItem::Type item1Type{ SdesItem::Type::CNAME };
+	std::string item1Value{ "t7mkYnCm46OcINy/" };
+	size_t item1Length{ 16u };
 
-	// SDES values.
-	uint32_t ssrc{ 0x9f65e742 };
-	SdesItem::Type type{ SdesItem::Type::CNAME };
-	std::string value{ "t7mkYnCm46OcINy/" };
-	size_t length = 16;
-
-	void verify(SdesChunk* chunk)
+	// clang-format off
+	uint8_t buffer2[] =
 	{
-		REQUIRE(chunk->GetSsrc() == ssrc);
+		0xa2, 0xca, 0x00, 0x0d, // Padding, Type: 202 (SDES), Count: 2, Length: 13
+		// Chunk 2
+		0x00, 0x00, 0x04, 0xd2, // SSRC: 1234
+		0x01, 0x06, 0x71, 0x77, // Item Type: 1 (CNAME), Length: 6, Text: "qwerty"
+		0x65, 0x72, 0x74, 0x79,
+		0x06, 0x06, 0x69, 0xc3, // Item Type: 6 (TOOL), Length: 6, Text: "iñaki"
+		0xb1, 0x61, 0x6b, 0x69,
+		0x00, 0x00, 0x00, 0x00, // 4 null octets
+		// Chunk 3
+		0x00, 0x00, 0x16, 0x2e, // SSRC: 5678
+		0x05, 0x11, 0x73, 0x6f, // Item Type: 5 (LOC), Length: 17, Text: "somewhere œæ€"
+		0x6d, 0x65, 0x77, 0x68,
+		0x65, 0x72, 0x65, 0x20,
+		0xc5, 0x93, 0xc3, 0xa6,
+		0xe2, 0x82, 0xac, 0x00,  // 1 null octet
+		0x00, 0x00, 0x00, 0x00  // Pading (4 bytes)
+	};
+	// clang-format on
 
-		SdesItem* item = *(chunk->Begin());
+	// First chunk (chunk 2).
+	uint32_t ssrc2{ 1234 };
+	// First item (item 2).
+	SdesItem::Type item2Type{ SdesItem::Type::CNAME };
+	std::string item2Value{ "qwerty" };
+	size_t item2Length{ 6u };
+	// First item (item 3).
+	SdesItem::Type item3Type{ SdesItem::Type::TOOL };
+	std::string item3Value{ "iñaki" };
+	size_t item3Length{ 6u };
+
+	// Second chunk (chunk 3).
+	uint32_t ssrc3{ 5678 };
+	// First item (item 4).
+	SdesItem::Type item4Type{ SdesItem::Type::LOC };
+	std::string item4Value{ "somewhere œæ€" };
+	size_t item4Length{ 17u };
 
-		REQUIRE(item->GetType() == type);
-		REQUIRE(item->GetLength() == length);
-		REQUIRE(std::string(item->GetValue(), length) == value);
-	}
+	// clang-format off
+	uint8_t buffer3[] =
+	{
+		0x81, 0xca, 0x00, 0x03, // Type: 202 (SDES), Count: 1, Length: 3
+		// Chunk
+		0x11, 0x22, 0x33, 0x44, // SSRC: 0x11223344
+		0x05, 0x02, 0x61, 0x62, // Item Type: 5 (LOC), Length: 2, Text: "ab"
+		0x00, 0x00, 0x00, 0x00  // 4 null octets
+	};
+	// clang-format on
+
+	// First chunk (chunk 4).
+	uint32_t ssrc4{ 0x11223344 };
+	// First item (item 5).
+	SdesItem::Type item5Type{ SdesItem::Type::LOC };
+	std::string item5Value{ "ab" };
+	size_t item5Length{ 2u };
 } // namespace TestSdes
 
 using namespace TestSdes;
 
 SCENARIO("RTCP SDES parsing", "[parser][rtcp][sdes]")
 {
-	SECTION("parse packet")
+	SECTION("parse packet 1")
 	{
-		SdesPacket* packet = SdesPacket::Parse(buffer, sizeof(buffer));
-		SdesChunk* chunk   = *(packet->Begin());
-
-		auto* header = reinterpret_cast<RTC::RTCP::Packet::CommonHeader*>(buffer);
+		SdesPacket* packet = SdesPacket::Parse(buffer1, sizeof(buffer1));
+		auto* header       = reinterpret_cast<RTC::RTCP::Packet::CommonHeader*>(buffer1);
 
+		REQUIRE(packet);
 		REQUIRE(ntohs(header->length) == 6);
-		REQUIRE(chunk);
+		REQUIRE(packet->GetSize() == 28);
+		REQUIRE(packet->GetCount() == 1);
+
+		size_t chunkIdx{ 0u };
+
+		for (auto it = packet->Begin(); it != packet->End(); ++it, ++chunkIdx)
+		{
+			auto* chunk = *it;
+
+			switch (chunkIdx)
+			{
+				/* First chunk (chunk 1). */
+				case 0:
+				{
+					// Chunk size must be 24 bytes (including 4 null octets).
+					REQUIRE(chunk->GetSize() == 24);
+					REQUIRE(chunk->GetSsrc() == ssrc1);
+
+					size_t itemIdx{ 0u };
+
+					for (auto it2 = chunk->Begin(); it2 != chunk->End(); ++it2, ++itemIdx)
+					{
+						auto* item = *it2;
+
+						switch (itemIdx)
+						{
+							/* First item (item 1). */
+							case 0:
+							{
+								REQUIRE(item->GetType() == item1Type);
+								REQUIRE(item->GetLength() == item1Length);
+								REQUIRE(std::string(item->GetValue(), item1Length) == item1Value);
+
+								break;
+							}
+						}
+					}
+
+					// There is 1 item.
+					REQUIRE(itemIdx == 1);
+
+					break;
+				}
+			}
+		}
 
-		verify(chunk);
+		// There is 1 chunk.
+		REQUIRE(chunkIdx == 1);
 
 		SECTION("serialize SdesChunk instance")
 		{
-			uint8_t serialized[sizeof(buffer) - Packet::CommonHeaderSize] = { 0 };
+			auto it               = packet->Begin();
+			auto* chunk1          = *it;
+			uint8_t* chunk1Buffer = buffer1 + Packet::CommonHeaderSize;
 
-			chunk->Serialize(serialized);
+			// NOTE: Length of first chunk (including null octets) is 24.
+			uint8_t serialized1[24] = { 0 };
 
-			SECTION("compare serialized SdesChunk with original buffer")
+			chunk1->Serialize(serialized1);
+
+			REQUIRE(std::memcmp(chunk1Buffer, serialized1, 24) == 0);
+		}
+
+		delete packet;
+	}
+
+	SECTION("parse packet 2")
+	{
+		SdesPacket* packet = SdesPacket::Parse(buffer2, sizeof(buffer2));
+		auto* header       = reinterpret_cast<RTC::RTCP::Packet::CommonHeader*>(buffer2);
+
+		REQUIRE(packet);
+		REQUIRE(ntohs(header->length) == 13);
+		// Despite total buffer size is 56 bytes, our GetSize() method doesn't not
+		// consider RTCP padding (4 bytes in this case).
+		REQUIRE(packet->GetSize() == 52);
+		REQUIRE(packet->GetCount() == 2);
+
+		size_t chunkIdx{ 0u };
+
+		for (auto it = packet->Begin(); it != packet->End(); ++it, ++chunkIdx)
+		{
+			auto* chunk = *it;
+
+			switch (chunkIdx)
 			{
-				REQUIRE(std::memcmp(chunkBuffer, serialized, sizeof(buffer) - Packet::CommonHeaderSize) == 0);
+				/* First chunk (chunk 2). */
+				case 0:
+				{
+					// Chunk size must be 24 bytes (including 4 null octets).
+					REQUIRE(chunk->GetSize() == 24);
+					REQUIRE(chunk->GetSsrc() == ssrc2);
+
+					size_t itemIdx{ 0u };
+
+					for (auto it2 = chunk->Begin(); it2 != chunk->End(); ++it2, ++itemIdx)
+					{
+						auto* item = *it2;
+
+						switch (itemIdx)
+						{
+							/* First item (item 2). */
+							case 0:
+							{
+								REQUIRE(item->GetType() == item2Type);
+								REQUIRE(item->GetLength() == item2Length);
+								REQUIRE(std::string(item->GetValue(), item2Length) == item2Value);
+
+								break;
+							}
+
+							/* Second item (item 3). */
+							case 1:
+							{
+								REQUIRE(item->GetType() == item3Type);
+								REQUIRE(item->GetLength() == item3Length);
+								REQUIRE(std::string(item->GetValue(), item3Length) == item3Value);
+
+								break;
+							}
+						}
+					}
+
+					// There are 2 items.
+					REQUIRE(itemIdx == 2);
+
+					break;
+				}
+
+				/* Second chunk (chunk 3). */
+				case 1:
+				{
+					// Chunk size must be 24 bytes (including 1 null octet).
+					REQUIRE(chunk->GetSize() == 24);
+					REQUIRE(chunk->GetSsrc() == ssrc3);
+
+					size_t itemIdx{ 0u };
+
+					for (auto it2 = chunk->Begin(); it2 != chunk->End(); ++it2, ++itemIdx)
+					{
+						auto* item = *it2;
+
+						switch (itemIdx)
+						{
+							/* First item (item 4). */
+							case 0:
+							{
+								REQUIRE(item->GetType() == item4Type);
+								REQUIRE(item->GetLength() == item4Length);
+								REQUIRE(std::string(item->GetValue(), item4Length) == item4Value);
+
+								break;
+							}
+						}
+					}
+
+					// There is 1 item.
+					REQUIRE(itemIdx == 1);
+
+					break;
+				}
 			}
 		}
+
+		// There are 2 chunks.
+		REQUIRE(chunkIdx == 2);
+
+		SECTION("serialize SdesChunk instances")
+		{
+			auto it               = packet->Begin();
+			auto* chunk1          = *it;
+			uint8_t* chunk1Buffer = buffer2 + Packet::CommonHeaderSize;
+
+			// NOTE: Length of first chunk (including null octets) is 24.
+			uint8_t serialized1[24] = { 0 };
+
+			chunk1->Serialize(serialized1);
+
+			REQUIRE(std::memcmp(chunk1Buffer, serialized1, 24) == 0);
+
+			auto* chunk2          = *(++it);
+			uint8_t* chunk2Buffer = buffer2 + Packet::CommonHeaderSize + 24;
+
+			// NOTE: Length of second chunk (including null octets) is 24.
+			uint8_t serialized2[24] = { 0 };
+
+			chunk2->Serialize(serialized2);
+
+			REQUIRE(std::memcmp(chunk2Buffer, serialized2, 24) == 0);
+		}
+
+		delete packet;
+	}
+
+	SECTION("parse packet 3")
+	{
+		SdesPacket* packet = SdesPacket::Parse(buffer3, sizeof(buffer3));
+		auto* header       = reinterpret_cast<RTC::RTCP::Packet::CommonHeader*>(buffer3);
+
+		REQUIRE(packet);
+		REQUIRE(ntohs(header->length) == 3);
+		REQUIRE(packet->GetSize() == 16);
+		REQUIRE(packet->GetCount() == 1);
+
+		size_t chunkIdx{ 0u };
+
+		for (auto it = packet->Begin(); it != packet->End(); ++it, ++chunkIdx)
+		{
+			auto* chunk = *it;
+
+			switch (chunkIdx)
+			{
+				/* First chunk (chunk 4). */
+				case 0:
+				{
+					REQUIRE(chunk->GetSize() == 12);
+					REQUIRE(chunk->GetSsrc() == ssrc4);
+
+					size_t itemIdx{ 0u };
+
+					for (auto it2 = chunk->Begin(); it2 != chunk->End(); ++it2, ++itemIdx)
+					{
+						auto* item = *it2;
+
+						switch (itemIdx)
+						{
+							/* First item (item 5). */
+							case 0:
+							{
+								REQUIRE(item->GetType() == item5Type);
+								REQUIRE(item->GetLength() == item5Length);
+								REQUIRE(std::string(item->GetValue(), item5Length) == item5Value);
+
+								break;
+							}
+						}
+					}
+
+					// There is 1 item.
+					REQUIRE(itemIdx == 1);
+
+					break;
+				}
+			}
+		}
+
+		// There is 1 chunk.
+		REQUIRE(chunkIdx == 1);
+
+		SECTION("serialize SdesChunk instance")
+		{
+			auto it               = packet->Begin();
+			auto* chunk1          = *it;
+			uint8_t* chunk1Buffer = buffer3 + Packet::CommonHeaderSize;
+
+			// NOTE: Length of first chunk (including null octets) is 12.
+			uint8_t serialized1[12] = { 0 };
+
+			chunk1->Serialize(serialized1);
+
+			REQUIRE(std::memcmp(chunk1Buffer, serialized1, 12) == 0);
+		}
+
 		delete packet;
 	}
 
+	SECTION("parsing a packet with missing null octects fails")
+	{
+		// clang-format off
+		uint8_t buffer[] =
+		{
+			0x81, 0xca, 0x00, 0x02, // Type: 202 (SDES), Count: 1, Length: 2
+			// Chunk
+			0x11, 0x22, 0x33, 0x44, // SSRC: 0x11223344
+			0x08, 0x02, 0x61, 0x62  // Item Type: 8 (PRIV), Length: 2, Text: "ab"
+		};
+
+		SdesPacket* packet = SdesPacket::Parse(buffer, sizeof(buffer));
+
+		REQUIRE(!packet);
+	}
+
 	SECTION("create SDES packet with more than 31 chunks")
 	{
 		const size_t count = 33;
@@ -82,23 +392,24 @@ SCENARIO("RTCP SDES parsing", "[parser][rtcp][sdes]")
 		for (auto i = 1; i <= count; i++)
 		{
 			// Create chunk and add to packet.
-			SdesChunk* chunk = new SdesChunk(i /*ssrc*/);
+			SdesChunk* chunk1 = new SdesChunk(i /*ssrc*/);
 
-			auto* item = new RTC::RTCP::SdesItem(SdesItem::Type::CNAME, value.size(), value.c_str());
+			auto* item1 =
+			  new RTC::RTCP::SdesItem(SdesItem::Type::CNAME, item1Value.size(), item1Value.c_str());
 
-			chunk->AddItem(item);
+			chunk1->AddItem(item1);
 
-			packet.AddChunk(chunk);
+			packet.AddChunk(chunk1);
 		}
 
 		REQUIRE(packet.GetCount() == count);
 
-		uint8_t buffer[1500] = { 0 };
+		uint8_t buffer1[1500] = { 0 };
 
 		// Serialization must contain 2 RR packets since report count exceeds 31.
-		packet.Serialize(buffer);
+		packet.Serialize(buffer1);
 
-		auto* packet2 = static_cast<SdesPacket*>(Packet::Parse(buffer, sizeof(buffer)));
+		auto* packet2 = static_cast<SdesPacket*>(Packet::Parse(buffer1, sizeof(buffer1)));
 
 		REQUIRE(packet2 != nullptr);
 		REQUIRE(packet2->GetCount() == 31);
@@ -114,8 +425,8 @@ SCENARIO("RTCP SDES parsing", "[parser][rtcp][sdes]")
 			auto* item = *(chunk->Begin());
 
 			REQUIRE(item->GetType() == SdesItem::Type::CNAME);
-			REQUIRE(item->GetSize() == 2 + value.size());
-			REQUIRE(std::string(item->GetValue()) == value);
+			REQUIRE(item->GetSize() == 2 + item1Value.size());
+			REQUIRE(std::string(item->GetValue()) == item1Value);
 		}
 
 		SdesPacket* packet3 = static_cast<SdesPacket*>(packet2->GetNext());
@@ -134,8 +445,8 @@ SCENARIO("RTCP SDES parsing", "[parser][rtcp][sdes]")
 			auto* item = *(chunk->Begin());
 
 			REQUIRE(item->GetType() == SdesItem::Type::CNAME);
-			REQUIRE(item->GetSize() == 2 + value.size());
-			REQUIRE(std::string(item->GetValue()) == value);
+			REQUIRE(item->GetSize() == 2 + item1Value.size());
+			REQUIRE(std::string(item->GetValue()) == item1Value);
 		}
 
 		delete packet2;
@@ -144,13 +455,19 @@ SCENARIO("RTCP SDES parsing", "[parser][rtcp][sdes]")
 
 	SECTION("create SdesChunk")
 	{
-		auto* item = new SdesItem(type, length, value.c_str());
+		auto* item = new SdesItem(item1Type, item1Length, item1Value.c_str());
 
 		// Create sdes chunk.
-		SdesChunk chunk(ssrc);
+		SdesChunk chunk(ssrc1);
 
 		chunk.AddItem(item);
 
-		verify(&chunk);
+		REQUIRE(chunk.GetSsrc() == ssrc1);
+
+		SdesItem* item1 = *(chunk.Begin());
+
+		REQUIRE(item1->GetType() == item1Type);
+		REQUIRE(item1->GetLength() == item1Length);
+		REQUIRE(std::string(item1->GetValue(), item1Length) == item1Value);
 	}
 }

package/worker/test/src/tests.cpp

@@ -40,6 +40,10 @@ int main(int argc, char* argv[])
 	{
 		Settings::configuration.logTags.rtp = true;
 	}
+	if (std::getenv("MS_TEST_LOG_TAG_RTCP"))
+	{
+		Settings::configuration.logTags.rtcp = true;
+	}
 
 	// Initialize static stuff.
 	DepLibUV::ClassInit();