@ttsc/win32-arm64 0.33.0 → 0.34.0

package/bin/go/src/vendor/golang.org/x/net/internal/http3/settings.go

@@ -0,0 +1,66 @@
+// Copyright 2025 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 http3
+
+const (
+	// https://www.rfc-editor.org/rfc/rfc9114.html#section-7.2.4.1
+	settingsMaxFieldSectionSize = 0x06
+
+	// https://www.rfc-editor.org/rfc/rfc9204.html#section-5
+	settingsQPACKMaxTableCapacity = 0x01
+	settingsQPACKBlockedStreams   = 0x07
+)
+
+// writeSettings writes a complete SETTINGS frame.
+// Its parameter is a list of alternating setting types and values.
+func (st *stream) writeSettings(settings ...int64) {
+	var size int64
+	for _, s := range settings {
+		// Settings values that don't fit in a QUIC varint ([0,2^62)) will panic here.
+		size += int64(sizeVarint(uint64(s)))
+	}
+	st.writeVarint(int64(frameTypeSettings))
+	st.writeVarint(size)
+	for _, s := range settings {
+		st.writeVarint(s)
+	}
+}
+
+// readSettings reads a complete SETTINGS frame, including the frame header.
+func (st *stream) readSettings(f func(settingType, value int64) error) error {
+	frameType, err := st.readFrameHeader()
+	if err != nil || frameType != frameTypeSettings {
+		return &connectionError{
+			code:    errH3MissingSettings,
+			message: "settings not sent on control stream",
+		}
+	}
+	for st.lim > 0 {
+		settingsType, err := st.readVarint()
+		if err != nil {
+			return err
+		}
+		settingsValue, err := st.readVarint()
+		if err != nil {
+			return err
+		}
+
+		// Use of HTTP/2 settings where there is no corresponding HTTP/3 setting
+		// is an error.
+		// https://www.rfc-editor.org/rfc/rfc9114.html#section-7.2.4.1-5
+		switch settingsType {
+		case 0x02, 0x03, 0x04, 0x05:
+			return &connectionError{
+				code:    errH3SettingsError,
+				message: "use of reserved setting",
+			}
+		}
+
+		if err := f(settingsType, settingsValue); err != nil {
+			return err
+		}
+	}
+	return st.endFrame()
+}

package/bin/go/src/vendor/golang.org/x/net/internal/http3/stream.go

