net,os: support converting between *os.File and net.Conn on Windows

The runtime poller and os.NewFile recently gained support for
disassociating the handle from the runtime poller IOCP (see CL 664455).
This was the main blocker for allowing the conversion between *os.File
and net.Conn.

Implementing the conversion is now trivial. The only remaining work,
implemented in this CL, is improving os.NewFile to also support
socket handles and updating some build tags so that Windows can share
almost the same net's File implementation as Unix.

There is one important limitation, though: the duplicated socket handle
returned by the various File methods in the net package is not
usable on other process. If someone needs to pass a socket handle to
another process, they should manually call the WSADuplicateSocket
Windows API passing the process ID of the target process.

Fixes #9503.
Fixes #10350.
Updates #19098.

Cq-Include-Trybots: luci.golang.try:gotip-windows-amd64-race,gotip-windows-amd64-longtest,gotip-windows-arm64
Change-Id: Ic43cadaac2662b925d57a9d362ddc7ae21d1b56e
Reviewed-on: https://go-review.googlesource.com/c/go/+/668195
Reviewed-by: Damien Neil <[email protected]>
LUCI-TryBot-Result: Go LUCI <[email protected]>
Reviewed-by: Carlos Amedee <[email protected]>

Author: qmuntal

doc/next/6-stdlib/99-minor/net/10350.md

@@ -0,0 +1,3 @@
+On Windows, the [TCPConn.File], [UDPConn.File], [UnixConn.File],
+[IPConn.File], [TCPListener.File], and [UnixListener.File]
+methods are now supported.

doc/next/6-stdlib/99-minor/net/9503.md

@@ -0,0 +1,2 @@
+On Windows, the [FileConn], [FilePacketConn], [FileListener]
+functions are now supported.

src/internal/syscall/windows/net_windows.go

