@ttsc/win32-arm64 0.33.1 → 0.34.0

package/bin/go/src/vendor/golang.org/x/net/internal/quic/quicwire/wire.go

@@ -0,0 +1,150 @@
+// Copyright 2023 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package quicwire encodes and decode QUIC/HTTP3 wire encoding types,
+// particularly variable-length integers.
+package quicwire
+
+import "encoding/binary"
+
+const (
+	MaxVarintSize = 8 // encoded size in bytes
+	MaxVarint     = (1 << 62) - 1
+)
+
+// ConsumeVarint parses a variable-length integer, reporting its length.
+// It returns a negative length upon an error.
+//
+// https://www.rfc-editor.org/rfc/rfc9000.html#section-16
+func ConsumeVarint(b []byte) (v uint64, n int) {
+	if len(b) < 1 {
+		return 0, -1
+	}
+	b0 := b[0] & 0x3f
+	switch b[0] >> 6 {
+	case 0:
+		return uint64(b0), 1
+	case 1:
+		if len(b) < 2 {
+			return 0, -1
+		}
+		return uint64(b0)<<8 | uint64(b[1]), 2
+	case 2:
+		if len(b) < 4 {
+			return 0, -1
+		}
+		return uint64(b0)<<24 | uint64(b[1])<<16 | uint64(b[2])<<8 | uint64(b[3]), 4
+	case 3:
+		if len(b) < 8 {
+			return 0, -1
+		}
+		return uint64(b0)<<56 | uint64(b[1])<<48 | uint64(b[2])<<40 | uint64(b[3])<<32 | uint64(b[4])<<24 | uint64(b[5])<<16 | uint64(b[6])<<8 | uint64(b[7]), 8
+	}
+	return 0, -1
+}
+
+// ConsumeVarintInt64 parses a variable-length integer as an int64.
+func ConsumeVarintInt64(b []byte) (v int64, n int) {
+	u, n := ConsumeVarint(b)
+	// QUIC varints are 62-bits large, so this conversion can never overflow.
+	return int64(u), n
+}
+
+// AppendVarint appends a variable-length integer to b.
+//
+// https://www.rfc-editor.org/rfc/rfc9000.html#section-16
+func AppendVarint(b []byte, v uint64) []byte {
+	switch {
+	case v <= 63:
+		return append(b, byte(v))
+	case v <= 16383:
+		return append(b, (1<<6)|byte(v>>8), byte(v))
+	case v <= 1073741823:
+		return append(b, (2<<6)|byte(v>>24), byte(v>>16), byte(v>>8), byte(v))
+	case v <= 4611686018427387903:
+		return append(b, (3<<6)|byte(v>>56), byte(v>>48), byte(v>>40), byte(v>>32), byte(v>>24), byte(v>>16), byte(v>>8), byte(v))
+	default:
+		panic("varint too large")
+	}
+}
+
+// SizeVarint returns the size of the variable-length integer encoding of f.
+func SizeVarint(v uint64) int {
+	switch {
+	case v <= 63:
+		return 1
+	case v <= 16383:
+		return 2
+	case v <= 1073741823:
+		return 4
+	case v <= 4611686018427387903:
+		return 8
+	default:
+		panic("varint too large")
+	}
+}
+
+// ConsumeUint32 parses a 32-bit fixed-length, big-endian integer, reporting its length.
+// It returns a negative length upon an error.
+func ConsumeUint32(b []byte) (uint32, int) {
+	if len(b) < 4 {
+		return 0, -1
+	}
+	return binary.BigEndian.Uint32(b), 4
+}
+
+// ConsumeUint64 parses a 64-bit fixed-length, big-endian integer, reporting its length.
+// It returns a negative length upon an error.
+func ConsumeUint64(b []byte) (uint64, int) {
+	if len(b) < 8 {
+		return 0, -1
+	}
+	return binary.BigEndian.Uint64(b), 8
+}
+
+// ConsumeUint8Bytes parses a sequence of bytes prefixed with an 8-bit length,
+// reporting the total number of bytes consumed.
+// It returns a negative length upon an error.
+func ConsumeUint8Bytes(b []byte) ([]byte, int) {
+	if len(b) < 1 {
+		return nil, -1
+	}
+	size := int(b[0])
+	const n = 1
+	if size > len(b[n:]) {
+		return nil, -1
+	}
+	return b[n:][:size], size + n
+}
+
+// AppendUint8Bytes appends a sequence of bytes prefixed by an 8-bit length.
+func AppendUint8Bytes(b, v []byte) []byte {
+	if len(v) > 0xff {
+		panic("uint8-prefixed bytes too large")
+	}
+	b = append(b, uint8(len(v)))
+	b = append(b, v...)
+	return b
+}
+
+// ConsumeVarintBytes parses a sequence of bytes preceded by a variable-length integer length,
+// reporting the total number of bytes consumed.
+// It returns a negative length upon an error.
+func ConsumeVarintBytes(b []byte) ([]byte, int) {
+	size, n := ConsumeVarint(b)
+	if n < 0 {
+		return nil, -1
+	}
+	if size > uint64(len(b[n:])) {
+		return nil, -1
+	}
+	return b[n:][:size], int(size) + n
+}
+
+// AppendVarintBytes appends a sequence of bytes prefixed by a variable-length integer length.
+func AppendVarintBytes(b, v []byte) []byte {
+	b = AppendVarint(b, uint64(len(v)))
+	b = append(b, v...)
+	return b
+}

