ProcessServerControlStreamAsync()

async Task System.Net.Http.Http3Connection.ProcessServerControlStreamAsync ( QuicStream stream, System::Net::ArrayBuffer buffer )

inlineprivate

Definition at line 422 of file Http3Connection.cs.

    {
        using (buffer)
        {
            Http3FrameType? http3FrameType;
            long settingsPayloadLength2;
            (http3FrameType, settingsPayloadLength2) = await ReadFrameEnvelopeAsync().ConfigureAwait(continueOnCapturedContext: false);
            if (!http3FrameType.HasValue)
            {
                throw new Http3ConnectionException(Http3ErrorCode.ClosedCriticalStream);
            }
            if (http3FrameType != Http3FrameType.Settings)
            {
                throw new Http3ConnectionException(Http3ErrorCode.MissingSettings);
            }
            await ProcessSettingsFrameAsync(settingsPayloadLength2).ConfigureAwait(continueOnCapturedContext: false);
            while (true)
            {
                (http3FrameType, settingsPayloadLength2) = await ReadFrameEnvelopeAsync().ConfigureAwait(continueOnCapturedContext: false);
                if (!http3FrameType.HasValue)
                {
                    break;
                }
                Http3FrameType valueOrDefault = http3FrameType.GetValueOrDefault();
                if ((ulong)valueOrDefault <= 13uL)
                {
                    switch (valueOrDefault)
                    {
                    case Http3FrameType.GoAway:
                        await ProcessGoAwayFrameAsync(settingsPayloadLength2).ConfigureAwait(continueOnCapturedContext: false);
                        continue;
                    case Http3FrameType.Settings:
                        throw new Http3ConnectionException(Http3ErrorCode.UnexpectedFrame);
                    case Http3FrameType.Data:
                    case Http3FrameType.Headers:
                    case Http3FrameType.ReservedHttp2Priority:
                    case Http3FrameType.ReservedHttp2Ping:
                    case Http3FrameType.ReservedHttp2WindowUpdate:
                    case Http3FrameType.ReservedHttp2Continuation:
                    case Http3FrameType.MaxPushId:
                        throw new Http3ConnectionException(Http3ErrorCode.UnexpectedFrame);
                    case Http3FrameType.CancelPush:
                    case Http3FrameType.PushPromise:
                        throw new Http3ConnectionException(Http3ErrorCode.IdError);
                    }
                }
                await SkipUnknownPayloadAsync(http3FrameType.GetValueOrDefault(), settingsPayloadLength2).ConfigureAwait(continueOnCapturedContext: false);
            }
            bool shuttingDown;
            lock (SyncObj)
            {
                shuttingDown = ShuttingDown;
            }
            if (!shuttingDown)
            {
                throw new Http3ConnectionException(Http3ErrorCode.ClosedCriticalStream);
            }
        }
        async ValueTask ProcessGoAwayFrameAsync(long goawayPayloadLength)
        {
            long value;
            int bytesRead;
            while (!VariableLengthIntegerHelper.TryRead(buffer.ActiveSpan, out value, out bytesRead))
            {
                buffer.EnsureAvailableSpace(8);
                bytesRead = await stream.ReadAsync(buffer.AvailableMemory, CancellationToken.None).ConfigureAwait(continueOnCapturedContext: false);
                if (bytesRead == 0)
                {
                    throw new Http3ConnectionException(Http3ErrorCode.FrameError);
                }
                buffer.Commit(bytesRead);
            }
            buffer.Discard(bytesRead);
            if (bytesRead != goawayPayloadLength)
            {
                throw new Http3ConnectionException(Http3ErrorCode.FrameError);
            }
            OnServerGoAway(value);
        }
        async ValueTask ProcessSettingsFrameAsync(long settingsPayloadLength)
        {
            while (settingsPayloadLength != 0L)
            {
                long a;
                long b;
                int bytesRead2;
                while (!Http3Frame.TryReadIntegerPair(buffer.ActiveSpan, out a, out b, out bytesRead2))
                {
                    buffer.EnsureAvailableSpace(16);
                    bytesRead2 = await stream.ReadAsync(buffer.AvailableMemory, CancellationToken.None).ConfigureAwait(continueOnCapturedContext: false);
                    if (bytesRead2 == 0)
                    {
                        throw new Http3ConnectionException(Http3ErrorCode.FrameError);
                    }
                    buffer.Commit(bytesRead2);
                }
                settingsPayloadLength -= bytesRead2;
                if (settingsPayloadLength < 0)
                {
                    throw new Http3ConnectionException(Http3ErrorCode.FrameError);
                }
                buffer.Discard(bytesRead2);
                switch ((Http3SettingType)a)
                {
                case Http3SettingType.MaxHeaderListSize:
                    _maximumHeadersLength = (int)Math.Min(b, 2147483647L);
                    break;
                case Http3SettingType.ReservedHttp2EnablePush:
                case Http3SettingType.ReservedHttp2MaxConcurrentStreams:
                case Http3SettingType.ReservedHttp2InitialWindowSize:
                case Http3SettingType.ReservedHttp2MaxFrameSize:
                    throw new Http3ConnectionException(Http3ErrorCode.SettingsError);
                }
            }
        }
        async ValueTask<(Http3FrameType? frameType, long payloadLength)> ReadFrameEnvelopeAsync()
        {
            long a2;
            long b2;
            int bytesRead3;
            while (!Http3Frame.TryReadIntegerPair(buffer.ActiveSpan, out a2, out b2, out bytesRead3))
            {
                buffer.EnsureAvailableSpace(16);
                bytesRead3 = await stream.ReadAsync(buffer.AvailableMemory, CancellationToken.None).ConfigureAwait(continueOnCapturedContext: false);
                if (bytesRead3 == 0)
                {
                    if (buffer.ActiveLength == 0)
                    {
                        return (null, 0L);
                    }
                    throw new Http3ConnectionException(Http3ErrorCode.FrameError);
                }
                buffer.Commit(bytesRead3);
            }
            buffer.Discard(bytesRead3);
            return ((Http3FrameType)a2, b2);
        }
        async ValueTask SkipUnknownPayloadAsync(Http3FrameType frameType, long payloadLength)
        {
            while (payloadLength != 0L)
            {
                if (buffer.ActiveLength == 0)
                {
                    int num = await stream.ReadAsync(buffer.AvailableMemory, CancellationToken.None).ConfigureAwait(continueOnCapturedContext: false);
                    if (num == 0)
                    {
                        throw new Http3ConnectionException(Http3ErrorCode.FrameError);
                    }
                    buffer.Commit(num);
                }
                long num2 = Math.Min(payloadLength, buffer.ActiveLength);
                buffer.Discard((int)num2);
                payloadLength -= num2;
            }
        }
    }

References System.Net.Http.Http3Connection._maximumHeadersLength, System.buffer, System.L, System.Math.Min(), System.Threading.CancellationToken.None, System.Net.Http.Http3Connection.OnServerGoAway(), System.Net.Http.Http3Connection.ShuttingDown, System.stream, System.Net.Http.Http3Connection.SyncObj, System.Net.Http.VariableLengthIntegerHelper.TryRead(), System.Net.Http.Http3Frame.TryReadIntegerPair(), and System.value.

Referenced by System.Net.Http.Http3Connection.ProcessServerStreamAsync().