@ttsc/win32-arm64 0.33.0 → 0.34.0

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

@@ -0,0 +1,173 @@
+// 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"
+)
+
+// A pipe is a byte buffer used in implementing streams.
+//
+// A pipe contains a window of stream data.
+// Random access reads and writes are supported within the window.
+// Writing past the end of the window extends it.
+// Data may be discarded from the start of the pipe, advancing the window.
+type pipe struct {
+	start int64    // stream position of first stored byte
+	end   int64    // stream position just past the last stored byte
+	head  *pipebuf // if non-nil, then head.off + len(head.b) > start
+	tail  *pipebuf // if non-nil, then tail.off + len(tail.b) == end
+}
+
+type pipebuf struct {
+	off  int64 // stream position of b[0]
+	b    []byte
+	next *pipebuf
+}
+
+func (pb *pipebuf) end() int64 {
+	return pb.off + int64(len(pb.b))
+}
+
+var pipebufPool = sync.Pool{
+	New: func() any {
+		return &pipebuf{
+			b: make([]byte, 4096),
+		}
+	},
+}
+
+func newPipebuf() *pipebuf {
+	return pipebufPool.Get().(*pipebuf)
+}
+
+func (b *pipebuf) recycle() {
+	b.off = 0
+	b.next = nil
+	pipebufPool.Put(b)
+}
+
+// writeAt writes len(b) bytes to the pipe at offset off.
+//
+// Writes to offsets before p.start are discarded.
+// Writes to offsets after p.end extend the pipe window.
+func (p *pipe) writeAt(b []byte, off int64) {
+	end := off + int64(len(b))
+	if end > p.end {
+		p.end = end
+	} else if end <= p.start {
+		return
+	}
+
+	if off < p.start {
+		// Discard the portion of b which falls before p.start.
+		trim := p.start - off
+		b = b[trim:]
+		off = p.start
+	}
+
+	if p.head == nil {
+		p.head = newPipebuf()
+		p.head.off = p.start
+		p.tail = p.head
+	}
+	pb := p.head
+	if off >= p.tail.off {
+		// Common case: Writing past the end of the pipe.
+		pb = p.tail
+	}
+	for {
+		pboff := off - pb.off
+		if pboff < int64(len(pb.b)) {
+			n := copy(pb.b[pboff:], b)
+			if n == len(b) {
+				return
+			}
+			off += int64(n)
+			b = b[n:]
+		}
+		if pb.next == nil {
+			pb.next = newPipebuf()
+			pb.next.off = pb.off + int64(len(pb.b))
+			p.tail = pb.next
+		}
+		pb = pb.next
+	}
+}
+
+// copy copies len(b) bytes into b starting from off.
+// The pipe must contain [off, off+len(b)).
+func (p *pipe) copy(off int64, b []byte) {
+	dst := b[:0]
+	p.read(off, len(b), func(c []byte) error {
+		dst = append(dst, c...)
+		return nil
+	})
+}
+
+// read calls f with the data in [off, off+n)
+// The data may be provided sequentially across multiple calls to f.
+// Note that read (unlike an io.Reader) does not consume the read data.
+func (p *pipe) read(off int64, n int, f func([]byte) error) error {
+	if off < p.start {
+		panic("invalid read range")
+	}
+	for pb := p.head; pb != nil && n > 0; pb = pb.next {
+		if off >= pb.end() {
+			continue
+		}
+		b := pb.b[off-pb.off:]
+		if len(b) > n {
+			b = b[:n]
+		}
+		off += int64(len(b))
+		n -= len(b)
+		if err := f(b); err != nil {
+			return err
+		}
+	}
+	if n > 0 {
+		panic("invalid read range")
+	}
+	return nil
+}
+
+// peek returns a reference to up to n bytes of internal data buffer, starting at p.start.
+// The returned slice is valid until the next call to discardBefore.
+// The length of the returned slice will be in the range [0,n].
+func (p *pipe) peek(n int64) []byte {
+	pb := p.head
+	if pb == nil {
+		return nil
+	}
+	b := pb.b[p.start-pb.off:]
+	return b[:min(int64(len(b)), n)]
+}
+
+// availableBuffer returns the available contiguous, allocated buffer space
+// following the pipe window.
+//
+// This is used by the stream write fast path, which makes multiple writes into the pipe buffer
+// without a lock, and then adjusts p.end at a later time with a lock held.
+func (p *pipe) availableBuffer() []byte {
+	if p.tail == nil {
+		return nil
+	}
+	return p.tail.b[p.end-p.tail.off:]
+}
+
+// discardBefore discards all data prior to off.
+func (p *pipe) discardBefore(off int64) {
+	for p.head != nil && p.head.end() < off {
+		head := p.head
+		p.head = p.head.next
+		head.recycle()
+	}
+	if p.head == nil {
+		p.tail = nil
+	}
+	p.start = off
+	p.end = max(p.end, off)
+}

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