@@ -0,0 +1,260 @@
+// Copyright 2025 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 http3
+
+import (
+	"context"
+	"io"
+
+	"golang.org/x/net/quic"
+)
+
+// A stream wraps a QUIC stream, providing methods to read/write various values.
+type stream struct {
+	stream *quic.Stream
+
+	// lim is the current read limit.
+	// Reading a frame header sets the limit to the end of the frame.
+	// Reading past the limit or reading less than the limit and ending the frame
+	// results in an error.
+	// -1 indicates no limit.
+	lim int64
+}
+
+// newConnStream creates a new stream on a connection.
+// It writes the stream header for unidirectional streams.
+//
+// The stream returned by newStream is not flushed,
+// and will not be sent to the peer until the caller calls
+// Flush or writes enough data to the stream.
+func newConnStream(ctx context.Context, qconn *quic.Conn, stype streamType) (*stream, error) {
+	var qs *quic.Stream
+	var err error
+	if stype == streamTypeRequest {
+		// Request streams are bidirectional.
+		qs, err = qconn.NewStream(ctx)
+	} else {
+		// All other streams are unidirectional.
+		qs, err = qconn.NewSendOnlyStream(ctx)
+	}
+	if err != nil {
+		return nil, err
+	}
+	st := &stream{
+		stream: qs,
+		lim:    -1, // no limit
+	}
+	if stype != streamTypeRequest {
+		// Unidirectional stream header.
+		st.writeVarint(int64(stype))
+	}
+	return st, err
+}
+
+func newStream(qs *quic.Stream) *stream {
+	return &stream{
+		stream: qs,
+		lim:    -1, // no limit
+	}
+}
+
+// readFrameHeader reads the type and length fields of an HTTP/3 frame.
+// It sets the read limit to the end of the frame.
+//
+// https://www.rfc-editor.org/rfc/rfc9114.html#section-7.1
+func (st *stream) readFrameHeader() (ftype frameType, err error) {
+	if st.lim >= 0 {
+		// We shouldn't call readFrameHeader before ending the previous frame.
+		return 0, errH3FrameError
+	}
+	ftype, err = readVarint[frameType](st)
+	if err != nil {
+		return 0, err
+	}
+	size, err := st.readVarint()
+	if err != nil {
+		return 0, err
+	}
+	st.lim = size
+	return ftype, nil
+}
+
+// endFrame is called after reading a frame to reset the read limit.
+// It returns an error if the entire contents of a frame have not been read.
+func (st *stream) endFrame() error {
+	if st.lim != 0 {
+		return &connectionError{
+			code:    errH3FrameError,
+			message: "invalid HTTP/3 frame",
+		}
+	}
+	st.lim = -1
+	return nil
+}
+
+// readFrameData returns the remaining data in the current frame.
+func (st *stream) readFrameData() ([]byte, error) {
+	if st.lim < 0 {
+		return nil, errH3FrameError
+	}
+	// TODO: Pool buffers to avoid allocation here.
+	b := make([]byte, st.lim)
+	_, err := io.ReadFull(st, b)
+	if err != nil {
+		return nil, err
+	}
+	return b, nil
+}
+
+// ReadByte reads one byte from the stream.
+func (st *stream) ReadByte() (b byte, err error) {
+	if err := st.recordBytesRead(1); err != nil {
+		return 0, err
+	}
+	b, err = st.stream.ReadByte()
+	if err != nil {
+		if err == io.EOF && st.lim < 0 {
+			return 0, io.EOF
+		}
+		return 0, errH3FrameError
+	}
+	return b, nil
+}
+
+// Read reads from the stream.
+func (st *stream) Read(b []byte) (int, error) {
+	n, err := st.stream.Read(b)
+	if e2 := st.recordBytesRead(n); e2 != nil {
+		return 0, e2
+	}
+	if err == io.EOF {
+		if st.lim == 0 {
+			// EOF at end of frame, ignore.
+			return n, nil
+		} else if st.lim > 0 {
+			// EOF inside frame, error.
+			return 0, errH3FrameError
+		} else {
+			// EOF outside of frame, surface to caller.
+			return n, io.EOF
+		}
+	}
+	if err != nil {
+		return 0, errH3FrameError
+	}
+	return n, nil
+}
+
+// discardUnknownFrame discards an unknown frame.
+//
+// HTTP/3 requires that unknown frames be ignored on all streams.
+// However, a known frame appearing in an unexpected place is a fatal error,
+// so this returns an error if the frame is one we know.
+func (st *stream) discardUnknownFrame(ftype frameType) error {
+	switch ftype {
+	case frameTypeData,
+		frameTypeHeaders,
+		frameTypeCancelPush,
+		frameTypeSettings,
+		frameTypePushPromise,
+		frameTypeGoaway,
+		frameTypeMaxPushID:
+		return &connectionError{
+			code:    errH3FrameUnexpected,
+			message: "unexpected " + ftype.String() + " frame",
+		}
+	}
+	return st.discardFrame()
+}
+
+// discardFrame discards any remaining data in the current frame and resets the read limit.
+func (st *stream) discardFrame() error {
+	// TODO: Consider adding a *quic.Stream method to discard some amount of data.
+	for range st.lim {
+		_, err := st.stream.ReadByte()
+		if err != nil {
+			return &streamError{errH3FrameError, err.Error()}
+		}
+	}
+	st.lim = -1
+	return nil
+}
+
+// Write writes to the stream.
+func (st *stream) Write(b []byte) (int, error) { return st.stream.Write(b) }
+
+// Flush commits data written to the stream.
+func (st *stream) Flush() error { return st.stream.Flush() }
+
+// readVarint reads a QUIC variable-length integer from the stream.
+func (st *stream) readVarint() (v int64, err error) {
+	b, err := st.stream.ReadByte()
+	if err != nil {
+		return 0, err
+	}
+	v = int64(b & 0x3f)
+	n := 1 << (b >> 6)
+	for i := 1; i < n; i++ {
+		b, err := st.stream.ReadByte()
+		if err != nil {
+			return 0, errH3FrameError
+		}
+		v = (v << 8) | int64(b)
+	}
+	if err := st.recordBytesRead(n); err != nil {
+		return 0, err
+	}
+	return v, nil
+}
+
+// readVarint reads a varint of a particular type.
+func readVarint[T ~int64 | ~uint64](st *stream) (T, error) {
+	v, err := st.readVarint()
+	return T(v), err
+}
+
+// writeVarint writes a QUIC variable-length integer to the stream.
+func (st *stream) writeVarint(v int64) {
+	switch {
+	case v <= (1<<6)-1:
+		st.stream.WriteByte(byte(v))
+	case v <= (1<<14)-1:
+		st.stream.WriteByte((1 << 6) | byte(v>>8))
+		st.stream.WriteByte(byte(v))
+	case v <= (1<<30)-1:
+		st.stream.WriteByte((2 << 6) | byte(v>>24))
+		st.stream.WriteByte(byte(v >> 16))
+		st.stream.WriteByte(byte(v >> 8))
+		st.stream.WriteByte(byte(v))
+	case v <= (1<<62)-1:
+		st.stream.WriteByte((3 << 6) | byte(v>>56))
+		st.stream.WriteByte(byte(v >> 48))
+		st.stream.WriteByte(byte(v >> 40))
+		st.stream.WriteByte(byte(v >> 32))
+		st.stream.WriteByte(byte(v >> 24))
+		st.stream.WriteByte(byte(v >> 16))
+		st.stream.WriteByte(byte(v >> 8))
+		st.stream.WriteByte(byte(v))
+	default:
+		panic("varint too large")
+	}
+}
+
+// recordBytesRead records that n bytes have been read.
+// It returns an error if the read passes the current limit.
+func (st *stream) recordBytesRead(n int) error {
+	if st.lim < 0 {
+		return nil
+	}
+	st.lim -= int64(n)
+	if st.lim < 0 {
+		st.stream = nil // panic if we try to read again
+		return &connectionError{
+			code:    errH3FrameError,
+			message: "invalid HTTP/3 frame",
+		}
+	}
+	return nil
+}

