mediasoup 3.19.21 → 3.20.0

package/worker/src/RTC/SCTP/association/Association.cpp

@@ -1,12 +1,8 @@
 #define MS_CLASS "RTC::SCTP::Association"
-// TODO: SCTP: COMMENT
-#define MS_LOG_DEV_LEVEL 3
+// #define MS_LOG_DEV_LEVEL 3
 
 #include "RTC/SCTP/association/Association.hpp"
-#include "DepLibUV.hpp"
 #include "Logger.hpp"
-#include "Utils.hpp"
-#include "RTC/Consts.hpp"
 #include "RTC/SCTP/packet/errorCauses/CookieReceivedWhileShuttingDownErrorCause.hpp"
 #include "RTC/SCTP/packet/errorCauses/NoUserDataErrorCause.hpp"
 #include "RTC/SCTP/packet/errorCauses/OutOfResourceErrorCause.hpp"
@@ -17,6 +13,7 @@
 #include "RTC/SCTP/packet/parameters/StateCookieParameter.hpp"
 #include "RTC/SCTP/packet/parameters/SupportedExtensionsParameter.hpp"
 #include "RTC/SCTP/packet/parameters/ZeroChecksumAcceptableParameter.hpp"
+#include "Utils.hpp"
 #include <limits>  // std::numeric_limits()
 #include <sstream> // std::ostringstream
 #include <string>
@@ -28,7 +25,7 @@ namespace RTC
 	{
 		/* Static. */
 
-		alignas(4) thread_local static uint8_t PacketFactoryBuffer[RTC::Consts::MaxSafeMtuSizeForSctp];
+		alignas(4) static thread_local uint8_t PacketFactoryBuffer[65536];
 		// @see https://tools.ietf.org/html/rfc9260#section-5.1
 		constexpr uint32_t MinVerificationTag{ 1 };
 		constexpr uint32_t MaxVerificationTag{ std::numeric_limits<uint32_t>::max() };
@@ -39,33 +36,49 @@ namespace RTC
 
 		/* Instance methods. */
 
-		Association::Association(const SctpOptions& sctpOptions, AssociationListener* listener)
+		Association::Association(
+		  const SctpOptions& sctpOptions,
+		  AssociationListenerInterface* listener,
+		  SharedInterface* shared,
+		  bool isDataChannel)
 		  : sctpOptions(sctpOptions),
 		    // Our `listener` member is a `AssociationListenerDeferrer` which takes
-		    // `AssociationListener` as constructor argument.
-		    listener(listener),
-		    packetSender(this, this->listener),
-		    t1InitTimer(
-		      std::make_unique<BackoffTimerHandle>(
-		        /*listener*/ this,
-		        /*baseTimeoutMs*/ sctpOptions.t1InitTimeoutMs,
-		        /*backoffAlgorithm*/ BackoffTimerHandle::BackoffAlgorithm::EXPONENTIAL,
-		        /*maxBackoffTimeoutMs*/ sctpOptions.timerMaxBackoffTimeoutMs,
-		        /*maxRestarts*/ sctpOptions.maxInitRetransmissions)),
-		    t1CookieTimer(
-		      std::make_unique<BackoffTimerHandle>(
-		        /*listener*/ this,
-		        /*baseTimeoutMs*/ sctpOptions.t1CookieTimeoutMs,
-		        /*backoffAlgorithm*/ BackoffTimerHandle::BackoffAlgorithm::EXPONENTIAL,
-		        /*maxBackoffTimeoutMs*/ sctpOptions.timerMaxBackoffTimeoutMs,
-		        /*maxRestarts*/ sctpOptions.maxInitRetransmissions)),
-		    t2ShutdownTimer(
-		      std::make_unique<BackoffTimerHandle>(
-		        /*listener*/ this,
-		        /*baseTimeoutMs*/ sctpOptions.t2ShutdownTimeoutMs,
-		        /*backoffAlgorithm*/ BackoffTimerHandle::BackoffAlgorithm::EXPONENTIAL,
-		        /*maxBackoffTimeoutMs*/ sctpOptions.timerMaxBackoffTimeoutMs,
-		        /*maxRestarts*/ sctpOptions.maxRetransmissions))
+		    // `listener` argument as constructor argument.
+		    associationListenerDeferrer(listener),
+		    shared(shared),
+		    packetSender(this, this->associationListenerDeferrer),
+		    sendQueue(
+		      this->associationListenerDeferrer,
+		      sctpOptions.mtu,
+		      sctpOptions.defaultStreamPriority,
+		      sctpOptions.totalBufferedAmountLowThreshold),
+		    t1InitTimer(this->shared->CreateBackoffTimer(
+		      BackoffTimerHandleInterface::BackoffTimerHandleOptions{
+		        .listener            = this,
+		        .label               = "sctp-t1-init",
+		        .baseTimeoutMs       = sctpOptions.t1InitTimeoutMs,
+		        .backoffAlgorithm    = BackoffTimerHandleInterface::BackoffAlgorithm::EXPONENTIAL,
+		        .maxBackoffTimeoutMs = sctpOptions.timerMaxBackoffTimeoutMs,
+		        .maxRestarts         = sctpOptions.maxInitRetransmissions,
+		      })),
+		    t1CookieTimer(this->shared->CreateBackoffTimer(
+		      BackoffTimerHandleInterface::BackoffTimerHandleOptions{
+		        .listener            = this,
+		        .label               = "sctp-t1-cookie",
+		        .baseTimeoutMs       = sctpOptions.t1CookieTimeoutMs,
+		        .backoffAlgorithm    = BackoffTimerHandleInterface::BackoffAlgorithm::EXPONENTIAL,
+		        .maxBackoffTimeoutMs = sctpOptions.timerMaxBackoffTimeoutMs,
+		        .maxRestarts         = sctpOptions.maxInitRetransmissions })),
+		    t2ShutdownTimer(this->shared->CreateBackoffTimer(
+		      BackoffTimerHandleInterface::BackoffTimerHandleOptions{
+		        .listener            = this,
+		        .label               = "sctp-t2-shutdown",
+		        .baseTimeoutMs       = sctpOptions.t2ShutdownTimeoutMs,
+		        .backoffAlgorithm    = BackoffTimerHandleInterface::BackoffAlgorithm::EXPONENTIAL,
+		        .maxBackoffTimeoutMs = sctpOptions.timerMaxBackoffTimeoutMs,
+		        .maxRestarts         = sctpOptions.maxRetransmissions })),
+		    maxPacketLength(Utils::Byte::PadDownTo4Bytes(this->sctpOptions.mtu)),
+		    isDataChannel(isDataChannel)
 		{
 			MS_TRACE();
 		}
@@ -92,12 +105,14 @@ namespace RTC
 			  static_cast<int>(stateStringView.size()),
 			  stateStringView.data());
 
+			this->sctpOptions.Dump();
+
 			if (this->tcb)
 			{
 				this->tcb->Dump(indentation + 1);
 			}
 
-			const auto metrics = GetMetrics();
+			const auto metrics = MakeMetrics();
 
 			if (metrics.has_value())
 			{
@@ -114,26 +129,13 @@ namespace RTC
 
 			return FBS::SctpParameters::CreateSctpParameters(
 			  builder,
-			  // Add port.
-			  this->sctpOptions.sourcePort,
-			  // Add OS.
-			  // TODO: SCTP: We should put here current value which may be different after
-			  // negotiation with peer and reconfig.
-			  this->sctpOptions.announcedMaxOutboundStreams,
-			  // Add MIS.
-			  // TODO: SCTP: We should put here current value which may be different after
-			  // negotiation with peer and reconfig.
-			  this->sctpOptions.announcedMaxInboundStreams,
-			  // Add maxMessageSize.
-			  this->sctpOptions.maxSendMessageSize,
-			  // Add sendBufferSize.
-			  this->sctpOptions.maxSendBufferSize,
-			  // Add sctpBufferedAmountLowThreshold.
-			  this->sctpOptions.totalBufferedAmountLowThreshold,
-			  // Add isDataChannel.
-			  // TODO: SCTP: Have a member for this.
-			  // TODO: SCTP: So remove this hardcoded `true`.
-			  /*isDataChannel*/ true);
+			  /*port*/ this->sctpOptions.sourcePort,
+			  /*maxSendMessageSize*/ this->sctpOptions.maxSendMessageSize,
+			  /*maxReceiveMessageSize*/ this->sctpOptions.maxReceiveMessageSize,
+			  /*sctpSendBufferSize*/ this->sctpOptions.maxSendBufferSize,
+			  /*sctpPerStreamSendQueueLimit*/ this->sctpOptions.perStreamSendQueueLimit,
+			  /*sctpMaxReceiverWindowBufferSize*/ this->sctpOptions.maxReceiverWindowBufferSize,
+			  /*isDataChannel*/ this->isDataChannel);
 		}
 
 		Types::AssociationState Association::GetAssociationState() const
