From 52224418a8db3e7963b987ca8535c8653807a4ff Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Maciej=20=C5=BBenczykowski?= Date: Fri, 24 Mar 2023 21:31:43 -0700 Subject: net-test: bpf_test - better close() hygiene MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This gets rid of a lot of spam presumably from newer python, stuff like: /usr/lib/python3.9/unittest/case.py:621: ResourceWarning: unclosed outcome.errors.clear() ResourceWarning: Enable tracemalloc to get the object allocation traceback Test: via UML on ACK 5.10-S Signed-off-by: Maciej Żenczykowski Change-Id: I2f6c1d83a55a234ecc38674a9d771418a97489da --- net/test/bpf_test.py | 57 +++++++++++++++++++++++++++++----------------------- 1 file changed, 32 insertions(+), 25 deletions(-) diff --git a/net/test/bpf_test.py b/net/test/bpf_test.py index d98c494..0678f1f 100755 --- a/net/test/bpf_test.py +++ b/net/test/bpf_test.py @@ -114,19 +114,23 @@ def PrintMapInfo(map_fd): def SocketUDPLoopBack(packet_count, version, prog_fd): family = {4: socket.AF_INET, 6: socket.AF_INET6}[version] sock = socket.socket(family, socket.SOCK_DGRAM, 0) - if prog_fd is not None: - BpfProgAttachSocket(sock.fileno(), prog_fd) - net_test.SetNonBlocking(sock) - addr = {4: "127.0.0.1", 6: "::1"}[version] - sock.bind((addr, 0)) - addr = sock.getsockname() - sockaddr = csocket.Sockaddr(addr) - for _ in range(packet_count): - sock.sendto(b"foo", addr) - data, retaddr = csocket.Recvfrom(sock, 4096, 0) - assert b"foo" == data - assert sockaddr == retaddr - return sock + try: + if prog_fd is not None: + BpfProgAttachSocket(sock.fileno(), prog_fd) + net_test.SetNonBlocking(sock) + addr = {4: "127.0.0.1", 6: "::1"}[version] + sock.bind((addr, 0)) + addr = sock.getsockname() + sockaddr = csocket.Sockaddr(addr) + for _ in range(packet_count): + sock.sendto(b"foo", addr) + data, retaddr = csocket.Recvfrom(sock, 4096, 0) + assert b"foo" == data + assert sockaddr == retaddr + return sock + except Exception as e: + sock.close() + raise e # The main code block for eBPF packet counting program. It takes a preloaded @@ -213,10 +217,13 @@ class BpfTest(net_test.NetworkTest): def tearDown(self): if self.prog_fd >= 0: os.close(self.prog_fd) + self.prog_fd = -1 if self.map_fd >= 0: os.close(self.map_fd) + self.map_fd = -1 if self.sock: self.sock.close() + self.sock = None super(BpfTest, self).tearDown() def testCreateMap(self): @@ -294,8 +301,8 @@ class BpfTest(net_test.NetworkTest): ] instructions += INS_SK_FILTER_ACCEPT self.prog_fd = BpfProgLoad(BPF_PROG_TYPE_SOCKET_FILTER, instructions) - SocketUDPLoopBack(1, 4, self.prog_fd) - SocketUDPLoopBack(1, 6, self.prog_fd) + SocketUDPLoopBack(1, 4, self.prog_fd).close() + SocketUDPLoopBack(1, 6, self.prog_fd).close() def testPacketBlock(self): self.prog_fd = BpfProgLoad(BPF_PROG_TYPE_SOCKET_FILTER, INS_BPF_EXIT_BLOCK) @@ -317,8 +324,8 @@ class BpfTest(net_test.NetworkTest): + INS_SK_FILTER_ACCEPT) self.prog_fd = BpfProgLoad(BPF_PROG_TYPE_SOCKET_FILTER, instructions) packet_count = 10 - SocketUDPLoopBack(packet_count, 4, self.prog_fd) - SocketUDPLoopBack(packet_count, 6, self.prog_fd) + SocketUDPLoopBack(packet_count, 4, self.prog_fd).close() + SocketUDPLoopBack(packet_count, 6, self.prog_fd).close() self.assertEqual(packet_count * 2, LookupMap(self.map_fd, key).value) ############################################################################## @@ -439,10 +446,10 @@ class BpfTest(net_test.NetworkTest): uid = TEST_UID with net_test.RunAsUid(uid): self.assertRaisesErrno(errno.ENOENT, LookupMap, self.map_fd, uid) - SocketUDPLoopBack(packet_count, 4, self.prog_fd) + SocketUDPLoopBack(packet_count, 4, self.prog_fd).close() self.assertEqual(packet_count, LookupMap(self.map_fd, uid).value) DeleteMap(self.map_fd, uid) - SocketUDPLoopBack(packet_count, 6, self.prog_fd) + SocketUDPLoopBack(packet_count, 6, self.prog_fd).close() self.assertEqual(packet_count, LookupMap(self.map_fd, uid).value) @@ -493,8 +500,8 @@ class BpfCgroupTest(net_test.NetworkTest): self.assertRaisesErrno(errno.EAGAIN, SocketUDPLoopBack, 1, 4, None) self.assertRaisesErrno(errno.EAGAIN, SocketUDPLoopBack, 1, 6, None) BpfProgDetach(self._cg_fd, BPF_CGROUP_INET_INGRESS) - SocketUDPLoopBack(1, 4, None) - SocketUDPLoopBack(1, 6, None) + SocketUDPLoopBack(1, 4, None).close() + SocketUDPLoopBack(1, 6, None).close() def testCgroupEgress(self): self.prog_fd = BpfProgLoad(BPF_PROG_TYPE_CGROUP_SKB, INS_BPF_EXIT_BLOCK) @@ -502,8 +509,8 @@ class BpfCgroupTest(net_test.NetworkTest): self.assertRaisesErrno(errno.EPERM, SocketUDPLoopBack, 1, 4, None) self.assertRaisesErrno(errno.EPERM, SocketUDPLoopBack, 1, 6, None) BpfProgDetach(self._cg_fd, BPF_CGROUP_INET_EGRESS) - SocketUDPLoopBack(1, 4, None) - SocketUDPLoopBack(1, 6, None) + SocketUDPLoopBack(1, 4, None).close() + SocketUDPLoopBack(1, 6, None).close() def testCgroupBpfUid(self): self.map_fd = CreateMap(BPF_MAP_TYPE_HASH, KEY_SIZE, VALUE_SIZE, @@ -522,10 +529,10 @@ class BpfCgroupTest(net_test.NetworkTest): uid = TEST_UID with net_test.RunAsUid(uid): self.assertRaisesErrno(errno.ENOENT, LookupMap, self.map_fd, uid) - SocketUDPLoopBack(packet_count, 4, None) + SocketUDPLoopBack(packet_count, 4, None).close() self.assertEqual(packet_count, LookupMap(self.map_fd, uid).value) DeleteMap(self.map_fd, uid) - SocketUDPLoopBack(packet_count, 6, None) + SocketUDPLoopBack(packet_count, 6, None).close() self.assertEqual(packet_count, LookupMap(self.map_fd, uid).value) BpfProgDetach(self._cg_fd, BPF_CGROUP_INET_INGRESS) -- cgit v1.2.3 From 8e4abd2a446a70c30bb4563a0f752df6f1801208 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Maciej=20=C5=BBenczykowski?= Date: Fri, 24 Mar 2023 19:40:22 +0000 Subject: net-test: add test for SO_NETNS_COOKIE MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Test: TreeHugger, manually ran net_test in uml Bug: 274789652 Signed-off-by: Maciej Żenczykowski Change-Id: Ic184be7b8b88eadd10f78ea93efcaf77ef6bc44d --- net/test/bpf.py | 10 ++++++++++ net/test/bpf_test.py | 38 +++++++++++++++++++++++++++++++++++++- 2 files changed, 47 insertions(+), 1 deletion(-) diff --git a/net/test/bpf.py b/net/test/bpf.py index 41f19eb..cef1a37 100755 --- a/net/test/bpf.py +++ b/net/test/bpf.py @@ -49,6 +49,16 @@ __NR_bpf = { # pylint: disable=invalid-name "riscv64-64bit": 280, }[os.uname()[4] + "-" + platform.architecture()[0]] +# After ACK merge of 5.10.168 is when support for this was backported from +# upstream Linux 5.14 and was merged into ACK android{12,13}-5.10 branches. +# ACK android12-5.10 was >= 5.10.168 without this support only for ~4.5 hours +# ACK android13-4.10 was >= 5.10.168 without this support only for ~25 hours +# as such we can >= 5.10.168 instead of > 5.10.168 +HAVE_SO_NETNS_COOKIE = net_test.LINUX_VERSION >= (5, 10, 168) + +# Note: This is *not* correct for parisc & sparc architectures +SO_NETNS_COOKIE = 71 + LOG_LEVEL = 1 LOG_SIZE = 65536 diff --git a/net/test/bpf_test.py b/net/test/bpf_test.py index 0678f1f..343ca97 100755 --- a/net/test/bpf_test.py +++ b/net/test/bpf_test.py @@ -79,7 +79,6 @@ from bpf import LookupMap from bpf import UpdateMap import csocket import net_test -from net_test import LINUX_VERSION import sock_diag libc = ctypes.CDLL(ctypes.util.find_library("c"), use_errno=True) @@ -407,6 +406,43 @@ class BpfTest(net_test.NetworkTest): b"Apache 2.0") # No exceptions? Good. + ############################################################################## + # + # Test for presence of upstream 5.14 kernel patches: + # + # Android12-5.10: + # UPSTREAM: net: initialize net->net_cookie at netns setup + # https://android-review.git.corp.google.com/c/kernel/common/+/2503195 + # + # UPSTREAM: net: retrieve netns cookie via getsocketopt + # https://android-review.git.corp.google.com/c/kernel/common/+/2503056 + # + # (and potentially if you care about kernel ABI) + # + # ANDROID: fix ABI by undoing atomic64_t -> u64 type conversion + # https://android-review.git.corp.google.com/c/kernel/common/+/2504335 + # + # Android13-5.10: + # UPSTREAM: net: initialize net->net_cookie at netns setup + # https://android-review.git.corp.google.com/c/kernel/common/+/2503795 + # + # UPSTREAM: net: retrieve netns cookie via getsocketopt + # https://android-review.git.corp.google.com/c/kernel/common/+/2503796 + # + # (and potentially if you care about kernel ABI) + # + # ANDROID: fix ABI by undoing atomic64_t -> u64 type conversion + # https://android-review.git.corp.google.com/c/kernel/common/+/2506895 + # + @unittest.skipUnless(bpf.HAVE_SO_NETNS_COOKIE, "no SO_NETNS_COOKIE support") + def testGetNetNsCookie(self): + sk = socket.socket(socket.AF_INET6, socket.SOCK_DGRAM, 0) + cookie = sk.getsockopt(socket.SOL_SOCKET, bpf.SO_NETNS_COOKIE, 8) # sizeof(u64) == 8 + sk.close() + self.assertEqual(len(cookie), 8) + cookie = int.from_bytes(cookie, "little") + self.assertGreaterEqual(cookie, 0) + def testGetSocketCookie(self): self.map_fd = CreateMap(BPF_MAP_TYPE_HASH, KEY_SIZE, VALUE_SIZE, TOTAL_ENTRIES) -- cgit v1.2.3 From acb7b4a1e1a3d86dcfc6dcf10aca4ddcc27eac96 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Maciej=20=C5=BBenczykowski?= Date: Fri, 24 Mar 2023 23:28:01 -0700 Subject: net-test: use sys.maxsize not platform.architecture()[0] MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit as recommended by: https://docs.python.org/3/library/platform.html#platform.architecture sys.maxsize is maximum value of Py_ssize_t, ie. 2**(sizeof(ssize_t)*8-1)-1 thus 32-bit: (2**31)-1 == 2147483647 == 0x7FFFFFFF 64-bit: (2**63)-1 == 9223372036854775807 == 0x7fffffffffffffff Test: on UML Signed-off-by: Maciej Żenczykowski Change-Id: Ib999a8a07e7f3e0054d8c94bd53c7a13d5c1ecb0 --- net/test/bpf.py | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) diff --git a/net/test/bpf.py b/net/test/bpf.py index cef1a37..b96c82a 100755 --- a/net/test/bpf.py +++ b/net/test/bpf.py @@ -18,9 +18,9 @@ import ctypes import os -import platform import resource import socket +import sys import csocket import cstruct @@ -32,10 +32,6 @@ import net_test # around this problem and pick the right syscall nr, we can additionally check # the bitness of the python interpreter. Assume that the 64-bit architectures # are not running with COMPAT_UTS_MACHINE and must be 64-bit at all times. -# -# Is there a better way of doing this? -# Is it correct to use os.uname()[4] instead of platform.machine() ? -# Should we use 'sys.maxsize > 2**32' instead of platform.architecture()[0] ? __NR_bpf = { # pylint: disable=invalid-name "aarch64-32bit": 386, "aarch64-64bit": 280, @@ -47,7 +43,7 @@ __NR_bpf = { # pylint: disable=invalid-name "x86_64-32bit": 357, "x86_64-64bit": 321, "riscv64-64bit": 280, -}[os.uname()[4] + "-" + platform.architecture()[0]] +}[os.uname()[4] + "-" + ("64" if sys.maxsize > 0x7FFFFFFF else "32") + "bit"] # After ACK merge of 5.10.168 is when support for this was backported from # upstream Linux 5.14 and was merged into ACK android{12,13}-5.10 branches. -- cgit v1.2.3 From 2e0364c6f75708afa1b5ea46044fbc2d965cc559 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Maciej=20=C5=BBenczykowski?= Date: Fri, 24 Mar 2023 23:43:06 -0700 Subject: net-test: close() fixes for neighbour_test.py MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Test: on UML Signed-off-by: Maciej Żenczykowski Change-Id: I0935796caf96fb9a71d1ec26ed41a5c70edadf3b --- net/test/neighbour_test.py | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/net/test/neighbour_test.py b/net/test/neighbour_test.py index ac15897..74b1156 100755 --- a/net/test/neighbour_test.py +++ b/net/test/neighbour_test.py @@ -116,6 +116,9 @@ class NeighbourTest(multinetwork_base.MultiNetworkBaseTest): # so as not to affect other tests. self.ChangeRouterNudState(4, NUD_PERMANENT) + self.sock.close() + self.sock = None + def ChangeRouterNudState(self, version, state): router = self._RouterAddress(self.netid, version) macaddr = self.RouterMacAddress(self.netid) @@ -268,6 +271,7 @@ class NeighbourTest(multinetwork_base.MultiNetworkBaseTest): # Send a packet, and verify we go into DELAY and then to PROBE. s.send(net_test.UDP_PAYLOAD) + s.close() self.assertNeighbourState(NUD_DELAY, router6) self.SleepMs(self.DELAY_TIME_MS * 1.1) self.assertNeighbourState(NUD_PROBE, router6) @@ -323,7 +327,7 @@ class NeighbourTest(multinetwork_base.MultiNetworkBaseTest): time.sleep(1) # Send another packet and expect a multicast NS. - self.SendDnsRequest(net_test.IPV6_ADDR) + self.SendDnsRequest(net_test.IPV6_ADDR).close() self.ExpectMulticastNS(router6) # Receive a unicast NA with the R flag set to 0. @@ -351,7 +355,7 @@ class NeighbourTest(multinetwork_base.MultiNetworkBaseTest): self.SetUnicastSolicit(proto, iface, self.UCAST_SOLICIT_LARGE) # Send a packet and check that we go into DELAY. - self.SendDnsRequest(ip_addr) + self.SendDnsRequest(ip_addr).close() self.assertNeighbourState(NUD_DELAY, router) # Probing 4 times but no reponse -- cgit v1.2.3 From 991b01da474f055492b3277f97dc7576111deb45 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Maciej=20=C5=BBenczykowski?= Date: Fri, 24 Mar 2023 23:50:43 -0700 Subject: net-test: close() fixes for anycast_test.py MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Test: on UML Signed-off-by: Maciej Żenczykowski Change-Id: Ib2170c3859f98dcf926bd13b82bf51a5e83b9e70 --- net/test/anycast_test.py | 1 + 1 file changed, 1 insertion(+) diff --git a/net/test/anycast_test.py b/net/test/anycast_test.py index eeb581c..a63f661 100755 --- a/net/test/anycast_test.py +++ b/net/test/anycast_test.py @@ -112,6 +112,7 @@ class AnycastTest(multinetwork_base.MultiNetworkBaseTest): # This doesn't seem to help, but still. self.AnycastSetsockopt(s, False, netid, addr) self.assertTrue(thread.finished) + s.close() if __name__ == "__main__": -- cgit v1.2.3 From b5a33dc95660836a4dcc133c2ee152dd6b0646a8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Maciej=20=C5=BBenczykowski?= Date: Fri, 24 Mar 2023 23:56:15 -0700 Subject: net-test: close() fixes for leak_test.py MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Test: on UML Signed-off-by: Maciej Żenczykowski Change-Id: I5d8220b62807444863055411db7959d91d2e6e91 --- net/test/leak_test.py | 1 + 1 file changed, 1 insertion(+) diff --git a/net/test/leak_test.py b/net/test/leak_test.py index 0e72c21..54bbe73 100755 --- a/net/test/leak_test.py +++ b/net/test/leak_test.py @@ -72,6 +72,7 @@ class ForceSocketBufferOptionTest(net_test.NetworkTest): bogusval = 2 ** 31 - val s.setsockopt(SOL_SOCKET, force_option, bogusval) self.assertLessEqual(minbuf, s.getsockopt(SOL_SOCKET, option)) + s.close() def testRcvBufForce(self): self.CheckForceSocketBufferOption(SO_RCVBUF, self.SO_RCVBUFFORCE) -- cgit v1.2.3 From da786190dd211c92c42c056e295e3fc8751f1b10 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Maciej=20=C5=BBenczykowski?= Date: Fri, 24 Mar 2023 23:58:58 -0700 Subject: net-test: close() fixes for multinetwork_test.py MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Test: on UML Signed-off-by: Maciej Żenczykowski Change-Id: Ia2327d8f931fa98cba7ed169f9beba0f66618310 --- net/test/multinetwork_test.py | 17 ++++++++++++++++- net/test/netlink.py | 5 +++++ 2 files changed, 21 insertions(+), 1 deletion(-) diff --git a/net/test/multinetwork_test.py b/net/test/multinetwork_test.py index 3a7682e..051b7d1 100755 --- a/net/test/multinetwork_test.py +++ b/net/test/multinetwork_test.py @@ -65,6 +65,7 @@ class OutgoingTest(multinetwork_base.MultiNetworkBaseTest): s.sendto(packet + packets.PING_PAYLOAD, (dstsockaddr, 19321)) self.ExpectPacketOn(netid, msg, expected) + s.close() def CheckTCPSYNPacket(self, version, netid, routing_mode): s = self.BuildSocket(version, net_test.TCPSocket, netid, routing_mode) @@ -102,7 +103,8 @@ class OutgoingTest(multinetwork_base.MultiNetworkBaseTest): s.connect((dstsockaddr, 53)) s.send(UDP_PAYLOAD) self.ExpectPacketOn(netid, msg % "connect/send", expected) - s.close() + + s.close() def CheckRawGrePacket(self, version, netid, routing_mode): s = self.BuildSocket(version, net_test.RawGRESocket, netid, routing_mode) @@ -123,6 +125,7 @@ class OutgoingTest(multinetwork_base.MultiNetworkBaseTest): msg = "Raw IPv%d GRE with inner IPv%d UDP: expected %s on %s" % ( version, inner_version, desc, self.GetInterfaceName(netid)) self.ExpectPacketOn(netid, msg, expected) + s.close() def CheckOutgoingPackets(self, routing_mode): for _ in range(self.ITERATIONS): @@ -249,6 +252,8 @@ class OutgoingTest(multinetwork_base.MultiNetworkBaseTest): self.SelectInterface(s, None, mode) prevnetid = netid + s.close() + def testIPv4Remarking(self): """Checks that updating the mark on an IPv4 socket changes routing.""" self.CheckRemarking(4, False) @@ -300,6 +305,7 @@ class OutgoingTest(multinetwork_base.MultiNetworkBaseTest): msg = "IPv6 UDP using sticky pktinfo: expected UDP packet on %s" % ( self.GetInterfaceName(netid)) self.ExpectPacketOn(netid, msg, expected) + s.close() def CheckPktinfoRouting(self, version): for _ in range(self.ITERATIONS): @@ -340,6 +346,8 @@ class OutgoingTest(multinetwork_base.MultiNetworkBaseTest): version, desc, self.GetInterfaceName(netid)) self.ExpectPacketOn(netid, msg, expected) + s.close() + def testIPv4PktinfoRouting(self): self.CheckPktinfoRouting(4) @@ -801,6 +809,7 @@ class RATest(multinetwork_base.MultiNetworkBaseTest): else: self.assertRaisesErrno(errno.ENETUNREACH, s.sendto, UDP_PAYLOAD, (net_test.IPV6_ADDR, 1234)) + s.close() try: CheckIPv6Connectivity(True) @@ -850,6 +859,8 @@ class RATest(multinetwork_base.MultiNetworkBaseTest): msg = "After NA response, expecting %s" % desc self.ExpectPacketOn(netid, msg, expected) + s.close() + # This test documents a known issue: routing tables are never deleted. @unittest.skipUnless(multinetwork_base.HAVE_AUTOCONF_TABLE, "no support for per-table autoconf") @@ -896,6 +907,7 @@ class RATest(multinetwork_base.MultiNetworkBaseTest): self.fail("Should have received an RTM_NEWNDUSEROPT message. " "Please ensure the kernel supports receiving the " "PREF64 RA option. Error: %s" % e) + s.close() # Check that the message is received correctly. nlmsghdr, data = cstruct.Read(data, netlink.NLMsgHdr) @@ -1005,6 +1017,8 @@ class PMTUTest(multinetwork_base.InboundMarkingTest): metrics = attributes["RTA_METRICS"] self.assertEqual(packets.PTB_MTU, metrics["RTAX_MTU"]) + s2.close() + def testIPv4BasicPMTU(self): """Tests IPv4 path MTU discovery. @@ -1256,6 +1270,7 @@ class UidRoutingTest(multinetwork_base.MultiNetworkBaseTest): CheckSendFails() finally: self.iproute.UidRangeRule(6, False, uid, uid, table, self.PRIORITY_UID) + s.close() class RulesTest(net_test.NetworkTest): diff --git a/net/test/netlink.py b/net/test/netlink.py index 190667c..b5efe11 100644 --- a/net/test/netlink.py +++ b/net/test/netlink.py @@ -183,6 +183,11 @@ class NetlinkSocket(object): def close(self): self.sock.close() + self.sock = None + + def __del__(self): + if self.sock: + self.close() def MaybeDebugCommand(self, command, flags, data): # Default no-op implementation to be overridden by subclasses. -- cgit v1.2.3 From a334b72ca33bca98ab11859730d976deb15c1dc8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Maciej=20=C5=BBenczykowski?= Date: Sat, 25 Mar 2023 00:45:42 -0700 Subject: net-test: close() fixes for nf_test.py MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Test: on UML Signed-off-by: Maciej Żenczykowski Change-Id: I64f6bd23271cf30320c61daec313b6848aa26cdd --- net/test/nf_test.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/net/test/nf_test.py b/net/test/nf_test.py index 8cc283f..2583c9a 100755 --- a/net/test/nf_test.py +++ b/net/test/nf_test.py @@ -55,6 +55,7 @@ class NetilterRejectTargetTest(multinetwork_base.MultiNetworkBaseTest): sock.connect((addr, 53)) except IOError: pass + sock.close() def testRejectTcp4(self): self.CheckRejectedTcp(4, _TEST_IP4_ADDR) @@ -74,6 +75,7 @@ class NetilterRejectTargetTest(multinetwork_base.MultiNetworkBaseTest): sock.sendto(net_test.UDP_PAYLOAD, (addr, 53)) except IOError: pass + sock.close() def testRejectUdp4(self): self.CheckRejectedUdp(4, _TEST_IP4_ADDR) -- cgit v1.2.3 From 5c9d3400b6760386e50dbbe4bea6a18b14a6589e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Maciej=20=C5=BBenczykowski?= Date: Sat, 25 Mar 2023 00:48:18 -0700 Subject: net-test: close() fixes for pf_key_test.py MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Test: on UML Signed-off-by: Maciej Żenczykowski Change-Id: I5130aff5105a22eb0ca62380782b2cf16684437f --- net/test/pf_key.py | 7 +++++++ net/test/pf_key_test.py | 4 ++++ 2 files changed, 11 insertions(+) diff --git a/net/test/pf_key.py b/net/test/pf_key.py index cc8e76c..ca6689e 100755 --- a/net/test/pf_key.py +++ b/net/test/pf_key.py @@ -200,6 +200,13 @@ class PfKey(object): net_test.SetNonBlocking(self.sock) self.seq = 0 + def close(self): + self.sock.close() + self.sock = None + + def __del__(self): + if self.sock: self.close() + def Recv(self): reply = self.sock.recv(4096) msg = SadbMsg(reply) diff --git a/net/test/pf_key_test.py b/net/test/pf_key_test.py index 77cf82c..7791bd1 100755 --- a/net/test/pf_key_test.py +++ b/net/test/pf_key_test.py @@ -34,6 +34,10 @@ class PfKeyTest(unittest.TestCase): self.pf_key = pf_key.PfKey() self.xfrm = xfrm.Xfrm() + def tearDown(self): + self.pf_key.close() + self.pf_key = None + def testAddDelSa(self): src4 = csocket.Sockaddr(("192.0.2.1", 0)) dst4 = csocket.Sockaddr(("192.0.2.2", 1)) -- cgit v1.2.3 From 0cee06032460e9921230479238c2db73a8fb3bd9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Maciej=20=C5=BBenczykowski?= Date: Sat, 25 Mar 2023 00:50:50 -0700 Subject: net-test: close() fixes for ping6_test.py MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Test: on UML Signed-off-by: Maciej Żenczykowski Change-Id: I29882cbb0bdfd6355c6ba5db61123c7274f4202a --- net/test/ping6_test.py | 53 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 53 insertions(+) diff --git a/net/test/ping6_test.py b/net/test/ping6_test.py index 7cb75cc..af2e4c5 100755 --- a/net/test/ping6_test.py +++ b/net/test/ping6_test.py @@ -336,10 +336,12 @@ class Ping6Test(multinetwork_base.MultiNetworkBaseTest): def testIPv4SendWithNoConnection(self): s = net_test.IPv4PingSocket() self.assertRaisesErrno(errno.EDESTADDRREQ, s.send, net_test.IPV4_PING) + s.close() def testIPv6SendWithNoConnection(self): s = net_test.IPv6PingSocket() self.assertRaisesErrno(errno.EDESTADDRREQ, s.send, net_test.IPV6_PING) + s.close() def testIPv4LoopbackPingWithConnect(self): s = net_test.IPv4PingSocket() @@ -347,24 +349,28 @@ class Ping6Test(multinetwork_base.MultiNetworkBaseTest): data = net_test.IPV4_PING + b"foobarbaz" s.send(data) self.assertValidPingResponse(s, data) + s.close() def testIPv6LoopbackPingWithConnect(self): s = net_test.IPv6PingSocket() s.connect(("::1", 55)) s.send(net_test.IPV6_PING) self.assertValidPingResponse(s, net_test.IPV6_PING) + s.close() def testIPv4PingUsingSendto(self): s = net_test.IPv4PingSocket() written = s.sendto(net_test.IPV4_PING, (net_test.IPV4_ADDR, 55)) self.assertEqual(len(net_test.IPV4_PING), written) self.assertValidPingResponse(s, net_test.IPV4_PING) + s.close() def testIPv6PingUsingSendto(self): s = net_test.IPv6PingSocket() written = s.sendto(net_test.IPV6_PING, (net_test.IPV6_ADDR, 55)) self.assertEqual(len(net_test.IPV6_PING), written) self.assertValidPingResponse(s, net_test.IPV6_PING) + s.close() def testIPv4NoCrash(self): # Python 2.x does not provide either read() or recvmsg. @@ -374,6 +380,7 @@ class Ping6Test(multinetwork_base.MultiNetworkBaseTest): fd = s.fileno() reply = posix.read(fd, 4096) self.assertEqual(written, len(reply)) + s.close() def testIPv6NoCrash(self): # Python 2.x does not provide either read() or recvmsg. @@ -383,6 +390,7 @@ class Ping6Test(multinetwork_base.MultiNetworkBaseTest): fd = s.fileno() reply = posix.read(fd, 4096) self.assertEqual(written, len(reply)) + s.close() def testCrossProtocolCrash(self): # Checks that an ICMP error containing a ping packet that matches the ID @@ -411,6 +419,7 @@ class Ping6Test(multinetwork_base.MultiNetworkBaseTest): _, port = s.getsockname() scapy.send(GetIPv6Unreachable(port), verbose=False) # No crash? Good. + s.close() def testCrossProtocolCalls(self): """Tests that passing in the wrong family returns EAFNOSUPPORT. @@ -454,12 +463,15 @@ class Ping6Test(multinetwork_base.MultiNetworkBaseTest): s4, ipv6sockaddr, net_test.IPV4_PING, None, 0) CheckEAFNoSupport(csocket.Sendmsg, s6, ipv4sockaddr, net_test.IPV6_PING, None, 0) + s4.close() + s6.close() def testIPv4Bind(self): # Bind to unspecified address. s = net_test.IPv4PingSocket() s.bind(("0.0.0.0", 544)) self.assertEqual(("0.0.0.0", 544), s.getsockname()) + s.close() # Bind to loopback. s = net_test.IPv4PingSocket() @@ -468,6 +480,7 @@ class Ping6Test(multinetwork_base.MultiNetworkBaseTest): # Binding twice is not allowed. self.assertRaisesErrno(errno.EINVAL, s.bind, ("127.0.0.1", 22)) + s.close() # But binding two different sockets to the same ID is allowed. s2 = net_test.IPv4PingSocket() @@ -476,6 +489,8 @@ class Ping6Test(multinetwork_base.MultiNetworkBaseTest): s3 = net_test.IPv4PingSocket() s3.bind(("127.0.0.1", 99)) self.assertEqual(("127.0.0.1", 99), s3.getsockname()) + s2.close() + s3.close() # If two sockets bind to the same port, the first one to call read() gets # the response. @@ -493,16 +508,22 @@ class Ping6Test(multinetwork_base.MultiNetworkBaseTest): s4.setsockopt(SOL_SOCKET, SO_REUSEADDR, 0) self.assertRaisesErrno(errno.EADDRINUSE, s6.bind, ("0.0.0.0", 167)) + s4.close() + s5.close() + s6.close() + # Can't bind after sendto. s = net_test.IPv4PingSocket() s.sendto(net_test.IPV4_PING, (net_test.IPV4_ADDR, 9132)) self.assertRaisesErrno(errno.EINVAL, s.bind, ("0.0.0.0", 5429)) + s.close() def testIPv6Bind(self): # Bind to unspecified address. s = net_test.IPv6PingSocket() s.bind(("::", 769)) self.assertEqual(("::", 769, 0, 0), s.getsockname()) + s.close() # Bind to loopback. s = net_test.IPv6PingSocket() @@ -511,6 +532,7 @@ class Ping6Test(multinetwork_base.MultiNetworkBaseTest): # Binding twice is not allowed. self.assertRaisesErrno(errno.EINVAL, s.bind, ("::1", 22)) + s.close() # But binding two different sockets to the same ID is allowed. s2 = net_test.IPv6PingSocket() @@ -519,17 +541,22 @@ class Ping6Test(multinetwork_base.MultiNetworkBaseTest): s3 = net_test.IPv6PingSocket() s3.bind(("::1", 99)) self.assertEqual(("::1", 99, 0, 0), s3.getsockname()) + s2.close() + s3.close() # Binding both IPv4 and IPv6 to the same socket works. s4 = net_test.IPv4PingSocket() s6 = net_test.IPv6PingSocket() s4.bind(("0.0.0.0", 444)) s6.bind(("::", 666, 0, 0)) + s4.close() + s6.close() # Can't bind after sendto. s = net_test.IPv6PingSocket() s.sendto(net_test.IPV6_PING, (net_test.IPV6_ADDR, 9132)) self.assertRaisesErrno(errno.EINVAL, s.bind, ("::", 5429)) + s.close() def testIPv4InvalidBind(self): s = net_test.IPv4PingSocket() @@ -546,6 +573,7 @@ class Ping6Test(multinetwork_base.MultiNetworkBaseTest): except IOError as e: if e.errno == errno.EACCES: pass # We're not root. let it go for now. + s.close() def testIPv6InvalidBind(self): s = net_test.IPv6PingSocket() @@ -561,6 +589,7 @@ class Ping6Test(multinetwork_base.MultiNetworkBaseTest): except IOError as e: if e.errno == errno.EACCES: pass # We're not root. let it go for now. + s.close() def testAfUnspecBind(self): # Binding to AF_UNSPEC is treated as IPv4 if the address is 0.0.0.0. @@ -574,12 +603,14 @@ class Ping6Test(multinetwork_base.MultiNetworkBaseTest): sockaddr = csocket.Sockaddr(("127.0.0.1", 58234)) sockaddr.family = AF_UNSPEC self.assertRaisesErrno(errno.EAFNOSUPPORT, csocket.Bind, s4, sockaddr) + s4.close() # This doesn't work for IPv6. s6 = net_test.IPv6PingSocket() sockaddr = csocket.Sockaddr(("::1", 58997)) sockaddr.family = AF_UNSPEC self.assertRaisesErrno(errno.EAFNOSUPPORT, csocket.Bind, s6, sockaddr) + s6.close() def testIPv6ScopedBind(self): # Can't bind to a link-local address without a scope ID. @@ -602,22 +633,26 @@ class Ping6Test(multinetwork_base.MultiNetworkBaseTest): # on the machine. self.assertRaisesErrno(errno.EADDRNOTAVAIL, s.bind, ("fe80::f00", 1026, 0, 1)) + s.close() # Scope IDs on non-link-local addresses are silently ignored. s = net_test.IPv6PingSocket() s.bind(("::1", 1234, 0, 1)) self.assertEqual(("::1", 1234, 0, 0), s.getsockname()) + s.close() def testBindAffectsIdentifier(self): s = net_test.IPv6PingSocket() s.bind((self.globaladdr, 0xf976)) s.sendto(net_test.IPV6_PING, (net_test.IPV6_ADDR, 55)) self.assertEqual(b"\xf9\x76", s.recv(32768)[4:6]) + s.close() s = net_test.IPv6PingSocket() s.bind((self.globaladdr, 0xace)) s.sendto(net_test.IPV6_PING, (net_test.IPV6_ADDR, 55)) self.assertEqual(b"\x0a\xce", s.recv(32768)[4:6]) + s.close() def testLinkLocalAddress(self): s = net_test.IPv6PingSocket() @@ -628,6 +663,7 @@ class Ping6Test(multinetwork_base.MultiNetworkBaseTest): # doesn't understand the "fe80::1%lo" format, even though it returns it. s.sendto(net_test.IPV6_PING, ("fe80::1", 55, 0, self.ifindex)) # No exceptions? Good. + s.close() def testLinkLocalOif(self): """Checks that ping to link-local addresses works correctly. @@ -673,6 +709,8 @@ class Ping6Test(multinetwork_base.MultiNetworkBaseTest): s2.connect((dst, 123, 0, scopeid)) s2.send(net_test.IPV6_PING) self.assertValidPingResponse(s2, net_test.IPV6_PING) + s2.close() + s.close() def testMappedAddressFails(self): s = net_test.IPv6PingSocket() @@ -682,6 +720,7 @@ class Ping6Test(multinetwork_base.MultiNetworkBaseTest): self.assertValidPingResponse(s, net_test.IPV6_PING) self.assertRaisesErrno(errno.EINVAL, s.sendto, net_test.IPV6_PING, ("::ffff:192.0.2.1", 55)) + s.close() @unittest.skipUnless(False, "skipping: does not work yet") def testFlowLabel(self): @@ -709,6 +748,7 @@ class Ping6Test(multinetwork_base.MultiNetworkBaseTest): _, src = s.recvfrom(32768) _, _, flowlabel, _ = src self.assertEqual(0xdead, flowlabel & 0xfffff) + s.close() def testIPv4Error(self): s = net_test.IPv4PingSocket() @@ -718,6 +758,7 @@ class Ping6Test(multinetwork_base.MultiNetworkBaseTest): # We can't check the actual error because Python 2.7 doesn't implement # recvmsg, but we can at least check that the socket returns an error. self.assertRaisesErrno(errno.EHOSTUNREACH, s.recv, 32768) # No response. + s.close() def testIPv6Error(self): s = net_test.IPv6PingSocket() @@ -727,6 +768,7 @@ class Ping6Test(multinetwork_base.MultiNetworkBaseTest): # We can't check the actual error because Python 2.7 doesn't implement # recvmsg, but we can at least check that the socket returns an error. self.assertRaisesErrno(errno.EHOSTUNREACH, s.recv, 32768) # No response. + s.close() def testIPv6MulticastPing(self): s = net_test.IPv6PingSocket() @@ -736,18 +778,21 @@ class Ping6Test(multinetwork_base.MultiNetworkBaseTest): s.sendto(net_test.IPV6_PING, ("ff02::1", 55, 0, self.ifindex)) self.assertValidPingResponse(s, net_test.IPV6_PING) self.assertValidPingResponse(s, net_test.IPV6_PING) + s.close() def testIPv4LargePacket(self): s = net_test.IPv4PingSocket() data = net_test.IPV4_PING + 20000 * b"a" s.sendto(data, ("127.0.0.1", 987)) self.assertValidPingResponse(s, data) + s.close() def testIPv6LargePacket(self): s = net_test.IPv6PingSocket() s.bind(("::", 0xace)) data = net_test.IPV6_PING + b"\x01" + 19994 * b"\x00" + b"aaaaa" s.sendto(data, ("::1", 953)) + s.close() def testIcmpSocketsNotInIcmp6(self): numrows = len(self.ReadProcNetSocket("icmp")) @@ -757,6 +802,7 @@ class Ping6Test(multinetwork_base.MultiNetworkBaseTest): s.connect(("127.0.0.1", 0xbeef)) self.assertEqual(numrows + 1, len(self.ReadProcNetSocket("icmp"))) self.assertEqual(numrows6, len(self.ReadProcNetSocket("icmp6"))) + s.close() def testIcmp6SocketsNotInIcmp(self): numrows = len(self.ReadProcNetSocket("icmp")) @@ -766,12 +812,14 @@ class Ping6Test(multinetwork_base.MultiNetworkBaseTest): s.connect(("::1", 0xbeef)) self.assertEqual(numrows, len(self.ReadProcNetSocket("icmp"))) self.assertEqual(numrows6 + 1, len(self.ReadProcNetSocket("icmp6"))) + s.close() def testProcNetIcmp(self): s = net_test.Socket(AF_INET, SOCK_DGRAM, IPPROTO_ICMP) s.bind(("127.0.0.1", 0xace)) s.connect(("127.0.0.1", 0xbeef)) self.CheckSockStatFile("icmp", "127.0.0.1", 0xace, "127.0.0.1", 0xbeef, 1) + s.close() def testProcNetIcmp6(self): numrows6 = len(self.ReadProcNetSocket("icmp6")) @@ -789,6 +837,7 @@ class Ping6Test(multinetwork_base.MultiNetworkBaseTest): self.assertEqual(0, len(self.ReadProcNetSocket("icmp6"))) s.sendto(net_test.IPV6_PING, (net_test.IPV6_ADDR, 12345)) self.assertEqual(1, len(self.ReadProcNetSocket("icmp6"))) + s.close() # Can't bind after sendto, apparently. s = net_test.IPv6PingSocket() @@ -807,18 +856,21 @@ class Ping6Test(multinetwork_base.MultiNetworkBaseTest): self.assertValidPingResponse(s, net_test.IPV6_PING) self.CheckSockStatFile("icmp6", self.lladdr, 0xd00d, "ff02::1", 0xdead, 1, txmem=0, rxmem=0) + s.close() def testProcNetUdp6(self): s = net_test.Socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP) s.bind(("::1", 0xace)) s.connect(("::1", 0xbeef)) self.CheckSockStatFile("udp6", "::1", 0xace, "::1", 0xbeef, 1) + s.close() def testProcNetRaw6(self): s = net_test.Socket(AF_INET6, SOCK_RAW, IPPROTO_RAW) s.bind(("::1", 0xace)) s.connect(("::1", 0xbeef)) self.CheckSockStatFile("raw6", "::1", 0xff, "::1", 0, 1) + s.close() def testIPv6MTU(self): """Tests IPV6_RECVERR and path MTU discovery on ping sockets. @@ -859,6 +911,7 @@ class Ping6Test(multinetwork_base.MultiNetworkBaseTest): ] self.assertEqual(msglist, cmsg) + s.close() if __name__ == "__main__": -- cgit v1.2.3 From c90a1c1b226b975cc31e709fa96fc1c6ecdbe272 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Maciej=20=C5=BBenczykowski?= Date: Sat, 25 Mar 2023 02:07:01 -0700 Subject: net-test: close() fixes for resilient_rs_test.py MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Test: on UML Signed-off-by: Maciej Żenczykowski Change-Id: I74d10acf1f8f651c89aea5edca7f1ffce4f57aa1 --- net/test/resilient_rs_test.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/net/test/resilient_rs_test.py b/net/test/resilient_rs_test.py index f6e022b..f53217d 100755 --- a/net/test/resilient_rs_test.py +++ b/net/test/resilient_rs_test.py @@ -171,5 +171,7 @@ class ResilientRouterSolicitationTest(multinetwork_base.MultiNetworkBaseTest): self.assertLess(min_exp, t) self.assertGreater(max_exp, t) + tun.close() + if __name__ == "__main__": unittest.main() -- cgit v1.2.3