@ttsc/win32-arm64 0.33.0 → 0.34.0

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

@@ -0,0 +1,138 @@
+// 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 (
+	"context"
+)
+
+// Limits on the number of open streams.
+// Every connection has separate limits for bidirectional and unidirectional streams.
+//
+// Note that the MAX_STREAMS limit includes closed as well as open streams.
+// Closing a stream doesn't enable an endpoint to open a new one;
+// only an increase in the MAX_STREAMS limit does.
+
+// localStreamLimits are limits on the number of open streams created by us.
+type localStreamLimits struct {
+	gate   gate
+	max    int64 // peer-provided MAX_STREAMS
+	opened int64 // number of streams opened by us, -1 when conn is closed
+}
+
+func (lim *localStreamLimits) init() {
+	lim.gate = newGate()
+}
+
+// open creates a new local stream, blocking until MAX_STREAMS quota is available.
+func (lim *localStreamLimits) open(ctx context.Context, c *Conn) (num int64, err error) {
+	// TODO: Send a STREAMS_BLOCKED when blocked.
+	if err := lim.gate.waitAndLock(ctx); err != nil {
+		return 0, err
+	}
+	defer lim.unlock()
+	if lim.opened < 0 {
+		return 0, errConnClosed
+	}
+	num = lim.opened
+	lim.opened++
+	return num, nil
+}
+
+// unlock is a wrapper around lim.gate.unlock. This should be used in lieu of
+// lim.gate.unlock directly so that out gate-state-setting logic is consistent
+// across multiple calls.
+func (lim *localStreamLimits) unlock() {
+	lim.gate.unlock(lim.opened < lim.max)
+}
+
+// wasOpened reports whether the given stream was opened by us.
+func (lim *localStreamLimits) wasOpened(num int64) bool {
+	lim.gate.lock()
+	defer lim.unlock()
+	return num < lim.opened
+}
+
+// connHasClosed indicates the connection has been closed, locally or by the peer.
+func (lim *localStreamLimits) connHasClosed() {
+	lim.gate.lock()
+	lim.opened = -1
+	lim.unlock()
+}
+
+// setMax sets the MAX_STREAMS provided by the peer.
+func (lim *localStreamLimits) setMax(maxStreams int64) {
+	lim.gate.lock()
+	lim.max = max(lim.max, maxStreams)
+	lim.unlock()
+}
+
+// remoteStreamLimits are limits on the number of open streams created by the peer.
+type remoteStreamLimits struct {
+	max     int64   // last MAX_STREAMS sent to the peer
+	opened  int64   // number of streams opened by the peer (including subsequently closed ones)
+	closed  int64   // number of peer streams in the "closed" state
+	maxOpen int64   // how many streams we want to let the peer simultaneously open
+	sendMax sentVal // set when we should send MAX_STREAMS
+}
+
+func (lim *remoteStreamLimits) init(maxOpen int64) {
+	lim.maxOpen = maxOpen
+	lim.max = min(maxOpen, implicitStreamLimit) // initial limit sent in transport parameters
+	lim.opened = 0
+}
+
+// open handles the peer opening a new stream.
+func (lim *remoteStreamLimits) open(id streamID) error {
+	num := id.num()
+	if num >= lim.max {
+		return localTransportError{
+			code:   errStreamLimit,
+			reason: "stream limit exceeded",
+		}
+	}
+	if num >= lim.opened {
+		lim.opened = num + 1
+		lim.maybeUpdateMax()
+	}
+	return nil
+}
+
+// close handles the peer closing an open stream.
+func (lim *remoteStreamLimits) close() {
+	lim.closed++
+	lim.maybeUpdateMax()
+}
+
+// maybeUpdateMax updates the MAX_STREAMS value we will send to the peer.
+func (lim *remoteStreamLimits) maybeUpdateMax() {
+	newMax := min(
+		// Max streams the peer can have open at once.
+		lim.closed+lim.maxOpen,
+		// Max streams the peer can open with a single frame.
+		lim.opened+implicitStreamLimit,
+	)
+	avail := lim.max - lim.opened
+	if newMax > lim.max && (avail < 8 || newMax-lim.max >= 2*avail) {
+		// If the peer has less than 8 streams, or if increasing the peer's
+		// stream limit would double it, then send a MAX_STREAMS.
+		lim.max = newMax
+		lim.sendMax.setUnsent()
+	}
+}
+
+// appendFrame appends a MAX_STREAMS frame to the current packet, if necessary.
+//
+// It returns true if no more frames need appending,
+// false if not everything fit in the current packet.
+func (lim *remoteStreamLimits) appendFrame(w *packetWriter, typ streamType, pnum packetNumber, pto bool) bool {
+	if lim.sendMax.shouldSendPTO(pto) {
+		if !w.appendMaxStreamsFrame(typ, lim.max) {
+			return false
+		}
+		lim.sendMax.setSent(pnum)
+	}
+	return true
+}

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

