mediasoup 3.19.19 → 3.19.21

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

@@ -0,0 +1,512 @@
+#define MS_CLASS "RTC::SCTP::StreamResetHandler"
+// TODO: SCTP: COMMENT
+#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"
+
+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
+		  )
+		  : associationListener(associationListener),
+		    tcbContext(tcbContext),
+		    reConfigTimer(
+		      std::make_unique<BackoffTimerHandle>(
+		        /*listener*/ this,
+		        /*baseTimeoutMs*/ 0,
+		        /*backoffAlgorithm*/ BackoffTimerHandle::BackoffAlgorithm::EXPONENTIAL,
+		        /*maxBackoffTimeoutMs*/ std::nullopt,
+		        /*maxRestarts*/ std::nullopt)),
+		    nextOutgoingReqSeqNbr(tcbContext->GetLocalInitialTsn()),
+		    lastProcessedReqSeqNbr(
+		      this->incomingReConfigRequestSnUnwrapper.Unwrap(tcbContext->GetRemoteInitialTsn() - 1)),
+		    lastProcessedReqResult(ReconfigurationResponseParameter::Result::SUCCESS_NOTHING_TO_DO)
+		{
+			MS_TRACE();
+		}
+
+		StreamResetHandler::~StreamResetHandler()
+		{
+			MS_TRACE();
+		}
+
+		void StreamResetHandler::ResetStreams(std::span<const uint16_t> /*outgoingStreamIds*/)
+		{
+			MS_TRACE();
+
+			// TODO: SCTP: Uncomment.
+			// for (const auto streamId : outgoingStreamIds)
+			{
+				// TODO: SCTP: Implement it.
+				// this->retransmissionQueue->PrepareResetStream(streamId);
+			}
+		}
+
+		void StreamResetHandler::HandleReceivedReConfigChunk(const ReConfigChunk* receivedReConfigChunk)
+		{
+			MS_TRACE();
+
+			if (!ValidateReceivedReConfigChunk(receivedReConfigChunk))
+			{
+				this->associationListener.OnAssociationError(
+				  Types::ErrorKind::PARSE_FAILED, "invalid RE-CONFIG command received");
+
+				return;
+			}
+
+			auto packet         = this->tcbContext->CreatePacket();
+			auto* reConfigChunk = packet->BuildChunkInPlace<ReConfigChunk>();
+
+			for (auto it = receivedReConfigChunk->ParametersBegin();
+			     it != receivedReConfigChunk->ParametersEnd();
+			     ++it)
+			{
+				const auto* parameter = *it;
+
+				switch (parameter->GetType())
+				{
+					case Parameter::ParameterType::OUTGOING_SSN_RESET_REQUEST:
+					{
+						HandleReceivedOutgoingSsnResetRequestParameter(
+						  reinterpret_cast<const OutgoingSsnResetRequestParameter*>(parameter), reConfigChunk);
+
+						break;
+					}
+
+					case Parameter::ParameterType::INCOMING_SSN_RESET_REQUEST:
+					{
+						HandleReceivedIncomingSsnResetRequestParameter(
+						  reinterpret_cast<const IncomingSsnResetRequestParameter*>(parameter), reConfigChunk);
+
+						break;
+					}
+
+					case Parameter::ParameterType::RECONFIGURATION_RESPONSE:
+					{
+						HandleReceivedReconfigurationResponseParameter(
+						  reinterpret_cast<const ReconfigurationResponseParameter*>(parameter));
+
+						break;
+					}
+
+					default:;
+				}
+			}
+
+			reConfigChunk->Consolidate();
+
+			if (reConfigChunk->GetParametersCount() > 0)
+			{
+				this->tcbContext->Send(packet.get());
+			}
+		}
+
+		bool StreamResetHandler::ValidateReceivedReConfigChunk(const ReConfigChunk* receivedReConfigChunk)
+		{
+			MS_TRACE();
+
+			if (receivedReConfigChunk->GetParametersCount() == 1)
+			{
+				const auto* firstParameter = receivedReConfigChunk->GetParameterAt(0);
+
+				if (
+				  firstParameter->GetType() == Parameter::ParameterType::OUTGOING_SSN_RESET_REQUEST ||
+				  firstParameter->GetType() == Parameter::ParameterType::INCOMING_SSN_RESET_REQUEST ||
+				  firstParameter->GetType() == Parameter::ParameterType::SSN_TSN_RESET_REQUEST ||
+				  firstParameter->GetType() == Parameter::ParameterType::ADD_OUTGOING_STREAMS_REQUEST ||
+				  firstParameter->GetType() == Parameter::ParameterType::ADD_INCOMING_STREAMS_REQUEST ||
+				  firstParameter->GetType() == Parameter::ParameterType::RECONFIGURATION_RESPONSE)
+				{
+					return true;
+				}
+			}
+			else if (receivedReConfigChunk->GetParametersCount() == 2)
+			{
+				const auto* firstParameter  = receivedReConfigChunk->GetParameterAt(0);
+				const auto* secondParameter = receivedReConfigChunk->GetParameterAt(1);
+
+				if (
+				  (firstParameter->GetType() == Parameter::ParameterType::OUTGOING_SSN_RESET_REQUEST &&
+				   secondParameter->GetType() == Parameter::ParameterType::INCOMING_SSN_RESET_REQUEST) ||
+				  (firstParameter->GetType() == Parameter::ParameterType::INCOMING_SSN_RESET_REQUEST &&
+				   secondParameter->GetType() == Parameter::ParameterType::OUTGOING_SSN_RESET_REQUEST) ||
+				  (firstParameter->GetType() == Parameter::ParameterType::ADD_OUTGOING_STREAMS_REQUEST &&
+				   secondParameter->GetType() == Parameter::ParameterType::ADD_INCOMING_STREAMS_REQUEST) ||
+				  (firstParameter->GetType() == Parameter::ParameterType::ADD_INCOMING_STREAMS_REQUEST &&
+				   secondParameter->GetType() == Parameter::ParameterType::ADD_OUTGOING_STREAMS_REQUEST) ||
+				  (firstParameter->GetType() == Parameter::ParameterType::RECONFIGURATION_RESPONSE &&
+				   secondParameter->GetType() == Parameter::ParameterType::OUTGOING_SSN_RESET_REQUEST) ||
+				  (firstParameter->GetType() == Parameter::ParameterType::OUTGOING_SSN_RESET_REQUEST &&
+				   secondParameter->GetType() == Parameter::ParameterType::RECONFIGURATION_RESPONSE) ||
+				  (firstParameter->GetType() == Parameter::ParameterType::RECONFIGURATION_RESPONSE &&
+				   secondParameter->GetType() == Parameter::ParameterType::RECONFIGURATION_RESPONSE) ||
+				  (firstParameter->GetType() == Parameter::ParameterType::RECONFIGURATION_RESPONSE &&
+				   secondParameter->GetType() == Parameter::ParameterType::RECONFIGURATION_RESPONSE))
+				{
+					return true;
+				}
+			}
+
+			MS_WARN_TAG(sctp, "invalid set of RE-CONFIG Parameters");
+
+			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()
+		{
+			MS_TRACE();
+
+			// The `reqSeqNbr` will be empty if the request has never been sent before,
+			// or if it was sent, but the sender responded "in progress", and then the
+			// `reqSeqNbr` will be cleared to re-send with a new number. But if the
+			// request is re-sent due to timeout (re-config timer expiring), the same
+			// `reqSeqNbr` will be used.
+			MS_ASSERT(this->currentRequest.has_value(), "currentRequest optional must have value");
+
+			if (this->currentRequest->HasBeenSent())
+			{
+				this->currentRequest->PrepareToSend(this->nextOutgoingReqSeqNbr);
+				this->nextOutgoingReqSeqNbr = uint32_t{ this->nextOutgoingReqSeqNbr + 1 };
+			}
+
+			auto* reConfigChunk = ReConfigChunk::Factory(ChunkFactoryBuffer, sizeof(ChunkFactoryBuffer));
+			auto* outgoingSsnResetRequestParameter =
+			  reConfigChunk->BuildParameterInPlace<OutgoingSsnResetRequestParameter>();
+
+			outgoingSsnResetRequestParameter->SetReconfigurationRequestSequenceNumber(
+			  this->currentRequest->GetReqSeqNbr());
+			outgoingSsnResetRequestParameter->SetReconfigurationResponseSequenceNumber(
+			  this->currentRequest->GetReqSeqNbr());
+			outgoingSsnResetRequestParameter->SetSenderLastAssignedTsn(
+			  this->currentRequest->GetSenderLastAssignedTsn());
+
+			for (const auto& streamId : this->currentRequest->GetStreamIds())
+			{
+				outgoingSsnResetRequestParameter->AddStreamId(streamId);
+			}
+
+			outgoingSsnResetRequestParameter->Consolidate();
+
+			return reConfigChunk;
+		}
+
+		StreamResetHandler::ReqSeqNbrValidationResult StreamResetHandler::ValidateReqSeqNbr(
+		  StreamResetHandler::UnwrappedReConfigRequestSn reqSeqNbr)
+		{
+			MS_TRACE();
+
+			if (reqSeqNbr == this->lastProcessedReqSeqNbr)
+			{
+				return ReqSeqNbrValidationResult::RETRANSMISSION;
+			}
+			else if (reqSeqNbr != this->lastProcessedReqSeqNbr.GetNextValue())
+			{
+				// Too old, too new, from wrong Association, etc.
+				MS_WARN_TAG(sctp, "bad reqSeqNbr: %" PRIu32, reqSeqNbr.Wrap());
+
+				return ReqSeqNbrValidationResult::BAD_SEQUENCE_NUMBER;
+			}
+			else
+			{
+				return ReqSeqNbrValidationResult::VALID;
+			}
+		}
+
+		void StreamResetHandler::HandleReceivedOutgoingSsnResetRequestParameter(
+		  const OutgoingSsnResetRequestParameter* receivedOutgoingSsnResetRequestParameter,
+		  ReConfigChunk* reConfigChunk)
+		{
+			MS_TRACE();
+
+			const UnwrappedReConfigRequestSn requestSn = this->incomingReConfigRequestSnUnwrapper.Unwrap(
+			  receivedOutgoingSsnResetRequestParameter->GetReconfigurationRequestSequenceNumber());
+			const ReqSeqNbrValidationResult validationResult = ValidateReqSeqNbr(requestSn);
+
+			if (validationResult == ReqSeqNbrValidationResult::BAD_SEQUENCE_NUMBER)
+			{
+				auto* reconfigurationResponseParameter =
+				  reConfigChunk->BuildParameterInPlace<ReconfigurationResponseParameter>();
+
+				reconfigurationResponseParameter->SetReconfigurationResponseSequenceNumber(
+				  receivedOutgoingSsnResetRequestParameter->GetReconfigurationRequestSequenceNumber());
+				reconfigurationResponseParameter->SetResult(
+				  ReconfigurationResponseParameter::Result::ERROR_BAD_SEQUENCE_NUMBER);
+
+				reconfigurationResponseParameter->Consolidate();
+
+				return;
+			}
+
+			// If this is a retransmission of a request that has already been finalized
+			// (i.e., not "In Progress"), just send the previous final response.
+			if (
+			  validationResult == ReqSeqNbrValidationResult::RETRANSMISSION &&
+			  this->lastProcessedReqResult != ReconfigurationResponseParameter::Result::IN_PROGRESS)
+			{
+				auto* reconfigurationResponseParameter =
+				  reConfigChunk->BuildParameterInPlace<ReconfigurationResponseParameter>();
+
+				reconfigurationResponseParameter->SetReconfigurationResponseSequenceNumber(
+				  receivedOutgoingSsnResetRequestParameter->GetReconfigurationRequestSequenceNumber());
+				reconfigurationResponseParameter->SetResult(this->lastProcessedReqResult);
+
+				reconfigurationResponseParameter->Consolidate();
+
+				return;
+			}
+
+			// At this point, the request is either brand new, a buggy client sending
+			// a new SN after "In Progress", or a compliant client retransmitting an
+			// "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());
+			// }
+
+			auto* reconfigurationResponseParameter =
+			  reConfigChunk->BuildParameterInPlace<ReconfigurationResponseParameter>();
+
+			reconfigurationResponseParameter->SetReconfigurationResponseSequenceNumber(
+			  receivedOutgoingSsnResetRequestParameter->GetReconfigurationRequestSequenceNumber());
+			reconfigurationResponseParameter->SetResult(this->lastProcessedReqResult);
+
+			reconfigurationResponseParameter->Consolidate();
+		}
+
+		void StreamResetHandler::HandleReceivedIncomingSsnResetRequestParameter(
+		  const IncomingSsnResetRequestParameter* receivedIncomingSsnResetRequestParameter,
+		  ReConfigChunk* reConfigChunk)
+		{
+			MS_TRACE();
+
+			const UnwrappedReConfigRequestSn requestSn = this->incomingReConfigRequestSnUnwrapper.Unwrap(
+			  receivedIncomingSsnResetRequestParameter->GetReconfigurationRequestSequenceNumber());
+			const ReqSeqNbrValidationResult validationResult = ValidateReqSeqNbr(requestSn);
+
+			if (validationResult == ReqSeqNbrValidationResult::VALID || validationResult == ReqSeqNbrValidationResult::RETRANSMISSION)
+			{
+				auto* reconfigurationResponseParameter =
+				  reConfigChunk->BuildParameterInPlace<ReconfigurationResponseParameter>();
+
+				reconfigurationResponseParameter->SetReconfigurationResponseSequenceNumber(
+				  receivedIncomingSsnResetRequestParameter->GetReconfigurationRequestSequenceNumber());
+				reconfigurationResponseParameter->SetResult(
+				  ReconfigurationResponseParameter::Result::SUCCESS_NOTHING_TO_DO);
+
+				reconfigurationResponseParameter->Consolidate();
+			}
+			else
+			{
+				auto* reconfigurationResponseParameter =
+				  reConfigChunk->BuildParameterInPlace<ReconfigurationResponseParameter>();
+
+				reconfigurationResponseParameter->SetReconfigurationResponseSequenceNumber(
+				  receivedIncomingSsnResetRequestParameter->GetReconfigurationRequestSequenceNumber());
+				reconfigurationResponseParameter->SetResult(
+				  ReconfigurationResponseParameter::Result::ERROR_BAD_SEQUENCE_NUMBER);
+
+				reconfigurationResponseParameter->Consolidate();
+			}
+		}
+
+		void StreamResetHandler::HandleReceivedReconfigurationResponseParameter(
+		  const ReconfigurationResponseParameter* receivedReconfigurationResponseParameter)
+
+		{
+			MS_TRACE();
+
+			if (
+			  this->currentRequest.has_value() && this->currentRequest->HasBeenSent() &&
+			  receivedReconfigurationResponseParameter->GetReconfigurationResponseSequenceNumber() ==
+			    this->currentRequest->GetReqSeqNbr())
+			{
+				this->reConfigTimer->Stop();
+
+				switch (receivedReconfigurationResponseParameter->GetResult())
+				{
+					case RTC::SCTP::ReconfigurationResponseParameter::Result::SUCCESS_NOTHING_TO_DO:
+					case RTC::SCTP::ReconfigurationResponseParameter::Result::SUCCESS_PERFORMED:
+					{
+						MS_DEBUG_DEV(
+						  "reset stream success [reqSeqNbr:%" PRIu32 "]", this->currentRequest->GetReqSeqNbr());
+
+						this->associationListener.OnAssociationStreamsResetPerformed(
+						  this->currentRequest->GetStreamIds());
+
+						this->currentRequest = std::nullopt;
+
+						// TODO: SCTP: Implement it.
+						// this->retransmissionQueue->CommitResetSteam();
+
+						break;
+					}
+
+					case RTC::SCTP::ReconfigurationResponseParameter::Result::IN_PROGRESS:
+					{
+						MS_DEBUG_DEV(
+						  "reset stream still pending [reqSeqNbr:%" PRIu32 "]",
+						  this->currentRequest->GetReqSeqNbr());
+
+						// Force this request to be sent again, but with the same `reqSeqNbr`.
+						this->currentRequest->SetDeferred(true);
+
+						this->reConfigTimer->SetBaseTimeoutMs(this->tcbContext->GetCurrentRtoMs());
+						this->reConfigTimer->Start();
+
+						break;
+					}
+
+					case RTC::SCTP::ReconfigurationResponseParameter::Result::ERROR_REQUEST_ALREADY_IN_PROGRESS:
+					case RTC::SCTP::ReconfigurationResponseParameter::Result::DENIED:
+					case RTC::SCTP::ReconfigurationResponseParameter::Result::ERROR_WRONG_SSN:
+					case RTC::SCTP::ReconfigurationResponseParameter::Result::ERROR_BAD_SEQUENCE_NUMBER:
+					{
+						MS_WARN_TAG(
+						  sctp,
+						  "reset stream error [reqSeqNbr:%" PRIu32 ", result:%s]",
+						  this->currentRequest->GetReqSeqNbr(),
+						  ReconfigurationResponseParameter::ResultToString(
+						    receivedReconfigurationResponseParameter->GetResult())
+						    .c_str());
+
+						this->associationListener.OnAssociationStreamsResetFailed(
+						  this->currentRequest->GetStreamIds(),
+						  ReconfigurationResponseParameter::ResultToString(
+						    receivedReconfigurationResponseParameter->GetResult()));
+
+						this->currentRequest = std::nullopt;
+
+						// TODO: SCTP: Implement it.
+						// this->retransmissionQueue->RollbackResetStreams();
+
+						break;
+					}
+				}
+			}
+		}
+
+		void StreamResetHandler::OnReConfigTimer(uint64_t& baseTimeoutMs, bool& /*stop*/)
+		{
+			MS_TRACE();
+
+			if (this->currentRequest && this->currentRequest->HasBeenSent())
+			{
+				// The request was deferred (received "In Progress"). This is not a
+				// timeout, but just time to retry.
+				if (this->currentRequest->IsDeferred())
+				{
+					this->currentRequest->SetDeferred(false);
+				}
+				// There is an outstanding request, which timed out while waiting for a
+				// response.
+				else if (!this->tcbContext->IncrementTxErrorCounter("RECONFIG timeout"))
+				{
+					// Timed out. The connection will close after processing the timers.
+					return;
+				}
+			}
+			else
+			{
+				// There is no outstanding request, but there is a prepared one. This means
+				// that the receiver has previously responded "in progress", which resulted
+				// in retrying the request (but with a new `reqSeqNbr`) after a while.
+			}
+
+			auto packet = this->tcbContext->CreatePacket();
+
+			packet->AddChunk(CreateReconfigChunk());
+
+			this->tcbContext->Send(packet.get());
+
+			baseTimeoutMs = this->tcbContext->GetCurrentRtoMs();
+		}
+
+		void StreamResetHandler::OnTimer(BackoffTimerHandle* backoffTimer, uint64_t& baseTimeoutMs, bool& stop)
+		{
+			MS_TRACE();
+
+			if (backoffTimer == this->reConfigTimer.get())
+			{
+				OnReConfigTimer(baseTimeoutMs, stop);
+			}
+		}
+	} // namespace SCTP
+} // namespace RTC

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