@@ -0,0 +1,272 @@
+// 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"
+	"encoding/hex"
+	"log/slog"
+	"net/netip"
+	"time"
+)
+
+// Log levels for qlog events.
+const (
+	// QLogLevelFrame includes per-frame information.
+	// When this level is enabled, packet_sent and packet_received events will
+	// contain information on individual frames sent/received.
+	QLogLevelFrame = slog.Level(-6)
+
+	// QLogLevelPacket events occur at most once per packet sent or received.
+	//
+	// For example: packet_sent, packet_received.
+	QLogLevelPacket = slog.Level(-4)
+
+	// QLogLevelConn events occur multiple times over a connection's lifetime,
+	// but less often than the frequency of individual packets.
+	//
+	// For example: connection_state_updated.
+	QLogLevelConn = slog.Level(-2)
+
+	// QLogLevelEndpoint events occur at most once per connection.
+	//
+	// For example: connection_started, connection_closed.
+	QLogLevelEndpoint = slog.Level(0)
+)
+
+func (c *Conn) logEnabled(level slog.Level) bool {
+	return logEnabled(c.log, level)
+}
+
+func logEnabled(log *slog.Logger, level slog.Level) bool {
+	return log != nil && log.Enabled(context.Background(), level)
+}
+
+// slogHexstring returns a slog.Attr for a value of the hexstring type.
+//
+// https://www.ietf.org/archive/id/draft-ietf-quic-qlog-main-schema-04.html#section-1.1.1
+func slogHexstring(key string, value []byte) slog.Attr {
+	return slog.String(key, hex.EncodeToString(value))
+}
+
+func slogAddr(key string, value netip.Addr) slog.Attr {
+	return slog.String(key, value.String())
+}
+
+func (c *Conn) logConnectionStarted(originalDstConnID []byte, peerAddr netip.AddrPort) {
+	if c.config.QLogLogger == nil ||
+		!c.config.QLogLogger.Enabled(context.Background(), QLogLevelEndpoint) {
+		return
+	}
+	var vantage string
+	if c.side == clientSide {
+		vantage = "client"
+		originalDstConnID = c.connIDState.originalDstConnID
+	} else {
+		vantage = "server"
+	}
+	// A qlog Trace container includes some metadata (title, description, vantage_point)
+	// and a list of Events. The Trace also includes a common_fields field setting field
+	// values common to all events in the trace.
+	//
+	//	Trace = {
+	//	    ? title: text
+	//	    ? description: text
+	//	    ? configuration: Configuration
+	//	    ? common_fields: CommonFields
+	//	    ? vantage_point: VantagePoint
+	//	    events: [* Event]
+	//	}
+	//
+	// To map this into slog's data model, we start each per-connection trace with a With
+	// call that includes both the trace metadata and the common fields.
+	//
+	// This means that in slog's model, each trace event will also include
+	// the Trace metadata fields (vantage_point), which is a divergence from the qlog model.
+	c.log = c.config.QLogLogger.With(
+		// The group_id permits associating traces taken from different vantage points
+		// for the same connection.
+		//
+		// We use the original destination connection ID as the group ID.
+		//
+		// https://www.ietf.org/archive/id/draft-ietf-quic-qlog-main-schema-04.html#section-3.4.6
+		slogHexstring("group_id", originalDstConnID),
+		slog.Group("vantage_point",
+			slog.String("name", "go quic"),
+			slog.String("type", vantage),
+		),
+	)
+	localAddr := c.endpoint.LocalAddr()
+	// https://www.ietf.org/archive/id/draft-ietf-quic-qlog-quic-events-03.html#section-4.2
+	c.log.LogAttrs(context.Background(), QLogLevelEndpoint,
+		"connectivity:connection_started",
+		slogAddr("src_ip", localAddr.Addr()),
+		slog.Int("src_port", int(localAddr.Port())),
+		slogHexstring("src_cid", c.connIDState.local[0].cid),
+		slogAddr("dst_ip", peerAddr.Addr()),
+		slog.Int("dst_port", int(peerAddr.Port())),
+		slogHexstring("dst_cid", c.connIDState.remote[0].cid),
+	)
+}
+
+func (c *Conn) logConnectionClosed() {
+	if !c.logEnabled(QLogLevelEndpoint) {
+		return
+	}
+	err := c.lifetime.finalErr
+	trigger := "error"
+	switch e := err.(type) {
+	case *ApplicationError:
+		// TODO: Distinguish between peer and locally-initiated close.
+		trigger = "application"
+	case localTransportError:
+		switch err {
+		case errHandshakeTimeout:
+			trigger = "handshake_timeout"
+		default:
+			if e.code == errNo {
+				trigger = "clean"
+			}
+		}
+	case peerTransportError:
+		if e.code == errNo {
+			trigger = "clean"
+		}
+	default:
+		switch err {
+		case errIdleTimeout:
+			trigger = "idle_timeout"
+		case errStatelessReset:
+			trigger = "stateless_reset"
+		}
+	}
+	// https://www.ietf.org/archive/id/draft-ietf-quic-qlog-quic-events-03.html#section-4.3
+	c.log.LogAttrs(context.Background(), QLogLevelEndpoint,
+		"connectivity:connection_closed",
+		slog.String("trigger", trigger),
+	)
+}
+
+func (c *Conn) logPacketDropped(dgram *datagram) {
+	c.log.LogAttrs(context.Background(), QLogLevelPacket,
+		"connectivity:packet_dropped",
+	)
+}
+
+func (c *Conn) logLongPacketReceived(p longPacket, pkt []byte) {
+	var frames slog.Attr
+	if c.logEnabled(QLogLevelFrame) {
+		frames = c.packetFramesAttr(p.payload)
+	}
+	c.log.LogAttrs(context.Background(), QLogLevelPacket,
+		"transport:packet_received",
+		slog.Group("header",
+			slog.String("packet_type", p.ptype.qlogString()),
+			slog.Uint64("packet_number", uint64(p.num)),
+			slog.Uint64("flags", uint64(pkt[0])),
+			slogHexstring("scid", p.srcConnID),
+			slogHexstring("dcid", p.dstConnID),
+		),
+		slog.Group("raw",
+			slog.Int("length", len(pkt)),
+		),
+		frames,
+	)
+}
+
+func (c *Conn) log1RTTPacketReceived(p shortPacket, pkt []byte) {
+	var frames slog.Attr
+	if c.logEnabled(QLogLevelFrame) {
+		frames = c.packetFramesAttr(p.payload)
+	}
+	dstConnID, _ := dstConnIDForDatagram(pkt)
+	c.log.LogAttrs(context.Background(), QLogLevelPacket,
+		"transport:packet_received",
+		slog.Group("header",
+			slog.String("packet_type", packetType1RTT.qlogString()),
+			slog.Uint64("packet_number", uint64(p.num)),
+			slog.Uint64("flags", uint64(pkt[0])),
+			slogHexstring("dcid", dstConnID),
+		),
+		slog.Group("raw",
+			slog.Int("length", len(pkt)),
+		),
+		frames,
+	)
+}
+
+func (c *Conn) logPacketSent(ptype packetType, pnum packetNumber, src, dst []byte, pktLen int, payload []byte) {
+	var frames slog.Attr
+	if c.logEnabled(QLogLevelFrame) {
+		frames = c.packetFramesAttr(payload)
+	}
+	var scid slog.Attr
+	if len(src) > 0 {
+		scid = slogHexstring("scid", src)
+	}
+	c.log.LogAttrs(context.Background(), QLogLevelPacket,
+		"transport:packet_sent",
+		slog.Group("header",
+			slog.String("packet_type", ptype.qlogString()),
+			slog.Uint64("packet_number", uint64(pnum)),
+			scid,
+			slogHexstring("dcid", dst),
+		),
+		slog.Group("raw",
+			slog.Int("length", pktLen),
+		),
+		frames,
+	)
+}
+
+// packetFramesAttr returns the "frames" attribute containing the frames in a packet.
+// We currently pass this as a slog Any containing a []slog.Value,
+// where each Value is a debugFrame that implements slog.LogValuer.
+//
+// This isn't tremendously efficient, but avoids the need to put a JSON encoder
+// in the quic package or a frame parser in the qlog package.
+func (c *Conn) packetFramesAttr(payload []byte) slog.Attr {
+	var frames []slog.Value
+	for len(payload) > 0 {
+		f, n := parseDebugFrame(payload)
+		if n < 0 {
+			break
+		}
+		payload = payload[n:]
+		switch f := f.(type) {
+		case debugFrameAck:
+			// The qlog ACK frame contains the ACK Delay field as a duration.
+			// Interpreting the contents of this field as a duration requires
+			// knowing the peer's ack_delay_exponent transport parameter,
+			// and it's possible for us to parse an ACK frame before we've
+			// received that parameter.
+			//
+			// We could plumb connection state down into the frame parser,
+			// but for now let's minimize the amount of code that needs to
+			// deal with this and convert the unscaled value into a scaled one here.
+			ackDelay := time.Duration(-1)
+			if c.peerAckDelayExponent >= 0 {
+				ackDelay = f.ackDelay.Duration(uint8(c.peerAckDelayExponent))
+			}
+			frames = append(frames, slog.AnyValue(debugFrameScaledAck{
+				ranges:   f.ranges,
+				ackDelay: ackDelay,
+			}))
+		default:
+			frames = append(frames, slog.AnyValue(f))
+		}
+	}
+	return slog.Any("frames", frames)
+}
+
+func (c *Conn) logPacketLost(space numberSpace, sent *sentPacket) {
+	c.log.LogAttrs(context.Background(), QLogLevelPacket,
+		"recovery:packet_lost",
+		slog.Group("header",
+			slog.String("packet_type", sent.ptype.qlogString()),
+			slog.Uint64("packet_number", uint64(sent.num)),
+		),
+	)
+}

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