@@ -0,0 +1,123 @@
+// 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 (
+	"context"
+	"crypto/tls"
+	"errors"
+	"fmt"
+	"net"
+	"time"
+)
+
+// startTLS starts the TLS handshake.
+func (c *Conn) startTLS(now time.Time, initialConnID []byte, peerHostname string, params transportParameters) error {
+	tlsConfig := c.config.TLSConfig
+	if a, _, err := net.SplitHostPort(peerHostname); err == nil {
+		peerHostname = a
+	}
+	if tlsConfig.ServerName == "" && peerHostname != "" {
+		tlsConfig = tlsConfig.Clone()
+		tlsConfig.ServerName = peerHostname
+	}
+
+	c.keysInitial = initialKeys(initialConnID, c.side)
+
+	qconfig := &tls.QUICConfig{TLSConfig: tlsConfig}
+	if c.side == clientSide {
+		c.tls = tls.QUICClient(qconfig)
+	} else {
+		c.tls = tls.QUICServer(qconfig)
+	}
+	c.tls.SetTransportParameters(marshalTransportParameters(params))
+	// TODO: We don't need or want a context for cancellation here,
+	// but users can use a context to plumb values through to hooks defined
+	// in the tls.Config. Pass through a context.
+	if err := c.tls.Start(context.TODO()); err != nil {
+		return err
+	}
+	return c.handleTLSEvents(now)
+}
+
+func (c *Conn) handleTLSEvents(now time.Time) error {
+	for {
+		e := c.tls.NextEvent()
+		if c.testHooks != nil {
+			c.testHooks.handleTLSEvent(e)
+		}
+		switch e.Kind {
+		case tls.QUICNoEvent:
+			return nil
+		case tls.QUICSetReadSecret:
+			if err := checkCipherSuite(e.Suite); err != nil {
+				return err
+			}
+			switch e.Level {
+			case tls.QUICEncryptionLevelHandshake:
+				c.keysHandshake.r.init(e.Suite, e.Data)
+			case tls.QUICEncryptionLevelApplication:
+				c.keysAppData.r.init(e.Suite, e.Data)
+			}
+		case tls.QUICSetWriteSecret:
+			if err := checkCipherSuite(e.Suite); err != nil {
+				return err
+			}
+			switch e.Level {
+			case tls.QUICEncryptionLevelHandshake:
+				c.keysHandshake.w.init(e.Suite, e.Data)
+			case tls.QUICEncryptionLevelApplication:
+				c.keysAppData.w.init(e.Suite, e.Data)
+			}
+		case tls.QUICWriteData:
+			var space numberSpace
+			switch e.Level {
+			case tls.QUICEncryptionLevelInitial:
+				space = initialSpace
+			case tls.QUICEncryptionLevelHandshake:
+				space = handshakeSpace
+			case tls.QUICEncryptionLevelApplication:
+				space = appDataSpace
+			default:
+				return fmt.Errorf("quic: internal error: write handshake data at level %v", e.Level)
+			}
+			c.crypto[space].write(e.Data)
+		case tls.QUICHandshakeDone:
+			if c.side == serverSide {
+				// "[...] the TLS handshake is considered confirmed
+				// at the server when the handshake completes."
+				// https://www.rfc-editor.org/rfc/rfc9001#section-4.1.2-1
+				c.confirmHandshake(now)
+			}
+			c.handshakeDone()
+		case tls.QUICTransportParameters:
+			params, err := unmarshalTransportParams(e.Data)
+			if err != nil {
+				return err
+			}
+			if err := c.receiveTransportParameters(params); err != nil {
+				return err
+			}
+		}
+	}
+}
+
+// handleCrypto processes data received in a CRYPTO frame.
+func (c *Conn) handleCrypto(now time.Time, space numberSpace, off int64, data []byte) error {
+	var level tls.QUICEncryptionLevel
+	switch space {
+	case initialSpace:
+		level = tls.QUICEncryptionLevelInitial
+	case handshakeSpace:
+		level = tls.QUICEncryptionLevelHandshake
+	case appDataSpace:
+		level = tls.QUICEncryptionLevelApplication
+	default:
+		return errors.New("quic: internal error: received CRYPTO frame in unexpected number space")
+	}
+	return c.crypto[space].handleCrypto(off, data, func(b []byte) error {
+		return c.tls.HandleData(level, b)
+	})
+}

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

