mediasoup 3.19.21 → 3.19.22

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

@@ -17,6 +17,7 @@
 #include "RTC/SCTP/packet/parameters/StateCookieParameter.hpp"
 #include "RTC/SCTP/packet/parameters/SupportedExtensionsParameter.hpp"
 #include "RTC/SCTP/packet/parameters/ZeroChecksumAcceptableParameter.hpp"
+#include "handles/BackoffTimerHandle.hpp"
 #include <limits>  // std::numeric_limits()
 #include <sstream> // std::ostringstream
 #include <string>
@@ -39,33 +40,36 @@ namespace RTC
 
 		/* Instance methods. */
 
-		Association::Association(const SctpOptions& sctpOptions, AssociationListener* listener)
+		Association::Association(
+		  const SctpOptions& sctpOptions, AssociationListener* listener, SharedInterface* shared)
 		  : sctpOptions(sctpOptions),
 		    // Our `listener` member is a `AssociationListenerDeferrer` which takes
 		    // `AssociationListener` as constructor argument.
 		    listener(listener),
+		    shared(shared),
 		    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))
+		    t1InitTimer(this->shared->CreateBackoffTimer(
+		      BackoffTimerHandleInterface::BackoffTimerHandleOptions{
+		        .listener            = this,
+		        .baseTimeoutMs       = sctpOptions.t1InitTimeoutMs,
+		        .backoffAlgorithm    = BackoffTimerHandleInterface::BackoffAlgorithm::EXPONENTIAL,
+		        .maxBackoffTimeoutMs = sctpOptions.timerMaxBackoffTimeoutMs,
+		        .maxRestarts         = sctpOptions.maxInitRetransmissions,
+		      })),
+		    t1CookieTimer(this->shared->CreateBackoffTimer(
+		      BackoffTimerHandleInterface::BackoffTimerHandleOptions{
+		        .listener            = this,
+		        .baseTimeoutMs       = sctpOptions.t1CookieTimeoutMs,
+		        .backoffAlgorithm    = BackoffTimerHandleInterface::BackoffAlgorithm::EXPONENTIAL,
+		        .maxBackoffTimeoutMs = sctpOptions.timerMaxBackoffTimeoutMs,
+		        .maxRestarts         = sctpOptions.maxInitRetransmissions })),
+		    t2ShutdownTimer(this->shared->CreateBackoffTimer(
+		      BackoffTimerHandleInterface::BackoffTimerHandleOptions{
+		        .listener            = this,
+		        .baseTimeoutMs       = sctpOptions.t2ShutdownTimeoutMs,
+		        .backoffAlgorithm    = BackoffTimerHandleInterface::BackoffAlgorithm::EXPONENTIAL,
+		        .maxBackoffTimeoutMs = sctpOptions.timerMaxBackoffTimeoutMs,
+		        .maxRestarts         = sctpOptions.maxRetransmissions }))
 		{
 			MS_TRACE();
 		}
@@ -342,15 +346,15 @@ namespace RTC
 				.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(),
+				.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(),
-				.peerImplementation           = this->privateMetrics.peerImplementation,
+				.peerRwndBytes      = static_cast<uint32_t>(this->tcb->GetRetransmissionQueue().GetRwnd()),
+				.peerImplementation = this->privateMetrics.peerImplementation,
 				.negotiatedMaxOutboundStreams = this->privateMetrics.negotiatedMaxOutboundStreams,
 				.negotiatedMaxInboundStreams  = this->privateMetrics.negotiatedMaxInboundStreams,
 				.usesPartialReliability       = this->privateMetrics.usesPartialReliability,
@@ -419,7 +423,7 @@ namespace RTC
 			// this->sendQueue.SetBufferedAmountLowThreshold(streamId, bytes);
 		}
 
-		Types::ResetStreamsStatus Association::ResetStreams(std::span<const uint16_t> /*outboundStreamIds*/)
+		Types::ResetStreamsStatus Association::ResetStreams(std::span<const uint16_t> outboundStreamIds)
 		{
 			MS_TRACE();
 
@@ -443,8 +447,7 @@ namespace RTC
 				return Types::ResetStreamsStatus::NOT_SUPPORTED;
 			}
 
