@ttsc/win32-arm64 0.33.1 → 0.34.0

package/bin/go/src/net/lookup.go

@@ -487,6 +487,11 @@ func (r *Resolver) LookupCNAME(ctx context.Context, host string) (string, error)
 // publishing SRV records under non-standard names, if both service
 // and proto are empty strings, LookupSRV looks up name directly.
 //
+// The returned cname is the owner name from the first SRV answer
+// record, which is typically the constructed DNS name
+// (_service._proto.name) but may differ if CNAME records redirect
+// the query to another name.
+//
 // The returned service names are validated to be properly
 // formatted presentation-format domain names. If the response contains
 // invalid names, those records are filtered out and an error
@@ -505,6 +510,11 @@ func LookupSRV(service, proto, name string) (cname string, addrs []*SRV, err err
 // publishing SRV records under non-standard names, if both service
 // and proto are empty strings, LookupSRV looks up name directly.
 //
+// The returned cname is the owner name from the first SRV answer
+// record, which is typically the constructed DNS name
+// (_service._proto.name) but may differ if CNAME records redirect
+// the query to another name.
+//
 // The returned service names are validated to be properly
 // formatted presentation-format domain names. If the response contains
 // invalid names, those records are filtered out and an error

package/bin/go/src/net/lookup_windows.go

@@ -464,7 +464,7 @@ Cname:
 			if !syscall.DnsNameCompare(name, p.Name) {
 				continue
 			}
-			name = (*syscall.DNSPTRData)(unsafe.Pointer(&r.Data[0])).Host
+			name = (*syscall.DNSPTRData)(unsafe.Pointer(&p.Data[0])).Host
 			continue Cname
 		}
 		break

package/bin/go/src/net/mail/message.go

