Merge changes I82db15c1,If838bab9 into main

* changes:
  net-test: re-enable 'ignore::ResourceWarning' python warnings
  net-test: close even more leaking sockets

4 files changed, 66 insertions, 15 deletions

diff --git a/net/test/all_tests.sh b/net/test/all_tests.sh
index aa63cdd..63576b0 100755
--- a/net/test/all_tests.sh
+++ b/net/test/all_tests.sh
@@ -18,10 +18,6 @@ readonly PREFIX="#####"
 readonly RETRIES=2
 test_prefix=
 
-# The tests currently have hundreds of ResourceWarnings that make it hard
-# to see errors/failures. Disable this warning for now.
-export PYTHONWARNINGS="ignore::ResourceWarning"
-
 function checkArgOrExit() {
   if [[ $# -lt 2 ]]; then
     echo "Missing argument for option $1" >&2
diff --git a/net/test/sock_diag_test.py b/net/test/sock_diag_test.py
index 8aac69d..58e8f01 100755
--- a/net/test/sock_diag_test.py
+++ b/net/test/sock_diag_test.py
@@ -179,6 +179,9 @@ class SockDiagTest(SockDiagBaseTest):
       self.sock_diag.GetSockInfo(diag_req)
       # No errors? Good.
 
+    for sock in socketpair:
+      sock.close()
+
   def CheckFindsAllMySockets(self, socktype, proto):
     """Tests that basic socket dumping works."""
     self.socketpairs = self._CreateLotsOfSockets(socktype)
@@ -220,6 +223,10 @@ class SockDiagTest(SockDiagBaseTest):
         info = self.sock_diag.GetSockInfo(req)
         self.assertSockInfoMatchesSocket(sock, info)
 
+    for socketpair in socketpairs:
+      for sock in socketpair:
+        sock.close()
+
   def assertItemsEqual(self, expected, actual):
     try:
       super(SockDiagTest, self).assertItemsEqual(expected, actual)
@@ -332,6 +339,15 @@ class SockDiagTest(SockDiagBaseTest):
     self.assertTrue(all(d in v4socks for d in diag_msgs))
     self.assertTrue(all(d in v6socks for d in diag_msgs))
 
+    for sock in unused_pair4:
+      sock.close()
+
+    for sock in unused_pair6:
+      sock.close()
+
+    for sock in pair5:
+      sock.close()
+
   def testPortComparisonValidation(self):
     """Checks for a bug in validating port comparison bytecode.
 
@@ -365,6 +381,9 @@ class SockDiagTest(SockDiagBaseTest):
       cookie = sock.getsockopt(net_test.SOL_SOCKET, net_test.SO_COOKIE, 8)
       self.assertEqual(diag_msg.id.cookie, cookie)
 
+    for sock in socketpair:
+      sock.close()
+
   def testGetsockoptcookie(self):
     self.CheckSocketCookie(AF_INET, "127.0.0.1")
     self.CheckSocketCookie(AF_INET6, "::1")
@@ -399,6 +418,8 @@ class SockDiagTest(SockDiagBaseTest):
 
       self.assertSockInfoMatchesSocket(s, self.sock_diag.GetSockInfo(req))
 
+      s.close()
+
 
 class SockDestroyTest(SockDiagBaseTest):
   """Tests that SOCK_DESTROY works correctly.
@@ -538,6 +559,7 @@ class TcpRcvWindowTest(tcp_test.TcpBaseTest, SockDiagBaseTest):
                     "Tcp rwnd of netid=%d, version=%d is not enough. "
                     "Expect: %d, actual: %d" % (netid, version, self.RWND_SIZE,
                                                 tcpInfo.tcpi_rcv_ssthresh))
+    self.CloseSockets()
 
   def checkSynPacketWindowSize(self, version, netid):
     s = self.BuildSocket(version, net_test.TCPSocket, netid, "mark")
@@ -595,6 +617,7 @@ class SockDestroyTcpTest(tcp_test.TcpBaseTest, SockDiagBaseTest):
       if state != tcp_test.TCP_LISTEN:
         msg = "Closing accepted IPv%d %s socket" % (version, statename)
         self.CheckRstOnClose(self.accepted, None, True, msg)
+        self.CloseSockets()
 
   def testTcpResets(self):
     """Checks that closing sockets in appropriate states sends a RST."""
@@ -613,6 +636,7 @@ class SockDestroyTcpTest(tcp_test.TcpBaseTest, SockDiagBaseTest):
       # Close the socket and check that it goes into FIN_WAIT1 and sends a FIN.
       net_test.EnableFinWait(self.accepted)
       self.accepted.close()
+      del self.accepted
       diag_req.states = 1 << tcp_test.TCP_FIN_WAIT1
       diag_msg, attrs = self.sock_diag.GetSockInfo(diag_req)
       self.assertEqual(tcp_test.TCP_FIN_WAIT1, diag_msg.state)
@@ -640,6 +664,8 @@ class SockDestroyTcpTest(tcp_test.TcpBaseTest, SockDiagBaseTest):
                           for diag_msg, attrs in infos),
                       "Expected to find FIN_WAIT2 socket in %s" % infos)
 
