[op] Replace syscall package usage with golang.org/x/sys/unix in test/.

The syscall package has been deprecated in favor of golang.org/x/sys.

Note that syscall is still used in some places because the following don't seem
to have an equivalent in unix package:
- syscall.SysProcIDMap
- syscall.Credential

Updates #214

PiperOrigin-RevId: 361332034

8 files changed, 32 insertions, 40 deletions

diff --git a/test/packetimpact/tests/tcp_linger_test.go b/test/packetimpact/tests/tcp_linger_test.go
index bc4b64388..6c57b6d37 100644
--- a/test/packetimpact/tests/tcp_linger_test.go
+++ b/test/packetimpact/tests/tcp_linger_test.go
@@ -17,7 +17,6 @@ package tcp_linger_test
 import (
 	"context"
 	"flag"
-	"syscall"
 	"testing"
 	"time"
 
@@ -183,7 +182,7 @@ func TestTCPLingerShutdownZeroTimeout(t *testing.T) {
 	defer closeAll(t, dut, listenFD, conn)
 
 	dut.SetSockLingerOption(t, acceptFD, 0, true)
-	dut.Shutdown(t, acceptFD, syscall.SHUT_RDWR)
+	dut.Shutdown(t, acceptFD, unix.SHUT_RDWR)
 	dut.Close(t, acceptFD)
 
 	// Shutdown will send FIN-ACK with read/write option.
@@ -220,7 +219,7 @@ func TestTCPLingerShutdownSendNonZeroTimeout(t *testing.T) {
 			sampleData := []byte("Sample Data")
 			dut.Send(t, acceptFD, sampleData, 0)
 
-			dut.Shutdown(t, acceptFD, syscall.SHUT_RDWR)
+			dut.Shutdown(t, acceptFD, unix.SHUT_RDWR)
 
 			// Increase timeout as Close will take longer time to
 			// return when SO_LINGER is set with non-zero timeout.
diff --git a/test/packetimpact/tests/tcp_network_unreachable_test.go b/test/packetimpact/tests/tcp_network_unreachable_test.go
index 53dc903e4..4e5b418e4 100644
--- a/test/packetimpact/tests/tcp_network_unreachable_test.go
+++ b/test/packetimpact/tests/tcp_network_unreachable_test.go
@@ -17,7 +17,6 @@ package tcp_synsent_reset_test
 import (
 	"context"
 	"flag"
-	"syscall"
 	"testing"
 	"time"
 
@@ -46,7 +45,7 @@ func TestTCPSynSentUnreachable(t *testing.T) {
 	defer cancel()
 	sa := unix.SockaddrInet4{Port: int(port)}
 	copy(sa.Addr[:], dut.Net.LocalIPv4)
-	if _, err := dut.ConnectWithErrno(ctx, t, clientFD, &sa); err != syscall.Errno(unix.EINPROGRESS) {
+	if _, err := dut.ConnectWithErrno(ctx, t, clientFD, &sa); err != unix.EINPROGRESS {
 		t.Errorf("got connect() = %v, want EINPROGRESS", err)
 	}
 
@@ -100,7 +99,7 @@ func TestTCPSynSentUnreachable6(t *testing.T) {
 		ZoneId: dut.Net.RemoteDevID,
 	}
 	copy(sa.Addr[:], dut.Net.LocalIPv6)
-	if _, err := dut.ConnectWithErrno(ctx, t, clientFD, &sa); err != syscall.Errno(unix.EINPROGRESS) {
+	if _, err := dut.ConnectWithErrno(ctx, t, clientFD, &sa); err != unix.EINPROGRESS {
 		t.Errorf("got connect() = %v, want EINPROGRESS", err)
 	}
 
@@ -156,7 +155,7 @@ func getConnectError(t *testing.T, dut *testbench.DUT, fd int32) error {
 	// failure).
 	dut.PollOne(t, fd, unix.POLLOUT, 10*time.Second)
 	if errno := dut.GetSockOptInt(t, fd, unix.SOL_SOCKET, unix.SO_ERROR); errno != 0 {
-		return syscall.Errno(errno)
+		return unix.Errno(errno)
 	}
 	return nil
 }
diff --git a/test/packetimpact/tests/tcp_queue_send_recv_in_syn_sent_test.go b/test/packetimpact/tests/tcp_queue_send_recv_in_syn_sent_test.go
index 7dd1c326a..74616a54c 100644
--- a/test/packetimpact/tests/tcp_queue_send_recv_in_syn_sent_test.go
+++ b/test/packetimpact/tests/tcp_queue_send_recv_in_syn_sent_test.go
@@ -21,7 +21,6 @@ import (
 	"errors"
 	"flag"
 	"sync"
-	"syscall"
 	"testing"
 	"time"
 
@@ -45,7 +44,7 @@ func TestQueueSendInSynSentHandshake(t *testing.T) {
 	sampleData := []byte("Sample Data")
 
 	dut.SetNonBlocking(t, socket, true)
-	if _, err := dut.ConnectWithErrno(context.Background(), t, socket, conn.LocalAddr(t)); !errors.Is(err, syscall.EINPROGRESS) {
+	if _, err := dut.ConnectWithErrno(context.Background(), t, socket, conn.LocalAddr(t)); !errors.Is(err, unix.EINPROGRESS) {
 		t.Fatalf("failed to bring DUT to SYN-SENT, got: %s, want EINPROGRESS", err)
 	}
 	if _, err := conn.Expect(t, testbench.TCP{Flags: testbench.Uint8(header.TCPFlagSyn)}, time.Second); err != nil {
@@ -113,15 +112,15 @@ func TestQueueRecvInSynSentHandshake(t *testing.T) {
 	sampleData := []byte("Sample Data")
 
 	dut.SetNonBlocking(t, socket, true)
-	if _, err := dut.ConnectWithErrno(context.Background(), t, socket, conn.LocalAddr(t)); !errors.Is(err, syscall.EINPROGRESS) {
+	if _, err := dut.ConnectWithErrno(context.Background(), t, socket, conn.LocalAddr(t)); !errors.Is(err, unix.EINPROGRESS) {
 		t.Fatalf("failed to bring DUT to SYN-SENT, got: %s, want EINPROGRESS", err)
 	}
 	if _, err := conn.Expect(t, testbench.TCP{Flags: testbench.Uint8(header.TCPFlagSyn)}, time.Second); err != nil {
 		t.Fatalf("expected a SYN from DUT, but got none: %s", err)
 	}
 
-	if _, _, err := dut.RecvWithErrno(context.Background(), t, socket, int32(len(sampleData)), 0); err != syscall.Errno(unix.EWOULDBLOCK) {
-		t.Fatalf("expected error %s, got %s", syscall.Errno(unix.EWOULDBLOCK), err)
+	if _, _, err := dut.RecvWithErrno(context.Background(), t, socket, int32(len(sampleData)), 0); err != unix.EWOULDBLOCK {
+		t.Fatalf("expected error %s, got %s", unix.EWOULDBLOCK, err)
 	}
 
 	// Test blocking read.
@@ -183,7 +182,7 @@ func TestQueueSendInSynSentRST(t *testing.T) {
 	sampleData := []byte("Sample Data")
 
 	dut.SetNonBlocking(t, socket, true)
-	if _, err := dut.ConnectWithErrno(context.Background(), t, socket, conn.LocalAddr(t)); !errors.Is(err, syscall.EINPROGRESS) {
+	if _, err := dut.ConnectWithErrno(context.Background(), t, socket, conn.LocalAddr(t)); !errors.Is(err, unix.EINPROGRESS) {
 		t.Fatalf("failed to bring DUT to SYN-SENT, got: %s, want EINPROGRESS", err)
 	}
 	if _, err := conn.Expect(t, testbench.TCP{Flags: testbench.Uint8(header.TCPFlagSyn)}, time.Second); err != nil {
@@ -207,8 +206,8 @@ func TestQueueSendInSynSentRST(t *testing.T) {
 		// Issue SEND call in SYN-SENT, this should be queued for
 		// process until the connection is established.
 		n, err := dut.SendWithErrno(ctx, t, socket, sampleData, 0)
-		if err != syscall.Errno(unix.ECONNREFUSED) {
-			t.Errorf("expected error %s, got %s", syscall.Errno(unix.ECONNREFUSED), err)
+		if err != unix.ECONNREFUSED {
+			t.Errorf("expected error %s, got %s", unix.ECONNREFUSED, err)
 		}
 		if n != -1 {
 			t.Errorf("expected return value %d, got %d", -1, n)
@@ -238,15 +237,15 @@ func TestQueueRecvInSynSentRST(t *testing.T) {
 	sampleData := []byte("Sample Data")
 
 	dut.SetNonBlocking(t, socket, true)
-	if _, err := dut.ConnectWithErrno(context.Background(), t, socket, conn.LocalAddr(t)); !errors.Is(err, syscall.EINPROGRESS) {
+	if _, err := dut.ConnectWithErrno(context.Background(), t, socket, conn.LocalAddr(t)); !errors.Is(err, unix.EINPROGRESS) {
 		t.Fatalf("failed to bring DUT to SYN-SENT, got: %s, want EINPROGRESS", err)
 	}
 	if _, err := conn.Expect(t, testbench.TCP{Flags: testbench.Uint8(header.TCPFlagSyn)}, time.Second); err != nil {
 		t.Fatalf("expected a SYN from DUT, but got none: %s", err)
 	}
 
-	if _, _, err := dut.RecvWithErrno(context.Background(), t, socket, int32(len(sampleData)), 0); err != syscall.Errno(unix.EWOULDBLOCK) {
-		t.Fatalf("expected error %s, got %s", syscall.Errno(unix.EWOULDBLOCK), err)
+	if _, _, err := dut.RecvWithErrno(context.Background(), t, socket, int32(len(sampleData)), 0); err != unix.EWOULDBLOCK {
+		t.Fatalf("expected error %s, got %s", unix.EWOULDBLOCK, err)
 	}
 
 	// Test blocking read.
@@ -266,8 +265,8 @@ func TestQueueRecvInSynSentRST(t *testing.T) {
 		// Issue RECEIVE call in SYN-SENT, this should be queued for
 		// process until the connection is established.
 		n, _, err := dut.RecvWithErrno(ctx, t, socket, int32(len(sampleData)), 0)
-		if err != syscall.Errno(unix.ECONNREFUSED) {
-			t.Errorf("expected error %s, got %s", syscall.Errno(unix.ECONNREFUSED), err)
+		if err != unix.ECONNREFUSED {
+			t.Errorf("expected error %s, got %s", unix.ECONNREFUSED, err)
 		}
 		if n != -1 {
 			t.Errorf("expected return value %d, got %d", -1, n)
diff --git a/test/packetimpact/tests/tcp_rcv_buf_space_test.go b/test/packetimpact/tests/tcp_rcv_buf_space_test.go
index d6ad5cda6..042da8fee 100644
--- a/test/packetimpact/tests/tcp_rcv_buf_space_test.go
+++ b/test/packetimpact/tests/tcp_rcv_buf_space_test.go
@@ -17,7 +17,6 @@ package tcp_rcv_buf_space_test
 import (
 	"context"
 	"flag"
-	"syscall"
 	"testing"
 
 	"golang.org/x/sys/unix"
@@ -73,7 +72,7 @@ func TestReduceRecvBuf(t *testing.T) {
 	// Second read should return EAGAIN as the last segment should have been
 	// dropped due to it exceeding the receive buffer space available in the
 	// socket.
-	if ret, got, err := dut.RecvWithErrno(context.Background(), t, acceptFd, int32(len(sampleData)), syscall.MSG_DONTWAIT); got != nil || ret != -1 || err != syscall.EAGAIN {
+	if ret, got, err := dut.RecvWithErrno(context.Background(), t, acceptFd, int32(len(sampleData)), unix.MSG_DONTWAIT); got != nil || ret != -1 || err != unix.EAGAIN {
 		t.Fatalf("expected no packets but got: %s", got)
 	}
 }
diff --git a/test/packetimpact/tests/tcp_unacc_seq_ack_test.go b/test/packetimpact/tests/tcp_unacc_seq_ack_test.go
index ea962c818..b76369dbe 100644
--- a/test/packetimpact/tests/tcp_unacc_seq_ack_test.go
+++ b/test/packetimpact/tests/tcp_unacc_seq_ack_test.go
@@ -17,7 +17,6 @@ package tcp_unacc_seq_ack_test
 import (
 	"flag"
 	"fmt"
-	"syscall"
 	"testing"
 	"time"
 
@@ -171,7 +170,7 @@ func TestActiveCloseUnaccpSeqAck(t *testing.T) {
 			acceptFD, _ := dut.Accept(t, listenFD)
 
 			// Trigger active close.
-			dut.Shutdown(t, acceptFD, syscall.SHUT_WR)
+			dut.Shutdown(t, acceptFD, unix.SHUT_WR)
 
 			// Get to FIN_WAIT2
 			gotTCP, err := conn.Expect(t, testbench.TCP{Flags: testbench.Uint8(header.TCPFlagFin | header.TCPFlagAck)}, time.Second)
diff --git a/test/packetimpact/tests/udp_discard_mcast_source_addr_test.go b/test/packetimpact/tests/udp_discard_mcast_source_addr_test.go
index 52c6f9d91..f63cfcc9a 100644
--- a/test/packetimpact/tests/udp_discard_mcast_source_addr_test.go
+++ b/test/packetimpact/tests/udp_discard_mcast_source_addr_test.go
@@ -19,7 +19,6 @@ import (
 	"flag"
 	"fmt"
 	"net"
-	"syscall"
 	"testing"
 
 	"golang.org/x/sys/unix"
@@ -56,7 +55,7 @@ func TestDiscardsUDPPacketsWithMcastSourceAddressV4(t *testing.T) {
 			)
 
 			ret, payload, errno := dut.RecvWithErrno(context.Background(), t, remoteFD, 100, 0)
-			if errno != syscall.EAGAIN || errno != syscall.EWOULDBLOCK {
+			if errno != unix.EAGAIN || errno != unix.EWOULDBLOCK {
 				t.Errorf("Recv got unexpected result, ret=%d, payload=%q, errno=%s", ret, payload, errno)
 			}
 		})
@@ -86,7 +85,7 @@ func TestDiscardsUDPPacketsWithMcastSourceAddressV6(t *testing.T) {
 				&testbench.Payload{Bytes: []byte("test payload")},
 			)
 			ret, payload, errno := dut.RecvWithErrno(context.Background(), t, remoteFD, 100, 0)
-			if errno != syscall.EAGAIN || errno != syscall.EWOULDBLOCK {
+			if errno != unix.EAGAIN || errno != unix.EWOULDBLOCK {
 				t.Errorf("Recv got unexpected result, ret=%d, payload=%q, errno=%s", ret, payload, errno)
 			}
 		})
diff --git a/test/packetimpact/tests/udp_icmp_error_propagation_test.go b/test/packetimpact/tests/udp_icmp_error_propagation_test.go
index 3fca8c7a3..3159d5b89 100644
--- a/test/packetimpact/tests/udp_icmp_error_propagation_test.go
+++ b/test/packetimpact/tests/udp_icmp_error_propagation_test.go
@@ -20,7 +20,6 @@ import (
 	"fmt"
 	"net"
 	"sync"
-	"syscall"
 	"testing"
 	"time"
 
@@ -86,16 +85,16 @@ type testData struct {
 	remotePort uint16
 	cleanFD    int32
 	cleanPort  uint16
-	wantErrno  syscall.Errno
+	wantErrno  unix.Errno
 }
 
 // wantErrno computes the errno to expect given the connection mode of a UDP
 // socket and the ICMP error it will receive.
-func wantErrno(c connectionMode, icmpErr icmpError) syscall.Errno {
+func wantErrno(c connectionMode, icmpErr icmpError) unix.Errno {
 	if c && icmpErr == portUnreachable {
-		return syscall.Errno(unix.ECONNREFUSED)
+		return unix.ECONNREFUSED
 	}
-	return syscall.Errno(0)
+	return unix.Errno(0)
 }
 
 // sendICMPError sends an ICMP error message in response to a UDP datagram.
@@ -123,7 +122,7 @@ func sendICMPError(t *testing.T, conn *testbench.UDPIPv4, icmpErr icmpError, udp
 	conn.SendFrameStateless(t, layers)
 }
 
-// testRecv tests observing the ICMP error through the recv syscall. A packet
+// testRecv tests observing the ICMP error through the recv unix. A packet
 // is sent to the DUT, and if wantErrno is non-zero, then the first recv should
 // fail and the second should succeed. Otherwise if wantErrno is zero then the
 // first recv should succeed immediately.
@@ -136,7 +135,7 @@ func testRecv(ctx context.Context, t *testing.T, d testData) {
 
 	d.conn.Send(t, testbench.UDP{})
 
-	if d.wantErrno != syscall.Errno(0) {
+	if d.wantErrno != unix.Errno(0) {
 		ctx, cancel := context.WithTimeout(ctx, time.Second)
 		defer cancel()
 		ret, _, err := d.dut.RecvWithErrno(ctx, t, d.remoteFD, 100, 0)
@@ -162,7 +161,7 @@ func testSendTo(ctx context.Context, t *testing.T, d testData) {
 		t.Fatalf("did not receive UDP packet from clean socket on DUT: %s", err)
 	}
 
-	if d.wantErrno != syscall.Errno(0) {
+	if d.wantErrno != unix.Errno(0) {
 		ctx, cancel := context.WithTimeout(ctx, time.Second)
 		defer cancel()
 		ret, err := d.dut.SendToWithErrno(ctx, t, d.remoteFD, nil, 0, d.conn.LocalAddr(t))
@@ -183,11 +182,11 @@ func testSendTo(ctx context.Context, t *testing.T, d testData) {
 
 func testSockOpt(_ context.Context, t *testing.T, d testData) {
 	// Check that there's no pending error on the clean socket.
-	if errno := syscall.Errno(d.dut.GetSockOptInt(t, d.cleanFD, unix.SOL_SOCKET, unix.SO_ERROR)); errno != syscall.Errno(0) {
+	if errno := unix.Errno(d.dut.GetSockOptInt(t, d.cleanFD, unix.SOL_SOCKET, unix.SO_ERROR)); errno != unix.Errno(0) {
 		t.Fatalf("unexpected error (%[1]d) %[1]v on clean socket", errno)
 	}
 
-	if errno := syscall.Errno(d.dut.GetSockOptInt(t, d.remoteFD, unix.SOL_SOCKET, unix.SO_ERROR)); errno != d.wantErrno {
+	if errno := unix.Errno(d.dut.GetSockOptInt(t, d.remoteFD, unix.SOL_SOCKET, unix.SO_ERROR)); errno != d.wantErrno {
 		t.Fatalf("SO_ERROR sockopt after ICMP error is (%[1]d) %[1]v, expected (%[2]d) %[2]v", errno, d.wantErrno)
 	}
 
@@ -310,7 +309,7 @@ func TestICMPErrorDuringUDPRecv(t *testing.T) {
 				go func() {
 					defer wg.Done()
 
-					if wantErrno != syscall.Errno(0) {
+					if wantErrno != unix.Errno(0) {
 						ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 						defer cancel()
 
diff --git a/test/packetimpact/tests/udp_send_recv_dgram_test.go b/test/packetimpact/tests/udp_send_recv_dgram_test.go
index 894d156cf..230b012c7 100644
--- a/test/packetimpact/tests/udp_send_recv_dgram_test.go
+++ b/test/packetimpact/tests/udp_send_recv_dgram_test.go
@@ -19,7 +19,6 @@ import (
 	"flag"
 	"fmt"
 	"net"
-	"syscall"
 	"testing"
 	"time"
 
@@ -241,7 +240,7 @@ func TestUDP(t *testing.T) {
 								},
 							)
 							ret, recvPayload, errno := dut.RecvWithErrno(context.Background(), t, socketFD, 100, 0)
-							if errno != syscall.EAGAIN || errno != syscall.EWOULDBLOCK {
+							if errno != unix.EAGAIN || errno != unix.EWOULDBLOCK {
 								t.Errorf("Recv got unexpected result, ret=%d, payload=%q, errno=%s", ret, recvPayload, errno)
 							}
 						}