Merge pull request #5 from Stebalien/feat/unix

switch to golang.org/x/sys

.gx/lastpubver

+1.0.0: QmTQZAuiXEkTNcF91c8Q9sN3f4dTNQS3Zuy5GHKEJ1ACea

README.md

 ## go-sockaddr - `{Raw,}Sockaddr` conversions
 
 See https://groups.google.com/d/msg/golang-nuts/B-meiFfkmH0/-TxP1r6zvk8J
-This package extracts unexported code from `syscall` to help in converting
+This package extracts unexported code from `golang.org/x/unix` to help in converting
 between:
 
 ```Go
-syscall.Sockaddr
-syscall.RawSockaddrAny
+unix.Sockaddr
+unix.RawSockaddrAny
 C.struct_sockaddr_any
 net.*Addr
 ```
 
 Godoc:
 
-- sockaddr - http://godoc.org/github.com/jbenet/go-sockaddr
-- sockaddr/net - http://godoc.org/github.com/jbenet/go-sockaddr/net
+- sockaddr - http://godoc.org/github.com/libp2p/go-sockaddr
+- sockaddr/net - http://godoc.org/github.com/libp2p/go-sockaddr/net

net/net.go

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

net/net_bsd.go

@@ -3,22 +3,22 @@
 package sockaddrnet
 
 import (
-	"syscall"
+	"golang.org/x/sys/unix"
 )
 
 const (
-	AF_INET   = syscall.AF_INET
-	AF_INET6  = syscall.AF_INET6
-	AF_UNIX   = syscall.AF_UNIX
-	AF_UNSPEC = syscall.AF_UNSPEC
+	AF_INET   = unix.AF_INET
+	AF_INET6  = unix.AF_INET6
+	AF_UNIX   = unix.AF_UNIX
+	AF_UNSPEC = unix.AF_UNSPEC
 
-	IPPROTO_IP   = syscall.IPPROTO_IP
-	IPPROTO_IPV4 = syscall.IPPROTO_IPV4
-	IPPROTO_IPV6 = syscall.IPPROTO_IPV6
-	IPPROTO_TCP  = syscall.IPPROTO_TCP
-	IPPROTO_UDP  = syscall.IPPROTO_UDP
+	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
 
-	SOCK_DGRAM     = syscall.SOCK_DGRAM
-	SOCK_STREAM    = syscall.SOCK_STREAM
-	SOCK_SEQPACKET = syscall.SOCK_SEQPACKET
+	SOCK_DGRAM     = unix.SOCK_DGRAM
+	SOCK_STREAM    = unix.SOCK_STREAM
+	SOCK_SEQPACKET = unix.SOCK_SEQPACKET
 )

net/net_linux.go

 package sockaddrnet
 
 import (
-	"syscall"
+	"golang.org/x/sys/unix"
 )
 
 const (
-	AF_INET   = syscall.AF_INET
-	AF_INET6  = syscall.AF_INET6
-	AF_UNIX   = syscall.AF_UNIX
-	AF_UNSPEC = syscall.AF_UNSPEC
+	AF_INET   = unix.AF_INET
+	AF_INET6  = unix.AF_INET6
+	AF_UNIX   = unix.AF_UNIX
+	AF_UNSPEC = unix.AF_UNSPEC
 
-	IPPROTO_IP   = syscall.IPPROTO_IP
-	IPPROTO_IPV4 = syscall.IPPROTO_IPIP
-	IPPROTO_IPV6 = syscall.IPPROTO_IPV6
-	IPPROTO_TCP  = syscall.IPPROTO_TCP
-	IPPROTO_UDP  = syscall.IPPROTO_UDP
+	IPPROTO_IP   = unix.IPPROTO_IP
+	IPPROTO_IPV4 = unix.IPPROTO_IPIP
+	IPPROTO_IPV6 = unix.IPPROTO_IPV6
+	IPPROTO_TCP  = unix.IPPROTO_TCP
+	IPPROTO_UDP  = unix.IPPROTO_UDP
 
-	SOCK_DGRAM     = syscall.SOCK_DGRAM
-	SOCK_STREAM    = syscall.SOCK_STREAM
-	SOCK_SEQPACKET = syscall.SOCK_SEQPACKET
+	SOCK_DGRAM     = unix.SOCK_DGRAM
+	SOCK_STREAM    = unix.SOCK_STREAM
+	SOCK_SEQPACKET = unix.SOCK_SEQPACKET
 )

