puma-plus-core 0.1.0

data/go/vendor/github.com/quic-go/quic-go/internal/wire/path_response_frame.go

@@ -0,0 +1,32 @@
+package wire
+
+import (
+	"io"
+
+	"github.com/quic-go/quic-go/internal/protocol"
+)
+
+// A PathResponseFrame is a PATH_RESPONSE frame
+type PathResponseFrame struct {
+	Data [8]byte
+}
+
+func parsePathResponseFrame(b []byte, _ protocol.Version) (*PathResponseFrame, int, error) {
+	f := &PathResponseFrame{}
+	if len(b) < 8 {
+		return nil, 0, io.EOF
+	}
+	copy(f.Data[:], b)
+	return f, 8, nil
+}
+
+func (f *PathResponseFrame) Append(b []byte, _ protocol.Version) ([]byte, error) {
+	b = append(b, byte(FrameTypePathResponse))
+	b = append(b, f.Data[:]...)
+	return b, nil
+}
+
+// Length of a written frame
+func (f *PathResponseFrame) Length(_ protocol.Version) protocol.ByteCount {
+	return 1 + 8
+}

data/go/vendor/github.com/quic-go/quic-go/internal/wire/ping_frame.go

@@ -0,0 +1,17 @@
+package wire
+
+import (
+	"github.com/quic-go/quic-go/internal/protocol"
+)
+
+// A PingFrame is a PING frame
+type PingFrame struct{}
+
+func (f *PingFrame) Append(b []byte, _ protocol.Version) ([]byte, error) {
+	return append(b, byte(FrameTypePing)), nil
+}
+
+// Length of a written frame
+func (f *PingFrame) Length(_ protocol.Version) protocol.ByteCount {
+	return 1
+}

data/go/vendor/github.com/quic-go/quic-go/internal/wire/pool.go

@@ -0,0 +1,33 @@
+package wire
+
+import (
+	"sync"
+
+	"github.com/quic-go/quic-go/internal/protocol"
+)
+
+var pool sync.Pool
+
+func init() {
+	pool.New = func() any {
+		return &StreamFrame{
+			Data:     make([]byte, 0, protocol.MaxPacketBufferSize),
+			fromPool: true,
+		}
+	}
+}
+
+func GetStreamFrame() *StreamFrame {
+	f := pool.Get().(*StreamFrame)
+	return f
+}
+
+func putStreamFrame(f *StreamFrame) {
+	if !f.fromPool {
+		return
+	}
+	if protocol.ByteCount(cap(f.Data)) != protocol.MaxPacketBufferSize {
+		panic("wire.PutStreamFrame called with packet of wrong size!")
+	}
+	pool.Put(f)
+}

data/go/vendor/github.com/quic-go/quic-go/internal/wire/reset_stream_frame.go

@@ -0,0 +1,79 @@
+package wire
+
+import (
+	"fmt"
+
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/internal/qerr"
+	"github.com/quic-go/quic-go/quicvarint"
+)
+
+// A ResetStreamFrame is a RESET_STREAM or RESET_STREAM_AT frame in QUIC
+type ResetStreamFrame struct {
+	StreamID     protocol.StreamID
+	ErrorCode    qerr.StreamErrorCode
+	FinalSize    protocol.ByteCount
+	ReliableSize protocol.ByteCount
+}
+
+func parseResetStreamFrame(b []byte, isResetStreamAt bool, _ protocol.Version) (*ResetStreamFrame, int, error) {
+	startLen := len(b)
+	streamID, l, err := quicvarint.Parse(b)
+	if err != nil {
+		return nil, 0, replaceUnexpectedEOF(err)
+	}
+	b = b[l:]
+	errorCode, l, err := quicvarint.Parse(b)
+	if err != nil {
+		return nil, 0, replaceUnexpectedEOF(err)
+	}
+	b = b[l:]
+	finalSize, l, err := quicvarint.Parse(b)
+	if err != nil {
+		return nil, 0, replaceUnexpectedEOF(err)
+	}
+	b = b[l:]
+
+	var reliableSize uint64
+	if isResetStreamAt {
+		reliableSize, l, err = quicvarint.Parse(b)
+		if err != nil {
+			return nil, 0, replaceUnexpectedEOF(err)
+		}
+		b = b[l:]
+	}
+	if reliableSize > finalSize {
+		return nil, 0, fmt.Errorf("RESET_STREAM_AT: reliable size can't be larger than final size (%d vs %d)", reliableSize, finalSize)
+	}
+
+	return &ResetStreamFrame{
+		StreamID:     protocol.StreamID(streamID),
+		ErrorCode:    qerr.StreamErrorCode(errorCode),
+		FinalSize:    protocol.ByteCount(finalSize),
+		ReliableSize: protocol.ByteCount(reliableSize),
+	}, startLen - len(b), nil
+}
+
+func (f *ResetStreamFrame) Append(b []byte, _ protocol.Version) ([]byte, error) {
+	if f.ReliableSize == 0 {
+		b = quicvarint.Append(b, uint64(FrameTypeResetStream))
+	} else {
+		b = quicvarint.Append(b, uint64(FrameTypeResetStreamAt))
+	}
+	b = quicvarint.Append(b, uint64(f.StreamID))
+	b = quicvarint.Append(b, uint64(f.ErrorCode))
+	b = quicvarint.Append(b, uint64(f.FinalSize))
+	if f.ReliableSize > 0 {
+		b = quicvarint.Append(b, uint64(f.ReliableSize))
+	}
+	return b, nil
+}
+
+// Length of a written frame
+func (f *ResetStreamFrame) Length(protocol.Version) protocol.ByteCount {
+	size := 1 // the frame type for both RESET_STREAM and RESET_STREAM_AT fits into 1 byte
+	if f.ReliableSize > 0 {
+		size += quicvarint.Len(uint64(f.ReliableSize))
+	}
+	return protocol.ByteCount(size + quicvarint.Len(uint64(f.StreamID)) + quicvarint.Len(uint64(f.ErrorCode)) + quicvarint.Len(uint64(f.FinalSize)))
+}