@@ -1,10 +1,13 @@
 #define MS_CLASS "RTC::SCTP::TransmissionControlBlock"
-// #define MS_LOG_DEV_LEVEL 3
+// TODO: SCTP: COMMENT
+#define MS_LOG_DEV_LEVEL 3
 
 #include "RTC/SCTP/association/TransmissionControlBlock.hpp"
 #include "DepLibUV.hpp"
 #include "Logger.hpp"
+#include "RTC/Consts.hpp"
 #include <cmath> // std::min()
+#include <string>
 
 namespace RTC
 {
@@ -26,7 +29,8 @@ namespace RTC
 		  uint32_t remoteInitialTsn,
 		  uint32_t remoteAdvertisedReceiverWindowCredit,
 		  uint64_t tieTag,
-		  const NegotiatedCapabilities& negotiatedCapabilities)
+		  const NegotiatedCapabilities& negotiatedCapabilities,
+		  std::function<bool()> isAssociationEstablished)
 		  : associationListener(associationListener),
 		    sctpOptions(sctpOptions),
 		    packetSender(packetSender),
@@ -37,6 +41,7 @@ namespace RTC
 		    remoteAdvertisedReceiverWindowCredit(remoteAdvertisedReceiverWindowCredit),
 		    tieTag(tieTag),
 		    negotiatedCapabilities(negotiatedCapabilities),
