/// <summary>
/// Routes a stream to an appropriate stream-type-specific processor
/// </summary>
private async Task ProcessServerStreamAsync(QuicStream stream)
{
ArrayBuffer buffer = default;
try
{
await using (stream.ConfigureAwait(false))
{
if (stream.CanWrite)
{
// Server initiated bidirectional streams are either push streams or extensions, and we support neither.
throw HttpProtocolException.CreateHttp3ConnectionException(Http3ErrorCode.StreamCreationError);
}
buffer = new ArrayBuffer(initialSize: 32, usePool: true);
int bytesRead;
try
{
bytesRead = await stream.ReadAsync(buffer.AvailableMemory, CancellationToken.None).ConfigureAwait(false);
}
catch (QuicException ex) when(ex.QuicError == QuicError.StreamAborted)
{
// Treat identical to receiving 0. See below comment.
bytesRead = 0;
}
if (bytesRead == 0)
{
// https://quicwg.org/base-drafts/draft-ietf-quic-http.html#name-unidirectional-streams
// A sender can close or reset a unidirectional stream unless otherwise specified. A receiver MUST
// tolerate unidirectional streams being closed or reset prior to the reception of the unidirectional
// stream header.
return;
}
buffer.Commit(bytesRead);
// Stream type is a variable-length integer, but we only check the first byte. There is no known type requiring more than 1 byte.
switch (buffer.ActiveSpan[0])
{
case (byte)Http3StreamType.Control:
if (Interlocked.Exchange(ref _haveServerControlStream, 1) != 0)
{
// A second control stream has been received.
throw HttpProtocolException.CreateHttp3ConnectionException(Http3ErrorCode.StreamCreationError);
}
// Discard the stream type header.
buffer.Discard(1);
// Ownership of buffer is transferred to ProcessServerControlStreamAsync.
ArrayBuffer bufferCopy = buffer;
buffer = default;
await ProcessServerControlStreamAsync(stream, bufferCopy).ConfigureAwait(false);
return;
case (byte)Http3StreamType.QPackDecoder:
if (Interlocked.Exchange(ref _haveServerQpackDecodeStream, 1) != 0)
{
// A second QPack decode stream has been received.
throw HttpProtocolException.CreateHttp3ConnectionException(Http3ErrorCode.StreamCreationError);
}
// The stream must not be closed, but we aren't using QPACK right now -- ignore.
buffer.Dispose();
await stream.CopyToAsync(Stream.Null).ConfigureAwait(false);
return;
case (byte)Http3StreamType.QPackEncoder:
if (Interlocked.Exchange(ref _haveServerQpackEncodeStream, 1) != 0)
{
// A second QPack encode stream has been received.
throw HttpProtocolException.CreateHttp3ConnectionException(Http3ErrorCode.StreamCreationError);
}
// We haven't enabled QPack in our SETTINGS frame, so we shouldn't receive any meaningful data here.
// However, the standard says the stream must not be closed for the lifetime of the connection. Just ignore any data.
buffer.Dispose();
await stream.CopyToAsync(Stream.Null).ConfigureAwait(false);
return;
case (byte)Http3StreamType.Push:
// We don't support push streams.
// Because no maximum push stream ID was negotiated via a MAX_PUSH_ID frame, server should not have sent this. Abort the connection with H3_ID_ERROR.
throw HttpProtocolException.CreateHttp3ConnectionException(Http3ErrorCode.IdError);
default:
// Unknown stream type. Per spec, these must be ignored and aborted but not be considered a connection-level error.
if (NetEventSource.Log.IsEnabled())
{
// Read the rest of the integer, which might be more than 1 byte, so we can log it.
long unknownStreamType;
while (!VariableLengthIntegerHelper.TryRead(buffer.ActiveSpan, out unknownStreamType, out _))
{
buffer.EnsureAvailableSpace(VariableLengthIntegerHelper.MaximumEncodedLength);
bytesRead = await stream.ReadAsync(buffer.AvailableMemory, CancellationToken.None).ConfigureAwait(false);
if (bytesRead == 0)
{
unknownStreamType = -1;
break;
}
buffer.Commit(bytesRead);
}
NetEventSource.Info(this, $"Ignoring server-initiated stream of unknown type {unknownStreamType}.");
}
stream.Abort(QuicAbortDirection.Read, (long)Http3ErrorCode.StreamCreationError);
stream.Dispose();
return;
}
}
}
catch (QuicException ex) when(ex.QuicError == QuicError.OperationAborted)
{
// ignore the exception, we have already closed the connection
}
catch (Exception ex)
{
Abort(ex);
}
finally
{
buffer.Dispose();
}
}