@@ -0,0 +1,283 @@
+// 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 (
+	"encoding/binary"
+	"net/netip"
+	"time"
+
+	"golang.org/x/net/internal/quic/quicwire"
+)
+
+// transportParameters transferred in the quic_transport_parameters TLS extension.
+// https://www.rfc-editor.org/rfc/rfc9000.html#section-18.2
+type transportParameters struct {
+	originalDstConnID              []byte
+	maxIdleTimeout                 time.Duration
+	statelessResetToken            []byte
+	maxUDPPayloadSize              int64
+	initialMaxData                 int64
+	initialMaxStreamDataBidiLocal  int64
+	initialMaxStreamDataBidiRemote int64
+	initialMaxStreamDataUni        int64
+	initialMaxStreamsBidi          int64
+	initialMaxStreamsUni           int64
+	ackDelayExponent               int8
+	maxAckDelay                    time.Duration
+	disableActiveMigration         bool
+	preferredAddrV4                netip.AddrPort
+	preferredAddrV6                netip.AddrPort
+	preferredAddrConnID            []byte
+	preferredAddrResetToken        []byte
+	activeConnIDLimit              int64
+	initialSrcConnID               []byte
+	retrySrcConnID                 []byte
+}
+
+const (
+	defaultParamMaxUDPPayloadSize       = 65527
+	defaultParamAckDelayExponent        = 3
+	defaultParamMaxAckDelayMilliseconds = 25
+	defaultParamActiveConnIDLimit       = 2
+)
+
+// defaultTransportParameters is initialized to the RFC 9000 default values.
+func defaultTransportParameters() transportParameters {
+	return transportParameters{
+		maxUDPPayloadSize: defaultParamMaxUDPPayloadSize,
+		ackDelayExponent:  defaultParamAckDelayExponent,
+		maxAckDelay:       defaultParamMaxAckDelayMilliseconds * time.Millisecond,
+		activeConnIDLimit: defaultParamActiveConnIDLimit,
+	}
+}
+
+const (
+	paramOriginalDestinationConnectionID = 0x00
+	paramMaxIdleTimeout                  = 0x01
+	paramStatelessResetToken             = 0x02
+	paramMaxUDPPayloadSize               = 0x03
+	paramInitialMaxData                  = 0x04
+	paramInitialMaxStreamDataBidiLocal   = 0x05
+	paramInitialMaxStreamDataBidiRemote  = 0x06
+	paramInitialMaxStreamDataUni         = 0x07
+	paramInitialMaxStreamsBidi           = 0x08
+	paramInitialMaxStreamsUni            = 0x09
+	paramAckDelayExponent                = 0x0a
+	paramMaxAckDelay                     = 0x0b
+	paramDisableActiveMigration          = 0x0c
+	paramPreferredAddress                = 0x0d
+	paramActiveConnectionIDLimit         = 0x0e
+	paramInitialSourceConnectionID       = 0x0f
+	paramRetrySourceConnectionID         = 0x10
+)
+
+func marshalTransportParameters(p transportParameters) []byte {
+	var b []byte
+	if v := p.originalDstConnID; v != nil {
+		b = quicwire.AppendVarint(b, paramOriginalDestinationConnectionID)
+		b = quicwire.AppendVarintBytes(b, v)
+	}
+	if v := uint64(p.maxIdleTimeout / time.Millisecond); v != 0 {
+		b = quicwire.AppendVarint(b, paramMaxIdleTimeout)
+		b = quicwire.AppendVarint(b, uint64(quicwire.SizeVarint(v)))
+		b = quicwire.AppendVarint(b, uint64(v))
+	}
+	if v := p.statelessResetToken; v != nil {
+		b = quicwire.AppendVarint(b, paramStatelessResetToken)
+		b = quicwire.AppendVarintBytes(b, v)
+	}
+	if v := p.maxUDPPayloadSize; v != defaultParamMaxUDPPayloadSize {
+		b = quicwire.AppendVarint(b, paramMaxUDPPayloadSize)
+		b = quicwire.AppendVarint(b, uint64(quicwire.SizeVarint(uint64(v))))
+		b = quicwire.AppendVarint(b, uint64(v))
+	}
+	if v := p.initialMaxData; v != 0 {
+		b = quicwire.AppendVarint(b, paramInitialMaxData)
+		b = quicwire.AppendVarint(b, uint64(quicwire.SizeVarint(uint64(v))))
+		b = quicwire.AppendVarint(b, uint64(v))
+	}
+	if v := p.initialMaxStreamDataBidiLocal; v != 0 {
+		b = quicwire.AppendVarint(b, paramInitialMaxStreamDataBidiLocal)
+		b = quicwire.AppendVarint(b, uint64(quicwire.SizeVarint(uint64(v))))
+		b = quicwire.AppendVarint(b, uint64(v))
+	}
+	if v := p.initialMaxStreamDataBidiRemote; v != 0 {
+		b = quicwire.AppendVarint(b, paramInitialMaxStreamDataBidiRemote)
+		b = quicwire.AppendVarint(b, uint64(quicwire.SizeVarint(uint64(v))))
+		b = quicwire.AppendVarint(b, uint64(v))
+	}
+	if v := p.initialMaxStreamDataUni; v != 0 {
+		b = quicwire.AppendVarint(b, paramInitialMaxStreamDataUni)
+		b = quicwire.AppendVarint(b, uint64(quicwire.SizeVarint(uint64(v))))
+		b = quicwire.AppendVarint(b, uint64(v))
+	}
+	if v := p.initialMaxStreamsBidi; v != 0 {
+		b = quicwire.AppendVarint(b, paramInitialMaxStreamsBidi)
+		b = quicwire.AppendVarint(b, uint64(quicwire.SizeVarint(uint64(v))))
+		b = quicwire.AppendVarint(b, uint64(v))
+	}
+	if v := p.initialMaxStreamsUni; v != 0 {
+		b = quicwire.AppendVarint(b, paramInitialMaxStreamsUni)
+		b = quicwire.AppendVarint(b, uint64(quicwire.SizeVarint(uint64(v))))
+		b = quicwire.AppendVarint(b, uint64(v))
+	}
+	if v := p.ackDelayExponent; v != defaultParamAckDelayExponent {
+		b = quicwire.AppendVarint(b, paramAckDelayExponent)
+		b = quicwire.AppendVarint(b, uint64(quicwire.SizeVarint(uint64(v))))
+		b = quicwire.AppendVarint(b, uint64(v))
+	}
+	if v := uint64(p.maxAckDelay / time.Millisecond); v != defaultParamMaxAckDelayMilliseconds {
+		b = quicwire.AppendVarint(b, paramMaxAckDelay)
+		b = quicwire.AppendVarint(b, uint64(quicwire.SizeVarint(v)))
+		b = quicwire.AppendVarint(b, v)
+	}
+	if p.disableActiveMigration {
+		b = quicwire.AppendVarint(b, paramDisableActiveMigration)
+		b = append(b, 0) // 0-length value
+	}
+	if p.preferredAddrConnID != nil {
+		b = append(b, paramPreferredAddress)
+		b = quicwire.AppendVarint(b, uint64(4+2+16+2+1+len(p.preferredAddrConnID)+16))
+		b = append(b, p.preferredAddrV4.Addr().AsSlice()...)           // 4 bytes
+		b = binary.BigEndian.AppendUint16(b, p.preferredAddrV4.Port()) // 2 bytes
+		b = append(b, p.preferredAddrV6.Addr().AsSlice()...)           // 16 bytes
+		b = binary.BigEndian.AppendUint16(b, p.preferredAddrV6.Port()) // 2 bytes
+		b = quicwire.AppendUint8Bytes(b, p.preferredAddrConnID)        // 1 byte + len(conn_id)
+		b = append(b, p.preferredAddrResetToken...)                    // 16 bytes
+	}
+	if v := p.activeConnIDLimit; v != defaultParamActiveConnIDLimit {
+		b = quicwire.AppendVarint(b, paramActiveConnectionIDLimit)
+		b = quicwire.AppendVarint(b, uint64(quicwire.SizeVarint(uint64(v))))
+		b = quicwire.AppendVarint(b, uint64(v))
+	}
+	if v := p.initialSrcConnID; v != nil {
+		b = quicwire.AppendVarint(b, paramInitialSourceConnectionID)
+		b = quicwire.AppendVarintBytes(b, v)
+	}
+	if v := p.retrySrcConnID; v != nil {
+		b = quicwire.AppendVarint(b, paramRetrySourceConnectionID)
+		b = quicwire.AppendVarintBytes(b, v)
+	}
+	return b
+}
+
+func unmarshalTransportParams(params []byte) (transportParameters, error) {
+	p := defaultTransportParameters()
+	for len(params) > 0 {
+		id, n := quicwire.ConsumeVarint(params)
+		if n < 0 {
+			return p, localTransportError{code: errTransportParameter}
+		}
+		params = params[n:]
+		val, n := quicwire.ConsumeVarintBytes(params)
+		if n < 0 {
+			return p, localTransportError{code: errTransportParameter}
+		}
+		params = params[n:]
+		n = 0
+		switch id {
+		case paramOriginalDestinationConnectionID:
+			p.originalDstConnID = val
+			n = len(val)
+		case paramMaxIdleTimeout:
+			var v uint64
+			v, n = quicwire.ConsumeVarint(val)
+			// If this is unreasonably large, consider it as no timeout to avoid
+			// time.Duration overflows.
+			if v > 1<<32 {
+				v = 0
+			}
+			p.maxIdleTimeout = time.Duration(v) * time.Millisecond
+		case paramStatelessResetToken:
+			if len(val) != 16 {
+				return p, localTransportError{code: errTransportParameter}
+			}
+			p.statelessResetToken = val
+			n = 16
+		case paramMaxUDPPayloadSize:
+			p.maxUDPPayloadSize, n = quicwire.ConsumeVarintInt64(val)
+			if p.maxUDPPayloadSize < 1200 {
+				return p, localTransportError{code: errTransportParameter}
+			}
+		case paramInitialMaxData:
+			p.initialMaxData, n = quicwire.ConsumeVarintInt64(val)
+		case paramInitialMaxStreamDataBidiLocal:
+			p.initialMaxStreamDataBidiLocal, n = quicwire.ConsumeVarintInt64(val)
+		case paramInitialMaxStreamDataBidiRemote:
+			p.initialMaxStreamDataBidiRemote, n = quicwire.ConsumeVarintInt64(val)
+		case paramInitialMaxStreamDataUni:
+			p.initialMaxStreamDataUni, n = quicwire.ConsumeVarintInt64(val)
+		case paramInitialMaxStreamsBidi:
+			p.initialMaxStreamsBidi, n = quicwire.ConsumeVarintInt64(val)
+			if p.initialMaxStreamsBidi > maxStreamsLimit {
+				return p, localTransportError{code: errTransportParameter}
+			}
+		case paramInitialMaxStreamsUni:
+			p.initialMaxStreamsUni, n = quicwire.ConsumeVarintInt64(val)
+			if p.initialMaxStreamsUni > maxStreamsLimit {
+				return p, localTransportError{code: errTransportParameter}
+			}
+		case paramAckDelayExponent:
+			var v uint64
+			v, n = quicwire.ConsumeVarint(val)
+			if v > 20 {
+				return p, localTransportError{code: errTransportParameter}
+			}
+			p.ackDelayExponent = int8(v)
+		case paramMaxAckDelay:
+			var v uint64
+			v, n = quicwire.ConsumeVarint(val)
+			if v >= 1<<14 {
+				return p, localTransportError{code: errTransportParameter}
+			}
+			p.maxAckDelay = time.Duration(v) * time.Millisecond
+		case paramDisableActiveMigration:
+			p.disableActiveMigration = true
+		case paramPreferredAddress:
+			if len(val) < 4+2+16+2+1 {
+				return p, localTransportError{code: errTransportParameter}
+			}
+			p.preferredAddrV4 = netip.AddrPortFrom(
+				netip.AddrFrom4(*(*[4]byte)(val[:4])),
+				binary.BigEndian.Uint16(val[4:][:2]),
+			)
+			val = val[4+2:]
+			p.preferredAddrV6 = netip.AddrPortFrom(
+				netip.AddrFrom16(*(*[16]byte)(val[:16])),
+				binary.BigEndian.Uint16(val[16:][:2]),
+			)
+			val = val[16+2:]
+			var nn int
+			p.preferredAddrConnID, nn = quicwire.ConsumeUint8Bytes(val)
+			if nn < 0 {
+				return p, localTransportError{code: errTransportParameter}
+			}
+			val = val[nn:]
+			if len(val) != 16 {
+				return p, localTransportError{code: errTransportParameter}
+			}
+			p.preferredAddrResetToken = val
+			val = nil
+		case paramActiveConnectionIDLimit:
+			p.activeConnIDLimit, n = quicwire.ConsumeVarintInt64(val)
+			if p.activeConnIDLimit < 2 {
+				return p, localTransportError{code: errTransportParameter}
+			}
+		case paramInitialSourceConnectionID:
+			p.initialSrcConnID = val
+			n = len(val)
+		case paramRetrySourceConnectionID:
+			p.retrySrcConnID = val
+			n = len(val)
+		default:
+			n = len(val)
+		}
+		if n != len(val) {
+			return p, localTransportError{code: errTransportParameter}
+		}
+	}
+	return p, nil
+}

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