@@ -81,7 +81,7 @@ func readHeader(r *textproto.Reader) (map[string][]string, error) {
 		if err != nil {
 			return m, err
 		}
-		return m, errors.New("malformed initial line: " + line)
+		return m, fmt.Errorf("malformed initial line: %q", line)
 	}
 
 	for {
@@ -93,7 +93,7 @@ func readHeader(r *textproto.Reader) (map[string][]string, error) {
 		// Key ends at first colon.
 		k, v, ok := strings.Cut(kv, ":")
 		if !ok {
-			return m, errors.New("malformed header line: " + kv)
+			return m, fmt.Errorf("malformed header line: %q", kv)
 		}
 		key := textproto.CanonicalMIMEHeaderKey(k)
 
@@ -764,7 +764,12 @@ func (p *addrParser) consumeDomainLiteral() (string, error) {
 	}
 
 	// Check if the domain literal is an IP address
-	if net.ParseIP(dtext) == nil {
+	if addr, ok := strings.CutPrefix(dtext, "IPv6:"); ok {
+		if len(net.ParseIP(addr)) != net.IPv6len {
+			return "", fmt.Errorf("mail: invalid IPv6 address in domain-literal: %q", dtext)
+		}
+
+	} else if net.ParseIP(dtext).To4() == nil {
 		return "", fmt.Errorf("mail: invalid IP address in domain-literal: %q", dtext)
 	}
 

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

@@ -606,6 +606,8 @@ func (e UnknownNetworkError) Temporary() bool { return false }
 
 type InvalidAddrError string
 
+var _ error = InvalidAddrError("")
+
 func (e InvalidAddrError) Error() string   { return string(e) }
 func (e InvalidAddrError) Timeout() bool   { return false }
 func (e InvalidAddrError) Temporary() bool { return false }

package/bin/go/src/net/netip/netip.go

@@ -97,7 +97,7 @@ func AddrFrom4(addr [4]byte) Addr {
 
 // AddrFrom16 returns the IPv6 address given by the bytes in addr.
 // An IPv4-mapped IPv6 address is left as an IPv6 address.
-// (Use Unmap to convert them if needed.)
+// (Use [Addr.Unmap] to convert them if needed.)
 func AddrFrom16(addr [16]byte) Addr {
 	return Addr{
 		addr: uint128{
@@ -637,6 +637,9 @@ func (ip Addr) IsGlobalUnicast() bool {
 // (IPv4 addresses) and RFC 4193 (IPv6 addresses). That is, it reports whether
 // ip is in 10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16, or fc00::/7. This is the
 // same as [net.IP.IsPrivate].
+//
+// IsPrivate does not describe a security property of addresses,
+// and should not be used for access control.
 func (ip Addr) IsPrivate() bool {
 	if ip.Is4In6() {
 		ip = ip.Unmap()
@@ -782,17 +785,32 @@ func (ip Addr) Prev() Addr {
 // IPv4-mapped IPv6 addresses format with a "::ffff:"
 // prefix before the dotted quad.
 func (ip Addr) String() string {
-	switch ip.z {
-	case z0:
+	if !ip.IsValid() {
 		return "invalid IP"
-	case z4:
-		return ip.string4()
+	}
+	var b []byte
+	switch {
+	case ip.z == z4:
+		const max = len("255.255.255.255")
+		b = make([]byte, 0, max)
+		b = ip.appendTo4(b)
+	case ip.Is4In6():
+		const max = len("::ffff:255.255.255.255%enp5s0")
+		b = make([]byte, 0, max)
+		b = ip.appendTo4In6(b)
 	default:
-		if ip.Is4In6() {
-			return ip.string4In6()
-		}
-		return ip.string6()
+		// Use a zone with a "plausibly long" name, so that most zone-ful
+		// IP addresses won't require additional allocation.
+		//
+		// The compiler does a cool optimization here, where b ends up
+		// stack-allocated and so the only allocation this function does
+		// is to construct the returned string. As such, it's okay to be a
+		// bit greedy here, size-wise.
+		const max = len("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff%enp5s0")
+		b = make([]byte, 0, max)
+		b = ip.appendTo6(b)
 	}
+	return string(b)
 }
 
 // AppendTo appends a text encoding of ip,
@@ -852,13 +870,6 @@ func appendHexPad(b []byte, x uint16) []byte {
 	return append(b, digits[x>>12], digits[x>>8&0xf], digits[x>>4&0xf], digits[x&0xf])
 }
 
-func (ip Addr) string4() string {
-	const max = len("255.255.255.255")
-	ret := make([]byte, 0, max)
-	ret = ip.appendTo4(ret)
-	return string(ret)
-}
-
 func (ip Addr) appendTo4(ret []byte) []byte {
 	ret = appendDecimal(ret, ip.v4(0))
 	ret = append(ret, '.')
@@ -870,13 +881,6 @@ func (ip Addr) appendTo4(ret []byte) []byte {
 	return ret
 }
 
-func (ip Addr) string4In6() string {
-	const max = len("::ffff:255.255.255.255%enp5s0")
-	ret := make([]byte, 0, max)
-	ret = ip.appendTo4In6(ret)
-	return string(ret)
-}
-
 func (ip Addr) appendTo4In6(ret []byte) []byte {
 	ret = append(ret, "::ffff:"...)
 	ret = ip.Unmap().appendTo4(ret)
@@ -887,25 +891,11 @@ func (ip Addr) appendTo4In6(ret []byte) []byte {
 	return ret
 }
 
-// string6 formats ip in IPv6 textual representation. It follows the
-// guidelines in section 4 of RFC 5952
-// (https://tools.ietf.org/html/rfc5952#section-4): no unnecessary
-// zeros, use :: to elide the longest run of zeros, and don't use ::
+// appendTo6 formats ip in IPv6 textual representation, appends the result to
+// the byte slice, and returns the updated slice. It follows the guidelines in
+// section 4 of RFC 5952 (https://tools.ietf.org/html/rfc5952#section-4): no
+// unnecessary zeros, use :: to elide the longest run of zeros, and don't use ::
 // to compact a single zero field.
-func (ip Addr) string6() string {
-	// Use a zone with a "plausibly long" name, so that most zone-ful
-	// IP addresses won't require additional allocation.
-	//
-	// The compiler does a cool optimization here, where ret ends up
-	// stack-allocated and so the only allocation this function does
-	// is to construct the returned string. As such, it's okay to be a
-	// bit greedy here, size-wise.
-	const max = len("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff%enp5s0")
-	ret := make([]byte, 0, max)
-	ret = ip.appendTo6(ret)
-	return string(ret)
-}
-
 func (ip Addr) appendTo6(ret []byte) []byte {
 	zeroStart, zeroEnd := uint8(255), uint8(255)
 	for i := uint8(0); i < 8; i++ {
@@ -967,13 +957,13 @@ func (ip Addr) StringExpanded() string {
 	return string(ret)
 }
 
-// AppendText implements the [encoding.TextAppender] interface,
-// It is the same as [Addr.AppendTo].
+// AppendText implements the [encoding.TextAppender] interface.
+// The encoding is the same as returned by [Addr.AppendTo].
 func (ip Addr) AppendText(b []byte) ([]byte, error) {
 	return ip.AppendTo(b), nil
 }
 
-// MarshalText implements the [encoding.TextMarshaler] interface,
+// MarshalText implements the [encoding.TextMarshaler] interface.
 // The encoding is the same as returned by [Addr.String], with one exception:
 // If ip is the zero [Addr], the encoding is the empty string.
 func (ip Addr) MarshalText() ([]byte, error) {
@@ -995,7 +985,7 @@ func (ip Addr) MarshalText() ([]byte, error) {
 	return ip.AppendText(buf)
 }
 
-// UnmarshalText implements the encoding.TextUnmarshaler interface.
+// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
 // The IP address is expected in a form accepted by [ParseAddr].
 //
 // If text is empty, UnmarshalText sets *ip to the zero [Addr] and
@@ -1044,7 +1034,7 @@ func (ip Addr) MarshalBinary() ([]byte, error) {
 }
 
 // UnmarshalBinary implements the [encoding.BinaryUnmarshaler] interface.
-// It expects data in the form generated by MarshalBinary.
+// It expects data in the form generated by [Addr.MarshalBinary].
 func (ip *Addr) UnmarshalBinary(b []byte) error {
 	n := len(b)
 	switch {
@@ -1211,15 +1201,15 @@ func (p AddrPort) AppendTo(b []byte) []byte {
 	return b
 }
 
-// AppendText implements the [encoding.TextAppender] interface. The
-// encoding is the same as returned by [AddrPort.AppendTo].
+// AppendText implements the [encoding.TextAppender] interface.
+// The encoding is the same as returned by [AddrPort.AppendTo].
 func (p AddrPort) AppendText(b []byte) ([]byte, error) {
 	return p.AppendTo(b), nil
 }
 
-// MarshalText implements the [encoding.TextMarshaler] interface. The
-// encoding is the same as returned by [AddrPort.String], with one exception: if
-// p.Addr() is the zero [Addr], the encoding is the empty string.
+// MarshalText implements the [encoding.TextMarshaler] interface.
+// The encoding is the same as returned by [AddrPort.String], with one exception:
+// If p.Addr() is the zero [Addr], the encoding is the empty string.
 func (p AddrPort) MarshalText() ([]byte, error) {
 	buf := []byte{}
 	switch p.ip.z {
@@ -1234,9 +1224,9 @@ func (p AddrPort) MarshalText() ([]byte, error) {
 	return p.AppendText(buf)
 }
 
-// UnmarshalText implements the encoding.TextUnmarshaler
-// interface. The [AddrPort] is expected in a form
-// generated by [AddrPort.MarshalText] or accepted by [ParseAddrPort].
+// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
+// The [AddrPort] is expected in a form generated by [AddrPort.MarshalText] or
+// accepted by [ParseAddrPort].
 func (p *AddrPort) UnmarshalText(text []byte) error {
 	if len(text) == 0 {
 		*p = AddrPort{}
@@ -1247,7 +1237,7 @@ func (p *AddrPort) UnmarshalText(text []byte) error {
 	return err
 }
 
-// AppendBinary implements the [encoding.BinaryAppendler] interface.
+// AppendBinary implements the [encoding.BinaryAppender] interface.
 // It returns [Addr.AppendBinary] with an additional two bytes appended
 // containing the port in little-endian.
 func (p AddrPort) AppendBinary(b []byte) ([]byte, error) {
@@ -1500,7 +1490,6 @@ func (p Prefix) AppendTo(b []byte) []byte {
 		return append(b, "invalid Prefix"...)
 	}
 
-	// p.ip is non-nil, because p is valid.
 	if p.ip.z == z4 {
 		b = p.ip.appendTo4(b)
 	} else {
@@ -1523,9 +1512,9 @@ func (p Prefix) AppendText(b []byte) ([]byte, error) {
 	return p.AppendTo(b), nil
 }
 
-// MarshalText implements the [encoding.TextMarshaler] interface,
+// MarshalText implements the [encoding.TextMarshaler] interface.
 // The encoding is the same as returned by [Prefix.String], with one exception:
-// If p is the zero value, the encoding is the empty string.
+// If p is the zero [Prefix], the encoding is the empty string.
 func (p Prefix) MarshalText() ([]byte, error) {
 	buf := []byte{}
 	switch p.ip.z {
@@ -1540,7 +1529,7 @@ func (p Prefix) MarshalText() ([]byte, error) {
 	return p.AppendText(buf)
 }
 
-// UnmarshalText implements the encoding.TextUnmarshaler interface.
+// UnmarshalText implements the [encoding.TextUnmarshaler] interface.
 // The IP address is expected in a form accepted by [ParsePrefix]
 // or generated by [Prefix.MarshalText].
 func (p *Prefix) UnmarshalText(text []byte) error {
@@ -1553,7 +1542,7 @@ func (p *Prefix) UnmarshalText(text []byte) error {
 	return err
 }
 
-// AppendBinary implements the [encoding.AppendMarshaler] interface.
+// AppendBinary implements the [encoding.BinaryAppender] interface.
 // It returns [Addr.AppendBinary] with an additional byte appended
 // containing the prefix bits.
 func (p Prefix) AppendBinary(b []byte) ([]byte, error) {
@@ -1592,5 +1581,23 @@ func (p Prefix) String() string {
 	if !p.IsValid() {
 		return "invalid Prefix"
 	}
-	return p.ip.String() + "/" + strconv.Itoa(p.Bits())
+	var b []byte
+	switch {
+	case p.ip.z == z4:
+		const maxCap = len("255.255.255.255/32")
+		b = make([]byte, 0, maxCap)
+		b = p.ip.appendTo4(b)
+	case p.ip.Is4In6():
+		const maxCap = len("::ffff:255.255.255.255/32")
+		b = make([]byte, 0, maxCap)
+		b = append(b, "::ffff:"...)
+		b = p.ip.Unmap().appendTo4(b)
+	default:
+		const maxCap = len("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff/128")
+		b = make([]byte, 0, maxCap)
+		b = p.ip.appendTo6(b)
+	}
+	b = append(b, '/')
+	b = appendDecimal(b, uint8(p.Bits()))
+	return string(b)
 }

package/bin/go/src/net/sock_posix.go

@@ -24,10 +24,7 @@ func socket(ctx context.Context, net string, family, sotype, proto int, ipv6only
 		poll.CloseFunc(s)
 		return nil, err
 	}
-	if fd, err = newFD(s, family, sotype, net); err != nil {
-		poll.CloseFunc(s)
-		return nil, err
-	}
+	fd = newFD(s, family, sotype, net)
 
 	// This function makes a network file descriptor for the
 	// following applications:

package/bin/go/src/net/textproto/reader.go

@@ -18,7 +18,7 @@ import (
 )
 
 // TODO: This should be a distinguishable error (ErrMessageTooLarge)
-// to allow mime/multipart to detect it.
+// to allow mime/multipart and net/http to detect it.
 var errMessageTooLarge = errors.New("message too large")
 
 // A Reader implements convenience methods for reading requests
@@ -508,11 +508,18 @@ func (r *Reader) ReadMIMEHeader() (MIMEHeader, error) {
 	return readMIMEHeader(r, math.MaxInt64, math.MaxInt64)
 }
 
-// readMIMEHeader is accessed from mime/multipart.
+// readMIMEHeader should be an internal detail,
+// but widely used packages access it using linkname.
+// Notable members of the hall of shame include:
+//   - github.com/qtgolang/SunnyNet
+//
+// Do not remove or change the type signature.
+// See go.dev/issue/67401.
+//
 //go:linkname readMIMEHeader
 
 // readMIMEHeader is a version of ReadMIMEHeader which takes a limit on the header size.
-// It is called by the mime/multipart package.
+// It is called by the mime/multipart and net/http package.
 func readMIMEHeader(r *Reader, maxMemory, maxHeaders int64) (MIMEHeader, error) {
 	if maxMemory < 0 {
 		return nil, errMessageTooLarge
@@ -833,6 +840,7 @@ func initCommonHeader() {
 		"Mime-Version",
 		"Pragma",
 		"Received",
+		"Referer",
 		"Return-Path",
 		"Server",
 		"Set-Cookie",

package/bin/go/src/net/udpsock_plan9.go

@@ -133,8 +133,7 @@ func (sl *sysListener) listenUDP(ctx context.Context, laddr *UDPAddr) (*UDPConn,
 	if err != nil {
 		return nil, err
 	}
-	fd, err := l.netFD()
-	return newUDPConn(fd), err
+	return newUDPConn(l.netFD()), nil
 }
 
 func (sl *sysListener) listenMulticastUDP(ctx context.Context, ifi *Interface, gaddr *UDPAddr) (*UDPConn, error) {
@@ -174,9 +173,5 @@ func (sl *sysListener) listenMulticastUDP(ctx context.Context, ifi *Interface, g
 	if err != nil {
 		return nil, err
 	}
-	fd, err := l.netFD()
-	if err != nil {
-		return nil, err
-	}
-	return newUDPConn(fd), nil
+	return newUDPConn(l.netFD()), nil
 }

package/bin/go/src/net/unixsock.go

@@ -6,6 +6,7 @@ package net
 
 import (
 	"context"
+	"io"
 	"os"
 	"sync"
 	"syscall"
@@ -19,6 +20,13 @@ import (
 // and UnixListener don't work for "unixgram" and "unixpacket".
 
 // UnixAddr represents the address of a Unix domain socket end point.
+//
+// On Linux, a Name beginning with "@" denotes an abstract socket address:
+// the "@" is translated to a NUL byte when the address is passed to the
+// kernel, placing the socket in the abstract namespace rather than the
+// filesystem. Abstract sockets are a Linux-specific feature; on other
+// platforms, a Name beginning with "@" is treated as a literal filesystem
+// path.
 type UnixAddr struct {
 	Name string
 	Net  string
@@ -108,7 +116,7 @@ func (c *UnixConn) ReadFromUnix(b []byte) (int, *UnixAddr, error) {
 		return 0, nil, syscall.EINVAL
 	}
 	n, addr, err := c.readFrom(b)
-	if err != nil {
+	if err != nil && err != io.EOF {
 		err = &OpError{Op: "read", Net: c.fd.net, Source: c.fd.laddr, Addr: c.fd.raddr, Err: err}
 	}
 	return n, addr, err
@@ -120,7 +128,7 @@ func (c *UnixConn) ReadFrom(b []byte) (int, Addr, error) {
 		return 0, nil, syscall.EINVAL
 	}
 	n, addr, err := c.readFrom(b)
-	if err != nil {
+	if err != nil && err != io.EOF {
 		err = &OpError{Op: "read", Net: c.fd.net, Source: c.fd.laddr, Addr: c.fd.raddr, Err: err}
 	}
 	if addr == nil {
@@ -141,7 +149,7 @@ func (c *UnixConn) ReadMsgUnix(b, oob []byte) (n, oobn, flags int, addr *UnixAdd
 		return 0, 0, 0, nil, syscall.EINVAL
 	}
 	n, oobn, flags, addr, err = c.readMsg(b, oob)
-	if err != nil {
+	if err != nil && err != io.EOF {
 		err = &OpError{Op: "read", Net: c.fd.net, Source: c.fd.laddr, Addr: c.fd.raddr, Err: err}
 	}
 	return

package/bin/go/src/net/url/url.go

@@ -837,6 +837,13 @@ func (u *URL) String() string {
 			}
 		}
 		path := u.EscapedPath()
+		if u.OmitHost && u.Host == "" && u.User == nil && strings.HasPrefix(path, "//") {
+			// Escape the first / in a path starting with "//" and no authority
+			// so that re-parsing the URL doesn't turn the path into an authority
+			// (e.g., Path="//host/p" producing "http://host/p").
+			buf.WriteString("%2F")
+			path = path[1:]
+		}
 		if path != "" && path[0] != '/' && u.Host != "" {
 			buf.WriteByte('/')
 		}
@@ -919,6 +926,19 @@ func (v Values) Has(key string) bool {
 	return ok
 }
 
+// Clone creates a deep copy of the subject [Values].
+func (vs Values) Clone() Values {
+	if vs == nil {
+		return nil
+	}
+
+	newVals := make(Values, len(vs))
+	for k, v := range vs {
+		newVals[k] = slices.Clone(v)
+	}
+	return newVals
+}
+
 // ParseQuery parses the URL-encoded query string and returns
 // a map listing the values specified for each key.
 // ParseQuery always returns a non-nil map containing all the
@@ -1318,3 +1338,16 @@ func JoinPath(base string, elem ...string) (result string, err error) {
 	}
 	return res.String(), nil
 }
+
+// Clone creates a deep copy of the fields of the subject [URL].
+func (u *URL) Clone() *URL {
+	if u == nil {
+		return nil
+	}
+
+	uc := new(*u)
+	if u.User != nil {
+		uc.User = new(*u.User)
+	}
+	return uc
+}

package/bin/go/src/os/dir_darwin.go

@@ -5,6 +5,7 @@
 package os
 
 import (
+	"errors"
 	"io"
 	"runtime"
 	"syscall"
@@ -94,6 +95,12 @@ func (f *File) readdir(n int, mode readdirMode) (names []string, dirents []DirEn
 				// Treat as if it didn't exist.
 				continue
 			}
+			if errors.Is(err, syscall.EBADF) {
+				// Work around go.dev/issue/80143 during
+				// os.ReadDir("/dev/fd") by skipping kqueue fds.
+				// Exercised by TestReadDirFD.
+				continue
+			}
 			if err != nil {
 				return nil, dirents, nil, err
 			}

package/bin/go/src/os/exec/exec.go

@@ -203,6 +203,11 @@ type Cmd struct {
 	// stops copying, either because it has reached the end of Stdin
 	// (EOF or a read error), or because writing to the pipe returned an error,
 	// or because a nonzero WaitDelay was set and expired.
+	//
+	// Regardless of WaitDelay, Wait can block until a Read from
+	// Stdin completes. If you need to use a blocking io.Reader,
+	// use the StdinPipe method to get a pipe, copy from the Reader
+	// to the pipe, and arrange to close the Reader after Wait returns.
 	Stdin io.Reader
 
 	// Stdout and Stderr specify the process's standard output and error.
@@ -219,6 +224,12 @@ type Cmd struct {
 	// goroutine reaches EOF or encounters an error or a nonzero WaitDelay
 	// expires.
 	//
+	// Regardless of WaitDelay, Wait can block until a Write to
+	// Stdout or Stderr completes. If you need to use a blocking io.Writer,
+	// use the StdoutPipe or StderrPipe method to get a pipe,
+	// copy from the pipe to the Writer, and arrange to close the
+	// Writer after Wait returns.
+	//
 	// If Stdout and Stderr are the same writer, and have a type that can
 	// be compared with ==, at most one goroutine at a time will call Write.
 	Stdout io.Writer
@@ -505,7 +516,7 @@ func (c *Cmd) String() string {
 	// report the exact executable path (plus args)
 	b := new(strings.Builder)
 	b.WriteString(c.Path)
-	for _, a := range c.Args[1:] {
+	for _, a := range c.argv()[1:] {
 		b.WriteByte(' ')
 		b.WriteString(a)
 	}
@@ -918,6 +929,9 @@ func (e *ExitError) Error() string {
 // If any of c.Stdin, c.Stdout or c.Stderr are not an [*os.File], Wait also waits
 // for the respective I/O loop copying to or from the process to complete.
 //
+// Wait must not be called concurrently from multiple goroutines.
+// A custom Cmd.Cancel function should not call Wait.
+//
 // Wait releases any resources associated with the [Cmd].
 func (c *Cmd) Wait() error {
 	if c.Process == nil {
@@ -1254,7 +1268,7 @@ func dedupEnv(env []string) ([]string, error) {
 
 // dedupEnvCase is dedupEnv with a case option for testing.
 // If caseInsensitive is true, the case of keys is ignored.
-// If nulOK is false, items containing NUL characters are allowed.
+// If nulOK is false, items containing NUL characters are rejected.
 func dedupEnvCase(caseInsensitive, nulOK bool, env []string) ([]string, error) {
 	// Construct the output in reverse order, to preserve the
 	// last occurrence of each key.

package/bin/go/src/os/exec.go

@@ -41,6 +41,7 @@ const (
 
 // Process stores the information about a process created by [StartProcess].
 type Process struct {
+	// Pid is the operating system process ID.
 	Pid int
 
 	// state contains the atomic process state.

package/bin/go/src/os/file.go

@@ -839,7 +839,13 @@ func (dir dirFS) ReadLink(name string) (string, error) {
 	if err != nil {
 		return "", &PathError{Op: "readlink", Path: name, Err: err}
 	}
-	return Readlink(fullname)
+	f, err := Readlink(fullname)
+	if err != nil {
+		// See comment in dirFS.Open.
+		err.(*PathError).Path = name
+		return "", err
+	}
+	return f, nil
 }
 
 // join returns the path for name in dir.
@@ -861,6 +867,7 @@ func (dir dirFS) join(name string) (string, error) {
 // A successful call returns err == nil, not err == EOF.
 // Because ReadFile reads the whole file, it does not treat an EOF from Read
 // as an error to be reported.
+// If there is an error, it will be of type [*PathError].
 func ReadFile(name string) ([]byte, error) {
 	f, err := Open(name)
 	if err != nil {

package/bin/go/src/os/root_windows.go

@@ -190,7 +190,7 @@ func rootOpenDir(parent syscall.Handle, name string) (syscall.Handle, error) {
 	h, err := openat(parent, name, syscall.O_RDONLY|syscall.O_CLOEXEC|windows.O_DIRECTORY, 0)
 	if err == syscall.ERROR_FILE_NOT_FOUND {
 		// Windows returns:
-		//   - ERROR_PATH_NOT_FOUND if any path compoenent before the leaf
+		//   - ERROR_PATH_NOT_FOUND if any path component before the leaf
 		//     does not exist or is not a directory.
 		//   - ERROR_FILE_NOT_FOUND if the leaf does not exist.
 		//
@@ -248,6 +248,10 @@ func rootSymlink(r *Root, oldname, newname string) error {
 		return syscall.EINVAL
 	}
 
+	// Windows treats / and \ as equivalent almost everywhere, but not in symlink targets.
+	// Match os.Symlink behavior and convert / to \.
+	oldname = filepathlite.FromSlash(oldname)
+
 	// CreateSymbolicLinkW converts volume-relative paths into absolute ones.
 	// Do the same.
 	if filepathlite.VolumeNameLen(oldname) > 0 && !filepathlite.IsAbs(oldname) {

package/bin/go/src/os/signal/doc.go

@@ -213,8 +213,9 @@ before raising the signal.
 On Windows a ^C (Control-C) or ^BREAK (Control-Break) normally cause
 the program to exit. If Notify is called for [os.Interrupt], ^C or ^BREAK
 will cause [os.Interrupt] to be sent on the channel, and the program will
-not exit. If Reset is called, or Stop is called on all channels passed
-to Notify, then the default behavior will be restored.
+not exit. [os.Interrupt] is the only signal that can be used on Windows.
+If Reset is called, or Stop is called on all channels passed to Notify,
+then the default behavior will be restored.
 
 Additionally, if Notify is called, and Windows sends CTRL_CLOSE_EVENT,
 CTRL_LOGOFF_EVENT or CTRL_SHUTDOWN_EVENT to the process, Notify will