mediasoup 3.19.19 → 3.19.21

package/worker/src/RTC/Transport.cpp

@@ -1,14 +1,14 @@
-#include "RTC/SCTP/public/SctpTypes.hpp"
 #define MS_CLASS "RTC::Transport"
 // #define MS_LOG_DEV_LEVEL 3
 
 #include "RTC/Transport.hpp"
-#ifdef MS_LIBURING_SUPPORTED
-#include "DepLibUring.hpp"
-#endif
 #include "Logger.hpp"
 #include "MediaSoupErrors.hpp"
+#include "Settings.hpp"
 #include "Utils.hpp"
+#ifdef MS_LIBURING_SUPPORTED
+#include "DepLibUring.hpp"
+#endif
 #include "FBS/transport.h"
 #include "RTC/BweType.hpp"
 #include "RTC/Consts.hpp"
@@ -20,10 +20,8 @@
 #include "RTC/RTCP/FeedbackRtpTransport.hpp"
 #include "RTC/RTCP/XrDelaySinceLastRr.hpp"
 #include "RTC/RtpDictionaries.hpp"
-#ifdef MS_SCTP_STACK
 #include "RTC/SCTP/association/Association.hpp"
 #include "RTC/SCTP/public/SctpOptions.hpp"
-#endif
 #include "RTC/SimpleConsumer.hpp"
 #include "RTC/SimulcastConsumer.hpp"
 #include "RTC/SvcConsumer.hpp"
@@ -36,8 +34,8 @@
 
 namespace RTC
 {
-	static const size_t DefaultSctpSendBufferSize{ 262144 }; // 2^18.
-	static const size_t MaxSctpSendBufferSize{ 268435456 };  // 2^28.
+	static const size_t DefaultSctpSendBufferSize{ 262144 }; // 2^18 bytes.
+	static const size_t MaxSctpSendBufferSize{ 268435456 };  // 2^28 bytes.
 
 	/* Instance methods. */
 
@@ -112,28 +110,30 @@ namespace RTC
 				sctpSendBufferSize = DefaultSctpSendBufferSize;
 			}
 
-#ifdef MS_SCTP_STACK
-			// TODO: SCTP: Many interesting options missing.
-			const RTC::SCTP::SctpOptions sctpOptions = { .sourcePort         = 5000,
-				                                           .destinationPort    = 5000,
-				                                           .maxOutboundStreams = 65535,
-				                                           .maxInboundStreams =
-				                                             options->numSctpStreams()->mis(),
-				                                           // TODO: SCTP: Sure?
-				                                           .maxSendMessageSize = this->maxMessageSize,
-				                                           .maxSendBufferSize  = sctpSendBufferSize };
-
-			this->sctpAssociation = std::make_unique<RTC::SCTP::Association>(sctpOptions, this);
-#else
-			// This may throw.
-			this->sctpAssociation = new RTC::SctpAssociation(
-			  this,
-			  options->numSctpStreams()->os(),
-			  options->numSctpStreams()->mis(),
-			  this->maxMessageSize,
-			  sctpSendBufferSize,
-			  options->isDataChannel());
-#endif
+			if (Settings::configuration.useBuiltInSctpStack)
+			{
+				// TODO: SCTP: Many interesting options missing.
+				// NOTE: When using the built-in SCTP stack, `numSctpStreams` given to the
+				// transport is ignored.
+				const RTC::SCTP::SctpOptions sctpOptions = { // TODO: SCTP: Sure?
+					                                           .maxSendMessageSize = this->maxMessageSize,
+					                                           .maxSendBufferSize  = sctpSendBufferSize
+				};
+
+				this->sctpAssociation = std::make_unique<RTC::SCTP::Association>(sctpOptions, this);
+			}
+			// TODO: Remove once we only use built-in SCTP stack.
+			else
+			{
+				// This may throw.
+				this->oldSctpAssociation = new RTC::SctpAssociation(
+				  this,
+				  options->numSctpStreams()->os(),
+				  options->numSctpStreams()->mis(),
+				  this->maxMessageSize,
+				  sctpSendBufferSize,
+				  options->isDataChannel());
+			}
 		}
 
 		// Create the RTCP timer.
@@ -184,11 +184,23 @@ namespace RTC
 		}
 		this->mapDataConsumers.clear();
 