@@ -191,7 +193,7 @@ namespace RTC
 
 			// If we haven't received any SCTP packet yet and the transport is not
 			// ready for SCTP traffic, don't do anything.
-			if (this->privateMetrics.rxPacketsCount == 0 && !this->listener.OnAssociationIsTransportReadyForSctp())
+			if (this->privateMetrics.rxPacketsCount == 0 && !this->associationListenerDeferrer.OnAssociationIsTransportReadyForSctp())
 			{
 				MS_DEBUG_DEV(
 				  "no SCTP data has been received yet and transport is not ready for SCTP traffic, ignoring");
@@ -223,7 +225,7 @@ namespace RTC
 				return;
 			}
 
-			const AssociationListenerDeferrer::ScopedDeferrer deferrer(this->listener);
+			const AssociationListenerDeferrer::ScopedDeferrer deferrer(this->associationListenerDeferrer);
 
 			this->preTcb.localVerificationTag =
 			  Utils::Crypto::GetRandomUInt<uint32_t>(MinVerificationTag, MaxVerificationTag);
@@ -236,9 +238,9 @@ namespace RTC
 
 			SetState(State::COOKIE_WAIT, "Connect() called");
 
-			AssertStateIsConsistent();
+			AssertIsConsistent();
 
-			this->listener.OnAssociationConnecting();
+			this->associationListenerDeferrer.OnAssociationConnecting();
 		}
 
 		void Association::Shutdown()
@@ -247,12 +249,12 @@ namespace RTC
 
 			if (this->state == State::NEW || this->state == State::CLOSED)
 			{
-				AssertStateIsConsistent();
+				AssertIsConsistent();
 
 				return;
 			}
 
-			const AssociationListenerDeferrer::ScopedDeferrer deferrer(this->listener);
+			const AssociationListenerDeferrer::ScopedDeferrer deferrer(this->associationListenerDeferrer);
 
 			// https://datatracker.ietf.org/doc/html/rfc9260#section-9.2
 			//
@@ -287,7 +289,7 @@ namespace RTC
 				InternalClose(Types::ErrorKind::SUCCESS, "");
 			}
 
-			AssertStateIsConsistent();
+			AssertIsConsistent();
 		}
 
 		void Association::Close()
@@ -296,12 +298,12 @@ namespace RTC
 
 			if (this->state == State::NEW || this->state == State::CLOSED)
 			{
-				AssertStateIsConsistent();
+				AssertIsConsistent();
 
 				return;
 			}
 
-			const AssociationListenerDeferrer::ScopedDeferrer deferrer(this->listener);
+			const AssociationListenerDeferrer::ScopedDeferrer deferrer(this->associationListenerDeferrer);
 
 			if (this->tcb)
 			{
@@ -323,33 +325,33 @@ namespace RTC
 			}
 
 			InternalClose(Types::ErrorKind::SUCCESS, "");
-			AssertStateIsConsistent();
+
+			AssertIsConsistent();
 		}
 
-		std::optional<AssociationMetrics> Association::GetMetrics() const
+		std::optional<AssociationMetrics> Association::MakeMetrics() const
 		{
 			if (!this->tcb)
 			{
 				return std::nullopt;
 			}
 
-			// const size_t packetPayloadLength =
-			//   this->sctpOptions.mtu - Packet::CommonHeaderLength - DataChunk::DataChunkHeaderLength;
+			const size_t packetPayloadLength =
+			  this->sctpOptions.mtu - Packet::CommonHeaderLength - DataChunk::DataChunkHeaderLength;
 
-			// TODO: SCTP: Implement missing fields.
 			AssociationMetrics metrics{
 				.txPacketsCount  = this->privateMetrics.txPacketsCount,
 				.txMessagesCount = this->privateMetrics.txMessagesCount,
 				.rxPacketsCount  = this->privateMetrics.rxPacketsCount,
 				.rxMessagesCount = this->privateMetrics.rxMessagesCount,
-				// .rtxPacketsCount = this->tcb->GetRetransmissionQueue().GetRtxPacketsCount(),
-				// .rtxBytesCount   = this->tcb->GetRetransmissionQueue().GetRtxBytesCount(),
-				// .cwndBytes       = this->tcb->GetCwnd(),
-				.srttMs = this->tcb->GetCurrentSrttMs(),
-				// .unackDataCount =
-				//   this->tcb->GetRetransmissionQueue().GetUnackedItems() +
-				//   (this->sendQueue.GetTotalBufferedAmount() + packetPayloadLength - 1) / packetPayloadLength,
-				// .peerRwndBytes                = this->tcb->GetRetransmissionQueue().GetRwnd(),
+				.rtxPacketsCount = this->tcb->GetRetransmissionQueue().GetRtxPacketsCount(),
+				.rtxBytesCount   = this->tcb->GetRetransmissionQueue().GetRtxBytesCount(),
+				.cwndBytes       = this->tcb->GetCwnd(),
+				.srttMs          = this->tcb->GetCurrentSrttMs(),
+				.unackDataCount  = this->tcb->GetRetransmissionQueue().GetUnackedItems() +
+				                   ((this->sendQueue.GetTotalBufferedAmount() + packetPayloadLength - 1) /
+				                    packetPayloadLength),
+				.peerRwndBytes   = static_cast<uint32_t>(this->tcb->GetRetransmissionQueue().GetRwnd()),
 				.peerImplementation           = this->privateMetrics.peerImplementation,
 				.negotiatedMaxOutboundStreams = this->privateMetrics.negotiatedMaxOutboundStreams,
 				.negotiatedMaxInboundStreams  = this->privateMetrics.negotiatedMaxInboundStreams,
@@ -363,23 +365,18 @@ namespace RTC
 			return metrics;
 		}
 
-		uint16_t Association::GetStreamPriority(uint16_t /*streamId*/) const
+		uint16_t Association::GetStreamPriority(uint16_t streamId) const
 		{
 			MS_TRACE();
 
-			// TODO: SCTP: Implement it.
-			// return this->sendQueue.GetStreamPriority(streamId);
-
-			// TODO: SCTP: Remove.
-			return 0;
+			return this->sendQueue.GetStreamPriority(streamId);
 		}
 
-		void Association::SetStreamPriority(uint16_t /*streamId*/, uint16_t /*priority*/)
+		void Association::SetStreamPriority(uint16_t streamId, uint16_t priority)
 		{
 			MS_TRACE();
 
-			// TODO: SCTP: Implement it.
-			// this->sendQueue.SetStreamPriority(streamId, priority);
+			this->sendQueue.SetStreamPriority(streamId, priority);
 		}
 
 		void Association::SetMaxSendMessageSize(size_t maxMessageSize)
@@ -389,45 +386,43 @@ namespace RTC
 			this->sctpOptions.maxSendMessageSize = maxMessageSize;
 		}
 
-		size_t Association::GetStreamBufferedAmount(uint16_t /*streamId*/) const
+		size_t Association::GetTotalBufferedAmount() const
 		{
 			MS_TRACE();
 
-			// TODO: SCTP: Implement it.
-			// return this->sendQueue.GetStreamBufferedAmount(streamId);
-
-			// TODO: SCTP: Remove.
-			return 0;
+			return this->sendQueue.GetTotalBufferedAmount();
 		}
 
-		size_t Association::GetStreamBufferedAmountLowThreshold(uint16_t /*streamId*/) const
+		size_t Association::GetStreamBufferedAmount(uint16_t streamId) const
 		{
 			MS_TRACE();
 
-			// TODO: SCTP: Implement it.
-			// return this->sendQueue.GetStreamBufferedAmountLowThreshold(streamId);
+			return this->sendQueue.GetStreamBufferedAmount(streamId);
+		}
+
+		size_t Association::GetStreamBufferedAmountLowThreshold(uint16_t streamId) const
+		{
+			MS_TRACE();
 
-			// TODO: SCTP: Remove.
-			return 0;
+			return this->sendQueue.GetStreamBufferedAmountLowThreshold(streamId);
 		}
 
