mediasoup 3.19.21 → 3.20.0

package/worker/src/RTC/Transport.cpp

@@ -4,11 +4,11 @@
 #include "RTC/Transport.hpp"
 #include "Logger.hpp"
 #include "MediaSoupErrors.hpp"
-#include "Settings.hpp"
 #include "Utils.hpp"
 #ifdef MS_LIBURING_SUPPORTED
 #include "DepLibUring.hpp"
 #endif
+#include "FBS/sctpAssociation.h"
 #include "FBS/transport.h"
 #include "RTC/BweType.hpp"
 #include "RTC/Consts.hpp"
@@ -29,40 +29,42 @@
 #include "RTC/RtcLogger.hpp"
 #endif
 #include <libwebrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h> // webrtc::RtpPacketSendInfo
-#include <iterator>                                              // std::ostream_iterator
-#include <map>                                                   // std::multimap
+#include <array>
+#include <iterator> // std::ostream_iterator
+#include <map>      // std::multimap
 
 namespace RTC
 {
-	static const size_t DefaultSctpSendBufferSize{ 262144 }; // 2^18 bytes.
-	static const size_t MaxSctpSendBufferSize{ 268435456 };  // 2^28 bytes.
-
 	/* Instance methods. */
 
 	Transport::Transport(
-	  RTC::Shared* shared,
+	  SharedInterface* shared,
 	  const std::string& id,
 	  RTC::Transport::Listener* listener,
 	  const FBS::Transport::Options* options)
 	  : id(id),
 	    shared(shared),
 	    listener(listener),
-	    recvRtpTransmission(/*ignorePaddingOnlyPackets*/ false),
-	    sendRtpTransmission(/*ignorePaddingOnlyPackets*/ false),
-	    recvRtxTransmission(/*ignorePaddingOnlyPackets*/ false, 1000u),
-	    sendRtxTransmission(/*ignorePaddingOnlyPackets*/ false, 1000u),
-	    sendProbationTransmission(/*ignorePaddingOnlyPackets*/ false, 100u)
+	    recvRtpTransmission(shared, /*ignorePaddingOnlyPackets*/ false),
+	    sendRtpTransmission(shared, /*ignorePaddingOnlyPackets*/ false),
+	    recvRtxTransmission(shared, /*ignorePaddingOnlyPackets*/ false, 1000u),
+	    sendRtxTransmission(shared, /*ignorePaddingOnlyPackets*/ false, 1000u),
+	    sendProbationTransmission(shared, /*ignorePaddingOnlyPackets*/ false, 100u)
 	{
 		MS_TRACE();
 
+		this->maxSendMessageSize    = options->maxSendMessageSize();
+		this->maxReceiveMessageSize = options->maxReceiveMessageSize();
+
 		if (options->direct())
 		{
 			this->direct = true;
-
-			if (auto maxMessageSize = options->maxMessageSize(); maxMessageSize.has_value())
-			{
-				this->maxMessageSize = maxMessageSize.value();
-			}
+		}
+		else
+		{
+			this->sctpSendBufferSize              = options->sctpSendBufferSize();
+			this->sctpPerStreamSendQueueLimit     = options->sctpPerStreamSendQueueLimit();
+			this->sctpMaxReceiverWindowBufferSize = options->sctpMaxReceiverWindowBufferSize();
 		}
 
 		if (
@@ -79,65 +81,21 @@ namespace RTC
 				MS_THROW_TYPE_ERROR("cannot enable SCTP in a direct Transport");
 			}
 
-			// numSctpStreams is mandatory.
-			if (!flatbuffers::IsFieldPresent(options, FBS::Transport::Options::VT_NUMSCTPSTREAMS))
-			{
-				MS_THROW_TYPE_ERROR("numSctpStreams missing");
-			}
-
-			// maxSctpMessageSize is mandatory.
-			if (!flatbuffers::IsFieldPresent(options, FBS::Transport::Options::VT_MAXSCTPMESSAGESIZE))
-			{
-				MS_THROW_TYPE_ERROR("maxSctpMessageSize missing");
-			}
-
-			this->maxMessageSize = options->maxSctpMessageSize();
+			const RTC::SCTP::SctpOptions sctpOptions = {
+				.mtu                         = RTC::Consts::MaxSafeMtuSizeForSctp,
+				.maxSendMessageSize          = this->maxSendMessageSize,
+				.maxSendBufferSize           = this->sctpSendBufferSize,
+				.perStreamSendQueueLimit     = this->sctpPerStreamSendQueueLimit,
+				.maxReceiveMessageSize       = this->maxReceiveMessageSize,
+				.maxReceiverWindowBufferSize = this->sctpMaxReceiverWindowBufferSize
+			};
 
-			size_t sctpSendBufferSize;
-
-			// sctpSendBufferSize is optional.
-			if (flatbuffers::IsFieldPresent(options, FBS::Transport::Options::VT_SCTPSENDBUFFERSIZE))
-			{
-				if (options->sctpSendBufferSize() > MaxSctpSendBufferSize)
-				{
-					MS_THROW_TYPE_ERROR("wrong sctpSendBufferSize (maximum value exceeded)");
-				}
-
-				sctpSendBufferSize = options->sctpSendBufferSize();
-			}
-			else
-			{
-				sctpSendBufferSize = DefaultSctpSendBufferSize;
-			}
-
-			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());
-			}
+			this->sctpAssociation = std::make_unique<RTC::SCTP::Association>(
+			  sctpOptions, this, this->shared, options->isDataChannel());
 		}
 
 		// Create the RTCP timer.
-		this->rtcpTimer = new TimerHandle(this);
+		this->rtcpTimer = this->shared->CreateTimer(this);
 	}
 
 	Transport::~Transport()
@@ -183,24 +141,15 @@ namespace RTC
 			delete dataConsumer;
 		}
 		this->mapDataConsumers.clear();
+		this->mapSctpStreamIdDataConsumers.clear();
 
-		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;
-		}
+		// NOTE: We don't close `this->sctpAssociation` here since the
+		// `SetDestroying()` method has already been called by the Transport
+		// subclass 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++).
 
 		// Delete the RTCP timer.
 		delete this->rtcpTimer;
@@ -266,6 +215,7 @@ namespace RTC
 			delete dataConsumer;
 		}
 		this->mapDataConsumers.clear();
+		this->mapSctpStreamIdDataConsumers.clear();
 	}
 
 	void Transport::ListenServerClosed()
@@ -373,7 +323,7 @@ namespace RTC
 		// Add sctpListener.
 		flatbuffers::Offset<FBS::Transport::SctpListener> sctpListener;
 
-		if (Settings::configuration.useBuiltInSctpStack && this->sctpAssociation)
+		if (this->sctpAssociation)
 		{
 			// Add sctpParameters.
 			sctpParameters = this->sctpAssociation->FillBuffer(builder);
@@ -409,47 +359,6 @@ namespace RTC
 
 			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:
-				{
-					sctpState = FBS::SctpAssociation::SctpState::NEW;
-					break;
-				}
-
-				case RTC::SctpAssociation::SctpState::CONNECTING:
-				{
-					sctpState = FBS::SctpAssociation::SctpState::CONNECTING;
-					break;
-				}
-
-				case RTC::SctpAssociation::SctpState::CONNECTED:
-				{
-					sctpState = FBS::SctpAssociation::SctpState::CONNECTED;
-					break;
-				}
-
-				case RTC::SctpAssociation::SctpState::FAILED:
-				{
-					sctpState = FBS::SctpAssociation::SctpState::FAILED;
-					break;
-				}
-
-				case RTC::SctpAssociation::SctpState::CLOSED:
-				{
-					sctpState = FBS::SctpAssociation::SctpState::CLOSED;
-					break;
-				}
-			}
-
-			sctpListener = this->sctpListener.FillBuffer(builder);
-		}
 
 		// Add traceEventTypes.
 		std::vector<FBS::Transport::TraceEventType> traceEventTypes;
@@ -475,11 +384,11 @@ namespace RTC
 		  &dataConsumerIds,
 		  recvRtpHeaderExtensions,
 		  rtpListenerOffset,
-		  this->maxMessageSize,
+		  this->maxSendMessageSize,
+		  this->maxReceiveMessageSize,
 		  sctpParameters,
-		  (this->sctpAssociation || this->oldSctpAssociation)
-		    ? flatbuffers::Optional<FBS::SctpAssociation::SctpState>(sctpState)
-		    : flatbuffers::nullopt,
+		  this->sctpAssociation ? flatbuffers::Optional<FBS::SctpAssociation::SctpState>(sctpState)
+		                        : flatbuffers::nullopt,
 		  sctpListener,
 		  &traceEventTypes);
 	}
