puma-plus-core 0.1.0

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

@@ -0,0 +1,298 @@
+package wire
+
+import (
+	"errors"
+	"math"
+	"sort"
+	"time"
+
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/quicvarint"
+)
+
+var errInvalidAckRanges = errors.New("AckFrame: ACK frame contains invalid ACK ranges")
+
+// An AckFrame is an ACK frame
+type AckFrame struct {
+	AckRanges []AckRange // has to be ordered. The highest ACK range goes first, the lowest ACK range goes last
+	DelayTime time.Duration
+
+	ECT0, ECT1, ECNCE uint64
+}
+
+// parseAckFrame reads an ACK frame
+func parseAckFrame(frame *AckFrame, b []byte, typ FrameType, ackDelayExponent uint8, _ protocol.Version) (int, error) {
+	startLen := len(b)
+	ecn := typ == FrameTypeAckECN
+
+	la, l, err := quicvarint.Parse(b)
+	if err != nil {
+		return 0, replaceUnexpectedEOF(err)
+	}
+	b = b[l:]
+	largestAcked := protocol.PacketNumber(la)
+	delay, l, err := quicvarint.Parse(b)
+	if err != nil {
+		return 0, replaceUnexpectedEOF(err)
+	}
+	b = b[l:]
+
+	delayTime := time.Duration(delay*1<<ackDelayExponent) * time.Microsecond
+	if delayTime < 0 {
+		// If the delay time overflows, set it to the maximum encode-able value.
+		delayTime = time.Duration(math.MaxInt64)
+	}
+	frame.DelayTime = delayTime
+
+	numBlocks, l, err := quicvarint.Parse(b)
+	if err != nil {
+		return 0, replaceUnexpectedEOF(err)
+	}
+	b = b[l:]
+
+	// read the first ACK range
+	ab, l, err := quicvarint.Parse(b)
+	if err != nil {
+		return 0, replaceUnexpectedEOF(err)
+	}
+	b = b[l:]
+	ackBlock := protocol.PacketNumber(ab)
+	if ackBlock > largestAcked {
+		return 0, errors.New("invalid first ACK range")
+	}
+	smallest := largestAcked - ackBlock
+	frame.AckRanges = append(frame.AckRanges, AckRange{Smallest: smallest, Largest: largestAcked})
+
+	// read all the other ACK ranges
+	for range numBlocks {
+		g, l, err := quicvarint.Parse(b)
+		if err != nil {
+			return 0, replaceUnexpectedEOF(err)
+		}
+		b = b[l:]
+		gap := protocol.PacketNumber(g)
+		if smallest < gap+2 {
+			return 0, errInvalidAckRanges
+		}
+		largest := smallest - gap - 2
+
+		ab, l, err := quicvarint.Parse(b)
+		if err != nil {
+			return 0, replaceUnexpectedEOF(err)
+		}
+		b = b[l:]
+		ackBlock := protocol.PacketNumber(ab)
+
+		if ackBlock > largest {
+			return 0, errInvalidAckRanges
+		}
+		smallest = largest - ackBlock
+		frame.AckRanges = append(frame.AckRanges, AckRange{Smallest: smallest, Largest: largest})
+	}
+
+	if !frame.validateAckRanges() {
+		return 0, errInvalidAckRanges
+	}
+
+	if ecn {
+		ect0, l, err := quicvarint.Parse(b)
+		if err != nil {
+			return 0, replaceUnexpectedEOF(err)
+		}
+		b = b[l:]
+		frame.ECT0 = ect0
+		ect1, l, err := quicvarint.Parse(b)
+		if err != nil {
+			return 0, replaceUnexpectedEOF(err)
+		}
+		b = b[l:]
+		frame.ECT1 = ect1
+		ecnce, l, err := quicvarint.Parse(b)
+		if err != nil {
+			return 0, replaceUnexpectedEOF(err)
+		}
+		b = b[l:]
+		frame.ECNCE = ecnce
+	}
+
+	return startLen - len(b), nil
+}
+
+// Append appends an ACK frame.
+func (f *AckFrame) Append(b []byte, _ protocol.Version) ([]byte, error) {
+	hasECN := f.ECT0 > 0 || f.ECT1 > 0 || f.ECNCE > 0
+	if hasECN {
+		b = append(b, byte(FrameTypeAckECN))
+	} else {
+		b = append(b, byte(FrameTypeAck))
+	}
+	b = quicvarint.Append(b, uint64(f.LargestAcked()))
+	b = quicvarint.Append(b, encodeAckDelay(f.DelayTime))
+
+	numRanges := min(len(f.AckRanges), protocol.MaxNumAckRanges)
+	b = quicvarint.Append(b, uint64(numRanges-1))
+
+	// write the first range
+	_, firstRange := f.encodeAckRange(0)
+	b = quicvarint.Append(b, firstRange)
+
+	// write all the other range
+	for i := 1; i < numRanges; i++ {
+		gap, len := f.encodeAckRange(i)
+		b = quicvarint.Append(b, gap)
+		b = quicvarint.Append(b, len)
+	}
+
+	if hasECN {
+		b = quicvarint.Append(b, f.ECT0)
+		b = quicvarint.Append(b, f.ECT1)
+		b = quicvarint.Append(b, f.ECNCE)
+	}
+	return b, nil
+}
+
+// Length of a written frame
+func (f *AckFrame) Length(_ protocol.Version) protocol.ByteCount {
+	largestAcked := f.AckRanges[0].Largest
+
+	// The number of ACK ranges is limited to 64, which guarantees that the
+	// ACK Range Count value can be encoded in a single byte varint.
+	length := 1 + quicvarint.Len(uint64(largestAcked)) + quicvarint.Len(encodeAckDelay(f.DelayTime)) + 1
+
+	lowestInFirstRange := f.AckRanges[0].Smallest
+	length += quicvarint.Len(uint64(largestAcked - lowestInFirstRange))
+
+	for i := 1; i < min(len(f.AckRanges), protocol.MaxNumAckRanges); i++ {
+		gap, len := f.encodeAckRange(i)
+		length += quicvarint.Len(gap)
+		length += quicvarint.Len(len)
+	}
+	if f.ECT0 > 0 || f.ECT1 > 0 || f.ECNCE > 0 {
+		length += quicvarint.Len(f.ECT0) + quicvarint.Len(f.ECT1) + quicvarint.Len(f.ECNCE)
+	}
+	return protocol.ByteCount(length)
+}
+
+// Truncate truncates the ACK frame to fit into maxSize,
+// and to at most 64 ACK ranges.
+// maxSize must be large enough to fit at least one ACK range.
+func (f *AckFrame) Truncate(maxSize protocol.ByteCount, _ protocol.Version) {
+	f.AckRanges = f.AckRanges[:f.numEncodableAckRanges(maxSize)]
+}
+
+// gets the number of ACK ranges that can be encoded
+// such that the resulting frame is smaller than maxSize
+func (f *AckFrame) numEncodableAckRanges(maxSize protocol.ByteCount) int {
+	// Fast path: Most ACK frames are relatively small, and we don't need to calculate the exact length.
+	// We just assume the worst case scenario: every varint is encoded to 8 bytes.
+	// If the result is still smaller than the maximum ACK frame size, the actual ACK frame will definitely fit.
+	length := 1 + 8 /* largest acked */ + 8 /* delay */ + 1 /* ack range count */ + 8 /* first range */
+	if f.ECT0 > 0 || f.ECT1 > 0 || f.ECNCE > 0 {
+		length += 8 + 8 + 8
+	}
+	numRanges := min(len(f.AckRanges), protocol.MaxNumAckRanges)
+	length += 2 * 8 * (numRanges - 1)
+	if protocol.ByteCount(length) <= maxSize {
+		return numRanges
+	}
+
+	// Slow path: Calculate the exact length of the ACK frame.
+	length = 1 + quicvarint.Len(uint64(f.LargestAcked())) + quicvarint.Len(encodeAckDelay(f.DelayTime)) + 1
+	_, firstRange := f.encodeAckRange(0)
+	length += quicvarint.Len(firstRange)
+	if f.ECT0 > 0 || f.ECT1 > 0 || f.ECNCE > 0 {
+		length += quicvarint.Len(f.ECT0) + quicvarint.Len(f.ECT1) + quicvarint.Len(f.ECNCE)
+	}
+	for i := 1; i < numRanges; i++ {
+		gap, l := f.encodeAckRange(i)
+		rangeLen := quicvarint.Len(gap) + quicvarint.Len(l)
+		if protocol.ByteCount(length+rangeLen) > maxSize {
+			// Writing range i would exceed the maximum size,
+			// so encode one range less than that.
+			return i
+		}
+		length += rangeLen
+	}
+	return numRanges
+}
+
+func (f *AckFrame) encodeAckRange(i int) (gap, length uint64) {
+	if i == 0 {
+		return 0, uint64(f.AckRanges[0].Largest - f.AckRanges[0].Smallest)
+	}
+	return uint64(f.AckRanges[i-1].Smallest - f.AckRanges[i].Largest - 2),
+		uint64(f.AckRanges[i].Largest - f.AckRanges[i].Smallest)
+}
+
+// HasMissingRanges returns if this frame reports any missing packets
+func (f *AckFrame) HasMissingRanges() bool {
+	return len(f.AckRanges) > 1
+}
+
+func (f *AckFrame) validateAckRanges() bool {
+	if len(f.AckRanges) == 0 {
+		return false
+	}
+
+	// check the validity of every single ACK range
+	for _, ackRange := range f.AckRanges {
+		if ackRange.Smallest > ackRange.Largest {
+			return false
+		}
+	}
+
+	// check the consistency for ACK with multiple ACK ranges
+	for i, ackRange := range f.AckRanges {
+		if i == 0 {
+			continue
+		}
+		lastAckRange := f.AckRanges[i-1]
+		if lastAckRange.Smallest <= ackRange.Smallest {
+			return false
+		}
+		if lastAckRange.Smallest <= ackRange.Largest+1 {
+			return false
+		}
+	}
+
+	return true
+}
+
+// LargestAcked is the largest acked packet number
+func (f *AckFrame) LargestAcked() protocol.PacketNumber {
+	return f.AckRanges[0].Largest
+}
+
+// LowestAcked is the lowest acked packet number
+func (f *AckFrame) LowestAcked() protocol.PacketNumber {
+	return f.AckRanges[len(f.AckRanges)-1].Smallest
+}
+
+// AcksPacket determines if this ACK frame acks a certain packet number
+func (f *AckFrame) AcksPacket(p protocol.PacketNumber) bool {
+	if p < f.LowestAcked() || p > f.LargestAcked() {
+		return false
+	}
+
+	i := sort.Search(len(f.AckRanges), func(i int) bool {
+		return p >= f.AckRanges[i].Smallest
+	})
+	// i will always be < len(f.AckRanges), since we checked above that p is not bigger than the largest acked
+	return p <= f.AckRanges[i].Largest
+}
+
+func (f *AckFrame) Reset() {
+	f.DelayTime = 0
+	f.ECT0 = 0
+	f.ECT1 = 0
+	f.ECNCE = 0
+	for _, r := range f.AckRanges {
+		r.Largest = 0
+		r.Smallest = 0
+	}
+	f.AckRanges = f.AckRanges[:0]
+}
+
+func encodeAckDelay(delay time.Duration) uint64 {
+	return uint64(delay.Nanoseconds() / (1000 * (1 << protocol.AckDelayExponent)))
+}

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