+		    isAssociationEstablished(std::move(isAssociationEstablished)),
 		    t3RtxTimer(
 		      std::make_unique<BackoffTimerHandle>(
 		        /*listener*/ this,
@@ -52,7 +57,8 @@ namespace RTC
 		        /*maxBackoffTimeoutMs*/ std::nullopt,
 		        /*maxRestarts*/ 0)),
 		    rto(sctpOptions),
-		    txErrorCounter(sctpOptions)
+		    txErrorCounter(sctpOptions),
+		    heartbeatHandler(this->associationListener, sctpOptions, this)
 		{
 			MS_TRACE();
 		}
@@ -102,16 +108,14 @@ namespace RTC
 			  rtt,
 			  prevRtoMs,
 			  this->rto.GetRtoMs(),
-			  this - rto.GetSrttMs());
+			  this->rto.GetSrttMs());
 
 			this->t3RtxTimer->SetBaseTimeoutMs(this->rto.GetRtoMs());
-			this->t3RtxTimer->Start();
 
 			const uint64_t delayedAckTimeoutMs = std::min(
 			  static_cast<uint64_t>(this->rto.GetRtoMs() * 0.5), this->sctpOptions.delayedAckMaxTimeoutMs);
 
 			this->delayedAckTimer->SetBaseTimeoutMs(delayedAckTimeoutMs);