data/go/vendor/github.com/quic-go/quic-go/internal/wire/retire_connection_id_frame.go

@@ -0,0 +1,30 @@
+package wire
+
+import (
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/quicvarint"
+)
+
+// A RetireConnectionIDFrame is a RETIRE_CONNECTION_ID frame
+type RetireConnectionIDFrame struct {
+	SequenceNumber uint64
+}
+
+func parseRetireConnectionIDFrame(b []byte, _ protocol.Version) (*RetireConnectionIDFrame, int, error) {
+	seq, l, err := quicvarint.Parse(b)
+	if err != nil {
+		return nil, 0, replaceUnexpectedEOF(err)
+	}
+	return &RetireConnectionIDFrame{SequenceNumber: seq}, l, nil
+}
+
+func (f *RetireConnectionIDFrame) Append(b []byte, _ protocol.Version) ([]byte, error) {
+	b = append(b, byte(FrameTypeRetireConnectionID))
+	b = quicvarint.Append(b, f.SequenceNumber)
+	return b, nil
+}
+
+// Length of a written frame
+func (f *RetireConnectionIDFrame) Length(protocol.Version) protocol.ByteCount {
+	return 1 + protocol.ByteCount(quicvarint.Len(f.SequenceNumber))
+}

data/go/vendor/github.com/quic-go/quic-go/internal/wire/short_header.go

@@ -0,0 +1,62 @@
+package wire
+
+import (
+	"errors"
+	"io"
+
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/internal/utils"
+)
+
+// ParseShortHeader parses a short header packet.
+// It must be called after header protection was removed.
+// Otherwise, the check for the reserved bits will (most likely) fail.
+func ParseShortHeader(data []byte, connIDLen int) (length int, _ protocol.PacketNumber, _ protocol.PacketNumberLen, _ protocol.KeyPhaseBit, _ error) {
+	if len(data) == 0 {
+		return 0, 0, 0, 0, io.EOF
+	}
+	if data[0]&0x80 > 0 {
+		return 0, 0, 0, 0, errors.New("not a short header packet")
+	}
+	if data[0]&0x40 == 0 {
+		return 0, 0, 0, 0, errors.New("not a QUIC packet")
+	}
+	pnLen := protocol.PacketNumberLen(data[0]&0b11) + 1
+	if len(data) < 1+int(pnLen)+connIDLen {
+		return 0, 0, 0, 0, io.EOF
+	}
+
+	pos := 1 + connIDLen
+	pn, err := readPacketNumber(data[pos:], pnLen)
+	if err != nil {
+		return 0, 0, 0, 0, err
+	}
+	kp := protocol.KeyPhaseZero
+	if data[0]&0b100 > 0 {
+		kp = protocol.KeyPhaseOne
+	}
+
+	if data[0]&0x18 != 0 {
+		err = ErrInvalidReservedBits
+	}
+	return 1 + connIDLen + int(pnLen), pn, pnLen, kp, err
+}
+
+// AppendShortHeader writes a short header.
+func AppendShortHeader(b []byte, connID protocol.ConnectionID, pn protocol.PacketNumber, pnLen protocol.PacketNumberLen, kp protocol.KeyPhaseBit) ([]byte, error) {
+	typeByte := 0x40 | uint8(pnLen-1)
+	if kp == protocol.KeyPhaseOne {
+		typeByte |= byte(1 << 2)
+	}
+	b = append(b, typeByte)
+	b = append(b, connID.Bytes()...)
+	return appendPacketNumber(b, pn, pnLen)
+}
+
+func ShortHeaderLen(dest protocol.ConnectionID, pnLen protocol.PacketNumberLen) protocol.ByteCount {
+	return 1 + protocol.ByteCount(dest.Len()) + protocol.ByteCount(pnLen)
+}
+
+func LogShortHeader(logger utils.Logger, dest protocol.ConnectionID, pn protocol.PacketNumber, pnLen protocol.PacketNumberLen, kp protocol.KeyPhaseBit) {
+	logger.Debugf("\tShort Header{DestConnectionID: %s, PacketNumber: %d, PacketNumberLen: %d, KeyPhase: %s}", dest, pn, pnLen, kp)
+}