@@ -0,0 +1,65 @@
+package wire
+
+import (
+	"math"
+	"time"
+
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/quicvarint"
+)
+
+type AckFrequencyFrame struct {
+	SequenceNumber        uint64
+	AckElicitingThreshold uint64
+	RequestMaxAckDelay    time.Duration
+	ReorderingThreshold   protocol.PacketNumber
+}
+
+func parseAckFrequencyFrame(b []byte, _ protocol.Version) (*AckFrequencyFrame, int, error) {
+	startLen := len(b)
+	seq, l, err := quicvarint.Parse(b)
+	if err != nil {
+		return nil, 0, replaceUnexpectedEOF(err)
+	}
+	b = b[l:]
+	aeth, l, err := quicvarint.Parse(b)
+	if err != nil {
+		return nil, 0, replaceUnexpectedEOF(err)
+	}
+	b = b[l:]
+	mad, l, err := quicvarint.Parse(b)
+	if err != nil {
+		return nil, 0, replaceUnexpectedEOF(err)
+	}
+	// prevents overflows if the peer sends a very large value
+	maxAckDelay := time.Duration(mad) * time.Microsecond
+	if maxAckDelay < 0 {
+		maxAckDelay = math.MaxInt64
+	}
+	b = b[l:]
+	rth, l, err := quicvarint.Parse(b)
+	if err != nil {
+		return nil, 0, replaceUnexpectedEOF(err)
+	}
+	b = b[l:]
+
+	return &AckFrequencyFrame{
+		SequenceNumber:        seq,
+		AckElicitingThreshold: aeth,
+		RequestMaxAckDelay:    maxAckDelay,
+		ReorderingThreshold:   protocol.PacketNumber(rth),
+	}, startLen - len(b), nil
+}
+
+func (f *AckFrequencyFrame) Append(b []byte, _ protocol.Version) ([]byte, error) {
+	b = quicvarint.Append(b, uint64(FrameTypeAckFrequency))
+	b = quicvarint.Append(b, f.SequenceNumber)
+	b = quicvarint.Append(b, f.AckElicitingThreshold)
+	b = quicvarint.Append(b, uint64(f.RequestMaxAckDelay/time.Microsecond))
+	return quicvarint.Append(b, uint64(f.ReorderingThreshold)), nil
+}
+
+func (f *AckFrequencyFrame) Length(_ protocol.Version) protocol.ByteCount {
+	return protocol.ByteCount(2 + quicvarint.Len(f.SequenceNumber) + quicvarint.Len(f.AckElicitingThreshold) +
+		quicvarint.Len(uint64(f.RequestMaxAckDelay/time.Microsecond)) + quicvarint.Len(uint64(f.ReorderingThreshold)))
+}

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

