public WindowUpdate(
UInt31 streamId,
UInt31 deltaWindowSize)
: base(Type)
{
StreamId = streamId;
DeltaWindowSize = deltaWindowSize;
}
private GoAway(
UInt31 lastGoodStreamId,
StatusCode status)
: base(Type)
{
LastGoodStreamId = lastGoodStreamId;
Status = status;
}
public Headers(
UInt31 streamId,
NameValueHeaderBlock values)
: this(
Options.None,
streamId,
values)
{
}
public Data(
UInt31 streamId,
byte[] payload)
: this(
streamId,
Options.None,
payload)
{
}
private Data(
UInt31 streamId,
Options flags,
byte[] payload)
{
StreamId = streamId;
Flags = flags;
Payload = payload;
}
private SynReply(
Options flags,
UInt31 streamId,
NameValueHeaderBlock?headers = null) : base(Type)
{
Flags = flags;
StreamId = streamId;
Headers = headers ?? new NameValueHeaderBlock();
}
private GoAway(
Options flags,
UInt24 length,
UInt31 lastGoodStreamId,
StatusCode status)
: this(lastGoodStreamId, status)
{
Flags = flags;
Length = length;
}
private Headers(
Options flags,
UInt31 streamId,
NameValueHeaderBlock values)
: base(Type)
{
Flags = flags;
StreamId = streamId;
Values = values;
}
private WindowUpdate(
Options flags,
UInt24 length,
UInt31 streamId,
UInt31 deltaWindowSize)
: this(streamId, deltaWindowSize)
{
Flags = flags;
Length = length;
}
internal new static async ValueTask <ReadResult <Control> > TryReadAsync(
IFrameReader frameReader,
CancellationToken cancellation = default)
{
var version =
(ushort)(await frameReader.ReadUShortAsync(cancellation)
.ConfigureAwait(false) & 0x7FFF);
if (version != Version)
{
// todo: What stream id should be specified here?
return(ReadResult <Control> .Error(RstStream.UnsupportedVersion(UInt31.From(0))));
}
var type = await frameReader.ReadUShortAsync(cancellation)
.ConfigureAwait(false);
var flags = await frameReader.ReadByteAsync(cancellation)
.ConfigureAwait(false);
var length = await frameReader.ReadUInt24Async(cancellation)
.ConfigureAwait(false);
return(type switch
{
SynStream.Type => (await SynStream.TryReadAsync(
flags, length, frameReader, cancellation)
.ConfigureAwait(false)).AsControl(),
SynReply.Type => (await SynReply.TryReadAsync(
flags, length, frameReader, cancellation)
.ConfigureAwait(false)).AsControl(),
RstStream.Type => (await RstStream.TryReadAsync(
flags, length, frameReader, cancellation)
.ConfigureAwait(false)).AsControl(),
Settings.Type => (await Settings.TryReadAsync(
flags, length, frameReader, cancellation)
.ConfigureAwait(false)).AsControl(),
Ping.Type => (await Ping.TryReadAsync(
flags, length, frameReader, cancellation)
.ConfigureAwait(false)).AsControl(),
GoAway.Type => (await GoAway.TryReadAsync(
flags, length, frameReader, cancellation)
.ConfigureAwait(false)).AsControl(),
Headers.Type => (await Headers.TryReadAsync(
flags, length, frameReader, cancellation)
.ConfigureAwait(false)).AsControl(),
WindowUpdate.Type => (await WindowUpdate.TryReadAsync(
flags, length, frameReader, cancellation)
.ConfigureAwait(false)).AsControl(),
_ => throw new ArgumentOutOfRangeException(
nameof(type), $"Unknown control frame type {type} received")
});
public SynStream(
Options flags,
UInt31 streamId,
UInt31 associatedToStreamId,
PriorityLevel priority,
NameValueHeaderBlock headers)
: base(Type)
{
Flags = flags;
StreamId = streamId;
AssociatedToStreamId = associatedToStreamId;
Priority = priority;
Headers = headers;
}
protected override Task GivenAsync(
CancellationToken cancellationToken)
{
_frame = new SynStream(
SynStream.Options.Unidirectional,
UInt31.From(123),
UInt31.From(524),
SynStream.PriorityLevel.High,
new NameValueHeaderBlock(
("host", new[] { "test", "test2" }),
("user-agent",
new[]
{
"Mozilla/5.0 (Macintosh; Intel Mac OS X 10.9; rv: 50.0) Gecko / 20100101 Firefox / 50.0"
})));
return(Task.CompletedTask);
}
internal static uint SetBit(
this UInt31 value,
int bitIndex,
bool bitValue)
{
if (bitIndex < 0 || bitIndex > 31)
{
throw new ArgumentOutOfRangeException(
nameof(bitIndex),
"Index must be in range [0..31]");
}
if (bitValue)
{
return((uint)(value | (1 << bitIndex)));
}
return((uint)(value & ~(1 << bitIndex)));
}
internal new static async ValueTask <ReadResult <Data> > TryReadAsync(
IFrameReader frameReader,
CancellationToken cancellation = default)
{
// Since bit 31 is the control bit which is 0 for data frames,
// there is no need to blank it out
var streamId = UInt31.From(
await frameReader.ReadUInt32Async(cancellation)
.ConfigureAwait(false));
var flags = await frameReader.ReadByteAsync(cancellation)
.ConfigureAwait(false);
var length = await frameReader.ReadUInt24Async(cancellation)
.ConfigureAwait(false);
var payload = await frameReader.ReadBytesAsync(
(int)length.Value, cancellation)
.ConfigureAwait(false);
return(ReadResult.Ok(new Data(streamId, flags.ToEnum <Options>(), payload)));
}
public static WindowUpdate ConnectionFlowControl(
UInt31 deltaWindowSize)
{
return(new WindowUpdate(ConnectionFlowId, deltaWindowSize));
}
public static Data Last(
UInt31 streamId,
byte[] payload)
{
return(new Data(streamId, Options.Fin, payload));
}
public static Headers Last(
UInt31 streamId,
NameValueHeaderBlock values)
{
return(new Headers(Options.Fin, streamId, values));
}
internal static async ValueTask <UInt31> AsUInt31Async(
this ValueTask <uint> value)
{
return(UInt31.From(await value
.ConfigureAwait(false) & 0x7FFFFFFF));
}
public static GoAway InternalError(
UInt31 lastGoodStreamId)
=> new GoAway(lastGoodStreamId, StatusCode.InternalError);
public static GoAway ProtocolError(
UInt31 lastGoodStreamId)
=> new GoAway(lastGoodStreamId, StatusCode.ProtocolError);
protected override Task GivenAsync(CancellationToken cancellationToken)
{
_frame = RstStream.Cancel(
UInt31.From(123));
return(Task.CompletedTask);
}
public static SynReply Accept(
UInt31 streamId,
NameValueHeaderBlock?headers = null)
{
return(new SynReply(Options.None, streamId, headers));
}
public static GoAway Ok(
UInt31 lastGoodStreamId)
=> new GoAway(lastGoodStreamId, StatusCode.Ok);