data/go/vendor/github.com/quic-go/quic-go/internal/wire/stop_sending_frame.go

@@ -0,0 +1,45 @@
+package wire
+
+import (
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/internal/qerr"
+	"github.com/quic-go/quic-go/quicvarint"
+)
+
+// A StopSendingFrame is a STOP_SENDING frame
+type StopSendingFrame struct {
+	StreamID  protocol.StreamID
+	ErrorCode qerr.StreamErrorCode
+}
+
+// parseStopSendingFrame parses a STOP_SENDING frame
+func parseStopSendingFrame(b []byte, _ protocol.Version) (*StopSendingFrame, int, error) {
+	startLen := len(b)
+	streamID, l, err := quicvarint.Parse(b)
+	if err != nil {
+		return nil, 0, replaceUnexpectedEOF(err)
+	}
+	b = b[l:]
+	errorCode, l, err := quicvarint.Parse(b)
+	if err != nil {
+		return nil, 0, replaceUnexpectedEOF(err)
+	}
+	b = b[l:]
+
+	return &StopSendingFrame{
+		StreamID:  protocol.StreamID(streamID),
+		ErrorCode: qerr.StreamErrorCode(errorCode),
+	}, startLen - len(b), nil
+}
+
+// Length of a written frame
+func (f *StopSendingFrame) Length(_ protocol.Version) protocol.ByteCount {
+	return 1 + protocol.ByteCount(quicvarint.Len(uint64(f.StreamID))+quicvarint.Len(uint64(f.ErrorCode)))
+}
+
+func (f *StopSendingFrame) Append(b []byte, _ protocol.Version) ([]byte, error) {
+	b = append(b, byte(FrameTypeStopSending))
+	b = quicvarint.Append(b, uint64(f.StreamID))
+	b = quicvarint.Append(b, uint64(f.ErrorCode))
+	return b, nil
+}

data/go/vendor/github.com/quic-go/quic-go/internal/wire/stream_data_blocked_frame.go

@@ -0,0 +1,42 @@
+package wire
+
+import (
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/quicvarint"
+)
+
+// A StreamDataBlockedFrame is a STREAM_DATA_BLOCKED frame
+type StreamDataBlockedFrame struct {
+	StreamID          protocol.StreamID
+	MaximumStreamData protocol.ByteCount
+}
+
+func parseStreamDataBlockedFrame(b []byte, _ protocol.Version) (*StreamDataBlockedFrame, int, error) {
+	startLen := len(b)
+	sid, l, err := quicvarint.Parse(b)
+	if err != nil {
+		return nil, 0, replaceUnexpectedEOF(err)
+	}
+	b = b[l:]
+	offset, l, err := quicvarint.Parse(b)
+	if err != nil {
+		return nil, 0, replaceUnexpectedEOF(err)
+	}
+
+	return &StreamDataBlockedFrame{
+		StreamID:          protocol.StreamID(sid),
+		MaximumStreamData: protocol.ByteCount(offset),
+	}, startLen - len(b) + l, nil
+}
+
+func (f *StreamDataBlockedFrame) Append(b []byte, _ protocol.Version) ([]byte, error) {
+	b = append(b, 0x15)
+	b = quicvarint.Append(b, uint64(f.StreamID))
+	b = quicvarint.Append(b, uint64(f.MaximumStreamData))
+	return b, nil
+}
+
+// Length of a written frame
+func (f *StreamDataBlockedFrame) Length(protocol.Version) protocol.ByteCount {
+	return 1 + protocol.ByteCount(quicvarint.Len(uint64(f.StreamID))+quicvarint.Len(uint64(f.MaximumStreamData)))
+}