-			// TODO: SCTP: Implement it.
-			// this->tcb->GetStreamResetHandler().ResetStreams(outboundStreamIds);
+			this->tcb->GetStreamResetHandler().ResetStreams(outboundStreamIds);
 
 			MaySendResetStreamsRequest();
 			AssertStateIsConsistent();
@@ -467,17 +470,17 @@ namespace RTC
 			}
 
 			// TODO: SCTP: Uncomment.
-			// const uint64_t now = DepLibUV::GetTimeMs();
+			// const uint64_t nowMs = DepLibUV::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();
@@ -493,7 +496,7 @@ namespace RTC
 			const AssociationListenerDeferrer::ScopedDeferrer deferrer(this->listener);
 
 			// TODO: SCTP: Uncomment.
-			// const uint64_t now = DepLibUV::GetTimeMs();
+			// const uint64_t nowMs = DepLibUV::GetTimeMs();
 			std::vector<Types::SendMessageStatus> statuses;
 
 			statuses.reserve(messages.size());
@@ -512,13 +515,13 @@ 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();
@@ -726,6 +729,7 @@ namespace RTC
 			this->tcb = std::make_unique<TransmissionControlBlock>(
 			  this->listener,
 			  this->sctpOptions,
+			  this->shared,
 			  this->packetSender,
 			  localVerificationTag,
 			  remoteVerificationTag,
@@ -836,10 +840,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 +917,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().ShouldCreateStreamResetRequest())
+			{
+				auto packet = this->tcb->CreatePacket();
 
-			// this->packetSender.SendPacket(packet.get());
+				this->tcb->GetStreamResetHandler().CreateStreamResetRequest(packet.get());
+				this->packetSender.SendPacket(packet.get());
+			}
 		}
 
 		void Association::MayDeliverMessages()
@@ -1620,7 +1600,7 @@ namespace RTC
 			// 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());
+			// this->tcb->SendBufferedPackets(nowMs);
 
 			this->t1CookieTimer->Start();
 			this->listener.OnAssociationConnecting();
@@ -1721,7 +1701,7 @@ namespace RTC
 			// 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());
+			// this->tcb->SendBufferedPackets(packet.get(), nowMs);
 
 			// TODO: SCTP: Remove this since COOKIE_ACK must be sent by
 			// tcb->SendBufferedPackets() call above.
@@ -1845,7 +1825,7 @@ namespace RTC
 			SetState(State::ESTABLISHED, "COOKIE_ACK received");
 
 			// TODO: SCTP: Implement this.
-			// this->tcb->SendBufferedPackets(callbacks_.Now());
+			// this->tcb->SendBufferedPackets(nowMs);
 
 			this->listener.OnAssociationConnected();
 		}