package/bin/go/src/vendor/golang.org/x/net/quic/ack_delay.go

@@ -0,0 +1,26 @@
+// Copyright 2023 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package quic
+
+import (
+	"math"
+	"time"
+)
+
+// An unscaledAckDelay is an ACK Delay field value from an ACK packet,
+// without the ack_delay_exponent scaling applied.
+type unscaledAckDelay int64
+
+func unscaledAckDelayFromDuration(d time.Duration, ackDelayExponent uint8) unscaledAckDelay {
+	return unscaledAckDelay(d.Microseconds() >> ackDelayExponent)
+}
+
+func (d unscaledAckDelay) Duration(ackDelayExponent uint8) time.Duration {
+	if int64(d) > (math.MaxInt64>>ackDelayExponent)/int64(time.Microsecond) {
+		// If scaling the delay would overflow, ignore the delay.
+		return 0
+	}
+	return time.Duration(d<<ackDelayExponent) * time.Microsecond
+}

package/bin/go/src/vendor/golang.org/x/net/quic/acks.go

@@ -0,0 +1,213 @@
+// Copyright 2023 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package quic
+
+import (
+	"time"
+)
+
+// ackState tracks packets received from a peer within a number space.
+// It handles packet deduplication (don't process the same packet twice) and
+// determines the timing and content of ACK frames.
+type ackState struct {
+	seen rangeset[packetNumber]
+
+	// The time at which we must send an ACK frame, even if we have no other data to send.
+	nextAck time.Time
+
+	// The time we received the largest-numbered packet in seen.
+	maxRecvTime time.Time
+
+	// The largest-numbered ack-eliciting packet in seen.
+	maxAckEliciting packetNumber
+
+	// The number of ack-eliciting packets in seen that we have not yet acknowledged.
+	unackedAckEliciting int
+
+	// Total ECN counters for this packet number space.
+	ecn ecnCounts
+}
+
+type ecnCounts struct {
+	t0 int
+	t1 int
+	ce int
+}
+
+// shouldProcess reports whether a packet should be handled or discarded.
+func (acks *ackState) shouldProcess(num packetNumber) bool {
+	if packetNumber(acks.seen.min()) > num {
+		// We've discarded the state for this range of packet numbers.
+		// Discard the packet rather than potentially processing a duplicate.
+		// https://www.rfc-editor.org/rfc/rfc9000.html#section-13.2.3-5
+		return false
+	}
+	if acks.seen.contains(num) {
+		// Discard duplicate packets.
+		return false
+	}
+	return true
+}
+
+// receive records receipt of a packet.
+func (acks *ackState) receive(now time.Time, space numberSpace, num packetNumber, ackEliciting bool, ecn ecnBits) {
+	if ackEliciting {
+		acks.unackedAckEliciting++
+		if acks.mustAckImmediately(space, num, ecn) {
+			acks.nextAck = now
+		} else if acks.nextAck.IsZero() {
+			// This packet does not need to be acknowledged immediately,
+			// but the ack must not be intentionally delayed by more than
+			// the max_ack_delay transport parameter we sent to the peer.
+			//
+			// We always delay acks by the maximum allowed, less the timer
+			// granularity. ("[max_ack_delay] SHOULD include the receiver's
+			// expected delays in alarms firing.")
+			//
+			// https://www.rfc-editor.org/rfc/rfc9000#section-18.2-4.28.1
+			acks.nextAck = now.Add(maxAckDelay - timerGranularity)
+		}
+		if num > acks.maxAckEliciting {
+			acks.maxAckEliciting = num
+		}
+	}
+
+	acks.seen.add(num, num+1)
+	if num == acks.seen.max() {
+		acks.maxRecvTime = now
+	}
+
+	switch ecn {
+	case ecnECT0:
+		acks.ecn.t0++
+	case ecnECT1:
+		acks.ecn.t1++
+	case ecnCE:
+		acks.ecn.ce++
+	}
+
+	// Limit the total number of ACK ranges by dropping older ranges.
+	//
+	// Remembering more ranges results in larger ACK frames.
+	//
+	// Remembering a large number of ranges could result in ACK frames becoming
+	// too large to fit in a packet, in which case we will silently drop older
+	// ranges during packet construction.
+	//
+	// Remembering fewer ranges can result in unnecessary retransmissions,
+	// since we cannot accept packets older than the oldest remembered range.
+	//
+	// The limit here is completely arbitrary. If it seems wrong, it probably is.
+	//
+	// https://www.rfc-editor.org/rfc/rfc9000#section-13.2.3
+	const maxAckRanges = 8
+	if overflow := acks.seen.numRanges() - maxAckRanges; overflow > 0 {
+		acks.seen.removeranges(0, overflow)
+	}
+}
+
+// mustAckImmediately reports whether an ack-eliciting packet must be acknowledged immediately,
+// or whether the ack may be deferred.
+func (acks *ackState) mustAckImmediately(space numberSpace, num packetNumber, ecn ecnBits) bool {
+	// https://www.rfc-editor.org/rfc/rfc9000.html#section-13.2.1
+	if space != appDataSpace {
+		// "[...] all ack-eliciting Initial and Handshake packets [...]"
+		// https://www.rfc-editor.org/rfc/rfc9000.html#section-13.2.1-2
+		return true
+	}
+	if num < acks.maxAckEliciting {
+		// "[...] when the received packet has a packet number less than another
+		// ack-eliciting packet that has been received [...]"
+		// https://www.rfc-editor.org/rfc/rfc9000.html#section-13.2.1-8.1
+		return true
+	}
+	if acks.seen.rangeContaining(acks.maxAckEliciting).end != num {
+		// "[...] when the packet has a packet number larger than the highest-numbered
+		// ack-eliciting packet that has been received and there are missing packets
+		// between that packet and this packet."
+		// https://www.rfc-editor.org/rfc/rfc9000.html#section-13.2.1-8.2
+		//
+		// This case is a bit tricky. Let's say we've received:
+		//   0, ack-eliciting
+		//   1, ack-eliciting
+		//   3, NOT ack eliciting
+		//
+		// We have sent ACKs for 0 and 1. If we receive ack-eliciting packet 2,
+		// we do not need to send an immediate ACK, because there are no missing
+		// packets between it and the highest-numbered ack-eliciting packet (1).
+		// If we receive ack-eliciting packet 4, we do need to send an immediate ACK,
+		// because there's a gap (the missing packet 2).
+		//
+		// We check for this by looking up the ACK range which contains the
+		// highest-numbered ack-eliciting packet: [0, 1) in the above example.
+		// If the range ends just before the packet we are now processing,
+		// there are no gaps. If it does not, there must be a gap.
+		return true
+	}
+	// "[...] packets marked with the ECN Congestion Experienced (CE) codepoint
+	// in the IP header SHOULD be acknowledged immediately [...]"
+	// https://www.rfc-editor.org/rfc/rfc9000.html#section-13.2.1-9
+	if ecn == ecnCE {
+		return true
+	}
+	// "[...] SHOULD send an ACK frame after receiving at least two ack-eliciting packets."
+	// https://www.rfc-editor.org/rfc/rfc9000.html#section-13.2.2
+	//
+	// This ack frequency takes a substantial toll on performance, however.
+	// Follow the behavior of Google QUICHE:
+	// Ack every other packet for the first 100 packets, and then ack every 10th packet.
+	// This keeps ack frequency high during the beginning of slow start when CWND is
+	// increasing rapidly.
+	packetsBeforeAck := 2
+	if acks.seen.max() > 100 {
+		packetsBeforeAck = 10
+	}
+	return acks.unackedAckEliciting >= packetsBeforeAck
+}
+
+// shouldSendAck reports whether the connection should send an ACK frame at this time,
+// in an ACK-only packet if necessary.
+func (acks *ackState) shouldSendAck(now time.Time) bool {
+	return !acks.nextAck.IsZero() && !acks.nextAck.After(now)
+}
+
+// acksToSend returns the set of packet numbers to ACK at this time, and the current ack delay.
+// It may return acks even if shouldSendAck returns false, when there are unacked
+// ack-eliciting packets whose ack is being delayed.
+func (acks *ackState) acksToSend(now time.Time) (nums rangeset[packetNumber], ackDelay time.Duration) {
+	if acks.nextAck.IsZero() && acks.unackedAckEliciting == 0 {
+		return nil, 0
+	}
+	// "[...] the delays intentionally introduced between the time the packet with the
+	// largest packet number is received and the time an acknowledgement is sent."
+	// https://www.rfc-editor.org/rfc/rfc9000#section-13.2.5-1
+	delay := now.Sub(acks.maxRecvTime)
+	if delay < 0 {
+		delay = 0
+	}
+	return acks.seen, delay
+}
+
+// sentAck records that an ACK frame has been sent.
+func (acks *ackState) sentAck() {
+	acks.nextAck = time.Time{}
+	acks.unackedAckEliciting = 0
+}
+
+// handleAck records that an ack has been received for a ACK frame we sent
+// containing the given Largest Acknowledged field.
+func (acks *ackState) handleAck(largestAcked packetNumber) {
+	// We can stop acking packets less or equal to largestAcked.
+	// https://www.rfc-editor.org/rfc/rfc9000.html#section-13.2.4-1
+	//
+	// We rely on acks.seen containing the largest packet number that has been successfully
+	// processed, so we retain the range containing largestAcked and discard previous ones.
+	acks.seen.sub(0, acks.seen.rangeContaining(largestAcked).start)
+}
+
+// largestSeen reports the largest seen packet.
+func (acks *ackState) largestSeen() packetNumber {
+	return acks.seen.max()
+}