@@ -18,6 +18,7 @@ func WSASendtoInet4(s syscall.Handle, bufs *syscall.WSABuf, bufcnt uint32, sent
 func WSASendtoInet6(s syscall.Handle, bufs *syscall.WSABuf, bufcnt uint32, sent *uint32, flags uint32, to *syscall.SockaddrInet6, overlapped *syscall.Overlapped, croutine *byte) (err error)
 
 const (
+	SO_TYPE                                = 0x1008
 	SIO_TCP_INITIAL_RTO                    = syscall.IOC_IN | syscall.IOC_VENDOR | 17
 	TCP_INITIAL_RTO_UNSPECIFIED_RTT        = ^uint16(0)
 	TCP_INITIAL_RTO_NO_SYN_RETRANSMISSIONS = ^uint8(1)

src/internal/syscall/windows/syscall_windows.go

@@ -268,6 +268,7 @@ type WSAMsg struct {
 }
 
 //sys	WSASocket(af int32, typ int32, protocol int32, protinfo *syscall.WSAProtocolInfo, group uint32, flags uint32) (handle syscall.Handle, err error) [failretval==syscall.InvalidHandle] = ws2_32.WSASocketW
+//sys	WSADuplicateSocket(s syscall.Handle, processID uint32, info *syscall.WSAProtocolInfo) (err error) [failretval!=0] = ws2_32.WSADuplicateSocketW
 //sys	WSAGetOverlappedResult(h syscall.Handle, o *syscall.Overlapped, bytes *uint32, wait bool, flags *uint32) (err error) = ws2_32.WSAGetOverlappedResult
 
 func loadWSASendRecvMsg() error {

src/internal/syscall/windows/zsyscall_windows.go

@@ -736,11 +736,6 @@ third:
 }
 
 func TestFileError(t *testing.T) {
-	switch runtime.GOOS {
-	case "windows":
-		t.Skipf("not supported on %s", runtime.GOOS)
-	}
-
 	f, err := os.CreateTemp("", "go-nettest")
 	if err != nil {
 		t.Fatal(err)

src/net/error_test.go

@@ -26,6 +26,17 @@ type netFD struct {
 	raddr       Addr
 }
 
+func (fd *netFD) name() string {
+	var ls, rs string
+	if fd.laddr != nil {
+		ls = fd.laddr.String()
+	}
+	if fd.raddr != nil {
+		rs = fd.raddr.String()
+	}
+	return fd.net + ":" + ls + "->" + rs
+}
+
 func (fd *netFD) setAddr(laddr, raddr Addr) {
 	fd.laddr = laddr
 	fd.raddr = raddr

src/net/fd_posix.go

@@ -41,17 +41,6 @@ func (fd *netFD) init() error {
 	return fd.pfd.Init(fd.net, true)
 }
 
-func (fd *netFD) name() string {
-	var ls, rs string
-	if fd.laddr != nil {
-		ls = fd.laddr.String()
-	}
-	if fd.raddr != nil {
-		rs = fd.raddr.String()
-	}
-	return fd.net + ":" + ls + "->" + rs
-}
-
 func (fd *netFD) connect(ctx context.Context, la, ra syscall.Sockaddr) (rsa syscall.Sockaddr, ret error) {
 	// Do not need to call fd.writeLock here,
 	// because fd is not yet accessible to user,

src/net/fd_unix.go

@@ -233,9 +233,23 @@ func (fd *netFD) accept() (*netFD, error) {
 	return netfd, nil
 }
 
-// Unimplemented functions.
-
 func (fd *netFD) dup() (*os.File, error) {
-	// TODO: Implement this, perhaps using internal/poll.DupCloseOnExec.
-	return nil, syscall.EWINDOWS
+	// Disassociate the IOCP from the socket,
+	// it is not safe to share a duplicated handle
+	// that is associated with IOCP.
+	if err := fd.pfd.DisassociateIOCP(); err != nil {
+		return nil, err
+	}
+	var h syscall.Handle
+	var syserr error
+	err := fd.pfd.RawControl(func(fd uintptr) {
+		h, syserr = dupSocket(syscall.Handle(fd))
+	})
+	if err != nil {
+		err = syserr
+	}
+	if err != nil {
+		return nil, err
+	}
+	return os.NewFile(uintptr(h), fd.name()), nil
 }

src/net/fd_windows.go

@@ -6,7 +6,7 @@ package net
 
 import "os"
 
-// BUG(mikio): On JS and Windows, the FileConn, FileListener and
+// BUG(mikio): On JS, the FileConn, FileListener and
 // FilePacketConn functions are not implemented.
 
 type fileAddr string

src/net/file.go

@@ -0,0 +1,104 @@
+// 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.
+
+//go:build unix || windows
+
+package net
+
+import (
+	"internal/poll"
+	"os"
+	"syscall"
+)
+
+func newFileFD(f *os.File) (*netFD, error) {
+	s, err := dupFileSocket(f)
+	if err != nil {
+		return nil, err
+	}
+	family := syscall.AF_UNSPEC
+	sotype, err := syscall.GetsockoptInt(s, syscall.SOL_SOCKET, _SO_TYPE)
+	if err != nil {
+		poll.CloseFunc(s)
+		return nil, os.NewSyscallError("getsockopt", err)
+	}
+	lsa, _ := syscall.Getsockname(s)
+	rsa, _ := syscall.Getpeername(s)
+	switch lsa.(type) {
+	case *syscall.SockaddrInet4:
+		family = syscall.AF_INET
+	case *syscall.SockaddrInet6:
+		family = syscall.AF_INET6
+	case *syscall.SockaddrUnix:
+		family = syscall.AF_UNIX
+	default:
+		poll.CloseFunc(s)
+		return nil, syscall.EPROTONOSUPPORT
+	}
+	fd, err := newFD(s, family, sotype, "")
+	if err != nil {
+		poll.CloseFunc(s)
+		return nil, err
+	}
+	laddr := fd.addrFunc()(lsa)
+	raddr := fd.addrFunc()(rsa)
+	fd.net = laddr.Network()
+	if err := fd.init(); err != nil {
+		fd.Close()
+		return nil, err
+	}
+	fd.setAddr(laddr, raddr)
+	return fd, nil
+}
+
+func fileConn(f *os.File) (Conn, error) {
+	fd, err := newFileFD(f)
+	if err != nil {
+		return nil, err
+	}
+	switch fd.laddr.(type) {
+	case *TCPAddr:
+		return newTCPConn(fd, defaultTCPKeepAliveIdle, KeepAliveConfig{}, testPreHookSetKeepAlive, testHookSetKeepAlive), nil
+	case *UDPAddr:
+		return newUDPConn(fd), nil
+	case *IPAddr:
+		return newIPConn(fd), nil
+	case *UnixAddr:
+		return newUnixConn(fd), nil
+	}
+	fd.Close()
+	return nil, syscall.EINVAL
+}
+
+func fileListener(f *os.File) (Listener, error) {
+	fd, err := newFileFD(f)
+	if err != nil {
+		return nil, err
+	}
+	switch laddr := fd.laddr.(type) {
+	case *TCPAddr:
+		return &TCPListener{fd: fd}, nil
+	case *UnixAddr:
+		return &UnixListener{fd: fd, path: laddr.Name, unlink: false}, nil
+	}
+	fd.Close()
+	return nil, syscall.EINVAL
+}
+
+func filePacketConn(f *os.File) (PacketConn, error) {
+	fd, err := newFileFD(f)
+	if err != nil {
+		return nil, err
+	}
+	switch fd.laddr.(type) {
+	case *UDPAddr:
+		return newUDPConn(fd), nil
+	case *IPAddr:
+		return newIPConn(fd), nil
+	case *UnixAddr:
+		return newUnixConn(fd), nil
+	}
+	fd.Close()
+	return nil, syscall.EINVAL
+}

src/net/file_posix.go

@@ -29,7 +29,7 @@ var fileConnTests = []struct {
 
 func TestFileConn(t *testing.T) {
 	switch runtime.GOOS {
-	case "plan9", "windows", "js", "wasip1":
+	case "plan9", "js", "wasip1":
 		t.Skipf("not supported on %s", runtime.GOOS)
 	}
 
@@ -130,7 +130,7 @@ var fileListenerTests = []struct {
 
 func TestFileListener(t *testing.T) {
 	switch runtime.GOOS {
-	case "plan9", "windows", "js", "wasip1":
+	case "plan9", "js", "wasip1":
 		t.Skipf("not supported on %s", runtime.GOOS)
 	}
 
@@ -222,7 +222,7 @@ var filePacketConnTests = []struct {
 
 func TestFilePacketConn(t *testing.T) {
 	switch runtime.GOOS {
-	case "plan9", "windows", "js", "wasip1":
+	case "plan9", "js", "wasip1":
 		t.Skipf("not supported on %s", runtime.GOOS)
 	}
 
@@ -289,7 +289,7 @@ func TestFilePacketConn(t *testing.T) {
 // Issue 24483.
 func TestFileCloseRace(t *testing.T) {
 	switch runtime.GOOS {
-	case "plan9", "windows", "js", "wasip1":
+	case "plan9", "js", "wasip1":
 		t.Skipf("not supported on %s", runtime.GOOS)
 	}
 	if !testableNetwork("tcp") {

src/net/file_test.go

@@ -12,7 +12,9 @@ import (
 	"syscall"
 )
 
-func dupSocket(f *os.File) (int, error) {
+const _SO_TYPE = syscall.SO_TYPE
+
+func dupFileSocket(f *os.File) (int, error) {
 	s, call, err := poll.DupCloseOnExec(int(f.Fd()))
 	if err != nil {
 		if call != "" {
@@ -26,94 +28,3 @@ func dupSocket(f *os.File) (int, error) {
 	}
 	return s, nil
 }
-
-func newFileFD(f *os.File) (*netFD, error) {
-	s, err := dupSocket(f)
-	if err != nil {
-		return nil, err
-	}
-	family := syscall.AF_UNSPEC
-	sotype, err := syscall.GetsockoptInt(s, syscall.SOL_SOCKET, syscall.SO_TYPE)
-	if err != nil {
-		poll.CloseFunc(s)
-		return nil, os.NewSyscallError("getsockopt", err)
-	}
-	lsa, _ := syscall.Getsockname(s)
-	rsa, _ := syscall.Getpeername(s)
-	switch lsa.(type) {
-	case *syscall.SockaddrInet4:
-		family = syscall.AF_INET
-	case *syscall.SockaddrInet6:
-		family = syscall.AF_INET6
-	case *syscall.SockaddrUnix:
-		family = syscall.AF_UNIX
-	default:
-		poll.CloseFunc(s)
-		return nil, syscall.EPROTONOSUPPORT
-	}
-	fd, err := newFD(s, family, sotype, "")
-	if err != nil {
-		poll.CloseFunc(s)
-		return nil, err
-	}
-	laddr := fd.addrFunc()(lsa)
-	raddr := fd.addrFunc()(rsa)
-	fd.net = laddr.Network()
-	if err := fd.init(); err != nil {
-		fd.Close()
-		return nil, err
-	}
-	fd.setAddr(laddr, raddr)
-	return fd, nil
-}
-
-func fileConn(f *os.File) (Conn, error) {
-	fd, err := newFileFD(f)
-	if err != nil {
-		return nil, err
-	}
-	switch fd.laddr.(type) {
-	case *TCPAddr:
-		return newTCPConn(fd, defaultTCPKeepAliveIdle, KeepAliveConfig{}, testPreHookSetKeepAlive, testHookSetKeepAlive), nil
-	case *UDPAddr:
-		return newUDPConn(fd), nil
-	case *IPAddr:
-		return newIPConn(fd), nil
-	case *UnixAddr:
-		return newUnixConn(fd), nil
-	}
-	fd.Close()
-	return nil, syscall.EINVAL
-}
-
-func fileListener(f *os.File) (Listener, error) {
-	fd, err := newFileFD(f)
-	if err != nil {
-		return nil, err
-	}
-	switch laddr := fd.laddr.(type) {
-	case *TCPAddr:
-		return &TCPListener{fd: fd}, nil
-	case *UnixAddr:
-		return &UnixListener{fd: fd, path: laddr.Name, unlink: false}, nil
-	}
-	fd.Close()
-	return nil, syscall.EINVAL
-}
-
-func filePacketConn(f *os.File) (PacketConn, error) {
-	fd, err := newFileFD(f)
-	if err != nil {
-		return nil, err
-	}
-	switch fd.laddr.(type) {
-	case *UDPAddr:
-		return newUDPConn(fd), nil
-	case *IPAddr:
-		return newIPConn(fd), nil
-	case *UnixAddr:
-		return newUnixConn(fd), nil
-	}
-	fd.Close()
-	return nil, syscall.EINVAL
-}