quicsilver 0.5.0-x86_64-linux

data/ext/quicsilver/patches/reliable-reset.patch

@@ -0,0 +1,723 @@
+diff --git c/src/core/api.c i/src/core/api.c
+index 2281da55a..c88b0b641 100644
+--- c/src/core/api.c
++++ i/src/core/api.c
+@@ -1259,6 +1259,7 @@ MsQuicStreamSend(
+             QueueOper = FALSE; // Not necessary if the previous send hasn't been flushed yet.
+         }
+         *ApiSendRequestsTail = SendRequest;
++        Stream->ApiSubmittedOffset += SendRequest->TotalLength;
+         Status = QUIC_STATUS_SUCCESS;
+ 
+         if (!SendInline && QueueOper) {
+diff --git c/src/core/connection.c i/src/core/connection.c
+index d2194a749..4bf4fb3d6 100644
+--- c/src/core/connection.c
++++ i/src/core/connection.c
+@@ -2203,7 +2203,9 @@ QuicConnRecvResumptionTicket(
+         //
+         // Validate resumed TP are <= current settings
+         //
+-        if (ResumedTP.ActiveConnectionIdLimit > QUIC_ACTIVE_CONNECTION_ID_LIMIT ||
++        if (((ResumedTP.Flags & QUIC_TP_FLAG_RELIABLE_RESET_ENABLED) &&
++             !Connection->Settings.ReliableResetEnabled) ||
++            ResumedTP.ActiveConnectionIdLimit > QUIC_ACTIVE_CONNECTION_ID_LIMIT ||
+             ResumedTP.InitialMaxData > Connection->Send.MaxData ||
+             ResumedTP.InitialMaxStreamDataBidiLocal > Connection->Settings.StreamRecvWindowBidiLocalDefault ||
+             ResumedTP.InitialMaxStreamDataBidiRemote > Connection->Settings.StreamRecvWindowBidiRemoteDefault ||
+@@ -2288,6 +2290,9 @@ QuicConnRecvResumptionTicket(
+ 
+ Error:
+ 
++    if (!ResumptionAccepted) {
++        Connection->Crypto.TicketValidationPending = FALSE;
++    }
+     QuicCryptoTlsCleanupTransportParameters(&ResumedTP);
+     return ResumptionAccepted;
+ }
+@@ -3001,6 +3006,23 @@ QuicConnProcessPeerTransportParameters(
+         Connection->SourceCidLimit = QUIC_TP_ACTIVE_CONNECTION_ID_LIMIT_DEFAULT;
+     }
+ 
++    // Restore the cached capability before 0-RTT sends, then replace it with
++    // the peer's actual capability when the new handshake supplies parameters.
++    if (Connection->Settings.ReliableResetEnabled) {
++        Connection->State.ReliableResetStreamNegotiated =
++            !!(Connection->PeerTransportParams.Flags & QUIC_TP_FLAG_RELIABLE_RESET_ENABLED);
++
++        QUIC_CONNECTION_EVENT Event;
++        Event.Type = QUIC_CONNECTION_EVENT_RELIABLE_RESET_NEGOTIATED;
++        Event.RELIABLE_RESET_NEGOTIATED.IsNegotiated = Connection->State.ReliableResetStreamNegotiated;
++        QuicTraceLogConnVerbose(
++            IndicateReliableResetNegotiated,
++            Connection,
++            "Indicating QUIC_CONNECTION_EVENT_RELIABLE_RESET_NEGOTIATED [IsNegotiated=%hhu]",
++            Event.RELIABLE_RESET_NEGOTIATED.IsNegotiated);
++        QuicConnIndicateEvent(Connection, &Event);
++    }
++
+     if (!FromResumptionTicket) {
+         if (Connection->Settings.VersionNegotiationExtEnabled &&
+             Connection->PeerTransportParams.Flags & QUIC_TP_FLAG_VERSION_NEGOTIATION) {
+@@ -3065,25 +3087,6 @@ QuicConnProcessPeerTransportParameters(
+             Connection->Stats.GreaseBitNegotiated = TRUE;
+         }
+ 
+-        if (Connection->Settings.ReliableResetEnabled) {
+-            Connection->State.ReliableResetStreamNegotiated =
+-                !!(Connection->PeerTransportParams.Flags & QUIC_TP_FLAG_RELIABLE_RESET_ENABLED);
+-
+-            //
+-            // Send event to app to indicate result of negotiation if app cares.
+-            //
+-            QUIC_CONNECTION_EVENT Event;
+-            Event.Type = QUIC_CONNECTION_EVENT_RELIABLE_RESET_NEGOTIATED;
+-            Event.RELIABLE_RESET_NEGOTIATED.IsNegotiated = Connection->State.ReliableResetStreamNegotiated;
+-
+-            QuicTraceLogConnVerbose(
+-                IndicateReliableResetNegotiated,
+-                Connection,
+-                "Indicating QUIC_CONNECTION_EVENT_RELIABLE_RESET_NEGOTIATED [IsNegotiated=%hhu]",
+-                Event.RELIABLE_RESET_NEGOTIATED.IsNegotiated);
+-            QuicConnIndicateEvent(Connection, &Event);
+-        }
+-
+         if (Connection->Settings.OneWayDelayEnabled) {
+             Connection->State.TimestampSendNegotiated = // Peer wants to recv, so we can send
+                 !!(Connection->PeerTransportParams.Flags & QUIC_TP_FLAG_TIMESTAMP_RECV_ENABLED);
+@@ -7732,7 +7735,8 @@ QuicConnApplyNewSettings(
+             Connection->Stats.GreaseBitNegotiated = TRUE;
+         }
+ 
+-        if (QuicConnIsServer(Connection) && Connection->Settings.ReliableResetEnabled) {
++        if (Connection->Settings.ReliableResetEnabled &&
++            (QuicConnIsServer(Connection) || Connection->State.PeerTransportParameterValid)) {
+             Connection->State.ReliableResetStreamNegotiated =
+                 !!(Connection->PeerTransportParams.Flags & QUIC_TP_FLAG_RELIABLE_RESET_ENABLED);
+ 
+diff --git c/src/core/crypto.c i/src/core/crypto.c
+index 91235bbc9..2dab61879 100644
+--- c/src/core/crypto.c
++++ i/src/core/crypto.c
+@@ -2578,6 +2578,7 @@ QuicCryptoEncodeServerTicket(
+     //
+     QUIC_TRANSPORT_PARAMETERS HSTPCopy = *HandshakeTP;
+     HSTPCopy.Flags &= (
++        QUIC_TP_FLAG_RELIABLE_RESET_ENABLED |
+         QUIC_TP_FLAG_ACTIVE_CONNECTION_ID_LIMIT |
+         QUIC_TP_FLAG_INITIAL_MAX_DATA |
+         QUIC_TP_FLAG_INITIAL_MAX_STRM_DATA_BIDI_LOCAL |
+diff --git c/src/core/crypto_tls.c i/src/core/crypto_tls.c
+index 4fa6b8cc7..a905e624f 100644
+--- c/src/core/crypto_tls.c
++++ i/src/core/crypto_tls.c
+@@ -66,7 +66,7 @@ typedef enum eSniNameType {
+ #define QUIC_TP_ID_MIN_ACK_DELAY                            0xFF04DE1BULL   // varint
+ #define QUIC_TP_ID_CIBIR_ENCODING                           0x1000          // {varint, varint}
+ #define QUIC_TP_ID_GREASE_QUIC_BIT                          0x2AB2          // N/A
+-#define QUIC_TP_ID_RELIABLE_RESET_ENABLED                   0x17f7586d2cb570   // varint
++#define QUIC_TP_ID_RELIABLE_RESET_ENABLED                   0x1d               // empty reset_stream_at
+ #define QUIC_TP_ID_ENABLE_TIMESTAMP                         0x7158          // varint
+ 
+ BOOLEAN
+diff --git c/src/core/frame.c i/src/core/frame.c
+index c5afcc628..fd2465fb0 100644
+--- c/src/core/frame.c
++++ i/src/core/frame.c
+@@ -457,7 +457,8 @@ QuicReliableResetFrameDecode(
+     if (!QuicVarIntDecode(BufferLength, Buffer, Offset, &Frame->StreamID) ||
+         !QuicVarIntDecode(BufferLength, Buffer, Offset, &Frame->ErrorCode) ||
+         !QuicVarIntDecode(BufferLength, Buffer, Offset, &Frame->FinalSize) ||
+-        !QuicVarIntDecode(BufferLength, Buffer, Offset, &Frame->ReliableSize)) {
++        !QuicVarIntDecode(BufferLength, Buffer, Offset, &Frame->ReliableSize) ||
++        Frame->ReliableSize > Frame->FinalSize) {
+         return FALSE;
+     }
+     return TRUE;
+diff --git c/src/core/frame.h i/src/core/frame.h
+index 563332740..7719f1301 100644
+--- c/src/core/frame.h
++++ i/src/core/frame.h
+@@ -149,9 +149,9 @@ typedef enum QUIC_FRAME_TYPE {
+     QUIC_FRAME_CONNECTION_CLOSE     = 0x1cULL, // to 0x1d
+     QUIC_FRAME_CONNECTION_CLOSE_1   = 0x1dULL,
+     QUIC_FRAME_HANDSHAKE_DONE       = 0x1eULL,
+-    /* 0x1f to 0x20 are unused currently */
+-    QUIC_FRAME_RELIABLE_RESET_STREAM = 0x21ULL, // intentionally ignore type 0x20 of QUIC_RESET_STREAM cause it's likely to be removed from RFC.
+-    /* 0x22 to 0x2f are unused currently */
++    /* 0x20 to 0x23 are unused currently */
++    QUIC_FRAME_RELIABLE_RESET_STREAM = 0x24ULL, // RESET_STREAM_AT
++    /* 0x25 to 0x2f are unused currently */
+     QUIC_FRAME_DATAGRAM             = 0x30ULL, // to 0x31
+     QUIC_FRAME_DATAGRAM_1           = 0x31ULL,
+     /* 0x32 to 0xad are unused currently */
+diff --git c/src/core/stream.c i/src/core/stream.c
+index ec426b406..f34388cb6 100644
+--- c/src/core/stream.c
++++ i/src/core/stream.c
+@@ -704,8 +704,15 @@ QuicStreamParamSet(
+             break;
+         }
+ 
++        // StreamSend may still be queued when the application sets the boundary.
++        // ApiSubmittedOffset counts everything passed to StreamSend and is
++        // maintained under the same lock, so there is no window in which a
++        // flush in progress makes a submitted send invisible.
++        CxPlatDispatchLockAcquire(&Stream->ApiSendRequestLock);
++        uint64_t SubmittedOffset = Stream->ApiSubmittedOffset;
++        CxPlatDispatchLockRelease(&Stream->ApiSendRequestLock);
+         if (!Stream->Connection->State.ReliableResetStreamNegotiated ||
+-            *(uint64_t*)Buffer > Stream->QueuedSendOffset) {
++            *(uint64_t*)Buffer > SubmittedOffset) {
+             Status = QUIC_STATUS_INVALID_STATE;
+             break;
+         }
+@@ -962,7 +969,7 @@ QuicStreamParamGet(
+             break;
+         }
+ 
+-        *(uint64_t*)Buffer = Stream->RecvMaxLength;
++        *(uint64_t*)Buffer = Stream->ReliableOffsetRecv;
+         Status = QUIC_STATUS_SUCCESS;
+         break;
+ 
+diff --git c/src/core/stream.h i/src/core/stream.h
+index 5a985692e..c4509ae6b 100644
+--- c/src/core/stream.h
++++ i/src/core/stream.h
+@@ -125,7 +125,7 @@ typedef union QUIC_STREAM_FLAGS {
+         BOOLEAN LocalCloseReset         : 1;    // Locally closed (locally aborted).
+         BOOLEAN LocalCloseResetReliable : 1;    // Indicates that we should shutdown the send path once we sent/ACK'd ReliableOffsetSend bytes.
+         BOOLEAN LocalCloseResetReliableAcked : 1; // Indicates the peer has acknowledged we will stop sending once we sent/ACK'd ReliableOffsetSend bytes.
+-        BOOLEAN RemoteCloseResetReliable : 1;   // Indicates that the peer initiated a reliable reset. Keep Recv path available for RecvMaxLength bytes.
++        BOOLEAN RemoteCloseResetReliable : 1;   // Indicates that the peer initiated a reliable reset. Keep Recv path available for ReliableOffsetRecv bytes.
+         BOOLEAN ReceivedStopSending     : 1;    // Peer sent STOP_SENDING frame.
+         BOOLEAN LocalCloseAcked         : 1;    // Any close acknowledged.
+         BOOLEAN FinAcked                : 1;    // Our FIN was acknowledged.
+@@ -310,6 +310,16 @@ typedef struct QUIC_STREAM {
+     CXPLAT_DISPATCH_LOCK ApiSendRequestLock;
+     QUIC_SEND_REQUEST* ApiSendRequests;
+ 
++    //
++    // Total bytes the application has passed to StreamSend, whether or not
++    // the worker has flushed them yet. Updated under ApiSendRequestLock.
++    // QUIC_PARAM_STREAM_RELIABLE_OFFSET is bounded by this rather than by
++    // QueuedSendOffset plus the ApiSendRequests list: the flush clears that
++    // list before it advances QueuedSendOffset, so a concurrent reader of
++    // the pair can see neither and reject a valid offset.
++    //
++    uint64_t ApiSubmittedOffset;
++
+     //
+     // Queued send requests.
+     //
+@@ -435,6 +445,10 @@ typedef struct QUIC_STREAM {
+     //
+     uint64_t RecvMaxLength;
+ 
++    // Reliable delivery boundary; RecvMaxLength remains the immutable final size.
++    uint64_t ReliableOffsetRecv;
++    QUIC_VAR_INT RecvResetErrorCode;
++
+     //
+     // The number of bytes that are currently outstanding up to the app.
+     //
+diff --git c/src/core/stream_recv.c i/src/core/stream_recv.c
+index 8d9640a9f..cd477447f 100644
+--- c/src/core/stream_recv.c
++++ i/src/core/stream_recv.c
+@@ -82,7 +82,8 @@ QuicStreamRecvShutdown(
+         // the receives to that point. Just treat the shutdown as if it was
+         // already acknowledged by a reset frame.
+         //
+-        QuicStreamProcessResetFrame(Stream, Stream->RecvMaxLength, 0);
++        QuicStreamProcessResetFrame(Stream, Stream->RecvMaxLength,
++            Stream->Flags.RemoteCloseResetReliable ? Stream->RecvResetErrorCode : 0);
+         Silent = TRUE; // To indicate we try to shutdown complete.
+         goto Exit;
+     }
+@@ -189,6 +190,7 @@ _IRQL_requires_max_(PASSIVE_LEVEL)
+ void
+ QuicStreamProcessReliableResetFrame(
+     _In_ QUIC_STREAM* Stream,
++    _In_ uint64_t FinalSize,
+     _In_ QUIC_VAR_INT ErrorCode,
+     _In_ QUIC_VAR_INT ReliableOffset
+     )
+@@ -206,35 +208,43 @@ QuicStreamProcessReliableResetFrame(
+         return;
+     }
+ 
+-    if (Stream->RecvMaxLength == 0 || ReliableOffset < Stream->RecvMaxLength) {
+-        //
+-        // As outlined in the spec, if we receive multiple CLOSE_STREAM frames, we only accept strictly
+-        // decreasing offsets.
+-        //
+-        Stream->RecvMaxLength = ReliableOffset;
++    if (ReliableOffset > FinalSize) {
++        QuicConnTransportError(Stream->Connection, QUIC_ERROR_FRAME_ENCODING_ERROR);
++        return;
++    }
++    if ((Stream->RecvMaxLength != UINT64_MAX && Stream->RecvMaxLength != FinalSize) ||
++        QuicRecvBufferGetTotalLength(&Stream->RecvBuffer) > FinalSize) {
++        QuicConnTransportError(Stream->Connection, QUIC_ERROR_FINAL_SIZE_ERROR);
++        return;
++    }
++    if ((Stream->Flags.RemoteCloseResetReliable || Stream->Flags.RemoteCloseReset) &&
++        Stream->RecvResetErrorCode != ErrorCode) {
++        QuicConnTransportError(Stream->Connection, QUIC_ERROR_STREAM_STATE_ERROR);
++        return;
++    }
++    if (Stream->Flags.RemoteCloseReset || Stream->Flags.RemoteCloseFin) {
++        return;
++    }
++    if (!Stream->Flags.RemoteCloseResetReliable) {
++        uint64_t Increase = FinalSize - QuicRecvBufferGetTotalLength(&Stream->RecvBuffer);
++        if (FinalSize > Stream->MaxAllowedRecvOffset ||
++            Increase > Stream->Connection->Send.MaxData - Stream->Connection->Send.OrderedStreamBytesReceived) {
++            QuicConnTransportError(Stream->Connection, QUIC_ERROR_FLOW_CONTROL_ERROR);
++            return;
++        }
++        // Charge the final size once, including bytes still missing from the buffer.
++        Stream->Connection->Send.OrderedStreamBytesReceived += Increase;
++        Stream->RecvMaxLength = FinalSize;
++        Stream->ReliableOffsetRecv = ReliableOffset;
++        Stream->RecvResetErrorCode = ErrorCode;
+         Stream->Flags.RemoteCloseResetReliable = TRUE;
+-
+-        QuicTraceLogStreamInfo(
+-            ReliableRecvOffsetSet,
+-            Stream,
+-            "Reliable recv offset set to %llu",
+-            ReliableOffset);
++    } else if (ReliableOffset < Stream->ReliableOffsetRecv) {
++        Stream->ReliableOffsetRecv = ReliableOffset;
++    }
++    if (Stream->RecvBuffer.BaseOffset >= Stream->ReliableOffsetRecv || Stream->Flags.SentStopSending) {
++        QuicStreamProcessResetFrame(Stream, FinalSize, ErrorCode);
+     }
+ 
+-    if (Stream->RecvBuffer.BaseOffset >= Stream->RecvMaxLength) {
+-        QuicTraceEvent(
+-            StreamRecvState,
+-            "[strm][%p] Recv State: %hhu",
+-            Stream,
+-            QuicStreamRecvGetState(Stream));
+-        QuicStreamIndicatePeerSendAbortedEvent(Stream, ErrorCode);
+-        QuicStreamRecvShutdown(Stream, TRUE, ErrorCode);
+-    } else {
+-        //
+-        // We still have data to deliver to the app, just cache the error code for later.
+-        //
+-        Stream->RecvShutdownErrorCode = ErrorCode;
+-    }
+ }
+ 
+ //
+@@ -248,10 +258,22 @@ QuicStreamProcessResetFrame(
+     _In_ QUIC_VAR_INT ErrorCode
+     )
+ {
++    if (Stream->RecvMaxLength != UINT64_MAX && FinalSize != Stream->RecvMaxLength) {
++        QuicConnTransportError(Stream->Connection, QUIC_ERROR_FINAL_SIZE_ERROR);
++        return;
++    }
++    if (Stream->Flags.RemoteCloseResetReliable || Stream->Flags.RemoteCloseReset) {
++        if (ErrorCode != Stream->RecvResetErrorCode) {
++            QuicConnTransportError(Stream->Connection, QUIC_ERROR_STREAM_STATE_ERROR);
++            return;
++        }
++    }
+     //
+     // Make sure the stream is remotely closed if not already.
+     //
+     Stream->Flags.RemoteCloseReset = TRUE;
++    Stream->RecvMaxLength = FinalSize;
++    Stream->RecvResetErrorCode = ErrorCode;
+ 
+     if (!Stream->Flags.RemoteCloseAcked) {
+         Stream->Flags.RemoteCloseAcked = TRUE;
+@@ -272,7 +294,7 @@ QuicStreamProcessResetFrame(
+             return;
+         }
+ 
+-        if (TotalRecvLength < FinalSize) {
++        if (TotalRecvLength < FinalSize && !Stream->Flags.RemoteCloseResetReliable) {
+             //
+             // The final offset is indicating that more data was sent than we
+             // have actually received. Make sure to update our flow control
+@@ -442,19 +464,8 @@ QuicStreamProcessStreamFrame(
+         goto Error;
+     }
+ 
+-    if (Stream->Flags.RemoteCloseResetReliable) {
+-        if (Stream->RecvBuffer.BaseOffset >= Stream->RecvMaxLength) {
+-            //
+-            // We've aborted reliably, but the stream goes past reliable offset, we can just
+-            // ignore it.
+-            //
+-            Status = QUIC_STATUS_SUCCESS;
+-            goto Error;
+-        }
+-    } else if (EndOffset > Stream->RecvMaxLength) {
+-        //
+-        // Frame goes past the FIN, and the stream is not reset reliably.
+-        //
++    if (EndOffset > Stream->RecvMaxLength) {
++        QuicConnTransportError(Stream->Connection, QUIC_ERROR_FINAL_SIZE_ERROR);
+         Status = QUIC_STATUS_INVALID_PARAMETER;
+         goto Error;
+     }
+@@ -481,9 +492,9 @@ QuicStreamProcessStreamFrame(
+         // On return from QuicRecvBufferWrite, this represents the
+         // actual number of bytes written.
+         //
+-        const uint64_t FlowControlQuota =
+-            Stream->Connection->Send.MaxData -
+-            Stream->Connection->Send.OrderedStreamBytesReceived;
++        const uint64_t FlowControlQuota = Stream->Flags.RemoteCloseResetReliable ?
++            Stream->RecvMaxLength - QuicRecvBufferGetTotalLength(&Stream->RecvBuffer) :
++            Stream->Connection->Send.MaxData - Stream->Connection->Send.OrderedStreamBytesReceived;
+         uint64_t QuotaConsumed = 0;
+         uint64_t BufferSizeNeeded = 0;
+ 
+@@ -541,7 +552,9 @@ QuicStreamProcessStreamFrame(
+         //
+         // Keep track of the total ordered bytes received.
+         //
+-        Stream->Connection->Send.OrderedStreamBytesReceived += QuotaConsumed;
++        if (!Stream->Flags.RemoteCloseResetReliable) {
++            Stream->Connection->Send.OrderedStreamBytesReceived += QuotaConsumed;
++        }
+         CXPLAT_DBG_ASSERT(Stream->Connection->Send.OrderedStreamBytesReceived <= Stream->Connection->Send.MaxData);
+         CXPLAT_DBG_ASSERT(Stream->Connection->Send.OrderedStreamBytesReceived >= QuotaConsumed);
+ 
+@@ -735,6 +748,7 @@ QuicStreamRecv(
+ 
+         QuicStreamProcessReliableResetFrame(
+             Stream,
++            Frame.FinalSize,
+             Frame.ErrorCode,
+             Frame.ReliableSize);
+ 
+@@ -981,7 +995,8 @@ QuicStreamRecvFlush(
+                 //
+             }
+ 
+-            if (Event.RECEIVE.AbsoluteOffset + Event.RECEIVE.TotalBufferLength == Stream->RecvMaxLength) {
++            if (!Stream->Flags.RemoteCloseResetReliable &&
++                Event.RECEIVE.AbsoluteOffset + Event.RECEIVE.TotalBufferLength == Stream->RecvMaxLength) {
+                 //
+                 // This data goes all the way to the FIN.
+                 //
+@@ -1158,6 +1173,11 @@ QuicStreamReceiveComplete(
+         return FALSE;
+     }
+ 
++    if (Stream->Flags.RemoteCloseResetReliable && Stream->RecvBuffer.BaseOffset >= Stream->ReliableOffsetRecv) {
++        QuicStreamProcessResetFrame(Stream, Stream->RecvMaxLength, Stream->RecvResetErrorCode);
++        return FALSE;
++    }
++
+     if (Stream->Flags.ReceiveDataPending) {
+         //
+         // There is still more data for the app to process and it still has
+@@ -1204,18 +1224,6 @@ QuicStreamReceiveComplete(
+             &Stream->Connection->Send,
+             Stream,
+             QUIC_STREAM_SEND_FLAG_MAX_DATA | QUIC_STREAM_SEND_FLAG_RECV_ABORT);
+-    } else if (Stream->Flags.RemoteCloseResetReliable && Stream->RecvBuffer.BaseOffset >= Stream->RecvMaxLength) {
+-        //
+-        // ReliableReset was initiated by the peer, and we sent enough data to the app, we can alert the app
+-        // we're done and shutdown the RECV direction of this stream.
+-        //
+-        QuicTraceEvent(
+-            StreamRecvState,
+-            "[strm][%p] Recv State: %hhu",
+-            Stream,
+-            QuicStreamRecvGetState(Stream));
+-        QuicStreamIndicatePeerSendAbortedEvent(Stream, Stream->RecvShutdownErrorCode);
+-        QuicStreamRecvShutdown(Stream, TRUE, Stream->RecvShutdownErrorCode);
+     }
+ 
+     return FALSE;
+diff --git c/src/core/stream_send.c i/src/core/stream_send.c
+index 0ac7dd101..ca70133df 100644
+--- c/src/core/stream_send.c
++++ i/src/core/stream_send.c
+@@ -119,7 +119,8 @@ QuicStreamSendShutdown(
+     _In_ QUIC_VAR_INT ErrorCode   // Only for !Graceful
+     )
+ {
+-    if (Stream->Flags.LocalCloseAcked) {
++    if (Stream->Flags.LocalCloseAcked ||
++        (Stream->Flags.LocalCloseResetReliable && !Silent)) {
+         //
+         // We have already closed (graceful or abortive) and it has been
+         // acknowledged by the peer. Nothing else to be done.
+@@ -275,7 +276,7 @@ QuicStreamSendShutdown(
+         QuicSendSetStreamSendFlag(
+             &Stream->Connection->Send,
+             Stream,
+-            QUIC_STREAM_SEND_FLAG_RELIABLE_ABORT,
++            QUIC_STREAM_SEND_FLAG_RELIABLE_ABORT | QUIC_STREAM_SEND_FLAG_DATA,
+             FALSE);
+ }
+ 
+@@ -361,6 +362,10 @@ QuicStreamSendCanWriteDataFrames(
+         return TRUE;
+     }
+ 
++    if (Stream->Flags.LocalCloseResetReliable &&
++        Stream->NextSendOffset >= CXPLAT_MAX(Stream->MaxSentLength, Stream->ReliableOffsetSend)) {
++        return FALSE;
++    }
+     if (Stream->NextSendOffset == Stream->QueuedSendOffset) {
+         //
+         // No unsent data. Can send only if a FIN is needed.
+@@ -392,7 +397,11 @@ QuicStreamCanSendNow(
+         return FALSE;
+     }
+ 
+-    if (HasStreamControlFrames(Stream->SendFlags) ||
++    uint32_t SendFlags = Stream->SendFlags;
++    if (Stream->MaxSentLength < Stream->ReliableOffsetSend) {
++        SendFlags &= ~QUIC_STREAM_SEND_FLAG_RELIABLE_ABORT;
++    }
++    if (HasStreamControlFrames(SendFlags) ||
+         (Stream->SendFlags & QUIC_STREAM_SEND_FLAG_OPEN)) {
+         //
+         // We can always send control frames and/or open new streams.
+@@ -963,6 +972,12 @@ QuicStreamWriteStreamFrames(
+             }
+         }
+ 
++        if (Stream->Flags.LocalCloseResetReliable) {
++            const uint64_t FinalSize = CXPLAT_MAX(Stream->MaxSentLength, Stream->ReliableOffsetSend);
++            if (Left >= FinalSize) { break; }
++            Right = CXPLAT_MIN(Right, FinalSize);
++        }
++
+         //
+         // Stream flow control
+         //
+@@ -1150,7 +1165,8 @@ QuicStreamSendWrite(
+         }
+     }
+ 
+-    if (Stream->SendFlags & QUIC_STREAM_SEND_FLAG_RELIABLE_ABORT) {
++    if ((Stream->SendFlags & QUIC_STREAM_SEND_FLAG_RELIABLE_ABORT) &&
++        Stream->MaxSentLength >= Stream->ReliableOffsetSend) {
+         QUIC_RELIABLE_RESET_STREAM_EX Frame = { Stream->ID, Stream->SendShutdownErrorCode, Stream->MaxSentLength, Stream->ReliableOffsetSend };
+ 
+         if (QuicReliableResetFrameEncode(
+diff --git c/src/core/unittest/CMakeLists.txt i/src/core/unittest/CMakeLists.txt
+index ae5411ae9..04f79f63c 100644
+--- c/src/core/unittest/CMakeLists.txt
++++ i/src/core/unittest/CMakeLists.txt
+@@ -9,6 +9,7 @@ set(SOURCES
+     PacketNumberTest.cpp
+     PartitionTest.cpp
+     RangeTest.cpp
++    ReliableResetTest.cpp
+     RecvBufferTest.cpp
+     SettingsTest.cpp
+     SlidingWindowExtremumTest.cpp
+diff --git c/src/core/unittest/FrameTest.cpp i/src/core/unittest/FrameTest.cpp
+index f3cde7e73..dcd7edb02 100644
+--- c/src/core/unittest/FrameTest.cpp
++++ i/src/core/unittest/FrameTest.cpp
+@@ -243,6 +243,26 @@ TEST(FrameTest, ReliableResetStreamFrameEncodeDecode)
+     ASSERT_EQ(Frame.ReliableSize, DecodedFrame.ReliableSize);
+ }
+ 
++// draft-ietf-quic-reliable-stream-reset-09, sections 4 and 8.2.
++TEST(FrameTest, ResetStreamAtUsesRegisteredWireType)
++{
++    QUIC_RELIABLE_RESET_STREAM_EX Frame = {0, 7, 10, 3};
++    uint8_t Buffer[5];
++    uint16_t Offset = 0;
++    ASSERT_TRUE(QuicReliableResetFrameEncode(&Frame, &Offset, sizeof(Buffer), Buffer));
++    const uint8_t Expected[] = {0x24, 0, 7, 10, 3};
++    ASSERT_EQ(sizeof(Expected), Offset);
++    ASSERT_EQ(0, memcmp(Expected, Buffer, sizeof(Expected)));
++}
++
++TEST(FrameTest, ResetStreamAtRejectsReliableSizeBeyondFinalSize)
++{
++    const uint8_t Buffer[] = {0x24, 0, 7, 3, 4};
++    uint16_t Offset = 1;
++    QUIC_RELIABLE_RESET_STREAM_EX Frame = {};
++    ASSERT_FALSE(QuicReliableResetFrameDecode(sizeof(Buffer), Buffer, &Offset, &Frame));
++}
++
+ // 
+ // Tests if the reordering threshold has been hit. This function initializes a
+ // QUIC_ACK_TRACKER and populates it with the provided packet numbers. It then 
+diff --git c/src/core/unittest/ReliableResetTest.cpp i/src/core/unittest/ReliableResetTest.cpp
+new file mode 100644
+index 000000000..8c4e15294
+--- /dev/null
++++ i/src/core/unittest/ReliableResetTest.cpp
+@@ -0,0 +1,33 @@
++// Copyright (c) Microsoft Corporation.
++// Licensed under the MIT License.
++#include "main.h"
++
++extern "C" void QuicStreamProcessReliableResetFrame(
++    QUIC_STREAM*, uint64_t, QUIC_VAR_INT, QUIC_VAR_INT);
++
++TEST(ReliableResetTest, FinalSizeIsChargedOnceWhileWaitingForPrefix)
++{
++    QUIC_CONNECTION Connection = {};
++    Connection.State.ReliableResetStreamNegotiated = TRUE;
++    Connection.Send.MaxData = 100;
++    QUIC_STREAM Stream = {};
++    Stream.Connection = &Connection;
++    Stream.RecvMaxLength = UINT64_MAX;
++    Stream.MaxAllowedRecvOffset = 100;
++
++    QuicStreamProcessReliableResetFrame(&Stream, 50, 42, 10);
++    EXPECT_EQ(50u, Connection.Send.OrderedStreamBytesReceived);
++    EXPECT_EQ(50u, Stream.RecvMaxLength);
++    EXPECT_EQ(10u, Stream.ReliableOffsetRecv);
++    EXPECT_EQ(100u, Connection.Send.MaxData); // No credit returned before consumption.
++
++    QuicStreamProcessReliableResetFrame(&Stream, 50, 42, 5);
++    EXPECT_EQ(50u, Connection.Send.OrderedStreamBytesReceived);
++    EXPECT_EQ(50u, Stream.RecvMaxLength);
++    EXPECT_EQ(5u, Stream.ReliableOffsetRecv);
++
++    // A reordered copy must not increase the reliable boundary or charge again.
++    QuicStreamProcessReliableResetFrame(&Stream, 50, 42, 10);
++    EXPECT_EQ(50u, Connection.Send.OrderedStreamBytesReceived);
++    EXPECT_EQ(5u, Stream.ReliableOffsetRecv);
++}
+diff --git c/src/core/unittest/TicketTest.cpp i/src/core/unittest/TicketTest.cpp
+index 6a55d9e11..493f6c5c8 100644
+--- c/src/core/unittest/TicketTest.cpp
++++ i/src/core/unittest/TicketTest.cpp
+@@ -57,7 +57,8 @@ TEST(ResumptionTicketTest, ClientEncDec)
+         QUIC_TP_FLAG_INITIAL_MAX_STRM_DATA_BIDI_REMOTE |
+         QUIC_TP_FLAG_INITIAL_MAX_STRM_DATA_UNI |
+         QUIC_TP_FLAG_INITIAL_MAX_STRMS_BIDI |
+-        QUIC_TP_FLAG_INITIAL_MAX_STRMS_UNI;
++        QUIC_TP_FLAG_INITIAL_MAX_STRMS_UNI |
++        QUIC_TP_FLAG_RELIABLE_RESET_ENABLED;
+     ClientTP.ActiveConnectionIdLimit = QUIC_TP_ACTIVE_CONNECTION_ID_LIMIT_MIN;
+ 
+     TEST_QUIC_SUCCEEDED(
+@@ -481,7 +482,8 @@ TEST(ResumptionTicketTest, ServerEncDec)
+         QUIC_TP_FLAG_INITIAL_MAX_STRM_DATA_BIDI_REMOTE |
+         QUIC_TP_FLAG_INITIAL_MAX_STRM_DATA_UNI |
+         QUIC_TP_FLAG_INITIAL_MAX_STRMS_BIDI |
+-        QUIC_TP_FLAG_INITIAL_MAX_STRMS_UNI;
++        QUIC_TP_FLAG_INITIAL_MAX_STRMS_UNI |
++        QUIC_TP_FLAG_RELIABLE_RESET_ENABLED;
+     ServerTP.ActiveConnectionIdLimit = QUIC_TP_ACTIVE_CONNECTION_ID_LIMIT_MIN;
+ 
+     TEST_QUIC_SUCCEEDED(
+diff --git c/src/core/unittest/TransportParamTest.cpp i/src/core/unittest/TransportParamTest.cpp
+index d5ad1e7f7..555e9a302 100644
+--- c/src/core/unittest/TransportParamTest.cpp
++++ i/src/core/unittest/TransportParamTest.cpp
+@@ -262,6 +262,25 @@ TEST(TransportParamTest, GreaseQuicBit)
+     EncodeDecodeAndCompare(&OriginalTP, true);
+ }
+ 
++TEST(TransportParamTest, ResetStreamAtRecognizesRegisteredParameter)
++{
++    const uint8_t Buffer[] = {0x1d, 0};
++    QUIC_TRANSPORT_PARAMETERS Decoded = {};
++    TransportParametersScope Scope(&Decoded);
++    ASSERT_TRUE(QuicCryptoTlsDecodeTransportParameters(
++        &JunkConnection, false, Buffer, sizeof(Buffer), &Decoded));
++    ASSERT_NE(0u, Decoded.Flags & QUIC_TP_FLAG_RELIABLE_RESET_ENABLED);
++}
++
++TEST(TransportParamTest, ResetStreamAtRejectsNonemptyParameter)
++{
++    const uint8_t Buffer[] = {0x1d, 1, 0};
++    QUIC_TRANSPORT_PARAMETERS Decoded = {};
++    TransportParametersScope Scope(&Decoded);
++    ASSERT_FALSE(QuicCryptoTlsDecodeTransportParameters(
++        &JunkConnection, false, Buffer, sizeof(Buffer), &Decoded));
++}
++
+ TEST(TransportParamTest, ReliableResetEnabled)
+ {
+     QUIC_TRANSPORT_PARAMETERS OriginalTP;
+diff --git c/src/test/lib/DataTest.cpp i/src/test/lib/DataTest.cpp
+index e1c2ca2ac..84a87d9db 100644
+--- c/src/test/lib/DataTest.cpp
++++ i/src/test/lib/DataTest.cpp
+@@ -4415,6 +4415,9 @@ QuicTestStreamReliableReset(
+         MsQuicStream Stream(Connection, QUIC_STREAM_OPEN_FLAG_NONE, CleanUpManual, StreamReliableReset::ClientStreamCallback, &Context);
+         TEST_QUIC_SUCCEEDED(Stream.GetInitStatus());
+         TEST_QUIC_SUCCEEDED(Stream.Start());
++        // Each loss pattern must deliver its own reliable prefix and error.
++        Context.ReceivedBufferSize = 0;
++        Context.ShutdownErrorCode = 0;
+         SendContext send1 = {FALSE, 0};
+         TEST_QUIC_SUCCEEDED(Stream.Send(&SendBuffer, 1, QUIC_SEND_FLAG_DELAY_SEND, &send1));
+         TEST_QUIC_STATUS(
+diff --git c/src/test/lib/HandshakeTest.cpp i/src/test/lib/HandshakeTest.cpp
+index a787edf70..a16a1fb2b 100644
+--- c/src/test/lib/HandshakeTest.cpp
++++ i/src/test/lib/HandshakeTest.cpp
+@@ -2815,6 +2815,7 @@ QuicTestReliableResetNegotiation(
+     MsQuicSettings ServerSettings;
+     MsQuicSettings ClientSettings;
+     ServerSettings.SetReliableResetEnabled(ServerSupport);
++    ServerSettings.SetServerResumptionLevel(QUIC_SERVER_RESUME_AND_ZERORTT);
+     ClientSettings.SetReliableResetEnabled(ClientSupport);
+ 
+     MsQuicConfiguration ServerConfiguration(Registration, "MsQuicTest", ServerSettings, ServerSelfSignedCredConfig);
+@@ -2856,6 +2857,47 @@ QuicTestReliableResetNegotiation(
+     } else {
+         TEST_FALSE(ServerContext.CallbackReceived);
+     }
++
++    TEST_QUIC_SUCCEEDED(Listener.LastConnection->SendResumptionTicket(QUIC_SEND_RESUMPTION_FLAG_NONE));
++    TEST_TRUE(Connection.ResumptionTicketReceivedEvent.WaitTimeout(TestWaitTimeout));
++
++    for (bool SettingsBeforeTicket : {false, true}) {
++        Context ResumedContext;
++        MsQuicConnection Resumed(Registration, CleanUpManual, Context::s_ConnectionCallback, &ResumedContext);
++        if (SettingsBeforeTicket) {
++            TEST_QUIC_SUCCEEDED(Resumed.SetSettings(ClientSettings));
++        }
++        TEST_QUIC_SUCCEEDED(Resumed.SetResumptionTicket(Connection.ResumptionTicket, Connection.ResumptionTicketLength));
++        if (!SettingsBeforeTicket) {
++            TEST_QUIC_SUCCEEDED(Resumed.SetSettings(ClientSettings));
++        }
++        if (ClientSupport) {
++            // The cached capability must be available before the new handshake.
++            TEST_TRUE(ResumedContext.CallbackReceived);
++            TEST_TRUE(ResumedContext.Negotiated == ServerSupport);
++        }
++        TEST_QUIC_SUCCEEDED(Resumed.Start(ClientConfiguration, ServerLocalAddr.GetFamily(), QUIC_TEST_LOOPBACK_FOR_AF(ServerLocalAddr.GetFamily()), ServerLocalAddr.GetPort()));
++        TEST_TRUE(Resumed.HandshakeCompleteEvent.WaitTimeout(TestWaitTimeout));
++        TEST_TRUE(Resumed.HandshakeComplete);
++        TEST_TRUE(Resumed.HandshakeResumed);
++        TEST_TRUE(ResumedContext.Negotiated == (ServerSupport && ClientSupport));
++    }
++
++    if (ServerSupport && ClientSupport) {
++        MsQuicSettings DisabledSettings;
++        DisabledSettings.SetReliableResetEnabled(false);
++        TEST_QUIC_SUCCEEDED(ServerConfiguration.SetSettings(DisabledSettings));
++
++        Context DowngradedContext;
++        MsQuicConnection Downgraded(Registration, CleanUpManual, Context::s_ConnectionCallback, &DowngradedContext);
++        TEST_QUIC_SUCCEEDED(Downgraded.SetSettings(ClientSettings));
++        TEST_QUIC_SUCCEEDED(Downgraded.SetResumptionTicket(Connection.ResumptionTicket, Connection.ResumptionTicketLength));
++        TEST_QUIC_SUCCEEDED(Downgraded.Start(ClientConfiguration, ServerLocalAddr.GetFamily(), QUIC_TEST_LOOPBACK_FOR_AF(ServerLocalAddr.GetFamily()), ServerLocalAddr.GetPort()));
++        TEST_TRUE(Downgraded.HandshakeCompleteEvent.WaitTimeout(TestWaitTimeout));
++        TEST_TRUE(Downgraded.HandshakeComplete);
++        TEST_FALSE(Downgraded.HandshakeResumed);
++        TEST_FALSE(DowngradedContext.Negotiated);
++    }
+ }
+ 
+ void