-#ifndef MS_SCTP_STACK
-		// Delete SCTP association.
-		delete this->sctpAssociation;
-		this->sctpAssociation = nullptr;
-#endif
+		if (Settings::configuration.useBuiltInSctpStack)
+		{
+			// NOTE: When using the built-in SCTP stack we don't do anything here since
+			// the `Destroying()` method has already been called by the Transport subclas
+			// and it closed the SCTP Association.
+			// NOTE: We cannot do it here in the destructor because here we are no longer
+			// the Transport subclass but Transport parent (this is how the destruction
+			// chain works in C++).
+		}
+		// TODO: Remove once we only use built-in SCTP stack.
+		else
+		{
+			// Delete SCTP association.
+			// TODO: Remove once we only use built-in SCTP stack.
+			delete this->oldSctpAssociation;
+			this->oldSctpAssociation = nullptr;
+		}
 
 		// Delete the RTCP timer.
 		delete this->rtcpTimer;
@@ -361,12 +373,11 @@ namespace RTC
 		// Add sctpListener.
 		flatbuffers::Offset<FBS::Transport::SctpListener> sctpListener;
 
-		if (this->sctpAssociation)
+		if (Settings::configuration.useBuiltInSctpStack && this->sctpAssociation)
 		{
 			// Add sctpParameters.
 			sctpParameters = this->sctpAssociation->FillBuffer(builder);
 
-#ifdef MS_SCTP_STACK
 			// NOTE: There is never permanent FAILED state.
 			switch (this->sctpAssociation->GetAssociationState())
 			{
@@ -395,8 +406,16 @@ namespace RTC
 					break;
 				}
 			}
-#else
-			switch (this->sctpAssociation->GetState())
+
+			sctpListener = this->sctpListener.FillBuffer(builder);
+		}
+		// TODO: Remove once we only use built-in SCTP stack.
+		else if (!Settings::configuration.useBuiltInSctpStack && this->oldSctpAssociation)
+		{
+			// Add sctpParameters.
+			sctpParameters = this->oldSctpAssociation->FillBuffer(builder);
+
+			switch (this->oldSctpAssociation->GetState())
 			{
 				case RTC::SctpAssociation::SctpState::NEW:
 				{
@@ -428,7 +447,7 @@ namespace RTC
 					break;
 				}
 			}
-#endif
+
 			sctpListener = this->sctpListener.FillBuffer(builder);
 		}
 
@@ -458,8 +477,9 @@ namespace RTC
 		  rtpListenerOffset,
 		  this->maxMessageSize,
 		  sctpParameters,
-		  this->sctpAssociation ? flatbuffers::Optional<FBS::SctpAssociation::SctpState>(sctpState)
-		                        : flatbuffers::nullopt,
+		  (this->sctpAssociation || this->oldSctpAssociation)
+		    ? flatbuffers::Optional<FBS::SctpAssociation::SctpState>(sctpState)
+		    : flatbuffers::nullopt,
 		  sctpListener,
 		  &traceEventTypes);
 	}
@@ -474,10 +494,9 @@ namespace RTC
 		// Add sctpState.
 		FBS::SctpAssociation::SctpState sctpState{ FBS::SctpAssociation::SctpState::NEW };
 
-		if (this->sctpAssociation)
+		// Add sctpState.
+		if (Settings::configuration.useBuiltInSctpStack && this->sctpAssociation)
 		{
-			// Add sctpState.
-#ifdef MS_SCTP_STACK
 			// NOTE: There is never permanent FAILED state.
 			switch (this->sctpAssociation->GetAssociationState())
 			{
@@ -506,8 +525,11 @@ namespace RTC
 					break;
 				}
 			}
