@ttsc/win32-arm64 0.33.1 → 0.34.0

package/bin/go/src/net/dnsclient_unix.go

@@ -366,7 +366,11 @@ type resolverConfig struct {
 var resolvConf resolverConfig
 
 func getSystemDNSConfig() *dnsConfig {
-	resolvConf.tryUpdate("/etc/resolv.conf")
+	return getSystemDNSConfigNamed("/etc/resolv.conf")
+}
+
+func getSystemDNSConfigNamed(path string) *dnsConfig {
+	resolvConf.tryUpdate(path)
 	return resolvConf.dnsConfig.Load()
 }
 
@@ -382,13 +386,28 @@ func (conf *resolverConfig) init() {
 	conf.ch = make(chan struct{}, 1)
 }
 
+// distantFuture is a sentinel time used for tests to signal that
+// resolv.conf should not be rechecked.
+var distantFuture = time.Date(3000, 1, 2, 3, 4, 5, 6, time.UTC)
+
 // tryUpdate tries to update conf with the named resolv.conf file.
 // The name variable only exists for testing. It is otherwise always
 // "/etc/resolv.conf".
 func (conf *resolverConfig) tryUpdate(name string) {
 	conf.initOnce.Do(conf.init)
 
-	if conf.dnsConfig.Load().noReload {
+	dc := conf.dnsConfig.Load()
+
+	// Currently we should never have a config that does not have any
+	// available servers to query, since in such cases the servers field
+	// is set to [defaultNS], see dnsReadConfig.
+	// This assertion main purpose is for testing, such that we never set
+	// the mocked dnsConfig in such way.
+	if len(dc.servers) == 0 {
+		panic("unreachable")
+	}
+
+	if dc.noReload {
 		return
 	}
 
@@ -399,7 +418,19 @@ func (conf *resolverConfig) tryUpdate(name string) {
 	defer conf.releaseSema()
 
 	now := time.Now()
-	if conf.lastChecked.After(now.Add(-5 * time.Second)) {
+
+	// Only recheck the resolv.conf when:
+	// - expired (last re-check was more that 5 seconds ago)
+	// - the default nameservers are used (the last parse could not load
+	//   resolv.conf, or it did not contain any nameservers)
+	// - rechecks are not disabled (only possible in case of testing)
+	//
+	// Note: We only do one check at a time. Other concurrent requests might
+	// still use the previous (outdated) version of the configuration file.
+	expired := now.After(conf.lastChecked.Add(5 * time.Second))
+	rechecksEnabled := conf.lastChecked != distantFuture // for testing purposes
+	recheck := (expired || dc.isDefaultNS()) && rechecksEnabled
+	if !recheck {
 		return
 	}
 	conf.lastChecked = now
@@ -495,9 +526,8 @@ func avoidDNS(name string) bool {
 // nameList returns a list of names for sequential DNS queries.
 func (conf *dnsConfig) nameList(name string) []string {
 	// Check name length (see isDomainName).
-	l := len(name)
-	rooted := l > 0 && name[l-1] == '.'
-	if l > 254 || l == 254 && !rooted {
+	rooted := len(name) > 0 && name[len(name)-1] == '.'
+	if len(name) > 254 || len(name) == 254 && !rooted {
 		return nil
 	}
 
@@ -511,7 +541,6 @@ func (conf *dnsConfig) nameList(name string) []string {
 
 	hasNdots := bytealg.CountString(name, '.') >= conf.ndots
 	name += "."
-	l++
 
 	// Build list of search choices.
 	names := make([]string, 0, 1+len(conf.search))
@@ -632,7 +661,7 @@ func (r *Resolver) goLookupIPCNAMEOrder(ctx context.Context, network, name strin
 	type result struct {
 		p      dnsmessage.Parser
 		server string
-		error
+		error  error
 	}
 
 	if conf == nil {

package/bin/go/src/net/dnsconfig.go

@@ -25,6 +25,12 @@ import (
 //go:linkname defaultNS
 var defaultNS = []string{"127.0.0.1:53", "[::1]:53"}
 
+// isDefaultNS reports whether the c.servers field is set to [defaultNS], meaning that
+// no nameservers were specified in /etc/resolv.conf, thus the default ones are used.
+func (c *dnsConfig) isDefaultNS() bool {
+	return len(c.servers) == len(defaultNS) && &c.servers[0] == &defaultNS[0]
+}
+
 var getHostname = os.Hostname // variable for testing
 
 type dnsConfig struct {

package/bin/go/src/net/fd_plan9.go

@@ -27,7 +27,7 @@ type netFD struct {
 
 var netdir = "/net" // default network
 
-func newFD(net, name string, listen, ctl, data *os.File, laddr, raddr Addr) (*netFD, error) {
+func newFD(net, name string, listen, ctl, data *os.File, laddr, raddr Addr) *netFD {
 	ret := &netFD{
 		net:    net,
 		n:      name,
@@ -38,7 +38,7 @@ func newFD(net, name string, listen, ctl, data *os.File, laddr, raddr Addr) (*ne
 		raddr: raddr,
 	}
 	ret.pfd.Destroy = ret.destroy
-	return ret, nil
+	return ret
 }
 
 func (fd *netFD) init() error {
@@ -80,13 +80,20 @@ func (fd *netFD) destroy() {
 }
 
 func (fd *netFD) Read(b []byte) (n int, err error) {
-	if !fd.ok() || fd.data == nil {
+	if fd == nil {
 		return 0, syscall.EINVAL
 	}
+	if fd.data == nil {
+		return 0, ErrClosed
+	}
 	n, err = fd.pfd.Read(fd.data.Read, b)
-	if fd.net == "udp" && err == io.EOF {
-		n = 0
-		err = nil
+	if err == io.EOF {
+		if fd.data == nil {
+			err = ErrClosed
+		} else if fd.net == "udp" {
+			n = 0
+			err = nil
+		}
 	}
 	return
 }

package/bin/go/src/net/fd_unix.go

@@ -23,8 +23,8 @@ const (
 	writeMsgSyscallName = "sendmsg"
 )
 
-func newFD(sysfd, family, sotype int, net string) (*netFD, error) {
-	ret := &netFD{
+func newFD(sysfd, family, sotype int, net string) *netFD {
+	return &netFD{
 		pfd: poll.FD{
 			Sysfd:         sysfd,
 			IsStream:      sotype == syscall.SOCK_STREAM,
@@ -34,7 +34,6 @@ func newFD(sysfd, family, sotype int, net string) (*netFD, error) {
 		sotype: sotype,
 		net:    net,
 	}
-	return ret, nil
 }
 
 func (fd *netFD) init() error {
@@ -155,10 +154,7 @@ func (fd *netFD) accept() (netfd *netFD, err error) {
 		return nil, err
 	}
 
-	if netfd, err = newFD(d, fd.family, fd.sotype, fd.net); err != nil {
-		poll.CloseFunc(d)
-		return nil, err
-	}
+	netfd = newFD(d, fd.family, fd.sotype, fd.net)
 	if err = netfd.init(); err != nil {
 		netfd.Close()
 		return nil, err

package/bin/go/src/net/fd_windows.go

@@ -38,8 +38,8 @@ func canUseConnectEx(net string) bool {
 	return false
 }
 
-func newFD(sysfd syscall.Handle, family, sotype int, net string) (*netFD, error) {
-	ret := &netFD{
+func newFD(sysfd syscall.Handle, family, sotype int, net string) *netFD {
+	return &netFD{
 		pfd: poll.FD{
 			Sysfd:         sysfd,
 			IsStream:      sotype == syscall.SOCK_STREAM,
@@ -49,7 +49,6 @@ func newFD(sysfd syscall.Handle, family, sotype int, net string) (*netFD, error)
 		sotype: sotype,
 		net:    net,
 	}
-	return ret, nil
 }
 
 func (fd *netFD) init() error {
@@ -211,13 +210,9 @@ func (fd *netFD) accept() (*netFD, error) {
 	}
 
 	// Associate our new socket with IOCP.
-	netfd, err := newFD(s, fd.family, fd.sotype, fd.net)
-	if err != nil {
-		poll.CloseFunc(s)
-		return nil, err
-	}
+	netfd := newFD(s, fd.family, fd.sotype, fd.net)
 	if err := netfd.init(); err != nil {
-		fd.Close()
+		netfd.Close()
 		return nil, err
 	}
 

package/bin/go/src/net/file_plan9.go

@@ -81,7 +81,7 @@ func newFileFD(f *os.File) (net *netFD, err error) {
 	if err != nil {
 		return nil, err
 	}
-	return newFD(comp[1], name, nil, ctl, nil, laddr, nil)
+	return newFD(comp[1], name, nil, ctl, nil, laddr, nil), nil
 }
 
 func fileConn(f *os.File) (Conn, error) {

package/bin/go/src/net/file_posix.go

@@ -40,11 +40,7 @@ func newFileFD(f *os.File) (*netFD, error) {
 		poll.CloseFunc(s)
 		return nil, syscall.EPROTONOSUPPORT
 	}
-	fd, err := newFD(s, family, sotype, "")
-	if err != nil {
-		poll.CloseFunc(s)
-		return nil, err
-	}
+	fd := newFD(s, family, sotype, "")
 	laddr := fd.addrFunc()(lsa)
 	raddr := fd.addrFunc()(rsa)
 	fd.net = laddr.Network()

package/bin/go/src/net/http/client.go

@@ -25,6 +25,8 @@ import (
 	"sync"
 	"sync/atomic"
 	"time"
+
+	"golang.org/x/net/http/httpguts"
 )
 
 // A Client is an HTTP client. Its zero value ([DefaultClient]) is a
@@ -329,7 +331,7 @@ func knownRoundTripperImpl(rt RoundTripper, req *Request) bool {
 			return knownRoundTripperImpl(altRT, req)
 		}
 		return true
-	case *http2Transport, http2noDialH2RoundTripper:
+	case http2RoundTripper:
 		return true
 	}
 	// There's a very minor chance of a false positive with this.
@@ -565,6 +567,9 @@ func urlErrorOp(method string) string {
 // read to EOF and closed, the [Client]'s underlying [RoundTripper]
 // (typically [Transport]) may not be able to re-use a persistent TCP
 // connection to the server for a subsequent "keep-alive" request.
+// Note, however, that [Transport] will automatically try to read a
+// [Response] Body to EOF asynchronously up to a conservative limit
+// when a Body is closed.
 //
 // The request Body, if non-nil, will be closed by the underlying
 // Transport, even on errors. The Body may be closed asynchronously after
@@ -586,6 +591,13 @@ func urlErrorOp(method string) string {
 // The [NewRequest] function automatically sets GetBody for common
 // standard library body types.
 //
+// Note that the [Client] redirect behavior does not follow the WHATWG
+// Fetch standard. This is because it was written before established
+// standards existed. As such, by modern standards, [Client] has a
+// rather permissive behavior. For example, sensitive headers are
+// retained on redirect to a subdomain or to a different scheme on the
+// same host.
+//
 // Any returned error will be of type [*url.Error]. The url.Error
 // value's Timeout method will report true if the request timed out.
 func (c *Client) Do(req *Request) (*Response, error) {
@@ -1016,9 +1028,14 @@ func shouldCopyHeaderOnRedirect(initial, dest *url.URL) bool {
 	// directly, we don't know their scope, so we assume
 	// it's for *.domain.com.
 
-	ihost := idnaASCIIFromURL(initial)
-	dhost := idnaASCIIFromURL(dest)
-	return isDomainOrSubdomain(dhost, ihost)
+	ihost, err1 := httpguts.PunycodeHostPort(initial.Hostname())
+	dhost, err2 := httpguts.PunycodeHostPort(dest.Hostname())
+	if err1 != nil || err2 != nil {
+		return false
+	}
+	ihost, ok1 := ascii.ToLower(ihost)
+	dhost, ok2 := ascii.ToLower(dhost)
+	return ok1 && ok2 && isDomainOrSubdomain(dhost, ihost)
 }
 
 // isDomainOrSubdomain reports whether sub is a subdomain (or exact

package/bin/go/src/net/http/clientconn.go

@@ -113,6 +113,14 @@ type genericClientConn interface {
 func (t *Transport) NewClientConn(ctx context.Context, scheme, address string) (*ClientConn, error) {
 	t.nextProtoOnce.Do(t.onceSetNextProtoDefaults)
 
+	if t.h2Config != nil {
+		// Handle x/net/http2.Transport.NewClientConn passing us a net.Conn
+		// to create a ClientConn from.
+		if cc, err := t.http2NewClientConnFromContext(ctx); err != errors.ErrUnsupported {
+			return cc, err
+		}
+	}
+
 	switch scheme {
 	case "http", "https":
 	default:
@@ -245,6 +253,17 @@ func validateClientConnRequest(req *Request) error {
 // before sending the request.
 func (cc *ClientConn) RoundTrip(req *Request) (*Response, error) {
 	defer cc.maybeRunStateHook()
+	if req.URL == nil && req.Method == ":ping" {
+		// Undocumented feature for sending a PING frame to a HTTP/2 connection,
+		// included to support x/net/http2.ClientConn.Ping.
+		pinger, ok := cc.cc.(interface {
+			Ping(context.Context) error
+		})
+		if !ok {
+			return nil, errors.New("http: ClientConn does not support PING")
+		}
+		return nil, pinger.Ping(req.Context())
+	}
 	if err := validateClientConnRequest(req); err != nil {
 		cc.Release()
 		return nil, err
@@ -380,7 +399,7 @@ func (cc http1ClientConn) RoundTrip(req *Request) (*Response, error) {
 	ctx := req.Context()
 	trace := httptrace.ContextClientTrace(ctx)
 
-	// Convert Request.Cancel into context cancelation.
+	// Convert Request.Cancel into context cancellation.
 	ctx, cancel := context.WithCancelCause(req.Context())
 	if req.Cancel != nil {
 		go awaitLegacyCancel(ctx, cancel, req)

package/bin/go/src/net/http/clone.go

@@ -39,16 +39,7 @@ func cloneURLValues(v url.Values) url.Values {
 //
 //go:linkname cloneURL
 func cloneURL(u *url.URL) *url.URL {
-	if u == nil {
-		return nil
-	}
-	u2 := new(url.URL)
-	*u2 = *u
-	if u.User != nil {
-		u2.User = new(url.Userinfo)
-		*u2.User = *u.User
-	}
-	return u2
+	return u.Clone()
 }
 
 // cloneMultipartForm should be an internal detail,

package/bin/go/src/net/http/cookie.go

@@ -89,15 +89,14 @@ func cookieNumWithinMax(cookieNum int) bool {
 // which were set in it. Since the same cookie name can appear multiple times
 // the returned Values can contain more than one value for a given key.
 func ParseCookie(line string) ([]*Cookie, error) {
-	if !cookieNumWithinMax(strings.Count(line, ";") + 1) {
+	nparts := strings.Count(line, ";") + 1
+	if !cookieNumWithinMax(nparts) {
 		return nil, errCookieNumLimitExceeded
-	}
-	parts := strings.Split(textproto.TrimString(line), ";")
-	if len(parts) == 1 && parts[0] == "" {
+	} else if nparts == 1 && textproto.TrimString(line) == "" {
 		return nil, errBlankCookie
 	}
-	cookies := make([]*Cookie, 0, len(parts))
-	for _, s := range parts {
+	cookies := make([]*Cookie, 0, nparts)
+	for s := range strings.SplitSeq(line, ";") {
 		s = textproto.TrimString(s)
 		name, value, found := strings.Cut(s, "=")
 		if !found {

package/bin/go/src/net/http/cookiejar/jar.go

@@ -2,7 +2,9 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// Package cookiejar implements an in-memory RFC 6265-compliant http.CookieJar.
+// Package cookiejar implements an in-memory [RFC 6265]-compliant [http.CookieJar].
+//
+// [RFC 6265]: https://www.rfc-editor.org/info/rfc6265
 package cookiejar
 
 import (
@@ -33,7 +35,7 @@ import (
 // set a cookie for bar.com.
 //
 // A public suffix list implementation is in the package
-// golang.org/x/net/publicsuffix.
+// [golang.org/x/net/publicsuffix].
 type PublicSuffixList interface {
 	// PublicSuffix returns the public suffix of domain.
 	//
@@ -48,7 +50,7 @@ type PublicSuffixList interface {
 	String() string
 }
 
-// Options are the options for creating a new Jar.
+// Options are the options for creating a new [Jar].
 type Options struct {
 	// PublicSuffixList is the public suffix list that determines whether
 	// an HTTP server can set a cookie for a domain.
@@ -59,7 +61,7 @@ type Options struct {
 	PublicSuffixList PublicSuffixList
 }
 
-// Jar implements the http.CookieJar interface from the net/http package.
+// Jar implements the [net/http.CookieJar] interface.
 type Jar struct {
 	psList PublicSuffixList
 

package/bin/go/src/net/http/fcgi/fcgi.go

@@ -189,8 +189,7 @@ func (c *conn) writePairs(recType recType, reqId uint16, pairs map[string]string
 			return err
 		}
 	}
-	w.Close()
-	return nil
+	return w.Close()
 }
 
 func readSize(s []byte) (uint32, int) {

package/bin/go/src/net/http/fs.go

@@ -15,6 +15,7 @@ import (
 	"math"
 	"mime"
 	"mime/multipart"
+	"net/http/internal"
 	"net/textproto"
 	"net/url"
 	"os"
@@ -289,7 +290,7 @@ func serveContent(w ResponseWriter, r *Request, name string, modtime time.Time,
 		ctype = mime.TypeByExtension(filepath.Ext(name))
 		if ctype == "" {
 			// read a chunk to decide between utf-8 text and binary
-			var buf [sniffLen]byte
+			var buf [internal.SniffLen]byte
 			n, _ := io.ReadFull(content, buf[:])
 			ctype = DetectContentType(buf[:n])
 			_, err := content.Seek(0, io.SeekStart) // rewind to output whole file
@@ -784,6 +785,12 @@ func toHTTPError(err error) (msg string, httpStatus int) {
 // localRedirect gives a Moved Permanently response.
 // It does not convert relative paths to absolute paths like Redirect does.
 func localRedirect(w ResponseWriter, r *Request, newPath string) {
+	// There is no reliable way for us to redirect correctly when the path has
+	// escaped slashes, since StripPrefix might be in use. Just return 404.
+	if p := r.URL.EscapedPath(); strings.Contains(p, "%2f") || strings.Contains(p, "%2F") {
+		NotFound(w, r)
+		return
+	}
 	if q := r.URL.RawQuery; q != "" {
 		newPath += "?" + q
 	}

package/bin/go/src/net/http/http.go

@@ -2,8 +2,6 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:generate bundle -o=h2_bundle.go -prefix=http2 -tags=!nethttpomithttp2 -import=golang.org/x/net/internal/httpcommon=net/http/internal/httpcommon golang.org/x/net/http2
-
 package http
 
 import (
@@ -12,6 +10,7 @@ import (
 	"strings"
 	"time"
 	"unicode/utf8"
+	_ "unsafe"
 
 	"golang.org/x/net/http/httpguts"
 )
@@ -24,7 +23,7 @@ import (
 //   - HTTP1 is the HTTP/1.0 and HTTP/1.1 protocols.
 //     HTTP1 is supported on both unsecured TCP and secured TLS connections.
 //
-//   - HTTP2 is the HTTP/2 protcol over a TLS connection.
+//   - HTTP2 is the HTTP/2 protocol over a TLS connection.
 //
 //   - UnencryptedHTTP2 is the HTTP/2 protocol over an unsecured TCP connection.
 type Protocols struct {
@@ -35,6 +34,7 @@ const (
 	protoHTTP1 = 1 << iota
 	protoHTTP2
 	protoUnencryptedHTTP2
+	protoHTTP3
 )
 
 // HTTP1 reports whether p includes HTTP/1.
@@ -55,6 +55,15 @@ func (p Protocols) UnencryptedHTTP2() bool { return p.bits&protoUnencryptedHTTP2
 // SetUnencryptedHTTP2 adds or removes unencrypted HTTP/2 from p.
 func (p *Protocols) SetUnencryptedHTTP2(ok bool) { p.setBit(protoUnencryptedHTTP2, ok) }
 
+// http3 reports whether p includes HTTP/3.
+func (p Protocols) http3() bool { return p.bits&protoHTTP3 != 0 }
+
+// setHTTP3 adds or removes HTTP/3 from p.
+func (p *Protocols) setHTTP3(ok bool) { p.setBit(protoHTTP3, ok) }
+
+//go:linkname protocolSetHTTP3 golang.org/x/net/internal/http3_test.protocolSetHTTP3
+func protocolSetHTTP3(p *Protocols) { p.setHTTP3(true) }
+
 func (p *Protocols) setBit(bit uint8, ok bool) {
 	if ok {
 		p.bits |= bit
@@ -63,6 +72,11 @@ func (p *Protocols) setBit(bit uint8, ok bool) {
 	}
 }
 
+// empty returns true if p has no protocol set at all.
+func (p Protocols) empty() bool {
+	return p.bits == 0
+}
+
 func (p Protocols) String() string {
 	var s []string
 	if p.HTTP1() {
@@ -74,6 +88,9 @@ func (p Protocols) String() string {
 	if p.UnencryptedHTTP2() {
 		s = append(s, "UnencryptedHTTP2")
 	}
+	if p.http3() {
+		s = append(s, "HTTP3")
+	}
 	return "{" + strings.Join(s, ",") + "}"
 }
 
@@ -106,15 +123,15 @@ type contextKey struct {
 
 func (k *contextKey) String() string { return "net/http context value " + k.name }
 
-// Given a string of the form "host", "host:port", or "[ipv6::address]:port",
-// return true if the string includes a port.
-func hasPort(s string) bool { return strings.LastIndex(s, ":") > strings.LastIndex(s, "]") }
-
-// removeEmptyPort strips the empty port in ":port" to ""
-// as mandated by RFC 3986 Section 6.2.3.
-func removeEmptyPort(host string) string {
-	if hasPort(host) {
-		return strings.TrimSuffix(host, ":")
+// removePort strips the port while correctly handling IPv6.
+func removePort(host string) string {
+	for i := len(host) - 1; i >= 0; i-- {
+		switch host[i] {
+		case ':':
+			return host[:i]
+		case ']':
+			return host
+		}
 	}
 	return host
 }