@@ -2101,7 +2081,7 @@ namespace RTC
 		}
 
 		void Association::HandleReceivedReConfigChunk(
-		  const Packet* /*receivedPacket*/, const ReConfigChunk* /*receivedReConfigChunk*/)
+		  const Packet* /*receivedPacket*/, const ReConfigChunk* receivedReConfigChunk)
 		{
 			MS_TRACE();
 
@@ -2110,8 +2090,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
@@ -2122,7 +2101,7 @@ 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());
+			// 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.
@@ -2329,7 +2308,7 @@ namespace RTC
 		}
 
 		void Association::HandleReceivedSackChunk(
-		  const Packet* /*receivedPacket*/, const SackChunk* /*receivedSackChunk*/)
+		  const Packet* /*receivedPacket*/, const SackChunk* receivedSackChunk)
 		{
 			MS_TRACE();
 
@@ -2338,37 +2317,37 @@ 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 = DepLibUV::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.
+				// TODO: SCTP: Implement it.
+				// this->tcb->SendBufferedPackets(nowMs);
+			}
+			else
+			{
+				MS_WARN_TAG(
+				  sctp,
+				  "dropping received out-of-order SACK [TSN:%" PRIu32 "]",
+				  receivedSackChunk->GetCumulativeTsnAck());
+			}
 		}
 
 		bool Association::HandleReceivedUnknownChunk(
@@ -2435,7 +2414,7 @@ namespace RTC
 
 			MS_DEBUG_TAG(
 			  sctp,
-			  "T1-init timer has expired %zu/%s]",
+			  "T1-init timer has expired [%zu/%s]",
 			  this->t1InitTimer->GetExpirationCount(),
 			  maxRestarts ? std::to_string(maxRestarts.value()).c_str() : "Infinite");
 
@@ -2463,7 +2442,7 @@ namespace RTC
 
 			MS_DEBUG_TAG(
 			  sctp,
-			  "T1-cookie timer has expired %zu/%s]",
+			  "T1-cookie timer has expired [%zu/%s]",
 			  this->t1CookieTimer->GetExpirationCount(),
 			  maxRestarts ? std::to_string(maxRestarts.value()).c_str() : "Infinite");
 
@@ -2472,7 +2451,7 @@ namespace RTC
 			if (this->t1CookieTimer->IsRunning())
 			{
 				// TODO: SCTP: Implement it.
-				// this->tcb->SendBufferedPackets(now);
+				// this->tcb->SendBufferedPackets(nowMs);
 			}
 			else
 			{
@@ -2807,7 +2786,8 @@ namespace RTC
 			}
 		}
 
-		void Association::OnTimer(BackoffTimerHandle* backoffTimer, uint64_t& baseTimeoutMs, bool& stop)
+		void Association::OnTimer(
+		  BackoffTimerHandleInterface* backoffTimer, uint64_t& baseTimeoutMs, bool& stop)
 		{
 			MS_TRACE();
 

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

@@ -8,6 +8,7 @@
 #include "Utils.hpp"
 #include "RTC/SCTP/packet/parameters/HeartbeatInfoParameter.hpp"
 #include "RTC/SCTP/public/SctpTypes.hpp"
+#include "handles/BackoffTimerHandle.hpp"
 #include <string>
 
 namespace RTC
@@ -21,26 +22,30 @@ namespace RTC
 		/* Instance methods. */
 
 		HeartbeatHandler::HeartbeatHandler(
-		  AssociationListener& associationListener, const SctpOptions& sctpOptions, TCBContext* tcbContext)
+		  AssociationListener& associationListener,
+		  const SctpOptions& sctpOptions,
+		  SharedInterface* shared,
+		  TCBContext* 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,
+		        .baseTimeoutMs       = sctpOptions.initialRtoMs,
+		        .backoffAlgorithm    = BackoffTimerHandleInterface::BackoffAlgorithm::EXPONENTIAL,
+		        .maxBackoffTimeoutMs = sctpOptions.timerMaxBackoffTimeoutMs,
+		        .maxRestarts         = std::nullopt })),
+		    timeoutTimer(this->shared->CreateBackoffTimer(
+		      BackoffTimerHandleInterface::BackoffTimerHandleOptions{
+		        .listener            = this,
+		        .baseTimeoutMs       = sctpOptions.initialRtoMs,
+		        .backoffAlgorithm    = BackoffTimerHandleInterface::BackoffAlgorithm::FIXED,
+		        .maxBackoffTimeoutMs = std::nullopt,
+		        .maxRestarts         = 0 }))
 		{
 			MS_TRACE();
 		}
@@ -145,11 +150,11 @@ namespace RTC
 
 			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
 			{
@@ -182,7 +187,7 @@ namespace RTC
 
 			MS_DEBUG_TAG(
 			  sctp,
-			  "interval timer has expired %zu/%s]",
+			  "interval timer has expired [%zu/%s]",
 			  this->intervalTimer->GetExpirationCount(),
 			  maxRestarts ? std::to_string(maxRestarts.value()).c_str() : "Infinite");
 
@@ -216,7 +221,7 @@ namespace RTC
 
 			MS_DEBUG_TAG(
 			  sctp,
-			  "timeout timer has expired %zu/%s]",
+			  "timeout timer has expired [%zu/%s]",
 			  this->timeoutTimer->GetExpirationCount(),
 			  maxRestarts ? std::to_string(maxRestarts.value()).c_str() : "Infinite");
 
@@ -227,7 +232,8 @@ namespace RTC
 			this->tcbContext->IncrementTxErrorCounter("hearbeat timeout");
 		}
 