@@ -0,0 +1,14 @@
+package wire
+
+import "github.com/quic-go/quic-go/internal/protocol"
+
+// AckRange is an ACK range
+type AckRange struct {
+	Smallest protocol.PacketNumber
+	Largest  protocol.PacketNumber
+}
+
+// Len returns the number of packets contained in this ACK range
+func (r AckRange) Len() protocol.PacketNumber {
+	return r.Largest - r.Smallest + 1
+}

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

@@ -0,0 +1,75 @@
+package wire
+
+import (
+	"io"
+
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/quicvarint"
+)
+
+// A ConnectionCloseFrame is a CONNECTION_CLOSE frame
+type ConnectionCloseFrame struct {
+	IsApplicationError bool
+	ErrorCode          uint64
+	FrameType          uint64
+	ReasonPhrase       string
+}
+
+func parseConnectionCloseFrame(b []byte, typ FrameType, _ protocol.Version) (*ConnectionCloseFrame, int, error) {
+	startLen := len(b)
+	f := &ConnectionCloseFrame{IsApplicationError: typ == FrameTypeApplicationClose}
+	ec, l, err := quicvarint.Parse(b)
+	if err != nil {
+		return nil, 0, replaceUnexpectedEOF(err)
+	}
+	b = b[l:]
+	f.ErrorCode = ec
+	// read the Frame Type, if this is not an application error
+	if !f.IsApplicationError {
+		ft, l, err := quicvarint.Parse(b)
+		if err != nil {
+			return nil, 0, replaceUnexpectedEOF(err)
+		}
+		b = b[l:]
+		f.FrameType = ft
+	}
+	var reasonPhraseLen uint64
+	reasonPhraseLen, l, err = quicvarint.Parse(b)
+	if err != nil {
+		return nil, 0, replaceUnexpectedEOF(err)
+	}
+	b = b[l:]
+	if int(reasonPhraseLen) > len(b) {
+		return nil, 0, io.EOF
+	}
+
+	reasonPhrase := make([]byte, reasonPhraseLen)
+	copy(reasonPhrase, b)
+	f.ReasonPhrase = string(reasonPhrase)
+	return f, startLen - len(b) + int(reasonPhraseLen), nil
+}
+
+// Length of a written frame
+func (f *ConnectionCloseFrame) Length(protocol.Version) protocol.ByteCount {
+	length := 1 + protocol.ByteCount(quicvarint.Len(f.ErrorCode)+quicvarint.Len(uint64(len(f.ReasonPhrase)))) + protocol.ByteCount(len(f.ReasonPhrase))
+	if !f.IsApplicationError {
+		length += protocol.ByteCount(quicvarint.Len(f.FrameType)) // for the frame type
+	}
+	return length
+}
+
+func (f *ConnectionCloseFrame) Append(b []byte, _ protocol.Version) ([]byte, error) {
+	if f.IsApplicationError {
+		b = append(b, byte(FrameTypeApplicationClose))
+	} else {
+		b = append(b, byte(FrameTypeConnectionClose))
+	}
+
+	b = quicvarint.Append(b, f.ErrorCode)
+	if !f.IsApplicationError {
+		b = quicvarint.Append(b, f.FrameType)
+	}
+	b = quicvarint.Append(b, uint64(len(f.ReasonPhrase)))
+	b = append(b, []byte(f.ReasonPhrase)...)
+	return b, nil
+}

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