net/net_windows.go

 package sockaddrnet
 
 import (
-	"syscall"
+	"golang.org/x/sys/unix"
 )
 
 const (
-	AF_INET   = syscall.AF_INET
-	AF_INET6  = syscall.AF_INET6
-	AF_UNIX   = syscall.AF_UNIX
-	AF_UNSPEC = syscall.AF_UNSPEC
+	AF_INET   = unix.AF_INET
+	AF_INET6  = unix.AF_INET6
+	AF_UNIX   = unix.AF_UNIX
+	AF_UNSPEC = unix.AF_UNSPEC
 
-	IPPROTO_IP   = syscall.IPPROTO_IP
-	IPPROTO_IPV4 = syscall.IPPROTO_IPV4
-	IPPROTO_IPV6 = syscall.IPPROTO_IPV6
-	IPPROTO_TCP  = syscall.IPPROTO_TCP
-	IPPROTO_UDP  = syscall.IPPROTO_UDP
+	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
 
-	SOCK_DGRAM     = syscall.SOCK_DGRAM
-	SOCK_STREAM    = syscall.SOCK_STREAM
-	SOCK_SEQPACKET = syscall.SOCK_SEQPACKET
+	SOCK_DGRAM     = unix.SOCK_DGRAM
+	SOCK_STREAM    = unix.SOCK_STREAM
+	SOCK_SEQPACKET = unix.SOCK_SEQPACKET
 )

package.json

+{
+  "author": "jbenet",
+  "bugs": {},
+  "gx": {
+    "dvcsimport": "github.com/libp2p/go-sockaddr"
+  },
+  "gxDependencies": [
+    {
+      "author": "The Go Authors",
+      "hash": "QmPXvegq26x982cQjSfbTvSzZXn7GiaMwhhVPHkeTEhrPT",
+      "name": "sys",
+      "version": "0.1.0"
+    }
+  ],
+  "gxVersion": "0.11.0",
+  "issues_url": "",
+  "language": "go",
+  "license": "",
+  "name": "go-sockaddr",
+  "version": "1.0.0"
+}
+

sockaddr.go

 package sockaddr
 
 import (
-	"syscall"
+	"golang.org/x/sys/unix"
 	"unsafe"
 )
 
@@ -10,24 +10,24 @@ import "C"
 // Socklen is a type for the length of a sockaddr.
 type Socklen uint
 
-// SockaddrToAny converts a syscall.Sockaddr into a syscall.RawSockaddrAny
+// SockaddrToAny converts a unix.Sockaddr into a unix.RawSockaddrAny
 // The implementation is platform dependent.