@@ -0,0 +1,28 @@
+// 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 "net/netip"
+
+// Per-plaform consts describing support for various features.
+//
+// const udpECNSupport indicates whether the platform supports setting
+// the ECN (Explicit Congestion Notification) IP header bits.
+//
+// const udpInvalidLocalAddrIsError indicates whether sending a packet
+// from an local address not associated with the system is an error.
+// For example, assuming 127.0.0.2 is not a local address, does sending
+// from it (using IP_PKTINFO or some other such feature) result in an error?
+
+// unmapAddrPort returns a with any IPv4-mapped IPv6 address prefix removed.
+func unmapAddrPort(a netip.AddrPort) netip.AddrPort {
+	if a.Addr().Is4In6() {
+		return netip.AddrPortFrom(
+			a.Addr().Unmap(),
+			a.Port(),
+		)
+	}
+	return a
+}

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

@@ -0,0 +1,45 @@
+// 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.
+
+//go:build darwin
+
+package quic
+
+import (
+	"encoding/binary"
+	"syscall"
+)
+
+// These socket options are available on darwin, but are not in the syscall
+// package. Since syscall package is frozen, just define them manually here.
+const (
+	ip_recvtos       = 0x1b
+	ipv6_recvpktinfo = 0x3d
+	ipv6_pktinfo     = 0x2e
+)
+
+// See udp.go.
+const (
+	udpECNSupport              = true
+	udpInvalidLocalAddrIsError = true
+)
+
+// Confusingly, on Darwin the contents of the IP_TOS option differ depending on whether
+// it is used as an inbound or outbound cmsg.
+
+func parseIPTOS(b []byte) (ecnBits, bool) {
+	// Single byte. The low two bits are the ECN field.
+	if len(b) != 1 {
+		return 0, false
+	}
+	return ecnBits(b[0] & ecnMask), true
+}
+
+func appendCmsgECNv4(b []byte, ecn ecnBits) []byte {
+	// 32-bit integer.
+	// https://github.com/apple/darwin-xnu/blob/2ff845c2e033bd0ff64b5b6aa6063a1f8f65aa32/bsd/netinet/in_tclass.c#L1062-L1073
+	b, data := appendCmsg(b, syscall.IPPROTO_IP, syscall.IP_TOS, 4)
+	binary.NativeEndian.PutUint32(data, uint32(ecn))
+	return b
+}

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

@@ -0,0 +1,39 @@
+// 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.
+
+//go:build linux
+
+package quic
+
+import (
+	"syscall"
+)
+
+const (
+	ip_recvtos       = syscall.IP_RECVTOS
+	ipv6_recvpktinfo = syscall.IPV6_RECVPKTINFO
+	ipv6_pktinfo     = syscall.IPV6_PKTINFO
+)
+
+// See udp.go.
+const (
+	udpECNSupport              = true
+	udpInvalidLocalAddrIsError = false
+)
+
+// The IP_TOS socket option is a single byte containing the IP TOS field.
+// The low two bits are the ECN field.
+
+func parseIPTOS(b []byte) (ecnBits, bool) {
+	if len(b) != 1 {
+		return 0, false
+	}
+	return ecnBits(b[0] & ecnMask), true
+}
+
+func appendCmsgECNv4(b []byte, ecn ecnBits) []byte {
+	b, data := appendCmsg(b, syscall.IPPROTO_IP, syscall.IP_TOS, 1)
+	data[0] = byte(ecn)
+	return b
+}