public void LogUnknownFrame(Direction direction, IChannelHandlerContext ctx, Http2FrameTypes frameType, int streamId,
Http2Flags flags, IByteBuffer data)
{
if (IsEnabled())
{
_logger.Log(_level, "{} {} UNKNOWN: frameType={} streamId={} flags={} length={} bytes={}",
ctx.Channel, direction, (byte)frameType & 0xFF, streamId, flags.Value, data.ReadableBytes, ToString(data));
}
}
public virtual Task WriteFrameAsync(IChannelHandlerContext ctx, Http2FrameTypes frameType,
int streamId, Http2Flags flags, IByteBuffer payload, IPromise promise)
{
SimplePromiseAggregator promiseAggregator = new SimplePromiseAggregator(promise);
try
{
if (streamId < 0)
{
ThrowHelper.ThrowArgumentException_PositiveOrZero(ExceptionArgument.StreamID);
}
IByteBuffer buf = ctx.Allocator.Buffer(Http2CodecUtil.FrameHeaderLength);
// Assume nothing below will throw until buf is written. That way we don't have to take care of ownership
// in the catch block.
Http2CodecUtil.WriteFrameHeaderInternal(buf, payload.ReadableBytes, frameType, flags, streamId);
_ = ctx.WriteAsync(buf, promiseAggregator.NewPromise());
}
catch (Exception t)
{
try
{
_ = payload.Release();
}
finally
{
promiseAggregator.SetException(t);
_ = promiseAggregator.DoneAllocatingPromises();
}
return(promiseAggregator.Task);
}
try
{
_ = ctx.WriteAsync(payload, promiseAggregator.NewPromise());
}
catch (Exception t)
{
promiseAggregator.SetException(t);
}
_ = promiseAggregator.DoneAllocatingPromises();
return(promiseAggregator.Task);
}
public virtual Task WriteFrameAsync(IChannelHandlerContext ctx, Http2FrameTypes frameType, int streamId, Http2Flags flags, IByteBuffer payload, IPromise promise)
{
return(_innerWriter.WriteFrameAsync(ctx, frameType, streamId, flags, payload, promise));
}
public Task WriteFrameAsync(IChannelHandlerContext ctx, Http2FrameTypes frameType, int streamId, Http2Flags flags, IByteBuffer payload, IPromise promise)
{
_logger.LogUnknownFrame(Direction.Outbound, ctx, frameType, streamId, flags, payload);
return(_writer.WriteFrameAsync(ctx, frameType, streamId, flags, payload, promise));
}
public virtual void OnUnknownFrame(IChannelHandlerContext ctx, Http2FrameTypes frameType, int streamId, Http2Flags flags, IByteBuffer payload)
{
_listener.OnUnknownFrame(ctx, frameType, streamId, flags, payload);
}
public void OnUnknownFrame(IChannelHandlerContext ctx, Http2FrameTypes frameType, int streamId, Http2Flags flags, IByteBuffer payload)
{
}
public void OnUnknownFrame(IChannelHandlerContext ctx, Http2FrameTypes frameType, int streamId, Http2Flags flags, IByteBuffer payload)
{
_logger.LogUnknownFrame(Direction.Inbound, ctx, frameType, streamId, flags, payload);
_listener.OnUnknownFrame(ctx, frameType, streamId, flags, payload);
}
public void OnUnknownFrame(IChannelHandlerContext ctx, Http2FrameTypes frameType, int streamId, Http2Flags flags, IByteBuffer payload)
{
this.listener.OnUnknownFrame(ctx, frameType, streamId, flags, payload);
this.messageLatch.SafeSignal();
}
public void WriteInboundFrame(Http2FrameTypes frameType, int streamId, Http2Flags flags, IByteBuffer payload)
{
_writer.WriteFrameAsync(_ctx, frameType, streamId, flags, payload, _ctx.NewPromise()).GetAwaiter().GetResult();
}
internal static void WriteFrameHeaderInternal(IByteBuffer output, int payloadLength, Http2FrameTypes type,
Http2Flags flags, int streamId)
{
_ = output.WriteMedium(payloadLength);
_ = output.WriteByte((int)type);
_ = output.WriteByte(flags.Value);
_ = output.WriteInt(streamId);
}
void ProcessHeaderState(IByteBuffer input)
{
if (input.ReadableBytes < Http2CodecUtil.FrameHeaderLength)
{
// Wait until the entire frame header has been read.
return;
}
// Read the header and prepare the unmarshaller to read the frame.
_payloadLength = input.ReadUnsignedMedium();
if (_payloadLength > _maxFrameSize)
{
ThrowHelper.ThrowConnectionError_FrameLengthExceedsMaximum(_payloadLength, _maxFrameSize);
}
_frameType = (Http2FrameTypes)input.ReadByte();
_flags = new Http2Flags(input.ReadByte());
_streamId = Http2CodecUtil.ReadUnsignedInt(input);
// We have consumed the data, next time we read we will be expecting to read the frame payload.
_readingHeaders = false;
switch (_frameType)
{
case Http2FrameTypes.Data:
VerifyDataFrame();
break;
case Http2FrameTypes.Headers:
VerifyHeadersFrame();
break;
case Http2FrameTypes.Priority:
VerifyPriorityFrame();
break;
case Http2FrameTypes.RstStream:
VerifyRstStreamFrame();
break;
case Http2FrameTypes.Settings:
VerifySettingsFrame();
break;
case Http2FrameTypes.PushPromise:
VerifyPushPromiseFrame();
break;
case Http2FrameTypes.Ping:
VerifyPingFrame();
break;
case Http2FrameTypes.GoAway:
VerifyGoAwayFrame();
break;
case Http2FrameTypes.WindowUpdate:
VerifyWindowUpdateFrame();
break;
case Http2FrameTypes.Continuation:
VerifyContinuationFrame();
break;
default:
// Unknown frame type, could be an extension.
VerifyUnknownFrame();
break;
}
}
/// <summary>
/// Writes an HTTP/2 frame header to the output buffer.
/// </summary>
/// <param name="output"></param>
/// <param name="payloadLength"></param>
/// <param name="type"></param>
/// <param name="flags"></param>
/// <param name="streamId"></param>
public static void WriteFrameHeader(IByteBuffer output, int payloadLength, Http2FrameTypes type,
Http2Flags flags, int streamId)
{
_ = output.EnsureWritable(FrameHeaderLength + payloadLength);
WriteFrameHeaderInternal(output, payloadLength, type, flags, streamId);
}
public DefaultHttp2UnknownFrame(Http2FrameTypes frameType, Http2Flags flags, IByteBuffer data)
: base(data)
{
_frameType = frameType;
_flags = flags;
}
public DefaultHttp2UnknownFrame(Http2FrameTypes frameType, Http2Flags flags)
: this(frameType, flags, Unpooled.Empty)
{
}
public static void IgnoringFrameForStreamRst(this IInternalLogger logger, IChannelHandlerContext ctx, Http2FrameTypes frameName, bool isResetSent, int lastStreamKnownByPeer)
{
logger.Info("{} ignoring {} frame for stream {}", ctx.Channel, frameName,
isResetSent ? "RST_STREAM sent." :
("Stream created after GOAWAY sent. Last known stream by peer " +
lastStreamKnownByPeer));
}
public static void IgnoringFrameForStream(this IInternalLogger logger, IChannelHandlerContext ctx, Http2FrameTypes frameName, int streamId)
{
logger.Info("{} ignoring {} frame for stream {}. Stream sent after GOAWAY sent",
ctx.Channel, frameName, streamId);
}