@@ -0,0 +1,97 @@
+package wire
+
+import (
+	"io"
+
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/quicvarint"
+)
+
+// A CryptoFrame is a CRYPTO frame
+type CryptoFrame struct {
+	Offset protocol.ByteCount
+	Data   []byte
+}
+
+func parseCryptoFrame(b []byte, _ protocol.Version) (*CryptoFrame, int, error) {
+	startLen := len(b)
+	frame := &CryptoFrame{}
+	offset, l, err := quicvarint.Parse(b)
+	if err != nil {
+		return nil, 0, replaceUnexpectedEOF(err)
+	}
+	b = b[l:]
+	frame.Offset = protocol.ByteCount(offset)
+	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
+	}
+	if dataLen != 0 {
+		frame.Data = make([]byte, dataLen)
+		copy(frame.Data, b)
+	}
+	return frame, startLen - len(b) + int(dataLen), nil
+}
+
+func (f *CryptoFrame) Append(b []byte, _ protocol.Version) ([]byte, error) {
+	b = append(b, byte(FrameTypeCrypto))
+	b = quicvarint.Append(b, uint64(f.Offset))
+	b = quicvarint.Append(b, uint64(len(f.Data)))
+	b = append(b, f.Data...)
+	return b, nil
+}
+
+// Length of a written frame
+func (f *CryptoFrame) Length(_ protocol.Version) protocol.ByteCount {
+	return protocol.ByteCount(1 + quicvarint.Len(uint64(f.Offset)) + quicvarint.Len(uint64(len(f.Data))) + len(f.Data))
+}
+
+// MaxDataLen returns the maximum data length
+func (f *CryptoFrame) MaxDataLen(maxSize protocol.ByteCount) protocol.ByteCount {
+	// pretend that the data size will be 1 bytes
+	// if it turns out that varint encoding the length will consume 2 bytes, we need to adjust the data length afterwards
+	headerLen := protocol.ByteCount(1 + quicvarint.Len(uint64(f.Offset)) + 1)
+	if headerLen > maxSize {
+		return 0
+	}
+	maxDataLen := maxSize - headerLen
+	if 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 *CryptoFrame) MaybeSplitOffFrame(maxSize protocol.ByteCount, version protocol.Version) (*CryptoFrame, bool /* was splitting required */) {
+	if f.Length(version) <= maxSize {
+		return nil, false
+	}
+
+	n := f.MaxDataLen(maxSize)
+	if n == 0 {
+		return nil, true
+	}
+
+	newLen := protocol.ByteCount(len(f.Data)) - n
+
+	new := &CryptoFrame{}
+	new.Offset = f.Offset
+	new.Data = make([]byte, newLen)
+
+	// swap the data slices
+	new.Data, f.Data = f.Data, new.Data
+
+	copy(f.Data, new.Data[n:])
+	new.Data = new.Data[:n]
+	f.Offset += n
+
+	return new, true
+}

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

