public static bool TryParse(ReadOnlyMemory <byte> bytes, out NewConnectionIdFrame result, out ReadOnlyMemory <byte> remainings)
        {
            result     = new NewConnectionIdFrame();
            remainings = ReadOnlyMemory <byte> .Empty;

            var type = FrameType.Parse(bytes, out var afterTypeBytes);

            if (!type.IsNewConnectionId())
            {
                return(false);
            }

            var sequenceNumber                   = VariableLengthEncoding.Decode32(afterTypeBytes.Span, out var decodedLength);
            var afterSequenceNumberBytes         = afterTypeBytes.Slice(decodedLength);
            var sequenceNumberToRetire           = VariableLengthEncoding.Decode32(afterSequenceNumberBytes.Span, out decodedLength);
            var afterSequenceNumberToRetiryBytes = afterSequenceNumberBytes.Slice(decodedLength);

            if (sequenceNumberToRetire > sequenceNumber)
            {
                throw new EncodingException();
            }

            var connectionId = PacketConnectionId.Parse(afterSequenceNumberToRetiryBytes, out var afterConnectionIdBytes);
            var resetToken   = ParseResetToken(afterConnectionIdBytes, out var afterTokenBytes);

            result     = new NewConnectionIdFrame(sequenceNumber, sequenceNumberToRetire, connectionId, resetToken);
            remainings = afterTokenBytes;

            return(true);
        }
        public static bool TryParse(ReadOnlyMemory <byte> bytes, out ConnectionCloseFrame result, out ReadOnlyMemory <byte> remainings)
        {
            result     = new ConnectionCloseFrame();
            remainings = ReadOnlyMemory <byte> .Empty;

            var type = FrameType.Parse(bytes, out var afterTypeBytes);

            if (!type.IsConnectionClose())
            {
                return(false);
            }

            var error           = new Error();
            var afterErrorBytes = afterTypeBytes;

            if (type.HasApplicationError())
            {
                error = Error.ParseApplication(afterTypeBytes, out afterErrorBytes);
            }

            if (type.HasTransportError())
            {
                error = Error.ParseTransport(afterTypeBytes, out afterErrorBytes);
            }

            var afterErrorFrameTypeBytes = afterErrorBytes;
            var errorFrameType           = type.HasTransportError() ? FrameType.Parse(afterErrorBytes, out afterErrorFrameTypeBytes) : new FrameType?();
            var reasonPhrase             = ReasonPhrase.Parse(afterErrorFrameTypeBytes, out var afterReasonPhraseBytes);

            result     = new ConnectionCloseFrame(error, errorFrameType, reasonPhrase);
            remainings = afterReasonPhraseBytes;

            return(true);
        }
        public static bool TryParse(ReadOnlyMemory <byte> bytes, out DataBlockedFrame result, out ReadOnlyMemory <byte> remainings)
        {
            result     = new DataBlockedFrame();
            remainings = ReadOnlyMemory <byte> .Empty;

            var type = FrameType.Parse(bytes, out var afterTypeBytes);

            if (!type.IsDataBlocked())
            {
                return(false);
            }

            var dataLimit = VariableLengthEncoding.Decode32(afterTypeBytes.Span, out var decodedLength);

            result     = new DataBlockedFrame(dataLimit);
            remainings = afterTypeBytes.Slice(decodedLength);

            return(true);
        }
        public static bool TryParse(ReadOnlyMemory <byte> bytes, out StreamsBlockedFrame result, out ReadOnlyMemory <byte> remainings)
        {
            result     = new StreamsBlockedFrame();
            remainings = ReadOnlyMemory <byte> .Empty;

            var type = FrameType.Parse(bytes, out var afterTypeBytes);

            if (!type.IsStreamsBlocked())
            {
                return(false);
            }

            var streamLimit = VariableLengthEncoding.Decode32(afterTypeBytes.Span, out var decodedLength);

            result     = new StreamsBlockedFrame(streamLimit, type.ForBidirectional(), type.ForUnidirectional());
            remainings = afterTypeBytes.Slice(decodedLength);

            return(true);
        }
Exemplo n.º 5
0
        public static bool TryParse(ReadOnlyMemory <byte> bytes, out PathFrame result, out ReadOnlyMemory <byte> remainings)
        {
            result     = new PathFrame();
            remainings = ReadOnlyMemory <byte> .Empty;

            var type = FrameType.Parse(bytes, out var afterTypeBytes);

            if (!type.IsPath())
            {
                return(false);
            }

            var data = ParseData(afterTypeBytes, out var afterDataBytes);

            result     = new PathFrame(type.IsChallenge(), type.IsResponse(), data);
            remainings = afterDataBytes;

            return(true);
        }
