use standard error types from the net package

Signed-off-by: Achille Roussel <[email protected]>

Author: achille-roussel

internal/syscall/errno_wasip1.go

@@ -4,19 +4,17 @@
 
 package syscall
 
-import (
-	"syscall"
-)
+import "syscall"
 
 type Errno = syscall.Errno
 
 const (
-	EAGAIN      Errno = 6
-	EINPROGRESS Errno = 26
-	EINTR       Errno = 27
-	EISCONN     Errno = 30
-	ENOSYS      Errno = 52
-	ENOTSUP     Errno = 58
+	EAGAIN      = syscall.EAGAIN
+	EINPROGRESS = syscall.EINPROGRESS
+	EINTR       = syscall.EINTR
+	EISCONN     = syscall.EISCONN
+	ENOSYS      = syscall.ENOSYS
+	ENOTSUP     = syscall.ENOTSUP
 )
 
 // Do the interface allocations only once for common

wasip1/dial_wasip1.go

@@ -2,7 +2,6 @@ package wasip1
 
 import (
 	"context"
-	"fmt"
 	"net"
 	"net/http"
 	"os"
@@ -20,72 +19,65 @@ func init() {
 func Dial(network, address string) (net.Conn, error) {
 	addr, err := lookupAddr("dial", network, address)
 	if err != nil {
-		return nil, err
+		addr := &netAddr{network, address}
+		return nil, dialErr(addr, err)
+	}
+	conn, err := dialAddr(addr)
+	if err != nil {
+		return nil, dialErr(addr, err)
 	}
-	return dialAddr(addr)
+	return conn, nil
 }
 
 // DialContext is a variant of Dial that accepts a context.
 func DialContext(ctx context.Context, network, address string) (net.Conn, error) {
 	select {
 	case <-ctx.Done():
-		addr := &networkAddress{
-			network: network,
-			address: address,
-		}
-		return nil, dialErr(nil, addr, context.Cause(err))
+		addr := &netAddr{network, address}
+		return nil, dialErr(addr, context.Cause(ctx))
 	default:
 		return Dial(network, address)
 	}
 }
 
-func dialErr(source, addr net.Addr, err error) error {
-	return &net.OpError{
-		Op:     "dial",
-		Net:    addr.Network(),
-		Source: source,
-		Addr:   addr,
-		Err:    err,
-	}
+func dialErr(addr net.Addr, err error) error {
+	return newOpError("dial", addr, err)
 }
 
-type networkAddress struct {
-	network string
-	address string
-}
-
-func (na *networkAddress) Network() string { return na.address }
-func (na *networkAddress) String() string  { return na.address }
-
 func dialAddr(addr net.Addr) (net.Conn, error) {
 	proto := family(addr)
 	sotype := socketType(addr)
 
 	fd, err := syscall.Socket(proto, sotype, 0)
 	if err != nil {
-		return nil, err
+		return nil, os.NewSyscallError("socket", err)
 	}
 
 	if err := syscall.SetNonblock(fd, true); err != nil {
 		syscall.Close(fd)
-		return nil, fmt.Errorf("SetNonblock: %w", err)
+		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 {
 			syscall.Close(fd)
-			return nil, err
+			return nil, os.NewSyscallError("setsockopt", err)
 		}
 	}
 
+	connectAddr, err := socketAddress(addr)
+	if err != nil {
+		return nil, os.NewSyscallError("connect", err)
+	}
+
 	var inProgress bool
-	switch err := syscall.Connect(fd, socketAddress(addr)); err {
+	switch err := syscall.Connect(fd, connectAddr); err {
 	case nil:
 	case syscall.EINPROGRESS:
 		inProgress = true
 	default:
 		syscall.Close(fd)
-		return nil, fmt.Errorf("Connect: %w", err)
+		return nil, os.NewSyscallError("connect", err)
 	}
 
 	f := os.NewFile(uintptr(fd), "")
@@ -117,10 +109,11 @@ func dialAddr(addr net.Addr) (net.Conn, error) {
 				return true
 			}
 		})
+		if err == nil {
+			err = rawConnErr
+		}
 		if err != nil {
-			return nil, err
-		} else if rawConnErr != nil {
-			return nil, err
+			return nil, os.NewSyscallError("connect", err)
 		}
 	}
 
@@ -130,7 +123,6 @@ func dialAddr(addr net.Addr) (net.Conn, error) {
 	}
 
 	// TODO: get local+peer address; wrap FileConn to implement LocalAddr() and RemoteAddr()
-
 	return c, nil
 }
 
@@ -165,12 +157,12 @@ func socketType(addr net.Addr) int {
 	}
 }
 