-func SockaddrToAny(sa syscall.Sockaddr) (*syscall.RawSockaddrAny, Socklen, error) {
+func SockaddrToAny(sa unix.Sockaddr) (*unix.RawSockaddrAny, Socklen, error) {
 	return sockaddrToAny(sa)
 }
 
-// SockaddrToAny converts a syscall.RawSockaddrAny into a syscall.Sockaddr
+// SockaddrToAny converts a unix.RawSockaddrAny into a unix.Sockaddr
 // The implementation is platform dependent.
-func AnyToSockaddr(rsa *syscall.RawSockaddrAny) (syscall.Sockaddr, error) {
+func AnyToSockaddr(rsa *unix.RawSockaddrAny) (unix.Sockaddr, error) {
 	return anyToSockaddr(rsa)
 }
 
 // AnyToCAny casts a *RawSockaddrAny to a *C.struct_sockaddr_any
-func AnyToCAny(a *syscall.RawSockaddrAny) *C.struct_sockaddr_any {
+func AnyToCAny(a *unix.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) *syscall.RawSockaddrAny {
-	return (*syscall.RawSockaddrAny)(unsafe.Pointer(a))
+func CAnyToAny(a *C.struct_sockaddr_any) *unix.RawSockaddrAny {
+	return (*unix.RawSockaddrAny)(unsafe.Pointer(a))
 }

sockaddr_bsd.go

@@ -3,38 +3,38 @@
 package sockaddr
 
 import (
-	"syscall"
+	"golang.org/x/sys/unix"
 	"unsafe"
 )
 
-func sockaddrToAny(sa syscall.Sockaddr) (*syscall.RawSockaddrAny, Socklen, error) {
+func sockaddrToAny(sa unix.Sockaddr) (*unix.RawSockaddrAny, Socklen, error) {
 	if sa == nil {
-		return nil, 0, syscall.EINVAL
+		return nil, 0, unix.EINVAL
 	}
 
 	switch sa := sa.(type) {
-	case *syscall.SockaddrInet4:
+	case *unix.SockaddrInet4:
 		if sa.Port < 0 || sa.Port > 0xFFFF {
-			return nil, 0, syscall.EINVAL
+			return nil, 0, unix.EINVAL
 		}
-		var raw syscall.RawSockaddrInet4
-		raw.Len = syscall.SizeofSockaddrInet4
-		raw.Family = syscall.AF_INET
+		var raw unix.RawSockaddrInet4
+		raw.Len = unix.SizeofSockaddrInet4
+		raw.Family = unix.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 (*syscall.RawSockaddrAny)(unsafe.Pointer(&raw)), Socklen(raw.Len), nil
+		return (*unix.RawSockaddrAny)(unsafe.Pointer(&raw)), Socklen(raw.Len), nil
 
-	case *syscall.SockaddrInet6:
+	case *unix.SockaddrInet6:
 		if sa.Port < 0 || sa.Port > 0xFFFF {
-			return nil, 0, syscall.EINVAL
+			return nil, 0, unix.EINVAL
 		}
-		var raw syscall.RawSockaddrInet6
-		raw.Len = syscall.SizeofSockaddrInet6
-		raw.Family = syscall.AF_INET6
+		var raw unix.RawSockaddrInet6
+		raw.Len = unix.SizeofSockaddrInet6
+		raw.Family = unix.AF_INET6
 		p := (*[2]byte)(unsafe.Pointer(&raw.Port))
 		p[0] = byte(sa.Port >> 8)
 		p[1] = byte(sa.Port)
@@ -42,29 +42,29 @@ func sockaddrToAny(sa syscall.Sockaddr) (*syscall.RawSockaddrAny, Socklen, error
 		for i := 0; i < len(sa.Addr); i++ {
 			raw.Addr[i] = sa.Addr[i]
 		}
-		return (*syscall.RawSockaddrAny)(unsafe.Pointer(&raw)), Socklen(raw.Len), nil
+		return (*unix.RawSockaddrAny)(unsafe.Pointer(&raw)), Socklen(raw.Len), nil
 
-	case *syscall.SockaddrUnix:
+	case *unix.SockaddrUnix:
 		name := sa.Name
 		n := len(name)
-		var raw syscall.RawSockaddrUnix
+		var raw unix.RawSockaddrUnix
 		if n >= len(raw.Path) || n == 0 {
-			return nil, 0, syscall.EINVAL
+			return nil, 0, unix.EINVAL
 		}
 		raw.Len = byte(3 + n) // 2 for Family, Len; 1 for NUL
-		raw.Family = syscall.AF_UNIX
+		raw.Family = unix.AF_UNIX
 		for i := 0; i < n; i++ {
 			raw.Path[i] = int8(name[i])
 		}
-		return (*syscall.RawSockaddrAny)(unsafe.Pointer(&raw)), Socklen(raw.Len), nil
+		return (*unix.RawSockaddrAny)(unsafe.Pointer(&raw)), Socklen(raw.Len), nil
 
-	case *syscall.SockaddrDatalink:
+	case *unix.SockaddrDatalink:
 		if sa.Index == 0 {
-			return nil, 0, syscall.EINVAL
+			return nil, 0, unix.EINVAL
 		}
-		var raw syscall.RawSockaddrDatalink
+		var raw unix.RawSockaddrDatalink
 		raw.Len = sa.Len
-		raw.Family = syscall.AF_LINK
+		raw.Family = unix.AF_LINK
 		raw.Index = sa.Index
 		raw.Type = sa.Type
 		raw.Nlen = sa.Nlen
@@ -73,20 +73,20 @@ func sockaddrToAny(sa syscall.Sockaddr) (*syscall.RawSockaddrAny, Socklen, error
 		for i := 0; i < len(raw.Data); i++ {
 			raw.Data[i] = sa.Data[i]
 		}
-		return (*syscall.RawSockaddrAny)(unsafe.Pointer(&raw)), syscall.SizeofSockaddrDatalink, nil
+		return (*unix.RawSockaddrAny)(unsafe.Pointer(&raw)), unix.SizeofSockaddrDatalink, nil
 	}
-	return nil, 0, syscall.EAFNOSUPPORT
+	return nil, 0, unix.EAFNOSUPPORT
 }
 
-func anyToSockaddr(rsa *syscall.RawSockaddrAny) (syscall.Sockaddr, error) {
+func anyToSockaddr(rsa *unix.RawSockaddrAny) (unix.Sockaddr, error) {
 	if rsa == nil {
-		return nil, syscall.EINVAL
+		return nil, unix.EINVAL
 	}
 
 	switch rsa.Addr.Family {
-	case syscall.AF_LINK:
-		pp := (*syscall.RawSockaddrDatalink)(unsafe.Pointer(rsa))
-		sa := new(syscall.SockaddrDatalink)
+	case unix.AF_LINK:
+		pp := (*unix.RawSockaddrDatalink)(unsafe.Pointer(rsa))
+		sa := new(unix.SockaddrDatalink)
 		sa.Len = pp.Len
 		sa.Family = pp.Family
 		sa.Index = pp.Index
@@ -99,12 +99,12 @@ func anyToSockaddr(rsa *syscall.RawSockaddrAny) (syscall.Sockaddr, error) {
 		}
 		return sa, nil
 
-	case syscall.AF_UNIX:
-		pp := (*syscall.RawSockaddrUnix)(unsafe.Pointer(rsa))
-		if pp.Len < 3 || pp.Len > syscall.SizeofSockaddrUnix {
-			return nil, syscall.EINVAL
+	case unix.AF_UNIX:
+		pp := (*unix.RawSockaddrUnix)(unsafe.Pointer(rsa))
+		if pp.Len < 3 || pp.Len > unix.SizeofSockaddrUnix {
+			return nil, unix.EINVAL
 		}
-		sa := new(syscall.SockaddrUnix)
+		sa := new(unix.SockaddrUnix)
 		n := int(pp.Len) - 3 // subtract leading Family, Len, terminating NUL
 		for i := 0; i < n; i++ {
 			if pp.Path[i] == 0 {
@@ -117,9 +117,9 @@ func anyToSockaddr(rsa *syscall.RawSockaddrAny) (syscall.Sockaddr, error) {
 		sa.Name = string(bytes)
 		return sa, nil
 
-	case syscall.AF_INET:
-		pp := (*syscall.RawSockaddrInet4)(unsafe.Pointer(rsa))
-		sa := new(syscall.SockaddrInet4)
+	case unix.AF_INET:
+		pp := (*unix.RawSockaddrInet4)(unsafe.Pointer(rsa))
+		sa := new(unix.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++ {
@@ -127,9 +127,9 @@ func anyToSockaddr(rsa *syscall.RawSockaddrAny) (syscall.Sockaddr, error) {
 		}
 		return sa, nil
 
-	case syscall.AF_INET6:
-		pp := (*syscall.RawSockaddrInet6)(unsafe.Pointer(rsa))
-		sa := new(syscall.SockaddrInet6)
+	case unix.AF_INET6:
+		pp := (*unix.RawSockaddrInet6)(unsafe.Pointer(rsa))
+		sa := new(unix.SockaddrInet6)
 		p := (*[2]byte)(unsafe.Pointer(&pp.Port))
 		sa.Port = int(p[0])<<8 + int(p[1])
 		sa.ZoneId = pp.Scope_id
@@ -138,5 +138,5 @@ func anyToSockaddr(rsa *syscall.RawSockaddrAny) (syscall.Sockaddr, error) {
 		}
 		return sa, nil
 	}
-	return nil, syscall.EAFNOSUPPORT
+	return nil, unix.EAFNOSUPPORT
 }

sockaddr_linux.go

 package sockaddr
 
 import (
-	"syscall"
+	"golang.org/x/sys/unix"
 	"unsafe"
 )
 
-func sockaddrToAny(sa syscall.Sockaddr) (*syscall.RawSockaddrAny, Socklen, error) {
+func sockaddrToAny(sa unix.Sockaddr) (*unix.RawSockaddrAny, Socklen, error) {
 	if sa == nil {
-		return nil, 0, syscall.EINVAL
+		return nil, 0, unix.EINVAL
 	}
 
 	switch sa := sa.(type) {
-	case *syscall.SockaddrInet4:
+	case *unix.SockaddrInet4:
 		if sa.Port < 0 || sa.Port > 0xFFFF {
-			return nil, 0, syscall.EINVAL
+			return nil, 0, unix.EINVAL
 		}
-		var raw syscall.RawSockaddrInet4
-		raw.Family = syscall.AF_INET
+		var raw unix.RawSockaddrInet4
+		raw.Family = unix.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 (*syscall.RawSockaddrAny)(unsafe.Pointer(&raw)), syscall.SizeofSockaddrInet4, nil
+		return (*unix.RawSockaddrAny)(unsafe.Pointer(&raw)), unix.SizeofSockaddrInet4, nil
 
-	case *syscall.SockaddrInet6:
+	case *unix.SockaddrInet6:
 		if sa.Port < 0 || sa.Port > 0xFFFF {
-			return nil, 0, syscall.EINVAL
+			return nil, 0, unix.EINVAL
 		}
-		var raw syscall.RawSockaddrInet6
-		raw.Family = syscall.AF_INET6
+		var raw unix.RawSockaddrInet6
+		raw.Family = unix.AF_INET6
 		p := (*[2]byte)(unsafe.Pointer(&raw.Port))
 		p[0] = byte(sa.Port >> 8)
 		p[1] = byte(sa.Port)
@@ -38,16 +38,16 @@ func sockaddrToAny(sa syscall.Sockaddr) (*syscall.RawSockaddrAny, Socklen, error
 		for i := 0; i < len(sa.Addr); i++ {
 			raw.Addr[i] = sa.Addr[i]
 		}
-		return (*syscall.RawSockaddrAny)(unsafe.Pointer(&raw)), syscall.SizeofSockaddrInet6, nil
+		return (*unix.RawSockaddrAny)(unsafe.Pointer(&raw)), unix.SizeofSockaddrInet6, nil
 
-	case *syscall.SockaddrUnix:
+	case *unix.SockaddrUnix:
 		name := sa.Name
 		n := len(name)
-		var raw syscall.RawSockaddrUnix
+		var raw unix.RawSockaddrUnix
 		if n >= len(raw.Path) {
-			return nil, 0, syscall.EINVAL
+			return nil, 0, unix.EINVAL
 		}
-		raw.Family = syscall.AF_UNIX
+		raw.Family = unix.AF_UNIX
 		for i := 0; i < n; i++ {
 			raw.Path[i] = int8(name[i])
 		}
@@ -61,14 +61,14 @@ func sockaddrToAny(sa syscall.Sockaddr) (*syscall.RawSockaddrAny, Socklen, error
 			// Don't count trailing NUL for abstract address.
 			sl--
 		}
-		return (*syscall.RawSockaddrAny)(unsafe.Pointer(&raw)), sl, nil
+		return (*unix.RawSockaddrAny)(unsafe.Pointer(&raw)), sl, nil
 
-	case *syscall.SockaddrLinklayer:
+	case *unix.SockaddrLinklayer:
 		if sa.Ifindex < 0 || sa.Ifindex > 0x7fffffff {
-			return nil, 0, syscall.EINVAL
+			return nil, 0, unix.EINVAL
 		}
-		var raw syscall.RawSockaddrLinklayer
-		raw.Family = syscall.AF_PACKET
+		var raw unix.RawSockaddrLinklayer
+		raw.Family = unix.AF_PACKET
 		raw.Protocol = sa.Protocol
 		raw.Ifindex = int32(sa.Ifindex)
 		raw.Hatype = sa.Hatype
@@ -77,25 +77,25 @@ func sockaddrToAny(sa syscall.Sockaddr) (*syscall.RawSockaddrAny, Socklen, error
 		for i := 0; i < len(sa.Addr); i++ {
 			raw.Addr[i] = sa.Addr[i]
 		}
-		return (*syscall.RawSockaddrAny)(unsafe.Pointer(&raw)), syscall.SizeofSockaddrLinklayer, nil
+		return (*unix.RawSockaddrAny)(unsafe.Pointer(&raw)), unix.SizeofSockaddrLinklayer, nil
 	}
-	return nil, 0, syscall.EAFNOSUPPORT
+	return nil, 0, unix.EAFNOSUPPORT
 }
 
-func anyToSockaddr(rsa *syscall.RawSockaddrAny) (syscall.Sockaddr, error) {
+func anyToSockaddr(rsa *unix.RawSockaddrAny) (unix.Sockaddr, error) {
 	switch rsa.Addr.Family {
-	case syscall.AF_NETLINK:
-		pp := (*syscall.RawSockaddrNetlink)(unsafe.Pointer(rsa))
-		sa := new(syscall.SockaddrNetlink)
+	case unix.AF_NETLINK:
+		pp := (*unix.RawSockaddrNetlink)(unsafe.Pointer(rsa))
+		sa := new(unix.SockaddrNetlink)
 		sa.Family = pp.Family
 		sa.Pad = pp.Pad
 		sa.Pid = pp.Pid
 		sa.Groups = pp.Groups
 		return sa, nil
 
-	case syscall.AF_PACKET:
-		pp := (*syscall.RawSockaddrLinklayer)(unsafe.Pointer(rsa))
-		sa := new(syscall.SockaddrLinklayer)
+	case unix.AF_PACKET:
+		pp := (*unix.RawSockaddrLinklayer)(unsafe.Pointer(rsa))
+		sa := new(unix.SockaddrLinklayer)
 		sa.Protocol = pp.Protocol
 		sa.Ifindex = int(pp.Ifindex)
 		sa.Hatype = pp.Hatype
@@ -106,9 +106,9 @@ func anyToSockaddr(rsa *syscall.RawSockaddrAny) (syscall.Sockaddr, error) {
 		}
 		return sa, nil
 
-	case syscall.AF_UNIX:
-		pp := (*syscall.RawSockaddrUnix)(unsafe.Pointer(rsa))
-		sa := new(syscall.SockaddrUnix)
+	case unix.AF_UNIX:
+		pp := (*unix.RawSockaddrUnix)(unsafe.Pointer(rsa))
+		sa := new(unix.SockaddrUnix)
 		if pp.Path[0] == 0 {
 			// "Abstract" Unix domain socket.
 			// Rewrite leading NUL as @ for textual display.
@@ -131,9 +131,9 @@ func anyToSockaddr(rsa *syscall.RawSockaddrAny) (syscall.Sockaddr, error) {
 		sa.Name = string(bytes)
 		return sa, nil
 
-	case syscall.AF_INET:
-		pp := (*syscall.RawSockaddrInet4)(unsafe.Pointer(rsa))
-		sa := new(syscall.SockaddrInet4)
+	case unix.AF_INET:
+		pp := (*unix.RawSockaddrInet4)(unsafe.Pointer(rsa))
+		sa := new(unix.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++ {
@@ -141,9 +141,9 @@ func anyToSockaddr(rsa *syscall.RawSockaddrAny) (syscall.Sockaddr, error) {
 		}
 		return sa, nil
 
-	case syscall.AF_INET6:
-		pp := (*syscall.RawSockaddrInet6)(unsafe.Pointer(rsa))
-		sa := new(syscall.SockaddrInet6)
+	case unix.AF_INET6:
+		pp := (*unix.RawSockaddrInet6)(unsafe.Pointer(rsa))
+		sa := new(unix.SockaddrInet6)
 		p := (*[2]byte)(unsafe.Pointer(&pp.Port))
 		sa.Port = int(p[0])<<8 + int(p[1])
 		sa.ZoneId = pp.Scope_id
@@ -152,5 +152,5 @@ func anyToSockaddr(rsa *syscall.RawSockaddrAny) (syscall.Sockaddr, error) {
 		}
 		return sa, nil
 	}
-	return nil, syscall.EAFNOSUPPORT
+	return nil, unix.EAFNOSUPPORT
 }

sockaddr_platform.go

 package sockaddr
 
 // import (
-//   "syscall"
+//   "unix"
 //   "unsafe"
 // )
 
-// func sockaddrToAny(sa syscall.Sockaddr) (*syscall.RawSockaddrAny, Socklen, error) {
+// func sockaddrToAny(sa unix.Sockaddr) (*unix.RawSockaddrAny, Socklen, error) {
 //   if sa == nil {
-//     return nil, 0, syscall.EINVAL
+//     return nil, 0, unix.EINVAL
 //   }
 
 //   switch sa.(type) {
-//   case *syscall.SockaddrInet4:
-//   case *syscall.SockaddrInet6:
-//   case *syscall.SockaddrUnix:
-//   case *syscall.SockaddrDatalink:
+//   case *unix.SockaddrInet4:
+//   case *unix.SockaddrInet6:
+//   case *unix.SockaddrUnix:
+//   case *unix.SockaddrDatalink:
 //   }
-//   return nil, 0, syscall.EAFNOSUPPORT
+//   return nil, 0, unix.EAFNOSUPPORT
 // }
 
-// func anyToSockaddr(rsa *syscall.RawSockaddrAny) (syscall.Sockaddr, error) {
+// func anyToSockaddr(rsa *unix.RawSockaddrAny) (unix.Sockaddr, error) {
 //   if rsa == nil {
-//     return nil, 0, syscall.EINVAL
+//     return nil, 0, unix.EINVAL
 //   }
 
 //   switch rsa.Addr.Family {
-//   case syscall.AF_NETLINK:
-//   case syscall.AF_PACKET:
-//   case syscall.AF_UNIX:
-//   case syscall.AF_INET:
-//   case syscall.AF_INET6:
+//   case unix.AF_NETLINK:
+//   case unix.AF_PACKET:
+//   case unix.AF_UNIX:
+//   case unix.AF_INET:
+//   case unix.AF_INET6:
 //   }
-//   return nil, syscall.EAFNOSUPPORT
+//   return nil, unix.EAFNOSUPPORT
 // }

sockaddr_windows.go

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