package/bin/go/src/vendor/golang.org/x/net/internal/http3/transport.go

@@ -0,0 +1,333 @@
+// Copyright 2025 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 http3
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"net/url"
+	"sync"
+
+	"golang.org/x/net/quic"
+)
+
+// A transport is an HTTP/3 transport.
+//
+// It does not manage a pool of connections,
+// and therefore does not implement net/http.RoundTripper.
+//
+// TODO: Provide a way to register an HTTP/3 transport with a net/http.transport's
+// connection pool.
+type transport struct {
+	// config is the QUIC configuration used for client connections.
+	config *quic.Config
+
+	listenQUIC func(addr string, config *quic.Config) (*quic.Endpoint, error)
+
+	mu sync.Mutex // Guards fields below.
+	// endpoint is the QUIC endpoint used by connections created by the
+	// transport. If CloseIdleConnections is called when activeConns is empty,
+	// endpoint will be unset. If unset, endpoint will be initialized by any
+	// call to dial.
+	endpoint      *quic.Endpoint
+	activeConns   map[*clientConn]struct{}
+	inFlightDials int
+}
+
+// netHTTPTransport implements the net/http.dialClientConner interface,
+// allowing our HTTP/3 transport to integrate with net/http.
+type netHTTPTransport struct {
+	*transport
+}
+
+// RoundTrip is defined since Transport.RegisterProtocol takes in a
+// RoundTripper. However, this method will never be used as net/http's
+// dialClientConner interface does not have a RoundTrip method and will only
+// use DialClientConn to create a new RoundTripper.
+func (t netHTTPTransport) RoundTrip(*http.Request) (*http.Response, error) {
+	panic("netHTTPTransport.RoundTrip should never be called")
+}
+
+func (t netHTTPTransport) DialClientConn(ctx context.Context, addr string, _ *url.URL, _ func()) (http.RoundTripper, error) {
+	return t.transport.dial(ctx, addr)
+}
+
+type TransportOpts struct {
+	// ListenQUIC determines how the transport will open a QUIC endpoint.
+	// By default, quic.Listen("udp", addr, config) is used.
+	// ListenQUIC might be called multiple times.
+	ListenQUIC func(addr string, config *quic.Config) (*quic.Endpoint, error)
+
+	// QUICConfig is the QUIC configuration used by the transport.
+	// QUICConfig may be nil and should not be modified after calling
+	// RegisterTransport.
+	// If QUICConfig.TLSConfig is nil, the TLSConfig of the net/http Transport
+	// given to RegisterTransport will be used.
+	QUICConfig *quic.Config
+}
+
+// RegisterTransport configures a net/http HTTP/1 Transport to use HTTP/3.
+func RegisterTransport(tr *http.Transport, opts TransportOpts) {
+	if opts.QUICConfig == nil {
+		opts.QUICConfig = &quic.Config{}
+	}
+	if opts.QUICConfig.TLSConfig == nil {
+		opts.QUICConfig.TLSConfig = tr.TLSClientConfig
+	}
+	if opts.ListenQUIC == nil {
+		opts.ListenQUIC = func(addr string, config *quic.Config) (*quic.Endpoint, error) {
+			return quic.Listen("udp", addr, config)
+		}
+	}
+	tr3 := &transport{
+		// initConfig will clone the tr.TLSClientConfig.
+		config:      initConfig(opts.QUICConfig),
+		listenQUIC:  opts.ListenQUIC,
+		activeConns: make(map[*clientConn]struct{}),
+	}
+	tr.RegisterProtocol("http/3", netHTTPTransport{tr3})
+}
+
+func (tr *transport) incInFlightDials() {
+	tr.mu.Lock()
+	defer tr.mu.Unlock()
+	tr.inFlightDials++
+}
+
+func (tr *transport) decInFlightDials() {
+	tr.mu.Lock()
+	defer tr.mu.Unlock()
+	tr.inFlightDials--
+}
+
+func (tr *transport) initEndpoint() (err error) {
+	tr.mu.Lock()
+	defer tr.mu.Unlock()
+	// This might cause rare issues on Darwin. Unlike Linux, Darwin kernel
+	// seems to have the following behaviors:
+	// - After closing a UDP socket, the port that was bound to the socket
+	//   might not be immediately usable again.
+	// - When doing IPv6 dual-stack binding (e.g., bind to ":0"), it will
+	//   happily bind the IPv6 port, even when the IPv4 port is unavailable.
+	//
+	// When both of these are combined, in practice, it is possible for the
+	// following to happen:
+	// 1. Transport binds ":0", creating a dual-stack IPv6 UDP socket.
+	//    Everything works as expected.
+	// 2. At some point, CloseIdleConnections is called and the socket is
+	//    closed.
+	// 3. Soon after, a new dial is started, and a new dual-stack IPv6 socket
+	//    is coincidentally assigned the same port as the previous socket.
+	// 4. If the IPv4 port is still unavailable, Darwin's permissive binding
+	//    behavior will cause us to have a socket that silently is unable to
+	//    receive packets on its IPv4 address.
+	// 5. If the dial target is an IPv4 address, transport will be able to send
+	//    packets to the target, but will be unable to receive its reply.
+	//
+	// TransportOpts.ListenQUIC can technically be configured to avoid
+	// dual-stack binding to avoid this issue, and high socket churn is
+	// probably uncommon for regular use cases. However, finding a workaround
+	// for this eventually would be ideal.
+	if tr.endpoint == nil {
+		tr.endpoint, err = tr.listenQUIC(":0", tr.config)
+	}
+	return err
+}
+
+// dial creates a new HTTP/3 client connection.
+func (tr *transport) dial(ctx context.Context, target string) (*clientConn, error) {
+	tr.incInFlightDials()
+	defer tr.decInFlightDials()
+
+	if err := tr.initEndpoint(); err != nil {
+		return nil, err
+	}
+	qconn, err := tr.endpoint.Dial(ctx, "udp", target, tr.config)
+	if err != nil {
+		return nil, err
+	}
+	return tr.newClientConn(ctx, qconn)
+}
+
+// CloseIdleConnections is called by net/http.Transport.CloseIdleConnections
+// after all existing idle connections are closed using http3.clientConn.Close.
+//
+// When the transport has no active connections anymore, calling this method
+// will make the transport clean up any shared resources that are no longer
+// required, such as its QUIC endpoint.
+func (tr *transport) CloseIdleConnections() {
+	tr.mu.Lock()
+	defer tr.mu.Unlock()
+	if tr.endpoint == nil || len(tr.activeConns) > 0 || tr.inFlightDials > 0 {
+		return
+	}
+	tr.endpoint.Close(canceledCtx)
+	tr.endpoint = nil
+}
+
+// A clientConn is a client HTTP/3 connection.
+//
+// Multiple goroutines may invoke methods on a clientConn simultaneously.
+type clientConn struct {
+	qconn *quic.Conn
+	genericConn
+
+	enc qpackEncoder
+	dec qpackDecoder
+}
+
+func (tr *transport) registerConn(cc *clientConn) {
+	tr.mu.Lock()
+	defer tr.mu.Unlock()
+	tr.activeConns[cc] = struct{}{}
+}
+
+func (tr *transport) unregisterConn(cc *clientConn) {
+	tr.mu.Lock()
+	defer tr.mu.Unlock()
+	delete(tr.activeConns, cc)
+}
+
+func (tr *transport) newClientConn(ctx context.Context, qconn *quic.Conn) (*clientConn, error) {
+	cc := &clientConn{
+		qconn: qconn,
+	}
+	tr.registerConn(cc)
+	cc.enc.init()
+
+	// Create control stream and send SETTINGS frame.
+	controlStream, err := newConnStream(ctx, cc.qconn, streamTypeControl)
+	if err != nil {
+		tr.unregisterConn(cc)
+		return nil, fmt.Errorf("http3: cannot create control stream: %v", err)
+	}
+	controlStream.writeSettings()
+	controlStream.Flush()
+
+	go func() {
+		cc.acceptStreams(qconn, cc)
+		tr.unregisterConn(cc)
+	}()
+	return cc, nil
+}
+
+// TODO: implement the rest of net/http.ClientConn methods beyond Close.
+func (cc *clientConn) Close() error {
+	// We need to use Close rather than Abort on the QUIC connection.
+	// Otherwise, when a net/http.Transport.CloseIdleConnections is called, it
+	// might call the http3.transport.CloseIdleConnections prior to all idle
+	// connections being fully closed; this would make it unable to close its
+	// QUIC endpoint, making http3.transport.CloseIdleConnections a no-op
+	// unintentionally.
+	return cc.qconn.Close()
+}
+
+func (cc *clientConn) Err() error {
+	return nil
+}
+
+func (cc *clientConn) Reserve() error {
+	return nil
+}
+
+func (cc *clientConn) Release() {
+}
+
+func (cc *clientConn) Available() int {
+	return 0
+}
+
+func (cc *clientConn) InFlight() int {
+	return 0
+}
+
+func (cc *clientConn) handleControlStream(st *stream) error {
+	// "A SETTINGS frame MUST be sent as the first frame of each control stream [...]"
+	// https://www.rfc-editor.org/rfc/rfc9114.html#section-7.2.4-2
+	if err := st.readSettings(func(settingsType, settingsValue int64) error {
+		switch settingsType {
+		case settingsMaxFieldSectionSize:
+			_ = settingsValue // TODO
+		case settingsQPACKMaxTableCapacity:
+			_ = settingsValue // TODO
+		case settingsQPACKBlockedStreams:
+			_ = settingsValue // TODO
+		default:
+			// Unknown settings types are ignored.
+		}
+		return nil
+	}); err != nil {
+		return err
+	}
+
+	for {
+		ftype, err := st.readFrameHeader()
+		if err != nil {
+			return err
+		}
+		switch ftype {
+		case frameTypeCancelPush:
+			// "If a CANCEL_PUSH frame is received that references a push ID
+			// greater than currently allowed on the connection,
+			// this MUST be treated as a connection error of type H3_ID_ERROR."
+			// https://www.rfc-editor.org/rfc/rfc9114.html#section-7.2.3-7
+			return &connectionError{
+				code:    errH3IDError,
+				message: "CANCEL_PUSH received when no MAX_PUSH_ID has been sent",
+			}
+		case frameTypeGoaway:
+			// TODO: Wait for requests to complete before closing connection.
+			return errH3NoError
+		default:
+			// Unknown frames are ignored.
+			if err := st.discardUnknownFrame(ftype); err != nil {
+				return err
+			}
+		}
+	}
+}
+
+func (cc *clientConn) handleEncoderStream(*stream) error {
+	// TODO
+	return nil
+}
+
+func (cc *clientConn) handleDecoderStream(*stream) error {
+	// TODO
+	return nil
+}
+
+func (cc *clientConn) handlePushStream(*stream) error {
+	// "A client MUST treat receipt of a push stream as a connection error
+	// of type H3_ID_ERROR when no MAX_PUSH_ID frame has been sent [...]"
+	// https://www.rfc-editor.org/rfc/rfc9114.html#section-4.6-3
+	return &connectionError{
+		code:    errH3IDError,
+		message: "push stream created when no MAX_PUSH_ID has been sent",
+	}
+}
+
+func (cc *clientConn) handleRequestStream(st *stream) error {
+	// "Clients MUST treat receipt of a server-initiated bidirectional
+	// stream as a connection error of type H3_STREAM_CREATION_ERROR [...]"
+	// https://www.rfc-editor.org/rfc/rfc9114.html#section-6.1-3
+	return &connectionError{
+		code:    errH3StreamCreationError,
+		message: "server created bidirectional stream",
+	}
+}
+
+// abort closes the connection with an error.
+func (cc *clientConn) abort(err error) {
+	if e, ok := err.(*connectionError); ok {
+		cc.qconn.Abort(&quic.ApplicationError{
+			Code:   uint64(e.code),
+			Reason: e.message,
+		})
+	} else {
+		cc.qconn.Abort(err)
+	}
+}

package/bin/go/src/vendor/golang.org/x/net/internal/http3/varint.go

@@ -0,0 +1,23 @@
+// Copyright 2026 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 http3
+
+// sizeVarint returns the size of the variable-length integer encoding of f.
+// Copied from internal/quic/quicwire to break dependency that makes bundling
+// into std more complicated.
+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")
+	}
+}