data/go/vendor/github.com/quic-go/quic-go/internal/wire/stream_frame.go

@@ -0,0 +1,191 @@
+package wire
+
+import (
+	"errors"
+	"io"
+
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/quicvarint"
+)
+
+// A StreamFrame of QUIC
+type StreamFrame struct {
+	StreamID       protocol.StreamID
+	Offset         protocol.ByteCount
+	Data           []byte
+	Fin            bool
+	DataLenPresent bool
+
+	fromPool bool
+}
+
+func ParseStreamFrame(b []byte, typ FrameType, _ protocol.Version) (*StreamFrame, int, error) {
+	startLen := len(b)
+	hasOffset := typ&0b100 > 0
+	fin := typ&0b1 > 0
+	hasDataLen := typ&0b10 > 0
+
+	streamID, l, err := quicvarint.Parse(b)
+	if err != nil {
+		return nil, 0, replaceUnexpectedEOF(err)
+	}
+	b = b[l:]
+	var offset uint64
+	if hasOffset {
+		offset, l, err = quicvarint.Parse(b)
+		if err != nil {
+			return nil, 0, replaceUnexpectedEOF(err)
+		}
+		b = b[l:]
+	}
+
+	var dataLen uint64
+	if hasDataLen {
+		var err error
+		var l int
+		dataLen, l, err = quicvarint.Parse(b)
+		if err != nil {
+			return nil, 0, replaceUnexpectedEOF(err)
+		}
+		b = b[l:]
+		if dataLen > uint64(len(b)) {
+			return nil, 0, io.EOF
+		}
+	} else {
+		// The rest of the packet is data
+		dataLen = uint64(len(b))
+	}
+
+	var frame *StreamFrame
+	if dataLen < protocol.MinStreamFrameBufferSize {
+		frame = &StreamFrame{}
+		if dataLen > 0 {
+			frame.Data = make([]byte, dataLen)
+		}
+	} else {
+		frame = GetStreamFrame()
+		// The STREAM frame can't be larger than the StreamFrame we obtained from the buffer,
+		// since those StreamFrames have a buffer length of the maximum packet size.
+		if dataLen > uint64(cap(frame.Data)) {
+			return nil, 0, io.EOF
+		}
+		frame.Data = frame.Data[:dataLen]
+	}
+
+	frame.StreamID = protocol.StreamID(streamID)
+	frame.Offset = protocol.ByteCount(offset)
+	frame.Fin = fin
+	frame.DataLenPresent = hasDataLen
+
+	if dataLen > 0 {
+		copy(frame.Data, b)
+	}
+	if frame.Offset+frame.DataLen() > protocol.MaxByteCount {
+		return nil, 0, errors.New("stream data overflows maximum offset")
+	}
+	return frame, startLen - len(b) + int(dataLen), nil
+}
+
+func (f *StreamFrame) Append(b []byte, _ protocol.Version) ([]byte, error) {
+	if len(f.Data) == 0 && !f.Fin {
+		return nil, errors.New("StreamFrame: attempting to write empty frame without FIN")
+	}
+
+	typ := byte(0x8)
+	if f.Fin {
+		typ ^= 0b1
+	}
+	hasOffset := f.Offset != 0
+	if f.DataLenPresent {
+		typ ^= 0b10
+	}
+	if hasOffset {
+		typ ^= 0b100
+	}
+	b = append(b, typ)
+	b = quicvarint.Append(b, uint64(f.StreamID))
+	if hasOffset {
+		b = quicvarint.Append(b, uint64(f.Offset))
+	}
+	if f.DataLenPresent {
+		b = quicvarint.Append(b, uint64(f.DataLen()))
+	}
+	b = append(b, f.Data...)
+	return b, nil
+}
+
+// Length returns the total length of the STREAM frame
+func (f *StreamFrame) Length(protocol.Version) protocol.ByteCount {
+	length := 1 + quicvarint.Len(uint64(f.StreamID))
+	if f.Offset != 0 {
+		length += quicvarint.Len(uint64(f.Offset))
+	}
+	if f.DataLenPresent {
+		length += quicvarint.Len(uint64(f.DataLen()))
+	}
+	return protocol.ByteCount(length) + f.DataLen()
+}
+
+// DataLen gives the length of data in bytes
+func (f *StreamFrame) DataLen() protocol.ByteCount {
+	return protocol.ByteCount(len(f.Data))
+}
+
+// MaxDataLen returns the maximum data length
+// If 0 is returned, writing will fail (a STREAM frame must contain at least 1 byte of data).
+func (f *StreamFrame) MaxDataLen(maxSize protocol.ByteCount, _ protocol.Version) protocol.ByteCount {
+	headerLen := 1 + protocol.ByteCount(quicvarint.Len(uint64(f.StreamID)))
+	if f.Offset != 0 {
+		headerLen += protocol.ByteCount(quicvarint.Len(uint64(f.Offset)))
+	}
+	if f.DataLenPresent {
+		// Pretend that the data size will be 1 byte.
+		// If it turns out that varint encoding the length will consume 2 bytes, we need to adjust the data length afterward
+		headerLen++
+	}
+	if headerLen > maxSize {
+		return 0
+	}
+	maxDataLen := maxSize - headerLen
+	if f.DataLenPresent && quicvarint.Len(uint64(maxDataLen)) != 1 {
+		maxDataLen--
+	}
+	return maxDataLen
+}
+
+// MaybeSplitOffFrame splits a frame such that it is not bigger than n bytes.
+// It returns if the frame was actually split.
+// The frame might not be split if:
+// * the size is large enough to fit the whole frame
+// * the size is too small to fit even a 1-byte frame. In that case, the frame returned is nil.
+func (f *StreamFrame) MaybeSplitOffFrame(maxSize protocol.ByteCount, version protocol.Version) (*StreamFrame, bool /* was splitting required */) {
+	if maxSize >= f.Length(version) {
+		return nil, false
+	}
+
+	n := f.MaxDataLen(maxSize, version)
+	if n == 0 {
+		return nil, true
+	}
+
+	new := GetStreamFrame()
+	new.StreamID = f.StreamID
+	new.Offset = f.Offset
+	new.Fin = false
+	new.DataLenPresent = f.DataLenPresent
+
+	// swap the data slices
+	new.Data, f.Data = f.Data, new.Data
+	new.fromPool, f.fromPool = f.fromPool, new.fromPool
+
+	f.Data = f.Data[:protocol.ByteCount(len(new.Data))-n]
+	copy(f.Data, new.Data[n:])
+	new.Data = new.Data[:n]
+	f.Offset += n
+
+	return new, true
+}
+
+func (f *StreamFrame) PutBack() {
+	putStreamFrame(f)
+}

