Add protocol state to TCPINFO

Add missing protocol state to TCPINFO struct and update packetimpact.
This re-arranges the TCP state definitions to align with Linux.

Fixes #478

PiperOrigin-RevId: 374996751

8 files changed, 125 insertions, 51 deletions

diff --git a/test/packetimpact/testbench/BUILD b/test/packetimpact/testbench/BUILD
index 616215dc3..d8059ab98 100644
--- a/test/packetimpact/testbench/BUILD
+++ b/test/packetimpact/testbench/BUILD
@@ -16,6 +16,8 @@ go_library(
     ],
     visibility = ["//test/packetimpact:__subpackages__"],
     deps = [
+        "//pkg/abi/linux",
+        "//pkg/binary",
         "//pkg/hostarch",
         "//pkg/tcpip",
         "//pkg/tcpip/buffer",
diff --git a/test/packetimpact/testbench/dut.go b/test/packetimpact/testbench/dut.go
index eabdc8cb3..269e163bb 100644
--- a/test/packetimpact/testbench/dut.go
+++ b/test/packetimpact/testbench/dut.go
@@ -22,11 +22,13 @@ import (
 	"testing"
 	"time"
 
-	pb "gvisor.dev/gvisor/test/packetimpact/proto/posix_server_go_proto"
-
 	"golang.org/x/sys/unix"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/keepalive"
+	"gvisor.dev/gvisor/pkg/abi/linux"
+	bin "gvisor.dev/gvisor/pkg/binary"
+	"gvisor.dev/gvisor/pkg/hostarch"
+	pb "gvisor.dev/gvisor/test/packetimpact/proto/posix_server_go_proto"
 )
 
 // DUT communicates with the DUT to force it to make POSIX calls.
@@ -428,6 +430,33 @@ func (dut *DUT) GetSockOptTimevalWithErrno(ctx context.Context, t *testing.T, so
 	return ret, timeval, errno
 }
 
+// GetSockOptTCPInfo retreives TCPInfo for the given socket descriptor.
+func (dut *DUT) GetSockOptTCPInfo(t *testing.T, sockfd int32) linux.TCPInfo {
+	t.Helper()
+
+	ctx, cancel := context.WithTimeout(context.Background(), RPCTimeout)
+	defer cancel()
+	ret, info, err := dut.GetSockOptTCPInfoWithErrno(ctx, t, sockfd)
+	if ret != 0 || err != unix.Errno(0) {
+		t.Fatalf("failed to GetSockOptTCPInfo: %s", err)
+	}
+	return info
+}
+
+// GetSockOptTCPInfoWithErrno retreives TCPInfo with any errno.
+func (dut *DUT) GetSockOptTCPInfoWithErrno(ctx context.Context, t *testing.T, sockfd int32) (int32, linux.TCPInfo, error) {
+	t.Helper()
+
+	info := linux.TCPInfo{}
+	ret, infoBytes, errno := dut.GetSockOptWithErrno(ctx, t, sockfd, unix.SOL_TCP, unix.TCP_INFO, int32(linux.SizeOfTCPInfo))
+	if got, want := len(infoBytes), linux.SizeOfTCPInfo; got != want {
+		t.Fatalf("expected %T, got %d bytes want %d bytes", info, got, want)
+	}
+	bin.Unmarshal(infoBytes, hostarch.ByteOrder, &info)
+
+	return ret, info, errno
+}
+
 // Listen calls listen on the DUT and causes a fatal test failure if it doesn't
 // succeed. If more control over the timeout or error handling is needed, use
 // ListenWithErrno.
diff --git a/test/packetimpact/tests/BUILD b/test/packetimpact/tests/BUILD
index c4fe293e0..b1d280f98 100644
--- a/test/packetimpact/tests/BUILD
+++ b/test/packetimpact/tests/BUILD
@@ -104,8 +104,6 @@ packetimpact_testbench(
     srcs = ["tcp_retransmits_test.go"],
     deps = [
         "//pkg/abi/linux",
-        "//pkg/binary",
-        "//pkg/hostarch",
         "//pkg/tcpip/header",
         "//test/packetimpact/testbench",
         "@org_golang_x_sys//unix:go_default_library",
@@ -189,6 +187,7 @@ packetimpact_testbench(
     name = "tcp_synsent_reset",
     srcs = ["tcp_synsent_reset_test.go"],
     deps = [
+        "//pkg/abi/linux",
         "//pkg/tcpip/header",
         "//test/packetimpact/testbench",
         "@org_golang_x_sys//unix:go_default_library",
@@ -353,8 +352,6 @@ packetimpact_testbench(
     srcs = ["tcp_rack_test.go"],
     deps = [
         "//pkg/abi/linux",
-        "//pkg/binary",
-        "//pkg/hostarch",
         "//pkg/tcpip/header",
         "//pkg/tcpip/seqnum",
         "//test/packetimpact/testbench",
@@ -367,8 +364,6 @@ packetimpact_testbench(
     srcs = ["tcp_info_test.go"],
     deps = [
         "//pkg/abi/linux",
-        "//pkg/binary",
-        "//pkg/hostarch",
         "//pkg/tcpip/header",
         "//test/packetimpact/testbench",
         "@org_golang_x_sys//unix:go_default_library",
diff --git a/test/packetimpact/tests/tcp_info_test.go b/test/packetimpact/tests/tcp_info_test.go
index 93f58ec49..b7514e846 100644
--- a/test/packetimpact/tests/tcp_info_test.go
+++ b/test/packetimpact/tests/tcp_info_test.go
@@ -21,8 +21,6 @@ import (
 
 	"golang.org/x/sys/unix"
 	"gvisor.dev/gvisor/pkg/abi/linux"
-	"gvisor.dev/gvisor/pkg/binary"
-	"gvisor.dev/gvisor/pkg/hostarch"
 	"gvisor.dev/gvisor/pkg/tcpip/header"
 	"gvisor.dev/gvisor/test/packetimpact/testbench"
 )
@@ -53,13 +51,10 @@ func TestTCPInfo(t *testing.T) {
 	}
 	conn.Send(t, testbench.TCP{Flags: testbench.TCPFlags(header.TCPFlagAck)})
 
-	info := linux.TCPInfo{}
-	infoBytes := dut.GetSockOpt(t, acceptFD, unix.SOL_TCP, unix.TCP_INFO, int32(linux.SizeOfTCPInfo))
-	if got, want := len(infoBytes), linux.SizeOfTCPInfo; got != want {
-		t.Fatalf("expected %T, got %d bytes want %d bytes", info, got, want)
+	info := dut.GetSockOptTCPInfo(t, acceptFD)
+	if got, want := uint32(info.State), linux.TCP_ESTABLISHED; got != want {
+		t.Fatalf("got %d want %d", got, want)
 	}
-	binary.Unmarshal(infoBytes, hostarch.ByteOrder, &info)
-
 	rtt := time.Duration(info.RTT) * time.Microsecond
 	rttvar := time.Duration(info.RTTVar) * time.Microsecond
 	rto := time.Duration(info.RTO) * time.Microsecond
@@ -94,12 +89,7 @@ func TestTCPInfo(t *testing.T) {
 		t.Fatalf("expected a packet with payload %v: %s", samplePayload, err)
 	}
 
-	info = linux.TCPInfo{}
-	infoBytes = dut.GetSockOpt(t, acceptFD, unix.SOL_TCP, unix.TCP_INFO, int32(linux.SizeOfTCPInfo))
-	if got, want := len(infoBytes), linux.SizeOfTCPInfo; got != want {
-		t.Fatalf("expected %T, got %d bytes want %d bytes", info, got, want)
-	}
-	binary.Unmarshal(infoBytes, hostarch.ByteOrder, &info)
+	info = dut.GetSockOptTCPInfo(t, acceptFD)
 	if info.CaState != linux.TCP_CA_Loss {
 		t.Errorf("expected the connection to be in loss recovery, got: %v want: %v", info.CaState, linux.TCP_CA_Loss)
 	}
diff --git a/test/packetimpact/tests/tcp_rack_test.go b/test/packetimpact/tests/tcp_rack_test.go
index ff1431bbf..5a60bf712 100644
--- a/test/packetimpact/tests/tcp_rack_test.go
+++ b/test/packetimpact/tests/tcp_rack_test.go
@@ -21,8 +21,6 @@ import (
 
 	"golang.org/x/sys/unix"
 	"gvisor.dev/gvisor/pkg/abi/linux"
-	"gvisor.dev/gvisor/pkg/binary"
-	"gvisor.dev/gvisor/pkg/hostarch"
 	"gvisor.dev/gvisor/pkg/tcpip/header"
 	"gvisor.dev/gvisor/pkg/tcpip/seqnum"
 	"gvisor.dev/gvisor/test/packetimpact/testbench"
@@ -69,12 +67,7 @@ func closeSACKConnection(t *testing.T, dut testbench.DUT, conn testbench.TCPIPv4
 }
 
 func getRTTAndRTO(t *testing.T, dut testbench.DUT, acceptFd int32) (rtt, rto time.Duration) {
-	info := linux.TCPInfo{}
-	infoBytes := dut.GetSockOpt(t, acceptFd, unix.SOL_TCP, unix.TCP_INFO, int32(linux.SizeOfTCPInfo))
-	if got, want := len(infoBytes), linux.SizeOfTCPInfo; got != want {
-		t.Fatalf("expected %T, got %d bytes want %d bytes", info, got, want)
-	}
-	binary.Unmarshal(infoBytes, hostarch.ByteOrder, &info)
+	info := dut.GetSockOptTCPInfo(t, acceptFd)
 	return time.Duration(info.RTT) * time.Microsecond, time.Duration(info.RTO) * time.Microsecond
 }
 
@@ -402,12 +395,7 @@ func TestRACKWithLostRetransmission(t *testing.T) {
 	}
 
 	// Check the congestion control state.
-	info := linux.TCPInfo{}
-	infoBytes := dut.GetSockOpt(t, acceptFd, unix.SOL_TCP, unix.TCP_INFO, int32(linux.SizeOfTCPInfo))
-	if got, want := len(infoBytes), linux.SizeOfTCPInfo; got != want {
-		t.Fatalf("expected %T, got %d bytes want %d bytes", info, got, want)
-	}
-	binary.Unmarshal(infoBytes, hostarch.ByteOrder, &info)
+	info := dut.GetSockOptTCPInfo(t, acceptFd)
 	if info.CaState != linux.TCP_CA_Recovery {
 		t.Fatalf("expected connection to be in fast recovery, want: %v got: %v", linux.TCP_CA_Recovery, info.CaState)
 	}
diff --git a/test/packetimpact/tests/tcp_retransmits_test.go b/test/packetimpact/tests/tcp_retransmits_test.go
index 1eafe20c3..d3fb789f4 100644
--- a/test/packetimpact/tests/tcp_retransmits_test.go
+++ b/test/packetimpact/tests/tcp_retransmits_test.go
@@ -21,9 +21,6 @@ import (
 	"time"
 
 	"golang.org/x/sys/unix"
-	"gvisor.dev/gvisor/pkg/abi/linux"
-	"gvisor.dev/gvisor/pkg/binary"
-	"gvisor.dev/gvisor/pkg/hostarch"
 	"gvisor.dev/gvisor/pkg/tcpip/header"
 	"gvisor.dev/gvisor/test/packetimpact/testbench"
 )
@@ -33,12 +30,7 @@ func init() {
 }
 
 func getRTO(t *testing.T, dut testbench.DUT, acceptFd int32) (rto time.Duration) {
-	info := linux.TCPInfo{}
-	infoBytes := dut.GetSockOpt(t, acceptFd, unix.SOL_TCP, unix.TCP_INFO, int32(linux.SizeOfTCPInfo))
-	if got, want := len(infoBytes), linux.SizeOfTCPInfo; got != want {
-		t.Fatalf("unexpected size for TCP_INFO, got %d bytes want %d bytes", got, want)
-	}
-	binary.Unmarshal(infoBytes, hostarch.ByteOrder, &info)
+	info := dut.GetSockOptTCPInfo(t, acceptFd)
 	return time.Duration(info.RTO) * time.Microsecond
 }
 
diff --git a/test/packetimpact/tests/tcp_synsent_reset_test.go b/test/packetimpact/tests/tcp_synsent_reset_test.go
index cccb0abc6..fe53e7061 100644
--- a/test/packetimpact/tests/tcp_synsent_reset_test.go
+++ b/test/packetimpact/tests/tcp_synsent_reset_test.go
@@ -20,6 +20,7 @@ import (
 	"time"
 
 	"golang.org/x/sys/unix"
+	"gvisor.dev/gvisor/pkg/abi/linux"
 	"gvisor.dev/gvisor/pkg/tcpip/header"
 	"gvisor.dev/gvisor/test/packetimpact/testbench"
 )
@@ -29,7 +30,7 @@ func init() {
 }
 
 // dutSynSentState sets up the dut connection in SYN-SENT state.
-func dutSynSentState(t *testing.T) (*testbench.DUT, *testbench.TCPIPv4, uint16, uint16) {
+func dutSynSentState(t *testing.T) (*testbench.DUT, *testbench.TCPIPv4, int32, uint16, uint16) {
 	t.Helper()
 
 	dut := testbench.NewDUT(t)
@@ -46,26 +47,29 @@ func dutSynSentState(t *testing.T) (*testbench.DUT, *testbench.TCPIPv4, uint16,
 		t.Fatalf("expected SYN\n")
 	}
 
-	return &dut, &conn, port, clientPort
+	return &dut, &conn, clientFD, port, clientPort
 }
 
 // TestTCPSynSentReset tests RFC793, p67: SYN-SENT to CLOSED transition.
 func TestTCPSynSentReset(t *testing.T) {
-	_, conn, _, _ := dutSynSentState(t)
+	dut, conn, fd, _, _ := dutSynSentState(t)
 	defer conn.Close(t)
 	conn.Send(t, testbench.TCP{Flags: testbench.TCPFlags(header.TCPFlagRst | header.TCPFlagAck)})
 	// Expect the connection to have closed.
-	// TODO(gvisor.dev/issue/478): Check for TCP_INFO on the dut side.
 	conn.Send(t, testbench.TCP{Flags: testbench.TCPFlags(header.TCPFlagAck)})
 	if _, err := conn.ExpectData(t, &testbench.TCP{Flags: testbench.TCPFlags(header.TCPFlagRst)}, nil, time.Second); err != nil {
 		t.Fatalf("expected a TCP RST")
 	}
+	info := dut.GetSockOptTCPInfo(t, fd)
+	if got, want := uint32(info.State), linux.TCP_CLOSE; got != want {
+		t.Fatalf("got %d want %d", got, want)
+	}
 }
 
 // TestTCPSynSentRcvdReset tests RFC793, p70, SYN-SENT to SYN-RCVD to CLOSED
 // transitions.
 func TestTCPSynSentRcvdReset(t *testing.T) {
-	dut, c, remotePort, clientPort := dutSynSentState(t)
+	dut, c, fd, remotePort, clientPort := dutSynSentState(t)
 	defer c.Close(t)
 
 	conn := dut.Net.NewTCPIPv4(t, testbench.TCP{SrcPort: &remotePort, DstPort: &clientPort}, testbench.TCP{SrcPort: &clientPort, DstPort: &remotePort})
@@ -79,9 +83,12 @@ func TestTCPSynSentRcvdReset(t *testing.T) {
 	}
 	conn.Send(t, testbench.TCP{Flags: testbench.TCPFlags(header.TCPFlagRst)})
 	// Expect the connection to have transitioned SYN-RCVD to CLOSED.
-	// TODO(gvisor.dev/issue/478): Check for TCP_INFO on the dut side.
 	conn.Send(t, testbench.TCP{Flags: testbench.TCPFlags(header.TCPFlagAck)})
 	if _, err := conn.ExpectData(t, &testbench.TCP{Flags: testbench.TCPFlags(header.TCPFlagRst)}, nil, time.Second); err != nil {
 		t.Fatalf("expected a TCP RST")
 	}
+	info := dut.GetSockOptTCPInfo(t, fd)
+	if got, want := uint32(info.State), linux.TCP_CLOSE; got != want {
+		t.Fatalf("got %d want %d", got, want)
+	}
 }
diff --git a/test/syscalls/linux/socket_inet_loopback.cc b/test/syscalls/linux/socket_inet_loopback.cc
index 9a6b089f6..f99d6f1c7 100644
--- a/test/syscalls/linux/socket_inet_loopback.cc
+++ b/test/syscalls/linux/socket_inet_loopback.cc
@@ -472,6 +472,77 @@ TEST_P(SocketInetLoopbackTest, TCPListenClose) {
   }
 }
 
+// Test the protocol state information returned by TCPINFO.
+TEST_P(SocketInetLoopbackTest, TCPInfoState) {
+  auto const& param = GetParam();
+  TestAddress const& listener = param.listener;
+  TestAddress const& connector = param.connector;
+
+  // Create the listening socket.
+  FileDescriptor const listen_fd = ASSERT_NO_ERRNO_AND_VALUE(
+      Socket(listener.family(), SOCK_STREAM, IPPROTO_TCP));
+
+  auto state = [](int fd) -> int {
+    struct tcp_info opt = {};
+    socklen_t optLen = sizeof(opt);
+    EXPECT_THAT(getsockopt(fd, SOL_TCP, TCP_INFO, &opt, &optLen),
+                SyscallSucceeds());
+    return opt.tcpi_state;
+  };
+  ASSERT_EQ(state(listen_fd.get()), TCP_CLOSE);
+
+  sockaddr_storage listen_addr = listener.addr;
+  ASSERT_THAT(
+      bind(listen_fd.get(), AsSockAddr(&listen_addr), listener.addr_len),
+      SyscallSucceeds());
+  ASSERT_EQ(state(listen_fd.get()), TCP_CLOSE);
+
+  ASSERT_THAT(listen(listen_fd.get(), SOMAXCONN), SyscallSucceeds());
+  ASSERT_EQ(state(listen_fd.get()), TCP_LISTEN);
+
+  // Get the port bound by the listening socket.
+  socklen_t addrlen = listener.addr_len;
+  ASSERT_THAT(getsockname(listen_fd.get(), AsSockAddr(&listen_addr), &addrlen),
+              SyscallSucceeds());
+  uint16_t const port =
+      ASSERT_NO_ERRNO_AND_VALUE(AddrPort(listener.family(), listen_addr));
+
+  // Connect to the listening socket.
+  FileDescriptor conn_fd = ASSERT_NO_ERRNO_AND_VALUE(
+      Socket(connector.family(), SOCK_STREAM, IPPROTO_TCP));
+  sockaddr_storage conn_addr = connector.addr;
+  ASSERT_NO_ERRNO(SetAddrPort(connector.family(), &conn_addr, port));
+  ASSERT_EQ(state(conn_fd.get()), TCP_CLOSE);
+  ASSERT_THAT(RetryEINTR(connect)(conn_fd.get(), AsSockAddr(&conn_addr),
+                                  connector.addr_len),
+              SyscallSucceeds());
+  ASSERT_EQ(state(conn_fd.get()), TCP_ESTABLISHED);
+
+  auto accepted =
+      ASSERT_NO_ERRNO_AND_VALUE(Accept(listen_fd.get(), nullptr, nullptr));
+  ASSERT_EQ(state(accepted.get()), TCP_ESTABLISHED);
+
+  ASSERT_THAT(close(accepted.release()), SyscallSucceeds());
+
+  struct pollfd pfd = {
+      .fd = conn_fd.get(),
+      .events = POLLIN | POLLRDHUP,
+  };
+  constexpr int kTimeout = 10000;
+  int n = poll(&pfd, 1, kTimeout);
+  ASSERT_GE(n, 0) << strerror(errno);
+  ASSERT_EQ(n, 1);
+  if (IsRunningOnGvisor()) {
+    // TODO(gvisor.dev/issue/6015): Notify POLLRDHUP on incoming FIN.
+    ASSERT_EQ(pfd.revents, POLLIN);
+  } else {
+    ASSERT_EQ(pfd.revents, POLLIN | POLLRDHUP);
+  }
+
+  ASSERT_THAT(state(conn_fd.get()), TCP_CLOSE_WAIT);
+  ASSERT_THAT(close(conn_fd.release()), SyscallSucceeds());
+}
+
 void TestHangupDuringConnect(const TestParam& param,
                              void (*hangup)(FileDescriptor&)) {
   TestAddress const& listener = param.listener;