-			this->delayedAckTimer->Start();
 		}
 
 		std::unique_ptr<Packet> TransmissionControlBlock::CreatePacket() const
@@ -136,6 +140,15 @@ namespace RTC
 			return packet;
 		}
 
+		void TransmissionControlBlock::Send(Packet* packet)
+		{
+			MS_TRACE();
+
+			this->packetSender.SendPacket(
+			  packet,
+			  /*writeChecksum*/ !this->negotiatedCapabilities.zeroChecksum);
+		}
+
 		void TransmissionControlBlock::SetRemoteStateCookie(std::vector<uint8_t> remoteStateCookie)
 		{
 			MS_TRACE();
@@ -154,26 +167,19 @@ namespace RTC
 		{
 			MS_TRACE();
 
-			// TODO: Implement it.
-			// if (this->dataTracker.ShouldSendAckChunk(/*alsoIfDelayed*/ false))
+			// TODO: SCTP: Implement it.
+			// if (!this->dataTracker.ShouldSendAckChunk(/*alsoIfDelayed*/ false))
 			// {
-			// 	auto packet = CreatePacket();
-
-			// 	// TODO: Here we must create a SackChunk in the Packet, however the
-			// 	// SackChunk is in theory generated by this->dataTracker... Let's see.
-			// 	builder.Add(this->dataTracker.CreateSelectiveAck(this->reassemblyQueue.GetRemainingBytes()));
-
-			// 	Send(packet.get());
+			// 	return;
 			// }
-		}
 
-		void TransmissionControlBlock::Send(Packet* packet)
-		{
-			MS_TRACE();
+			// auto packet = CreatePacket();
 
-			this->packetSender.SendPacket(
-			  packet,
-			  /*writeChecksum*/ !this->negotiatedCapabilities.zeroChecksum);
+			// TODO: SCTP: Here we must create a SackChunk in the Packet, however the
+			// SackChunk is in theory generated by this->dataTracker... Let's see.
+			// builder.Add(this->dataTracker.CreateSelectiveAck(this->reassemblyQueue.GetRemainingBytes()));
+
+			// Send(packet.get());
 		}
 
 		void TransmissionControlBlock::OnT3RtxTimer(uint64_t& /*baseTimeoutMs*/, bool& /*stop*/)
@@ -190,22 +196,23 @@ namespace RTC
 
 			// In the COOKIE_ECHO state, let the T1-COOKIE timer trigger
 			// retransmissions, to avoid having two timers doing that.
-			// TODO: Implement it.
-			// if (this->cookieEchoChunk.has_value())
-			// {
-			// 	MS_DEBUG_DEV("not retransmitting as T1-cookie is active");
-			// }
-			// else
-			// {
-			// 	if (IncrementTxErrorCounter("t3-rtx expired"))
-			// 	{
-			// 		this->retransmissionQueue.HandleT3RtxTimerExpiry();
+			if (this->remoteStateCookie.has_value())
+			{
+				MS_DEBUG_DEV("not retransmitting as T1-cookie is active");
+			}
+			else
+			{
+				if (IncrementTxErrorCounter("t3-rtx expired"))
+				{
+					// TODO: SCTP: Implement
+					// this->retransmissionQueue.HandleT3RtxTimerExpiry();
 
-			// 		const uint64_t now = DepLibUV::GetTimeMs();
+					// const uint64_t now = DepLibUV::GetTimeMs();
 
-			// 		SendBufferedPackets(now);
-			// 	}
-			// }
+					// TODO: SCTP: Implement
+					// SendBufferedPackets(now);
+				}
+			}
 		}
 
 		void TransmissionControlBlock::OnDelayedAckTimer(uint64_t& /*baseTimeoutMs*/, bool& /*stop*/)