-func socketAddress(addr net.Addr) syscall.Sockaddr {
+func socketAddress(addr net.Addr) (syscall.Sockaddr, error) {
 	var ip net.IP
 	var port int
 	switch a := addr.(type) {
 	case *net.UnixAddr:
-		return &syscall.SockaddrUnix{Name: a.Name}
+		return &syscall.SockaddrUnix{Name: a.Name}, nil
 	case *net.TCPAddr:
 		ip, port = a.IP, a.Port
 	case *net.UDPAddr:
@@ -179,9 +171,13 @@ func socketAddress(addr net.Addr) syscall.Sockaddr {
 		ip = a.IP
 	}
 	if ipv4 := ip.To4(); ipv4 != nil {
-		return &syscall.SockaddrInet4{Addr: ([4]byte)(ipv4), Port: port}
+		return &syscall.SockaddrInet4{Addr: ([4]byte)(ipv4), Port: port}, nil
 	} else if len(ip) == net.IPv6len {
-		return &syscall.SockaddrInet6{Addr: ([16]byte)(ip), Port: port}
+		return &syscall.SockaddrInet6{Addr: ([16]byte)(ip), Port: port}, nil
+	} else {
+		return nil, &net.AddrError{
+			Err:  "unsupported address type",
+			Addr: addr.String(),
+		}
 	}
-	panic("not implemented")
 }

wasip1/listen_wasip1.go

@@ -1,7 +1,6 @@
 package wasip1
 
 import (
-	"fmt"
 	"net"
 	"os"
 
@@ -12,35 +11,49 @@ import (
 func Listen(network, address string) (net.Listener, error) {
 	addr, err := lookupAddr("listen", network, address)
 	if err != nil {
-		return nil, err
+		addr := &netAddr{network, address}
+		return nil, listenErr(addr, err)
+	}
+	lstn, err := listenAddr(addr)
+	if err != nil {
+		return nil, listenErr(addr, err)
 	}
-	return listenAddr(addr)
+	return lstn, nil
+}
+
+func listenErr(addr net.Addr, err error) error {
+	return newOpError("listen", addr, err)
 }
 
 func listenAddr(addr net.Addr) (net.Listener, error) {
 	fd, err := syscall.Socket(family(addr), socketType(addr), 0)
 	if err != nil {
-		return nil, fmt.Errorf("Socket: %w", err)
+		return nil, os.NewSyscallError("socket", err)
 	}
 
 	if err := syscall.SetNonblock(fd, true); err != nil {
 		syscall.Close(fd)
-		return nil, fmt.Errorf("SetNonBlock: %w", err)
+		return nil, os.NewSyscallError("setnonblock", err)
 	}
 	if err := syscall.SetsockoptInt(fd, syscall.SOL_SOCKET, syscall.SO_REUSEADDR, 1); err != nil {
 		syscall.Close(fd)
-		return nil, err
+		return nil, os.NewSyscallError("setsockopt", err)
+	}
+
+	listenAddr, err := socketAddress(addr)
+	if err != nil {
+		return nil, os.NewSyscallError("bind", err)
 	}
 
-	if err := syscall.Bind(fd, socketAddress(addr)); err != nil {
+	if err := syscall.Bind(fd, listenAddr); err != nil {
 		syscall.Close(fd)
-		return nil, fmt.Errorf("Bind: %w", err)
+		return nil, os.NewSyscallError("bind", err)
 	}
 
 	const backlog = 64 // TODO: configurable?
 	if err := syscall.Listen(fd, backlog); err != nil {
 		syscall.Close(fd)
-		return nil, fmt.Errorf("Listen: %w", err)
+		return nil, os.NewSyscallError("listen", err)
 	}
 
 	f := os.NewFile(uintptr(fd), "")
@@ -50,7 +63,7 @@ func listenAddr(addr net.Addr) (net.Listener, error) {
 	if err != nil {
 		return nil, err
 	}
-	return &listener{l, addr}, err
+	return &listener{l, addr}, nil
 }
 
 type listener struct {

wasip1/lookup_wasip1.go

@@ -1,13 +1,15 @@
+//go:build wasip1 && !purego
+
 package wasip1
 
 import (
-	"fmt"
 	"net"
+	"os"
 
-	"github.com/stealthrocket/net/syscall"
+	"github.com/stealthrocket/net/internal/syscall"
 )
 
-func lookupAddr(context, network, address string) (net.Addr, error) {
+func lookupAddr(op, network, address string) (net.Addr, error) {
 	var hints syscall.AddrInfo
 	switch network {
 	case "tcp", "tcp4", "tcp6":
@@ -19,7 +21,7 @@ func lookupAddr(context, network, address string) (net.Addr, error) {
 	case "unix", "unixgram":
 		return &net.UnixAddr{Name: address, Net: network}, nil
 	default:
-		return nil, fmt.Errorf("not implemented: %s", network)
+		return nil, net.UnknownNetworkError(network)
 	}
 	switch network {
 	case "tcp", "udp":
@@ -31,16 +33,17 @@ func lookupAddr(context, network, address string) (net.Addr, error) {
 	}
 	hostname, service, err := net.SplitHostPort(address)
 	if err != nil {
-		return nil, err
+		return nil, net.InvalidAddrError(address)
 	}
-	if context == "listen" && hostname == "" {
+	if op == "listen" && hostname == "" {
 		hints.Flags |= syscall.AI_PASSIVE
 	}
 
 	results := make([]syscall.AddrInfo, 16)
 	n, err := syscall.Getaddrinfo(hostname, service, hints, results)
 	if err != nil {
-		return nil, err
+		addr := &netAddr{network, address}
+		return nil, newOpError(op, addr, os.NewSyscallError("getaddrinfo", err))
 	}
 	results = results[:n]
 	for _, r := range results {
@@ -61,5 +64,9 @@ func lookupAddr(context, network, address string) (net.Addr, error) {
 			return &net.UDPAddr{IP: ip, Port: port}, nil
 		}
 	}
-	return nil, &net.DNSError{Err: "lookup failed", Name: hostname, IsNotFound: true}
+	return nil, &net.DNSError{
+		Err:        "lookup failed",
+		Name:       hostname,
+		IsNotFound: true,
+	}
 }

lookup_wasip1_purego.go renamed to wasip1/lookup_wasip1_purego.go

@@ -1,6 +1,6 @@
 //go:build wasip1 && purego
 
-package net
+package wasip1
 
 import (
 	"fmt"
@@ -18,11 +18,11 @@ func lookupAddr(context, network, address string) (net.Addr, error) {
 	case "unix", "unixgram":
 		return &net.UnixAddr{Name: address, Net: network}, nil
 	default:
-		return nil, fmt.Errorf("not implemented: %s", network)
+		return nil, net.UnknownNetworkError(network)
 	}
 	hostname, service, err := net.SplitHostPort(address)
 	if err != nil {
-		return nil, err
+		return nil, net.InvalidAddrError(address)
 	}
 	port, err := net.LookupPort(network, service)
 	if err != nil {
@@ -71,5 +71,9 @@ func lookupAddr(context, network, address string) (net.Addr, error) {
 			}
 		}
 	}
-	return nil, &net.DNSError{Err: "lookup failed", Name: hostname, IsNotFound: true}
+	return nil, &net.DNSError{
+		Err:        "lookup failed",
+		Name:       hostname,
+		IsNotFound: true,
+	}
 }