@@ -0,0 +1,63 @@
+// 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"
+
+// A queue is an unbounded queue of some item (new connections and streams).
+type queue[T any] struct {
+	// The gate condition is set if the queue is non-empty or closed.
+	gate gate
+	err  error
+	q    []T
+}
+
+func newQueue[T any]() queue[T] {
+	return queue[T]{gate: newGate()}
+}
+
+// close closes the queue, causing pending and future pop operations
+// to return immediately with err.
+func (q *queue[T]) close(err error) {
+	q.gate.lock()
+	defer q.unlock()
+	if q.err == nil {
+		q.err = err
+	}
+}
+
+// put appends an item to the queue.
+// It returns true if the item was added, false if the queue is closed.
+func (q *queue[T]) put(v T) bool {
+	q.gate.lock()
+	defer q.unlock()
+	if q.err != nil {
+		return false
+	}
+	q.q = append(q.q, v)
+	return true
+}
+
+// get removes the first item from the queue, blocking until ctx is done, an item is available,
+// or the queue is closed.
+func (q *queue[T]) get(ctx context.Context) (T, error) {
+	var zero T
+	if err := q.gate.waitAndLock(ctx); err != nil {
+		return zero, err
+	}
+	defer q.unlock()
+	if q.err != nil {
+		return zero, q.err
+	}
+	v := q.q[0]
+	copy(q.q[:], q.q[1:])
+	q.q[len(q.q)-1] = zero
+	q.q = q.q[:len(q.q)-1]
+	return v, nil
+}
+
+func (q *queue[T]) unlock() {
+	q.gate.unlock(q.err != nil || len(q.q) > 0)
+}