mediasoup 3.24.0 → 3.24.2

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ### NEXT
 
+### 3.24.2
+
+- Worker: Verify `DataConsumer` subchannels before cloning the message ([PR #1880](https://github.com/versatica/mediasoup/pull/1880)).
+
+### 3.24.1
+
+- Worker: Don't check `ignoredSubchannel` in piped `DataConsumers` ([PR #1879](https://github.com/versatica/mediasoup/pull/1879)).
+
 ### 3.24.0
 
 - `DataProducer.send()`: Add `ignoredSubchannel` optional argument ([PR #1877](https://github.com/versatica/mediasoup/pull/1877)).

package/node/lib/test/test-PipeTransport.js

@@ -967,8 +967,8 @@ test('transport.consumeData() for a pipe DataProducer succeeds with subchannels'
     /* ppid */ undefined, 
     /* subchannels */ [125], 
     /* requiredSubchannel */ 666);
-    // The `pipeDataConsumer` is subscribed to subchannel 666 so it must not
-    // allow the message to pass through.
+    // The final `directDataConsumer` is subscribed to subchannel 666 so it must
+    // not receive the message.
     directDataProducer.send('hello5', 
     /* ppid */ undefined, 
     /* subchannels */ [123], 
@@ -979,7 +979,7 @@ test('transport.consumeData() for a pipe DataProducer succeeds with subchannels'
     directDataProducer.send('hello6', 
     /* ppid */ undefined, 
     /* subchannels */ undefined, 
-    /* requiredSubchannel */ undefined, 
+    /* requiredSubchannel */ 123, 
     /* ignoredSubchannel */ 777);
     // Send a message without subchannels so it's guaranteed that it will reach
     // the final `directDataConsumer`. And wait for reception of this message so
@@ -997,6 +997,63 @@ test('transport.consumeData() for a pipe DataProducer succeeds with subchannels'
     });
     expect(receivedMessages).toStrictEqual(['hello1', 'hello2', 'bye']);
 }, 2000);
+test('transport.consumeData() for a pipe DataProducer succeeds with ignoredSubchannel', async () => {
+    const directTransport1 = await ctx.router1.createDirectTransport();
+    const directDataProducer = await directTransport1.produceData({
+        label: 'foo',
+        protocol: 'bar',
+    });
+    const { pipeDataConsumer } = await ctx.router1.pipeToRouter({
+        dataProducerId: directDataProducer.id,
+        router: ctx.router2,
+    });
+    const directTransport2 = await ctx.router2.createDirectTransport();
+    const directDataConsumer1 = await directTransport2.consumeData({
+        dataProducerId: directDataProducer.id,
+        subchannels: [111],
+    });
+    const directDataConsumer2 = await directTransport2.consumeData({
+        dataProducerId: directDataProducer.id,
+        subchannels: [222],
+    });
+    // A pipe DataConsumer must be subscribed to the union of the subchannels of
+    // all the DataConsumers behind it.
+    await pipeDataConsumer.setSubchannels([111, 222]);
+    const receivedMessages1 = [];
+    const receivedMessages2 = [];
+    // Resolved once both final DataConsumers have received the last sent message.
+    const allReceived = Promise.all([
+        [directDataConsumer1, receivedMessages1],
+        [directDataConsumer2, receivedMessages2],
+    ].map(([dataConsumer, receivedMessages]) => new Promise(resolve => {
+        dataConsumer.on('message', message => {
+            const receivedMessage = message.toString('utf8');
+            receivedMessages.push(receivedMessage);
+            // Resolve once the last sent message is received.
+            if (receivedMessage === 'bye') {
+                resolve();
+            }
+        });
+    })));
+    // The `pipeDataConsumer` is subscribed to subchannel 111, but being a pipe
+    // DataConsumer it must not apply `ignoredSubchannel` itself. Otherwise it
+    // would drop the message for every DataConsumer behind it rather than just
+    // for `directDataConsumer1`. `ignoredSubchannel` travels within the message
+    // and is applied by the final DataConsumers, so `directDataConsumer2` must
+    // still receive it.
+    directDataProducer.send('hello1', 
+    /* ppid */ undefined, 
+    /* subchannels */ undefined, 
+    /* requiredSubchannel */ undefined, 
+    /* ignoredSubchannel */ 111);
+    // Send a message without subchannels so it's guaranteed that it will reach
+    // both final DataConsumers. And wait for reception of this message so at
+    // this time we know whether the previous one reached them.
+    directDataProducer.send('bye');
+    await allReceived;
+    expect(receivedMessages1).toStrictEqual(['bye']);
+    expect(receivedMessages2).toStrictEqual(['hello1', 'bye']);
+}, 2000);
 test('dataProducer.close() is transmitted to pipe DataConsumer', async () => {
     const { pipeDataProducer } = await ctx.router1.pipeToRouter({
         dataProducerId: ctx.dataProducer.id,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "mediasoup",
-	"version": "3.24.0",
+	"version": "3.24.2",
 	"description": "Cutting Edge WebRTC Video Conferencing",
 	"contributors": [
 		"Iñaki Baz Castillo <ibc@aliax.net> (https://inakibaz.me)",
@@ -121,22 +121,22 @@
 		"@types/debug": "^4.1.13",
 		"@types/ini": "^4.1.1",
 		"@types/jest": "^30.0.0",
-		"@types/node": "^26.1.2",
-		"eslint": "^10.8.0",
+		"@types/node": "^26.2.0",
+		"eslint": "^10.8.1",
 		"eslint-config-prettier": "^10.1.8",
 		"eslint-plugin-jest": "^29.16.0",
 		"eslint-plugin-prettier": "^5.5.6",
 		"globals": "^17.9.0",
 		"ini": "^7.0.0",
 		"jest": "^30.4.2",
-		"knip": "^6.31.0",
-		"marked": "^18.0.7",
+		"knip": "^6.32.0",
+		"marked": "^18.0.9",
 		"open-cli": "^9.0.0",
 		"pick-port": "^2.2.1",
 		"prettier": "^3.9.6",
 		"ts-jest": "^29.4.12",
 		"typescript": "^6.0.3",
-		"typescript-eslint": "^8.65.0",
+		"typescript-eslint": "^8.66.0",
 		"werift-sctp": "^0.0.11"
 	}
 }

package/worker/include/RTC/DataConsumer.hpp

@@ -93,6 +93,18 @@ namespace RTC
 		void SctpBufferedAmountLow(uint32_t bufferedAmount) const;
 		void SctpSendBufferFull() const;
 		void DataProducerClosed();
+		/**
+		 * Verifies if given subchannels would allow a message to be delivered to
+		 * the DataConsumer endpoint or not.
+		 *
+		 * @remarks
+		 * - This method must be called before invoking `SendMessage()` if subchannels
+		 *   are given to `SendMessage()`.
+		 */
+		bool VerifySubchannels(
+		  const std::vector<uint16_t>& subchannels,
+		  std::optional<uint16_t> requiredSubchannel,
+		  std::optional<uint16_t> ignoredSubchannel) const;
 		bool SendMessage(
 		  RTC::SCTP::Message message,
 		  std::vector<uint16_t>& subchannels,

package/worker/scripts/package-lock.json

@@ -21,9 +21,9 @@
 			}
 		},
 		"node_modules/brace-expansion": {
-			"version": "5.0.8",
-			"resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.8.tgz",
-			"integrity": "sha512-JZyDyq3D4AUifKTPOB7DELf6XsB3WdPuNxCtob1vFXPsSXhdAiHBWJ/tJ8HAc9aH84BK+5JFZLNkJKx3G9kzQg==",
+			"version": "5.0.9",
+			"resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.9.tgz",
+			"integrity": "sha512-ScQ4IuvIEF1TMlP7Zt+vjJ//9zlPb2SDcxWxM3bk8s6t6GGdJ7KO1dCcTidOPJKePW30LE/2cT7wCyPho9/Wxg==",
 			"license": "MIT",
 			"dependencies": {
 				"balanced-match": "^4.0.2"
@@ -105,9 +105,9 @@
 			"integrity": "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA=="
 		},
 		"brace-expansion": {
-			"version": "5.0.8",
-			"resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.8.tgz",
-			"integrity": "sha512-JZyDyq3D4AUifKTPOB7DELf6XsB3WdPuNxCtob1vFXPsSXhdAiHBWJ/tJ8HAc9aH84BK+5JFZLNkJKx3G9kzQg==",
+			"version": "5.0.9",
+			"resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.9.tgz",
+			"integrity": "sha512-ScQ4IuvIEF1TMlP7Zt+vjJ//9zlPb2SDcxWxM3bk8s6t6GGdJ7KO1dCcTidOPJKePW30LE/2cT7wCyPho9/Wxg==",
 			"requires": {
 				"balanced-match": "^4.0.2"
 			}

package/worker/src/RTC/DataConsumer.cpp

@@ -482,96 +482,93 @@ namespace RTC
 		this->listener->OnDataConsumerDataProducerClosed(this);
 	}
 
-	bool DataConsumer::SendMessage(
-	  RTC::SCTP::Message message,
-	  std::vector<uint16_t>& subchannels,
+	bool DataConsumer::VerifySubchannels(
+	  const std::vector<uint16_t>& subchannels,
 	  std::optional<uint16_t> requiredSubchannel,
-	  std::optional<uint16_t> ignoredSubchannel,
-	  const onQueuedCallback* cb)
+	  std::optional<uint16_t> ignoredSubchannel) const
 	{
 		MS_TRACE();
 
-		if (!IsActive())
+		// Only verify subchannels if this is not a piped DataConsumer or if this
+		// is a piped DataConsumer and it's subscribed to at least one subchannel.
+		const bool verifySubchannels = !this->pipe || !this->subchannels.empty();
+
+		if (!verifySubchannels)
 		{
-			if (cb)
-			{
-				(*cb)(false, false);
-				delete cb;
-			}
+			return true;
+		}
 
+		// If a required subchannel is given, verify that this data consumer is
+		// subscribed to it.
+		if (requiredSubchannel.has_value() && !this->subchannels.contains(requiredSubchannel.value()))
+		{
 			return false;
 		}
 
-		// Only verify subchannels if this is not a piped DataConsumer or if this is
-		// a piped DataConsumer and it's subscribed to at least one subchannel.
-		const bool verifySubchannels = !this->pipe || !this->subchannels.empty();
+		// If an ignored subchannel is given, verify that this data consumer is
+		// not subscribed to it, otherwise don't send this message to it.
+		// NOTE: We don't check this in piped DataConsumers on purpose. Otherwise
+		// a message generated by peer X and forwarded to all peers in another
+		// host wouldn't pass this filter in the local PipeTransport.
+		if (!this->pipe && ignoredSubchannel.has_value() && this->subchannels.contains(ignoredSubchannel.value()))
+		{
+			return false;
+		}
 
-		if (verifySubchannels)
+		// If subchannels are given, verify that this data consumer is subscribed
+		// to at least one of them.
+		if (!subchannels.empty())
 		{
-			// If a required subchannel is given, verify that this data consumer is
-			// subscribed to it.
-			if (requiredSubchannel.has_value() && !this->subchannels.contains(requiredSubchannel.value()))
+			bool subchannelMatched{ false };
+
+			for (const auto subchannel : subchannels)
 			{
-				if (cb)
+				if (this->subchannels.contains(subchannel))
 				{
-					(*cb)(false, false);
-					delete cb;
-				}
+					subchannelMatched = true;
 
-				return false;
+					break;
+				}
 			}
 
-			// If an ignored subchannel is given, verify that this data consumer is not
-			// subscribed to it, otherwise don't send this message to it.
-			if (ignoredSubchannel.has_value() && this->subchannels.contains(ignoredSubchannel.value()))
+			if (!subchannelMatched)
 			{
-				if (cb)
-				{
-					(*cb)(false, false);
-					delete cb;
-				}
-
 				return false;
 			}
+		}
 
-			// If subchannels are given, verify that this data consumer is subscribed
-			// to at least one of them.
-			if (!subchannels.empty())
-			{
-				bool subchannelMatched{ false };
-
-				for (const auto subchannel : subchannels)
-				{
-					if (this->subchannels.contains(subchannel))
-					{
-						subchannelMatched = true;
-
-						break;
-					}
-				}
+		return true;
+	}
 
-				if (!subchannelMatched)
-				{
-					if (cb)
-					{
-						(*cb)(false, false);
-						delete cb;
-					}
+	bool DataConsumer::SendMessage(
+	  RTC::SCTP::Message message,
+	  std::vector<uint16_t>& subchannels,
+	  std::optional<uint16_t> requiredSubchannel,
+	  std::optional<uint16_t> ignoredSubchannel,
+	  const onQueuedCallback* cb)
+	{
+		MS_TRACE();
 
-					return false;
-				}
+		if (!IsActive())
+		{
+			if (cb)
+			{
+				(*cb)(false, false);
+				delete cb;
 			}
+
+			return false;
 		}
 
-		// If this is a piped DataConsumer, encode given subchannels and required
-		// subchannel at the beginning of the message payload so the receiving
-		// PipeTransport can decode them and apply them to its own DataConsumers.
+		// If this is a piped DataConsumer, encode given subchannels at the beginning
+		// of the message payload so the receiving PipeTransport can decode them and
+		// apply them to its own DataConsumers.
 		if (this->pipe)
 		{
-			// If subchannels were verified, encode just those this DataConsumer is
-			// subscribed to. Otherwise the receiving Router would deliver the message to
+			// Encode just those subchannels this DataConsumer is subscribed to.
+			// Otherwise the receiving Router would deliver the message to
 			// DataConsumers subscribed to subchannels that this pipe does not carry.
-			const bool reduceSubchannels = verifySubchannels && !subchannels.empty();
+			const bool reduceSubchannels = !this->subchannels.empty();
 
 			std::vector<uint16_t> reducedSubchannels;
 

package/worker/src/RTC/Router.cpp

@@ -917,44 +917,57 @@ namespace RTC
 
 		auto& dataConsumers = this->mapDataProducerDataConsumers.at(dataProducer);
 
-		if (!dataConsumers.empty())
+		const auto getStreamId = [](const RTC::DataConsumer* dataConsumer) -> uint16_t
 		{
-			const auto numDataConsumers = dataConsumers.size();
+			return dataConsumer->GetType() == DataConsumer::Type::SCTP
+			         ? dataConsumer->GetSctpStreamParameters().streamId
+			         : 0;
+		};
 
-			for (auto* dataConsumer : dataConsumers)
+		// NOTE: We don't send the message to a matching DataConsumer right away.
+		// Instead we hold it as pending until we know whether there is another
+		// matching DataConsumer after it. This way just the last matching one needs
+		// no message clone since it can take ownership of the original message.
+		RTC::DataConsumer* pendingDataConsumer{ nullptr };
+
+		for (auto* dataConsumer : dataConsumers)
+		{
+			// Verify subchannels first to avoid cloning the message needlessly.
+			if (!dataConsumer->IsActive() || !dataConsumer->VerifySubchannels(subchannels, requiredSubchannel, ignoredSubchannel))
 			{
-				const uint16_t streamId =
-				  (dataConsumer->GetType() == DataConsumer::Type::SCTP
-				     ? dataConsumer->GetSctpStreamParameters().streamId
-				     : 0);
+				continue;
+			}
 
-				if (numDataConsumers == 1)
-				{
-					// We must update the message`s `streamId` for each destination
-					// DataConsumer.
-					// NOTE: clang-tidy doesn't understand that we are only doing this
-					// once in the original `message`.
-					// NOLINTNEXTLINE(clang-analyzer-cplusplus.Move, bugprone-use-after-move, hicpp-invalid-access-moved)
-					message.SetStreamId(streamId);
-
-					dataConsumer->SendMessage(
-					  std::move(message), subchannels, requiredSubchannel, ignoredSubchannel);
-				}
-				// NOTE: Here we are cloning the message before passing it to each
-				// DataConsumer because each DataConsumer will pass std::move(message)
-				// internally to its SCTP association.
-				else
-				{
-					auto clonedMessage = message.Clone();
+			// There is a matching DataConsumer after the pending one, so the pending
+			// one must be given a clone of the message.
+			// NOTE: Here we are cloning the message before passing it to the
+			// DataConsumer because each DataConsumer will pass std::move(message)
+			// internally to its SCTP association.
+			if (pendingDataConsumer)
+			{
+				auto clonedMessage = message.Clone();
 
-					// We must update the message`s `streamId` for each destination
-					// DataConsumer.
-					clonedMessage.SetStreamId(streamId);
+				// We must update the message`s `streamId` for each destination
+				// DataConsumer.
+				clonedMessage.SetStreamId(getStreamId(pendingDataConsumer));
 
-					dataConsumer->SendMessage(
-					  std::move(clonedMessage), subchannels, requiredSubchannel, ignoredSubchannel);
-				}
+				pendingDataConsumer->SendMessage(
+				  std::move(clonedMessage), subchannels, requiredSubchannel, ignoredSubchannel);
 			}
+
+			pendingDataConsumer = dataConsumer;
+		}
+
+		// The last matching DataConsumer (if any) takes ownership of the original
+		// message.
+		if (pendingDataConsumer)
+		{
+			// We must update the message`s `streamId` for each destination
+			// DataConsumer.
+			message.SetStreamId(getStreamId(pendingDataConsumer));
+
+			pendingDataConsumer->SendMessage(
+			  std::move(message), subchannels, requiredSubchannel, ignoredSubchannel);
 		}
 	}