+      self.CloseSockets()
+
   def FindChildSockets(self, s):
     """Finds the SYN_RECV child sockets of a given listening socket."""
     d = self.sock_diag.FindSockDiagFromFd(self.s)
@@ -703,11 +729,11 @@ class SockDestroyTcpTest(tcp_test.TcpBaseTest, SockDiagBaseTest):
       else:
         CloseChildren()
         CheckChildrenClosed()
-      self.s.close()
     else:
       CloseChildren()
       CloseParent(False)
-      self.s.close()
+
+    self.CloseSockets()
 
   def testChildSockets(self):
     for version in [4, 5, 6]:
@@ -726,6 +752,7 @@ class SockDestroyTcpTest(tcp_test.TcpBaseTest, SockDiagBaseTest):
       self.assertRaisesErrno(EINVAL, self.s.accept)
       # TODO: this should really return an error such as ENOTCONN...
       self.assertEqual(b"", self.s.recv(4096))
+      self.CloseSockets()
 
   def testReadInterrupted(self):
     """Tests that read() is interrupted by SOCK_DESTROY."""
@@ -737,6 +764,7 @@ class SockDestroyTcpTest(tcp_test.TcpBaseTest, SockDiagBaseTest):
       self.assertRaisesErrno(EPIPE, self.accepted.send, b"foo")
       self.assertEqual(b"", self.accepted.recv(4096))
       self.assertEqual(b"", self.accepted.recv(4096))
+      self.CloseSockets()
 
   def testConnectInterrupted(self):
     """Tests that connect() is interrupted by SOCK_DESTROY."""
@@ -756,6 +784,7 @@ class SockDestroyTcpTest(tcp_test.TcpBaseTest, SockDiagBaseTest):
       self.ExpectPacketOn(self.netid, desc, syn)
       msg = "SOCK_DESTROY of socket in connect, expected no RST"
       self.ExpectNoPacketsOn(self.netid, msg)
+      s.close()
 
 
 class PollOnCloseTest(tcp_test.TcpBaseTest, SockDiagBaseTest):
@@ -817,6 +846,7 @@ class PollOnCloseTest(tcp_test.TcpBaseTest, SockDiagBaseTest):
           lambda sock: self.BlockingPoll(sock, mask, expected, ignoremask),
           None)
       self.assertSocketErrors(ECONNABORTED)
+      self.CloseSockets()
 
   def CheckPollRst(self, mask, expected, ignoremask):
     """Interrupts a poll() by receiving a TCP RST."""
@@ -827,6 +857,7 @@ class PollOnCloseTest(tcp_test.TcpBaseTest, SockDiagBaseTest):
           lambda sock: self.BlockingPoll(sock, mask, expected, ignoremask),
           None)
       self.assertSocketErrors(ECONNRESET)
+      self.CloseSockets()
 
   def testReadPollRst(self):
     self.CheckPollRst(select.POLLIN, self.POLLIN_ERR_HUP, 0)
@@ -899,6 +930,7 @@ class SockDestroyUdpTest(SockDiagBaseTest):
       s.connect((dst, 53))
       self.sock_diag.CloseSocketFromFd(s)
       self.assertEqual((unspec, 0), s.getsockname()[:2])
+      s.close()
 
       # Closing a socket bound to an IP address leaves the address as is.
       s = self.BuildSocket(version, net_test.UDPSocket, netid, "mark")
@@ -908,6 +940,7 @@ class SockDestroyUdpTest(SockDiagBaseTest):
       port = s.getsockname()[1]
       self.sock_diag.CloseSocketFromFd(s)
       self.assertEqual((src, 0), s.getsockname()[:2])
+      s.close()
 
       # Closing a socket bound to a port leaves the port as is.
       s = self.BuildSocket(version, net_test.UDPSocket, netid, "mark")
@@ -915,6 +948,7 @@ class SockDestroyUdpTest(SockDiagBaseTest):
       s.connect((dst, 53))
       self.sock_diag.CloseSocketFromFd(s)
       self.assertEqual((unspec, port), s.getsockname()[:2])
+      s.close()
 
       # Closing a socket bound to IP address and port leaves both as is.
       s = self.BuildSocket(version, net_test.UDPSocket, netid, "mark")
@@ -922,6 +956,7 @@ class SockDestroyUdpTest(SockDiagBaseTest):
       port = self.BindToRandomPort(s, src)
       self.sock_diag.CloseSocketFromFd(s)
       self.assertEqual((src, port), s.getsockname()[:2])
+      s.close()
 
   def testReadInterrupted(self):
     """Tests that read() is interrupted by SOCK_DESTROY."""
@@ -945,6 +980,8 @@ class SockDestroyUdpTest(SockDiagBaseTest):
       self.CloseDuringBlockingCall(s, lambda sock: sock.recv(4096),
                                    ECONNABORTED)
 
