fix windows support

1. Switch back to the syscall package for errors. That way, we get consistent
   errors on all platforms.
2. Use `sys/windows` where appropriate.
3. Export type aliases for the *Sockaddr* types. That way, we can use the
   platform-specific types but call them the same name, regardless of platform.

README.md

@@ -5,8 +5,8 @@ This package extracts unexported code from `golang.org/x/unix` to help in conver
 between:
 
 ```Go
-unix.Sockaddr
-unix.RawSockaddrAny
+${platform}.Sockaddr
+${platform}.RawSockaddrAny
 C.struct_sockaddr_any
 net.*Addr
 ```

net/net.go

-// package sockaddrnet provides conversions between net.Addr and unix.Sockaddr
+// package sockaddrnet provides conversions between net.Addr and Sockaddr
 package sockaddrnet
 
 import (
-	"golang.org/x/sys/unix"
 	"net"
 )
 
@@ -95,9 +94,9 @@ func NetAddrSOCK(addr net.Addr) int {
 	}
 }
 
-// NetAddrToSockaddr converts a net.Addr to a unix.Sockaddr.
+// NetAddrToSockaddr converts a net.Addr to a Sockaddr.
 // Returns nil if the input is invalid or conversion is not possible.
-func NetAddrToSockaddr(addr net.Addr) unix.Sockaddr {
+func NetAddrToSockaddr(addr net.Addr) Sockaddr {
 	switch addr := addr.(type) {
 	case *net.IPAddr:
 		return IPAddrToSockaddr(addr)
@@ -113,42 +112,42 @@ func NetAddrToSockaddr(addr net.Addr) unix.Sockaddr {
 	}
 }
 
-// IPAndZoneToSockaddr converts a net.IP (with optional IPv6 Zone) to a unix.Sockaddr
+// IPAndZoneToSockaddr converts a net.IP (with optional IPv6 Zone) to a Sockaddr
 // Returns nil if conversion fails.
-func IPAndZoneToSockaddr(ip net.IP, zone string) unix.Sockaddr {
+func IPAndZoneToSockaddr(ip net.IP, zone string) Sockaddr {
 	switch {
 	case len(ip) < net.IPv4len: // default to IPv4
 		buf := [4]byte{0, 0, 0, 0}
-		return &unix.SockaddrInet4{Addr: buf}
+		return &SockaddrInet4{Addr: buf}
 
 	case ip.To4() != nil:
 		var buf [4]byte
 		copy(buf[:], ip[12:16]) // last 4 bytes
-		return &unix.SockaddrInet4{Addr: buf}
+		return &SockaddrInet4{Addr: buf}
 
 	case ip.To16() != nil:
 		var buf [16]byte
 		copy(buf[:], ip)
-		return &unix.SockaddrInet6{Addr: buf, ZoneId: uint32(IP6ZoneToInt(zone))}
+		return &SockaddrInet6{Addr: buf, ZoneId: uint32(IP6ZoneToInt(zone))}
 	}
 	panic("should be unreachable")
 }
 
-// IPAddrToSockaddr converts a net.IPAddr to a unix.Sockaddr.
+// IPAddrToSockaddr converts a net.IPAddr to a Sockaddr.
 // Returns nil if conversion fails.
-func IPAddrToSockaddr(addr *net.IPAddr) unix.Sockaddr {
+func IPAddrToSockaddr(addr *net.IPAddr) Sockaddr {
 	return IPAndZoneToSockaddr(addr.IP, addr.Zone)
 }
 
-// TCPAddrToSockaddr converts a net.TCPAddr to a unix.Sockaddr.
+// TCPAddrToSockaddr converts a net.TCPAddr to a Sockaddr.
 // Returns nil if conversion fails.
-func TCPAddrToSockaddr(addr *net.TCPAddr) unix.Sockaddr {
+func TCPAddrToSockaddr(addr *net.TCPAddr) Sockaddr {
 	sa := IPAndZoneToSockaddr(addr.IP, addr.Zone)
 	switch sa := sa.(type) {
-	case *unix.SockaddrInet4:
+	case *SockaddrInet4:
 		sa.Port = addr.Port
 		return sa
-	case *unix.SockaddrInet6:
+	case *SockaddrInet6:
 		sa.Port = addr.Port
 		return sa
 	default:
@@ -156,15 +155,15 @@ func TCPAddrToSockaddr(addr *net.TCPAddr) unix.Sockaddr {
 	}
 }
 
-// UDPAddrToSockaddr converts a net.UDPAddr to a unix.Sockaddr.
+// UDPAddrToSockaddr converts a net.UDPAddr to a Sockaddr.
 // Returns nil if conversion fails.
-func UDPAddrToSockaddr(addr *net.UDPAddr) unix.Sockaddr {
+func UDPAddrToSockaddr(addr *net.UDPAddr) Sockaddr {
 	sa := IPAndZoneToSockaddr(addr.IP, addr.Zone)
 	switch sa := sa.(type) {
-	case *unix.SockaddrInet4:
+	case *SockaddrInet4:
 		sa.Port = addr.Port
 		return sa
-	case *unix.SockaddrInet6:
+	case *SockaddrInet6:
 		sa.Port = addr.Port
 		return sa
 	default:
@@ -172,34 +171,34 @@ func UDPAddrToSockaddr(addr *net.UDPAddr) unix.Sockaddr {
 	}
 }
 
-// UnixAddrToSockaddr converts a net.UnixAddr to a unix.Sockaddr, and returns
+// UnixAddrToSockaddr converts a net.UnixAddr to a Sockaddr, and returns
 // the type (unix.SOCK_STREAM, unix.SOCK_DGRAM, unix.SOCK_SEQPACKET)
 // Returns (nil, 0) if conversion fails.
-func UnixAddrToSockaddr(addr *net.UnixAddr) (unix.Sockaddr, int) {
+func UnixAddrToSockaddr(addr *net.UnixAddr) (Sockaddr, int) {
 	t := 0
 	switch addr.Net {
 	case "unix":
-		t = unix.SOCK_STREAM
+		t = SOCK_STREAM
 	case "unixgram":
-		t = unix.SOCK_DGRAM
+		t = SOCK_DGRAM
 	case "unixpacket":
-		t = unix.SOCK_SEQPACKET
+		t = SOCK_SEQPACKET
 	default:
 		return nil, 0
 	}
-	return &unix.SockaddrUnix{Name: addr.Name}, t
+	return &SockaddrUnix{Name: addr.Name}, t
 }
 
-// IPAndZoneToSockaddr converts a net.IP (with optional IPv6 Zone) to a unix.Sockaddr
+// IPAndZoneToSockaddr converts a net.IP (with optional IPv6 Zone) to a Sockaddr
 // Returns nil if conversion fails.
-func SockaddrToIPAndZone(sa unix.Sockaddr) (net.IP, string) {
+func SockaddrToIPAndZone(sa Sockaddr) (net.IP, string) {
 	switch sa := sa.(type) {
-	case *unix.SockaddrInet4:
+	case *SockaddrInet4:
 		ip := make([]byte, 16)
 		copy(ip[12:16], sa.Addr[:])
 		return ip, ""
 
-	case *unix.SockaddrInet6:
+	case *SockaddrInet6:
 		ip := make([]byte, 16)
 		copy(ip, sa.Addr[:])
 		return ip, IP6ZoneToString(int(sa.ZoneId))
@@ -207,40 +206,40 @@ func SockaddrToIPAndZone(sa unix.Sockaddr) (net.IP, string) {
 	return nil, ""
 }
 
-// SockaddrToIPAddr converts a unix.Sockaddr to a net.IPAddr
+// SockaddrToIPAddr converts a Sockaddr to a net.IPAddr
 // Returns nil if conversion fails.
-func SockaddrToIPAddr(sa unix.Sockaddr) *net.IPAddr {
+func SockaddrToIPAddr(sa Sockaddr) *net.IPAddr {
 	ip, zone := SockaddrToIPAndZone(sa)
 	switch sa.(type) {
-	case *unix.SockaddrInet4:
+	case *SockaddrInet4:
 		return &net.IPAddr{IP: ip}
-	case *unix.SockaddrInet6:
+	case *SockaddrInet6:
 		return &net.IPAddr{IP: ip, Zone: zone}
 	}
 	return nil
 }
 
-// SockaddrToTCPAddr converts a unix.Sockaddr to a net.TCPAddr
+// SockaddrToTCPAddr converts a Sockaddr to a net.TCPAddr
 // Returns nil if conversion fails.
-func SockaddrToTCPAddr(sa unix.Sockaddr) *net.TCPAddr {
+func SockaddrToTCPAddr(sa Sockaddr) *net.TCPAddr {
 	ip, zone := SockaddrToIPAndZone(sa)
 	switch sa := sa.(type) {
-	case *unix.SockaddrInet4:
+	case *SockaddrInet4:
 		return &net.TCPAddr{IP: ip, Port: sa.Port}
-	case *unix.SockaddrInet6:
+	case *SockaddrInet6:
 		return &net.TCPAddr{IP: ip, Port: sa.Port, Zone: zone}
 	}
 	return nil
 }
 
-// SockaddrToUDPAddr converts a unix.Sockaddr to a net.UDPAddr
+// SockaddrToUDPAddr converts a Sockaddr to a net.UDPAddr
 // Returns nil if conversion fails.
-func SockaddrToUDPAddr(sa unix.Sockaddr) *net.UDPAddr {
+func SockaddrToUDPAddr(sa Sockaddr) *net.UDPAddr {
 	ip, zone := SockaddrToIPAndZone(sa)
 	switch sa := sa.(type) {
-	case *unix.SockaddrInet4:
+	case *SockaddrInet4:
 		return &net.UDPAddr{IP: ip, Port: sa.Port}
-	case *unix.SockaddrInet6:
+	case *SockaddrInet6:
 		return &net.UDPAddr{IP: ip, Port: sa.Port, Zone: zone}
 	}
 	return nil
@@ -248,28 +247,28 @@ func SockaddrToUDPAddr(sa unix.Sockaddr) *net.UDPAddr {
 
 // from: go/src/pkg/net/unixsock_posix.go
 
-// SockaddrToUnixAddr converts a unix.Sockaddr to a net.UnixAddr
+// SockaddrToUnixAddr converts a Sockaddr to a net.UnixAddr
 // Returns nil if conversion fails.
-func SockaddrToUnixAddr(sa unix.Sockaddr) *net.UnixAddr {
-	if s, ok := sa.(*unix.SockaddrUnix); ok {
+func SockaddrToUnixAddr(sa Sockaddr) *net.UnixAddr {
+	if s, ok := sa.(*SockaddrUnix); ok {
 		return &net.UnixAddr{Name: s.Name, Net: "unix"}
 	}
 	return nil
 }
 
-// SockaddrToUnixgramAddr converts a unix.Sockaddr to a net.UnixAddr
+// SockaddrToUnixgramAddr converts a Sockaddr to a net.UnixAddr
 // Returns nil if conversion fails.
-func SockaddrToUnixgramAddr(sa unix.Sockaddr) *net.UnixAddr {
-	if s, ok := sa.(*unix.SockaddrUnix); ok {
+func SockaddrToUnixgramAddr(sa Sockaddr) *net.UnixAddr {
+	if s, ok := sa.(*SockaddrUnix); ok {
 		return &net.UnixAddr{Name: s.Name, Net: "unixgram"}
 	}
 	return nil
 }
 
-// SockaddrToUnixpacketAddr converts a unix.Sockaddr to a net.UnixAddr
+// SockaddrToUnixpacketAddr converts a Sockaddr to a net.UnixAddr
 // Returns nil if conversion fails.
-func SockaddrToUnixpacketAddr(sa unix.Sockaddr) *net.UnixAddr {
-	if s, ok := sa.(*unix.SockaddrUnix); ok {
+func SockaddrToUnixpacketAddr(sa Sockaddr) *net.UnixAddr {
+	if s, ok := sa.(*SockaddrUnix); ok {
 		return &net.UnixAddr{Name: s.Name, Net: "unixpacket"}
 	}
 	return nil

net/net_bsd.go

@@ -22,3 +22,9 @@ const (
 	SOCK_STREAM    = unix.SOCK_STREAM
 	SOCK_SEQPACKET = unix.SOCK_SEQPACKET
 )
+
+type Sockaddr = unix.Sockaddr
+type SockaddrInet4 = unix.SockaddrInet4
+type SockaddrInet6 = unix.SockaddrInet6
+type SockaddrUnix = unix.SockaddrUnix
+type RawSockaddrAny = unix.RawSockaddrAny

net/net_linux.go

@@ -20,3 +20,9 @@ const (
 	SOCK_STREAM    = unix.SOCK_STREAM
 	SOCK_SEQPACKET = unix.SOCK_SEQPACKET
 )
+
+type Sockaddr = unix.Sockaddr
+type SockaddrInet4 = unix.SockaddrInet4
+type SockaddrInet6 = unix.SockaddrInet6
+type SockaddrUnix = unix.SockaddrUnix
+type RawSockaddrAny = unix.RawSockaddrAny

net/net_windows.go

 package sockaddrnet
 
 import (
-	"golang.org/x/sys/unix"
+	"golang.org/x/sys/windows"
 )
 
 const (
-	AF_INET   = unix.AF_INET
-	AF_INET6  = unix.AF_INET6
-	AF_UNIX   = unix.AF_UNIX
-	AF_UNSPEC = unix.AF_UNSPEC
+	AF_INET   = windows.AF_INET
+	AF_INET6  = windows.AF_INET6
+	AF_UNIX   = windows.AF_UNIX
+	AF_UNSPEC = windows.AF_UNSPEC
 
-	IPPROTO_IP   = unix.IPPROTO_IP
-	IPPROTO_IPV4 = unix.IPPROTO_IPV4
-	IPPROTO_IPV6 = unix.IPPROTO_IPV6
-	IPPROTO_TCP  = unix.IPPROTO_TCP
-	IPPROTO_UDP  = unix.IPPROTO_UDP
+	IPPROTO_IP   = windows.IPPROTO_IP
+	IPPROTO_IPV4 = windows.IPPROTO_IPV4
+	IPPROTO_IPV6 = windows.IPPROTO_IPV6
+	IPPROTO_TCP  = windows.IPPROTO_TCP
+	IPPROTO_UDP  = windows.IPPROTO_UDP
 
-	SOCK_DGRAM     = unix.SOCK_DGRAM
-	SOCK_STREAM    = unix.SOCK_STREAM
-	SOCK_SEQPACKET = unix.SOCK_SEQPACKET
+	SOCK_DGRAM     = windows.SOCK_DGRAM
+	SOCK_STREAM    = windows.SOCK_STREAM
+	SOCK_SEQPACKET = windows.SOCK_SEQPACKET
 )
+
+type Sockaddr = windows.Sockaddr
+type SockaddrInet4 = windows.SockaddrInet4
+type SockaddrInet6 = windows.SockaddrInet6
+type SockaddrUnix = windows.SockaddrUnix
+type RawSockaddrAny = windows.RawSockaddrAny

sockaddr.go

 package sockaddr
 
 import (
-	"golang.org/x/sys/unix"
 	"unsafe"
+
+	sockaddrnet "github.com/libp2p/go-sockaddr/net"
 )
 
 import "C"
@@ -10,24 +11,24 @@ import "C"
 // Socklen is a type for the length of a sockaddr.
 type Socklen uint
 
-// SockaddrToAny converts a unix.Sockaddr into a unix.RawSockaddrAny
+// SockaddrToAny converts a Sockaddr into a RawSockaddrAny
 // The implementation is platform dependent.
-func SockaddrToAny(sa unix.Sockaddr) (*unix.RawSockaddrAny, Socklen, error) {
+func SockaddrToAny(sa sockaddrnet.Sockaddr) (*sockaddrnet.RawSockaddrAny, Socklen, error) {
 	return sockaddrToAny(sa)
 }
 
-// SockaddrToAny converts a unix.RawSockaddrAny into a unix.Sockaddr
+// SockaddrToAny converts a RawSockaddrAny into a Sockaddr
 // The implementation is platform dependent.
-func AnyToSockaddr(rsa *unix.RawSockaddrAny) (unix.Sockaddr, error) {
+func AnyToSockaddr(rsa *sockaddrnet.RawSockaddrAny) (sockaddrnet.Sockaddr, error) {
 	return anyToSockaddr(rsa)
 }
 
 // AnyToCAny casts a *RawSockaddrAny to a *C.struct_sockaddr_any
-func AnyToCAny(a *unix.RawSockaddrAny) *C.struct_sockaddr_any {
+func AnyToCAny(a *sockaddrnet.RawSockaddrAny) *C.struct_sockaddr_any {
 	return (*C.struct_sockaddr_any)(unsafe.Pointer(a))
 }
 
 // CAnyToAny casts a *C.struct_sockaddr_any to a *RawSockaddrAny
-func CAnyToAny(a *C.struct_sockaddr_any) *unix.RawSockaddrAny {
-	return (*unix.RawSockaddrAny)(unsafe.Pointer(a))
+func CAnyToAny(a *C.struct_sockaddr_any) *sockaddrnet.RawSockaddrAny {
+	return (*sockaddrnet.RawSockaddrAny)(unsafe.Pointer(a))
 }

sockaddr_bsd.go

@@ -3,19 +3,21 @@
 package sockaddr
 
 import (
-	"golang.org/x/sys/unix"
+	"syscall"
 	"unsafe"
+
+	"golang.org/x/sys/unix"
 )
 
 func sockaddrToAny(sa unix.Sockaddr) (*unix.RawSockaddrAny, Socklen, error) {
 	if sa == nil {
-		return nil, 0, unix.EINVAL
+		return nil, 0, syscall.EINVAL
 	}
 
 	switch sa := sa.(type) {
 	case *unix.SockaddrInet4:
 		if sa.Port < 0 || sa.Port > 0xFFFF {
-			return nil, 0, unix.EINVAL
+			return nil, 0, syscall.EINVAL
 		}
 		var raw unix.RawSockaddrInet4
 		raw.Len = unix.SizeofSockaddrInet4
@@ -30,7 +32,7 @@ func sockaddrToAny(sa unix.Sockaddr) (*unix.RawSockaddrAny, Socklen, error) {
 
 	case *unix.SockaddrInet6:
 		if sa.Port < 0 || sa.Port > 0xFFFF {
-			return nil, 0, unix.EINVAL
+			return nil, 0, syscall.EINVAL
 		}
 		var raw unix.RawSockaddrInet6
 		raw.Len = unix.SizeofSockaddrInet6
@@ -49,7 +51,7 @@ func sockaddrToAny(sa unix.Sockaddr) (*unix.RawSockaddrAny, Socklen, error) {
 		n := len(name)
 		var raw unix.RawSockaddrUnix
 		if n >= len(raw.Path) || n == 0 {
-			return nil, 0, unix.EINVAL
+			return nil, 0, syscall.EINVAL
 		}
 		raw.Len = byte(3 + n) // 2 for Family, Len; 1 for NUL
 		raw.Family = unix.AF_UNIX
@@ -60,7 +62,7 @@ func sockaddrToAny(sa unix.Sockaddr) (*unix.RawSockaddrAny, Socklen, error) {
 
 	case *unix.SockaddrDatalink:
 		if sa.Index == 0 {
-			return nil, 0, unix.EINVAL
+			return nil, 0, syscall.EINVAL
 		}
 		var raw unix.RawSockaddrDatalink
 		raw.Len = sa.Len
@@ -75,12 +77,12 @@ func sockaddrToAny(sa unix.Sockaddr) (*unix.RawSockaddrAny, Socklen, error) {
 		}
 		return (*unix.RawSockaddrAny)(unsafe.Pointer(&raw)), unix.SizeofSockaddrDatalink, nil
 	}
-	return nil, 0, unix.EAFNOSUPPORT
+	return nil, 0, syscall.EAFNOSUPPORT
 }
 
 func anyToSockaddr(rsa *unix.RawSockaddrAny) (unix.Sockaddr, error) {
 	if rsa == nil {
-		return nil, unix.EINVAL
+		return nil, syscall.EINVAL
 	}
 
 	switch rsa.Addr.Family {
@@ -102,7 +104,7 @@ func anyToSockaddr(rsa *unix.RawSockaddrAny) (unix.Sockaddr, error) {
 	case unix.AF_UNIX:
 		pp := (*unix.RawSockaddrUnix)(unsafe.Pointer(rsa))
 		if pp.Len < 3 || pp.Len > unix.SizeofSockaddrUnix {
-			return nil, unix.EINVAL
+			return nil, syscall.EINVAL
 		}
 		sa := new(unix.SockaddrUnix)
 		n := int(pp.Len) - 3 // subtract leading Family, Len, terminating NUL
@@ -138,5 +140,5 @@ func anyToSockaddr(rsa *unix.RawSockaddrAny) (unix.Sockaddr, error) {
 		}
 		return sa, nil
 	}
-	return nil, unix.EAFNOSUPPORT
+	return nil, syscall.EAFNOSUPPORT
 }

sockaddr_linux.go

 package sockaddr
 
 import (
-	"golang.org/x/sys/unix"
+	"syscall"
 	"unsafe"
+
+	"golang.org/x/sys/unix"
 )
 
 func sockaddrToAny(sa unix.Sockaddr) (*unix.RawSockaddrAny, Socklen, error) {
 	if sa == nil {
-		return nil, 0, unix.EINVAL
+		return nil, 0, syscall.EINVAL
 	}
 
 	switch sa := sa.(type) {
 	case *unix.SockaddrInet4:
 		if sa.Port < 0 || sa.Port > 0xFFFF {
-			return nil, 0, unix.EINVAL
+			return nil, 0, syscall.EINVAL
 		}
 		var raw unix.RawSockaddrInet4
 		raw.Family = unix.AF_INET
@@ -27,7 +29,7 @@ func sockaddrToAny(sa unix.Sockaddr) (*unix.RawSockaddrAny, Socklen, error) {
 
 	case *unix.SockaddrInet6:
 		if sa.Port < 0 || sa.Port > 0xFFFF {
-			return nil, 0, unix.EINVAL
+			return nil, 0, syscall.EINVAL
 		}
 		var raw unix.RawSockaddrInet6
 		raw.Family = unix.AF_INET6
@@ -45,7 +47,7 @@ func sockaddrToAny(sa unix.Sockaddr) (*unix.RawSockaddrAny, Socklen, error) {
 		n := len(name)
 		var raw unix.RawSockaddrUnix
 		if n >= len(raw.Path) {
-			return nil, 0, unix.EINVAL
+			return nil, 0, syscall.EINVAL
 		}
 		raw.Family = unix.AF_UNIX
 		for i := 0; i < n; i++ {
@@ -65,7 +67,7 @@ func sockaddrToAny(sa unix.Sockaddr) (*unix.RawSockaddrAny, Socklen, error) {
 
 	case *unix.SockaddrLinklayer:
 		if sa.Ifindex < 0 || sa.Ifindex > 0x7fffffff {
-			return nil, 0, unix.EINVAL
+			return nil, 0, syscall.EINVAL
 		}
 		var raw unix.RawSockaddrLinklayer
 		raw.Family = unix.AF_PACKET
@@ -79,10 +81,14 @@ func sockaddrToAny(sa unix.Sockaddr) (*unix.RawSockaddrAny, Socklen, error) {
 		}
 		return (*unix.RawSockaddrAny)(unsafe.Pointer(&raw)), unix.SizeofSockaddrLinklayer, nil
 	}
-	return nil, 0, unix.EAFNOSUPPORT
+	return nil, 0, syscall.EAFNOSUPPORT
 }
 
 func anyToSockaddr(rsa *unix.RawSockaddrAny) (unix.Sockaddr, error) {
+	if rsa == nil {
+		return nil, syscall.EINVAL
+	}
+
 	switch rsa.Addr.Family {
 	case unix.AF_NETLINK:
 		pp := (*unix.RawSockaddrNetlink)(unsafe.Pointer(rsa))
@@ -152,5 +158,5 @@ func anyToSockaddr(rsa *unix.RawSockaddrAny) (unix.Sockaddr, error) {
 		}
 		return sa, nil
 	}
-	return nil, unix.EAFNOSUPPORT
+	return nil, syscall.EAFNOSUPPORT
 }

sockaddr_windows.go

 package sockaddr
 
 import (
-	"golang.org/x/sys/unix"
+	"syscall"
 	"unsafe"
+
+	"golang.org/x/sys/windows"
 )
 
-func sockaddrToAny(sa unix.Sockaddr) (*unix.RawSockaddrAny, Socklen, error) {
+func sockaddrToAny(sa windows.Sockaddr) (*windows.RawSockaddrAny, Socklen, error) {
 	if sa == nil {
-		return nil, 0, unix.EINVAL
+		return nil, 0, syscall.EINVAL
 	}
 
 	switch sa := sa.(type) {
-	case *unix.SockaddrInet4:
+	case *windows.SockaddrInet4:
 		if sa.Port < 0 || sa.Port > 0xFFFF {
-			return nil, 0, unix.EINVAL
+			return nil, 0, syscall.EINVAL
 		}
-		var raw unix.RawSockaddrInet4
-		raw.Family = unix.AF_INET
+		var raw windows.RawSockaddrInet4
+		raw.Family = windows.AF_INET
 		p := (*[2]byte)(unsafe.Pointer(&raw.Port))
 		p[0] = byte(sa.Port >> 8)
 		p[1] = byte(sa.Port)
 		for i := 0; i < len(sa.Addr); i++ {
 			raw.Addr[i] = sa.Addr[i]
 		}
-		return (*unix.RawSockaddrAny)(unsafe.Pointer(&raw)), int32(unsafe.Sizeof(raw)), nil
+		return (*windows.RawSockaddrAny)(unsafe.Pointer(&raw)), int32(unsafe.Sizeof(raw)), nil
 
-	case *unix.SockaddrInet6:
+	case *windows.SockaddrInet6:
 		if sa.Port < 0 || sa.Port > 0xFFFF {
-			return nil, 0, unix.EINVAL
+			return nil, 0, syscall.EINVAL
 		}
-		var raw unix.RawSockaddrInet6
-		raw.Family = unix.AF_INET6
+		var raw windows.RawSockaddrInet6
+		raw.Family = windows.AF_INET6
 		p := (*[2]byte)(unsafe.Pointer(&raw.Port))
 		p[0] = byte(sa.Port >> 8)
 		p[1] = byte(sa.Port)
@@ -38,26 +40,26 @@ func sockaddrToAny(sa unix.Sockaddr) (*unix.RawSockaddrAny, Socklen, error) {
 		for i := 0; i < len(sa.Addr); i++ {
 			raw.Addr[i] = sa.Addr[i]
 		}
-		return (*unix.RawSockaddrAny)(unsafe.Pointer(&raw)), int32(unsafe.Sizeof(raw)), nil
+		return (*windows.RawSockaddrAny)(unsafe.Pointer(&raw)), int32(unsafe.Sizeof(raw)), nil
 
-	case *unix.SockaddrUnix:
-		return nil, 0, unix.EWINDOWS
+	case *windows.SockaddrUnix:
+		return nil, 0, syscall.EWINDOWS
 	}
-	return nil, 0, unix.EAFNOSUPPORT
+	return nil, 0, syscall.EAFNOSUPPORT
 }
 
-func anyToSockaddr(rsa *unix.RawSockaddrAny) (unix.Sockaddr, error) {
+func anyToSockaddr(rsa *windows.RawSockaddrAny) (windows.Sockaddr, error) {
 	if rsa == nil {
-		return nil, 0, unix.EINVAL
+		return nil, 0, syscall.EINVAL
 	}
 
 	switch rsa.Addr.Family {
-	case unix.AF_UNIX:
-		return nil, unix.EWINDOWS
+	case windows.AF_UNIX:
+		return nil, syscall.EWINDOWS
 
-	case unix.AF_INET:
-		pp := (*unix.RawSockaddrInet4)(unsafe.Pointer(rsa))
-		sa := new(unix.SockaddrInet4)
+	case windows.AF_INET:
+		pp := (*windows.RawSockaddrInet4)(unsafe.Pointer(rsa))
+		sa := new(windows.SockaddrInet4)
 		p := (*[2]byte)(unsafe.Pointer(&pp.Port))
 		sa.Port = int(p[0])<<8 + int(p[1])
 		for i := 0; i < len(sa.Addr); i++ {
@@ -65,9 +67,9 @@ func anyToSockaddr(rsa *unix.RawSockaddrAny) (unix.Sockaddr, error) {
 		}
 		return sa, nil
 
-	case unix.AF_INET6:
-		pp := (*unix.RawSockaddrInet6)(unsafe.Pointer(rsa))
-		sa := new(unix.SockaddrInet6)
+	case windows.AF_INET6:
+		pp := (*windows.RawSockaddrInet6)(unsafe.Pointer(rsa))
+		sa := new(windows.SockaddrInet6)
 		p := (*[2]byte)(unsafe.Pointer(&pp.Port))
 		sa.Port = int(p[0])<<8 + int(p[1])
 		sa.ZoneId = pp.Scope_id
@@ -76,5 +78,5 @@ func anyToSockaddr(rsa *unix.RawSockaddrAny) (unix.Sockaddr, error) {
 		}
 		return sa, nil
 	}
-	return nil, unix.EAFNOSUPPORT
+	return nil, syscall.EAFNOSUPPORT
 }