Exemplo n.º 6
0
        public static bool TryParse(ReadOnlyMemory <byte> bytes, out NewTokenFrame result, out ReadOnlyMemory <byte> remainings)
        {
            result     = new NewTokenFrame();
            remainings = ReadOnlyMemory <byte> .Empty;

            var type = FrameType.Parse(bytes, out var afterTypeRemainings);

            if (!type.IsNewToken())
            {
                return(false);
            }

            var token = PacketToken.Parse(afterTypeRemainings, out var afterTokenBytes);

            result     = new NewTokenFrame(token);
            remainings = afterTokenBytes;

            return(true);
        }
        public static bool TryParse(ReadOnlyMemory <byte> bytes, out MaxStreamDataFrame result, out ReadOnlyMemory <byte> remainings)
        {
            result     = new MaxStreamDataFrame();
            remainings = ReadOnlyMemory <byte> .Empty;

            var type = FrameType.Parse(bytes, out var afterTypeBytes);

            if (!type.IsMaxStreamData())
            {
                return(false);
            }

            var streamId      = StreamId.Parse(afterTypeBytes, out var afterStreamIdBytes);
            var maxDataLength = VariableLengthEncoding.Decode32(afterStreamIdBytes.Span, out var decodedLength);

            result     = new MaxStreamDataFrame(streamId, maxDataLength);
            remainings = afterStreamIdBytes.Slice(decodedLength);

            return(true);
        }
        public static bool TryParse(ReadOnlyMemory <byte> bytes, out RetireConnectionIdFrame result, out ReadOnlyMemory <byte> remainings)
        {
            result     = new RetireConnectionIdFrame();
            remainings = ReadOnlyMemory <byte> .Empty;

            var type = FrameType.Parse(bytes, out var afterTypeBytes);

            if (!type.IsRetireConnectionId())
            {
                return(false);
            }

            var sequenceNumber           = VariableLengthEncoding.Decode32(afterTypeBytes.Span, out var decodedLength);
            var afterSequenceNumberBytes = afterTypeBytes.Slice(decodedLength);

            result     = new RetireConnectionIdFrame(sequenceNumber);
            remainings = afterSequenceNumberBytes;

            return(true);
        }
Exemplo n.º 9
0
        public static bool TryParse(ReadOnlyMemory <byte> bytes, out StopSendingFrame result, out ReadOnlyMemory <byte> remainings)
        {
            result     = new StopSendingFrame();
            remainings = ReadOnlyMemory <byte> .Empty;

            var type = FrameType.Parse(bytes, out var afterTypeRemainings);

            if (!type.IsStopSending())
            {
                return(false);
            }

            var streamId         = StreamId.Parse(afterTypeRemainings, out var afterStreamIdBytes);
            var applicationError = Error.ParseApplication(afterStreamIdBytes, out var afterApplicationErrorBytes);

            result     = new StopSendingFrame(streamId, applicationError);
            remainings = afterApplicationErrorBytes;

            return(true);
        }
Exemplo n.º 10
0
        public static bool TryParse(ReadOnlyMemory <byte> bytes, out ResetStreamFrame result, out ReadOnlyMemory <byte> remainings)
        {
            result     = new ResetStreamFrame();
            remainings = ReadOnlyMemory <byte> .Empty;

            var type = FrameType.Parse(bytes, out var afterTypeRemainings);

            if (!type.IsResetStream())
            {
                return(false);
            }

            var streamId  = StreamId.Parse(afterTypeRemainings, out var afterStreamIdBytes);
            var error     = Error.ParseApplication(afterStreamIdBytes, out var afterApplicationErrorBytes);
            var finalSize = VariableLengthEncoding.Decode32(afterApplicationErrorBytes.Span, out var decodedLength);

            result     = new ResetStreamFrame(streamId, error, finalSize);
            remainings = afterApplicationErrorBytes.Slice(decodedLength);

            return(true);
        }
Exemplo n.º 11
0
        public static bool TryParse(ReadOnlyMemory <byte> bytes, out StreamFrame result, out ReadOnlyMemory <byte> remainings)
        {
            result     = new StreamFrame();
            remainings = ReadOnlyMemory <byte> .Empty;

            var type = FrameType.Parse(bytes, out var afterTypeBytes);

            if (!type.IsStream())
            {
                return(false);
            }

            var streamId = StreamId.Parse(afterTypeBytes, out var afterStreamIdBytes);
            var offset   = ParseOffset(afterStreamIdBytes, type, out var afterOffsetBytes);
            var data     = ParseData(afterOffsetBytes, type, out var afterDataBytes);
            var isFinal  = type.HasFinal();

            result     = new StreamFrame(streamId, offset, isFinal, data);
            remainings = afterDataBytes;

            return(true);
        }
 public static bool TryParse(ReadOnlyMemory <byte> bytes, out ReadOnlyMemory <byte> remainings)
 {
     return(FrameType
            .Parse(bytes, out remainings)
            .IsHandshakeDone());
 }