Remove internal syscall package

wasip1/dial_wasip1.go

@@ -4,8 +4,7 @@ import (
 	"context"
 	"net"
 	"os"
-
-	"github.com/stealthrocket/net/internal/syscall"
+	"syscall"
 )
 
 // Dial connects to the address on the named network.
@@ -41,7 +40,7 @@ func dialAddr(addr net.Addr) (net.Conn, error) {
 	proto := family(addr)
 	sotype := socketType(addr)
 
-	fd, err := syscall.Socket(proto, sotype, 0)
+	fd, err := socket(proto, sotype, 0)
 	if err != nil {
 		return nil, os.NewSyscallError("socket", err)
 	}
@@ -51,8 +50,8 @@ func dialAddr(addr net.Addr) (net.Conn, error) {
 		return nil, os.NewSyscallError("setnonblock", err)
 	}
 
-	if sotype == syscall.SOCK_DGRAM && proto != syscall.AF_UNIX {
-		if err := syscall.SetsockoptInt(fd, syscall.SOL_SOCKET, syscall.SO_BROADCAST, 1); err != nil {
+	if sotype == SOCK_DGRAM && proto != AF_UNIX {
+		if err := setsockopt(fd, SOL_SOCKET, SO_BROADCAST, 1); err != nil {
 			syscall.Close(fd)
 			return nil, os.NewSyscallError("setsockopt", err)
 		}
@@ -64,7 +63,7 @@ func dialAddr(addr net.Addr) (net.Conn, error) {
 	}
 
 	var inProgress bool
-	switch err := syscall.Connect(fd, connectAddr); err {
+	switch err := connect(fd, connectAddr); err {
 	case nil:
 	case syscall.EINPROGRESS:
 		inProgress = true
@@ -83,7 +82,7 @@ func dialAddr(addr net.Addr) (net.Conn, error) {
 		}
 		rawConnErr := rawConn.Write(func(fd uintptr) bool {
 			var value int
-			value, err = syscall.GetsockoptInt(int(fd), syscall.SOL_SOCKET, syscall.SO_ERROR)
+			value, err = getsockopt(int(fd), SOL_SOCKET, SO_ERROR)
 			if err != nil {
 				return true // done
 			}
@@ -96,7 +95,7 @@ func dialAddr(addr net.Addr) (net.Conn, error) {
 			case syscall.Errno(0):
 				// The net poller can wake up spuriously. Check that we are
 				// are really connected.
-				_, err := syscall.Getpeername(int(fd))
+				_, err := getpeername(int(fd))
 				return err == nil
 			default:
 				return true
@@ -123,7 +122,7 @@ func family(addr net.Addr) int {
 	var ip net.IP
 	switch a := addr.(type) {
 	case *net.UnixAddr:
-		return syscall.AF_UNIX
+		return AF_UNIX
 	case *net.TCPAddr:
 		ip = a.IP
 	case *net.UDPAddr:
@@ -132,30 +131,30 @@ func family(addr net.Addr) int {
 		ip = a.IP
 	}
 	if ip.To4() != nil {
-		return syscall.AF_INET
+		return AF_INET
 	} else if len(ip) == net.IPv6len {
-		return syscall.AF_INET6
+		return AF_INET6
 	}
-	return syscall.AF_INET
+	return AF_INET
 }
 
 func socketType(addr net.Addr) int {
 	switch addr.Network() {
 	case "tcp", "unix":
-		return syscall.SOCK_STREAM
+		return SOCK_STREAM
 	case "udp", "unixgram":
-		return syscall.SOCK_DGRAM
+		return SOCK_DGRAM
 	default:
 		panic("not implemented")
 	}
 }
 
-func socketAddress(addr net.Addr) (syscall.Sockaddr, error) {
+func socketAddress(addr net.Addr) (sockaddr, error) {
 	var ip net.IP
 	var port int
 	switch a := addr.(type) {
 	case *net.UnixAddr:
-		return &syscall.SockaddrUnix{Name: a.Name}, nil
+		return &sockaddrUnix{name: a.Name}, nil
 	case *net.TCPAddr:
 		ip, port = a.IP, a.Port
 	case *net.UDPAddr:
@@ -164,9 +163,9 @@ func socketAddress(addr net.Addr) (syscall.Sockaddr, error) {
 		ip = a.IP
 	}
 	if ipv4 := ip.To4(); ipv4 != nil {
-		return &syscall.SockaddrInet4{Addr: ([4]byte)(ipv4), Port: port}, nil
+		return &sockaddrInet4{addr: ([4]byte)(ipv4), port: port}, nil
 	} else if len(ip) == net.IPv6len {
-		return &syscall.SockaddrInet6{Addr: ([16]byte)(ip), Port: port}, nil
+		return &sockaddrInet6{addr: ([16]byte)(ip), port: port}, nil
 	} else {
 		return nil, &net.AddrError{
 			Err:  "unsupported address type",

wasip1/listen_wasip1.go

@@ -3,8 +3,7 @@ package wasip1
 import (
 	"net"
 	"os"
-
-	"github.com/stealthrocket/net/internal/syscall"
+	"syscall"
 )
 
 // Listen announces on the local network address.
@@ -26,7 +25,7 @@ func listenErr(addr net.Addr, err error) error {
 }
 
 func listenAddr(addr net.Addr) (net.Listener, error) {
-	fd, err := syscall.Socket(family(addr), socketType(addr), 0)
+	fd, err := socket(family(addr), socketType(addr), 0)
 	if err != nil {
 		return nil, os.NewSyscallError("socket", err)
 	}
@@ -35,7 +34,7 @@ func listenAddr(addr net.Addr) (net.Listener, error) {
 		syscall.Close(fd)
 		return nil, os.NewSyscallError("setnonblock", err)
 	}
-	if err := syscall.SetsockoptInt(fd, syscall.SOL_SOCKET, syscall.SO_REUSEADDR, 1); err != nil {
+	if err := setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, 1); err != nil {
 		syscall.Close(fd)
 		return nil, os.NewSyscallError("setsockopt", err)
 	}
@@ -45,13 +44,13 @@ func listenAddr(addr net.Addr) (net.Listener, error) {
 		return nil, os.NewSyscallError("bind", err)
 	}
 
-	if err := syscall.Bind(fd, listenAddr); err != nil {
+	if err := bind(fd, listenAddr); err != nil {
 		syscall.Close(fd)
 		return nil, os.NewSyscallError("bind", err)
 	}
 
 	const backlog = 64 // TODO: configurable?
-	if err := syscall.Listen(fd, backlog); err != nil {
+	if err := listen(fd, backlog); err != nil {
 		syscall.Close(fd)
 		return nil, os.NewSyscallError("listen", err)
 	}

wasip1/lookup_wasip1.go

@@ -5,42 +5,40 @@ package wasip1
 import (
 	"net"
 	"os"
-
-	"github.com/stealthrocket/net/internal/syscall"
 )
 
 func lookupAddr(op, network, address string) (net.Addr, error) {
-	var hints syscall.AddrInfo
+	var hints addrInfo
 	switch network {
 	case "tcp", "tcp4", "tcp6":
-		hints.SocketType = syscall.SOCK_STREAM
-		hints.Protocol = syscall.IPPROTO_TCP
+		hints.socketType = SOCK_STREAM
+		hints.protocol = IPPROTO_TCP
 	case "udp", "udp4", "udp6":
-		hints.SocketType = syscall.SOCK_DGRAM
-		hints.Protocol = syscall.IPPROTO_UDP
+		hints.socketType = SOCK_DGRAM
+		hints.protocol = IPPROTO_UDP
 	case "unix", "unixgram":
 		return &net.UnixAddr{Name: address, Net: network}, nil
 	default:
 		return nil, net.UnknownNetworkError(network)
 	}
 	switch network {
 	case "tcp", "udp":
-		hints.Family = syscall.AF_UNSPEC
+		hints.family = AF_UNSPEC
 	case "tcp4", "udp4":
-		hints.Family = syscall.AF_INET
+		hints.family = AF_INET
 	case "tcp6", "udp6":
-		hints.Family = syscall.AF_INET6
+		hints.family = AF_INET6
 	}
 	hostname, service, err := net.SplitHostPort(address)
 	if err != nil {
 		return nil, net.InvalidAddrError(address)
 	}
 	if op == "listen" && hostname == "" {
-		hints.Flags |= syscall.AI_PASSIVE
+		hints.flags |= AI_PASSIVE
 	}
 
-	results := make([]syscall.AddrInfo, 16)
-	n, err := syscall.Getaddrinfo(hostname, service, hints, results)
+	results := make([]addrInfo, 16)
+	n, err := getaddrinfo(hostname, service, &hints, results)
 	if err != nil {
 		addr := &netAddr{network, address}
 		return nil, newOpError(op, addr, os.NewSyscallError("getaddrinfo", err))
@@ -49,13 +47,13 @@ func lookupAddr(op, network, address string) (net.Addr, error) {
 	for _, r := range results {
 		var ip net.IP
 		var port int
-		switch a := r.Address.(type) {
-		case *syscall.SockaddrInet4:
-			ip = a.Addr[:]
-			port = a.Port
-		case *syscall.SockaddrInet6:
-			ip = a.Addr[:]
-			port = a.Port
+		switch a := r.address.(type) {
+		case *sockaddrInet4:
+			ip = a.addr[:]
+			port = a.port
+		case *sockaddrInet6:
+			ip = a.addr[:]
+			port = a.port
 		}
 		switch network {
 		case "tcp", "tcp4", "tcp6":

wasip1/net_wasip1.go

@@ -37,10 +37,7 @@ func newOpError(op string, addr net.Addr, err error) error {
 	}
 }
 
-type netAddr struct {
-	network string
-	address string
-}
+type netAddr struct{ network, address string }
 
 func (na *netAddr) Network() string { return na.address }
 func (na *netAddr) String() string  { return na.address }