@@ -489,13 +398,13 @@ namespace RTC
 	{
 		MS_TRACE();
 
-		auto nowMs = DepLibUV::GetTimeMs();
+		auto nowMs = this->shared->GetTimeMs();
 
 		// Add sctpState.
 		FBS::SctpAssociation::SctpState sctpState{ FBS::SctpAssociation::SctpState::NEW };
 
 		// Add sctpState.
-		if (Settings::configuration.useBuiltInSctpStack && this->sctpAssociation)
+		if (this->sctpAssociation)
 		{
 			// NOTE: There is never permanent FAILED state.
 			switch (this->sctpAssociation->GetAssociationState())
@@ -526,42 +435,6 @@ namespace RTC
 				}
 			}
 		}
-		// 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:
-				{
-					sctpState = FBS::SctpAssociation::SctpState::NEW;
-					break;
-				}
-
-				case RTC::SctpAssociation::SctpState::CONNECTING:
-				{
-					sctpState = FBS::SctpAssociation::SctpState::CONNECTING;
-					break;
-				}
-
-				case RTC::SctpAssociation::SctpState::CONNECTED:
-				{
-					sctpState = FBS::SctpAssociation::SctpState::CONNECTED;
-					break;
-				}
-
-				case RTC::SctpAssociation::SctpState::FAILED:
-				{
-					sctpState = FBS::SctpAssociation::SctpState::FAILED;
-					break;
-				}
-
-				case RTC::SctpAssociation::SctpState::CLOSED:
-				{
-					sctpState = FBS::SctpAssociation::SctpState::CLOSED;
-					break;
-				}
-			}
-		}
 
 		return FBS::Transport::CreateStatsDirect(
 		  builder,
@@ -570,9 +443,8 @@ namespace RTC
 		  // timestamp.
 		  nowMs,
 		  // sctpState.
-		  (this->sctpAssociation || this->oldSctpAssociation)
-		    ? flatbuffers::Optional<FBS::SctpAssociation::SctpState>(sctpState)
-		    : flatbuffers::nullopt,
+		  this->sctpAssociation ? flatbuffers::Optional<FBS::SctpAssociation::SctpState>(sctpState)
+		                        : flatbuffers::nullopt,
 		  // bytesReceived.
 		  this->recvTransmission.GetBytes(),
 		  // recvBitrate.
@@ -880,7 +752,7 @@ namespace RTC
 					if (createTccServer)
 					{
 						this->tccServer = std::make_shared<RTC::TransportCongestionControlServer>(
-						  this, bweType, RTC::Consts::RtcpPacketMaxSize);
+						  this, this->shared, bweType, RTC::Consts::RtcpPacketMaxSize);
 
 						if (this->maxIncomingBitrate != 0u)
 						{
@@ -1073,6 +945,7 @@ namespace RTC
 
 						this->tccClient = std::make_shared<RTC::TransportCongestionControlClient>(
 						  this,
+						  this->shared,
 						  bweType,
 						  this->initialAvailableOutgoingBitrate,
 						  this->maxOutgoingBitrate,
@@ -1127,7 +1000,7 @@ namespace RTC
 					};
 
 					this->senderBwe = std::make_shared<RTC::SenderBandwidthEstimator>(
-					  this, this->initialAvailableOutgoingBitrate);
+					  this, this->shared, this->initialAvailableOutgoingBitrate);
 
 					if (IsConnected())
 					{
@@ -1154,10 +1027,7 @@ namespace RTC
 			case Channel::ChannelRequest::Method::TRANSPORT_PRODUCE_DATA:
 			{
 				// Early check. The Transport must support SCTP or be direct.
-				if (
-				  ((Settings::configuration.useBuiltInSctpStack && !this->sctpAssociation) ||
-				   (!Settings::configuration.useBuiltInSctpStack && !this->oldSctpAssociation)) &&
-				  !this->direct)
+				if (!this->sctpAssociation && !this->direct)
 				{
 					MS_THROW_ERROR("SCTP not enabled and not a direct Transport");
 				}
@@ -1170,17 +1040,15 @@ namespace RTC
 				CheckNoDataProducer(dataProducerId);
 
 				// This may throw.
-				auto* dataProducer =
-				  new RTC::DataProducer(this->shared, dataProducerId, this->maxMessageSize, this, body);
+				auto* dataProducer = new RTC::DataProducer(
+				  this->shared, dataProducerId, this->maxReceiveMessageSize, this, body);
 
 				// Verify the type of the DataProducer.
 				switch (dataProducer->GetType())
 				{
 					case RTC::DataProducer::Type::SCTP:
 					{
-						if (
-						  (Settings::configuration.useBuiltInSctpStack && !this->sctpAssociation) ||
-						  (!Settings::configuration.useBuiltInSctpStack && !this->oldSctpAssociation))
+						if (!this->sctpAssociation)
 						{
 							delete dataProducer;
 
@@ -1253,15 +1121,7 @@ namespace RTC
 				if (dataProducer->GetType() == RTC::DataProducer::Type::SCTP)
 				{
 					// Tell to the SCTP association.
-					if (Settings::configuration.useBuiltInSctpStack)
-					{
-						this->sctpAssociation->MayConnect();
-					}
-					// TODO: Remove once we only use built-in SCTP stack.
-					else
-					{
-						this->oldSctpAssociation->HandleDataProducer(dataProducer);
-					}
+					this->sctpAssociation->MayConnect();
 				}
 
 				break;
@@ -1270,10 +1130,7 @@ namespace RTC
 			case Channel::ChannelRequest::Method::TRANSPORT_CONSUME_DATA:
 			{
 				// Early check. The Transport must support SCTP or be direct.
-				if (
-				  ((Settings::configuration.useBuiltInSctpStack && !this->sctpAssociation) ||
-				   (!Settings::configuration.useBuiltInSctpStack && !this->oldSctpAssociation)) &&
-				  !this->direct)
+				if (!this->sctpAssociation && !this->direct)
 				{
 					MS_THROW_ERROR("SCTP not enabled and not a direct Transport");
 				}
@@ -1288,16 +1145,14 @@ namespace RTC
 
 				// This may throw.
 				auto* dataConsumer = new RTC::DataConsumer(
-				  this->shared, dataConsumerId, dataProducerId, this, body, this->maxMessageSize);
+				  this->shared, dataConsumerId, dataProducerId, this, body, this->maxSendMessageSize);
 
 				// Verify the type of the DataConsumer.
 				switch (dataConsumer->GetType())
 				{
 					case RTC::DataConsumer::Type::SCTP:
 					{
-						if (
-						  (Settings::configuration.useBuiltInSctpStack && !this->sctpAssociation) ||
-						  (!Settings::configuration.useBuiltInSctpStack && !this->oldSctpAssociation))
+						if (!this->sctpAssociation)
 						{
 							delete dataConsumer;
 
@@ -1306,6 +1161,18 @@ namespace RTC
 							;
 						}
 
+						try
+						{
+							// This may throw.
+							CheckNoSctpDataConsumer(dataConsumer->GetSctpStreamParameters().streamId);
+						}
+						catch (const MediaSoupError& error)
+						{
+							delete dataConsumer;
+
+							throw;
+						}
+
 						break;
 					}
 
@@ -1340,6 +1207,12 @@ namespace RTC
 				// Insert into the maps.
 				this->mapDataConsumers[dataConsumerId] = dataConsumer;
 
+				if (dataConsumer->GetType() == RTC::DataConsumer::Type::SCTP)
+				{
+					this->mapSctpStreamIdDataConsumers[dataConsumer->GetSctpStreamParameters().streamId] =
+					  dataConsumer;
+				}
+
 				MS_DEBUG_DEV(
 				  "DataConsumer created [dataConsumerId:%s, dataProducerId:%s]",
 				  dataConsumerId.c_str(),
@@ -1356,29 +1229,14 @@ namespace RTC
 
 				if (dataConsumer->GetType() == RTC::DataConsumer::Type::SCTP)
 				{
-					if (Settings::configuration.useBuiltInSctpStack)
+					if (this->sctpAssociation->GetAssociationState() == RTC::SCTP::Types::AssociationState::CONNECTED)
 					{
-						if (this->sctpAssociation->GetAssociationState() == RTC::SCTP::Types::AssociationState::CONNECTED)
-						{
-							// Tell to the DataConsumer.
-							dataConsumer->SctpAssociationConnected();
-						}
-
-						// Tell to the SCTP association.
-						this->sctpAssociation->MayConnect();
+						// Tell to the DataConsumer.
+						dataConsumer->SctpAssociationConnected();
 					}
-					// 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();
-						}
 
-						// Tell to the SCTP association.
-						this->oldSctpAssociation->HandleDataConsumer(dataConsumer);
-					}
+					// Tell to the SCTP association.
+					this->sctpAssociation->MayConnect();
 				}
 
 				break;
@@ -1423,7 +1281,7 @@ namespace RTC
 				const auto* body = request->data->body_as<FBS::Transport::CloseProducerRequest>();
 
 				// This may throw.
-				RTC::Producer* producer = GetProducerById(body->producerId()->str());
+				RTC::Producer* producer = AssertAndGetProducerById(body->producerId()->str());
 
 				// Remove it from the RtpListener.
 				this->rtpListener.RemoveProducer(producer);
@@ -1462,7 +1320,7 @@ namespace RTC
 				const auto* body = request->data->body_as<FBS::Transport::CloseConsumerRequest>();
 
 				// This may throw.
-				RTC::Consumer* consumer = GetConsumerById(body->consumerId()->str());
+				RTC::Consumer* consumer = AssertAndGetConsumerById(body->consumerId()->str());
 
 				// Remove it from the maps.
 				this->mapConsumers.erase(consumer->id);
@@ -1505,10 +1363,7 @@ namespace RTC
 
 			case Channel::ChannelRequest::Method::TRANSPORT_CLOSE_DATAPRODUCER:
 			{
-				if (
-				  ((Settings::configuration.useBuiltInSctpStack && !this->sctpAssociation) ||
-				   (!Settings::configuration.useBuiltInSctpStack && !this->oldSctpAssociation)) &&
-				  !this->direct)
+				if (!this->sctpAssociation && !this->direct)
 				{
 					MS_THROW_ERROR("cannot close DataProducer, SCTP not enabled and not a direct Transport");
 				}
@@ -1516,7 +1371,7 @@ namespace RTC
 				const auto* body = request->data->body_as<FBS::Transport::CloseDataProducerRequest>();
 
 				// This may throw.
-				RTC::DataProducer* dataProducer = GetDataProducerById(body->dataProducerId()->str());
+				RTC::DataProducer* dataProducer = AssertAndGetDataProducerById(body->dataProducerId()->str());
 
 				if (dataProducer->GetType() == RTC::DataProducer::Type::SCTP)
 				{
@@ -1527,25 +1382,24 @@ namespace RTC
 				// Remove it from the map.
 				this->mapDataProducers.erase(dataProducer->id);
 
+				// https://datatracker.ietf.org/doc/html/rfc8831#section-6.7
+				//
+				// "Closing of a data channel MUST be signaled by resetting the corresponding
+				// outgoing streams [RFC6525]. This means that if one side decides to close
+				// the data channel, it resets the corresponding outgoing stream. When the
+				// peer sees that an incoming stream was reset, it also resets its
+				// corresponding outgoing stream."
+				if (this->sctpAssociation && this->sctpAssociation->IsDataChannel())
+				{
+					this->sctpAssociation->ResetStreams(
+					  std::array<uint16_t, 1>{ dataProducer->GetSctpStreamParameters().streamId });
+				}
+
 				// Notify the listener.
 				this->listener->OnTransportDataProducerClosed(this, dataProducer);
 
 				MS_DEBUG_DEV("DataProducer closed [dataProducerId:%s]", dataProducer->id.c_str());
 
-				if (dataProducer->GetType() == RTC::DataProducer::Type::SCTP)
-				{
-					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.
 				delete dataProducer;
 
@@ -1556,10 +1410,7 @@ namespace RTC
 
 			case Channel::ChannelRequest::Method::TRANSPORT_CLOSE_DATACONSUMER:
 			{
-				if (
-				  ((Settings::configuration.useBuiltInSctpStack && !this->sctpAssociation) ||
-				   (!Settings::configuration.useBuiltInSctpStack && !this->oldSctpAssociation)) &&
-				  !this->direct)
+				if (!this->sctpAssociation && !this->direct)
 				{
 					MS_THROW_ERROR("cannot close DataConsumer, SCTP not enabled and not a direct Transport");
 				}
@@ -1567,30 +1418,27 @@ namespace RTC
 				const auto* body = request->data->body_as<FBS::Transport::CloseDataConsumerRequest>();
 
 				// This may throw.
-				RTC::DataConsumer* dataConsumer = GetDataConsumerById(body->dataConsumerId()->str());
+				RTC::DataConsumer* dataConsumer = AssertAndGetDataConsumerById(body->dataConsumerId()->str());
 
 				// Remove it from the maps.
 				this->mapDataConsumers.erase(dataConsumer->id);
 
+				if (dataConsumer->GetType() == RTC::DataConsumer::Type::SCTP)
+				{
+					this->mapSctpStreamIdDataConsumers.erase(dataConsumer->GetSctpStreamParameters().streamId);
+				}
+
+				if (this->sctpAssociation)
+				{
+					this->sctpAssociation->ResetStreams(
+					  std::array<uint16_t, 1>{ dataConsumer->GetSctpStreamParameters().streamId });
+				}
+
 				// Notify the listener.
 				this->listener->OnTransportDataConsumerClosed(this, dataConsumer);
 
 				MS_DEBUG_DEV("DataConsumer closed [dataConsumerId:%s]", dataConsumer->id.c_str());
 
-				if (dataConsumer->GetType() == RTC::DataConsumer::Type::SCTP)
-				{
-					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.
 				delete dataConsumer;
 
@@ -1629,23 +1477,20 @@ namespace RTC
 		}
 	}
 
-	void Transport::Destroying()
+	void Transport::SetDestroying()
 	{
 		MS_TRACE();
 
-		if (Settings::configuration.useBuiltInSctpStack)
+		if (this->sctpAssociation)
 		{
-			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();
-			}
+			// 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;
+		this->isDestroying = true;
 	}
 
 	void Transport::Connected()
@@ -1669,15 +1514,10 @@ namespace RTC
 		}
 
 		// Tell the SctpAssociation.
-		if (Settings::configuration.useBuiltInSctpStack && this->sctpAssociation)
+		if (this->sctpAssociation)
 		{
 			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.
 		this->rtcpTimer->Start(static_cast<uint64_t>(RTC::RTCP::MaxVideoIntervalMs / 2));
@@ -1723,13 +1563,6 @@ namespace RTC
 			dataConsumer->TransportDisconnected();
 		}
 
-		// TODO: Remove once we only use built-in SCTP stack.
-		// Tell the SctpAssociation.
-		if (!Settings::configuration.useBuiltInSctpStack && this->oldSctpAssociation)
-		{
-			this->oldSctpAssociation->TransportDisconnected();
-		}
-
 		// Stop the RTCP timer.
 		this->rtcpTimer->Stop();
 
@@ -1766,7 +1599,7 @@ namespace RTC
 		// them.
 		packet->AssignExtensionIds(this->recvRtpHeaderExtensionIds);
 
-		auto nowMs = DepLibUV::GetTimeMs();
+		auto nowMs = this->shared->GetTimeMs();
 
 		// Feed the TransportCongestionControlServer.
 		if (this->tccServer)
@@ -1854,9 +1687,7 @@ namespace RTC
 	{
 		MS_TRACE();
 
-		if (
-		  (Settings::configuration.useBuiltInSctpStack && !this->sctpAssociation) ||
-		  (!Settings::configuration.useBuiltInSctpStack && !this->oldSctpAssociation))
+		if (!this->sctpAssociation)
 		{
 			MS_DEBUG_TAG(sctp, "ignoring SCTP packet (SCTP not enabled)");
 
@@ -1864,14 +1695,97 @@ namespace RTC
 		}
 
 		// Pass it to the SctpAssociation.
-		if (Settings::configuration.useBuiltInSctpStack)
+		this->sctpAssociation->ReceiveSctpData(data, len);
+	}
+
+	void Transport::SendSctpMessage(
+	  RTC::DataConsumer* dataConsumer, RTC::SCTP::Message message, onQueuedCallback* cb)
+	{
+		MS_TRACE();
+
+		// NOTE: The `message` must already have its `streamId` pointing to the same
+		// as in the `dataConsumer` if its type is "sctp", or 0 otherwise.
+
+		if (!this->sctpAssociation)
 		{
-			this->sctpAssociation->ReceiveSctpData(data, len);
+			MS_THROW_ERROR("SCTP not enabled");
+
+			if (cb)
+			{
+				(*cb)(false, false);
+				delete cb;
+			}
+
+			return;
 		}
-		else
+
+		const auto& sctpStreamParameters = dataConsumer->GetSctpStreamParameters();
+		const RTC::SCTP::SendMessageOptions sendMessageOptions{
+			.unordered          = !sctpStreamParameters.ordered,
+			.lifetimeMs         = sctpStreamParameters.ordered
+			                        ? std::nullopt
+			                        : std::optional<uint64_t>(sctpStreamParameters.maxPacketLifeTime),
+			.maxRetransmissions = sctpStreamParameters.ordered
+			                        ? std::nullopt
+			                        : std::optional<uint64_t>(sctpStreamParameters.maxRetransmits),
+			// NOTE: We don't set `lifecyleId` in production.
+		};
+
+		const auto sendStatus =
+		  this->sctpAssociation->SendMessage(std::move(message), sendMessageOptions);
+
+		switch (sendStatus)
 		{
-			this->oldSctpAssociation->ProcessSctpData(data, len);
+			case RTC::SCTP::Types::SendMessageStatus::SUCCESS:
+			{
+				if (cb)
+				{
+					(*cb)(true, /*sctpSendBufferFull*/ false);
+				}
+
+				break;
+			}
+
+			case RTC::SCTP::Types::SendMessageStatus::ERROR_RESOURCE_EXHAUSTION:
+			{
+				const auto sendStatusStringView = RTC::SCTP::Types::SendMessageStatusToString(sendStatus);
+
+				MS_WARN_TAG(
+				  sctp,
+				  "failed to send SCTP message [sendStatus:%.*s]",
+				  static_cast<int>(sendStatusStringView.size()),
+				  sendStatusStringView.data());
+
+				if (cb)
+				{
+					(*cb)(false, /*sctpSendBufferFull*/ true);
+				}
+
+				dataConsumer->SctpSendBufferFull();
+
+				break;
+			}
+
+			default:
+			{
+				const auto sendStatusStringView = RTC::SCTP::Types::SendMessageStatusToString(sendStatus);
+
+				MS_WARN_TAG(
+				  sctp,
+				  "failed to send SCTP message [sendStatus:%.*s]",
+				  static_cast<int>(sendStatusStringView.size()),
+				  sendStatusStringView.data());
+
+				if (cb)
+				{
+					(*cb)(false, /*sctpSendBufferFull*/ false);
+				}
+
+				break;
+			}
 		}
+
+		delete cb;
 	}
 
 	void Transport::CheckNoDataProducer(const std::string& dataProducerId) const
@@ -1892,7 +1806,17 @@ namespace RTC
 		}
 	}
 
-	RTC::Producer* Transport::GetProducerById(const std::string& producerId) const
+	void Transport::CheckNoSctpDataConsumer(uint16_t streamId) const
+	{
+		MS_TRACE();
+
+		if (this->mapSctpStreamIdDataConsumers.find(streamId) != this->mapSctpStreamIdDataConsumers.end())
+		{
+			MS_THROW_ERROR("an SCTP DataConsumer with same streamId %" PRIu16 " already exists", streamId);
+		}
+	}
+
+	RTC::Producer* Transport::AssertAndGetProducerById(const std::string& producerId) const
 	{
 		MS_TRACE();
 
@@ -1906,7 +1830,7 @@ namespace RTC
 		return it->second;
 	}
 
-	RTC::Consumer* Transport::GetConsumerById(const std::string& consumerId) const
+	RTC::Consumer* Transport::AssertAndGetConsumerById(const std::string& consumerId) const
 	{
 		MS_TRACE();
 
@@ -1952,7 +1876,7 @@ namespace RTC
 		return consumer;
 	}
 
-	RTC::DataProducer* Transport::GetDataProducerById(const std::string& dataProducerId) const
+	RTC::DataProducer* Transport::AssertAndGetDataProducerById(const std::string& dataProducerId) const
 	{
 		MS_TRACE();
 
@@ -1966,7 +1890,7 @@ namespace RTC
 		return it->second;
 	}
 
-	RTC::DataConsumer* Transport::GetDataConsumerById(const std::string& dataConsumerId) const
+	RTC::DataConsumer* Transport::AssertAndGetDataConsumerById(const std::string& dataConsumerId) const
 	{
 		MS_TRACE();
 
@@ -1980,6 +1904,20 @@ namespace RTC
 		return it->second;
 	}
 
+	RTC::DataConsumer* Transport::GetSctpDataConsumerByStreamId(uint16_t streamId) const
+	{
+		MS_TRACE();
+
+		auto it = this->mapSctpStreamIdDataConsumers.find(streamId);
+
+		if (it == this->mapSctpStreamIdDataConsumers.end())
+		{
+			MS_THROW_ERROR("SCTP DataConsumer with streamId %" PRIu16 " not found", streamId);
+		}
+
+		return it->second;
+	}
+
 	void Transport::HandleRtcpPacket(RTC::RTCP::Packet* packet)
 	{
 		MS_TRACE();
@@ -2037,7 +1975,7 @@ namespace RTC
 						}
 					}
 
-					this->tccClient->ReceiveRtcpReceiverReport(rr, rtt, DepLibUV::GetTimeMsInt64());
+					this->tccClient->ReceiveRtcpReceiverReport(rr, rtt, this->shared->GetTimeMsInt64());
 				}
 
 				break;
@@ -2553,12 +2491,12 @@ namespace RTC
 
 		// TODO: Missing trace info (RTP packet dump).
 		auto notification = FBS::Transport::CreateTraceNotification(
-		  this->shared->channelNotifier->GetBufferBuilder(),
+		  this->shared->GetChannelNotifier()->GetBufferBuilder(),
 		  FBS::Transport::TraceEventType::PROBATION,
-		  DepLibUV::GetTimeMs(),
+		  this->shared->GetTimeMs(),
 		  FBS::Common::TraceDirection::DIRECTION_OUT);
 
-		this->shared->channelNotifier->Emit(
+		this->shared->GetChannelNotifier()->Emit(
 		  this->id,
 		  FBS::Notification::Event::TRANSPORT_TRACE,
 		  FBS::Notification::Body::Transport_TraceNotification,
@@ -2576,7 +2514,7 @@ namespace RTC
 		}
 
 		auto traceInfo = FBS::Transport::CreateBweTraceInfo(
-		  this->shared->channelNotifier->GetBufferBuilder(),
+		  this->shared->GetChannelNotifier()->GetBufferBuilder(),
 		  this->tccClient->GetBweType() == RTC::BweType::TRANSPORT_CC
 		    ? FBS::Transport::BweType::TRANSPORT_CC
 		    : FBS::Transport::BweType::REMB,
@@ -2589,14 +2527,14 @@ namespace RTC
 		  bitrates.availableBitrate);
 
 		auto notification = FBS::Transport::CreateTraceNotification(
-		  this->shared->channelNotifier->GetBufferBuilder(),
+		  this->shared->GetChannelNotifier()->GetBufferBuilder(),
 		  FBS::Transport::TraceEventType::BWE,
-		  DepLibUV::GetTimeMs(),
+		  this->shared->GetTimeMs(),
 		  FBS::Common::TraceDirection::DIRECTION_OUT,
 		  FBS::Transport::TraceInfo::BweTraceInfo,
 		  traceInfo.Union());
 
-		this->shared->channelNotifier->Emit(
+		this->shared->GetChannelNotifier()->Emit(
 		  this->id,
 		  FBS::Notification::Event::TRANSPORT_TRACE,
 		  FBS::Notification::Body::Transport_TraceNotification,
@@ -2674,7 +2612,7 @@ namespace RTC
 #endif
 
 		// Update abs-send-time if present.
-		packet->UpdateAbsSendTime(DepLibUV::GetTimeMs());
+		packet->UpdateAbsSendTime(this->shared->GetTimeMs());
 
 		// Update transport wide sequence number if present.
 		if (
@@ -2702,16 +2640,18 @@ namespace RTC
 			// send callbacks.
 			const std::weak_ptr<RTC::TransportCongestionControlClient> tccClientWeakPtr(this->tccClient);
 
+			auto* shared = this->shared;
+
 #ifdef ENABLE_RTC_SENDER_BANDWIDTH_ESTIMATOR
 			std::weak_ptr<RTC::SenderBandwidthEstimator> senderBweWeakPtr(this->senderBwe);
 			RTC::SenderBandwidthEstimator::SentInfo sentInfo;
 
 			sentInfo.wideSeq     = this->transportWideCcSeq;
 			sentInfo.size        = packet->GetLength();
-			sentInfo.sendingAtMs = DepLibUV::GetTimeMs();
+			sentInfo.sendingAtMs = this->shared->GetTimeMs();
 
-			auto* cb = new onSendCallback(
-			  [tccClientWeakPtr, packetInfo, senderBweWeakPtr, sentInfo](bool sent)
+			const auto* cb = new onSendCallback(
+			  [tccClientWeakPtr, shared, packetInfo, senderBweWeakPtr, sentInfo](bool sent) mutable
 			  {
 				  if (sent)
 				  {
@@ -2719,14 +2659,14 @@ namespace RTC
 
 					  if (tccClient)
 					  {
-						  tccClient->PacketSent(packetInfo, DepLibUV::GetTimeMsInt64());
+						  tccClient->PacketSent(packetInfo, shared->GetTimeMsInt64());
 					  }
 
 					  auto senderBwe = senderBweWeakPtr.lock();
 
 					  if (senderBwe)
 					  {
-						  sentInfo.sentAtMs = DepLibUV::GetTimeMs();
+						  sentInfo.sentAtMs = shared->GetTimeMs();
 						  senderBwe->RtpPacketSent(sentInfo);
 					  }
 				  }
@@ -2735,7 +2675,7 @@ namespace RTC
 			SendRtpPacket(consumer, packet, cb);
 #else
 			const auto* cb = new onSendCallback(
-			  [tccClientWeakPtr, packetInfo](bool sent)
+			  [tccClientWeakPtr, shared, packetInfo](bool sent)
 			  {
 				  if (sent)
 				  {
@@ -2743,7 +2683,7 @@ namespace RTC
 
 					  if (tccClient)
 					  {
-						  tccClient->PacketSent(packetInfo, DepLibUV::GetTimeMsInt64());
+						  tccClient->PacketSent(packetInfo, shared->GetTimeMsInt64());
 					  }
 				  }
 			  });
@@ -2764,7 +2704,7 @@ namespace RTC
 		MS_TRACE();
 
 		// Update abs-send-time if present.
-		packet->UpdateAbsSendTime(DepLibUV::GetTimeMs());
+		packet->UpdateAbsSendTime(this->shared->GetTimeMs());
 
 		// Update transport wide sequence number if present.
 		if (
@@ -2787,16 +2727,18 @@ namespace RTC
 
 			const std::weak_ptr<RTC::TransportCongestionControlClient> tccClientWeakPtr(this->tccClient);
 
+			auto* shared = this->shared;
+
 #ifdef ENABLE_RTC_SENDER_BANDWIDTH_ESTIMATOR
 			std::weak_ptr<RTC::SenderBandwidthEstimator> senderBweWeakPtr = this->senderBwe;
 			RTC::SenderBandwidthEstimator::SentInfo sentInfo;
 
 			sentInfo.wideSeq     = this->transportWideCcSeq;
 			sentInfo.size        = packet->GetLength();
-			sentInfo.sendingAtMs = DepLibUV::GetTimeMs();
+			sentInfo.sendingAtMs = this->shared->GetTimeMs();
 
-			auto* cb = new onSendCallback(
-			  [tccClientWeakPtr, packetInfo, senderBweWeakPtr, sentInfo](bool sent)
+			const auto* cb = new onSendCallback(
+			  [tccClientWeakPtr, shared, packetInfo, senderBweWeakPtr, sentInfo](bool sent) mutable
 			  {
 				  if (sent)
 				  {
@@ -2804,14 +2746,14 @@ namespace RTC
 
 					  if (tccClient)
 					  {
-						  tccClient->PacketSent(packetInfo, DepLibUV::GetTimeMsInt64());
+						  tccClient->PacketSent(packetInfo, shared->GetTimeMsInt64());
 					  }
 
 					  auto senderBwe = senderBweWeakPtr.lock();
 
 					  if (senderBwe)
 					  {
-						  sentInfo.sentAtMs = DepLibUV::GetTimeMs();
+						  sentInfo.sentAtMs = shared->GetTimeMs();
 						  senderBwe->RtpPacketSent(sentInfo);
 					  }
 				  }
@@ -2820,7 +2762,7 @@ namespace RTC
 			SendRtpPacket(consumer, packet, cb);
 #else
 			const auto* cb = new onSendCallback(
-			  [tccClientWeakPtr, packetInfo](bool sent)
+			  [tccClientWeakPtr, shared, packetInfo](bool sent)
 			  {
 				  if (sent)
 				  {
@@ -2828,7 +2770,7 @@ namespace RTC
 
 					  if (tccClient)
 					  {
-						  tccClient->PacketSent(packetInfo, DepLibUV::GetTimeMsInt64());
+						  tccClient->PacketSent(packetInfo, shared->GetTimeMsInt64());
 					  }
 				  }
 			  });
@@ -2906,6 +2848,8 @@ namespace RTC
 		// Notify the listener.
 		this->listener->OnTransportConsumerProducerClosed(this, consumer);
 
+		MS_DEBUG_DEV("Consumer closed [consumerId:%s]", consumer->id.c_str());
+
 		// Delete it.
 		delete consumer;
 
@@ -2918,16 +2862,14 @@ namespace RTC
 
 	void Transport::OnDataProducerMessageReceived(
 	  RTC::DataProducer* dataProducer,
-	  const uint8_t* msg,
-	  size_t len,
-	  uint32_t ppid,
+	  RTC::SCTP::Message message,
 	  std::vector<uint16_t>& subchannels,
 	  std::optional<uint16_t> requiredSubchannel)
 	{
 		MS_TRACE();
 
 		this->listener->OnTransportDataProducerMessageReceived(
-		  this, dataProducer, msg, len, ppid, subchannels, requiredSubchannel);
+		  this, dataProducer, std::move(message), subchannels, requiredSubchannel);
 	}
 
 	void Transport::OnDataProducerPaused(RTC::DataProducer* dataProducer)
@@ -2945,35 +2887,56 @@ namespace RTC
 	}
 
 	void Transport::OnDataConsumerSendMessage(
-	  RTC::DataConsumer* dataConsumer, const uint8_t* msg, size_t len, uint32_t ppid, onQueuedCallback* cb)
+	  RTC::DataConsumer* dataConsumer, RTC::SCTP::Message message, onQueuedCallback* cb)
 	{
 		MS_TRACE();
 
-		SendMessage(dataConsumer, msg, len, ppid, cb);
+		SendMessage(dataConsumer, std::move(message), cb);
 	}
 
 	void Transport::OnDataConsumerNeedBufferedAmount(
-	  RTC::DataConsumer* /*dataConsumer*/, uint32_t& bufferedAmount)
+	  const RTC::DataConsumer* dataConsumer, uint32_t& bufferedAmount) const
 	{
 		MS_TRACE();
 
-		if (Settings::configuration.useBuiltInSctpStack && this->sctpAssociation)
+		if (this->sctpAssociation)
+		{
+			bufferedAmount = static_cast<uint32_t>(this->sctpAssociation->GetStreamBufferedAmount(
+			  dataConsumer->GetSctpStreamParameters().streamId));
+		}
+		else
 		{
-			// TODO: SCTP
-			// TODO: Let's see how to obtain `streamId` argument from the DataConsumer.
-			// bufferedAmount = this->sctpAssociation->GetStreamBufferedAmount(streamId);
+			bufferedAmount = 0;
 		}
-		// TODO: Remove once we only use built-in SCTP stack.
-		else if (!Settings::configuration.useBuiltInSctpStack && this->oldSctpAssociation)
+	}
+
+	void Transport::OnDataConsumerNeedBufferedAmountLowThreshold(
+	  const RTC::DataConsumer* dataConsumer, uint32_t& bufferedAmountLowThreshold) const
+	{
+		if (this->sctpAssociation)
 		{
-			// 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();
+			bufferedAmountLowThreshold =
+			  static_cast<uint32_t>(this->sctpAssociation->GetStreamBufferedAmountLowThreshold(
+			    dataConsumer->GetSctpStreamParameters().streamId));
 		}
 		else
 		{
-			bufferedAmount = 0;
+			bufferedAmountLowThreshold = 0;
+		}
+	}
+
+	void Transport::OnDataConsumerSetBufferedAmountLowThreshold(
+	  const RTC::DataConsumer* dataConsumer, uint32_t bytes) const
+	{
+		MS_TRACE();
+
+		MS_ASSERT(
+		  dataConsumer->GetType() == RTC::DataConsumer::Type::SCTP, "DataConsumer must have type SCTP");
+
+		if (this->sctpAssociation)
+		{
+			this->sctpAssociation->SetStreamBufferedAmountLowThreshold(
+			  dataConsumer->GetSctpStreamParameters().streamId, static_cast<size_t>(bytes));
 		}
 	}
 
@@ -2984,26 +2947,22 @@ namespace RTC
 		// Remove it from the maps.
 		this->mapDataConsumers.erase(dataConsumer->id);
 
-		// Notify the listener.
-		this->listener->OnTransportDataConsumerDataProducerClosed(this, dataConsumer);
-
-		if (Settings::configuration.useBuiltInSctpStack)
+		if (dataConsumer->GetType() == RTC::DataConsumer::Type::SCTP)
 		{
-			if (this->sctpAssociation && dataConsumer->GetType() == RTC::DataConsumer::Type::SCTP)
-			{
-				// TODO: SCTP
-			}
+			this->mapSctpStreamIdDataConsumers.erase(dataConsumer->GetSctpStreamParameters().streamId);
 		}
-		// TODO: Remove once we only use built-in SCTP stack.
-		else
+
+		if (this->sctpAssociation)
 		{
-			if (this->oldSctpAssociation && dataConsumer->GetType() == RTC::DataConsumer::Type::SCTP)
-			{
-				// Tell the SctpAssociation so it can reset the SCTP stream.
-				this->oldSctpAssociation->DataConsumerClosed(dataConsumer);
-			}
+			this->sctpAssociation->ResetStreams(
+			  std::array<uint16_t, 1>{ dataConsumer->GetSctpStreamParameters().streamId });
 		}
 
+		// Notify the listener.
+		this->listener->OnTransportDataConsumerDataProducerClosed(this, dataConsumer);
+
+		MS_DEBUG_DEV("DataConsumer closed [dataConsumerId:%s]", dataConsumer->id.c_str());
+
 		// Delete it.
 		delete dataConsumer;
 	}
@@ -3015,15 +2974,15 @@ namespace RTC
 		// 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)
+		// and we would end here calling SendData() which is an abstract method.
+		if (this->isDestroying)
 		{
 			MS_WARN_DEV("ignoring sending data because Transport is being destroying");
 
 			return false;
 		}
 
-		return SendSctpData(data, len);
+		return SendData(data, len);
 	}
 
 	void Transport::OnAssociationConnecting()
@@ -3031,14 +2990,15 @@ namespace RTC
 		MS_TRACE();
 
 		// Notify the Node Transport.
-		auto sctpStateChangeOffset = FBS::Transport::CreateSctpStateChangeNotification(
-		  this->shared->channelNotifier->GetBufferBuilder(), FBS::SctpAssociation::SctpState::CONNECTING);
+		auto sctpStateChangeNotification = FBS::Transport::CreateSctpStateChangeNotification(
+		  this->shared->GetChannelNotifier()->GetBufferBuilder(),
+		  FBS::SctpAssociation::SctpState::CONNECTING);
 
-		this->shared->channelNotifier->Emit(
+		this->shared->GetChannelNotifier()->Emit(
 		  this->id,
 		  FBS::Notification::Event::TRANSPORT_SCTP_STATE_CHANGE,
 		  FBS::Notification::Body::Transport_SctpStateChangeNotification,
-		  sctpStateChangeOffset);
+		  sctpStateChangeNotification);
 	}
 
 	void Transport::OnAssociationConnected()
@@ -3056,26 +3016,56 @@ namespace RTC
 			}
 		}
 
-		// Notify the Node Transport.
-		auto sctpStateChangeOffset = FBS::Transport::CreateSctpStateChangeNotification(
-		  this->shared->channelNotifier->GetBufferBuilder(), FBS::SctpAssociation::SctpState::CONNECTED);
+		// Notify the upper layer.
 
-		this->shared->channelNotifier->Emit(
+		// First tell it about the SCTP negotiated capabilities.
+		auto sctpNegotiatedCapabilitiesOffset = FBS::SctpAssociation::CreateSctpNegotiatedCapabilities(
+		  this->shared->GetChannelNotifier()->GetBufferBuilder(),
+		  this->sctpAssociation->GetNegotiatedMaxOutboundStreams(),
+		  this->sctpAssociation->GetNegotiatedMaxInboundStreams());
+
+		auto sctpNegotiatedCapabilitiesNotification =
+		  FBS::Transport::CreateSctpNegotiatedCapabilitiesNotification(
+		    this->shared->GetChannelNotifier()->GetBufferBuilder(), sctpNegotiatedCapabilitiesOffset);
+
+		this->shared->GetChannelNotifier()->Emit(
+		  this->id,
+		  FBS::Notification::Event::TRANSPORT_SCTP_NEGOTIATED_CAPABILITIES,
+		  FBS::Notification::Body::Transport_SctpNegotiatedCapabilitiesNotification,
+		  sctpNegotiatedCapabilitiesNotification);
+
+		// Then announce "connected" SCTP state.
+		auto sctpStateChangeNotification = FBS::Transport::CreateSctpStateChangeNotification(
+		  this->shared->GetChannelNotifier()->GetBufferBuilder(),
+		  FBS::SctpAssociation::SctpState::CONNECTED);
+
+		this->shared->GetChannelNotifier()->Emit(
 		  this->id,
 		  FBS::Notification::Event::TRANSPORT_SCTP_STATE_CHANGE,
 		  FBS::Notification::Body::Transport_SctpStateChangeNotification,
-		  sctpStateChangeOffset);
+		  sctpStateChangeNotification);
 
-		// TODO: SCTP: REMOVE
-		MS_DUMP("---- SCTP Association connected, dump():");
+// For debugging purposes.
+#if MS_LOG_DEV_LEVEL == 3
+		MS_DUMP("--- SCTP association connected:");
 		this->sctpAssociation->Dump();
+#endif
 	}
 
-	void Transport::OnAssociationFailed(
-	  RTC::SCTP::Types::ErrorKind /*errorKind*/, std::string_view /*errorMessage*/)
+	void Transport::OnAssociationFailed(RTC::SCTP::Types::ErrorKind errorKind, std::string_view errorMessage)
 	{
 		MS_TRACE();
 
+		const auto errorKindStringView = RTC::SCTP::Types::ErrorKindToString(errorKind);
+
+		MS_WARN_TAG(
+		  sctp,
+		  "SCTP association failed [errorKind:%.*s, message:%.*s]",
+		  static_cast<int>(errorKindStringView.size()),
+		  errorKindStringView.data(),
+		  static_cast<int>(errorMessage.size()),
+		  errorMessage.data());
+
 		// Tell all DataConsumers.
 		for (auto& kv : this->mapDataConsumers)
 		{
@@ -3088,21 +3078,34 @@ namespace RTC
 		}
 
 		// Notify the Node Transport.
-		auto sctpStateChangeOffset = FBS::Transport::CreateSctpStateChangeNotification(
-		  this->shared->channelNotifier->GetBufferBuilder(), FBS::SctpAssociation::SctpState::FAILED);
+		auto sctpStateChangeNotification = FBS::Transport::CreateSctpStateChangeNotification(
+		  this->shared->GetChannelNotifier()->GetBufferBuilder(),
+		  FBS::SctpAssociation::SctpState::FAILED);
 
-		this->shared->channelNotifier->Emit(
+		this->shared->GetChannelNotifier()->Emit(
 		  this->id,
 		  FBS::Notification::Event::TRANSPORT_SCTP_STATE_CHANGE,
 		  FBS::Notification::Body::Transport_SctpStateChangeNotification,
-		  sctpStateChangeOffset);
+		  sctpStateChangeNotification);
 	}
 
-	void Transport::OnAssociationClosed(
-	  RTC::SCTP::Types::ErrorKind /*errorKind*/, std::string_view /*errorMessage*/)
+	void Transport::OnAssociationClosed(RTC::SCTP::Types::ErrorKind errorKind, std::string_view errorMessage)
 	{
 		MS_TRACE();
 
+		if (errorKind != RTC::SCTP::Types::ErrorKind::SUCCESS)
+		{
+			const auto errorKindStringView = RTC::SCTP::Types::ErrorKindToString(errorKind);
+
+			MS_WARN_TAG(
+			  sctp,
+			  "SCTP association closed [errorKind:%.*s, message:%.*s]",
+			  static_cast<int>(errorKindStringView.size()),
+			  errorKindStringView.data(),
+			  static_cast<int>(errorMessage.size()),
+			  errorMessage.data());
+		}
+
 		// Tell all DataConsumers.
 		for (auto& kv : this->mapDataConsumers)
 		{
@@ -3115,21 +3118,22 @@ namespace RTC
 		}
 
 		// Notify the Node Transport.
-		auto sctpStateChangeOffset = FBS::Transport::CreateSctpStateChangeNotification(
-		  this->shared->channelNotifier->GetBufferBuilder(), FBS::SctpAssociation::SctpState::CLOSED);
+		auto sctpStateChangeNotification = FBS::Transport::CreateSctpStateChangeNotification(
+		  this->shared->GetChannelNotifier()->GetBufferBuilder(),
+		  FBS::SctpAssociation::SctpState::CLOSED);
 
-		this->shared->channelNotifier->Emit(
+		this->shared->GetChannelNotifier()->Emit(
 		  this->id,
 		  FBS::Notification::Event::TRANSPORT_SCTP_STATE_CHANGE,
 		  FBS::Notification::Body::Transport_SctpStateChangeNotification,
-		  sctpStateChangeOffset);
+		  sctpStateChangeNotification);
 	}
 
 	void Transport::OnAssociationRestarted()
 	{
 		MS_TRACE();
 
-		// TODO: SCTP
+		MS_DEBUG_TAG(sctp, "SCTP association restarted");
 	}
 
 	void Transport::OnAssociationError(RTC::SCTP::Types::ErrorKind errorKind, std::string_view errorMessage)
@@ -3140,236 +3144,164 @@ namespace RTC
 
 		MS_WARN_TAG(
 		  sctp,
-		  "SCTP Association error [kind:%.*s, message:%.*s]",
+		  "SCTP association error [errorKind:%.*s, message:%.*s]",
 		  static_cast<int>(errorKindStringView.size()),
 		  errorKindStringView.data(),
 		  static_cast<int>(errorMessage.size()),
 		  errorMessage.data());
 	}
 
-	void Transport::OnAssociationMessageReceived(RTC::SCTP::Message /*message*/)
-	{
-		MS_TRACE();
-
-		// TODO: SCTP
-	}
-
-	void Transport::OnAssociationStreamsResetPerformed(std::span<const uint16_t> /*outboundStreamIds*/)
+	void Transport::OnAssociationMessageReceived(RTC::SCTP::Message message)
 	{
 		MS_TRACE();
 
-		// TODO: SCTP
-	}
+		RTC::DataProducer* dataProducer = this->sctpListener.GetDataProducer(message.GetStreamId());
 
-	void Transport::OnAssociationStreamsResetFailed(
-	  std::span<const uint16_t> /*outboundStreamIds*/, std::string_view /*errorMessage*/)
-	{
-		MS_TRACE();
+		if (!dataProducer)
+		{
+			MS_WARN_TAG(
+			  sctp,
+			  "no suitable DataProducer for received SCTP message [streamId:%" PRIu16 "]",
+			  message.GetStreamId());
 
-		// TODO: SCTP
-	}
+			return;
+		}
 
-	void Transport::OnAssociationInboundStreamsReset(std::span<const uint16_t> /*inboundStreamIds*/)
-	{
-		MS_TRACE();
+		// Pass the SCTP message to the corresponding DataProducer.
+		try
+		{
+			static thread_local std::vector<uint16_t> emptySubchannels;
 
-		// TODO: SCTP
+			dataProducer->ReceiveMessage(
+			  std::move(message), emptySubchannels, /*requiredSubchannel*/ std::nullopt);
+		}
+		catch (std::exception& error)
+		{
+			MS_WARN_TAG(
+			  sctp,
+			  "DataProducer::ReceiveMessage() failed for received SCTP message [streamId:%" PRIu16 "]: %s",
+			  message.GetStreamId(),
+			  error.what());
+		}
 	}
 
-	void Transport::OnAssociationStreamBufferedAmountLow(uint16_t /*streamId*/)
+	void Transport::OnAssociationStreamsResetPerformed(std::span<const uint16_t> /*outboundStreamIds*/)
 	{
 		MS_TRACE();
 
-		// TODO: SCTP
+		MS_DEBUG_DEV("SCTP association streams reset performed");
 	}
 
-	void Transport::OnAssociationTotalBufferedAmountLow()
+	void Transport::OnAssociationStreamsResetFailed(
+	  std::span<const uint16_t> /*outboundStreamIds*/, std::string_view errorMessage)
 	{
 		MS_TRACE();
 
-		// TODO: SCTP
+		MS_WARN_TAG(
+		  sctp,
+		  "SCTP association streams reset failed [message:%.*s]",
+		  static_cast<int>(errorMessage.size()),
+		  errorMessage.data());
 	}
 
-	bool Transport::OnAssociationIsTransportReadyForSctp()
+	void Transport::OnAssociationInboundStreamsReset(std::span<const uint16_t> inboundStreamIds)
 	{
 		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.
+		// https://datatracker.ietf.org/doc/html/rfc8831#section-6.7
 		//
-		// 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.
-
-	void Transport::OnSctpAssociationConnecting(RTC::SctpAssociation* /*sctpAssociation*/)
-	{
-		MS_TRACE();
-
-		// Notify the Node Transport.
-		auto sctpStateChangeOffset = FBS::Transport::CreateSctpStateChangeNotification(
-		  this->shared->channelNotifier->GetBufferBuilder(), FBS::SctpAssociation::SctpState::CONNECTING);
-
-		this->shared->channelNotifier->Emit(
-		  this->id,
-		  FBS::Notification::Event::TRANSPORT_SCTP_STATE_CHANGE,
-		  FBS::Notification::Body::Transport_SctpStateChangeNotification,
-		  sctpStateChangeOffset);
-	}
-
-	void Transport::OnSctpAssociationConnected(RTC::SctpAssociation* /*sctpAssociation*/)
-	{
-		MS_TRACE();
-
-		// Tell all DataConsumers.
-		for (auto& kv : this->mapDataConsumers)
+		// "Closing of a data channel MUST be signaled by resetting the corresponding
+		// outgoing streams [RFC6525]. This means that if one side decides to close
+		// the data channel, it resets the corresponding outgoing stream. When the
+		// peer sees that an incoming stream was reset, it also resets its
+		// corresponding outgoing stream."
+		if (this->sctpAssociation->IsDataChannel())
 		{
-			auto* dataConsumer = kv.second;
+			std::vector<RTC::DataConsumer*> dataConsumersToClose;
+			std::vector<uint16_t> streamsToReset;
 
-			if (dataConsumer->GetType() == RTC::DataConsumer::Type::SCTP)
+			for (const auto streamId : inboundStreamIds)
 			{
-				dataConsumer->SctpAssociationConnected();
-			}
-		}
-
-		// Notify the Node Transport.
-		auto sctpStateChangeOffset = FBS::Transport::CreateSctpStateChangeNotification(
-		  this->shared->channelNotifier->GetBufferBuilder(), FBS::SctpAssociation::SctpState::CONNECTED);
+				// Only reset the outgoing stream if there is a live DataConsumer
+				// using it. If the DataChannel was closed by the app, the DataConsumer
+				// will have already been closed and removed.
+				const auto it = this->mapSctpStreamIdDataConsumers.find(streamId);
 
-		this->shared->channelNotifier->Emit(
-		  this->id,
-		  FBS::Notification::Event::TRANSPORT_SCTP_STATE_CHANGE,
-		  FBS::Notification::Body::Transport_SctpStateChangeNotification,
-		  sctpStateChangeOffset);
-	}
-
-	void Transport::OnSctpAssociationFailed(RTC::SctpAssociation* /*sctpAssociation*/)
-	{
-		MS_TRACE();
+				if (it != this->mapSctpStreamIdDataConsumers.end())
+				{
+					auto* dataConsumer = it->second;
 
-		// Tell all DataConsumers.
-		for (auto& kv : this->mapDataConsumers)
-		{
-			auto* dataConsumer = kv.second;
+					dataConsumersToClose.push_back(dataConsumer);
+					streamsToReset.push_back(streamId);
+				}
+			}
 
-			if (dataConsumer->GetType() == RTC::DataConsumer::Type::SCTP)
+			if (!dataConsumersToClose.empty())
 			{
-				dataConsumer->SctpAssociationClosed();
-			}
-		}
+				this->sctpAssociation->ResetStreams(streamsToReset);
 
-		// Notify the Node Transport.
-		auto sctpStateChangeOffset = FBS::Transport::CreateSctpStateChangeNotification(
-		  this->shared->channelNotifier->GetBufferBuilder(), FBS::SctpAssociation::SctpState::FAILED);
+				for (auto* dataConsumer : dataConsumersToClose)
+				{
+					// Remove it from the maps.
+					this->mapDataConsumers.erase(dataConsumer->id);
 
-		this->shared->channelNotifier->Emit(
-		  this->id,
-		  FBS::Notification::Event::TRANSPORT_SCTP_STATE_CHANGE,
-		  FBS::Notification::Body::Transport_SctpStateChangeNotification,
-		  sctpStateChangeOffset);
-	}
+					if (dataConsumer->GetType() == RTC::DataConsumer::Type::SCTP)
+					{
+						this->mapSctpStreamIdDataConsumers.erase(dataConsumer->GetSctpStreamParameters().streamId);
+					}
 
-	void Transport::OnSctpAssociationClosed(RTC::SctpAssociation* /*sctpAssociation*/)
-	{
-		MS_TRACE();
+					// Notify the listener.
+					this->listener->OnTransportDataConsumerClosed(this, dataConsumer);
 
-		// Tell all DataConsumers.
-		for (auto& kv : this->mapDataConsumers)
-		{
-			auto* dataConsumer = kv.second;
+					MS_DEBUG_DEV(
+					  "SCTP DataConsumer closed via SCTP inbound stream reset [dataConsumerId:%s, streamId:%" PRIu16
+					  "]",
+					  dataConsumer->id.c_str(),
+					  dataConsumer->GetSctpStreamParameters().streamId);
 
-			if (dataConsumer->GetType() == RTC::DataConsumer::Type::SCTP)
-			{
-				dataConsumer->SctpAssociationClosed();
+					// Delete it.
+					delete dataConsumer;
+				}
 			}
 		}
-
-		// Notify the Node Transport.
-		auto sctpStateChangeOffset = FBS::Transport::CreateSctpStateChangeNotification(
-		  this->shared->channelNotifier->GetBufferBuilder(), FBS::SctpAssociation::SctpState::CLOSED);
-
-		this->shared->channelNotifier->Emit(
-		  this->id,
-		  FBS::Notification::Event::TRANSPORT_SCTP_STATE_CHANGE,
-		  FBS::Notification::Body::Transport_SctpStateChangeNotification,
-		  sctpStateChangeOffset);
 	}
 
-	void Transport::OnSctpAssociationSendData(
-	  RTC::SctpAssociation* /*sctpAssociation*/, const uint8_t* data, size_t len)
+	void Transport::OnAssociationStreamBufferedAmountLow(uint16_t streamId)
 	{
 		MS_TRACE();
 
-		// 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)
-		{
-			MS_WARN_DEV("ignoring sending data because Transport is being destroying");
+		const auto* dataConsumer = GetSctpDataConsumerByStreamId(streamId);
 
+		if (!dataConsumer)
+		{
 			return;
 		}
 
-		SendSctpData(data, len);
+		dataConsumer->SctpBufferedAmountLow(this->sctpAssociation->GetStreamBufferedAmount(streamId));
 	}
 
-	void Transport::OnSctpAssociationMessageReceived(
-	  RTC::SctpAssociation* /*sctpAssociation*/,
-	  uint16_t streamId,
-	  const uint8_t* msg,
-	  size_t len,
-	  uint32_t ppid)
+	void Transport::OnAssociationTotalBufferedAmountLow()
 	{
 		MS_TRACE();
 
-		RTC::DataProducer* dataProducer = this->sctpListener.GetDataProducer(streamId);
-
-		if (!dataProducer)
-		{
-			MS_WARN_TAG(
-			  sctp, "no suitable DataProducer for received SCTP message [streamId:%" PRIu16 "]", streamId);
-
-			return;
-		}
-
-		// Pass the SCTP message to the corresponding DataProducer.
-		try
-		{
-			static std::vector<uint16_t> emptySubchannels;
-
-			dataProducer->ReceiveMessage(
-			  msg, len, ppid, emptySubchannels, /*requiredSubchannel*/ std::nullopt);
-		}
-		catch (std::exception& error)
-		{
-			MS_WARN_TAG(
-			  sctp,
-			  "DataProducer::ReceiveMessage() failed for received SCTP message [streamId:%" PRIu16 "]: %s",
-			  streamId,
-			  error.what());
-		}
+		// TODO: SCTP: Here we should emit a new event to the upper layer saying
+		// that the transport SCTP total buffered amount is low. However we don't
+		// expose `SctpOptions::totalBufferedAmountLowThreshold` to Transport.
 	}
 
-	void Transport::OnSctpAssociationBufferedAmount(
-	  RTC::SctpAssociation* /*sctpAssociation*/, uint32_t bufferedAmount)
+	bool Transport::OnAssociationIsTransportReadyForSctp()
 	{
 		MS_TRACE();
 
-		for (const auto& kv : this->mapDataConsumers)
-		{
-			auto* dataConsumer = kv.second;
-
-			if (dataConsumer->GetType() == RTC::DataConsumer::Type::SCTP)
-			{
-				dataConsumer->SetSctpAssociationBufferedAmount(bufferedAmount);
-			}
-		}
+		// 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.empty() || !this->mapDataConsumers.empty());
 	}
 
 	void Transport::OnTransportCongestionControlClientBitrates(
@@ -3395,7 +3327,7 @@ namespace RTC
 		MS_TRACE();
 
 		// Update abs-send-time if present.
-		packet->UpdateAbsSendTime(DepLibUV::GetTimeMs());
+		packet->UpdateAbsSendTime(this->shared->GetTimeMs());
 
 		// Update transport wide sequence number if present.
 		if (
@@ -3421,6 +3353,8 @@ namespace RTC
 
 			const std::weak_ptr<RTC::TransportCongestionControlClient> tccClientWeakPtr(this->tccClient);
 
+			auto* shared = this->shared;
+
 #ifdef ENABLE_RTC_SENDER_BANDWIDTH_ESTIMATOR
 			std::weak_ptr<RTC::SenderBandwidthEstimator> senderBweWeakPtr = this->senderBwe;
 			RTC::SenderBandwidthEstimator::SentInfo sentInfo;
@@ -3428,10 +3362,10 @@ namespace RTC
 			sentInfo.wideSeq     = this->transportWideCcSeq;
 			sentInfo.size        = packet->GetLength();
 			sentInfo.isProbation = true;
-			sentInfo.sendingAtMs = DepLibUV::GetTimeMs();
+			sentInfo.sendingAtMs = this->shared->GetTimeMs();
 
-			auto* cb = new onSendCallback(
-			  [tccClientWeakPtr, packetInfo, senderBweWeakPtr, sentInfo](bool sent)
+			const auto* cb = new onSendCallback(
+			  [tccClientWeakPtr, shared, packetInfo, senderBweWeakPtr, sentInfo](bool sent) mutable
 			  {
 				  if (sent)
 				  {
@@ -3439,14 +3373,14 @@ namespace RTC
 
 					  if (tccClient)
 					  {
-						  tccClient->PacketSent(packetInfo, DepLibUV::GetTimeMsInt64());
+						  tccClient->PacketSent(packetInfo, shared->GetTimeMsInt64());
 					  }
 
 					  auto senderBwe = senderBweWeakPtr.lock();
 
 					  if (senderBwe)
 					  {
-						  sentInfo.sentAtMs = DepLibUV::GetTimeMs();
+						  sentInfo.sentAtMs = shared->GetTimeMs();
 						  senderBwe->RtpPacketSent(sentInfo);
 					  }
 				  }
@@ -3455,7 +3389,7 @@ namespace RTC
 			SendRtpPacket(nullptr, packet, cb);
 #else
 			const auto* cb = new onSendCallback(
-			  [tccClientWeakPtr, packetInfo](bool sent)
+			  [tccClientWeakPtr, shared, packetInfo](bool sent)
 			  {
 				  if (sent)
 				  {
@@ -3463,7 +3397,7 @@ namespace RTC
 
 					  if (tccClient)
 					  {
-						  tccClient->PacketSent(packetInfo, DepLibUV::GetTimeMsInt64());
+						  tccClient->PacketSent(packetInfo, shared->GetTimeMsInt64());
 					  }
 				  }
 			  });
@@ -3486,7 +3420,7 @@ namespace RTC
 		  packet->GetSequenceNumber(),
 		  this->transportWideCcSeq,
 		  packet->GetLength(),
-		  this->sendProbationTransmission.GetBitrate(DepLibUV::GetTimeMs()));
+		  this->sendProbationTransmission.GetBitrate(this->shared->GetTimeMs()));
 	}
 
 	void Transport::OnTransportCongestionControlServerSendRtcpPacket(
@@ -3518,7 +3452,7 @@ namespace RTC
 	}
 #endif
 
-	void Transport::OnTimer(TimerHandle* timer)
+	void Transport::OnTimer(TimerHandleInterface* timer)
 	{
 		MS_TRACE();
 
@@ -3526,7 +3460,7 @@ namespace RTC
 		if (timer == this->rtcpTimer)
 		{
 			auto interval        = static_cast<uint64_t>(RTC::RTCP::MaxVideoIntervalMs);
-			const uint64_t nowMs = DepLibUV::GetTimeMs();
+			const uint64_t nowMs = this->shared->GetTimeMs();
 
 			SendRtcp(nowMs);