1 #!/usr/bin/python 2 # 3 # Copyright 2015 The Android Open Source Project 4 # 5 # Licensed under the Apache License, Version 2.0 (the "License"); 6 # you may not use this file except in compliance with the License. 7 # You may obtain a copy of the License at 8 # 9 # http://www.apache.org/licenses/LICENSE-2.0 10 # 11 # Unless required by applicable law or agreed to in writing, software 12 # distributed under the License is distributed on an "AS IS" BASIS, 13 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 # See the License for the specific language governing permissions and 15 # limitations under the License. 16 17 import contextlib 18 import errno 19 import fcntl 20 import resource 21 import os 22 from socket import * # pylint: disable=wildcard-import 23 import struct 24 import threading 25 import time 26 import unittest 27 28 import csocket 29 import cstruct 30 import net_test 31 32 IPV4_LOOPBACK_ADDR = "127.0.0.1" 33 IPV6_LOOPBACK_ADDR = "::1" 34 LOOPBACK_DEV = "lo" 35 LOOPBACK_IFINDEX = 1 36 37 SIOCKILLADDR = 0x8939 38 39 DEFAULT_TCP_PORT = 8001 40 DEFAULT_BUFFER_SIZE = 20 41 DEFAULT_TEST_MESSAGE = "TCP NUKE ADDR TEST" 42 DEFAULT_TEST_RUNS = 100 43 HASH_TEST_RUNS = 4000 44 HASH_TEST_NOFILE = 16384 45 46 47 Ifreq = cstruct.Struct("Ifreq", "=16s16s", "name data") 48 In6Ifreq = cstruct.Struct("In6Ifreq", "=16sIi", "addr prefixlen ifindex") 49 50 @contextlib.contextmanager 51 def RunInBackground(thread): 52 """Starts a thread and waits until it joins. 53 54 Args: 55 thread: A not yet started threading.Thread object. 56 """ 57 try: 58 thread.start() 59 yield thread 60 finally: 61 thread.join() 62 63 64 def TcpAcceptAndReceive(listening_sock, buffer_size=DEFAULT_BUFFER_SIZE): 65 """Accepts a single connection and blocks receiving data from it. 66 67 Args: 68 listening_socket: A socket in LISTEN state. 69 buffer_size: Size of buffer where to read a message. 70 """ 71 connection, _ = listening_sock.accept() 72 with contextlib.closing(connection): 73 _ = connection.recv(buffer_size) 74 75 76 def ExchangeMessage(addr_family, ip_addr): 77 """Creates a listening socket, accepts a connection and sends data to it. 78 79 Args: 80 addr_family: The address family (e.g. AF_INET6). 81 ip_addr: The IP address (IPv4 or IPv6 depending on the addr_family). 82 tcp_port: The TCP port to listen on. 83 """ 84 # Bind to a random port and connect to it. 85 test_addr = (ip_addr, 0) 86 with contextlib.closing( 87 socket(addr_family, SOCK_STREAM)) as listening_socket: 88 listening_socket.bind(test_addr) 89 test_addr = listening_socket.getsockname() 90 listening_socket.listen(1) 91 with RunInBackground(threading.Thread(target=TcpAcceptAndReceive, 92 args=(listening_socket,))): 93 with contextlib.closing( 94 socket(addr_family, SOCK_STREAM)) as client_socket: 95 client_socket.connect(test_addr) 96 client_socket.send(DEFAULT_TEST_MESSAGE) 97 98 99 def KillAddrIoctl(addr): 100 """Calls the SIOCKILLADDR ioctl on the provided IP address. 101 102 Args: 103 addr The IP address to pass to the ioctl. 104 105 Raises: 106 ValueError: If addr is of an unsupported address family. 107 """ 108 family, _, _, _, _ = getaddrinfo(addr, None, AF_UNSPEC, SOCK_DGRAM, 0, 109 AI_NUMERICHOST)[0] 110 if family == AF_INET6: 111 addr = inet_pton(AF_INET6, addr) 112 ifreq = In6Ifreq((addr, 128, LOOPBACK_IFINDEX)).Pack() 113 elif family == AF_INET: 114 addr = inet_pton(AF_INET, addr) 115 sockaddr = csocket.SockaddrIn((AF_INET, 0, addr)).Pack() 116 ifreq = Ifreq((LOOPBACK_DEV, sockaddr)).Pack() 117 else: 118 raise ValueError('Address family %r not supported.' % family) 119 datagram_socket = socket(family, SOCK_DGRAM) 120 fcntl.ioctl(datagram_socket.fileno(), SIOCKILLADDR, ifreq) 121 datagram_socket.close() 122 123 124 class ExceptionalReadThread(threading.Thread): 125 126 def __init__(self, sock): 127 self.sock = sock 128 self.exception = None 129 super(ExceptionalReadThread, self).__init__() 130 self.daemon = True 131 132 def run(self): 133 try: 134 read = self.sock.recv(4096) 135 except Exception, e: 136 self.exception = e 137 138 # For convenience. 139 def CreateIPv4SocketPair(): 140 return net_test.CreateSocketPair(AF_INET, SOCK_STREAM, IPV4_LOOPBACK_ADDR) 141 142 def CreateIPv6SocketPair(): 143 return net_test.CreateSocketPair(AF_INET6, SOCK_STREAM, IPV6_LOOPBACK_ADDR) 144 145 146 class TcpNukeAddrTest(net_test.NetworkTest): 147 148 def testTimewaitSockets(self): 149 """Tests that SIOCKILLADDR works as expected. 150 151 Relevant kernel commits: 152 https://www.codeaurora.org/cgit/quic/la/kernel/msm-3.18/commit/net/ipv4/tcp.c?h=aosp/android-3.10&id=1dcd3a1fa2fe78251cc91700eb1d384ab02e2dd6 153 """ 154 for i in xrange(DEFAULT_TEST_RUNS): 155 ExchangeMessage(AF_INET6, IPV6_LOOPBACK_ADDR) 156 KillAddrIoctl(IPV6_LOOPBACK_ADDR) 157 ExchangeMessage(AF_INET, IPV4_LOOPBACK_ADDR) 158 KillAddrIoctl(IPV4_LOOPBACK_ADDR) 159 # Test passes if kernel does not crash. 160 161 def testClosesIPv6Sockets(self): 162 """Tests that SIOCKILLADDR closes IPv6 sockets and unblocks threads.""" 163 164 threadpairs = [] 165 166 for i in xrange(DEFAULT_TEST_RUNS): 167 clientsock, acceptedsock = CreateIPv6SocketPair() 168 clientthread = ExceptionalReadThread(clientsock) 169 clientthread.start() 170 serverthread = ExceptionalReadThread(acceptedsock) 171 serverthread.start() 172 threadpairs.append((clientthread, serverthread)) 173 174 KillAddrIoctl(IPV6_LOOPBACK_ADDR) 175 176 def CheckThreadException(thread): 177 thread.join(100) 178 self.assertFalse(thread.is_alive()) 179 self.assertIsNotNone(thread.exception) 180 self.assertTrue(isinstance(thread.exception, IOError)) 181 self.assertEquals(errno.ETIMEDOUT, thread.exception.errno) 182 self.assertRaisesErrno(errno.ENOTCONN, thread.sock.getpeername) 183 self.assertRaisesErrno(errno.EISCONN, thread.sock.connect, 184 (IPV6_LOOPBACK_ADDR, 53)) 185 self.assertRaisesErrno(errno.EPIPE, thread.sock.send, "foo") 186 187 for clientthread, serverthread in threadpairs: 188 CheckThreadException(clientthread) 189 CheckThreadException(serverthread) 190 191 def assertSocketsClosed(self, socketpair): 192 for sock in socketpair: 193 self.assertRaisesErrno(errno.ENOTCONN, sock.getpeername) 194 195 def assertSocketsNotClosed(self, socketpair): 196 for sock in socketpair: 197 self.assertTrue(sock.getpeername()) 198 199 def testAddresses(self): 200 socketpair = CreateIPv4SocketPair() 201 KillAddrIoctl("::") 202 self.assertSocketsNotClosed(socketpair) 203 KillAddrIoctl("::1") 204 self.assertSocketsNotClosed(socketpair) 205 KillAddrIoctl("127.0.0.3") 206 self.assertSocketsNotClosed(socketpair) 207 KillAddrIoctl("0.0.0.0") 208 self.assertSocketsNotClosed(socketpair) 209 KillAddrIoctl("127.0.0.1") 210 self.assertSocketsClosed(socketpair) 211 212 socketpair = CreateIPv6SocketPair() 213 KillAddrIoctl("0.0.0.0") 214 self.assertSocketsNotClosed(socketpair) 215 KillAddrIoctl("127.0.0.1") 216 self.assertSocketsNotClosed(socketpair) 217 KillAddrIoctl("::2") 218 self.assertSocketsNotClosed(socketpair) 219 KillAddrIoctl("::") 220 self.assertSocketsNotClosed(socketpair) 221 KillAddrIoctl("::1") 222 self.assertSocketsClosed(socketpair) 223 224 225 class TcpNukeAddrHashTest(net_test.NetworkTest): 226 227 def setUp(self): 228 self.nofile = resource.getrlimit(resource.RLIMIT_NOFILE) 229 resource.setrlimit(resource.RLIMIT_NOFILE, (HASH_TEST_NOFILE, 230 HASH_TEST_NOFILE)) 231 232 def tearDown(self): 233 resource.setrlimit(resource.RLIMIT_NOFILE, self.nofile) 234 235 def testClosesAllSockets(self): 236 socketpairs = [] 237 for i in xrange(HASH_TEST_RUNS): 238 socketpairs.append(CreateIPv4SocketPair()) 239 socketpairs.append(CreateIPv6SocketPair()) 240 241 KillAddrIoctl(IPV4_LOOPBACK_ADDR) 242 KillAddrIoctl(IPV6_LOOPBACK_ADDR) 243 244 for socketpair in socketpairs: 245 for sock in socketpair: 246 self.assertRaisesErrno(errno.ENOTCONN, sock.getpeername) 247 248 249 if __name__ == "__main__": 250 unittest.main() 251