-		void Association::SetBufferedAmountLowThreshold(uint16_t /*streamId*/, size_t /*bytes*/)
+		void Association::SetStreamBufferedAmountLowThreshold(uint16_t streamId, size_t bytes)
 		{
 			MS_TRACE();
 
-			// TODO: SCTP: Implement it.
-			// this->sendQueue.SetBufferedAmountLowThreshold(streamId, bytes);
+			this->sendQueue.SetStreamBufferedAmountLowThreshold(streamId, bytes);
 		}
 
-		Types::ResetStreamsStatus Association::ResetStreams(std::span<const uint16_t> /*outboundStreamIds*/)
+		Types::ResetStreamsStatus Association::ResetStreams(std::span<const uint16_t> outboundStreamIds)
 		{
 			MS_TRACE();
 
-			const AssociationListenerDeferrer::ScopedDeferrer deferrer(this->listener);
+			const AssociationListenerDeferrer::ScopedDeferrer deferrer(this->associationListenerDeferrer);
 
 			if (!this->tcb)
 			{
-				this->listener.OnAssociationError(
+				this->associationListenerDeferrer.OnAssociationError(
 				  Types::ErrorKind::WRONG_SEQUENCE,
 				  "cannot reset outbound streams as the association is not connected");
 
@@ -436,18 +431,18 @@ namespace RTC
 
 			if (!this->tcb->GetNegotiatedCapabilities().reConfig)
 			{
-				this->listener.OnAssociationError(
+				this->associationListenerDeferrer.OnAssociationError(
 				  Types::ErrorKind::UNSUPPORTED_OPERATION,
 				  "cannot reset outbound streams as the remote doesn't support it");
 
 				return Types::ResetStreamsStatus::NOT_SUPPORTED;
 			}
 
-			// TODO: SCTP: Implement it.
-			// this->tcb->GetStreamResetHandler().ResetStreams(outboundStreamIds);
+			this->tcb->GetStreamResetHandler().ResetStreams(outboundStreamIds);
 
 			MaySendResetStreamsRequest();
-			AssertStateIsConsistent();
+
+			AssertIsConsistent();
 
 			return Types::ResetStreamsStatus::PERFORMED;
 		}
@@ -457,30 +452,27 @@ namespace RTC
 		{
 			MS_TRACE();
 
-			const AssociationListenerDeferrer::ScopedDeferrer deferrer(this->listener);
+			const AssociationListenerDeferrer::ScopedDeferrer deferrer(this->associationListenerDeferrer);
 
-			const auto status = InternalSendMessage(message, sendMessageOptions);
+			const auto status = InternalSendMessageCheck(message, sendMessageOptions);
 
 			if (status != Types::SendMessageStatus::SUCCESS)
 			{
 				return status;
 			}
 
-			// TODO: SCTP: Uncomment.
-			// const uint64_t now = DepLibUV::GetTimeMs();
+			const uint64_t nowMs = this->shared->GetTimeMs();
 
 			this->privateMetrics.txMessagesCount++;
 
-			// TODO: SCTP: Implement it.
-			// this->sendQueue.AddMessage(now, std::move(message), sendMessageOptions);
+			this->sendQueue.AddMessage(nowMs, std::move(message), sendMessageOptions);
 
 			if (this->tcb)
 			{
-				// TODO: SCTP: Implement it.
-				// this->tcb->SendBufferedPackets(now);
+				this->tcb->SendBufferedPackets(nowMs);
 			}
 
-			AssertStateIsConsistent();
+			AssertIsConsistent();
 
 			return Types::SendMessageStatus::SUCCESS;
 		}
@@ -490,17 +482,17 @@ namespace RTC
 		{
 			MS_TRACE();
 
-			const AssociationListenerDeferrer::ScopedDeferrer deferrer(this->listener);
+			const AssociationListenerDeferrer::ScopedDeferrer deferrer(this->associationListenerDeferrer);
+
+			const uint64_t nowMs = this->shared->GetTimeMs();
 
-			// TODO: SCTP: Uncomment.
-			// const uint64_t now = DepLibUV::GetTimeMs();
 			std::vector<Types::SendMessageStatus> statuses;
 
 			statuses.reserve(messages.size());
 
-			for (const auto& message : messages)
+			for (auto& message : messages)
 			{
-				const auto status = InternalSendMessage(message, sendMessageOptions);
+				const auto status = InternalSendMessageCheck(message, sendMessageOptions);
 
 				statuses.push_back(status);
 
@@ -511,17 +503,15 @@ namespace RTC
 
 				this->privateMetrics.txMessagesCount++;
 
-				// TODO: SCTP: Implement it.
-				// this->sendQueue.AddMessage(now, std::move(message), sendMessageOptions);
+				this->sendQueue.AddMessage(nowMs, std::move(message), sendMessageOptions);
 			}
 
 			if (this->tcb)
 			{
-				// TODO: SCTP: Implement it.
-				// this->tcb->SendBufferedPackets(now);
+				this->tcb->SendBufferedPackets(nowMs);
 			}
 
-			AssertStateIsConsistent();
+			AssertIsConsistent();
 
 			return statuses;
 		}
@@ -530,23 +520,23 @@ namespace RTC
 		{
 			MS_TRACE();
 
-			// TODO: SCTP: For testing purposes. Must be removed.
+// For debugging purposes.
+#if MS_LOG_DEV_LEVEL == 3
+			const auto* packet = RTC::SCTP::Packet::Parse(data, len);
+
+			if (packet)
 			{
 				MS_DUMP("<<< received SCTP packet:");
 
-				const auto* packet = RTC::SCTP::Packet::Parse(data, len);
-
-				if (packet)
-				{
-					packet->Dump();
+				packet->Dump();
 
-					delete packet;
-				}
-				else
-				{
-					MS_ABORT("RTC::SCTP::Packet::Parse() failed to parse received SCTP data");
-				}
+				delete packet;
 			}
+			else
+			{
+				MS_ERROR("RTC::SCTP::Packet::Parse() failed to parse received SCTP data");
+			}
+#endif
 
 			this->privateMetrics.rxPacketsCount++;
 
@@ -557,7 +547,7 @@ namespace RTC
 			// NOTE: It's important to create the deferrer here, otherwise it may
 			// happen that MayConnect() ends calling to Connect() so we end with two
 			// nested deferreds (and hence an assertion).
-			const AssociationListenerDeferrer::ScopedDeferrer deferrer(this->listener);
+			const AssociationListenerDeferrer::ScopedDeferrer deferrer(this->associationListenerDeferrer);
 
 			std::unique_ptr<Packet> receivedPacket{ Packet::Parse(data, len) };
 
@@ -565,10 +555,10 @@ namespace RTC
 			{
 				MS_WARN_TAG(sctp, "failed to parse received SCTP packet");
 
-				this->listener.OnAssociationError(
+				this->associationListenerDeferrer.OnAssociationError(
 				  Types::ErrorKind::PARSE_FAILED, "failed to parse received SCTP packet");
 
-				AssertStateIsConsistent();
+				AssertIsConsistent();
 
 				return;
 			}
@@ -594,12 +584,47 @@ namespace RTC
 
 			if (this->tcb)
 			{
-				// TODO: SCTP: Implement it.
-				// this->tcb->GetDadaTracker().ObservePacketEnd();
+				this->tcb->GetDataTracker().ObservePacketEnd();
 				this->tcb->MaySendSackChunk();
 			}
 
-			AssertStateIsConsistent();
+			AssertIsConsistent();
+		}
+
+		uint16_t Association::GetNegotiatedMaxOutboundStreams() const
+		{
+			MS_TRACE();
+
+			if (this->tcb)
+			{
+				return this->tcb->GetNegotiatedCapabilities().negotiatedMaxOutboundStreams;
+			}
+			else
+			{
+				MS_WARN_TAG(
+				  sctp,
+				  "calling Association::GetNegotiatedMaxOutboundStreams() before TCB is created returns 0");
+
+				return 0;
+			}
+		}
+
+		uint16_t Association::GetNegotiatedMaxInboundStreams() const
+		{
+			MS_TRACE();
+
+			if (this->tcb)
+			{
+				return this->tcb->GetNegotiatedCapabilities().negotiatedMaxInboundStreams;
+			}
+			else
+			{
+				MS_WARN_TAG(
+				  sctp,
+				  "calling Association::GetNegotiatedMaxInboundStreams() before TCB is created returns 0");
+
+				return 0;
+			}
 		}
 
 		void Association::InternalClose(Types::ErrorKind errorKind, const std::string_view& message)
@@ -623,16 +648,16 @@ namespace RTC
 			{
 				if (errorKind == Types::ErrorKind::SUCCESS)
 				{
-					this->listener.OnAssociationClosed(errorKind, message);
+					this->associationListenerDeferrer.OnAssociationClosed(errorKind, message);
 				}
 				else
 				{
-					this->listener.OnAssociationFailed(errorKind, message);
+					this->associationListenerDeferrer.OnAssociationFailed(errorKind, message);
 				}
 			}
 			else
 			{
-				this->listener.OnAssociationClosed(errorKind, message);
+				this->associationListenerDeferrer.OnAssociationClosed(errorKind, message);
 			}
 		}
 
@@ -724,8 +749,10 @@ namespace RTC
 			MS_TRACE();
 
 			this->tcb = std::make_unique<TransmissionControlBlock>(
-			  this->listener,
+			  this->associationListenerDeferrer,
 			  this->sctpOptions,
+			  this->shared,
+			  this->sendQueue,
 			  this->packetSender,
 			  localVerificationTag,
 			  remoteVerificationTag,
@@ -734,6 +761,7 @@ namespace RTC
 			  remoteAdvertisedReceiverWindowCredit,
 			  tieTag,
 			  negotiatedCapabilities,
+			  this->maxPacketLength,
 			  [this]()
 			  {
 				  return this->state == State::ESTABLISHED;
@@ -761,7 +789,7 @@ namespace RTC
 			MS_TRACE();
 
 			auto packet =
-			  std::unique_ptr<Packet>(Packet::Factory(PacketFactoryBuffer, sizeof(PacketFactoryBuffer)));
+			  std::unique_ptr<Packet>{ Packet::Factory(PacketFactoryBuffer, this->maxPacketLength) };
 
 			packet->SetSourcePort(this->sctpOptions.sourcePort);
 			packet->SetDestinationPort(this->sctpOptions.destinationPort);
@@ -803,11 +831,10 @@ namespace RTC
 
 			AssertHasTcb();
 
-			auto packet               = this->tcb->CreatePacket();
-			const auto* shutdownChunk = packet->BuildChunkInPlace<ShutdownChunk>();
+			auto packet         = this->tcb->CreatePacket();
+			auto* shutdownChunk = packet->BuildChunkInPlace<ShutdownChunk>();
 
-			// TODO: SCTP: Implement it.
-			// shutdownChunk->SetCumulativeTsnAck(this->tcb->GetDataTracker().GetLastCumulativeAckedTsn());
+			shutdownChunk->SetCumulativeTsnAck(this->tcb->GetDataTracker().GetLastCumulativeAckedTsn());
 			shutdownChunk->Consolidate();
 
 			this->packetSender.SendPacket(packet.get());
@@ -836,10 +863,10 @@ namespace RTC
 
 			AssertHasTcb();
 
-			// TODO: SCTP: Implement it.
-			// if (this->tcb->GetRetransmissionQueue().GetUnackedItems() != 0) {
-			//   return;
-			// }
+			if (this->tcb->GetRetransmissionQueue().GetUnackedItems() != 0)
+			{
+				return;
+			}
 
 			// https://datatracker.ietf.org/doc/html/rfc9260#section-9.2
 			//
@@ -913,37 +940,13 @@ namespace RTC
 
 			AssertHasTcb();
 
-			// TODO: SCTP: I don't like this. I don't want to use Packet::AddChunk() (which
-			// clones the given Chunk). I want to use Packet::BuildChunkInPlace() so
-			// we need that `tcb->GetStreamResetHandler().MakeStreamResetRequest()`
-			// doesn't return a `ReConfigChunk` but something different such as the
-			// Re-configuration Request Parameter(s) (OutgoingSSNResetRequestParameter):
-			// https://datatracker.ietf.org/doc/html/rfc6525#section-8.2
-			// Mmmm, but not even that because we also want to use
-			// ReConfigChunk::BuildParameterInPlace() instead of AddParameter() for
-			// same reasons... Ok, let's see.
-			// NOTE: What about if we do some std::move() somewhere?
-
-			// const auto* reConfigChunk =
-			//     this->tcb->GetStreamResetHandler().MakeStreamResetRequest();
-			// const auto* outgoingSSNResetRequestParameter =
-			//   this->tcb->GetStreamResetHandler().MakeOutgoingSSNResetRequestParameter();
-
-			// if (!outgoingSSNResetRequestParameter)
-			// {
-			// 	return;
-			// }
-
-			// auto packet         = this->tcb->CreatePacket();
-			// auto* reConfigChunk = packet->BuildChunkInPlace<ReConfigChunk>();
-
-			// reConfigChunk->AddParameter(outgoingSSNResetRequestParameter);
-
-			// delete outgoingSSNResetRequestParameter;
-
-			// reConfigChunk->Consolidate();
+			if (this->tcb->GetStreamResetHandler().ShouldSendStreamResetRequest())
+			{
+				auto packet = this->tcb->CreatePacket();
 
-			// this->packetSender.SendPacket(packet.get());
+				this->tcb->GetStreamResetHandler().AddStreamResetRequest(packet.get());
+				this->packetSender.SendPacket(packet.get());
+			}
 		}
 
 		void Association::MayDeliverMessages()
@@ -952,15 +955,26 @@ namespace RTC
 
 			AssertHasTcb();
 
-			// TODO: SCTP: Implement it.
-			// while (std::optional<Message> message = this->tcb->GetReassemblyQueue().GetNextMessage())
-			// {
-			// 	this->privateMetrics.rxMessagesCount++;
-			// 	this->listener.OnAssociationMessageReceived(*std::move(message));
-			// }
+			while (std::optional<Message> message = this->tcb->GetReassemblyQueue().GetNextMessage())
+			{
+				this->privateMetrics.rxMessagesCount++;
+
+				if (message->GetPayloadLength() > this->sctpOptions.maxReceiveMessageSize)
+				{
+					MS_WARN_TAG(
+					  sctp,
+					  "dropping too large received message [messageByteLength:%zu, maxReceiveMessageSize:%zu]",
+					  message->GetPayloadLength(),
+					  this->sctpOptions.maxReceiveMessageSize);
+
+					break;
+				}
+
+				this->associationListenerDeferrer.OnAssociationMessageReceived(*std::move(message));
+			}
 		}
 
-		Types::SendMessageStatus Association::InternalSendMessage(
+		Types::SendMessageStatus Association::InternalSendMessageCheck(
 		  const Message& message, const SendMessageOptions& sendMessageOptions)
 		{
 			MS_TRACE();
@@ -971,10 +985,10 @@ namespace RTC
 			{
 				if (lifecycleId.has_value())
 				{
-					this->listener.OnAssociationLifecycleMessageEnd(lifecycleId.value());
+					this->associationListenerDeferrer.OnAssociationLifecycleMessageEnd(lifecycleId.value());
 				}
 
-				this->listener.OnAssociationError(
+				this->associationListenerDeferrer.OnAssociationError(
 				  Types::ErrorKind::PROTOCOL_VIOLATION, "cannot send empty message");
 
 				return Types::SendMessageStatus::ERROR_MESSAGE_EMPTY;
@@ -983,10 +997,10 @@ namespace RTC
 			{
 				if (lifecycleId.has_value())
 				{
-					this->listener.OnAssociationLifecycleMessageEnd(lifecycleId.value());
+					this->associationListenerDeferrer.OnAssociationLifecycleMessageEnd(lifecycleId.value());
 				}
 
-				this->listener.OnAssociationError(
+				this->associationListenerDeferrer.OnAssociationError(
 				  Types::ErrorKind::PROTOCOL_VIOLATION, "cannot send too large message");
 
 				return Types::SendMessageStatus::ERROR_MESSAGE_TOO_LARGE;
@@ -1002,31 +1016,30 @@ namespace RTC
 			{
 				if (lifecycleId.has_value())
 				{
-					this->listener.OnAssociationLifecycleMessageEnd(lifecycleId.value());
+					this->associationListenerDeferrer.OnAssociationLifecycleMessageEnd(lifecycleId.value());
 				}
 
-				this->listener.OnAssociationError(
+				this->associationListenerDeferrer.OnAssociationError(
 				  Types::ErrorKind::WRONG_SEQUENCE,
 				  "cannot send message as the association is shutting down");
 
 				return Types::SendMessageStatus::ERROR_SHUTTING_DOWN;
 			}
-			// TODO: SCTP: Implement it.
-			// else if (
-			//   this->sendQueue.GetTotalBufferedAmount() >= this->sctpOptions.maxSendBufferSize ||
-			//   this->sendQueue.GetStreamBufferedAmount(message.GetStreamId()) >=
-			//     this->sctpOptions.perStreamSendQueueLimit)
-			// {
-			// 	if (lifecycleId.has_value())
-			// 	{
-			// 		this->listener.OnAssociationLifecycleMessageEnd(lifecycleId.value());
-			// 	}
+			else if (
+			  this->sendQueue.GetTotalBufferedAmount() >= this->sctpOptions.maxSendBufferSize ||
+			  this->sendQueue.GetStreamBufferedAmount(message.GetStreamId()) >=
+			    this->sctpOptions.perStreamSendQueueLimit)
+			{
+				if (lifecycleId.has_value())
+				{
+					this->associationListenerDeferrer.OnAssociationLifecycleMessageEnd(lifecycleId.value());
+				}
 
-			// 	this->listener.OnAssociationError(
-			// 	  Types::ErrorKind::RESOURCE_EXHAUSTION, "cannot send message as the send queue is full");
+				this->associationListenerDeferrer.OnAssociationError(
+				  Types::ErrorKind::RESOURCE_EXHAUSTION, "cannot send message as the send queue is full");
 
-			// 	return Types::SendMessageStatus::ERROR_RESOURCE_EXHAUSTION;
-			// }
+				return Types::SendMessageStatus::ERROR_RESOURCE_EXHAUSTION;
+			}
 
 			return Types::SendMessageStatus::SUCCESS;
 		}
@@ -1054,7 +1067,7 @@ namespace RTC
 					  sctp,
 					  "Packet with Verification Tag 0 must have a single Chunk and it must be an INIT Chunk, packet discarded");
 
-					this->listener.OnAssociationError(
+					this->associationListenerDeferrer.OnAssociationError(
 					  Types::ErrorKind::PARSE_FAILED,
 					  "packet with Verification Tag 0 must have a single chunk and it must be an INIT chunk");
 
@@ -1094,7 +1107,7 @@ namespace RTC
 					  "ABORT Chunk Verification Tag %" PRIu32 " is wrong, packet discarded",
 					  receivedPacket->GetVerificationTag());
 
-					this->listener.OnAssociationError(
+					this->associationListenerDeferrer.OnAssociationError(
 					  Types::ErrorKind::PARSE_FAILED, "packet with ABORT chunk has invalid Verification Tag");
 
 					return false;
@@ -1115,7 +1128,7 @@ namespace RTC
 					  receivedPacket->GetVerificationTag(),
 					  this->preTcb.localVerificationTag);
 
-					this->listener.OnAssociationError(
+					this->associationListenerDeferrer.OnAssociationError(
 					  Types::ErrorKind::PARSE_FAILED,
 					  "packet with INIT_ACK chunk has invalid Verification Tag");
 
@@ -1163,7 +1176,7 @@ namespace RTC
 					  "SHUTDOWN_COMPLETE Chunk Verification Tag %" PRIu32 " is wrong, packet discarded",
 					  receivedPacket->GetVerificationTag());
 
-					this->listener.OnAssociationError(
+					this->associationListenerDeferrer.OnAssociationError(
 					  Types::ErrorKind::PARSE_FAILED,
 					  "packet with SHUTDOWN_COMPLETE chunk has invalid Verification Tag");
 
@@ -1191,7 +1204,7 @@ namespace RTC
 				  receivedPacket->GetVerificationTag(),
 				  localVerificationTag);
 
-				this->listener.OnAssociationError(
+				this->associationListenerDeferrer.OnAssociationError(
 				  Types::ErrorKind::PARSE_FAILED, "packet has invalid Verification Tag");
 
 				return false;
@@ -1594,8 +1607,7 @@ namespace RTC
 			// partly sent message is re-sent in full. The same is true when the
 			// Association is closed and later re-opened, which never happens in
 			// WebRTC, but is a valid operation on the SCTP level.
-			// TODO: SCTP: Implement it.
-			// this->sendQueue.Reset();
+			this->sendQueue.Reset();
 
 			CreateTransmissionControlBlock(
 			  this->preTcb.localVerificationTag,
@@ -1616,14 +1628,12 @@ namespace RTC
 
 			this->tcb->SetRemoteStateCookie(std::move(remoteStateCookie));
 
-			// TODO: SCTP: Implement it.
-			// TODO: SCTP: tcb->SendBufferedPackets() must check that the remote state cookie
-			// is set in TCB and must send a COOKIE_ECHO Chunk before potentially
-			// buffered messages.
-			// this->tcb->SendBufferedPackets(callbacks_.Now());
+			const uint64_t nowMs = this->shared->GetTimeMs();
 
+			this->tcb->SendBufferedPackets(nowMs);
 			this->t1CookieTimer->Start();
-			this->listener.OnAssociationConnecting();
+
+			this->associationListenerDeferrer.OnAssociationConnecting();
 		}
 
 		void Association::HandleReceivedCookieEchoChunk(
@@ -1635,7 +1645,7 @@ namespace RTC
 			{
 				MS_WARN_TAG(sctp, "ignoring received COOKIE_ECHO Chunk without Cookie");
 
-				this->listener.OnAssociationError(
+				this->associationListenerDeferrer.OnAssociationError(
 				  Types::ErrorKind::PARSE_FAILED, "received COOKIE_ECHO Chunk without Cookie");
 
 				return;
@@ -1648,7 +1658,7 @@ namespace RTC
 			{
 				MS_WARN_TAG(sctp, "failed to parse Cookie in received COOKIE_ECHO Chunk");
 
-				this->listener.OnAssociationError(
+				this->associationListenerDeferrer.OnAssociationError(
 				  Types::ErrorKind::PARSE_FAILED, "received COOKIE_ECHO Chunk with invalid Cookie");
 
 				return;
@@ -1667,7 +1677,7 @@ namespace RTC
 				{
 					MS_WARN_TAG(sctp, "received COOKIE_ECHO Chunk with invalid Verification Tag");
 
-					this->listener.OnAssociationError(
+					this->associationListenerDeferrer.OnAssociationError(
 					  Types::ErrorKind::PARSE_FAILED,
 					  "received COOKIE_ECHO Chunk with invalid Verification Tag");
 
@@ -1687,7 +1697,7 @@ namespace RTC
 
 				SetState(State::ESTABLISHED, "COOKIE_ECHO received");
 
-				this->listener.OnAssociationConnected();
+				this->associationListenerDeferrer.OnAssociationConnected();
 			}
 
 			if (!this->tcb)
@@ -1697,8 +1707,7 @@ namespace RTC
 				// partly sent message is re-sent in full. The same is true when the
 				// Association is closed and later re-opened, which never happens in
 				// WebRTC, but is a valid operation on the SCTP level.
-				// TODO: SCTP: Implement it.
-				// this->sendQueue.Reset();
+				this->sendQueue.Reset();
 
 				CreateTransmissionControlBlock(
 				  cookie->GetLocalVerificationTag(),
@@ -1710,23 +1719,14 @@ namespace RTC
 				  cookie->GetNegotiatedCapabilities());
 			}
 
-			auto packet                = this->tcb->CreatePacket();
-			const auto* cookieAckChunk = packet->BuildChunkInPlace<CookieAckChunk>();
-
-			cookieAckChunk->Consolidate();
-
 			// https://datatracker.ietf.org/doc/html/rfc9260#section-5.1
 			//
 			// "A COOKIE ACK chunk MAY be bundled with any pending DATA chunks (and/or
 			// SACK chunks), but the COOKIE ACK chunk MUST be the first chunk in the
 			// packet."
-			// TODO: SCTP: Implement it. Note that we pass Packet as argument!
-			// this->tcb->SendBufferedPackets(packet.get(), callbacks_.Now());
+			const uint64_t nowMs = this->shared->GetTimeMs();
 
-			// TODO: SCTP: Remove this since COOKIE_ACK must be sent by
-			// tcb->SendBufferedPackets() call above.
-			MS_DUMP("TODO: REMOVE");
-			this->packetSender.SendPacket(packet.get());
+			this->tcb->SendBufferedPackets(nowMs, /*addCookieAckChunk*/ true);
 		}
 
 		bool Association::HandleReceivedCookieEchoChunkWithTcb(
@@ -1768,8 +1768,7 @@ namespace RTC
 					operationErrorChunk->Consolidate();
 
 					this->packetSender.SendPacket(packet.get());
-
-					this->listener.OnAssociationError(
+					this->associationListenerDeferrer.OnAssociationError(
 					  Types::ErrorKind::WRONG_SEQUENCE, "received COOKIE_ECHO while shutting down");
 
 					return false;
@@ -1778,7 +1777,7 @@ namespace RTC
 				MS_DEBUG_DEV("received COOKIE_ECHO indicating a restarted peer");
 
 				this->tcb = nullptr;
-				this->listener.OnAssociationRestarted();
+				this->associationListenerDeferrer.OnAssociationRestarted();
 			}
 			// "B) In this case, both sides might be attempting to start an association
 			// at about the same time, but the peer endpoint sent its INIT chunk after
@@ -1844,10 +1843,11 @@ namespace RTC
 
 			SetState(State::ESTABLISHED, "COOKIE_ACK received");
 
-			// TODO: SCTP: Implement this.
-			// this->tcb->SendBufferedPackets(callbacks_.Now());
+			const uint64_t nowMs = this->shared->GetTimeMs();
+
+			this->tcb->SendBufferedPackets(nowMs);
 
-			this->listener.OnAssociationConnected();
+			this->associationListenerDeferrer.OnAssociationConnected();
 		}
 
 		void Association::HandleReceivedShutdownChunk(
@@ -2032,7 +2032,8 @@ namespace RTC
 
 			MS_WARN_TAG(sctp, "received OPERATION_ERROR Chunk: %s", errorCausesStr.c_str());
 
-			this->listener.OnAssociationError(Types::ErrorKind::PEER_REPORTED, errorCausesStr);
+			this->associationListenerDeferrer.OnAssociationError(
+			  Types::ErrorKind::PEER_REPORTED, errorCausesStr);
 		}
 
 		void Association::HandleReceivedAbortAssociationChunk(
@@ -2101,7 +2102,7 @@ namespace RTC
 		}
 
 		void Association::HandleReceivedReConfigChunk(
-		  const Packet* /*receivedPacket*/, const ReConfigChunk* /*receivedReConfigChunk*/)
+		  const Packet* /*receivedPacket*/, const ReConfigChunk* receivedReConfigChunk)
 		{
 			MS_TRACE();
 
@@ -2110,8 +2111,7 @@ namespace RTC
 				return;
 			}
 
-			// TODO: SCTP: Implement it.
-			// this->tcb->GetStreamResetHandler().HandleReConfig(*std::move(receivedReConfigChunk));
+			this->tcb->GetStreamResetHandler().HandleReceivedReConfigChunk(receivedReConfigChunk);
 
 			// Handling this response may result in outgoing stream resets finishing
 			// (either successfully or with failure). If there still are pending
@@ -2121,8 +2121,9 @@ namespace RTC
 
 			// If a response was processed, pending to-be-reset streams may now have
 			// become unpaused. Try to send more DATA/I_DATA chunks.
-			// TODO: SCTP: Implement it.
-			// this->tcb->SendBufferedPackets(callbacks_.Now());
+			const uint64_t nowMs = this->shared->GetTimeMs();
+
+			this->tcb->SendBufferedPackets(nowMs);
 
 			// If it leaves "deferred reset processing", there may be chunks to
 			// deliver that were queued while waiting for the stream to reset.
@@ -2146,7 +2147,7 @@ namespace RTC
 		}
 
 		void Association::HandleReceivedAnyForwardTsnChunk(
-		  const Packet* /*receivedPacket*/, const AnyForwardTsnChunk* /*receivedAnyForwardTsnChunk*/)
+		  const Packet* /*receivedPacket*/, const AnyForwardTsnChunk* receivedAnyForwardTsnChunk)
 		{
 			MS_TRACE();
 
@@ -2167,28 +2168,26 @@ namespace RTC
 				  abortAssociationChunk->BuildErrorCauseInPlace<ProtocolViolationErrorCause>();
 
 				protocolViolationErrorCause->SetAdditionalInformation(
-				  "FORWARD_TSN or I_FORWARD_TSN-TSN chunk received but partial reliability is not negotiated");
+				  "FORWARD-TSN or I_FORWARD-TSN chunk received but partial reliability is not negotiated");
 
 				protocolViolationErrorCause->Consolidate();
 				abortAssociationChunk->Consolidate();
 
 				this->packetSender.SendPacket(packet.get());
 
-				this->listener.OnAssociationError(
+				this->associationListenerDeferrer.OnAssociationError(
 				  Types::ErrorKind::PROTOCOL_VIOLATION,
-				  "received FORWARD_TSN or I_FORWARD_TSN-TSN chunk but partial reliability is not negotiated");
+				  "received FORWARD-TSN or I-FORWARD-TSN chunk but partial reliability is not negotiated");
 
 				return;
 			}
 
-			// TODO: SCTP: Implement it.
-			// if
-			// (this->tcb->GetDataTracker().HandleForwardTsn(receivedAnyForwardTsnChunk->GetNewCumulativeTsn()))
-			// {
-			// 	this->tcb->GetReassemblyQueue().HandleForwardTsn(
-			// 		receivedAnyForwardTsnChunk->GetNewCumulativeTsn(),
-			// 		receivedAnyForwardTsnChunk->GetSkippedStreams());
-			// }
+			if (this->tcb->GetDataTracker().HandleForwardTsn(receivedAnyForwardTsnChunk->GetNewCumulativeTsn()))
+			{
+				this->tcb->GetReassemblyQueue().HandleForwardTsn(
+				  receivedAnyForwardTsnChunk->GetNewCumulativeTsn(),
+				  receivedAnyForwardTsnChunk->GetSkippedStreams());
+			}
 
 			// A forward TSN (for ordered streams) may allow messages to be delivered.
 			MayDeliverMessages();
@@ -2220,9 +2219,8 @@ namespace RTC
 				return;
 			}
 
-			const uint32_t tsn = receivedAnyDataChunk->GetTsn();
-			// TODO: SCTP: Uncomment.
-			// const bool immediateAck = receivedAnyDataChunk->GetI();
+			const uint32_t tsn      = receivedAnyDataChunk->GetTsn();
+			const bool immediateAck = receivedAnyDataChunk->GetI();
 
 			if (receivedAnyDataChunk->GetUserDataPayloadLength() == 0)
 			{
@@ -2237,99 +2235,95 @@ namespace RTC
 
 				this->packetSender.SendPacket(packet.get());
 
-				this->listener.OnAssociationError(
-				  Types::ErrorKind::PROTOCOL_VIOLATION, "received DATA or I_DATA chunk with no user data");
+				this->associationListenerDeferrer.OnAssociationError(
+				  Types::ErrorKind::PROTOCOL_VIOLATION, "received DATA or I-DATA chunk with no user data");
 
 				return;
 			}
 
-			// TODO: SCTP: Implement it.
-			// MS_DEBUG_DEV("data received [data length:%" PRIu16 ", queue size:%zu, watermark:%zu,
-			// full:%s, above:%s]", 	receivedAnyDataChunk->GetUserDataLength(),
-			// 	this->tcb->GetReassemblyQueue()->GetQueuedBytes(),
-			// 	this->tcb->GetReassemblyQueue()->GetWaterMarkBytes(),
-			// 	this->tcb->GetReassemblyQueue()->IsFull(),
-			// 	this->tcb->GetReassemblyQueue()->IsAboveWatermark(),
-			// );
-
-			// TODO: SCTP: Implement it.
-			// if (this->tcb->GetReassemblyQueue()->IsFull())
-			// {
-			// 	// If the reassembly queue is full but there are assembled messages
-			// 	// waiting to be pulled, we can't do anything with this data except drop
-			// 	// it, and hope the upper layer drains the accumulated messages soon.
-			// 	if (this->tcb->GetReassemblyQueue()->HasMessages())
-			// 	{
-			// 		MS_WARN_TAG(sctp, "received data rejected because reassembly queue is full");
-
-			// 		return;
-			// 	}
-			// 	// If the reassembly queue is full and there's no messages waiting,
-			// 	// there is nothing that can be done. The specification only allows
-			// 	// dropping gap-ack-blocks, and that's not likely to help as the
-			// 	// Association has been trying to fill gaps since the watermark was
-			// 	// reached.
-			// 	else
-			// 	{
-			// 		auto packet      = this->tcb->CreatePacket();
-			// 		auto* abortAssociationChunk = packet->BuildChunkInPlace<AbortAssociationChunk>();
-
-			// 		// NOTE: Don't set bit T in the ABORT chunk since TCB knows the
-			// 		// Verification Tag expected by the remote.
-
-			// 		auto* outOfResourceErrorCause =
-			// 		  abortAssociationChunk->BuildErrorCauseInPlace<OutOfResourceErrorCause>();
-
-			// 		outOfResourceErrorCause->Consolidate();
-			// 		abortAssociationChunk->Consolidate();
-
-			// 		this->packetSender.SendPacket(packet.get());
-
-			// 		InternalClose(Types::ErrorKind::RESOURCE_EXHAUSTION, "reassembly queue is exhausted");
-
-			// 		return;
-			// 	}
-			// }
+			MS_DEBUG_DEV(
+			  "data received [data length:%" PRIu16 ", queue size:%zu, watermark:%zu, full:%s, above:%s]",
+			  receivedAnyDataChunk->GetUserDataPayloadLength(),
+			  this->tcb->GetReassemblyQueue().GetQueuedBytes(),
+			  this->tcb->GetReassemblyQueue().GetWatermarkBytes(),
+			  this->tcb->GetReassemblyQueue().IsFull() ? "yes" : "no",
+			  this->tcb->GetReassemblyQueue().IsAboveWatermark() ? "yes" : "no");
+
+			if (this->tcb->GetReassemblyQueue().IsFull())
+			{
+				// If the reassembly queue is full but there are assembled messages
+				// waiting to be pulled, we can't do anything with this data except drop
+				// it, and hope the upper layer drains the accumulated messages soon.
+				if (this->tcb->GetReassemblyQueue().HasMessages())
+				{
+					MS_WARN_TAG(sctp, "received data rejected because reassembly queue is full");
+
+					return;
+				}
+				// If the reassembly queue is full and there's no messages waiting,
+				// there is nothing that can be done. The specification only allows
+				// dropping gap-ack-blocks, and that's not likely to help as the
+				// Association has been trying to fill gaps since the watermark was
+				// reached.
+				else
+				{
+					auto packet                 = this->tcb->CreatePacket();
+					auto* abortAssociationChunk = packet->BuildChunkInPlace<AbortAssociationChunk>();
+
+					// NOTE: Don't set bit T in the ABORT chunk since TCB knows the
+					// Verification Tag expected by the remote.
+
+					auto* outOfResourceErrorCause =
+					  abortAssociationChunk->BuildErrorCauseInPlace<OutOfResourceErrorCause>();
+
+					outOfResourceErrorCause->Consolidate();
+					abortAssociationChunk->Consolidate();
+
+					this->packetSender.SendPacket(packet.get());
+
+					InternalClose(Types::ErrorKind::RESOURCE_EXHAUSTION, "reassembly queue is exhausted");
+
+					return;
+				}
+			}
 
 			// If the reassembly queue is above its high watermark, only accept data
 			// chunks that increase its cumulative ack tsn in an attempt to fill gaps
 			// to deliver messages.
-			// TODO: SCTP: Implement it.
-			// if (this->tcb->GetReassemblyQueue()->IsAboveWatermark())
-			// {
-			// 	MS_WARN_TAG(sctp, "reassembly queue is above watermark");
+			if (this->tcb->GetReassemblyQueue().IsAboveWatermark())
+			{
+				MS_WARN_TAG(sctp, "reassembly queue is above watermark");
 
-			// 	if (this->tcb->GetDataTracker()->WillIncreaseCumAckTsn(tsn))
-			// 	{
-			// 		MS_WARN_TAG(sctp, "reassembly queue is above watermark");
+				if (!this->tcb->GetDataTracker().WillIncreaseCumAckTsn(tsn))
+				{
+					MS_WARN_TAG(sctp, "reassembly queue is above watermark");
 
-			// 		this->tcb->GetDataTracker()->ForceImmediateSack();
+					this->tcb->GetDataTracker().ForceImmediateSack();
 
-			// 		return;
-			// 	}
-			// }
+					return;
+				}
+			}
 
-			// TODO: SCTP: Implement it.
-			// if (this->tcb->GetDataTracker()->IsTsnValid(tsn))
-			// {
-			// 	MS_WARN_TAG(sctp, "data rejected because of failing TSN validity");
+			if (!this->tcb->GetDataTracker().IsTsnValid(tsn))
+			{
+				MS_WARN_TAG(sctp, "data rejected because of failing TSN validity");
 
-			// 	return;
-			// }
+				return;
+			}
 
-			// TODO: SCTP: Implement it.
-			// if (this->tcb->GetDataTracker()->Observe(tsn, immediateAck))
-			// {
-			// 	// TODO: SCTP: Here we should have a std::vector<uint8_t> holding the data so
-			// 	// we can move it.
-			// 	this->tcb->GetReassemblyQueue()->Add(tsn, std::move(data));
+			if (this->tcb->GetDataTracker().Observe(tsn, immediateAck))
+			{
+				// NOTE: Here we are passing an UserData r-value created and returned by
+				// receivedAnyDataChunk->MakeUserData() so there is only one copy here.
+				// And ReassemblyQueue::AddData() will std::move() it internally.
+				this->tcb->GetReassemblyQueue().AddData(tsn, receivedAnyDataChunk->MakeUserData());
 
-			// 	MayDeliverMessages();
-			// }
+				MayDeliverMessages();
+			}
 		}
 
 		void Association::HandleReceivedSackChunk(
-		  const Packet* /*receivedPacket*/, const SackChunk* /*receivedSackChunk*/)
+		  const Packet* /*receivedPacket*/, const SackChunk* receivedSackChunk)
 		{
 			MS_TRACE();
 
@@ -2338,37 +2332,36 @@ namespace RTC
 				return;
 			}
 
-			// TODO: SCTP: Implement it.
-			// if (this->tcb->GetRetransmissionQueue()->HandleReceivedSack(receivedSackChunk))
-			// {
-			// 	MaySendShutdownOrShutdownAckChunk();
-
-			// 	// Receiving an ACK may make the Association go into fast recovery mode.
-			// 	//
-			// 	// https://datatracker.ietf.org/doc/html/rfc9260#section-7.2.4
-			// 	//
-			// 	// "If not in Fast Recovery, determine how many of the earliest (i.e.,
-			// 	// lowest TSN) DATA chunks marked for retransmission will fit into a
-			// 	// single packet, subject to constraint of the PMTU of the destination
-			// 	// transport address to which the packet is being sent. Call this value
-			// 	// K. Retransmit those K DATA chunks in a single packet. When a Fast
-			// 	// Retransmit is being performed, the sender SHOULD ignore the value of
-			// 	// cwnd and SHOULD NOT delay retransmission for this single packet."
-			// 	this->tcb->MaySendFastRetransmit();
-
-			// 	// Receiving an ACK will decrease outstanding bytes (maybe now below
-			// 	// cwnd?) or indicate packet loss that may result in sending FORWARD-TSN.
-			// 	const uint64_t now = DepLibUV::GetTimeMs();
-
-			// 	this->tcb->SendBufferedPackets(now);
-			// }
-			// else
-			// {
-			// 	MS_WARN_TAG(
-			// 	  sctp,
-			// 	  "dropping received out-of-order SACK [TSN:%" PRIu32 "]",
-			// 	  receivedSackChunk->GetCumulativeTsnAck());
-			// }
+			const uint64_t nowMs = this->shared->GetTimeMs();
+
+			if (this->tcb->GetRetransmissionQueue().HandleReceivedSackChunk(nowMs, receivedSackChunk))
+			{
+				MaySendShutdownOrShutdownAckChunk();
+
+				// Receiving an ACK may make the Association go into fast recovery mode.
+				//
+				// https://datatracker.ietf.org/doc/html/rfc9260#section-7.2.4
+				//
+				// "If not in Fast Recovery, determine how many of the earliest (i.e.,
+				// lowest TSN) DATA chunks marked for retransmission will fit into a
+				// single packet, subject to constraint of the PMTU of the destination
+				// transport address to which the packet is being sent. Call this value
+				// K. Retransmit those K DATA chunks in a single packet. When a Fast
+				// Retransmit is being performed, the sender SHOULD ignore the value of
+				// cwnd and SHOULD NOT delay retransmission for this single packet."
+				this->tcb->MaySendFastRetransmit();
+
+				// Receiving an ACK will decrease outstanding bytes (maybe now below
+				// cwnd?) or indicate packet loss that may result in sending FORWARD-TSN.
+				this->tcb->SendBufferedPackets(nowMs);
+			}
+			else
+			{
+				MS_WARN_TAG(
+				  sctp,
+				  "dropping received out-of-order SACK [TSN:%" PRIu32 "]",
+				  receivedSackChunk->GetCumulativeTsnAck());
+			}
 		}
 
 		bool Association::HandleReceivedUnknownChunk(
@@ -2400,7 +2393,7 @@ namespace RTC
 
 			if (reportError)
 			{
-				this->listener.OnAssociationError(
+				this->associationListenerDeferrer.OnAssociationError(
 				  Types::ErrorKind::PARSE_FAILED, "unknown chunk with type indicating it should be reported");
 
 				// If there is TCB (we need correct remote verification tag) send an
@@ -2429,15 +2422,7 @@ namespace RTC
 		{
 			MS_TRACE();
 
-			const AssociationListenerDeferrer::ScopedDeferrer deferrer(this->listener);
-
-			const auto maxRestarts = this->t1InitTimer->GetMaxRestarts();
-
-			MS_DEBUG_TAG(
-			  sctp,
-			  "T1-init timer has expired %zu/%s]",
-			  this->t1InitTimer->GetExpirationCount(),
-			  maxRestarts ? std::to_string(maxRestarts.value()).c_str() : "Infinite");
+			const AssociationListenerDeferrer::ScopedDeferrer deferrer(this->associationListenerDeferrer);
 
 			AssertState(State::COOKIE_WAIT);
 
@@ -2450,36 +2435,29 @@ namespace RTC
 				InternalClose(Types::ErrorKind::TOO_MANY_RETRIES, "no INIT_ACK chunk received");
 			}
 
-			AssertStateIsConsistent();
+			AssertIsConsistent();
 		}
 
 		void Association::OnT1CookieTimer(uint64_t& /*baseTimeoutMs*/, bool& /*stop*/)
 		{
 			MS_TRACE();
 
-			const AssociationListenerDeferrer::ScopedDeferrer deferrer(this->listener);
-
-			const auto maxRestarts = this->t1CookieTimer->GetMaxRestarts();
-
-			MS_DEBUG_TAG(
-			  sctp,
-			  "T1-cookie timer has expired %zu/%s]",
-			  this->t1CookieTimer->GetExpirationCount(),
-			  maxRestarts ? std::to_string(maxRestarts.value()).c_str() : "Infinite");
+			const AssociationListenerDeferrer::ScopedDeferrer deferrer(this->associationListenerDeferrer);
 
 			AssertState(State::COOKIE_ECHOED);
 
 			if (this->t1CookieTimer->IsRunning())
 			{
-				// TODO: SCTP: Implement it.
-				// this->tcb->SendBufferedPackets(now);
+				const uint64_t nowMs = this->shared->GetTimeMs();
+
+				this->tcb->SendBufferedPackets(nowMs);
 			}
 			else
 			{
 				InternalClose(Types::ErrorKind::TOO_MANY_RETRIES, "no COOKIE_ACK chunk received");
 			}
 
-			AssertStateIsConsistent();
+			AssertIsConsistent();
 		}
 
 		void Association::OnT2ShutdownTimer(uint64_t& baseTimeoutMs, bool& /*stop*/)
@@ -2489,15 +2467,7 @@ namespace RTC
 			AssertState(State::SHUTDOWN_SENT, State::SHUTDOWN_ACK_SENT);
 			AssertHasTcb();
 
-			const AssociationListenerDeferrer::ScopedDeferrer deferrer(this->listener);
-
-			const auto maxRestarts = this->t2ShutdownTimer->GetMaxRestarts();
-
-			MS_DEBUG_TAG(
-			  sctp,
-			  "T2-shutdown timer has expired %zu/%s]",
-			  this->t2ShutdownTimer->GetExpirationCount(),
-			  maxRestarts ? std::to_string(maxRestarts.value()).c_str() : "Infinite");
+			const AssociationListenerDeferrer::ScopedDeferrer deferrer(this->associationListenerDeferrer);
 
 			// https://datatracker.ietf.org/doc/html/rfc9260#section-9.2
 			//
@@ -2526,7 +2496,8 @@ namespace RTC
 				this->packetSender.SendPacket(packet.get());
 
 				InternalClose(Types::ErrorKind::TOO_MANY_RETRIES, "no SHUTDOWN_ACK chunk received");
-				AssertStateIsConsistent();
+
+				AssertIsConsistent();
 
 				return;
 			}
@@ -2550,7 +2521,7 @@ namespace RTC
 				SendShutdownChunk();
 			}
 
-			AssertStateIsConsistent();
+			AssertIsConsistent();
 
 			baseTimeoutMs = this->tcb->GetCurrentRtoMs();
 		}
@@ -2626,7 +2597,7 @@ namespace RTC
 				return true;
 			}
 
-			this->listener.OnAssociationError(
+			this->associationListenerDeferrer.OnAssociationError(
 			  Types::ErrorKind::NOT_CONNECTED,
 			  "received unexpected commands on association that is not connected");
 
@@ -2643,10 +2614,23 @@ namespace RTC
 			}
 		}
 
-		void Association::AssertStateIsConsistent() const
+		void Association::AssertIsConsistent() const
 		{
 			MS_TRACE();
 
+			// NOTE: This assertion is present in dcsctp but we are removing it because
+			// it's dangerous. Depending on where `AssertIsConsistent()` is called from,
+			// it may legitimately happen that tere are SCTP full messages stored in
+			// the reassembly queue. `ReassemblyQueue::HasMessages()` can legitimately
+			// return `true` during stream deferred reset processing, which is a valid
+			// state where the reassembly queue intentionally retains messages while
+			// waiting for the TSN marked by the peer as the "Sender's Last Assigned
+			// TSN". There is no point in the code where we can guarantee that this
+			// state is not active.
+			// MS_ASSERT(
+			//   !(this->tcb && this->tcb->GetReassemblyQueue().HasMessages()),
+			//   "this->tcb && this->tcb->GetReassemblyQueue().HasMessages()");
+
 			switch (this->state)
 			{
 				case State::NEW:
@@ -2796,21 +2780,43 @@ namespace RTC
 			}
 		}
 
+#if MS_LOG_DEV_LEVEL == 3
+		void Association::OnPacketSenderPacketSent(
+		  PacketSender* /*packetSender*/, const Packet* packet, bool sent)
+#else
 		void Association::OnPacketSenderPacketSent(
 		  PacketSender* /*packetSender*/, const Packet* /*packet*/, bool sent)
+#endif
 		{
 			MS_TRACE();
 
+// For debugging purposes.
+#if MS_LOG_DEV_LEVEL == 3
+			MS_DUMP(">>> SCTP packet sent [sent:%s]", sent ? "yes" : "no");
+
+			packet->Dump();
+#endif
+
 			if (sent)
 			{
 				this->privateMetrics.txPacketsCount++;
 			}
 		}
 
-		void Association::OnTimer(BackoffTimerHandle* backoffTimer, uint64_t& baseTimeoutMs, bool& stop)
+		void Association::OnBackoffTimer(
+		  BackoffTimerHandleInterface* backoffTimer, uint64_t& baseTimeoutMs, bool& stop)
 		{
 			MS_TRACE();
 
+			const auto maxRestarts = backoffTimer->GetMaxRestarts();
+
+			MS_DEBUG_TAG(
+			  sctp,
+			  "%s timer has expired [expìrations:%zu/%s]",
+			  backoffTimer->GetLabel().c_str(),
+			  backoffTimer->GetExpirationCount(),
+			  maxRestarts ? std::to_string(maxRestarts.value()).c_str() : "Infinite");
+
 			if (backoffTimer == this->t1InitTimer.get())
 			{
 				OnT1InitTimer(baseTimeoutMs, stop);