data/go/vendor/github.com/quic-go/quic-go/internal/wire/streams_blocked_frame.go

@@ -0,0 +1,50 @@
+package wire
+
+import (
+	"fmt"
+
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/quicvarint"
+)
+
+// A StreamsBlockedFrame is a STREAMS_BLOCKED frame
+type StreamsBlockedFrame struct {
+	Type        protocol.StreamType
+	StreamLimit protocol.StreamNum
+}
+
+func parseStreamsBlockedFrame(b []byte, typ FrameType, _ protocol.Version) (*StreamsBlockedFrame, int, error) {
+	f := &StreamsBlockedFrame{}
+	//nolint:exhaustive // This will only be called with a BidiStreamBlockedFrameType or a UniStreamBlockedFrameType.
+	switch typ {
+	case FrameTypeBidiStreamBlocked:
+		f.Type = protocol.StreamTypeBidi
+	case FrameTypeUniStreamBlocked:
+		f.Type = protocol.StreamTypeUni
+	}
+	streamLimit, l, err := quicvarint.Parse(b)
+	if err != nil {
+		return nil, 0, replaceUnexpectedEOF(err)
+	}
+	f.StreamLimit = protocol.StreamNum(streamLimit)
+	if f.StreamLimit > protocol.MaxStreamCount {
+		return nil, 0, fmt.Errorf("%d exceeds the maximum stream count", f.StreamLimit)
+	}
+	return f, l, nil
+}
+
+func (f *StreamsBlockedFrame) Append(b []byte, _ protocol.Version) ([]byte, error) {
+	switch f.Type {
+	case protocol.StreamTypeBidi:
+		b = append(b, byte(FrameTypeBidiStreamBlocked))
+	case protocol.StreamTypeUni:
+		b = append(b, byte(FrameTypeUniStreamBlocked))
+	}
+	b = quicvarint.Append(b, uint64(f.StreamLimit))
+	return b, nil
+}
+
+// Length of a written frame
+func (f *StreamsBlockedFrame) Length(_ protocol.Version) protocol.ByteCount {
+	return 1 + protocol.ByteCount(quicvarint.Len(uint64(f.StreamLimit)))
+}