-#else
-			switch (this->sctpAssociation->GetState())
+		}
+		// TODO: Remove once we only use built-in SCTP stack.
+		else if (!Settings::configuration.useBuiltInSctpStack && this->oldSctpAssociation)
+		{
+			switch (this->oldSctpAssociation->GetState())
 			{
 				case RTC::SctpAssociation::SctpState::NEW:
 				{
@@ -539,7 +561,6 @@ namespace RTC
 					break;
 				}
 			}
-#endif
 		}
 
 		return FBS::Transport::CreateStatsDirect(
@@ -549,8 +570,9 @@ namespace RTC
 		  // timestamp.
 		  nowMs,
 		  // sctpState.
-		  this->sctpAssociation ? flatbuffers::Optional<FBS::SctpAssociation::SctpState>(sctpState)
-		                        : flatbuffers::nullopt,
+		  (this->sctpAssociation || this->oldSctpAssociation)
+		    ? flatbuffers::Optional<FBS::SctpAssociation::SctpState>(sctpState)
+		    : flatbuffers::nullopt,
 		  // bytesReceived.
 		  this->recvTransmission.GetBytes(),
 		  // recvBitrate.
@@ -1132,7 +1154,10 @@ namespace RTC
 			case Channel::ChannelRequest::Method::TRANSPORT_PRODUCE_DATA:
 			{
 				// Early check. The Transport must support SCTP or be direct.
-				if (!this->sctpAssociation && !this->direct)
+				if (
+				  ((Settings::configuration.useBuiltInSctpStack && !this->sctpAssociation) ||
+				   (!Settings::configuration.useBuiltInSctpStack && !this->oldSctpAssociation)) &&
+				  !this->direct)
 				{
 					MS_THROW_ERROR("SCTP not enabled and not a direct Transport");
 				}
@@ -1153,7 +1178,9 @@ namespace RTC
 				{
 					case RTC::DataProducer::Type::SCTP:
 					{
-						if (!this->sctpAssociation)
+						if (
+						  (Settings::configuration.useBuiltInSctpStack && !this->sctpAssociation) ||
+						  (!Settings::configuration.useBuiltInSctpStack && !this->oldSctpAssociation))
 						{
 							delete dataProducer;
 
@@ -1225,12 +1252,16 @@ namespace RTC
 
 				if (dataProducer->GetType() == RTC::DataProducer::Type::SCTP)
 				{
-#ifdef MS_SCTP_STACK
-					// TODO: SCTP
-#else
 					// Tell to the SCTP association.
-					this->sctpAssociation->HandleDataProducer(dataProducer);
-#endif
+					if (Settings::configuration.useBuiltInSctpStack)
+					{
+						this->sctpAssociation->MayConnect();
+					}
+					// TODO: Remove once we only use built-in SCTP stack.
+					else
+					{
+						this->oldSctpAssociation->HandleDataProducer(dataProducer);
+					}
 				}
 
 				break;
@@ -1239,7 +1270,10 @@ namespace RTC
 			case Channel::ChannelRequest::Method::TRANSPORT_CONSUME_DATA:
 			{
 				// Early check. The Transport must support SCTP or be direct.
-				if (!this->sctpAssociation && !this->direct)
+				if (
+				  ((Settings::configuration.useBuiltInSctpStack && !this->sctpAssociation) ||
+				   (!Settings::configuration.useBuiltInSctpStack && !this->oldSctpAssociation)) &&
+				  !this->direct)
 				{
 					MS_THROW_ERROR("SCTP not enabled and not a direct Transport");
 				}
@@ -1254,22 +1288,16 @@ namespace RTC
 
 				// This may throw.
 				auto* dataConsumer = new RTC::DataConsumer(
-				  this->shared,
-				  dataConsumerId,
-				  dataProducerId,
-#ifndef MS_SCTP_STACK
-				  this->sctpAssociation,
-#endif
-				  this,
-				  body,
-				  this->maxMessageSize);
+				  this->shared, dataConsumerId, dataProducerId, this, body, this->maxMessageSize);
 
 				// Verify the type of the DataConsumer.
 				switch (dataConsumer->GetType())
 				{
 					case RTC::DataConsumer::Type::SCTP:
 					{
-						if (!this->sctpAssociation)
+						if (
+						  (Settings::configuration.useBuiltInSctpStack && !this->sctpAssociation) ||
+						  (!Settings::configuration.useBuiltInSctpStack && !this->oldSctpAssociation))
 						{
 							delete dataConsumer;
 
@@ -1328,21 +1356,29 @@ namespace RTC
 
 				if (dataConsumer->GetType() == RTC::DataConsumer::Type::SCTP)
 				{
-#ifdef MS_SCTP_STACK
-					if (this->sctpAssociation->GetAssociationState() == RTC::SCTP::Types::AssociationState::CONNECTED)
-#else
-					if (this->sctpAssociation->GetState() == RTC::SctpAssociation::SctpState::CONNECTED)
-#endif
+					if (Settings::configuration.useBuiltInSctpStack)
 					{
-						dataConsumer->SctpAssociationConnected();
+						if (this->sctpAssociation->GetAssociationState() == RTC::SCTP::Types::AssociationState::CONNECTED)
+						{
+							// Tell to the DataConsumer.
+							dataConsumer->SctpAssociationConnected();
+						}
+
+						// Tell to the SCTP association.
+						this->sctpAssociation->MayConnect();
 					}
+					// TODO: Remove once we only use built-in SCTP stack.
+					else
+					{
+						if (this->oldSctpAssociation->GetState() == RTC::SctpAssociation::SctpState::CONNECTED)
+						{
+							// Tell to the DataConsumer.
+							dataConsumer->SctpAssociationConnected();
+						}
 
-#ifdef MS_SCTP_STACK
-					// TODO: SCTP
-#else
-					// Tell to the SCTP association.
-					this->sctpAssociation->HandleDataConsumer(dataConsumer);
-#endif
+						// Tell to the SCTP association.
+						this->oldSctpAssociation->HandleDataConsumer(dataConsumer);
+					}
 				}
 
 				break;
@@ -1469,6 +1505,14 @@ namespace RTC
 
 			case Channel::ChannelRequest::Method::TRANSPORT_CLOSE_DATAPRODUCER:
 			{
+				if (
+				  ((Settings::configuration.useBuiltInSctpStack && !this->sctpAssociation) ||
+				   (!Settings::configuration.useBuiltInSctpStack && !this->oldSctpAssociation)) &&
+				  !this->direct)
+				{
+					MS_THROW_ERROR("cannot close DataProducer, SCTP not enabled and not a direct Transport");
+				}
+
 				const auto* body = request->data->body_as<FBS::Transport::CloseDataProducerRequest>();
 
 				// This may throw.
@@ -1490,12 +1534,16 @@ namespace RTC
 
 				if (dataProducer->GetType() == RTC::DataProducer::Type::SCTP)
 				{
-#ifdef MS_SCTP_STACK
-					// TODO: SCTP
-#else
-					// Tell the SctpAssociation so it can reset the SCTP stream.
-					this->sctpAssociation->DataProducerClosed(dataProducer);
-#endif
+					if (Settings::configuration.useBuiltInSctpStack)
+					{
+						// TODO: SCTP
+					}
+					// TODO: Remove once we only use built-in SCTP stack.
+					else
+					{
+						// Tell the SctpAssociation so it can reset the SCTP stream.
+						this->oldSctpAssociation->DataProducerClosed(dataProducer);
+					}
 				}
 
 				// Delete it.
@@ -1508,6 +1556,14 @@ namespace RTC
 
 			case Channel::ChannelRequest::Method::TRANSPORT_CLOSE_DATACONSUMER:
 			{
+				if (
+				  ((Settings::configuration.useBuiltInSctpStack && !this->sctpAssociation) ||
+				   (!Settings::configuration.useBuiltInSctpStack && !this->oldSctpAssociation)) &&
+				  !this->direct)
+				{
+					MS_THROW_ERROR("cannot close DataConsumer, SCTP not enabled and not a direct Transport");
+				}
+
 				const auto* body = request->data->body_as<FBS::Transport::CloseDataConsumerRequest>();
 
 				// This may throw.
@@ -1523,12 +1579,16 @@ namespace RTC
 
 				if (dataConsumer->GetType() == RTC::DataConsumer::Type::SCTP)
 				{
-#ifdef MS_SCTP_STACK
-					// TODO: SCTP
-#else
-					// Tell the SctpAssociation so it can reset the SCTP stream.
-					this->sctpAssociation->DataConsumerClosed(dataConsumer);
-#endif
+					if (Settings::configuration.useBuiltInSctpStack)
+					{
+						// TODO: SCTP
+					}
+					// TODO: Remove once we only use built-in SCTP stack.
+					else
+					{
+						// Tell the SctpAssociation so it can reset the SCTP stream.
+						this->oldSctpAssociation->DataConsumerClosed(dataConsumer);
+					}
 				}
 
 				// Delete it.
@@ -1573,6 +1633,18 @@ namespace RTC
 	{
 		MS_TRACE();
 
+		if (Settings::configuration.useBuiltInSctpStack)
+		{
+			if (this->sctpAssociation)
+			{
+				// NOTE: We don't invoke `Shutdown()` but `Close()` in the SCTP Association
+				// because at this point we are closing everything and we won't have any
+				// chance to complete the SCTP SHUTDOWN + SHUTDOWN_ACK + SHUTDOWN_COMPLETE
+				// dance, so we invoke `Close()` which just sends a SCTP ABORT.
+				this->sctpAssociation->Close();
+			}
+		}
+
 		this->destroying = true;
 	}
 
@@ -1597,13 +1669,14 @@ namespace RTC
 		}
 
 		// Tell the SctpAssociation.
-		if (this->sctpAssociation)
+		if (Settings::configuration.useBuiltInSctpStack && this->sctpAssociation)
 		{
-#ifdef MS_SCTP_STACK
-			// TODO: SCTP
-#else
-			this->sctpAssociation->TransportConnected();
-#endif
+			this->sctpAssociation->MayConnect();
+		}
+		// TODO: Remove once we only use built-in SCTP stack.
+		else if (!Settings::configuration.useBuiltInSctpStack && this->oldSctpAssociation)
+		{
+			this->oldSctpAssociation->TransportConnected();
 		}
 
 		// Start the RTCP timer.
@@ -1650,14 +1723,11 @@ namespace RTC
 			dataConsumer->TransportDisconnected();
 		}
 
+		// TODO: Remove once we only use built-in SCTP stack.
 		// Tell the SctpAssociation.
-		if (this->sctpAssociation)
+		if (!Settings::configuration.useBuiltInSctpStack && this->oldSctpAssociation)
 		{
-#ifdef MS_SCTP_STACK
-			// TODO: SCTP
-#else
-			this->sctpAssociation->TransportDisconnected();
-#endif
+			this->oldSctpAssociation->TransportDisconnected();
 		}
 
 		// Stop the RTCP timer.
@@ -1784,7 +1854,9 @@ namespace RTC
 	{
 		MS_TRACE();
 
-		if (!this->sctpAssociation)
+		if (
+		  (Settings::configuration.useBuiltInSctpStack && !this->sctpAssociation) ||
+		  (!Settings::configuration.useBuiltInSctpStack && !this->oldSctpAssociation))
 		{
 			MS_DEBUG_TAG(sctp, "ignoring SCTP packet (SCTP not enabled)");
 
@@ -1792,11 +1864,14 @@ namespace RTC
 		}
 
 		// Pass it to the SctpAssociation.
-#ifdef MS_SCTP_STACK
-		this->sctpAssociation->ReceiveSctpData(data, len);
-#else
-		this->sctpAssociation->ProcessSctpData(data, len);
-#endif
+		if (Settings::configuration.useBuiltInSctpStack)
+		{
+			this->sctpAssociation->ReceiveSctpData(data, len);
+		}
+		else
+		{
+			this->oldSctpAssociation->ProcessSctpData(data, len);
+		}
 	}
 
 	void Transport::CheckNoDataProducer(const std::string& dataProducerId) const
@@ -2877,6 +2952,31 @@ namespace RTC
 		SendMessage(dataConsumer, msg, len, ppid, cb);
 	}
 
+	void Transport::OnDataConsumerNeedBufferedAmount(
+	  RTC::DataConsumer* /*dataConsumer*/, uint32_t& bufferedAmount)
+	{
+		MS_TRACE();
+
+		if (Settings::configuration.useBuiltInSctpStack && this->sctpAssociation)
+		{
+			// TODO: SCTP
+			// TODO: Let's see how to obtain `streamId` argument from the DataConsumer.
+			// bufferedAmount = this->sctpAssociation->GetStreamBufferedAmount(streamId);
+		}
+		// TODO: Remove once we only use built-in SCTP stack.
+		else if (!Settings::configuration.useBuiltInSctpStack && this->oldSctpAssociation)
+		{
+			// NOTE: The underlaying SCTP association uses a common send buffer for all
+			// data consumers, hence the value given by this method indicates the data
+			// buffered for all data consumers in the transport.
+			bufferedAmount = this->oldSctpAssociation->GetSctpBufferedAmount();
+		}
+		else
+		{
+			bufferedAmount = 0;
+		}
+	}
+
 	void Transport::OnDataConsumerDataProducerClosed(RTC::DataConsumer* dataConsumer)
 	{
 		MS_TRACE();
@@ -2887,43 +2987,43 @@ namespace RTC
 		// Notify the listener.
 		this->listener->OnTransportDataConsumerDataProducerClosed(this, dataConsumer);
 
-		if (dataConsumer->GetType() == RTC::DataConsumer::Type::SCTP)
+		if (Settings::configuration.useBuiltInSctpStack)
 		{
-#ifdef MS_SCTP_STACK
-			// TODO: SCTP
-#else
-			// Tell the SctpAssociation so it can reset the SCTP stream.
-			this->sctpAssociation->DataConsumerClosed(dataConsumer);
-#endif
+			if (this->sctpAssociation && dataConsumer->GetType() == RTC::DataConsumer::Type::SCTP)
+			{
+				// TODO: SCTP
+			}
+		}
+		// TODO: Remove once we only use built-in SCTP stack.
+		else
+		{
+			if (this->oldSctpAssociation && dataConsumer->GetType() == RTC::DataConsumer::Type::SCTP)
+			{
+				// Tell the SctpAssociation so it can reset the SCTP stream.
+				this->oldSctpAssociation->DataConsumerClosed(dataConsumer);
+			}
 		}
 
 		// Delete it.
 		delete dataConsumer;
 	}
 
-#ifdef MS_SCTP_STACK
 	bool Transport::OnAssociationSendData(const uint8_t* data, size_t len)
 	{
 		MS_TRACE();
 
-		// TODO: Check if this is still true.
 		// Ignore if destroying.
 		// NOTE: This is because when the child class (i.e. WebRtcTransport) is deleted,
 		// its destructor is called first and then the parent Transport's destructor,
 		// and we would end here calling SendSctpData() which is an abstract method.
 		if (this->destroying)
 		{
-			return false;
-		}
+			MS_WARN_DEV("ignoring sending data because Transport is being destroying");
 
-		if (this->sctpAssociation)
-		{
-			return SendSctpData(data, len);
-		}
-		else
-		{
 			return false;
 		}
+
+		return SendSctpData(data, len);
 	}
 
 	void Transport::OnAssociationConnecting()
@@ -3090,8 +3190,23 @@ namespace RTC
 		// TODO: SCTP
 	}
 
+	bool Transport::OnAssociationIsTransportReadyForSctp()
+	{
+		MS_TRACE();
+
+		// We are ready for SCTP traffic if the transport is connected (e.g. the
+		// WebRtcTransport has ICE and DTLS connected) and there is at least a
+		// DataProducer or DataConsumer.
+		//
+		// NOTE: We don't want to start SCTP connection if there are no DataProducers
+		// and DataConsumers because the peer (e.g. a browser) may have not started
+		// its SCTP stack (e.g. no "m=application" media section in its SDP) so if we
+		// initiate the SCTP connection it would fail after some time.
+		return IsConnected() && (this->mapDataProducers.size() > 0 || this->mapDataConsumers.size() > 0);
+	}
+
 	// TODO: SCTP: Add OnAssociationLifecycleMessageXxxxxx() methods.
-#else
+
 	void Transport::OnSctpAssociationConnecting(RTC::SctpAssociation* /*sctpAssociation*/)
 	{
 		MS_TRACE();
@@ -3196,13 +3311,12 @@ namespace RTC
 		// and we would end here calling SendSctpData() which is an abstract method.
 		if (this->destroying)
 		{
+			MS_WARN_DEV("ignoring sending data because Transport is being destroying");
+
 			return;
 		}
 
-		if (this->sctpAssociation)
-		{
-			SendSctpData(data, len);
-		}
+		SendSctpData(data, len);
 	}
 
 	void Transport::OnSctpAssociationMessageReceived(
@@ -3253,11 +3367,10 @@ namespace RTC
 
 			if (dataConsumer->GetType() == RTC::DataConsumer::Type::SCTP)
 			{
-				dataConsumer->SctpAssociationBufferedAmount(bufferedAmount);
+				dataConsumer->SetSctpAssociationBufferedAmount(bufferedAmount);
 			}
 		}
 	}
-#endif
 
 	void Transport::OnTransportCongestionControlClientBitrates(
 	  RTC::TransportCongestionControlClient* /*tccClient*/,

package/worker/src/RTC/WebRtcTransport.cpp

@@ -856,11 +856,15 @@ namespace RTC
 	{
 		MS_TRACE();
 
-#ifdef MS_SCTP_STACK
-		// TODO: SCTP
-#else
-		this->sctpAssociation->SendSctpMessage(dataConsumer, msg, len, ppid, cb);
-#endif
+		if (Settings::configuration.useBuiltInSctpStack)
+		{
+			// TODO: SCTP
+		}
+		// TODO: Remove once we only use built-in SCTP stack.
+		else
+		{
+			this->oldSctpAssociation->SendSctpMessage(dataConsumer, msg, len, ppid, cb);
+		}
 	}
 
 	bool WebRtcTransport::SendSctpData(const uint8_t* data, size_t len)