mediasoup 3.19.21 → 3.20.0

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

@@ -25,7 +25,7 @@ namespace RTC
 			this->listenerDeferrer.TriggerDeferredCallbacks();
 		}
 
-		AssociationListenerDeferrer::AssociationListenerDeferrer(AssociationListener* innerListener)
+		AssociationListenerDeferrer::AssociationListenerDeferrer(AssociationListenerInterface* innerListener)
 		  : innerListener(innerListener)
 		{
 			MS_TRACE();
@@ -87,7 +87,7 @@ namespace RTC
 			MS_ASSERT(this->ready, "not ready");
 
 			this->deferredCallbacks.emplace_back(
-			  [](CallbackData /*data*/, AssociationListener* listener)
+			  [](CallbackData /*data*/, AssociationListenerInterface* listener)
 			  {
 				  listener->OnAssociationConnecting();
 			  },
@@ -101,7 +101,7 @@ namespace RTC
 			MS_ASSERT(this->ready, "not ready");
 
 			this->deferredCallbacks.emplace_back(
-			  [](CallbackData /*data*/, AssociationListener* listener)
+			  [](CallbackData /*data*/, AssociationListenerInterface* listener)
 			  {
 				  listener->OnAssociationConnected();
 			  },
@@ -116,7 +116,7 @@ namespace RTC
 			MS_ASSERT(this->ready, "not ready");
 
 			this->deferredCallbacks.emplace_back(
-			  [](CallbackData data, AssociationListener* listener)
+			  [](CallbackData data, AssociationListenerInterface* listener)
 			  {
 				  const Error error = std::get<Error>(std::move(data));
 				  listener->OnAssociationFailed(error.errorKind, error.message);
@@ -132,7 +132,7 @@ namespace RTC
 			MS_ASSERT(this->ready, "not ready");
 
 			this->deferredCallbacks.emplace_back(
-			  [](CallbackData data, AssociationListener* listener)
+			  [](CallbackData data, AssociationListenerInterface* listener)
 			  {
 				  const Error error = std::get<Error>(std::move(data));
 				  listener->OnAssociationClosed(error.errorKind, error.message);
@@ -147,7 +147,7 @@ namespace RTC
 			MS_ASSERT(this->ready, "not ready");
 
 			this->deferredCallbacks.emplace_back(
-			  [](CallbackData /*data*/, AssociationListener* listener)
+			  [](CallbackData /*data*/, AssociationListenerInterface* listener)
 			  {
 				  listener->OnAssociationRestarted();
 			  },
@@ -162,7 +162,7 @@ namespace RTC
 			MS_ASSERT(this->ready, "not ready");
 
 			this->deferredCallbacks.emplace_back(
-			  [](CallbackData data, AssociationListener* listener)
+			  [](CallbackData data, AssociationListenerInterface* listener)
 			  {
 				  const Error error = std::get<Error>(std::move(data));
 				  listener->OnAssociationError(error.errorKind, error.message);
@@ -177,7 +177,7 @@ namespace RTC
 			MS_ASSERT(this->ready, "not ready");
 
 			this->deferredCallbacks.emplace_back(
-			  [](CallbackData data, AssociationListener* listener)
+			  [](CallbackData data, AssociationListenerInterface* listener)
 			  {
 				  listener->OnAssociationMessageReceived(std::get<Message>(std::move(data)));
 			  },
@@ -192,7 +192,7 @@ namespace RTC
 			MS_ASSERT(this->ready, "not ready");
 
 			this->deferredCallbacks.emplace_back(
-			  [](CallbackData data, AssociationListener* listener)
+			  [](CallbackData data, AssociationListenerInterface* listener)
 			  {
 				  StreamReset streamReset = std::get<StreamReset>(std::move(data));
 				  listener->OnAssociationStreamsResetPerformed(streamReset.streamIds);
@@ -208,7 +208,7 @@ namespace RTC
 			MS_ASSERT(this->ready, "not ready");
 
 			this->deferredCallbacks.emplace_back(
-			  [](CallbackData data, AssociationListener* listener)
+			  [](CallbackData data, AssociationListenerInterface* listener)
 			  {
 				  StreamReset streamReset = std::get<StreamReset>(std::move(data));
 				  listener->OnAssociationStreamsResetFailed(streamReset.streamIds, streamReset.errorMessage);
@@ -225,7 +225,7 @@ namespace RTC
 			MS_ASSERT(this->ready, "not ready");
 
 			this->deferredCallbacks.emplace_back(
-			  [](CallbackData data, AssociationListener* listener)
+			  [](CallbackData data, AssociationListenerInterface* listener)
 			  {
 				  StreamReset streamReset = std::get<StreamReset>(std::move(data));
 				  listener->OnAssociationInboundStreamsReset(streamReset.streamIds);
@@ -241,7 +241,7 @@ namespace RTC
 			MS_ASSERT(this->ready, "not ready");
 
 			this->deferredCallbacks.emplace_back(
-			  [](CallbackData data, AssociationListener* listener)
+			  [](CallbackData data, AssociationListenerInterface* listener)
 			  {
 				  listener->OnAssociationStreamBufferedAmountLow(std::get<uint16_t>(std::move(data)));
 			  },
@@ -255,7 +255,7 @@ namespace RTC
 			MS_ASSERT(this->ready, "not ready");
 
 			this->deferredCallbacks.emplace_back(
-			  [](CallbackData /*data*/, AssociationListener* listener)
+			  [](CallbackData /*data*/, AssociationListenerInterface* listener)
 			  {
 				  listener->OnAssociationTotalBufferedAmountLow();
 			  },
@@ -270,5 +270,38 @@ namespace RTC
 			// Will not be deferred but called directly.
 			return this->innerListener->OnAssociationIsTransportReadyForSctp();
 		}
+
+		void AssociationListenerDeferrer::OnAssociationLifecycleMessageFullySent(uint64_t lifecycleId)
+		{
+			MS_TRACE();
+
+			// Will not be deferred but called directly.
+			this->innerListener->OnAssociationLifecycleMessageFullySent(lifecycleId);
+		}
+
+		void AssociationListenerDeferrer::OnAssociationLifecycleMessageExpired(
+		  uint64_t lifecycleId, bool maybeDelivered)
+		{
+			MS_TRACE();
+
+			// Will not be deferred but called directly.
+			this->innerListener->OnAssociationLifecycleMessageExpired(lifecycleId, maybeDelivered);
+		}
+
+		void AssociationListenerDeferrer::OnAssociationLifecycleMessageDelivered(uint64_t lifecycleId)
+		{
+			MS_TRACE();
+
+			// Will not be deferred but called directly.
+			this->innerListener->OnAssociationLifecycleMessageDelivered(lifecycleId);
+		}
+
+		void AssociationListenerDeferrer::OnAssociationLifecycleMessageEnd(uint64_t lifecycleId)
+		{
+			MS_TRACE();
+
+			// Will not be deferred but called directly.
+			this->innerListener->OnAssociationLifecycleMessageEnd(lifecycleId);
+		}
 	} // namespace SCTP
 } // namespace RTC

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

@@ -1,13 +1,11 @@
 #define MS_CLASS "RTC::SCTP::HeartbeatHandler"
-// TODO: SCTP: COMMENT
-#define MS_LOG_DEV_LEVEL 3
+// #define MS_LOG_DEV_LEVEL 3
 
 #include "RTC/SCTP/association/HeartbeatHandler.hpp"
-#include "DepLibUV.hpp"
 #include "Logger.hpp"
-#include "Utils.hpp"
 #include "RTC/SCTP/packet/parameters/HeartbeatInfoParameter.hpp"
 #include "RTC/SCTP/public/SctpTypes.hpp"
+#include "Utils.hpp"
 #include <string>
 
 namespace RTC
@@ -21,28 +19,39 @@ namespace RTC
 		/* Instance methods. */
 
 		HeartbeatHandler::HeartbeatHandler(
-		  AssociationListener& associationListener, const SctpOptions& sctpOptions, TCBContext* tcbContext)
+		  AssociationListenerInterface& associationListener,
+		  const SctpOptions& sctpOptions,
+		  SharedInterface* shared,
+		  TransmissionControlBlockContextInterface* tcbContext)
 		  : associationListener(associationListener),
 		    sctpOptions(sctpOptions),
+		    shared(shared),
 		    tcbContext(tcbContext),
 		    intervalDurationMs(sctpOptions.heartbeatIntervalMs),
 		    intervalDurationShouldIncludeRtt(sctpOptions.heartbeatIntervalIncludeRtt),
-		    intervalTimer(
-		      std::make_unique<BackoffTimerHandle>(
-		        /*listener*/ this,
-		        /*baseTimeoutMs*/ sctpOptions.initialRtoMs,
-		        /*backoffAlgorithm*/ BackoffTimerHandle::BackoffAlgorithm::EXPONENTIAL,
-		        /*maxBackoffTimeoutMs*/ sctpOptions.timerMaxBackoffTimeoutMs,
-		        /*maxRestarts*/ std::nullopt)),
-		    timeoutTimer(
-		      std::make_unique<BackoffTimerHandle>(
-		        /*listener*/ this,
-		        /*baseTimeoutMs*/ sctpOptions.initialRtoMs,
-		        /*backoffAlgorithm*/ BackoffTimerHandle::BackoffAlgorithm::FIXED,
-		        /*maxBackoffTimeoutMs*/ std::nullopt,
-		        /*maxRestarts*/ 0))
+		    intervalTimer(this->shared->CreateBackoffTimer(
+		      BackoffTimerHandleInterface::BackoffTimerHandleOptions{
+		        .listener            = this,
+		        .label               = "sctp-heartbeat-interval",
+		        .baseTimeoutMs       = sctpOptions.initialRtoMs,
+		        .backoffAlgorithm    = BackoffTimerHandleInterface::BackoffAlgorithm::EXPONENTIAL,
+		        .maxBackoffTimeoutMs = sctpOptions.timerMaxBackoffTimeoutMs,
+		        .maxRestarts         = std::nullopt })),
+		    timeoutTimer(this->shared->CreateBackoffTimer(
+		      BackoffTimerHandleInterface::BackoffTimerHandleOptions{
+		        .listener            = this,
+		        .label               = "sctp-heartbeat-timeout",
+		        .baseTimeoutMs       = sctpOptions.initialRtoMs,
+		        .backoffAlgorithm    = BackoffTimerHandleInterface::BackoffAlgorithm::FIXED,
+		        .maxBackoffTimeoutMs = std::nullopt,
+		        .maxRestarts         = 0 }))
 		{
 			MS_TRACE();
+
+			// The interval timer must always be running as long as the association
+			// is up (so when the TCB is created, which is the one that creates the
+			// HeartbeatHandler.
+			RestartTimer();
 		}
 
 		HeartbeatHandler::~HeartbeatHandler()
@@ -100,7 +109,7 @@ namespace RTC
 
 			heartbeatAckChunk->Consolidate();
 
-			this->tcbContext->Send(packet.get());
+			this->tcbContext->SendPacket(packet.get());
 		}
 
 		void HeartbeatHandler::HandleReceivedHeartbeatAckChunk(
@@ -141,15 +150,15 @@ namespace RTC
 			}
 
 			const uint64_t createdAtMs = Utils::Byte::Get8Bytes(info, 0);
-			const uint64_t nowMs       = DepLibUV::GetTimeMs();
+			const uint64_t nowMs       = this->shared->GetTimeMs();
 
 			if (createdAtMs > 0 && createdAtMs <= nowMs)
 			{
-				const uint64_t rtt = nowMs - createdAtMs;
+				const uint64_t rttMs = nowMs - createdAtMs;
 
-				MS_DEBUG_DEV("valid HEARTBEAT_ACK Chunk received, calling ObserveRtt(%" PRIu64 ")", rtt);
+				MS_DEBUG_DEV("valid HEARTBEAT_ACK Chunk received, calling ObserveRttMs(%" PRIu64 ")", rttMs);
 
-				this->tcbContext->ObserveRtt(rtt);
+				this->tcbContext->ObserveRttMs(rttMs);
 			}
 			else
 			{
@@ -178,19 +187,12 @@ namespace RTC
 				return;
 			}
 
-			const auto maxRestarts = this->intervalTimer->GetMaxRestarts();
-
-			MS_DEBUG_TAG(
-			  sctp,
-			  "interval timer has expired %zu/%s]",
-			  this->intervalTimer->GetExpirationCount(),
-			  maxRestarts ? std::to_string(maxRestarts.value()).c_str() : "Infinite");
-
 			this->timeoutTimer->SetBaseTimeoutMs(this->tcbContext->GetCurrentRtoMs());
 			this->timeoutTimer->Start();
 
 			alignas(8) uint8_t info[HeartbeatInfoLength];
-			const uint64_t nowMs = DepLibUV::GetTimeMs();
+
+			const uint64_t nowMs = this->shared->GetTimeMs();
 
 			Utils::Byte::Set8Bytes(info, 0, nowMs);
 
@@ -205,21 +207,13 @@ namespace RTC
 
 			MS_DEBUG_DEV("sending HEARTBEAT_REQUEST Chunk with info content [nowMs:%" PRIu64 "]", nowMs);
 
-			this->tcbContext->Send(packet.get());
+			this->tcbContext->SendPacket(packet.get());
 		}
 
 		void HeartbeatHandler::OnTimeoutTimer(uint64_t& /*baseTimeoutMs*/, bool& /*stop*/)
 		{
 			MS_TRACE();
 
-			const auto maxRestarts = this->timeoutTimer->GetMaxRestarts();
-
-			MS_DEBUG_TAG(
-			  sctp,
-			  "timeout timer has expired %zu/%s]",
-			  this->timeoutTimer->GetExpirationCount(),
-			  maxRestarts ? std::to_string(maxRestarts.value()).c_str() : "Infinite");
-
 			// Note that the timeout timer is not restarted. It will be started again when
 			// the interval timer expires.
 			MS_ASSERT(!this->timeoutTimer->IsRunning(), "timeout timer shouldn't be running");
@@ -227,10 +221,20 @@ namespace RTC
 			this->tcbContext->IncrementTxErrorCounter("hearbeat timeout");
 		}
 
-		void HeartbeatHandler::OnTimer(BackoffTimerHandle* backoffTimer, uint64_t& baseTimeoutMs, bool& stop)
+		void HeartbeatHandler::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->intervalTimer.get())
 			{
 				OnIntervalTimer(baseTimeoutMs, stop);

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

@@ -8,7 +8,7 @@ namespace RTC
 {
 	namespace SCTP
 	{
-		PacketSender::PacketSender(Listener* listener, AssociationListener& associationListener)
+		PacketSender::PacketSender(Listener* listener, AssociationListenerInterface& associationListener)
 		  : listener(listener), associationListener(associationListener)
 		{
 			MS_TRACE();
@@ -23,18 +23,18 @@ namespace RTC
 		{
 			MS_TRACE();
 
-			if (writeChecksum)
+			if (packet->GetChunksCount() == 0)
 			{
-				packet->WriteCRC32cChecksum();
+				return false;
 			}
 
-			// TODO: SCTP: For testing purposes. Must be removed.
+			if (writeChecksum)
 			{
-				MS_DUMP(">>> sending SCTP packet:");
-
-				packet->Dump();
+				packet->WriteCRC32cChecksum();
 			}
 
+			MS_ASSERT(!packet->NeedsConsolidation(), "cannot send a SCTP packet that needs consolidation");
+
 			const bool sent =
 			  this->associationListener.OnAssociationSendData(packet->GetBuffer(), packet->GetLength());
 
@@ -42,7 +42,7 @@ namespace RTC
 
 			if (!sent)
 			{
-				MS_WARN_TAG(sctp, "coudln't send SCTP Packet");
+				MS_WARN_TAG(sctp, "couldn't send SCTP Packet");
 			}
 
 			return sent;

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

@@ -1,10 +1,8 @@
 #define MS_CLASS "RTC::SCTP::StreamResetHandler"
-// TODO: SCTP: COMMENT
-#define MS_LOG_DEV_LEVEL 3
+// #define MS_LOG_DEV_LEVEL 3
 
 #include "RTC/SCTP/association/StreamResetHandler.hpp"
 #include "Logger.hpp"
-#include "RTC/Consts.hpp"
 #include "RTC/SCTP/packet/Parameter.hpp"
 #include "RTC/SCTP/packet/parameters/ReconfigurationResponseParameter.hpp"
 
@@ -12,28 +10,30 @@ namespace RTC
 {
 	namespace SCTP
 	{
-		/* Static. */
-
-		alignas(4) thread_local static uint8_t ChunkFactoryBuffer[RTC::Consts::MaxSafeMtuSizeForSctp];
-
 		/* Instance methods. */
 
 		StreamResetHandler::StreamResetHandler(
-		  AssociationListener& associationListener, TCBContext* tcbContext
-		  // TODO: SCTP: Implement
-		  // DataTracker* dataTracker,
-		  // ReassemblyQueue* reassemblyQueue,
-		  // RetransmissionQueue* retransmissionQueue
-		  )
+		  AssociationListenerInterface& associationListener,
+		  SharedInterface* shared,
+		  TransmissionControlBlockContextInterface* tcbContext,
+		  DataTracker* dataTracker,
+		  ReassemblyQueue* reassemblyQueue,
+		  RetransmissionQueue* retransmissionQueue)
 		  : associationListener(associationListener),
+		    shared(shared),
 		    tcbContext(tcbContext),
-		    reConfigTimer(
-		      std::make_unique<BackoffTimerHandle>(
-		        /*listener*/ this,
-		        /*baseTimeoutMs*/ 0,
-		        /*backoffAlgorithm*/ BackoffTimerHandle::BackoffAlgorithm::EXPONENTIAL,
-		        /*maxBackoffTimeoutMs*/ std::nullopt,
-		        /*maxRestarts*/ std::nullopt)),
+		    dataTracker(dataTracker),
+		    reassemblyQueue(reassemblyQueue),
+		    retransmissionQueue(retransmissionQueue),
+		    reConfigTimer(this->shared->CreateBackoffTimer(
+		      BackoffTimerHandleInterface::BackoffTimerHandleOptions{
+		        .listener            = this,
+		        .label               = "sctp-re-config",
+		        .baseTimeoutMs       = 0,
+		        .backoffAlgorithm    = BackoffTimerHandleInterface::BackoffAlgorithm::EXPONENTIAL,
+		        .maxBackoffTimeoutMs = std::nullopt,
+		        .maxRestarts         = std::nullopt,
+		      })),
 		    nextOutgoingReqSeqNbr(tcbContext->GetLocalInitialTsn()),
 		    lastProcessedReqSeqNbr(
 		      this->incomingReConfigRequestSnUnwrapper.Unwrap(tcbContext->GetRemoteInitialTsn() - 1)),
@@ -47,18 +47,42 @@ namespace RTC
 			MS_TRACE();
 		}
 
-		void StreamResetHandler::ResetStreams(std::span<const uint16_t> /*outgoingStreamIds*/)
+		void StreamResetHandler::ResetStreams(std::span<const uint16_t> outgoingStreamIds)
 		{
 			MS_TRACE();
 
-			// TODO: SCTP: Uncomment.
-			// for (const auto streamId : outgoingStreamIds)
+			for (const auto streamId : outgoingStreamIds)
 			{
-				// TODO: SCTP: Implement it.
-				// this->retransmissionQueue->PrepareResetStream(streamId);
+				this->retransmissionQueue->PrepareResetStream(streamId);
 			}
 		}
 
+		bool StreamResetHandler::ShouldSendStreamResetRequest() const
+		{
+			MS_TRACE();
+
+			// Only send stream resets if there are streams to reset and no current
+			// ongoing request (there can only be one at a time).
+			return !this->currentRequest.has_value() &&
+			       this->retransmissionQueue->HasStreamsReadyToBeReset();
+		}
+
+		void StreamResetHandler::AddStreamResetRequest(Packet* packet)
+		{
+			MS_TRACE();
+
+			MS_ASSERT(ShouldSendStreamResetRequest(), "should not send a stream reset request");
+
+			this->currentRequest.emplace(
+			  this->retransmissionQueue->GetLastAssignedTsn(),
+			  this->retransmissionQueue->BeginResetStreams());
+
+			this->reConfigTimer->SetBaseTimeoutMs(this->tcbContext->GetCurrentRtoMs());
+			this->reConfigTimer->Start();
+
+			AddReConfigChunk(packet);
+		}
+
 		void StreamResetHandler::HandleReceivedReConfigChunk(const ReConfigChunk* receivedReConfigChunk)
 		{
 			MS_TRACE();
@@ -114,7 +138,7 @@ namespace RTC
 
 			if (reConfigChunk->GetParametersCount() > 0)
 			{
-				this->tcbContext->Send(packet.get());
+				this->tcbContext->SendPacket(packet.get());
 			}
 		}
 
@@ -169,32 +193,7 @@ namespace RTC
 			return false;
 		}
 
-		ReConfigChunk* StreamResetHandler::CreateStreamResetRequest()
-		{
-			MS_TRACE();
-
-			// Only send stream resets if there are streams to reset, and no current
-			// ongoing request (there can only be one at a time), and if the stream
-			// can be reset.
-			// TODO: SCTP: Implement it.
-			// if (this->currentRequest.has_value() ||
-			//     !this->retransmissionQueue->HasStreamsReadyToBeReset())
-			// {
-			//   return nullptr;
-			// }
-
-			// TODO: SCTP: Implement it.
-			// this->currentRequest.emplace(
-			//   this->retransmissionQueue->GetLastAssignedTsn(),
-			//   this->retransmissionQueue->BeginResetStreams());
-
-			this->reConfigTimer->SetBaseTimeoutMs(this->tcbContext->GetCurrentRtoMs());
-			this->reConfigTimer->Start();
-
-			return CreateReconfigChunk();
-		}
-
-		ReConfigChunk* StreamResetHandler::CreateReconfigChunk()
+		void StreamResetHandler::AddReConfigChunk(Packet* packet)
 		{
 			MS_TRACE();
 
@@ -205,13 +204,13 @@ namespace RTC
 			// `reqSeqNbr` will be used.
 			MS_ASSERT(this->currentRequest.has_value(), "currentRequest optional must have value");
 
-			if (this->currentRequest->HasBeenSent())
+			if (!this->currentRequest->HasBeenSent())
 			{
 				this->currentRequest->PrepareToSend(this->nextOutgoingReqSeqNbr);
 				this->nextOutgoingReqSeqNbr = uint32_t{ this->nextOutgoingReqSeqNbr + 1 };
 			}
 
-			auto* reConfigChunk = ReConfigChunk::Factory(ChunkFactoryBuffer, sizeof(ChunkFactoryBuffer));
+			auto* reConfigChunk = packet->BuildChunkInPlace<ReConfigChunk>();
 			auto* outgoingSsnResetRequestParameter =
 			  reConfigChunk->BuildParameterInPlace<OutgoingSsnResetRequestParameter>();
 
@@ -228,8 +227,7 @@ namespace RTC
 			}
 
 			outgoingSsnResetRequestParameter->Consolidate();
-
-			return reConfigChunk;
+			reConfigChunk->Consolidate();
 		}
 
 		StreamResetHandler::ReqSeqNbrValidationResult StreamResetHandler::ValidateReqSeqNbr(
@@ -302,44 +300,50 @@ namespace RTC
 			// "In Progress" request. In all cases, re-evaluate the state.
 			this->lastProcessedReqSeqNbr = requestSn;
 
-			// // TODO: SCTP implement.
-			// if (this->dataTracker->IsLaterThanCumulativeAckedTsn(
-			//         receivedOutgoingSsnResetRequestParameter->GetSenderLastAssignedTsn()))
-			// {
-			//   // https://datatracker.ietf.org/doc/html/rfc6525#section-5.2.2
-			//   //
-			//   // E2) "If the Sender's Last Assigned TSN is greater than the cumulative
-			//   // acknowledgment point, then the endpoint MUST enter 'deferred reset
-			//   // processing'."
-			//   this->reassemblyQueue->EnterDeferredReset(
-			//   	receivedOutgoingSsnResetRequestParameter->GetSenderLastAssignedTsn(),
-			//   	receivedOutgoingSsnResetRequestParameter->GetStreamIds());
-
-			//   // "If the endpoint enters 'deferred reset processing', it MUST put a
-			//   // Re-configuration Response Parameter into a RE-CONFIG chunk indicating
-			//   // 'In progress' and MUST send the RE-CONFIG chunk.
-			//   this->lastProcessedReqResult = ReconfigurationResponseParameter::Result::IN_PROGRESS;
-
-			//  	MS_DEBUG_DEV("reset outgoing in progress, sender last assigned tsn %" PRIu32 " not yet
-			//  reached", receivedOutgoingSsnResetRequestParameter->GetSenderLastAssignedTsn());
-			// } else {
-			//   // https://datatracker.ietf.org/doc/html/rfc6525#section-5.2.2
-			//   //
-			//   // E3) If no stream numbers are listed in the parameter, then all incoming
-			//   // streams MUST be reset to 0 as the next expected SSN. If specific stream
-			//   // numbers are listed, then only these specific streams MUST be reset to
-			//   // 0, and all other non-listed SSNs remain unchanged. E4: Any queued TSNs
-			//   // (queued at step E2) MUST now be released and processed normally.
-			//   this->reassemblyQueue->ResetStreamsAndLeaveDeferredReset(receivedOutgoingSsnResetRequestParameter->GetStreamIds());
-
-			//   this->associationListener.OnAssociationInboundStreamsReset(receivedOutgoingSsnResetRequestParameter->GetStreamIds());
-
-			//   this->lastProcessedReqResult = ReconfigurationResponseParameter::Result::SUCCESS_PERFORMED;
-
-			//   MS_DEBUG_DEV("reset outgoing performed");
-			//  	MS_DEBUG_DEV("reset outgoing performed, sender last assigned tsn %" PRIu32 " reached",
-			//  receivedOutgoingSsnResetRequestParameter->GetSenderLastAssignedTsn());
-			// }
+			if (
+			  this->dataTracker->IsLaterThanCumulativeAckedTsn(
+			    receivedOutgoingSsnResetRequestParameter->GetSenderLastAssignedTsn()))
+			{
+				// https://datatracker.ietf.org/doc/html/rfc6525#section-5.2.2
+				//
+				// E2) "If the Sender's Last Assigned TSN is greater than the cumulative
+				// acknowledgment point, then the endpoint MUST enter 'deferred reset
+				// processing'."
+				this->reassemblyQueue->EnterDeferredReset(
+				  receivedOutgoingSsnResetRequestParameter->GetSenderLastAssignedTsn(),
+				  receivedOutgoingSsnResetRequestParameter->GetStreamIds());
+
+				// "If the endpoint enters 'deferred reset processing', it MUST put a
+				// Re-configuration Response Parameter into a RE-CONFIG chunk indicating
+				// 'In progress' and MUST send the RE-CONFIG chunk.
+				this->lastProcessedReqResult = ReconfigurationResponseParameter::Result::IN_PROGRESS;
+
+				MS_DEBUG_DEV(
+				  "reset outgoing in progress, sender last assigned tsn %" PRIu32 " not yet reached",
+				  receivedOutgoingSsnResetRequestParameter->GetSenderLastAssignedTsn());
+			}
+			else
+			{
+				// https://datatracker.ietf.org/doc/html/rfc6525#section-5.2.2
+				//
+				// E3) If no stream numbers are listed in the parameter, then all incoming
+				// streams MUST be reset to 0 as the next expected SSN. If specific stream
+				// numbers are listed, then only these specific streams MUST be reset to
+				// 0, and all other non-listed SSNs remain unchanged. E4: Any queued TSNs
+				// (queued at step E2) MUST now be released and processed normally.
+				this->reassemblyQueue->ResetStreamsAndLeaveDeferredReset(
+				  receivedOutgoingSsnResetRequestParameter->GetStreamIds());
+
+				this->associationListener.OnAssociationInboundStreamsReset(
+				  receivedOutgoingSsnResetRequestParameter->GetStreamIds());
+
+				this->lastProcessedReqResult = ReconfigurationResponseParameter::Result::SUCCESS_PERFORMED;
+
+				MS_DEBUG_DEV("reset outgoing performed");
+				MS_DEBUG_DEV(
+				  "reset outgoing performed, sender last assigned tsn %" PRIu32 " reached",
+				  receivedOutgoingSsnResetRequestParameter->GetSenderLastAssignedTsn());
+			}
 
 			auto* reconfigurationResponseParameter =
 			  reConfigChunk->BuildParameterInPlace<ReconfigurationResponseParameter>();
@@ -413,8 +417,7 @@ namespace RTC
 
 						this->currentRequest = std::nullopt;
 
-						// TODO: SCTP: Implement it.
-						// this->retransmissionQueue->CommitResetSteam();
+						this->retransmissionQueue->CommitResetStreams();
 
 						break;
 					}
@@ -454,8 +457,7 @@ namespace RTC
 
 						this->currentRequest = std::nullopt;
 
-						// TODO: SCTP: Implement it.
-						// this->retransmissionQueue->RollbackResetStreams();
+						this->retransmissionQueue->RollbackResetStreams();
 
 						break;
 					}
@@ -492,17 +494,27 @@ namespace RTC
 
 			auto packet = this->tcbContext->CreatePacket();
 
-			packet->AddChunk(CreateReconfigChunk());
+			AddReConfigChunk(packet.get());
 
-			this->tcbContext->Send(packet.get());
+			this->tcbContext->SendPacket(packet.get());
 
 			baseTimeoutMs = this->tcbContext->GetCurrentRtoMs();
 		}
 
-		void StreamResetHandler::OnTimer(BackoffTimerHandle* backoffTimer, uint64_t& baseTimeoutMs, bool& stop)
+		void StreamResetHandler::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->reConfigTimer.get())
 			{
 				OnReConfigTimer(baseTimeoutMs, stop);