+      s.close()
+
 class SockDestroyPermissionTest(SockDiagBaseTest):
 
   def CheckPermissions(self, socktype):
@@ -964,6 +1001,8 @@ class SockDestroyPermissionTest(SockDiagBaseTest):
     self.sock_diag.CloseSocketFromFd(s)
     self.assertRaises(ValueError, self.sock_diag.CloseSocketFromFd, s)
 
+    s.close()
+
 
   def testUdp(self):
     self.CheckPermissions(SOCK_DGRAM)
@@ -1050,6 +1089,9 @@ class SockDiagMarkTest(tcp_test.TcpBaseTest, SockDiagBaseTest):
         self.assertRaisesErrno(EPERM, self.FilterEstablishedSockets,
                                0xfff0000, 0xf0fed00)
 
+    s1.close()
+    s2.close()
+
   @staticmethod
   def SetRandomMark(s):
     # Python doesn't like marks that don't fit into a signed int.
@@ -1091,6 +1133,7 @@ class SockDiagMarkTest(tcp_test.TcpBaseTest, SockDiagBaseTest):
       self.assertSocketMarkIs(accepted, accepted_mark)
       self.assertSocketMarkIs(server, server_mark)
 
+      accepted.close()
       server.close()
       client.close()
 
diff --git a/net/test/tcp_test.py b/net/test/tcp_test.py
index f551afc..f3ee291 100644
--- a/net/test/tcp_test.py
+++ b/net/test/tcp_test.py
@@ -40,13 +40,16 @@ TCP_NOT_YET_ACCEPTED = -1
 
 class TcpBaseTest(multinetwork_base.MultiNetworkBaseTest):
 
-  def tearDown(self):
+  def CloseSockets(self):
     if hasattr(self, "accepted"):
       self.accepted.close()
       del self.accepted
     if hasattr(self, "s"):
       self.s.close()
       del self.s
+
+  def tearDown(self):
+    self.CloseSockets()
     super(TcpBaseTest, self).tearDown()
 
   def OpenListenSocket(self, version, netid):
diff --git a/net/test/xfrm_tunnel_test.py b/net/test/xfrm_tunnel_test.py
index 715b559..3d0aa53 100755
--- a/net/test/xfrm_tunnel_test.py
+++ b/net/test/xfrm_tunnel_test.py
@@ -162,6 +162,7 @@ def _SendPacket(testInstance, netid, version, remote, remote_port):
   testInstance.SelectInterface(write_sock, netid, "mark")
   write_sock.sendto(net_test.UDP_PAYLOAD, (remote, remote_port))
   local_port = write_sock.getsockname()[1]
+  write_sock.close()
 
   return local_port
 
@@ -260,6 +261,9 @@ class XfrmTunnelTest(xfrm_base.XfrmLazyTest):
       sock = write_sock if direction == xfrm.XFRM_POLICY_OUT else read_sock
       func(inner_version, outer_version, u_netid, netid, local_inner,
           remote_inner, local_outer, remote_outer, sock)
+
+      write_sock.close()
+      read_sock.close()
     finally:
       if test_output_mark_unset:
         self.ClearDefaultNetwork()
@@ -731,14 +735,17 @@ class XfrmTunnelBase(xfrm_base.XfrmBaseTest):
         local_inner, tunnel.local, local_port, sa_info.spi, sa_info.seq_num)
     self.ReceivePacketOn(tunnel.underlying_netid, input_pkt)
 
-    if expect_fail:
-      self.assertRaisesErrno(EAGAIN, read_sock.recv, 4096)
-    else:
-      # Verify that the packet data and src are correct
-      data, src = read_sock.recvfrom(4096)
-      self.assertReceivedPacket(tunnel, sa_info)
-      self.assertEqual(net_test.UDP_PAYLOAD, data)
-      self.assertEqual((remote_inner, _TEST_REMOTE_PORT), src[:2])
+    try:
+      if expect_fail:
+        self.assertRaisesErrno(EAGAIN, read_sock.recv, 4096)
+      else:
+        # Verify that the packet data and src are correct
+        data, src = read_sock.recvfrom(4096)
+        self.assertReceivedPacket(tunnel, sa_info)
+        self.assertEqual(net_test.UDP_PAYLOAD, data)
+        self.assertEqual((remote_inner, _TEST_REMOTE_PORT), src[:2])
+    finally:
+      read_sock.close()
 
   def _CheckTunnelOutput(self, tunnel, inner_version, local_inner,
                          remote_inner, sa_info=None):
@@ -826,6 +833,8 @@ class XfrmTunnelBase(xfrm_base.XfrmBaseTest):
 
       # Check that the interface statistics recorded the inbound packet
       self.assertReceivedPacket(tunnel, tunnel.in_sa)
+
+      read_sock.close()
     finally:
       # Swap the interface addresses to pretend we are the remote
       self._SwapInterfaceAddress(