net, syscall, internal/syscall/windows: implement FileConn, FilePacketConn, FileListener

DO NOT REVIEW

Fixes golang#9503.
Fixes golang#10350.

Change-Id: If0851cb3340281cc1ea523cd0ddf48fc7f87c775

Author: mattn

src/internal/syscall/windows/syscall_windows.go

@@ -101,6 +101,11 @@ type IpAdapterAddresses struct {
 	/* more fields might be present here. */
 }
 
+type WSANetworkEvents struct {
+	NetworkEvents int32
+	ErrorCode     [10]int32
+}
+
 const (
 	IfOperStatusUp             = 1
 	IfOperStatusDown           = 2
@@ -292,3 +297,15 @@ const (
 func LoadGetFinalPathNameByHandle() error {
 	return procGetFinalPathNameByHandleW.Find()
 }
+
+const (
+	SO_TYPE = 0x1008
+)
+
+const (
+	HANDLE_FLAG_INHERIT            = 0x01
+	HANDLE_FLAG_PROTECT_FROM_CLOSE = 0x02
+)
+
+//sys	WSAEnumNetworkEvents(handle syscall.Handle, event syscall.Handle, events *WSANetworkEvents) (err error) [failretval==socket_error] = ws2_32.WSAEnumNetworkEvents
+//sys	GetHandleInformation(handle syscall.Handle, flags *uint32) (err error) = GetHandleInformation

src/internal/syscall/windows/zsyscall_windows.go

@@ -66,6 +66,9 @@ var (
 	procGetProfilesDirectoryW     = moduserenv.NewProc("GetProfilesDirectoryW")
 	procNetUserGetLocalGroups     = modnetapi32.NewProc("NetUserGetLocalGroups")
 	procGetProcessMemoryInfo      = modpsapi.NewProc("GetProcessMemoryInfo")
+
+	procWSAEnumNetworkEvents = modws2_32.NewProc("WSAEnumNetworkEvents")
+	procGetHandleInformation = modkernel32.NewProc("GetHandleInformation")
 )
 
 func GetAdaptersAddresses(family uint32, flags uint32, reserved uintptr, adapterAddresses *IpAdapterAddresses, sizePointer *uint32) (errcode error) {
@@ -321,3 +324,27 @@ func GetProcessMemoryInfo(handle syscall.Handle, memCounters *PROCESS_MEMORY_COU
 	}
 	return
 }
+
+func WSAEnumNetworkEvents(handle syscall.Handle, event syscall.Handle, events *WSANetworkEvents) (err error) {
+	r1, _, e1 := syscall.Syscall(procWSAEnumNetworkEvents.Addr(), 3, uintptr(handle), uintptr(event), uintptr(unsafe.Pointer(events)))
+	if r1 == socket_error {
+		if e1 != 0 {
+			err = error(e1)
+		} else {
+			err = syscall.EINVAL
+		}
+	}
+	return
+}
+
+func GetHandleInformation(handle syscall.Handle, flags *uint32) (err error) {
+	r1, _, e1 := syscall.Syscall(procGetHandleInformation.Addr(), 2, uintptr(handle), uintptr(unsafe.Pointer(flags)), 0)
+	if r1 == 0 {
+		if e1 != 0 {
+			err = error(e1)
+		} else {
+			err = syscall.EINVAL
+		}
+	}
+	return
+}

src/net/fd_windows.go

@@ -35,6 +35,7 @@ type netFD struct {
 	net         string
 	laddr       Addr
 	raddr       Addr
+	isFile      bool
 }
 
 func newFD(sysfd syscall.Handle, family, sotype int, net string) (*netFD, error) {
@@ -206,6 +207,7 @@ func (fd *netFD) accept() (*netFD, error) {
 		poll.CloseFunc(s)
 		return nil, err
 	}
+	netfd.isFile = fd.isFile
 	if err := netfd.init(); err != nil {
 		fd.Close()
 		return nil, err
@@ -238,6 +240,24 @@ func (fd *netFD) writeMsg(p []byte, oob []byte, sa syscall.Sockaddr) (n int, oob
 // Unimplemented functions.
 
 func (fd *netFD) dup() (*os.File, error) {
-	// TODO: Implement this
-	return nil, syscall.EWINDOWS
+	var s syscall.Handle
+	p, _ := syscall.GetCurrentProcess()
+	err := syscall.DuplicateHandle(p, syscall.Handle(fd.pfd.Sysfd), p, &s, 0, true, syscall.DUPLICATE_SAME_ACCESS)
+	if err != nil {
+		return nil, os.NewSyscallError("duplicatehandle", err)
+	}
+	return os.NewFile(uintptr(s), fd.name()), nil
+}
+
+// Unimplemented functions.
+
+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
 }

src/net/file_windows.go

@@ -5,21 +5,126 @@
 package net
 
 import (
+	"internal/poll"
+	"internal/syscall/windows"
 	"os"
 	"syscall"
 )
 
+func dupCloseOnExec(s int) (syscall.Handle, error) {
+	var ns syscall.Handle
+	p, _ := syscall.GetCurrentProcess()
+	err := syscall.DuplicateHandle(p, syscall.Handle(s), p, &ns, 0, false, syscall.DUPLICATE_SAME_ACCESS)
+	if err != nil {
+		return syscall.InvalidHandle, os.NewSyscallError("duplicatehandle", err)
+	}
+	return ns, nil
+}
+
+func newFileFD(f *os.File) (*netFD, error) {
+	var flags uint32
+
+	var err error
+	s := syscall.Handle(f.Fd())
+	if err := windows.GetHandleInformation(s, &flags); err != nil {
+		return nil, err
+	}
+
+	s, err = dupCloseOnExec(int(f.Fd()))
+	if err != nil {
+		return nil, err
+	}
+
+	if err = syscall.SetNonblock(s, true); err != nil {
+		poll.CloseFunc(s)
+		return nil, err
+	}
+	family := syscall.AF_UNSPEC
+	sotype, err := syscall.GetsockoptInt(s, syscall.SOL_SOCKET, windows.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:
+		poll.CloseFunc(s)
+		return nil, syscall.EWINDOWS
+	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.pfd.Init("tcp", fd.isFile); err != nil {
+		fd.Close()
+		return nil, err
+	}
+	fd.setAddr(laddr, raddr)
+	return fd, nil
+}
+
 func fileConn(f *os.File) (Conn, error) {
-	// TODO: Implement this
-	return nil, syscall.EWINDOWS
+	fd, err := newFileFD(f)
+	if err != nil {
+		return nil, err
+	}
+	switch fd.laddr.(type) {
+	case *TCPAddr:
+		return newTCPConn(fd), nil
+	case *UDPAddr:
+		return newUDPConn(fd), nil
+	case *IPAddr:
+		return newIPConn(fd), nil
+	case *UnixAddr:
+		fd.Close()
+		return nil, syscall.EWINDOWS
+	}
+	fd.Close()
+	return nil, syscall.EINVAL
 }
 
 func fileListener(f *os.File) (Listener, error) {
-	// TODO: Implement this
-	return nil, syscall.EWINDOWS
+	fd, err := newFileFD(f)
+	if err != nil {
+		return nil, err
+	}
+	switch fd.laddr.(type) {
+	case *TCPAddr:
+		return &TCPListener{fd}, nil
+	case *UnixAddr:
+		fd.Close()
+		return nil, syscall.EWINDOWS
+	}
+	fd.Close()
+	return nil, syscall.EINVAL
 }
 
 func filePacketConn(f *os.File) (PacketConn, error) {
-	// TODO: Implement this
-	return nil, syscall.EWINDOWS
+	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:
+		fd.Close()
+		return nil, syscall.EWINDOWS
+	}
+	fd.Close()
+	return nil, syscall.EINVAL
 }