-		void HeartbeatHandler::OnTimer(BackoffTimerHandle* backoffTimer, uint64_t& baseTimeoutMs, bool& stop)
+		void HeartbeatHandler::OnTimer(
+		  BackoffTimerHandleInterface* backoffTimer, uint64_t& baseTimeoutMs, bool& stop)
 		{
 			MS_TRACE();
 

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

@@ -4,36 +4,36 @@
 
 #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"
+#include "handles/BackoffTimerHandle.hpp"
 
 namespace RTC
 {
 	namespace SCTP
 	{
-		/* Static. */
-
-		alignas(4) thread_local static uint8_t ChunkFactoryBuffer[RTC::Consts::MaxSafeMtuSizeForSctp];
-
 		/* Instance methods. */
 
 		StreamResetHandler::StreamResetHandler(
-		  AssociationListener& associationListener, TCBContext* tcbContext
+		  AssociationListener& associationListener,
+		  SharedInterface* shared,
+		  TCBContext* tcbContext,
 		  // TODO: SCTP: Implement
 		  // DataTracker* dataTracker,
 		  // ReassemblyQueue* reassemblyQueue,
-		  // RetransmissionQueue* retransmissionQueue
-		  )
+		  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)),
+		    retransmissionQueue(retransmissionQueue),
+		    reConfigTimer(this->shared->CreateBackoffTimer(
+		      BackoffTimerHandleInterface::BackoffTimerHandleOptions{
+		        .listener            = this,
+		        .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::ShouldCreateStreamResetRequest() 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::CreateStreamResetRequest(Packet* packet)
+		{
+			MS_TRACE();
+
+			MS_ASSERT(ShouldCreateStreamResetRequest(), "should not create a stream reset request");
+
+			this->currentRequest.emplace(
+			  this->retransmissionQueue->GetLastAssignedTsn(),
+			  this->retransmissionQueue->BeginResetStreams());
+
+			this->reConfigTimer->SetBaseTimeoutMs(this->tcbContext->GetCurrentRtoMs());
+			this->reConfigTimer->Start();
+
+			CreateReConfigChunk(packet);
+		}
+
 		void StreamResetHandler::HandleReceivedReConfigChunk(const ReConfigChunk* receivedReConfigChunk)
 		{
 			MS_TRACE();
@@ -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::CreateReConfigChunk(Packet* packet)
 		{
 			MS_TRACE();
 
@@ -211,7 +210,7 @@ namespace RTC
 				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(
@@ -413,8 +411,7 @@ namespace RTC
 
 						this->currentRequest = std::nullopt;
 
-						// TODO: SCTP: Implement it.
-						// this->retransmissionQueue->CommitResetSteam();
+						this->retransmissionQueue->CommitResetStreams();
 
 						break;
 					}
@@ -454,8 +451,7 @@ namespace RTC
 
 						this->currentRequest = std::nullopt;
 
-						// TODO: SCTP: Implement it.
-						// this->retransmissionQueue->RollbackResetStreams();
+						this->retransmissionQueue->RollbackResetStreams();
 
 						break;
 					}
@@ -492,14 +488,15 @@ namespace RTC
 
 			auto packet = this->tcbContext->CreatePacket();
 
-			packet->AddChunk(CreateReconfigChunk());
+			CreateReConfigChunk(packet.get());
 
 			this->tcbContext->Send(packet.get());
 
 			baseTimeoutMs = this->tcbContext->GetCurrentRtoMs();
 		}
 
-		void StreamResetHandler::OnTimer(BackoffTimerHandle* backoffTimer, uint64_t& baseTimeoutMs, bool& stop)
+		void StreamResetHandler::OnTimer(
+		  BackoffTimerHandleInterface* backoffTimer, uint64_t& baseTimeoutMs, bool& stop)
 		{
 			MS_TRACE();