huahaofeng
/
aspnetcore
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

PR feedback for https://github.com/aspnet/KestrelHttpServer/pull/2838

This commit is contained in:
John Luo 2018-08-31 12:06:22 -07:00
parent 0c3b443e3c
commit de5ccb5c78
7 changed files with 61 additions and 61 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
src/Kestrel.Core/Http2Limits.cs
View File

@ -13,11 +13,7 @@ namespace Microsoft.AspNetCore.Server.Kestrel.Core
{ {
private int _maxStreamsPerConnection = 100; private int _maxStreamsPerConnection = 100;
private int _headerTableSize = (int)Http2PeerSettings.DefaultHeaderTableSize; private int _headerTableSize = (int)Http2PeerSettings.DefaultHeaderTableSize;
private int _maxFrameSize = MinAllowedMaxFrameSize; private int _maxFrameSize = (int)Http2PeerSettings.DefaultMaxFrameSize;
// These are limits defined by the RFC https://tools.ietf.org/html/rfc7540#section-4.2
public const int MinAllowedMaxFrameSize = 16 * 1024;
public const int MaxAllowedMaxFrameSize = 16 * 1024 * 1024 - 1;
/// <summary> /// <summary>
/// Limits the number of concurrent request streams per HTTP/2 connection. Excess streams will be refused. /// Limits the number of concurrent request streams per HTTP/2 connection. Excess streams will be refused.
@ -42,7 +38,7 @@ namespace Microsoft.AspNetCore.Server.Kestrel.Core
/// <summary> /// <summary>
/// Limits the size of the header compression table, in octets, the HPACK decoder on the server can use. /// Limits the size of the header compression table, in octets, the HPACK decoder on the server can use.
/// <para> /// <para>
/// Defaults to 4096 /// Value must be greater than 0, defaults to 4096
/// </para> /// </para>
/// </summary> /// </summary>
public int HeaderTableSize public int HeaderTableSize
@ -62,7 +58,7 @@ namespace Microsoft.AspNetCore.Server.Kestrel.Core
/// <summary> /// <summary>
/// Indicates the size of the largest frame payload that is allowed to be received, in octets. The size must be between 2^14 and 2^24-1. /// Indicates the size of the largest frame payload that is allowed to be received, in octets. The size must be between 2^14 and 2^24-1.
/// <para> /// <para>
/// Defaults to 2^14 (16,384) /// Value must be between 2^14 and 2^24, defaults to 2^14 (16,384)
/// </para> /// </para>
/// </summary> /// </summary>
public int MaxFrameSize public int MaxFrameSize
@ -70,9 +66,9 @@ namespace Microsoft.AspNetCore.Server.Kestrel.Core
get => _maxFrameSize; get => _maxFrameSize;
set set
{ {
if (value < MinAllowedMaxFrameSize || value > MaxAllowedMaxFrameSize) if (value < Http2PeerSettings.MinAllowedMaxFrameSize || value > Http2PeerSettings.MaxAllowedMaxFrameSize)
{ {
throw new ArgumentOutOfRangeException(nameof(value), value, CoreStrings.FormatArgumentOutOfRange(MinAllowedMaxFrameSize, MaxAllowedMaxFrameSize)); throw new ArgumentOutOfRangeException(nameof(value), value, CoreStrings.FormatArgumentOutOfRange(Http2PeerSettings.MinAllowedMaxFrameSize, Http2PeerSettings.MaxAllowedMaxFrameSize));
} }
_maxFrameSize = value; _maxFrameSize = value;

8
src/Kestrel.Core/Internal/Http2/Http2Connection.cs
View File

@ -606,7 +606,7 @@ namespace Microsoft.AspNetCore.Server.Kestrel.Core.Internal.Http2
return Task.CompletedTask; return Task.CompletedTask;
} }
private async Task ProcessSettingsFrameAsync() private Task ProcessSettingsFrameAsync()
{ {
if (_currentHeadersStream != null) if (_currentHeadersStream != null)
{ {
@ -625,7 +625,7 @@ namespace Microsoft.AspNetCore.Server.Kestrel.Core.Internal.Http2
throw new Http2ConnectionErrorException(CoreStrings.Http2ErrorSettingsAckLengthNotZero, Http2ErrorCode.FRAME_SIZE_ERROR); throw new Http2ConnectionErrorException(CoreStrings.Http2ErrorSettingsAckLengthNotZero, Http2ErrorCode.FRAME_SIZE_ERROR);
} }
return; return Task.CompletedTask;
} }
if (_incomingFrame.PayloadLength % 6 != 0) if (_incomingFrame.PayloadLength % 6 != 0)
@ -642,7 +642,7 @@ namespace Microsoft.AspNetCore.Server.Kestrel.Core.Internal.Http2
_clientSettings.Update(_incomingFrame.GetSettings()); _clientSettings.Update(_incomingFrame.GetSettings());
// Ack before we update the windows, they could send data immediately. // Ack before we update the windows, they could send data immediately.
await _frameWriter.WriteSettingsAckAsync(); var ackTask = _frameWriter.WriteSettingsAckAsync();
if (_clientSettings.MaxFrameSize != previousMaxFrameSize) if (_clientSettings.MaxFrameSize != previousMaxFrameSize)
{ {
@ -665,6 +665,8 @@ namespace Microsoft.AspNetCore.Server.Kestrel.Core.Internal.Http2
} }
} }
} }
return ackTask;
} }
catch (Http2SettingsParameterOutOfRangeException ex) catch (Http2SettingsParameterOutOfRangeException ex)
{ {

2
src/Kestrel.Core/Internal/Http2/Http2FrameWriter.cs
View File

@ -21,7 +21,7 @@ namespace Microsoft.AspNetCore.Server.Kestrel.Core.Internal.Http2
// Literal Header Field without Indexing - Indexed Name (Index 8 - :status) // Literal Header Field without Indexing - Indexed Name (Index 8 - :status)
private static readonly byte[] _continueBytes = new byte[] { 0x08, 0x03, (byte)'1', (byte)'0', (byte)'0' }; private static readonly byte[] _continueBytes = new byte[] { 0x08, 0x03, (byte)'1', (byte)'0', (byte)'0' };
private uint _maxFrameSize = Http2Limits.MinAllowedMaxFrameSize; private uint _maxFrameSize = Http2PeerSettings.MinAllowedMaxFrameSize;
private Http2Frame _outgoingFrame; private Http2Frame _outgoingFrame;
private readonly object _writeLock = new object(); private readonly object _writeLock = new object();
private readonly HPackEncoder _hpackEncoder = new HPackEncoder(); private readonly HPackEncoder _hpackEncoder = new HPackEncoder();

10
src/Kestrel.Core/Internal/Http2/Http2PeerSettings.cs
View File

@ -12,9 +12,11 @@ namespace Microsoft.AspNetCore.Server.Kestrel.Core.Internal.Http2
public const bool DefaultEnablePush = true; public const bool DefaultEnablePush = true;
public const uint DefaultMaxConcurrentStreams = uint.MaxValue; public const uint DefaultMaxConcurrentStreams = uint.MaxValue;
public const uint DefaultInitialWindowSize = 65535; public const uint DefaultInitialWindowSize = 65535;
public const uint DefaultMaxFrameSize = Http2Limits.MinAllowedMaxFrameSize; public const uint DefaultMaxFrameSize = MinAllowedMaxFrameSize;
public const uint DefaultMaxHeaderListSize = uint.MaxValue; public const uint DefaultMaxHeaderListSize = uint.MaxValue;
public const uint MaxWindowSize = int.MaxValue; public const uint MaxWindowSize = int.MaxValue;
internal const int MinAllowedMaxFrameSize = 16 * 1024;
internal const int MaxAllowedMaxFrameSize = 16 * 1024 * 1024 - 1;
public uint HeaderTableSize { get; set; } = DefaultHeaderTableSize; public uint HeaderTableSize { get; set; } = DefaultHeaderTableSize;
@ -64,11 +66,11 @@ namespace Microsoft.AspNetCore.Server.Kestrel.Core.Internal.Http2
InitialWindowSize = value; InitialWindowSize = value;
break; break;
case Http2SettingsParameter.SETTINGS_MAX_FRAME_SIZE: case Http2SettingsParameter.SETTINGS_MAX_FRAME_SIZE:
if (value < Http2Limits.MinAllowedMaxFrameSize || value > Http2Limits.MaxAllowedMaxFrameSize) if (value < MinAllowedMaxFrameSize || value > MaxAllowedMaxFrameSize)
{ {
throw new Http2SettingsParameterOutOfRangeException(Http2SettingsParameter.SETTINGS_MAX_FRAME_SIZE, throw new Http2SettingsParameterOutOfRangeException(Http2SettingsParameter.SETTINGS_MAX_FRAME_SIZE,
lowerBound: Http2Limits.MinAllowedMaxFrameSize, lowerBound: MinAllowedMaxFrameSize,
upperBound: Http2Limits.MaxAllowedMaxFrameSize); upperBound: MaxAllowedMaxFrameSize);
} }
MaxFrameSize = value; MaxFrameSize = value;

16
test/Kestrel.InMemory.FunctionalTests/Http2/Http2ConnectionTests.cs
View File

@ -76,7 +76,7 @@ namespace Microsoft.AspNetCore.Server.Kestrel.Core.Tests
private static readonly byte[] _worldBytes = Encoding.ASCII.GetBytes("world"); private static readonly byte[] _worldBytes = Encoding.ASCII.GetBytes("world");
private static readonly byte[] _helloWorldBytes = Encoding.ASCII.GetBytes("hello, world"); private static readonly byte[] _helloWorldBytes = Encoding.ASCII.GetBytes("hello, world");
private static readonly byte[] _noData = new byte[0]; private static readonly byte[] _noData = new byte[0];
private static readonly byte[] _maxData = Encoding.ASCII.GetBytes(new string('a', Http2Limits.MinAllowedMaxFrameSize)); private static readonly byte[] _maxData = Encoding.ASCII.GetBytes(new string('a', Http2PeerSettings.MinAllowedMaxFrameSize));
[Fact] [Fact]
public async Task Frame_Received_OverMaxSize_FrameError() public async Task Frame_Received_OverMaxSize_FrameError()
@ -84,20 +84,20 @@ namespace Microsoft.AspNetCore.Server.Kestrel.Core.Tests
await InitializeConnectionAsync(_echoApplication); await InitializeConnectionAsync(_echoApplication);
await StartStreamAsync(1, _browserRequestHeaders, endStream: false); await StartStreamAsync(1, _browserRequestHeaders, endStream: false);
uint length = Http2Limits.MinAllowedMaxFrameSize + 1; uint length = Http2PeerSettings.MinAllowedMaxFrameSize + 1;
await SendDataAsync(1, new byte[length].AsSpan(), endStream: true); await SendDataAsync(1, new byte[length].AsSpan(), endStream: true);
await WaitForConnectionErrorAsync<Http2ConnectionErrorException>( await WaitForConnectionErrorAsync<Http2ConnectionErrorException>(
ignoreNonGoAwayFrames: true, ignoreNonGoAwayFrames: true,
expectedLastStreamId: 1, expectedLastStreamId: 1,
expectedErrorCode: Http2ErrorCode.FRAME_SIZE_ERROR, expectedErrorCode: Http2ErrorCode.FRAME_SIZE_ERROR,
expectedErrorMessage: CoreStrings.FormatHttp2ErrorFrameOverLimit(length, Http2Limits.MinAllowedMaxFrameSize)); expectedErrorMessage: CoreStrings.FormatHttp2ErrorFrameOverLimit(length, Http2PeerSettings.MinAllowedMaxFrameSize));
} }
[Fact] [Fact]
public async Task ServerSettings_ChangesRequestMaxFrameSize() public async Task ServerSettings_ChangesRequestMaxFrameSize()
{ {
var length = Http2Limits.MinAllowedMaxFrameSize + 10; var length = Http2PeerSettings.MinAllowedMaxFrameSize + 10;
_connectionContext.ServiceContext.ServerOptions.Limits.Http2.MaxFrameSize = length; _connectionContext.ServiceContext.ServerOptions.Limits.Http2.MaxFrameSize = length;
_connection = new Http2Connection(_connectionContext); _connection = new Http2Connection(_connectionContext);
@ -112,11 +112,11 @@ namespace Microsoft.AspNetCore.Server.Kestrel.Core.Tests
withStreamId: 1); withStreamId: 1);
// The client's settings is still defaulted to Http2PeerSettings.MinAllowedMaxFrameSize so the echo response will come back in two separate frames // The client's settings is still defaulted to Http2PeerSettings.MinAllowedMaxFrameSize so the echo response will come back in two separate frames
await ExpectAsync(Http2FrameType.DATA, await ExpectAsync(Http2FrameType.DATA,
withLength: Http2Limits.MinAllowedMaxFrameSize, withLength: Http2PeerSettings.MinAllowedMaxFrameSize,
withFlags: (byte)Http2DataFrameFlags.NONE, withFlags: (byte)Http2DataFrameFlags.NONE,
withStreamId: 1); withStreamId: 1);
await ExpectAsync(Http2FrameType.DATA, await ExpectAsync(Http2FrameType.DATA,
withLength: length - Http2Limits.MinAllowedMaxFrameSize, withLength: length - Http2PeerSettings.MinAllowedMaxFrameSize,
withFlags: (byte)Http2DataFrameFlags.NONE, withFlags: (byte)Http2DataFrameFlags.NONE,
withStreamId: 1); withStreamId: 1);
await ExpectAsync(Http2FrameType.DATA, await ExpectAsync(Http2FrameType.DATA,
@ -2139,7 +2139,7 @@ namespace Microsoft.AspNetCore.Server.Kestrel.Core.Tests
{ {
await InitializeConnectionAsync(_noopApplication); await InitializeConnectionAsync(_noopApplication);
var frame = new Http2Frame(Http2Limits.MinAllowedMaxFrameSize); var frame = new Http2Frame(Http2PeerSettings.MinAllowedMaxFrameSize);
frame.PrepareSettings(Http2SettingsFrameFlags.ACK); frame.PrepareSettings(Http2SettingsFrameFlags.ACK);
await SendAsync(frame.Raw); await SendAsync(frame.Raw);
@ -2262,7 +2262,7 @@ namespace Microsoft.AspNetCore.Server.Kestrel.Core.Tests
{ {
// This includes the default response headers such as :status, etc // This includes the default response headers such as :status, etc
var defaultResponseHeaderLength = 37; var defaultResponseHeaderLength = 37;
var headerValueLength = Http2Limits.MinAllowedMaxFrameSize; var headerValueLength = Http2PeerSettings.MinAllowedMaxFrameSize;
// First byte is always 0 // First byte is always 0
// Second byte is the length of header name which is 1 // Second byte is the length of header name which is 1
// Third byte is the header name which is A/B // Third byte is the header name which is A/B

70
test/Kestrel.InMemory.FunctionalTests/Http2/Http2TestBase.cs
View File

@ -141,7 +141,7 @@ namespace Microsoft.AspNetCore.Server.Kestrel.Core.Tests
_echoApplication = async context => _echoApplication = async context =>
{ {
var buffer = new byte[Http2Limits.MinAllowedMaxFrameSize]; var buffer = new byte[Http2PeerSettings.MinAllowedMaxFrameSize];
var received = 0; var received = 0;
while ((received = await context.Request.Body.ReadAsync(buffer, 0, buffer.Length)) > 0) while ((received = await context.Request.Body.ReadAsync(buffer, 0, buffer.Length)) > 0)
@ -152,7 +152,7 @@ namespace Microsoft.AspNetCore.Server.Kestrel.Core.Tests
_echoWaitForAbortApplication = async context => _echoWaitForAbortApplication = async context =>
{ {
var buffer = new byte[Http2Limits.MinAllowedMaxFrameSize]; var buffer = new byte[Http2PeerSettings.MinAllowedMaxFrameSize];
var received = 0; var received = 0;
while ((received = await context.Request.Body.ReadAsync(buffer, 0, buffer.Length)) > 0) while ((received = await context.Request.Body.ReadAsync(buffer, 0, buffer.Length)) > 0)
@ -315,7 +315,7 @@ namespace Microsoft.AspNetCore.Server.Kestrel.Core.Tests
await SendSettingsAsync(); await SendSettingsAsync();
await ExpectAsync(Http2FrameType.SETTINGS, await ExpectAsync(Http2FrameType.SETTINGS,
withLength: expectedSettingsCount * 6, withLength: expectedSettingsCount * Http2Frame.SettingSize,
withFlags: 0, withFlags: 0,
withStreamId: 0); withStreamId: 0);
@ -330,7 +330,7 @@ namespace Microsoft.AspNetCore.Server.Kestrel.Core.Tests
var tcs = new TaskCompletionSource<object>(TaskCreationOptions.RunContinuationsAsynchronously); var tcs = new TaskCompletionSource<object>(TaskCreationOptions.RunContinuationsAsynchronously);
_runningStreams[streamId] = tcs; _runningStreams[streamId] = tcs;
var frame = new Http2Frame(Http2Limits.MinAllowedMaxFrameSize); var frame = new Http2Frame(Http2PeerSettings.MinAllowedMaxFrameSize);
frame.PrepareHeaders(Http2HeadersFrameFlags.NONE, streamId); frame.PrepareHeaders(Http2HeadersFrameFlags.NONE, streamId);
var done = _hpackEncoder.BeginEncode(headers, frame.HeadersPayload, out var length); var done = _hpackEncoder.BeginEncode(headers, frame.HeadersPayload, out var length);
frame.PayloadLength = length; frame.PayloadLength = length;
@ -367,7 +367,7 @@ namespace Microsoft.AspNetCore.Server.Kestrel.Core.Tests
var tcs = new TaskCompletionSource<object>(TaskCreationOptions.RunContinuationsAsynchronously); var tcs = new TaskCompletionSource<object>(TaskCreationOptions.RunContinuationsAsynchronously);
_runningStreams[streamId] = tcs; _runningStreams[streamId] = tcs;
var frame = new Http2Frame(Http2Limits.MinAllowedMaxFrameSize); var frame = new Http2Frame(Http2PeerSettings.MinAllowedMaxFrameSize);
frame.PrepareHeaders(Http2HeadersFrameFlags.END_HEADERS | Http2HeadersFrameFlags.PADDED, streamId); frame.PrepareHeaders(Http2HeadersFrameFlags.END_HEADERS | Http2HeadersFrameFlags.PADDED, streamId);
frame.HeadersPadLength = padLength; frame.HeadersPadLength = padLength;
@ -390,7 +390,7 @@ namespace Microsoft.AspNetCore.Server.Kestrel.Core.Tests
var tcs = new TaskCompletionSource<object>(TaskCreationOptions.RunContinuationsAsynchronously); var tcs = new TaskCompletionSource<object>(TaskCreationOptions.RunContinuationsAsynchronously);
_runningStreams[streamId] = tcs; _runningStreams[streamId] = tcs;
var frame = new Http2Frame(Http2Limits.MinAllowedMaxFrameSize); var frame = new Http2Frame(Http2PeerSettings.MinAllowedMaxFrameSize);
frame.PrepareHeaders(Http2HeadersFrameFlags.END_HEADERS | Http2HeadersFrameFlags.PRIORITY, streamId); frame.PrepareHeaders(Http2HeadersFrameFlags.END_HEADERS | Http2HeadersFrameFlags.PRIORITY, streamId);
frame.HeadersPriorityWeight = priority; frame.HeadersPriorityWeight = priority;
frame.HeadersStreamDependency = streamDependency; frame.HeadersStreamDependency = streamDependency;
@ -412,7 +412,7 @@ namespace Microsoft.AspNetCore.Server.Kestrel.Core.Tests
var tcs = new TaskCompletionSource<object>(TaskCreationOptions.RunContinuationsAsynchronously); var tcs = new TaskCompletionSource<object>(TaskCreationOptions.RunContinuationsAsynchronously);
_runningStreams[streamId] = tcs; _runningStreams[streamId] = tcs;
var frame = new Http2Frame(Http2Limits.MinAllowedMaxFrameSize); var frame = new Http2Frame(Http2PeerSettings.MinAllowedMaxFrameSize);
frame.PrepareHeaders(Http2HeadersFrameFlags.END_HEADERS | Http2HeadersFrameFlags.PADDED | Http2HeadersFrameFlags.PRIORITY, streamId); frame.PrepareHeaders(Http2HeadersFrameFlags.END_HEADERS | Http2HeadersFrameFlags.PADDED | Http2HeadersFrameFlags.PRIORITY, streamId);
frame.HeadersPadLength = padLength; frame.HeadersPadLength = padLength;
frame.HeadersPriorityWeight = priority; frame.HeadersPriorityWeight = priority;
@ -452,14 +452,14 @@ namespace Microsoft.AspNetCore.Server.Kestrel.Core.Tests
protected Task SendSettingsAsync() protected Task SendSettingsAsync()
{ {
var frame = new Http2Frame(Http2Limits.MinAllowedMaxFrameSize); var frame = new Http2Frame(Http2PeerSettings.MinAllowedMaxFrameSize);
frame.PrepareSettings(Http2SettingsFrameFlags.NONE, _clientSettings.GetNonProtocolDefaults()); frame.PrepareSettings(Http2SettingsFrameFlags.NONE, _clientSettings.GetNonProtocolDefaults());
return SendAsync(frame.Raw); return SendAsync(frame.Raw);
} }
protected Task SendSettingsAckWithInvalidLengthAsync(int length) protected Task SendSettingsAckWithInvalidLengthAsync(int length)
{ {
var frame = new Http2Frame(Http2Limits.MinAllowedMaxFrameSize); var frame = new Http2Frame(Http2PeerSettings.MinAllowedMaxFrameSize);
frame.PrepareSettings(Http2SettingsFrameFlags.ACK); frame.PrepareSettings(Http2SettingsFrameFlags.ACK);
frame.PayloadLength = length; frame.PayloadLength = length;
return SendAsync(frame.Raw); return SendAsync(frame.Raw);
@ -467,7 +467,7 @@ namespace Microsoft.AspNetCore.Server.Kestrel.Core.Tests
protected Task SendSettingsWithInvalidStreamIdAsync(int streamId) protected Task SendSettingsWithInvalidStreamIdAsync(int streamId)
{ {
var frame = new Http2Frame(Http2Limits.MinAllowedMaxFrameSize); var frame = new Http2Frame(Http2PeerSettings.MinAllowedMaxFrameSize);
frame.PrepareSettings(Http2SettingsFrameFlags.NONE, _clientSettings.GetNonProtocolDefaults()); frame.PrepareSettings(Http2SettingsFrameFlags.NONE, _clientSettings.GetNonProtocolDefaults());
frame.StreamId = streamId; frame.StreamId = streamId;
return SendAsync(frame.Raw); return SendAsync(frame.Raw);
@ -475,7 +475,7 @@ namespace Microsoft.AspNetCore.Server.Kestrel.Core.Tests
protected Task SendSettingsWithInvalidLengthAsync(int length) protected Task SendSettingsWithInvalidLengthAsync(int length)
{ {
var frame = new Http2Frame(Http2Limits.MinAllowedMaxFrameSize); var frame = new Http2Frame(Http2PeerSettings.MinAllowedMaxFrameSize);
frame.PrepareSettings(Http2SettingsFrameFlags.NONE, _clientSettings.GetNonProtocolDefaults()); frame.PrepareSettings(Http2SettingsFrameFlags.NONE, _clientSettings.GetNonProtocolDefaults());
frame.PayloadLength = length; frame.PayloadLength = length;
return SendAsync(frame.Raw); return SendAsync(frame.Raw);
@ -483,7 +483,7 @@ namespace Microsoft.AspNetCore.Server.Kestrel.Core.Tests
protected Task SendSettingsWithInvalidParameterValueAsync(Http2SettingsParameter parameter, uint value) protected Task SendSettingsWithInvalidParameterValueAsync(Http2SettingsParameter parameter, uint value)
{ {
var frame = new Http2Frame(Http2Limits.MinAllowedMaxFrameSize); var frame = new Http2Frame(Http2PeerSettings.MinAllowedMaxFrameSize);
frame.PrepareSettings(Http2SettingsFrameFlags.NONE); frame.PrepareSettings(Http2SettingsFrameFlags.NONE);
frame.PayloadLength = 6; frame.PayloadLength = 6;
@ -499,7 +499,7 @@ namespace Microsoft.AspNetCore.Server.Kestrel.Core.Tests
protected Task SendPushPromiseFrameAsync() protected Task SendPushPromiseFrameAsync()
{ {
var frame = new Http2Frame(Http2Limits.MinAllowedMaxFrameSize); var frame = new Http2Frame(Http2PeerSettings.MinAllowedMaxFrameSize);
frame.PayloadLength = 0; frame.PayloadLength = 0;
frame.Type = Http2FrameType.PUSH_PROMISE; frame.Type = Http2FrameType.PUSH_PROMISE;
frame.StreamId = 1; frame.StreamId = 1;
@ -508,7 +508,7 @@ namespace Microsoft.AspNetCore.Server.Kestrel.Core.Tests
protected async Task<bool> SendHeadersAsync(int streamId, Http2HeadersFrameFlags flags, IEnumerable<KeyValuePair<string, string>> headers) protected async Task<bool> SendHeadersAsync(int streamId, Http2HeadersFrameFlags flags, IEnumerable<KeyValuePair<string, string>> headers)
{ {
var frame = new Http2Frame(Http2Limits.MinAllowedMaxFrameSize); var frame = new Http2Frame(Http2PeerSettings.MinAllowedMaxFrameSize);
frame.PrepareHeaders(flags, streamId); frame.PrepareHeaders(flags, streamId);
var done = _hpackEncoder.BeginEncode(headers, frame.Payload, out var length); var done = _hpackEncoder.BeginEncode(headers, frame.Payload, out var length);
@ -521,7 +521,7 @@ namespace Microsoft.AspNetCore.Server.Kestrel.Core.Tests
protected Task SendHeadersAsync(int streamId, Http2HeadersFrameFlags flags, byte[] headerBlock) protected Task SendHeadersAsync(int streamId, Http2HeadersFrameFlags flags, byte[] headerBlock)
{ {
var frame = new Http2Frame(Http2Limits.MinAllowedMaxFrameSize); var frame = new Http2Frame(Http2PeerSettings.MinAllowedMaxFrameSize);
frame.PrepareHeaders(flags, streamId); frame.PrepareHeaders(flags, streamId);
frame.PayloadLength = headerBlock.Length; frame.PayloadLength = headerBlock.Length;
@ -534,7 +534,7 @@ namespace Microsoft.AspNetCore.Server.Kestrel.Core.Tests
{ {
Assert.True(padLength >= payloadLength, $"{nameof(padLength)} must be greater than or equal to {nameof(payloadLength)} to create an invalid frame."); Assert.True(padLength >= payloadLength, $"{nameof(padLength)} must be greater than or equal to {nameof(payloadLength)} to create an invalid frame.");
var frame = new Http2Frame(Http2Limits.MinAllowedMaxFrameSize); var frame = new Http2Frame(Http2PeerSettings.MinAllowedMaxFrameSize);
frame.PrepareHeaders(Http2HeadersFrameFlags.PADDED, streamId); frame.PrepareHeaders(Http2HeadersFrameFlags.PADDED, streamId);
frame.Payload[0] = padLength; frame.Payload[0] = padLength;
@ -547,7 +547,7 @@ namespace Microsoft.AspNetCore.Server.Kestrel.Core.Tests
protected Task SendIncompleteHeadersFrameAsync(int streamId) protected Task SendIncompleteHeadersFrameAsync(int streamId)
{ {
var frame = new Http2Frame(Http2Limits.MinAllowedMaxFrameSize); var frame = new Http2Frame(Http2PeerSettings.MinAllowedMaxFrameSize);
frame.PrepareHeaders(Http2HeadersFrameFlags.END_HEADERS, streamId); frame.PrepareHeaders(Http2HeadersFrameFlags.END_HEADERS, streamId);
frame.PayloadLength = 3; frame.PayloadLength = 3;
@ -563,7 +563,7 @@ namespace Microsoft.AspNetCore.Server.Kestrel.Core.Tests
protected async Task<bool> SendContinuationAsync(int streamId, Http2ContinuationFrameFlags flags) protected async Task<bool> SendContinuationAsync(int streamId, Http2ContinuationFrameFlags flags)
{ {
var frame = new Http2Frame(Http2Limits.MinAllowedMaxFrameSize); var frame = new Http2Frame(Http2PeerSettings.MinAllowedMaxFrameSize);
frame.PrepareContinuation(flags, streamId); frame.PrepareContinuation(flags, streamId);
var done = _hpackEncoder.Encode(frame.Payload, out var length); var done = _hpackEncoder.Encode(frame.Payload, out var length);
@ -576,7 +576,7 @@ namespace Microsoft.AspNetCore.Server.Kestrel.Core.Tests
protected async Task SendContinuationAsync(int streamId, Http2ContinuationFrameFlags flags, byte[] payload) protected async Task SendContinuationAsync(int streamId, Http2ContinuationFrameFlags flags, byte[] payload)
{ {
var frame = new Http2Frame(Http2Limits.MinAllowedMaxFrameSize); var frame = new Http2Frame(Http2PeerSettings.MinAllowedMaxFrameSize);
frame.PrepareContinuation(flags, streamId); frame.PrepareContinuation(flags, streamId);
frame.PayloadLength = payload.Length; frame.PayloadLength = payload.Length;
@ -587,7 +587,7 @@ namespace Microsoft.AspNetCore.Server.Kestrel.Core.Tests
protected Task SendEmptyContinuationFrameAsync(int streamId, Http2ContinuationFrameFlags flags) protected Task SendEmptyContinuationFrameAsync(int streamId, Http2ContinuationFrameFlags flags)
{ {
var frame = new Http2Frame(Http2Limits.MinAllowedMaxFrameSize); var frame = new Http2Frame(Http2PeerSettings.MinAllowedMaxFrameSize);
frame.PrepareContinuation(flags, streamId); frame.PrepareContinuation(flags, streamId);
frame.PayloadLength = 0; frame.PayloadLength = 0;
@ -597,7 +597,7 @@ namespace Microsoft.AspNetCore.Server.Kestrel.Core.Tests
protected Task SendIncompleteContinuationFrameAsync(int streamId) protected Task SendIncompleteContinuationFrameAsync(int streamId)
{ {
var frame = new Http2Frame(Http2Limits.MinAllowedMaxFrameSize); var frame = new Http2Frame(Http2PeerSettings.MinAllowedMaxFrameSize);
frame.PrepareContinuation(Http2ContinuationFrameFlags.END_HEADERS, streamId); frame.PrepareContinuation(Http2ContinuationFrameFlags.END_HEADERS, streamId);
frame.PayloadLength = 3; frame.PayloadLength = 3;
@ -625,7 +625,7 @@ namespace Microsoft.AspNetCore.Server.Kestrel.Core.Tests
protected Task SendDataWithPaddingAsync(int streamId, Span<byte> data, byte padLength, bool endStream) protected Task SendDataWithPaddingAsync(int streamId, Span<byte> data, byte padLength, bool endStream)
{ {
var frame = new Http2Frame(Http2Limits.MinAllowedMaxFrameSize); var frame = new Http2Frame(Http2PeerSettings.MinAllowedMaxFrameSize);
frame.PrepareData(streamId, padLength); frame.PrepareData(streamId, padLength);
frame.PayloadLength = data.Length + 1 + padLength; frame.PayloadLength = data.Length + 1 + padLength;
@ -643,7 +643,7 @@ namespace Microsoft.AspNetCore.Server.Kestrel.Core.Tests
{ {
Assert.True(padLength >= frameLength, $"{nameof(padLength)} must be greater than or equal to {nameof(frameLength)} to create an invalid frame."); Assert.True(padLength >= frameLength, $"{nameof(padLength)} must be greater than or equal to {nameof(frameLength)} to create an invalid frame.");
var frame = new Http2Frame(Http2Limits.MinAllowedMaxFrameSize); var frame = new Http2Frame(Http2PeerSettings.MinAllowedMaxFrameSize);
frame.PrepareData(streamId); frame.PrepareData(streamId);
frame.DataFlags = Http2DataFrameFlags.PADDED; frame.DataFlags = Http2DataFrameFlags.PADDED;
@ -657,14 +657,14 @@ namespace Microsoft.AspNetCore.Server.Kestrel.Core.Tests
protected Task SendPingAsync(Http2PingFrameFlags flags) protected Task SendPingAsync(Http2PingFrameFlags flags)
{ {
var pingFrame = new Http2Frame(Http2Limits.MinAllowedMaxFrameSize); var pingFrame = new Http2Frame(Http2PeerSettings.MinAllowedMaxFrameSize);
pingFrame.PreparePing(flags); pingFrame.PreparePing(flags);
return SendAsync(pingFrame.Raw); return SendAsync(pingFrame.Raw);
} }
protected Task SendPingWithInvalidLengthAsync(int length) protected Task SendPingWithInvalidLengthAsync(int length)
{ {
var pingFrame = new Http2Frame(Http2Limits.MinAllowedMaxFrameSize); var pingFrame = new Http2Frame(Http2PeerSettings.MinAllowedMaxFrameSize);
pingFrame.PreparePing(Http2PingFrameFlags.NONE); pingFrame.PreparePing(Http2PingFrameFlags.NONE);
pingFrame.PayloadLength = length; pingFrame.PayloadLength = length;
return SendAsync(pingFrame.Raw); return SendAsync(pingFrame.Raw);
@ -674,7 +674,7 @@ namespace Microsoft.AspNetCore.Server.Kestrel.Core.Tests
{ {
Assert.NotEqual(0, streamId); Assert.NotEqual(0, streamId);
var pingFrame = new Http2Frame(Http2Limits.MinAllowedMaxFrameSize); var pingFrame = new Http2Frame(Http2PeerSettings.MinAllowedMaxFrameSize);
pingFrame.PreparePing(Http2PingFrameFlags.NONE); pingFrame.PreparePing(Http2PingFrameFlags.NONE);
pingFrame.StreamId = streamId; pingFrame.StreamId = streamId;
return SendAsync(pingFrame.Raw); return SendAsync(pingFrame.Raw);
@ -682,14 +682,14 @@ namespace Microsoft.AspNetCore.Server.Kestrel.Core.Tests
protected Task SendPriorityAsync(int streamId, int streamDependency = 0) protected Task SendPriorityAsync(int streamId, int streamDependency = 0)
{ {
var priorityFrame = new Http2Frame(Http2Limits.MinAllowedMaxFrameSize); var priorityFrame = new Http2Frame(Http2PeerSettings.MinAllowedMaxFrameSize);
priorityFrame.PreparePriority(streamId, streamDependency: streamDependency, exclusive: false, weight: 0); priorityFrame.PreparePriority(streamId, streamDependency: streamDependency, exclusive: false, weight: 0);
return SendAsync(priorityFrame.Raw); return SendAsync(priorityFrame.Raw);
} }
protected Task SendInvalidPriorityFrameAsync(int streamId, int length) protected Task SendInvalidPriorityFrameAsync(int streamId, int length)
{ {
var priorityFrame = new Http2Frame(Http2Limits.MinAllowedMaxFrameSize); var priorityFrame = new Http2Frame(Http2PeerSettings.MinAllowedMaxFrameSize);
priorityFrame.PreparePriority(streamId, streamDependency: 0, exclusive: false, weight: 0); priorityFrame.PreparePriority(streamId, streamDependency: 0, exclusive: false, weight: 0);
priorityFrame.PayloadLength = length; priorityFrame.PayloadLength = length;
return SendAsync(priorityFrame.Raw); return SendAsync(priorityFrame.Raw);
@ -697,14 +697,14 @@ namespace Microsoft.AspNetCore.Server.Kestrel.Core.Tests
protected Task SendRstStreamAsync(int streamId) protected Task SendRstStreamAsync(int streamId)
{ {
var rstStreamFrame = new Http2Frame(Http2Limits.MinAllowedMaxFrameSize); var rstStreamFrame = new Http2Frame(Http2PeerSettings.MinAllowedMaxFrameSize);
rstStreamFrame.PrepareRstStream(streamId, Http2ErrorCode.CANCEL); rstStreamFrame.PrepareRstStream(streamId, Http2ErrorCode.CANCEL);
return SendAsync(rstStreamFrame.Raw); return SendAsync(rstStreamFrame.Raw);
} }
protected Task SendInvalidRstStreamFrameAsync(int streamId, int length) protected Task SendInvalidRstStreamFrameAsync(int streamId, int length)
{ {
var frame = new Http2Frame(Http2Limits.MinAllowedMaxFrameSize); var frame = new Http2Frame(Http2PeerSettings.MinAllowedMaxFrameSize);
frame.PrepareRstStream(streamId, Http2ErrorCode.CANCEL); frame.PrepareRstStream(streamId, Http2ErrorCode.CANCEL);
frame.PayloadLength = length; frame.PayloadLength = length;
return SendAsync(frame.Raw); return SendAsync(frame.Raw);
@ -712,14 +712,14 @@ namespace Microsoft.AspNetCore.Server.Kestrel.Core.Tests
protected Task SendGoAwayAsync() protected Task SendGoAwayAsync()
{ {
var frame = new Http2Frame(Http2Limits.MinAllowedMaxFrameSize); var frame = new Http2Frame(Http2PeerSettings.MinAllowedMaxFrameSize);
frame.PrepareGoAway(0, Http2ErrorCode.NO_ERROR); frame.PrepareGoAway(0, Http2ErrorCode.NO_ERROR);
return SendAsync(frame.Raw); return SendAsync(frame.Raw);
} }
protected Task SendInvalidGoAwayFrameAsync() protected Task SendInvalidGoAwayFrameAsync()
{ {
var frame = new Http2Frame(Http2Limits.MinAllowedMaxFrameSize); var frame = new Http2Frame(Http2PeerSettings.MinAllowedMaxFrameSize);
frame.PrepareGoAway(0, Http2ErrorCode.NO_ERROR); frame.PrepareGoAway(0, Http2ErrorCode.NO_ERROR);
frame.StreamId = 1; frame.StreamId = 1;
return SendAsync(frame.Raw); return SendAsync(frame.Raw);
@ -727,14 +727,14 @@ namespace Microsoft.AspNetCore.Server.Kestrel.Core.Tests
protected Task SendWindowUpdateAsync(int streamId, int sizeIncrement) protected Task SendWindowUpdateAsync(int streamId, int sizeIncrement)
{ {
var frame = new Http2Frame(Http2Limits.MinAllowedMaxFrameSize); var frame = new Http2Frame(Http2PeerSettings.MinAllowedMaxFrameSize);
frame.PrepareWindowUpdate(streamId, sizeIncrement); frame.PrepareWindowUpdate(streamId, sizeIncrement);
return SendAsync(frame.Raw); return SendAsync(frame.Raw);
} }
protected Task SendInvalidWindowUpdateAsync(int streamId, int sizeIncrement, int length) protected Task SendInvalidWindowUpdateAsync(int streamId, int sizeIncrement, int length)
{ {
var frame = new Http2Frame(Http2Limits.MinAllowedMaxFrameSize); var frame = new Http2Frame(Http2PeerSettings.MinAllowedMaxFrameSize);
frame.PrepareWindowUpdate(streamId, sizeIncrement); frame.PrepareWindowUpdate(streamId, sizeIncrement);
frame.PayloadLength = length; frame.PayloadLength = length;
return SendAsync(frame.Raw); return SendAsync(frame.Raw);
@ -742,7 +742,7 @@ namespace Microsoft.AspNetCore.Server.Kestrel.Core.Tests
protected Task SendUnknownFrameTypeAsync(int streamId, int frameType) protected Task SendUnknownFrameTypeAsync(int streamId, int frameType)
{ {
var frame = new Http2Frame(Http2Limits.MinAllowedMaxFrameSize); var frame = new Http2Frame(Http2PeerSettings.MinAllowedMaxFrameSize);
frame.StreamId = streamId; frame.StreamId = streamId;
frame.Type = (Http2FrameType)frameType; frame.Type = (Http2FrameType)frameType;
frame.PayloadLength = 0; frame.PayloadLength = 0;

2
test/Kestrel.InMemory.FunctionalTests/Http2/TlsTests.cs
View File

@ -92,7 +92,7 @@ namespace Microsoft.AspNetCore.Server.Kestrel.InMemory.FunctionalTests.Http2
private async Task<Http2Frame> ReceiveFrameAsync(PipeReader reader) private async Task<Http2Frame> ReceiveFrameAsync(PipeReader reader)
{ {
var frame = new Http2Frame(Http2Limits.MinAllowedMaxFrameSize); var frame = new Http2Frame(Http2PeerSettings.MinAllowedMaxFrameSize);
while (true) while (true)
{ {