@@ -220,11 +227,10 @@ namespace RTC
 			  this->delayedAckTimer->GetExpirationCount(),
 			  maxRestarts ? std::to_string(maxRestarts.value()).c_str() : "Infinite");
 
-			// TODO: Implement it.
+			// TODO: SCTP: Implement it.
 			// this->dataTracker.HandleDelayedAckTimerExpiry();
 
-			// TODO: Implement it.
-			// MaySendSackChunk();
+			MaySendSackChunk();
 		}
 
 		void TransmissionControlBlock::OnTimer(

package/worker/src/RTC/SCTP/packet/chunks/SackChunk.cpp

@@ -233,7 +233,7 @@ namespace RTC
 
 			duplicateTsns.reserve(numberOfDuplicateTsns);
 
-			for (uint32_t idx{ 0 }; idx < GetNumberOfDuplicateTsns(); ++idx)
+			for (uint32_t idx{ 0 }; idx < numberOfDuplicateTsns; ++idx)
 			{
 				duplicateTsns.emplace_back(GetDuplicateTsnAt(idx));
 			}

package/worker/src/RTC/SCTP/packet/errorCauses/UserInitiatedAbortErrorCause.cpp

@@ -97,7 +97,7 @@ namespace RTC
 				MS_DUMP_CLEAN(indentation, "  has upper layer abort reason: yes");
 				MS_DUMP_CLEAN(
 				  indentation,
-				  "  upper layer abort reason: %.*s",
+				  "  upper layer abort reason: \"%.*s\"",
 				  static_cast<int>(reason.size()),
 				  reason.data());
 			}