@@ -0,0 +1,29 @@
+package wire
+
+import (
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/quicvarint"
+)
+
+// A DataBlockedFrame is a DATA_BLOCKED frame
+type DataBlockedFrame struct {
+	MaximumData protocol.ByteCount
+}
+
+func parseDataBlockedFrame(b []byte, _ protocol.Version) (*DataBlockedFrame, int, error) {
+	offset, l, err := quicvarint.Parse(b)
+	if err != nil {
+		return nil, 0, replaceUnexpectedEOF(err)
+	}
+	return &DataBlockedFrame{MaximumData: protocol.ByteCount(offset)}, l, nil
+}
+
+func (f *DataBlockedFrame) Append(b []byte, version protocol.Version) ([]byte, error) {
+	b = append(b, byte(FrameTypeDataBlocked))
+	return quicvarint.Append(b, uint64(f.MaximumData)), nil
+}
+
+// Length of a written frame
+func (f *DataBlockedFrame) Length(version protocol.Version) protocol.ByteCount {
+	return 1 + protocol.ByteCount(quicvarint.Len(uint64(f.MaximumData)))
+}

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

@@ -0,0 +1,85 @@
+package wire
+
+import (
+	"io"
+
+	"github.com/quic-go/quic-go/internal/protocol"
+	"github.com/quic-go/quic-go/quicvarint"
+)
+
+// MaxDatagramSize is the maximum size of a DATAGRAM frame (RFC 9221).
+// By setting it to a large value, we allow all datagrams that fit into a QUIC packet.
+// The value is chosen such that it can still be encoded as a 2 byte varint.
+// This is a var and not a const so it can be set in tests.
+var MaxDatagramSize protocol.ByteCount = 16383
+
+// A DatagramFrame is a DATAGRAM frame
+type DatagramFrame struct {
+	DataLenPresent bool
+	Data           []byte
+}
+
+func parseDatagramFrame(b []byte, typ FrameType, _ protocol.Version) (*DatagramFrame, int, error) {
+	startLen := len(b)
+	f := &DatagramFrame{}
+	f.DataLenPresent = uint64(typ)&0x1 > 0
+
+	var length uint64
+	if f.DataLenPresent {
+		var err error
+		var l int
+		length, l, err = quicvarint.Parse(b)
+		if err != nil {
+			return nil, 0, replaceUnexpectedEOF(err)
+		}
+		b = b[l:]
+		if length > uint64(len(b)) {
+			return nil, 0, io.EOF
+		}
+	} else {
+		length = uint64(len(b))
+	}
+	f.Data = make([]byte, length)
+	copy(f.Data, b)
+	return f, startLen - len(b) + int(length), nil
+}
+
+func (f *DatagramFrame) Append(b []byte, _ protocol.Version) ([]byte, error) {
+	typ := uint8(0x30)
+	if f.DataLenPresent {
+		typ ^= 0b1
+	}
+	b = append(b, typ)
+	if f.DataLenPresent {
+		b = quicvarint.Append(b, uint64(len(f.Data)))
+	}
+	b = append(b, f.Data...)
+	return b, nil
+}
+
+// MaxDataLen returns the maximum data length
+func (f *DatagramFrame) MaxDataLen(maxSize protocol.ByteCount, version protocol.Version) protocol.ByteCount {
+	headerLen := protocol.ByteCount(1)
+	if f.DataLenPresent {
+		// pretend that the data size will be 1 bytes
+		// if it turns out that varint encoding the length will consume 2 bytes, we need to adjust the data length afterwards
+		headerLen++
+	}
+	if headerLen > maxSize {
+		return 0
+	}
+	maxDataLen := maxSize - headerLen
+	if f.DataLenPresent && quicvarint.Len(uint64(maxDataLen)) != 1 {
+		maxDataLen--
+	}
+	return maxDataLen
+}
+
+// Length of a written frame
+func (f *DatagramFrame) Length(_ protocol.Version) protocol.ByteCount {
+	length := 1 + protocol.ByteCount(len(f.Data))
+	if f.DataLenPresent {
+		length += protocol.ByteCount(quicvarint.Len(uint64(len(f.Data))))
+	}
+	return length
+}