package/bin/go/src/vendor/golang.org/x/net/quic/atomic_bits.go

@@ -0,0 +1,31 @@
+// Copyright 2023 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package quic
+
+import "sync/atomic"
+
+// atomicBits is an atomic uint32 that supports setting individual bits.
+type atomicBits[T ~uint32] struct {
+	bits atomic.Uint32
+}
+
+// set sets the bits in mask to the corresponding bits in v.
+// It returns the new value.
+func (a *atomicBits[T]) set(v, mask T) T {
+	if v&^mask != 0 {
+		panic("BUG: bits in v are not in mask")
+	}
+	for {
+		o := a.bits.Load()
+		n := (o &^ uint32(mask)) | uint32(v)
+		if a.bits.CompareAndSwap(o, n) {
+			return T(n)
+		}
+	}
+}
+
+func (a *atomicBits[T]) load() T {
+	return T(a.bits.Load())
+}

package/bin/go/src/vendor/golang.org/x/net/quic/config.go

@@ -0,0 +1,158 @@
+// Copyright 2023 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package quic
+
+import (
+	"crypto/tls"
+	"log/slog"
+	"math"
+	"time"
+
+	"golang.org/x/net/internal/quic/quicwire"
+)
+
+// A Config structure configures a QUIC endpoint.
+// A Config must not be modified after it has been passed to a QUIC function.
+// A Config may be reused; the quic package will also not modify it.
+type Config struct {
+	// TLSConfig is the endpoint's TLS configuration.
+	// It must be non-nil and include at least one certificate or else set GetCertificate.
+	TLSConfig *tls.Config
+
+	// MaxBidiRemoteStreams limits the number of simultaneous bidirectional streams
+	// a peer may open.
+	// If zero, the default value of 100 is used.
+	// If negative, the limit is zero.
+	MaxBidiRemoteStreams int64
+
+	// MaxUniRemoteStreams limits the number of simultaneous unidirectional streams
+	// a peer may open.
+	// If zero, the default value of 100 is used.
+	// If negative, the limit is zero.
+	MaxUniRemoteStreams int64
+
+	// MaxStreamReadBufferSize is the maximum amount of data sent by the peer that a
+	// stream will buffer for reading.
+	// If zero, the default value of 1MiB is used.
+	// If negative, the limit is zero.
+	MaxStreamReadBufferSize int64
+
+	// MaxStreamWriteBufferSize is the maximum amount of data a stream will buffer for
+	// sending to the peer.
+	// If zero, the default value of 1MiB is used.
+	// If negative, the limit is zero.
+	MaxStreamWriteBufferSize int64
+
+	// MaxConnReadBufferSize is the maximum amount of data sent by the peer that a
+	// connection will buffer for reading, across all streams.
+	// If zero, the default value of 1MiB is used.
+	// If negative, the limit is zero.
+	MaxConnReadBufferSize int64
+
+	// RequireAddressValidation may be set to true to enable address validation
+	// of client connections prior to starting the handshake.
+	//
+	// Enabling this setting reduces the amount of work packets with spoofed
+	// source address information can cause a server to perform,
+	// at the cost of increased handshake latency.
+	RequireAddressValidation bool
+
+	// StatelessResetKey is used to provide stateless reset of connections.
+	// A restart may leave an endpoint without access to the state of
+	// existing connections. Stateless reset permits an endpoint to respond
+	// to a packet for a connection it does not recognize.
+	//
+	// This field should be filled with random bytes.
+	// The contents should remain stable across restarts,
+	// to permit an endpoint to send a reset for
+	// connections created before a restart.
+	//
+	// The contents of the StatelessResetKey should not be exposed.
+	// An attacker can use knowledge of this field's value to
+	// reset existing connections.
+	//
+	// If this field is left as zero, stateless reset is disabled.
+	StatelessResetKey [32]byte
+
+	// HandshakeTimeout is the maximum time in which a connection handshake must complete.
+	// If zero, the default of 10 seconds is used.
+	// If negative, there is no handshake timeout.
+	HandshakeTimeout time.Duration
+
+	// MaxIdleTimeout is the maximum time after which an idle connection will be closed.
+	// If zero, the default of 30 seconds is used.
+	// If negative, idle connections are never closed.
+	//
+	// The idle timeout for a connection is the minimum of the maximum idle timeouts
+	// of the endpoints.
+	MaxIdleTimeout time.Duration
+
+	// KeepAlivePeriod is the time after which a packet will be sent to keep
+	// an idle connection alive.
+	// If zero, keep alive packets are not sent.
+	// If greater than zero, the keep alive period is the smaller of KeepAlivePeriod and
+	// half the connection idle timeout.
+	KeepAlivePeriod time.Duration
+
+	// QLogLogger receives qlog events.
+	//
+	// Events currently correspond to the definitions in draft-ietf-qlog-quic-events-03.
+	// This is not the latest version of the draft, but is the latest version supported
+	// by common event log viewers as of the time this paragraph was written.
+	//
+	// The qlog package contains a slog.Handler which serializes qlog events
+	// to a standard JSON representation.
+	QLogLogger *slog.Logger
+}
+
+// Clone returns a shallow clone of c, or nil if c is nil.
+// It is safe to clone a [Config] that is being used concurrently by a QUIC endpoint.
+func (c *Config) Clone() *Config {
+	n := *c
+	return &n
+}
+
+func configDefault[T ~int64](v, def, limit T) T {
+	switch {
+	case v == 0:
+		return def
+	case v < 0:
+		return 0
+	default:
+		return min(v, limit)
+	}
+}
+
+func (c *Config) maxBidiRemoteStreams() int64 {
+	return configDefault(c.MaxBidiRemoteStreams, 100, maxStreamsLimit)
+}
+
+func (c *Config) maxUniRemoteStreams() int64 {
+	return configDefault(c.MaxUniRemoteStreams, 100, maxStreamsLimit)
+}
+
+func (c *Config) maxStreamReadBufferSize() int64 {
+	return configDefault(c.MaxStreamReadBufferSize, 1<<20, quicwire.MaxVarint)
+}
+
+func (c *Config) maxStreamWriteBufferSize() int64 {
+	return configDefault(c.MaxStreamWriteBufferSize, 1<<20, quicwire.MaxVarint)
+}
+
+func (c *Config) maxConnReadBufferSize() int64 {
+	return configDefault(c.MaxConnReadBufferSize, 1<<20, quicwire.MaxVarint)
+}
+
+func (c *Config) handshakeTimeout() time.Duration {
+	return configDefault(c.HandshakeTimeout, defaultHandshakeTimeout, math.MaxInt64)
+}
+
+func (c *Config) maxIdleTimeout() time.Duration {
+	return configDefault(c.MaxIdleTimeout, defaultMaxIdleTimeout, math.MaxInt64)
+}
+
+func (c *Config) keepAlivePeriod() time.Duration {
+	return configDefault(c.KeepAlivePeriod, defaultKeepAlivePeriod, math.MaxInt64)
+}