blob: 67ff1beede87e535ab51d69ab3b90128e548f0dc [file] [log] [blame]
Guido van Rossum24e4af82002-06-12 19:18:08 +00001import unittest
Benjamin Petersonee8712c2008-05-20 21:35:26 +00002from test import support
Antoine Pitroub7eb5632012-06-24 01:34:13 +02003from unittest.case import _ExpectedFailure
Barry Warsawcf3d4b51997-01-03 20:03:32 +00004
Christian Heimes5e696852008-04-09 08:37:03 +00005import errno
Gregory P. Smithaafdca82010-01-04 04:50:36 +00006import io
Barry Warsawcf3d4b51997-01-03 20:03:32 +00007import socket
Guido van Rossum24e4af82002-06-12 19:18:08 +00008import select
Nick Coghlan96fe56a2011-08-22 11:55:57 +10009import tempfile
Christian Heimesbbe741d2008-03-28 10:53:29 +000010import time
11import traceback
Alexandre Vassalottif260e442008-05-11 19:59:59 +000012import queue
Jack Jansen522e7692002-09-06 21:57:50 +000013import sys
Christian Heimesfaf2f632008-01-06 16:59:19 +000014import os
15import array
Antoine Pitrouacd0fda2010-10-23 17:01:44 +000016import platform
Antoine Pitrou4b92b5f2010-09-07 21:05:49 +000017import contextlib
Raymond Hettinger027bb632004-05-31 03:09:25 +000018from weakref import proxy
Thomas Wouters0e3f5912006-08-11 14:57:12 +000019import signal
Antoine Pitrou6d7df632010-09-27 17:52:25 +000020import math
Antoine Pitrou6d58d642011-03-20 23:56:36 +010021import pickle
Charles-François Natali47413c12011-10-06 19:47:44 +020022import struct
Antoine Pitroub1c54962010-10-14 15:05:38 +000023try:
24 import fcntl
25except ImportError:
26 fcntl = False
Kristján Valur Jónsson10f383a2012-04-07 11:23:31 +000027try:
28 import multiprocessing
29except ImportError:
30 multiprocessing = False
Barry Warsawcf3d4b51997-01-03 20:03:32 +000031
Benjamin Petersonee8712c2008-05-20 21:35:26 +000032HOST = support.HOST
Marc-André Lemburg8f36af72011-02-25 15:42:01 +000033MSG = 'Michael Gilfix was here\u1234\r\n'.encode('utf-8') ## test unicode string and carriage return
Barry Warsawcf3d4b51997-01-03 20:03:32 +000034
Victor Stinner45df8202010-04-28 22:31:17 +000035try:
36 import _thread as thread
37 import threading
38except ImportError:
39 thread = None
40 threading = None
41
Charles-François Natali47413c12011-10-06 19:47:44 +020042def _have_socket_can():
43 """Check whether CAN sockets are supported on this host."""
44 try:
45 s = socket.socket(socket.PF_CAN, socket.SOCK_RAW, socket.CAN_RAW)
46 except (AttributeError, socket.error, OSError):
47 return False
48 else:
49 s.close()
50 return True
51
Charles-François Natali10b8cf42011-11-10 19:21:37 +010052def _have_socket_rds():
53 """Check whether RDS sockets are supported on this host."""
54 try:
55 s = socket.socket(socket.PF_RDS, socket.SOCK_SEQPACKET, 0)
56 except (AttributeError, OSError):
57 return False
58 else:
59 s.close()
60 return True
61
Charles-François Natali47413c12011-10-06 19:47:44 +020062HAVE_SOCKET_CAN = _have_socket_can()
63
Charles-François Natali10b8cf42011-11-10 19:21:37 +010064HAVE_SOCKET_RDS = _have_socket_rds()
65
Nick Coghlan96fe56a2011-08-22 11:55:57 +100066# Size in bytes of the int type
67SIZEOF_INT = array.array("i").itemsize
68
Guido van Rossum24e4af82002-06-12 19:18:08 +000069class SocketTCPTest(unittest.TestCase):
Barry Warsawcf3d4b51997-01-03 20:03:32 +000070
Guido van Rossum24e4af82002-06-12 19:18:08 +000071 def setUp(self):
72 self.serv = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
Benjamin Petersonee8712c2008-05-20 21:35:26 +000073 self.port = support.bind_port(self.serv)
Guido van Rossum24e4af82002-06-12 19:18:08 +000074 self.serv.listen(1)
Barry Warsawcf3d4b51997-01-03 20:03:32 +000075
Guido van Rossum24e4af82002-06-12 19:18:08 +000076 def tearDown(self):
77 self.serv.close()
78 self.serv = None
Barry Warsawcf3d4b51997-01-03 20:03:32 +000079
Guido van Rossum24e4af82002-06-12 19:18:08 +000080class SocketUDPTest(unittest.TestCase):
81
82 def setUp(self):
83 self.serv = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
Benjamin Petersonee8712c2008-05-20 21:35:26 +000084 self.port = support.bind_port(self.serv)
Guido van Rossum24e4af82002-06-12 19:18:08 +000085
86 def tearDown(self):
87 self.serv.close()
88 self.serv = None
89
Nick Coghlan96fe56a2011-08-22 11:55:57 +100090class ThreadSafeCleanupTestCase(unittest.TestCase):
91 """Subclass of unittest.TestCase with thread-safe cleanup methods.
92
93 This subclass protects the addCleanup() and doCleanups() methods
94 with a recursive lock.
95 """
96
97 if threading:
98 def __init__(self, *args, **kwargs):
99 super().__init__(*args, **kwargs)
100 self._cleanup_lock = threading.RLock()
101
102 def addCleanup(self, *args, **kwargs):
103 with self._cleanup_lock:
104 return super().addCleanup(*args, **kwargs)
105
106 def doCleanups(self, *args, **kwargs):
107 with self._cleanup_lock:
108 return super().doCleanups(*args, **kwargs)
109
Charles-François Natali47413c12011-10-06 19:47:44 +0200110class SocketCANTest(unittest.TestCase):
111
112 """To be able to run this test, a `vcan0` CAN interface can be created with
113 the following commands:
114 # modprobe vcan
115 # ip link add dev vcan0 type vcan
116 # ifconfig vcan0 up
117 """
118 interface = 'vcan0'
119 bufsize = 128
120
121 def setUp(self):
122 self.s = socket.socket(socket.PF_CAN, socket.SOCK_RAW, socket.CAN_RAW)
Antoine Pitrou86fe8602011-10-10 20:15:59 +0200123 self.addCleanup(self.s.close)
Charles-François Natali47413c12011-10-06 19:47:44 +0200124 try:
125 self.s.bind((self.interface,))
126 except socket.error:
127 self.skipTest('network interface `%s` does not exist' %
128 self.interface)
Charles-François Natali47413c12011-10-06 19:47:44 +0200129
Charles-François Natali10b8cf42011-11-10 19:21:37 +0100130
131class SocketRDSTest(unittest.TestCase):
132
133 """To be able to run this test, the `rds` kernel module must be loaded:
134 # modprobe rds
135 """
136 bufsize = 8192
137
138 def setUp(self):
139 self.serv = socket.socket(socket.PF_RDS, socket.SOCK_SEQPACKET, 0)
140 self.addCleanup(self.serv.close)
141 try:
142 self.port = support.bind_port(self.serv)
143 except OSError:
144 self.skipTest('unable to bind RDS socket')
145
146
Guido van Rossum24e4af82002-06-12 19:18:08 +0000147class ThreadableTest:
Guido van Rossum83ccb4e2002-06-18 18:35:13 +0000148 """Threadable Test class
149
150 The ThreadableTest class makes it easy to create a threaded
151 client/server pair from an existing unit test. To create a
152 new threaded class from an existing unit test, use multiple
153 inheritance:
154
155 class NewClass (OldClass, ThreadableTest):
156 pass
157
158 This class defines two new fixture functions with obvious
159 purposes for overriding:
160
161 clientSetUp ()
162 clientTearDown ()
163
164 Any new test functions within the class must then define
165 tests in pairs, where the test name is preceeded with a
166 '_' to indicate the client portion of the test. Ex:
167
168 def testFoo(self):
169 # Server portion
170
171 def _testFoo(self):
172 # Client portion
173
174 Any exceptions raised by the clients during their tests
175 are caught and transferred to the main thread to alert
176 the testing framework.
177
178 Note, the server setup function cannot call any blocking
179 functions that rely on the client thread during setup,
Guido van Rossumd8faa362007-04-27 19:54:29 +0000180 unless serverExplicitReady() is called just before
Guido van Rossum83ccb4e2002-06-18 18:35:13 +0000181 the blocking call (such as in setting up a client/server
182 connection and performing the accept() in setUp().
183 """
Guido van Rossum24e4af82002-06-12 19:18:08 +0000184
185 def __init__(self):
186 # Swap the true setup function
187 self.__setUp = self.setUp
188 self.__tearDown = self.tearDown
189 self.setUp = self._setUp
190 self.tearDown = self._tearDown
191
Guido van Rossum83ccb4e2002-06-18 18:35:13 +0000192 def serverExplicitReady(self):
193 """This method allows the server to explicitly indicate that
194 it wants the client thread to proceed. This is useful if the
195 server is about to execute a blocking routine that is
196 dependent upon the client thread during its setup routine."""
197 self.server_ready.set()
198
Guido van Rossum24e4af82002-06-12 19:18:08 +0000199 def _setUp(self):
Guido van Rossum83ccb4e2002-06-18 18:35:13 +0000200 self.server_ready = threading.Event()
201 self.client_ready = threading.Event()
Guido van Rossum24e4af82002-06-12 19:18:08 +0000202 self.done = threading.Event()
Alexandre Vassalottif260e442008-05-11 19:59:59 +0000203 self.queue = queue.Queue(1)
Antoine Pitrou86fe8602011-10-10 20:15:59 +0200204 self.server_crashed = False
Guido van Rossum24e4af82002-06-12 19:18:08 +0000205
206 # Do some munging to start the client test.
Guido van Rossum11ba0942002-06-13 15:07:44 +0000207 methodname = self.id()
208 i = methodname.rfind('.')
209 methodname = methodname[i+1:]
210 test_method = getattr(self, '_' + methodname)
Guido van Rossumab659962002-06-12 21:29:43 +0000211 self.client_thread = thread.start_new_thread(
212 self.clientRun, (test_method,))
Guido van Rossum24e4af82002-06-12 19:18:08 +0000213
Antoine Pitrou86fe8602011-10-10 20:15:59 +0200214 try:
215 self.__setUp()
216 except:
217 self.server_crashed = True
218 raise
219 finally:
Guido van Rossum83ccb4e2002-06-18 18:35:13 +0000220 self.server_ready.set()
221 self.client_ready.wait()
Guido van Rossum24e4af82002-06-12 19:18:08 +0000222
223 def _tearDown(self):
224 self.__tearDown()
225 self.done.wait()
226
Raymond Hettingerda3caed2008-01-14 21:39:24 +0000227 if self.queue.qsize():
Antoine Pitrou98b46702010-09-18 22:59:00 +0000228 exc = self.queue.get()
229 raise exc
Guido van Rossum24e4af82002-06-12 19:18:08 +0000230
231 def clientRun(self, test_func):
Guido van Rossum83ccb4e2002-06-18 18:35:13 +0000232 self.server_ready.wait()
Guido van Rossum24e4af82002-06-12 19:18:08 +0000233 self.clientSetUp()
Charles-François Natalia49ed762011-09-21 22:03:58 +0200234 self.client_ready.set()
Antoine Pitrou86fe8602011-10-10 20:15:59 +0200235 if self.server_crashed:
236 self.clientTearDown()
237 return
Guido van Rossumd59da4b2007-05-22 18:11:13 +0000238 if not hasattr(test_func, '__call__'):
Collin Winter3add4d72007-08-29 23:37:32 +0000239 raise TypeError("test_func must be a callable function")
Guido van Rossum24e4af82002-06-12 19:18:08 +0000240 try:
241 test_func()
Antoine Pitroub7eb5632012-06-24 01:34:13 +0200242 except _ExpectedFailure:
Nick Coghlan2496f332011-09-19 20:26:31 +1000243 # We deliberately ignore expected failures
244 pass
Antoine Pitrou98b46702010-09-18 22:59:00 +0000245 except BaseException as e:
246 self.queue.put(e)
247 finally:
248 self.clientTearDown()
Guido van Rossum24e4af82002-06-12 19:18:08 +0000249
250 def clientSetUp(self):
Collin Winter3add4d72007-08-29 23:37:32 +0000251 raise NotImplementedError("clientSetUp must be implemented.")
Guido van Rossum24e4af82002-06-12 19:18:08 +0000252
253 def clientTearDown(self):
254 self.done.set()
255 thread.exit()
256
257class ThreadedTCPSocketTest(SocketTCPTest, ThreadableTest):
258
259 def __init__(self, methodName='runTest'):
260 SocketTCPTest.__init__(self, methodName=methodName)
261 ThreadableTest.__init__(self)
262
263 def clientSetUp(self):
264 self.cli = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
265
266 def clientTearDown(self):
267 self.cli.close()
268 self.cli = None
269 ThreadableTest.clientTearDown(self)
270
271class ThreadedUDPSocketTest(SocketUDPTest, ThreadableTest):
272
273 def __init__(self, methodName='runTest'):
274 SocketUDPTest.__init__(self, methodName=methodName)
275 ThreadableTest.__init__(self)
276
277 def clientSetUp(self):
278 self.cli = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
279
Brian Curtin3beb38f2010-11-04 03:41:43 +0000280 def clientTearDown(self):
281 self.cli.close()
282 self.cli = None
283 ThreadableTest.clientTearDown(self)
284
Charles-François Natali47413c12011-10-06 19:47:44 +0200285class ThreadedCANSocketTest(SocketCANTest, ThreadableTest):
286
287 def __init__(self, methodName='runTest'):
288 SocketCANTest.__init__(self, methodName=methodName)
289 ThreadableTest.__init__(self)
290
291 def clientSetUp(self):
292 self.cli = socket.socket(socket.PF_CAN, socket.SOCK_RAW, socket.CAN_RAW)
293 try:
294 self.cli.bind((self.interface,))
295 except socket.error:
Antoine Pitrou86fe8602011-10-10 20:15:59 +0200296 # skipTest should not be called here, and will be called in the
297 # server instead
298 pass
Charles-François Natali47413c12011-10-06 19:47:44 +0200299
300 def clientTearDown(self):
301 self.cli.close()
302 self.cli = None
303 ThreadableTest.clientTearDown(self)
304
Charles-François Natali10b8cf42011-11-10 19:21:37 +0100305class ThreadedRDSSocketTest(SocketRDSTest, ThreadableTest):
306
307 def __init__(self, methodName='runTest'):
308 SocketRDSTest.__init__(self, methodName=methodName)
309 ThreadableTest.__init__(self)
Charles-François Natali10b8cf42011-11-10 19:21:37 +0100310
311 def clientSetUp(self):
312 self.cli = socket.socket(socket.PF_RDS, socket.SOCK_SEQPACKET, 0)
313 try:
314 # RDS sockets must be bound explicitly to send or receive data
315 self.cli.bind((HOST, 0))
316 self.cli_addr = self.cli.getsockname()
317 except OSError:
318 # skipTest should not be called here, and will be called in the
319 # server instead
320 pass
321
322 def clientTearDown(self):
323 self.cli.close()
324 self.cli = None
325 ThreadableTest.clientTearDown(self)
326
Guido van Rossum24e4af82002-06-12 19:18:08 +0000327class SocketConnectedTest(ThreadedTCPSocketTest):
Jeremy Hylton5accbdb2007-08-03 20:40:09 +0000328 """Socket tests for client-server connection.
329
330 self.cli_conn is a client socket connected to the server. The
331 setUp() method guarantees that it is connected to the server.
332 """
Guido van Rossum24e4af82002-06-12 19:18:08 +0000333
334 def __init__(self, methodName='runTest'):
335 ThreadedTCPSocketTest.__init__(self, methodName=methodName)
336
337 def setUp(self):
338 ThreadedTCPSocketTest.setUp(self)
Guido van Rossum83ccb4e2002-06-18 18:35:13 +0000339 # Indicate explicitly we're ready for the client thread to
340 # proceed and then perform the blocking call to accept
341 self.serverExplicitReady()
Guido van Rossum24e4af82002-06-12 19:18:08 +0000342 conn, addr = self.serv.accept()
343 self.cli_conn = conn
344
345 def tearDown(self):
346 self.cli_conn.close()
347 self.cli_conn = None
348 ThreadedTCPSocketTest.tearDown(self)
349
350 def clientSetUp(self):
351 ThreadedTCPSocketTest.clientSetUp(self)
Christian Heimes5e696852008-04-09 08:37:03 +0000352 self.cli.connect((HOST, self.port))
Guido van Rossum24e4af82002-06-12 19:18:08 +0000353 self.serv_conn = self.cli
354
355 def clientTearDown(self):
356 self.serv_conn.close()
357 self.serv_conn = None
358 ThreadedTCPSocketTest.clientTearDown(self)
359
Dave Cole331708b2004-08-09 04:51:41 +0000360class SocketPairTest(unittest.TestCase, ThreadableTest):
361
362 def __init__(self, methodName='runTest'):
363 unittest.TestCase.__init__(self, methodName=methodName)
364 ThreadableTest.__init__(self)
365
366 def setUp(self):
367 self.serv, self.cli = socket.socketpair()
368
369 def tearDown(self):
370 self.serv.close()
371 self.serv = None
372
373 def clientSetUp(self):
374 pass
375
376 def clientTearDown(self):
377 self.cli.close()
378 self.cli = None
379 ThreadableTest.clientTearDown(self)
380
Tim Peters494aaee2004-08-09 18:54:11 +0000381
Nick Coghlan96fe56a2011-08-22 11:55:57 +1000382# The following classes are used by the sendmsg()/recvmsg() tests.
383# Combining, for instance, ConnectedStreamTestMixin and TCPTestBase
384# gives a drop-in replacement for SocketConnectedTest, but different
385# address families can be used, and the attributes serv_addr and
386# cli_addr will be set to the addresses of the endpoints.
387
388class SocketTestBase(unittest.TestCase):
389 """A base class for socket tests.
390
391 Subclasses must provide methods newSocket() to return a new socket
392 and bindSock(sock) to bind it to an unused address.
393
394 Creates a socket self.serv and sets self.serv_addr to its address.
395 """
396
397 def setUp(self):
398 self.serv = self.newSocket()
399 self.bindServer()
400
401 def bindServer(self):
402 """Bind server socket and set self.serv_addr to its address."""
403 self.bindSock(self.serv)
404 self.serv_addr = self.serv.getsockname()
405
406 def tearDown(self):
407 self.serv.close()
408 self.serv = None
409
410
411class SocketListeningTestMixin(SocketTestBase):
412 """Mixin to listen on the server socket."""
413
414 def setUp(self):
415 super().setUp()
416 self.serv.listen(1)
417
418
419class ThreadedSocketTestMixin(ThreadSafeCleanupTestCase, SocketTestBase,
420 ThreadableTest):
421 """Mixin to add client socket and allow client/server tests.
422
423 Client socket is self.cli and its address is self.cli_addr. See
424 ThreadableTest for usage information.
425 """
426
427 def __init__(self, *args, **kwargs):
428 super().__init__(*args, **kwargs)
429 ThreadableTest.__init__(self)
430
431 def clientSetUp(self):
432 self.cli = self.newClientSocket()
433 self.bindClient()
434
435 def newClientSocket(self):
436 """Return a new socket for use as client."""
437 return self.newSocket()
438
439 def bindClient(self):
440 """Bind client socket and set self.cli_addr to its address."""
441 self.bindSock(self.cli)
442 self.cli_addr = self.cli.getsockname()
443
444 def clientTearDown(self):
445 self.cli.close()
446 self.cli = None
447 ThreadableTest.clientTearDown(self)
448
449
450class ConnectedStreamTestMixin(SocketListeningTestMixin,
451 ThreadedSocketTestMixin):
452 """Mixin to allow client/server stream tests with connected client.
453
454 Server's socket representing connection to client is self.cli_conn
455 and client's connection to server is self.serv_conn. (Based on
456 SocketConnectedTest.)
457 """
458
459 def setUp(self):
460 super().setUp()
461 # Indicate explicitly we're ready for the client thread to
462 # proceed and then perform the blocking call to accept
463 self.serverExplicitReady()
464 conn, addr = self.serv.accept()
465 self.cli_conn = conn
466
467 def tearDown(self):
468 self.cli_conn.close()
469 self.cli_conn = None
470 super().tearDown()
471
472 def clientSetUp(self):
473 super().clientSetUp()
474 self.cli.connect(self.serv_addr)
475 self.serv_conn = self.cli
476
477 def clientTearDown(self):
478 self.serv_conn.close()
479 self.serv_conn = None
480 super().clientTearDown()
481
482
483class UnixSocketTestBase(SocketTestBase):
484 """Base class for Unix-domain socket tests."""
485
486 # This class is used for file descriptor passing tests, so we
487 # create the sockets in a private directory so that other users
488 # can't send anything that might be problematic for a privileged
489 # user running the tests.
490
491 def setUp(self):
492 self.dir_path = tempfile.mkdtemp()
493 self.addCleanup(os.rmdir, self.dir_path)
494 super().setUp()
495
496 def bindSock(self, sock):
497 path = tempfile.mktemp(dir=self.dir_path)
498 sock.bind(path)
499 self.addCleanup(support.unlink, path)
500
501class UnixStreamBase(UnixSocketTestBase):
502 """Base class for Unix-domain SOCK_STREAM tests."""
503
504 def newSocket(self):
505 return socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
506
507
508class InetTestBase(SocketTestBase):
509 """Base class for IPv4 socket tests."""
510
511 host = HOST
512
513 def setUp(self):
514 super().setUp()
515 self.port = self.serv_addr[1]
516
517 def bindSock(self, sock):
518 support.bind_port(sock, host=self.host)
519
520class TCPTestBase(InetTestBase):
521 """Base class for TCP-over-IPv4 tests."""
522
523 def newSocket(self):
524 return socket.socket(socket.AF_INET, socket.SOCK_STREAM)
525
526class UDPTestBase(InetTestBase):
527 """Base class for UDP-over-IPv4 tests."""
528
529 def newSocket(self):
530 return socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
531
532class SCTPStreamBase(InetTestBase):
533 """Base class for SCTP tests in one-to-one (SOCK_STREAM) mode."""
534
535 def newSocket(self):
536 return socket.socket(socket.AF_INET, socket.SOCK_STREAM,
537 socket.IPPROTO_SCTP)
538
539
540class Inet6TestBase(InetTestBase):
541 """Base class for IPv6 socket tests."""
542
543 # Don't use "localhost" here - it may not have an IPv6 address
544 # assigned to it by default (e.g. in /etc/hosts), and if someone
545 # has assigned it an IPv4-mapped address, then it's unlikely to
546 # work with the full IPv6 API.
547 host = "::1"
548
549class UDP6TestBase(Inet6TestBase):
550 """Base class for UDP-over-IPv6 tests."""
551
552 def newSocket(self):
553 return socket.socket(socket.AF_INET6, socket.SOCK_DGRAM)
554
555
556# Test-skipping decorators for use with ThreadableTest.
557
558def skipWithClientIf(condition, reason):
559 """Skip decorated test if condition is true, add client_skip decorator.
560
561 If the decorated object is not a class, sets its attribute
562 "client_skip" to a decorator which will return an empty function
563 if the test is to be skipped, or the original function if it is
564 not. This can be used to avoid running the client part of a
565 skipped test when using ThreadableTest.
566 """
567 def client_pass(*args, **kwargs):
568 pass
569 def skipdec(obj):
570 retval = unittest.skip(reason)(obj)
571 if not isinstance(obj, type):
572 retval.client_skip = lambda f: client_pass
573 return retval
574 def noskipdec(obj):
575 if not (isinstance(obj, type) or hasattr(obj, "client_skip")):
576 obj.client_skip = lambda f: f
577 return obj
578 return skipdec if condition else noskipdec
579
580
581def requireAttrs(obj, *attributes):
582 """Skip decorated test if obj is missing any of the given attributes.
583
584 Sets client_skip attribute as skipWithClientIf() does.
585 """
586 missing = [name for name in attributes if not hasattr(obj, name)]
587 return skipWithClientIf(
588 missing, "don't have " + ", ".join(name for name in missing))
589
590
591def requireSocket(*args):
592 """Skip decorated test if a socket cannot be created with given arguments.
593
594 When an argument is given as a string, will use the value of that
595 attribute of the socket module, or skip the test if it doesn't
596 exist. Sets client_skip attribute as skipWithClientIf() does.
597 """
598 err = None
599 missing = [obj for obj in args if
600 isinstance(obj, str) and not hasattr(socket, obj)]
601 if missing:
602 err = "don't have " + ", ".join(name for name in missing)
603 else:
604 callargs = [getattr(socket, obj) if isinstance(obj, str) else obj
605 for obj in args]
606 try:
607 s = socket.socket(*callargs)
608 except socket.error as e:
609 # XXX: check errno?
610 err = str(e)
611 else:
612 s.close()
613 return skipWithClientIf(
614 err is not None,
615 "can't create socket({0}): {1}".format(
616 ", ".join(str(o) for o in args), err))
617
618
Guido van Rossum24e4af82002-06-12 19:18:08 +0000619#######################################################################
620## Begin Tests
621
622class GeneralModuleTests(unittest.TestCase):
623
Walter Dörwalda7eb93e2007-06-05 13:41:53 +0000624 def test_repr(self):
625 s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
Brian Curtin21ebbb72010-11-02 02:07:09 +0000626 self.addCleanup(s.close)
Benjamin Petersonc9c0f202009-06-30 23:06:06 +0000627 self.assertTrue(repr(s).startswith("<socket.socket object"))
Walter Dörwalda7eb93e2007-06-05 13:41:53 +0000628
Raymond Hettinger027bb632004-05-31 03:09:25 +0000629 def test_weakref(self):
630 s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
631 p = proxy(s)
632 self.assertEqual(p.fileno(), s.fileno())
633 s.close()
634 s = None
635 try:
636 p.fileno()
637 except ReferenceError:
638 pass
639 else:
640 self.fail('Socket proxy still exists')
641
Guido van Rossum24e4af82002-06-12 19:18:08 +0000642 def testSocketError(self):
Guido van Rossum8c943832002-08-08 01:00:28 +0000643 # Testing socket module exceptions
Ezio Melotti845f1522011-05-08 20:23:57 +0300644 msg = "Error raising socket exception (%s)."
645 with self.assertRaises(socket.error, msg=msg % 'socket.error'):
Guido van Rossum24e4af82002-06-12 19:18:08 +0000646 raise socket.error
Ezio Melotti845f1522011-05-08 20:23:57 +0300647 with self.assertRaises(socket.error, msg=msg % 'socket.herror'):
Guido van Rossum24e4af82002-06-12 19:18:08 +0000648 raise socket.herror
Ezio Melotti845f1522011-05-08 20:23:57 +0300649 with self.assertRaises(socket.error, msg=msg % 'socket.gaierror'):
Guido van Rossum24e4af82002-06-12 19:18:08 +0000650 raise socket.gaierror
Guido van Rossum24e4af82002-06-12 19:18:08 +0000651
Ezio Melotti63e42302011-05-07 19:47:48 +0300652 def testSendtoErrors(self):
653 # Testing that sendto doens't masks failures. See #10169.
654 s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
655 self.addCleanup(s.close)
656 s.bind(('', 0))
657 sockname = s.getsockname()
658 # 2 args
Ezio Melotti4c1aebd2011-05-07 19:50:28 +0300659 with self.assertRaises(TypeError) as cm:
Ezio Melotti63e42302011-05-07 19:47:48 +0300660 s.sendto('\u2620', sockname)
Ezio Melotti4c1aebd2011-05-07 19:50:28 +0300661 self.assertEqual(str(cm.exception),
662 "'str' does not support the buffer interface")
663 with self.assertRaises(TypeError) as cm:
Ezio Melotti63e42302011-05-07 19:47:48 +0300664 s.sendto(5j, sockname)
Ezio Melotti4c1aebd2011-05-07 19:50:28 +0300665 self.assertEqual(str(cm.exception),
666 "'complex' does not support the buffer interface")
667 with self.assertRaises(TypeError) as cm:
Ezio Melotti63e42302011-05-07 19:47:48 +0300668 s.sendto(b'foo', None)
Ezio Melotti4c1aebd2011-05-07 19:50:28 +0300669 self.assertIn('not NoneType',str(cm.exception))
Ezio Melotti63e42302011-05-07 19:47:48 +0300670 # 3 args
Ezio Melotti4c1aebd2011-05-07 19:50:28 +0300671 with self.assertRaises(TypeError) as cm:
Ezio Melotti63e42302011-05-07 19:47:48 +0300672 s.sendto('\u2620', 0, sockname)
Ezio Melotti4c1aebd2011-05-07 19:50:28 +0300673 self.assertEqual(str(cm.exception),
674 "'str' does not support the buffer interface")
675 with self.assertRaises(TypeError) as cm:
Ezio Melotti63e42302011-05-07 19:47:48 +0300676 s.sendto(5j, 0, sockname)
Ezio Melotti4c1aebd2011-05-07 19:50:28 +0300677 self.assertEqual(str(cm.exception),
678 "'complex' does not support the buffer interface")
679 with self.assertRaises(TypeError) as cm:
Ezio Melotti63e42302011-05-07 19:47:48 +0300680 s.sendto(b'foo', 0, None)
Ezio Melotti4c1aebd2011-05-07 19:50:28 +0300681 self.assertIn('not NoneType', str(cm.exception))
682 with self.assertRaises(TypeError) as cm:
Ezio Melotti63e42302011-05-07 19:47:48 +0300683 s.sendto(b'foo', 'bar', sockname)
Ezio Melotti4c1aebd2011-05-07 19:50:28 +0300684 self.assertIn('an integer is required', str(cm.exception))
685 with self.assertRaises(TypeError) as cm:
Ezio Melotti63e42302011-05-07 19:47:48 +0300686 s.sendto(b'foo', None, None)
Ezio Melotti4c1aebd2011-05-07 19:50:28 +0300687 self.assertIn('an integer is required', str(cm.exception))
Ezio Melotti63e42302011-05-07 19:47:48 +0300688 # wrong number of args
Ezio Melotti4c1aebd2011-05-07 19:50:28 +0300689 with self.assertRaises(TypeError) as cm:
Ezio Melotti63e42302011-05-07 19:47:48 +0300690 s.sendto(b'foo')
Ezio Melotti4c1aebd2011-05-07 19:50:28 +0300691 self.assertIn('(1 given)', str(cm.exception))
692 with self.assertRaises(TypeError) as cm:
Ezio Melotti63e42302011-05-07 19:47:48 +0300693 s.sendto(b'foo', 0, sockname, 4)
Ezio Melotti4c1aebd2011-05-07 19:50:28 +0300694 self.assertIn('(4 given)', str(cm.exception))
Ezio Melotti63e42302011-05-07 19:47:48 +0300695
Guido van Rossum24e4af82002-06-12 19:18:08 +0000696 def testCrucialConstants(self):
Guido van Rossum8c943832002-08-08 01:00:28 +0000697 # Testing for mission critical constants
Guido van Rossum24e4af82002-06-12 19:18:08 +0000698 socket.AF_INET
699 socket.SOCK_STREAM
700 socket.SOCK_DGRAM
701 socket.SOCK_RAW
702 socket.SOCK_RDM
703 socket.SOCK_SEQPACKET
704 socket.SOL_SOCKET
705 socket.SO_REUSEADDR
706
Guido van Rossum654c11e2002-06-13 20:24:17 +0000707 def testHostnameRes(self):
Guido van Rossum8c943832002-08-08 01:00:28 +0000708 # Testing hostname resolution mechanisms
Guido van Rossum654c11e2002-06-13 20:24:17 +0000709 hostname = socket.gethostname()
Guido van Rossum71e02942002-12-26 16:55:15 +0000710 try:
711 ip = socket.gethostbyname(hostname)
712 except socket.error:
713 # Probably name lookup wasn't set up right; skip this test
Zachary Ware9fe6d862013-12-08 00:20:35 -0600714 self.skipTest('name lookup failure')
Benjamin Petersonc9c0f202009-06-30 23:06:06 +0000715 self.assertTrue(ip.find('.') >= 0, "Error resolving host to ip.")
Guido van Rossum9647b522002-12-26 17:04:45 +0000716 try:
717 hname, aliases, ipaddrs = socket.gethostbyaddr(ip)
718 except socket.error:
719 # Probably a similar problem as above; skip this test
Zachary Ware9fe6d862013-12-08 00:20:35 -0600720 self.skipTest('name lookup failure')
Brett Cannon01668a12005-03-11 00:04:17 +0000721 all_host_names = [hostname, hname] + aliases
Thomas Wouters49fd7fa2006-04-21 10:40:58 +0000722 fqhn = socket.getfqdn(ip)
Guido van Rossum654c11e2002-06-13 20:24:17 +0000723 if not fqhn in all_host_names:
Thomas Wouters49fd7fa2006-04-21 10:40:58 +0000724 self.fail("Error testing host resolution mechanisms. (fqdn: %s, all: %s)" % (fqhn, repr(all_host_names)))
Barry Warsawcf3d4b51997-01-03 20:03:32 +0000725
Antoine Pitrou061cfb52011-02-28 22:25:22 +0000726 @unittest.skipUnless(hasattr(socket, 'sethostname'), "test needs socket.sethostname()")
727 @unittest.skipUnless(hasattr(socket, 'gethostname'), "test needs socket.gethostname()")
728 def test_sethostname(self):
729 oldhn = socket.gethostname()
730 try:
731 socket.sethostname('new')
732 except socket.error as e:
733 if e.errno == errno.EPERM:
734 self.skipTest("test should be run as root")
735 else:
736 raise
737 try:
738 # running test as root!
739 self.assertEqual(socket.gethostname(), 'new')
740 # Should work with bytes objects too
741 socket.sethostname(b'bar')
742 self.assertEqual(socket.gethostname(), 'bar')
743 finally:
744 socket.sethostname(oldhn)
745
Gregory P. Smith5ed2e772011-05-15 00:26:45 -0700746 @unittest.skipUnless(hasattr(socket, 'if_nameindex'),
747 'socket.if_nameindex() not available.')
748 def testInterfaceNameIndex(self):
749 interfaces = socket.if_nameindex()
750 for index, name in interfaces:
Charles-François Natali60713592011-05-20 16:55:06 +0200751 self.assertIsInstance(index, int)
752 self.assertIsInstance(name, str)
Gregory P. Smith5ed2e772011-05-15 00:26:45 -0700753 # interface indices are non-zero integers
754 self.assertGreater(index, 0)
Charles-François Natali60713592011-05-20 16:55:06 +0200755 _index = socket.if_nametoindex(name)
756 self.assertIsInstance(_index, int)
757 self.assertEqual(index, _index)
758 _name = socket.if_indextoname(index)
759 self.assertIsInstance(_name, str)
760 self.assertEqual(name, _name)
761
762 @unittest.skipUnless(hasattr(socket, 'if_nameindex'),
763 'socket.if_nameindex() not available.')
764 def testInvalidInterfaceNameIndex(self):
765 # test nonexistent interface index/name
766 self.assertRaises(socket.error, socket.if_indextoname, 0)
767 self.assertRaises(socket.error, socket.if_nametoindex, '_DEADBEEF')
768 # test with invalid values
769 self.assertRaises(TypeError, socket.if_nametoindex, 0)
770 self.assertRaises(TypeError, socket.if_indextoname, '_DEADBEEF')
Gregory P. Smith5ed2e772011-05-15 00:26:45 -0700771
Serhiy Storchaka79080682013-11-03 21:31:18 +0200772 @unittest.skipUnless(hasattr(sys, 'getrefcount'),
773 'test needs sys.getrefcount()')
Guido van Rossum284a2cf2002-06-12 21:19:40 +0000774 def testRefCountGetNameInfo(self):
Guido van Rossum8c943832002-08-08 01:00:28 +0000775 # Testing reference count for getnameinfo
Serhiy Storchaka79080682013-11-03 21:31:18 +0200776 try:
777 # On some versions, this loses a reference
778 orig = sys.getrefcount(__name__)
779 socket.getnameinfo(__name__,0)
780 except TypeError:
781 if sys.getrefcount(__name__) != orig:
782 self.fail("socket.getnameinfo loses a reference")
Barry Warsawcf3d4b51997-01-03 20:03:32 +0000783
Guido van Rossum24e4af82002-06-12 19:18:08 +0000784 def testInterpreterCrash(self):
Guido van Rossum8c943832002-08-08 01:00:28 +0000785 # Making sure getnameinfo doesn't crash the interpreter
Guido van Rossum24e4af82002-06-12 19:18:08 +0000786 try:
787 # On some versions, this crashes the interpreter.
788 socket.getnameinfo(('x', 0, 0, 0), 0)
789 except socket.error:
790 pass
Barry Warsawcf3d4b51997-01-03 20:03:32 +0000791
Guido van Rossumc0a0e082002-09-16 01:30:03 +0000792 def testNtoH(self):
Guido van Rossuma2627af2002-09-14 00:58:46 +0000793 # This just checks that htons etc. are their own inverse,
794 # when looking at the lower 16 or 32 bits.
795 sizes = {socket.htonl: 32, socket.ntohl: 32,
796 socket.htons: 16, socket.ntohs: 16}
797 for func, size in sizes.items():
Guido van Rossume2a383d2007-01-15 16:59:06 +0000798 mask = (1<<size) - 1
Guido van Rossuma2627af2002-09-14 00:58:46 +0000799 for i in (0, 1, 0xffff, ~0xffff, 2, 0x01234567, 0x76543210):
800 self.assertEqual(i & mask, func(func(i&mask)) & mask)
Jeremy Hyltoncbd5b892002-07-31 15:57:39 +0000801
Guido van Rossuma2627af2002-09-14 00:58:46 +0000802 swapped = func(mask)
803 self.assertEqual(swapped & mask, mask)
Guido van Rossume2a383d2007-01-15 16:59:06 +0000804 self.assertRaises(OverflowError, func, 1<<34)
Jeremy Hyltonc075e192002-07-25 16:01:12 +0000805
Guido van Rossum018919a2007-01-15 00:07:32 +0000806 def testNtoHErrors(self):
Guido van Rossume2a383d2007-01-15 16:59:06 +0000807 good_values = [ 1, 2, 3, 1, 2, 3 ]
808 bad_values = [ -1, -2, -3, -1, -2, -3 ]
Guido van Rossum018919a2007-01-15 00:07:32 +0000809 for k in good_values:
810 socket.ntohl(k)
811 socket.ntohs(k)
812 socket.htonl(k)
813 socket.htons(k)
814 for k in bad_values:
815 self.assertRaises(OverflowError, socket.ntohl, k)
816 self.assertRaises(OverflowError, socket.ntohs, k)
817 self.assertRaises(OverflowError, socket.htonl, k)
818 self.assertRaises(OverflowError, socket.htons, k)
819
Barry Warsaw11b91a02004-06-28 00:50:43 +0000820 def testGetServBy(self):
821 eq = self.assertEqual
822 # Find one service that exists, then check all the related interfaces.
823 # I've ordered this by protocols that have both a tcp and udp
824 # protocol, at least for modern Linuxes.
Victor Stinnere6747472011-08-21 00:39:18 +0200825 if (sys.platform.startswith(('freebsd', 'netbsd'))
826 or sys.platform in ('linux', 'darwin')):
Andrew MacIntyre18bf43c2004-07-12 12:10:30 +0000827 # avoid the 'echo' service on this platform, as there is an
828 # assumption breaking non-standard port/protocol entry
829 services = ('daytime', 'qotd', 'domain')
830 else:
831 services = ('echo', 'daytime', 'domain')
832 for service in services:
Skip Montanarof4433302002-08-02 15:52:30 +0000833 try:
Barry Warsaw11b91a02004-06-28 00:50:43 +0000834 port = socket.getservbyname(service, 'tcp')
Skip Montanarof4433302002-08-02 15:52:30 +0000835 break
836 except socket.error:
837 pass
Skip Montanaro05eb4012004-02-10 15:51:15 +0000838 else:
839 raise socket.error
Barry Warsaw11b91a02004-06-28 00:50:43 +0000840 # Try same call with optional protocol omitted
841 port2 = socket.getservbyname(service)
842 eq(port, port2)
Terry Jan Reedyc30b7b12013-03-11 17:57:08 -0400843 # Try udp, but don't barf if it doesn't exist
Barry Warsaw11b91a02004-06-28 00:50:43 +0000844 try:
845 udpport = socket.getservbyname(service, 'udp')
846 except socket.error:
847 udpport = None
848 else:
849 eq(udpport, port)
850 # Now make sure the lookup by port returns the same service name
851 eq(socket.getservbyport(port2), service)
852 eq(socket.getservbyport(port, 'tcp'), service)
853 if udpport is not None:
854 eq(socket.getservbyport(udpport, 'udp'), service)
Benjamin Peterson5c6d7872009-02-06 02:40:07 +0000855 # Make sure getservbyport does not accept out of range ports.
856 self.assertRaises(OverflowError, socket.getservbyport, -1)
857 self.assertRaises(OverflowError, socket.getservbyport, 65536)
Guido van Rossum24e4af82002-06-12 19:18:08 +0000858
Guido van Rossum9d0c8ce2002-07-18 17:08:35 +0000859 def testDefaultTimeout(self):
Guido van Rossum8c943832002-08-08 01:00:28 +0000860 # Testing default timeout
Guido van Rossum9d0c8ce2002-07-18 17:08:35 +0000861 # The default timeout should initially be None
862 self.assertEqual(socket.getdefaulttimeout(), None)
863 s = socket.socket()
864 self.assertEqual(s.gettimeout(), None)
865 s.close()
866
867 # Set the default timeout to 10, and see if it propagates
868 socket.setdefaulttimeout(10)
869 self.assertEqual(socket.getdefaulttimeout(), 10)
870 s = socket.socket()
871 self.assertEqual(s.gettimeout(), 10)
872 s.close()
873
874 # Reset the default timeout to None, and see if it propagates
875 socket.setdefaulttimeout(None)
876 self.assertEqual(socket.getdefaulttimeout(), None)
877 s = socket.socket()
878 self.assertEqual(s.gettimeout(), None)
879 s.close()
880
881 # Check that setting it to an invalid value raises ValueError
882 self.assertRaises(ValueError, socket.setdefaulttimeout, -1)
883
884 # Check that setting it to an invalid type raises TypeError
885 self.assertRaises(TypeError, socket.setdefaulttimeout, "spam")
886
Serhiy Storchaka79080682013-11-03 21:31:18 +0200887 @unittest.skipUnless(hasattr(socket, 'inet_aton'),
888 'test needs socket.inet_aton()')
Benjamin Petersonf91df042009-02-13 02:50:59 +0000889 def testIPv4_inet_aton_fourbytes(self):
Benjamin Petersonf91df042009-02-13 02:50:59 +0000890 # Test that issue1008086 and issue767150 are fixed.
891 # It must return 4 bytes.
Ezio Melottib3aedd42010-11-20 19:04:17 +0000892 self.assertEqual(b'\x00'*4, socket.inet_aton('0.0.0.0'))
893 self.assertEqual(b'\xff'*4, socket.inet_aton('255.255.255.255'))
Benjamin Petersonf91df042009-02-13 02:50:59 +0000894
Serhiy Storchaka79080682013-11-03 21:31:18 +0200895 @unittest.skipUnless(hasattr(socket, 'inet_pton'),
896 'test needs socket.inet_pton()')
Guido van Rossum47dfa4a2003-04-25 05:48:32 +0000897 def testIPv4toString(self):
898 from socket import inet_aton as f, inet_pton, AF_INET
899 g = lambda a: inet_pton(AF_INET, a)
900
Antoine Pitrou7ded21e2011-12-19 16:21:21 +0100901 assertInvalid = lambda func,a: self.assertRaises(
902 (socket.error, ValueError), func, a
903 )
904
Ezio Melottib3aedd42010-11-20 19:04:17 +0000905 self.assertEqual(b'\x00\x00\x00\x00', f('0.0.0.0'))
906 self.assertEqual(b'\xff\x00\xff\x00', f('255.0.255.0'))
907 self.assertEqual(b'\xaa\xaa\xaa\xaa', f('170.170.170.170'))
908 self.assertEqual(b'\x01\x02\x03\x04', f('1.2.3.4'))
909 self.assertEqual(b'\xff\xff\xff\xff', f('255.255.255.255'))
Antoine Pitrou7ded21e2011-12-19 16:21:21 +0100910 assertInvalid(f, '0.0.0.')
911 assertInvalid(f, '300.0.0.0')
912 assertInvalid(f, 'a.0.0.0')
913 assertInvalid(f, '1.2.3.4.5')
914 assertInvalid(f, '::1')
Guido van Rossum47dfa4a2003-04-25 05:48:32 +0000915
Ezio Melottib3aedd42010-11-20 19:04:17 +0000916 self.assertEqual(b'\x00\x00\x00\x00', g('0.0.0.0'))
917 self.assertEqual(b'\xff\x00\xff\x00', g('255.0.255.0'))
918 self.assertEqual(b'\xaa\xaa\xaa\xaa', g('170.170.170.170'))
919 self.assertEqual(b'\xff\xff\xff\xff', g('255.255.255.255'))
Antoine Pitrou7ded21e2011-12-19 16:21:21 +0100920 assertInvalid(g, '0.0.0.')
921 assertInvalid(g, '300.0.0.0')
922 assertInvalid(g, 'a.0.0.0')
923 assertInvalid(g, '1.2.3.4.5')
924 assertInvalid(g, '::1')
Tim Petersc2659cf2003-05-12 20:19:37 +0000925
Serhiy Storchaka79080682013-11-03 21:31:18 +0200926 @unittest.skipUnless(hasattr(socket, 'inet_pton'),
927 'test needs socket.inet_pton()')
Guido van Rossum47dfa4a2003-04-25 05:48:32 +0000928 def testIPv6toString(self):
929 try:
930 from socket import inet_pton, AF_INET6, has_ipv6
931 if not has_ipv6:
Zachary Ware9fe6d862013-12-08 00:20:35 -0600932 self.skipTest('IPv6 not available')
Guido van Rossum47dfa4a2003-04-25 05:48:32 +0000933 except ImportError:
Zachary Ware9fe6d862013-12-08 00:20:35 -0600934 self.skipTest('could not import needed symbols from socket')
Guido van Rossum47dfa4a2003-04-25 05:48:32 +0000935 f = lambda a: inet_pton(AF_INET6, a)
Antoine Pitrou7ded21e2011-12-19 16:21:21 +0100936 assertInvalid = lambda a: self.assertRaises(
937 (socket.error, ValueError), f, a
938 )
Guido van Rossum47dfa4a2003-04-25 05:48:32 +0000939
Ezio Melottib3aedd42010-11-20 19:04:17 +0000940 self.assertEqual(b'\x00' * 16, f('::'))
941 self.assertEqual(b'\x00' * 16, f('0::0'))
942 self.assertEqual(b'\x00\x01' + b'\x00' * 14, f('1::'))
943 self.assertEqual(
Guido van Rossum67180622007-07-10 07:29:12 +0000944 b'\x45\xef\x76\xcb\x00\x1a\x56\xef\xaf\xeb\x0b\xac\x19\x24\xae\xae',
Guido van Rossum47dfa4a2003-04-25 05:48:32 +0000945 f('45ef:76cb:1a:56ef:afeb:bac:1924:aeae')
946 )
Antoine Pitrou7ded21e2011-12-19 16:21:21 +0100947 self.assertEqual(
948 b'\xad\x42\x0a\xbc' + b'\x00' * 4 + b'\x01\x27\x00\x00\x02\x54\x00\x02',
949 f('ad42:abc::127:0:254:2')
950 )
951 self.assertEqual(b'\x00\x12\x00\x0a' + b'\x00' * 12, f('12:a::'))
952 assertInvalid('0x20::')
953 assertInvalid(':::')
954 assertInvalid('::0::')
955 assertInvalid('1::abc::')
956 assertInvalid('1::abc::def')
957 assertInvalid('1:2:3:4:5:6:')
958 assertInvalid('1:2:3:4:5:6')
959 assertInvalid('1:2:3:4:5:6:7:8:')
960 assertInvalid('1:2:3:4:5:6:7:8:0')
961
962 self.assertEqual(b'\x00' * 12 + b'\xfe\x2a\x17\x40',
963 f('::254.42.23.64')
964 )
965 self.assertEqual(
966 b'\x00\x42' + b'\x00' * 8 + b'\xa2\x9b\xfe\x2a\x17\x40',
967 f('42::a29b:254.42.23.64')
968 )
969 self.assertEqual(
970 b'\x00\x42\xa8\xb9\x00\x00\x00\x02\xff\xff\xa2\x9b\xfe\x2a\x17\x40',
971 f('42:a8b9:0:2:ffff:a29b:254.42.23.64')
972 )
973 assertInvalid('255.254.253.252')
974 assertInvalid('1::260.2.3.0')
975 assertInvalid('1::0.be.e.0')
976 assertInvalid('1:2:3:4:5:6:7:1.2.3.4')
977 assertInvalid('::1.2.3.4:0')
978 assertInvalid('0.100.200.0:3:4:5:6:7:8')
Tim Petersc2659cf2003-05-12 20:19:37 +0000979
Serhiy Storchaka79080682013-11-03 21:31:18 +0200980 @unittest.skipUnless(hasattr(socket, 'inet_ntop'),
981 'test needs socket.inet_ntop()')
Guido van Rossum47dfa4a2003-04-25 05:48:32 +0000982 def testStringToIPv4(self):
983 from socket import inet_ntoa as f, inet_ntop, AF_INET
984 g = lambda a: inet_ntop(AF_INET, a)
Antoine Pitrou7ded21e2011-12-19 16:21:21 +0100985 assertInvalid = lambda func,a: self.assertRaises(
986 (socket.error, ValueError), func, a
987 )
Guido van Rossum47dfa4a2003-04-25 05:48:32 +0000988
Ezio Melottib3aedd42010-11-20 19:04:17 +0000989 self.assertEqual('1.0.1.0', f(b'\x01\x00\x01\x00'))
990 self.assertEqual('170.85.170.85', f(b'\xaa\x55\xaa\x55'))
991 self.assertEqual('255.255.255.255', f(b'\xff\xff\xff\xff'))
992 self.assertEqual('1.2.3.4', f(b'\x01\x02\x03\x04'))
Antoine Pitrou7ded21e2011-12-19 16:21:21 +0100993 assertInvalid(f, b'\x00' * 3)
994 assertInvalid(f, b'\x00' * 5)
995 assertInvalid(f, b'\x00' * 16)
Tim Petersc2659cf2003-05-12 20:19:37 +0000996
Ezio Melottib3aedd42010-11-20 19:04:17 +0000997 self.assertEqual('1.0.1.0', g(b'\x01\x00\x01\x00'))
998 self.assertEqual('170.85.170.85', g(b'\xaa\x55\xaa\x55'))
999 self.assertEqual('255.255.255.255', g(b'\xff\xff\xff\xff'))
Antoine Pitrou7ded21e2011-12-19 16:21:21 +01001000 assertInvalid(g, b'\x00' * 3)
1001 assertInvalid(g, b'\x00' * 5)
1002 assertInvalid(g, b'\x00' * 16)
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00001003
Serhiy Storchaka79080682013-11-03 21:31:18 +02001004 @unittest.skipUnless(hasattr(socket, 'inet_ntop'),
1005 'test needs socket.inet_ntop()')
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00001006 def testStringToIPv6(self):
1007 try:
1008 from socket import inet_ntop, AF_INET6, has_ipv6
1009 if not has_ipv6:
Zachary Ware9fe6d862013-12-08 00:20:35 -06001010 self.skipTest('IPv6 not available')
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00001011 except ImportError:
Zachary Ware9fe6d862013-12-08 00:20:35 -06001012 self.skipTest('could not import needed symbols from socket')
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00001013 f = lambda a: inet_ntop(AF_INET6, a)
Antoine Pitrou7ded21e2011-12-19 16:21:21 +01001014 assertInvalid = lambda a: self.assertRaises(
1015 (socket.error, ValueError), f, a
1016 )
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00001017
Ezio Melottib3aedd42010-11-20 19:04:17 +00001018 self.assertEqual('::', f(b'\x00' * 16))
1019 self.assertEqual('::1', f(b'\x00' * 15 + b'\x01'))
1020 self.assertEqual(
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00001021 'aef:b01:506:1001:ffff:9997:55:170',
Guido van Rossum67180622007-07-10 07:29:12 +00001022 f(b'\x0a\xef\x0b\x01\x05\x06\x10\x01\xff\xff\x99\x97\x00\x55\x01\x70')
Guido van Rossum47dfa4a2003-04-25 05:48:32 +00001023 )
1024
Antoine Pitrou7ded21e2011-12-19 16:21:21 +01001025 assertInvalid(b'\x12' * 15)
1026 assertInvalid(b'\x12' * 17)
1027 assertInvalid(b'\x12' * 4)
1028
Guido van Rossumb6cc7d22002-07-19 12:46:46 +00001029 # XXX The following don't test module-level functionality...
Guido van Rossum9d0c8ce2002-07-18 17:08:35 +00001030
Benjamin Peterson5c6d7872009-02-06 02:40:07 +00001031 def testSockName(self):
1032 # Testing getsockname()
Antoine Pitrouccc87b52011-05-10 23:37:11 +02001033 port = support.find_unused_port()
Guido van Rossum24e4af82002-06-12 19:18:08 +00001034 sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
Brian Curtin21ebbb72010-11-02 02:07:09 +00001035 self.addCleanup(sock.close)
Christian Heimes5e696852008-04-09 08:37:03 +00001036 sock.bind(("0.0.0.0", port))
Guido van Rossum24e4af82002-06-12 19:18:08 +00001037 name = sock.getsockname()
Thomas Wouters0e3f5912006-08-11 14:57:12 +00001038 # XXX(nnorwitz): http://tinyurl.com/os5jz seems to indicate
1039 # it reasonable to get the host's addr in addition to 0.0.0.0.
1040 # At least for eCos. This is required for the S/390 to pass.
Georg Brandl89197fe2010-11-20 14:16:17 +00001041 try:
1042 my_ip_addr = socket.gethostbyname(socket.gethostname())
1043 except socket.error:
1044 # Probably name lookup wasn't set up right; skip this test
Zachary Ware9fe6d862013-12-08 00:20:35 -06001045 self.skipTest('name lookup failure')
Benjamin Peterson577473f2010-01-19 00:09:57 +00001046 self.assertIn(name[0], ("0.0.0.0", my_ip_addr), '%s invalid' % name[0])
Christian Heimes5e696852008-04-09 08:37:03 +00001047 self.assertEqual(name[1], port)
Guido van Rossum24e4af82002-06-12 19:18:08 +00001048
1049 def testGetSockOpt(self):
Guido van Rossum8c943832002-08-08 01:00:28 +00001050 # Testing getsockopt()
Guido van Rossum24e4af82002-06-12 19:18:08 +00001051 # We know a socket should start without reuse==0
1052 sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
Brian Curtin21ebbb72010-11-02 02:07:09 +00001053 self.addCleanup(sock.close)
Guido van Rossum24e4af82002-06-12 19:18:08 +00001054 reuse = sock.getsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR)
Benjamin Petersonc9c0f202009-06-30 23:06:06 +00001055 self.assertFalse(reuse != 0, "initial mode is reuse")
Guido van Rossum24e4af82002-06-12 19:18:08 +00001056
1057 def testSetSockOpt(self):
Guido van Rossum8c943832002-08-08 01:00:28 +00001058 # Testing setsockopt()
Guido van Rossum24e4af82002-06-12 19:18:08 +00001059 sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
Brian Curtin21ebbb72010-11-02 02:07:09 +00001060 self.addCleanup(sock.close)
Guido van Rossum24e4af82002-06-12 19:18:08 +00001061 sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
1062 reuse = sock.getsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR)
Benjamin Petersonc9c0f202009-06-30 23:06:06 +00001063 self.assertFalse(reuse == 0, "failed to set reuse mode")
Guido van Rossum24e4af82002-06-12 19:18:08 +00001064
Guido van Rossumb6cc7d22002-07-19 12:46:46 +00001065 def testSendAfterClose(self):
Guido van Rossum8c943832002-08-08 01:00:28 +00001066 # testing send() after close() with timeout
Guido van Rossumb6cc7d22002-07-19 12:46:46 +00001067 sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
1068 sock.settimeout(1)
1069 sock.close()
Guido van Rossum8a392d72007-11-21 22:09:45 +00001070 self.assertRaises(socket.error, sock.send, b"spam")
Guido van Rossumb6cc7d22002-07-19 12:46:46 +00001071
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00001072 def testNewAttributes(self):
1073 # testing .family, .type and .protocol
1074 sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
1075 self.assertEqual(sock.family, socket.AF_INET)
1076 self.assertEqual(sock.type, socket.SOCK_STREAM)
1077 self.assertEqual(sock.proto, 0)
1078 sock.close()
1079
Benjamin Peterson5c6d7872009-02-06 02:40:07 +00001080 def test_getsockaddrarg(self):
1081 host = '0.0.0.0'
Antoine Pitrouccc87b52011-05-10 23:37:11 +02001082 port = support.find_unused_port()
Benjamin Peterson5c6d7872009-02-06 02:40:07 +00001083 big_port = port + 65536
1084 neg_port = port - 65536
1085 sock = socket.socket()
1086 try:
1087 self.assertRaises(OverflowError, sock.bind, (host, big_port))
1088 self.assertRaises(OverflowError, sock.bind, (host, neg_port))
1089 sock.bind((host, port))
1090 finally:
1091 sock.close()
1092
Brian Curtin5ad0bd62010-11-05 15:47:45 +00001093 @unittest.skipUnless(os.name == "nt", "Windows specific")
Christian Heimesfaf2f632008-01-06 16:59:19 +00001094 def test_sock_ioctl(self):
Benjamin Petersonc9c0f202009-06-30 23:06:06 +00001095 self.assertTrue(hasattr(socket.socket, 'ioctl'))
1096 self.assertTrue(hasattr(socket, 'SIO_RCVALL'))
1097 self.assertTrue(hasattr(socket, 'RCVALL_ON'))
1098 self.assertTrue(hasattr(socket, 'RCVALL_OFF'))
Kristján Valur Jónsson847ec752009-09-27 21:10:38 +00001099 self.assertTrue(hasattr(socket, 'SIO_KEEPALIVE_VALS'))
1100 s = socket.socket()
Brian Curtin5ad0bd62010-11-05 15:47:45 +00001101 self.addCleanup(s.close)
Kristján Valur Jónsson847ec752009-09-27 21:10:38 +00001102 self.assertRaises(ValueError, s.ioctl, -1, None)
1103 s.ioctl(socket.SIO_KEEPALIVE_VALS, (1, 100, 100))
Christian Heimesfaf2f632008-01-06 16:59:19 +00001104
Giampaolo Rodolà419f7042010-08-14 16:45:41 +00001105 def testGetaddrinfo(self):
1106 try:
1107 socket.getaddrinfo('localhost', 80)
1108 except socket.gaierror as err:
1109 if err.errno == socket.EAI_SERVICE:
1110 # see http://bugs.python.org/issue1282647
1111 self.skipTest("buggy libc version")
1112 raise
1113 # len of every sequence is supposed to be == 5
1114 for info in socket.getaddrinfo(HOST, None):
1115 self.assertEqual(len(info), 5)
1116 # host can be a domain name, a string representation of an
1117 # IPv4/v6 address or None
1118 socket.getaddrinfo('localhost', 80)
1119 socket.getaddrinfo('127.0.0.1', 80)
1120 socket.getaddrinfo(None, 80)
Antoine Pitrou9c39f3c2011-04-28 19:18:10 +02001121 if support.IPV6_ENABLED:
Giampaolo Rodolà419f7042010-08-14 16:45:41 +00001122 socket.getaddrinfo('::1', 80)
1123 # port can be a string service name such as "http", a numeric
1124 # port number or None
1125 socket.getaddrinfo(HOST, "http")
1126 socket.getaddrinfo(HOST, 80)
1127 socket.getaddrinfo(HOST, None)
1128 # test family and socktype filters
1129 infos = socket.getaddrinfo(HOST, None, socket.AF_INET)
1130 for family, _, _, _, _ in infos:
1131 self.assertEqual(family, socket.AF_INET)
1132 infos = socket.getaddrinfo(HOST, None, 0, socket.SOCK_STREAM)
1133 for _, socktype, _, _, _ in infos:
1134 self.assertEqual(socktype, socket.SOCK_STREAM)
1135 # test proto and flags arguments
Giampaolo Rodolà677d95c2010-08-16 05:08:11 +00001136 socket.getaddrinfo(HOST, None, 0, 0, socket.SOL_TCP)
Giampaolo Rodolà419f7042010-08-14 16:45:41 +00001137 socket.getaddrinfo(HOST, None, 0, 0, 0, socket.AI_PASSIVE)
1138 # a server willing to support both IPv4 and IPv6 will
1139 # usually do this
1140 socket.getaddrinfo(None, 0, socket.AF_UNSPEC, socket.SOCK_STREAM, 0,
1141 socket.AI_PASSIVE)
Giampaolo Rodolàccfb91c2010-08-17 15:30:23 +00001142 # test keyword arguments
1143 a = socket.getaddrinfo(HOST, None)
1144 b = socket.getaddrinfo(host=HOST, port=None)
1145 self.assertEqual(a, b)
1146 a = socket.getaddrinfo(HOST, None, socket.AF_INET)
1147 b = socket.getaddrinfo(HOST, None, family=socket.AF_INET)
1148 self.assertEqual(a, b)
1149 a = socket.getaddrinfo(HOST, None, 0, socket.SOCK_STREAM)
1150 b = socket.getaddrinfo(HOST, None, type=socket.SOCK_STREAM)
1151 self.assertEqual(a, b)
1152 a = socket.getaddrinfo(HOST, None, 0, 0, socket.SOL_TCP)
1153 b = socket.getaddrinfo(HOST, None, proto=socket.SOL_TCP)
1154 self.assertEqual(a, b)
1155 a = socket.getaddrinfo(HOST, None, 0, 0, 0, socket.AI_PASSIVE)
1156 b = socket.getaddrinfo(HOST, None, flags=socket.AI_PASSIVE)
1157 self.assertEqual(a, b)
1158 a = socket.getaddrinfo(None, 0, socket.AF_UNSPEC, socket.SOCK_STREAM, 0,
1159 socket.AI_PASSIVE)
1160 b = socket.getaddrinfo(host=None, port=0, family=socket.AF_UNSPEC,
1161 type=socket.SOCK_STREAM, proto=0,
1162 flags=socket.AI_PASSIVE)
1163 self.assertEqual(a, b)
Alexander Belopolskye239d232010-12-08 23:31:48 +00001164 # Issue #6697.
1165 self.assertRaises(UnicodeEncodeError, socket.getaddrinfo, 'localhost', '\uD800')
Giampaolo Rodolà419f7042010-08-14 16:45:41 +00001166
Ronald Oussoren27a4ac52013-05-24 13:47:37 +02001167 # Issue 17269
Ronald Oussorena822d3662013-06-10 10:36:28 +02001168 if hasattr(socket, 'AI_NUMERICSERV'):
1169 socket.getaddrinfo("localhost", None, 0, 0, 0, socket.AI_NUMERICSERV)
Ronald Oussoren27a4ac52013-05-24 13:47:37 +02001170
Martin v. Löwis112c0f32010-08-25 07:38:15 +00001171 def test_getnameinfo(self):
1172 # only IP addresses are allowed
1173 self.assertRaises(socket.error, socket.getnameinfo, ('mail.python.org',0), 0)
1174
Daniel Stutzbach460ff3d2010-09-09 21:17:58 +00001175 @unittest.skipUnless(support.is_resource_enabled('network'),
1176 'network is not enabled')
Martin v. Löwisfc0275a2010-08-22 19:33:47 +00001177 def test_idna(self):
Nadeem Vawda61baebd2012-01-25 08:02:05 +02001178 # Check for internet access before running test (issue #12804).
1179 try:
1180 socket.gethostbyname('python.org')
1181 except socket.gaierror as e:
1182 if e.errno == socket.EAI_NODATA:
1183 self.skipTest('internet access required for this test')
Martin v. Löwisfc0275a2010-08-22 19:33:47 +00001184 # these should all be successful
1185 socket.gethostbyname('испытание.python.org')
1186 socket.gethostbyname_ex('испытание.python.org')
Martin v. Löwis67e91ad2010-08-23 15:27:26 +00001187 socket.getaddrinfo('испытание.python.org',0,socket.AF_UNSPEC,socket.SOCK_STREAM)
1188 # this may not work if the forward lookup choses the IPv6 address, as that doesn't
1189 # have a reverse entry yet
1190 # socket.gethostbyaddr('испытание.python.org')
Christian Heimesfaf2f632008-01-06 16:59:19 +00001191
Antoine Pitrou6d7df632010-09-27 17:52:25 +00001192 def check_sendall_interrupted(self, with_timeout):
1193 # socketpair() is not stricly required, but it makes things easier.
1194 if not hasattr(signal, 'alarm') or not hasattr(socket, 'socketpair'):
1195 self.skipTest("signal.alarm and socket.socketpair required for this test")
1196 # Our signal handlers clobber the C errno by calling a math function
1197 # with an invalid domain value.
1198 def ok_handler(*args):
1199 self.assertRaises(ValueError, math.acosh, 0)
1200 def raising_handler(*args):
1201 self.assertRaises(ValueError, math.acosh, 0)
1202 1 // 0
1203 c, s = socket.socketpair()
1204 old_alarm = signal.signal(signal.SIGALRM, raising_handler)
1205 try:
1206 if with_timeout:
1207 # Just above the one second minimum for signal.alarm
1208 c.settimeout(1.5)
1209 with self.assertRaises(ZeroDivisionError):
1210 signal.alarm(1)
Charles-François Natali5fd26422013-08-29 19:01:40 +02001211 c.sendall(b"x" * support.SOCK_MAX_SIZE)
Antoine Pitrou6d7df632010-09-27 17:52:25 +00001212 if with_timeout:
1213 signal.signal(signal.SIGALRM, ok_handler)
1214 signal.alarm(1)
Charles-François Natali5fd26422013-08-29 19:01:40 +02001215 self.assertRaises(socket.timeout, c.sendall,
1216 b"x" * support.SOCK_MAX_SIZE)
Antoine Pitrou6d7df632010-09-27 17:52:25 +00001217 finally:
Victor Stinner71fe8c02013-08-24 15:52:47 +02001218 signal.alarm(0)
Antoine Pitrou6d7df632010-09-27 17:52:25 +00001219 signal.signal(signal.SIGALRM, old_alarm)
1220 c.close()
1221 s.close()
1222
1223 def test_sendall_interrupted(self):
1224 self.check_sendall_interrupted(False)
1225
1226 def test_sendall_interrupted_with_timeout(self):
1227 self.check_sendall_interrupted(True)
1228
Antoine Pitroue033e062010-10-29 10:38:18 +00001229 def test_dealloc_warn(self):
1230 sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
1231 r = repr(sock)
1232 with self.assertWarns(ResourceWarning) as cm:
1233 sock = None
1234 support.gc_collect()
1235 self.assertIn(r, str(cm.warning.args[0]))
1236 # An open socket file object gets dereferenced after the socket
1237 sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
1238 f = sock.makefile('rb')
1239 r = repr(sock)
1240 sock = None
1241 support.gc_collect()
1242 with self.assertWarns(ResourceWarning):
1243 f = None
1244 support.gc_collect()
1245
Victor Stinnerc3a51ec2011-01-04 11:00:45 +00001246 def test_name_closed_socketio(self):
1247 with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
1248 fp = sock.makefile("rb")
1249 fp.close()
1250 self.assertEqual(repr(fp), "<_io.BufferedReader name=-1>")
1251
Antoine Pitrou1e7ee9d2012-09-14 17:28:10 +02001252 def test_unusable_closed_socketio(self):
1253 with socket.socket() as sock:
1254 fp = sock.makefile("rb", buffering=0)
1255 self.assertTrue(fp.readable())
1256 self.assertFalse(fp.writable())
1257 self.assertFalse(fp.seekable())
1258 fp.close()
1259 self.assertRaises(ValueError, fp.readable)
1260 self.assertRaises(ValueError, fp.writable)
1261 self.assertRaises(ValueError, fp.seekable)
1262
Antoine Pitrou6d58d642011-03-20 23:56:36 +01001263 def test_pickle(self):
1264 sock = socket.socket()
1265 with sock:
1266 for protocol in range(pickle.HIGHEST_PROTOCOL + 1):
1267 self.assertRaises(TypeError, pickle.dumps, sock, protocol)
1268
Serhiy Storchaka441d30f2013-01-19 12:26:26 +02001269 def test_listen_backlog(self):
1270 for backlog in 0, -1:
1271 srv = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
1272 srv.bind((HOST, 0))
1273 srv.listen(backlog)
1274 srv.close()
1275
Serhiy Storchaka5cfc79d2014-02-07 10:06:39 +02001276 @support.cpython_only
1277 def test_listen_backlog_overflow(self):
Serhiy Storchaka441d30f2013-01-19 12:26:26 +02001278 # Issue 15989
Serhiy Storchaka5cfc79d2014-02-07 10:06:39 +02001279 import _testcapi
Antoine Pitrou1be815a2011-05-10 19:16:29 +02001280 srv = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
1281 srv.bind((HOST, 0))
Serhiy Storchaka441d30f2013-01-19 12:26:26 +02001282 self.assertRaises(OverflowError, srv.listen, _testcapi.INT_MAX + 1)
Antoine Pitrou1be815a2011-05-10 19:16:29 +02001283 srv.close()
1284
Charles-François Natali42663332012-01-02 15:57:30 +01001285 @unittest.skipUnless(support.IPV6_ENABLED, 'IPv6 required for this test.')
Charles-François Natali366999a2012-01-02 15:47:29 +01001286 def test_flowinfo(self):
1287 self.assertRaises(OverflowError, socket.getnameinfo,
1288 ('::1',0, 0xffffffff), 0)
1289 with socket.socket(socket.AF_INET6, socket.SOCK_STREAM) as s:
1290 self.assertRaises(OverflowError, s.bind, ('::1', 0, -10))
1291
Antoine Pitrou6d7df632010-09-27 17:52:25 +00001292
Charles-François Natali47413c12011-10-06 19:47:44 +02001293@unittest.skipUnless(HAVE_SOCKET_CAN, 'SocketCan required for this test.')
1294class BasicCANTest(unittest.TestCase):
1295
1296 def testCrucialConstants(self):
1297 socket.AF_CAN
1298 socket.PF_CAN
1299 socket.CAN_RAW
1300
1301 def testCreateSocket(self):
1302 with socket.socket(socket.PF_CAN, socket.SOCK_RAW, socket.CAN_RAW) as s:
1303 pass
1304
1305 def testBindAny(self):
1306 with socket.socket(socket.PF_CAN, socket.SOCK_RAW, socket.CAN_RAW) as s:
1307 s.bind(('', ))
1308
1309 def testTooLongInterfaceName(self):
1310 # most systems limit IFNAMSIZ to 16, take 1024 to be sure
1311 with socket.socket(socket.PF_CAN, socket.SOCK_RAW, socket.CAN_RAW) as s:
Antoine Pitrouffa547e2011-10-11 22:43:37 +02001312 self.assertRaisesRegex(socket.error, 'interface name too long',
1313 s.bind, ('x' * 1024,))
Charles-François Natali47413c12011-10-06 19:47:44 +02001314
1315 @unittest.skipUnless(hasattr(socket, "CAN_RAW_LOOPBACK"),
1316 'socket.CAN_RAW_LOOPBACK required for this test.')
1317 def testLoopback(self):
1318 with socket.socket(socket.PF_CAN, socket.SOCK_RAW, socket.CAN_RAW) as s:
1319 for loopback in (0, 1):
1320 s.setsockopt(socket.SOL_CAN_RAW, socket.CAN_RAW_LOOPBACK,
1321 loopback)
1322 self.assertEqual(loopback,
1323 s.getsockopt(socket.SOL_CAN_RAW, socket.CAN_RAW_LOOPBACK))
1324
1325 @unittest.skipUnless(hasattr(socket, "CAN_RAW_FILTER"),
1326 'socket.CAN_RAW_FILTER required for this test.')
1327 def testFilter(self):
1328 can_id, can_mask = 0x200, 0x700
1329 can_filter = struct.pack("=II", can_id, can_mask)
1330 with socket.socket(socket.PF_CAN, socket.SOCK_RAW, socket.CAN_RAW) as s:
1331 s.setsockopt(socket.SOL_CAN_RAW, socket.CAN_RAW_FILTER, can_filter)
1332 self.assertEqual(can_filter,
1333 s.getsockopt(socket.SOL_CAN_RAW, socket.CAN_RAW_FILTER, 8))
1334
1335
1336@unittest.skipUnless(HAVE_SOCKET_CAN, 'SocketCan required for this test.')
1337@unittest.skipUnless(thread, 'Threading required for this test.')
1338class CANTest(ThreadedCANSocketTest):
1339
1340 """The CAN frame structure is defined in <linux/can.h>:
1341
1342 struct can_frame {
1343 canid_t can_id; /* 32 bit CAN_ID + EFF/RTR/ERR flags */
1344 __u8 can_dlc; /* data length code: 0 .. 8 */
1345 __u8 data[8] __attribute__((aligned(8)));
1346 };
1347 """
1348 can_frame_fmt = "=IB3x8s"
1349
1350 def __init__(self, methodName='runTest'):
1351 ThreadedCANSocketTest.__init__(self, methodName=methodName)
1352
1353 @classmethod
1354 def build_can_frame(cls, can_id, data):
1355 """Build a CAN frame."""
1356 can_dlc = len(data)
1357 data = data.ljust(8, b'\x00')
1358 return struct.pack(cls.can_frame_fmt, can_id, can_dlc, data)
1359
1360 @classmethod
1361 def dissect_can_frame(cls, frame):
1362 """Dissect a CAN frame."""
1363 can_id, can_dlc, data = struct.unpack(cls.can_frame_fmt, frame)
1364 return (can_id, can_dlc, data[:can_dlc])
1365
1366 def testSendFrame(self):
1367 cf, addr = self.s.recvfrom(self.bufsize)
1368 self.assertEqual(self.cf, cf)
1369 self.assertEqual(addr[0], self.interface)
1370 self.assertEqual(addr[1], socket.AF_CAN)
1371
1372 def _testSendFrame(self):
1373 self.cf = self.build_can_frame(0x00, b'\x01\x02\x03\x04\x05')
1374 self.cli.send(self.cf)
1375
1376 def testSendMaxFrame(self):
1377 cf, addr = self.s.recvfrom(self.bufsize)
1378 self.assertEqual(self.cf, cf)
1379
1380 def _testSendMaxFrame(self):
1381 self.cf = self.build_can_frame(0x00, b'\x07' * 8)
1382 self.cli.send(self.cf)
1383
1384 def testSendMultiFrames(self):
1385 cf, addr = self.s.recvfrom(self.bufsize)
1386 self.assertEqual(self.cf1, cf)
1387
1388 cf, addr = self.s.recvfrom(self.bufsize)
1389 self.assertEqual(self.cf2, cf)
1390
1391 def _testSendMultiFrames(self):
1392 self.cf1 = self.build_can_frame(0x07, b'\x44\x33\x22\x11')
1393 self.cli.send(self.cf1)
1394
1395 self.cf2 = self.build_can_frame(0x12, b'\x99\x22\x33')
1396 self.cli.send(self.cf2)
1397
1398
Charles-François Natali10b8cf42011-11-10 19:21:37 +01001399@unittest.skipUnless(HAVE_SOCKET_RDS, 'RDS sockets required for this test.')
1400class BasicRDSTest(unittest.TestCase):
1401
1402 def testCrucialConstants(self):
1403 socket.AF_RDS
1404 socket.PF_RDS
1405
1406 def testCreateSocket(self):
1407 with socket.socket(socket.PF_RDS, socket.SOCK_SEQPACKET, 0) as s:
1408 pass
1409
1410 def testSocketBufferSize(self):
1411 bufsize = 16384
1412 with socket.socket(socket.PF_RDS, socket.SOCK_SEQPACKET, 0) as s:
1413 s.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, bufsize)
1414 s.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, bufsize)
1415
1416
1417@unittest.skipUnless(HAVE_SOCKET_RDS, 'RDS sockets required for this test.')
1418@unittest.skipUnless(thread, 'Threading required for this test.')
1419class RDSTest(ThreadedRDSSocketTest):
1420
1421 def __init__(self, methodName='runTest'):
1422 ThreadedRDSSocketTest.__init__(self, methodName=methodName)
1423
Charles-François Natali240c55f2011-11-10 20:33:36 +01001424 def setUp(self):
1425 super().setUp()
1426 self.evt = threading.Event()
1427
Charles-François Natali10b8cf42011-11-10 19:21:37 +01001428 def testSendAndRecv(self):
1429 data, addr = self.serv.recvfrom(self.bufsize)
1430 self.assertEqual(self.data, data)
1431 self.assertEqual(self.cli_addr, addr)
1432
1433 def _testSendAndRecv(self):
1434 self.data = b'spam'
1435 self.cli.sendto(self.data, 0, (HOST, self.port))
1436
1437 def testPeek(self):
1438 data, addr = self.serv.recvfrom(self.bufsize, socket.MSG_PEEK)
1439 self.assertEqual(self.data, data)
1440 data, addr = self.serv.recvfrom(self.bufsize)
1441 self.assertEqual(self.data, data)
1442
1443 def _testPeek(self):
1444 self.data = b'spam'
1445 self.cli.sendto(self.data, 0, (HOST, self.port))
1446
1447 @requireAttrs(socket.socket, 'recvmsg')
1448 def testSendAndRecvMsg(self):
1449 data, ancdata, msg_flags, addr = self.serv.recvmsg(self.bufsize)
1450 self.assertEqual(self.data, data)
1451
1452 @requireAttrs(socket.socket, 'sendmsg')
1453 def _testSendAndRecvMsg(self):
1454 self.data = b'hello ' * 10
1455 self.cli.sendmsg([self.data], (), 0, (HOST, self.port))
1456
1457 def testSendAndRecvMulti(self):
1458 data, addr = self.serv.recvfrom(self.bufsize)
1459 self.assertEqual(self.data1, data)
1460
1461 data, addr = self.serv.recvfrom(self.bufsize)
1462 self.assertEqual(self.data2, data)
1463
1464 def _testSendAndRecvMulti(self):
1465 self.data1 = b'bacon'
1466 self.cli.sendto(self.data1, 0, (HOST, self.port))
1467
1468 self.data2 = b'egg'
1469 self.cli.sendto(self.data2, 0, (HOST, self.port))
1470
1471 def testSelect(self):
1472 r, w, x = select.select([self.serv], [], [], 3.0)
1473 self.assertIn(self.serv, r)
1474 data, addr = self.serv.recvfrom(self.bufsize)
1475 self.assertEqual(self.data, data)
1476
1477 def _testSelect(self):
1478 self.data = b'select'
1479 self.cli.sendto(self.data, 0, (HOST, self.port))
1480
1481 def testCongestion(self):
1482 # wait until the sender is done
1483 self.evt.wait()
1484
1485 def _testCongestion(self):
1486 # test the behavior in case of congestion
1487 self.data = b'fill'
1488 self.cli.setblocking(False)
1489 try:
1490 # try to lower the receiver's socket buffer size
1491 self.cli.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 16384)
1492 except OSError:
1493 pass
1494 with self.assertRaises(OSError) as cm:
1495 try:
1496 # fill the receiver's socket buffer
1497 while True:
1498 self.cli.sendto(self.data, 0, (HOST, self.port))
1499 finally:
1500 # signal the receiver we're done
1501 self.evt.set()
1502 # sendto() should have failed with ENOBUFS
1503 self.assertEqual(cm.exception.errno, errno.ENOBUFS)
1504 # and we should have received a congestion notification through poll
1505 r, w, x = select.select([self.serv], [], [], 3.0)
1506 self.assertIn(self.serv, r)
1507
1508
Victor Stinner45df8202010-04-28 22:31:17 +00001509@unittest.skipUnless(thread, 'Threading required for this test.')
Guido van Rossum24e4af82002-06-12 19:18:08 +00001510class BasicTCPTest(SocketConnectedTest):
1511
1512 def __init__(self, methodName='runTest'):
1513 SocketConnectedTest.__init__(self, methodName=methodName)
1514
1515 def testRecv(self):
Guido van Rossum8c943832002-08-08 01:00:28 +00001516 # Testing large receive over TCP
Guido van Rossum24e4af82002-06-12 19:18:08 +00001517 msg = self.cli_conn.recv(1024)
Guido van Rossum76489682002-06-12 20:38:30 +00001518 self.assertEqual(msg, MSG)
Guido van Rossum24e4af82002-06-12 19:18:08 +00001519
1520 def _testRecv(self):
1521 self.serv_conn.send(MSG)
1522
1523 def testOverFlowRecv(self):
Guido van Rossum8c943832002-08-08 01:00:28 +00001524 # Testing receive in chunks over TCP
Guido van Rossum24e4af82002-06-12 19:18:08 +00001525 seg1 = self.cli_conn.recv(len(MSG) - 3)
1526 seg2 = self.cli_conn.recv(1024)
Guido van Rossumab659962002-06-12 21:29:43 +00001527 msg = seg1 + seg2
Guido van Rossum76489682002-06-12 20:38:30 +00001528 self.assertEqual(msg, MSG)
Guido van Rossum24e4af82002-06-12 19:18:08 +00001529
1530 def _testOverFlowRecv(self):
1531 self.serv_conn.send(MSG)
1532
1533 def testRecvFrom(self):
Guido van Rossum8c943832002-08-08 01:00:28 +00001534 # Testing large recvfrom() over TCP
Guido van Rossum24e4af82002-06-12 19:18:08 +00001535 msg, addr = self.cli_conn.recvfrom(1024)
Guido van Rossum76489682002-06-12 20:38:30 +00001536 self.assertEqual(msg, MSG)
Guido van Rossum24e4af82002-06-12 19:18:08 +00001537
1538 def _testRecvFrom(self):
1539 self.serv_conn.send(MSG)
1540
1541 def testOverFlowRecvFrom(self):
Guido van Rossum8c943832002-08-08 01:00:28 +00001542 # Testing recvfrom() in chunks over TCP
Guido van Rossum24e4af82002-06-12 19:18:08 +00001543 seg1, addr = self.cli_conn.recvfrom(len(MSG)-3)
1544 seg2, addr = self.cli_conn.recvfrom(1024)
Guido van Rossumab659962002-06-12 21:29:43 +00001545 msg = seg1 + seg2
Guido van Rossum76489682002-06-12 20:38:30 +00001546 self.assertEqual(msg, MSG)
Guido van Rossum24e4af82002-06-12 19:18:08 +00001547
1548 def _testOverFlowRecvFrom(self):
1549 self.serv_conn.send(MSG)
1550
1551 def testSendAll(self):
Guido van Rossum8c943832002-08-08 01:00:28 +00001552 # Testing sendall() with a 2048 byte string over TCP
Guido van Rossum7d0a8262007-05-21 23:13:11 +00001553 msg = b''
Guido van Rossum24e4af82002-06-12 19:18:08 +00001554 while 1:
1555 read = self.cli_conn.recv(1024)
1556 if not read:
1557 break
Guido van Rossume531e292002-08-08 20:28:34 +00001558 msg += read
Guido van Rossum7d0a8262007-05-21 23:13:11 +00001559 self.assertEqual(msg, b'f' * 2048)
Guido van Rossum24e4af82002-06-12 19:18:08 +00001560
1561 def _testSendAll(self):
Guido van Rossum7d0a8262007-05-21 23:13:11 +00001562 big_chunk = b'f' * 2048
Guido van Rossum24e4af82002-06-12 19:18:08 +00001563 self.serv_conn.sendall(big_chunk)
1564
1565 def testFromFd(self):
Guido van Rossum8c943832002-08-08 01:00:28 +00001566 # Testing fromfd()
Guido van Rossum24e4af82002-06-12 19:18:08 +00001567 fd = self.cli_conn.fileno()
1568 sock = socket.fromfd(fd, socket.AF_INET, socket.SOCK_STREAM)
Brian Curtin21ebbb72010-11-02 02:07:09 +00001569 self.addCleanup(sock.close)
Antoine Pitrou9e0b8642010-09-14 18:00:02 +00001570 self.assertIsInstance(sock, socket.socket)
Guido van Rossum24e4af82002-06-12 19:18:08 +00001571 msg = sock.recv(1024)
Guido van Rossum76489682002-06-12 20:38:30 +00001572 self.assertEqual(msg, MSG)
Guido van Rossum24e4af82002-06-12 19:18:08 +00001573
1574 def _testFromFd(self):
1575 self.serv_conn.send(MSG)
1576
Guido van Rossum39eb8fa2007-11-16 01:24:05 +00001577 def testDup(self):
1578 # Testing dup()
1579 sock = self.cli_conn.dup()
Brian Curtin21ebbb72010-11-02 02:07:09 +00001580 self.addCleanup(sock.close)
Guido van Rossum39eb8fa2007-11-16 01:24:05 +00001581 msg = sock.recv(1024)
1582 self.assertEqual(msg, MSG)
1583
1584 def _testDup(self):
1585 self.serv_conn.send(MSG)
1586
Guido van Rossum24e4af82002-06-12 19:18:08 +00001587 def testShutdown(self):
Guido van Rossum8c943832002-08-08 01:00:28 +00001588 # Testing shutdown()
Guido van Rossum24e4af82002-06-12 19:18:08 +00001589 msg = self.cli_conn.recv(1024)
Guido van Rossum76489682002-06-12 20:38:30 +00001590 self.assertEqual(msg, MSG)
Mark Dickinson29500f62009-01-15 15:36:10 +00001591 # wait for _testShutdown to finish: on OS X, when the server
1592 # closes the connection the client also becomes disconnected,
1593 # and the client's shutdown call will fail. (Issue #4397.)
1594 self.done.wait()
Guido van Rossum24e4af82002-06-12 19:18:08 +00001595
1596 def _testShutdown(self):
1597 self.serv_conn.send(MSG)
Serhiy Storchaka5cfc79d2014-02-07 10:06:39 +02001598 self.serv_conn.shutdown(2)
1599
1600 testShutdown_overflow = support.cpython_only(testShutdown)
1601
1602 @support.cpython_only
1603 def _testShutdown_overflow(self):
1604 import _testcapi
1605 self.serv_conn.send(MSG)
Serhiy Storchaka441d30f2013-01-19 12:26:26 +02001606 # Issue 15989
1607 self.assertRaises(OverflowError, self.serv_conn.shutdown,
1608 _testcapi.INT_MAX + 1)
1609 self.assertRaises(OverflowError, self.serv_conn.shutdown,
1610 2 + (_testcapi.UINT_MAX + 1))
Guido van Rossum24e4af82002-06-12 19:18:08 +00001611 self.serv_conn.shutdown(2)
1612
Antoine Pitrou6e451df2010-08-09 20:39:54 +00001613 def testDetach(self):
1614 # Testing detach()
1615 fileno = self.cli_conn.fileno()
1616 f = self.cli_conn.detach()
1617 self.assertEqual(f, fileno)
1618 # cli_conn cannot be used anymore...
Antoine Pitrou70deb3d2012-04-01 01:00:17 +02001619 self.assertTrue(self.cli_conn._closed)
Antoine Pitroue43f9d02010-08-08 23:24:50 +00001620 self.assertRaises(socket.error, self.cli_conn.recv, 1024)
1621 self.cli_conn.close()
Antoine Pitrou6e451df2010-08-09 20:39:54 +00001622 # ...but we can create another socket using the (still open)
1623 # file descriptor
Antoine Pitroue43f9d02010-08-08 23:24:50 +00001624 sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM, fileno=f)
Brian Curtin21ebbb72010-11-02 02:07:09 +00001625 self.addCleanup(sock.close)
Antoine Pitroue43f9d02010-08-08 23:24:50 +00001626 msg = sock.recv(1024)
1627 self.assertEqual(msg, MSG)
1628
Antoine Pitrou6e451df2010-08-09 20:39:54 +00001629 def _testDetach(self):
Antoine Pitroue43f9d02010-08-08 23:24:50 +00001630 self.serv_conn.send(MSG)
1631
Victor Stinner45df8202010-04-28 22:31:17 +00001632@unittest.skipUnless(thread, 'Threading required for this test.')
Guido van Rossum24e4af82002-06-12 19:18:08 +00001633class BasicUDPTest(ThreadedUDPSocketTest):
1634
1635 def __init__(self, methodName='runTest'):
1636 ThreadedUDPSocketTest.__init__(self, methodName=methodName)
1637
1638 def testSendtoAndRecv(self):
Guido van Rossum8c943832002-08-08 01:00:28 +00001639 # Testing sendto() and Recv() over UDP
Guido van Rossum24e4af82002-06-12 19:18:08 +00001640 msg = self.serv.recv(len(MSG))
Guido van Rossum76489682002-06-12 20:38:30 +00001641 self.assertEqual(msg, MSG)
Guido van Rossum24e4af82002-06-12 19:18:08 +00001642
1643 def _testSendtoAndRecv(self):
Christian Heimes5e696852008-04-09 08:37:03 +00001644 self.cli.sendto(MSG, 0, (HOST, self.port))
Guido van Rossum24e4af82002-06-12 19:18:08 +00001645
Guido van Rossum1c938012002-06-12 21:17:20 +00001646 def testRecvFrom(self):
Guido van Rossum8c943832002-08-08 01:00:28 +00001647 # Testing recvfrom() over UDP
Guido van Rossum24e4af82002-06-12 19:18:08 +00001648 msg, addr = self.serv.recvfrom(len(MSG))
Guido van Rossum76489682002-06-12 20:38:30 +00001649 self.assertEqual(msg, MSG)
Guido van Rossum24e4af82002-06-12 19:18:08 +00001650
Guido van Rossum1c938012002-06-12 21:17:20 +00001651 def _testRecvFrom(self):
Christian Heimes5e696852008-04-09 08:37:03 +00001652 self.cli.sendto(MSG, 0, (HOST, self.port))
Guido van Rossum24e4af82002-06-12 19:18:08 +00001653
Guido van Rossumd8faa362007-04-27 19:54:29 +00001654 def testRecvFromNegative(self):
1655 # Negative lengths passed to recvfrom should give ValueError.
1656 self.assertRaises(ValueError, self.serv.recvfrom, -1)
1657
1658 def _testRecvFromNegative(self):
Christian Heimes5e696852008-04-09 08:37:03 +00001659 self.cli.sendto(MSG, 0, (HOST, self.port))
Guido van Rossumd8faa362007-04-27 19:54:29 +00001660
Nick Coghlan96fe56a2011-08-22 11:55:57 +10001661# Tests for the sendmsg()/recvmsg() interface. Where possible, the
1662# same test code is used with different families and types of socket
1663# (e.g. stream, datagram), and tests using recvmsg() are repeated
1664# using recvmsg_into().
1665#
1666# The generic test classes such as SendmsgTests and
1667# RecvmsgGenericTests inherit from SendrecvmsgBase and expect to be
1668# supplied with sockets cli_sock and serv_sock representing the
1669# client's and the server's end of the connection respectively, and
1670# attributes cli_addr and serv_addr holding their (numeric where
1671# appropriate) addresses.
1672#
1673# The final concrete test classes combine these with subclasses of
1674# SocketTestBase which set up client and server sockets of a specific
1675# type, and with subclasses of SendrecvmsgBase such as
1676# SendrecvmsgDgramBase and SendrecvmsgConnectedBase which map these
1677# sockets to cli_sock and serv_sock and override the methods and
1678# attributes of SendrecvmsgBase to fill in destination addresses if
1679# needed when sending, check for specific flags in msg_flags, etc.
1680#
1681# RecvmsgIntoMixin provides a version of doRecvmsg() implemented using
1682# recvmsg_into().
1683
1684# XXX: like the other datagram (UDP) tests in this module, the code
1685# here assumes that datagram delivery on the local machine will be
1686# reliable.
1687
1688class SendrecvmsgBase(ThreadSafeCleanupTestCase):
1689 # Base class for sendmsg()/recvmsg() tests.
1690
1691 # Time in seconds to wait before considering a test failed, or
1692 # None for no timeout. Not all tests actually set a timeout.
1693 fail_timeout = 3.0
1694
1695 def setUp(self):
1696 self.misc_event = threading.Event()
1697 super().setUp()
1698
1699 def sendToServer(self, msg):
1700 # Send msg to the server.
1701 return self.cli_sock.send(msg)
1702
1703 # Tuple of alternative default arguments for sendmsg() when called
1704 # via sendmsgToServer() (e.g. to include a destination address).
1705 sendmsg_to_server_defaults = ()
1706
1707 def sendmsgToServer(self, *args):
1708 # Call sendmsg() on self.cli_sock with the given arguments,
1709 # filling in any arguments which are not supplied with the
1710 # corresponding items of self.sendmsg_to_server_defaults, if
1711 # any.
1712 return self.cli_sock.sendmsg(
1713 *(args + self.sendmsg_to_server_defaults[len(args):]))
1714
1715 def doRecvmsg(self, sock, bufsize, *args):
1716 # Call recvmsg() on sock with given arguments and return its
1717 # result. Should be used for tests which can use either
1718 # recvmsg() or recvmsg_into() - RecvmsgIntoMixin overrides
1719 # this method with one which emulates it using recvmsg_into(),
1720 # thus allowing the same test to be used for both methods.
1721 result = sock.recvmsg(bufsize, *args)
1722 self.registerRecvmsgResult(result)
1723 return result
1724
1725 def registerRecvmsgResult(self, result):
1726 # Called by doRecvmsg() with the return value of recvmsg() or
1727 # recvmsg_into(). Can be overridden to arrange cleanup based
1728 # on the returned ancillary data, for instance.
1729 pass
1730
1731 def checkRecvmsgAddress(self, addr1, addr2):
1732 # Called to compare the received address with the address of
1733 # the peer.
1734 self.assertEqual(addr1, addr2)
1735
1736 # Flags that are normally unset in msg_flags
1737 msg_flags_common_unset = 0
1738 for name in ("MSG_CTRUNC", "MSG_OOB"):
1739 msg_flags_common_unset |= getattr(socket, name, 0)
1740
1741 # Flags that are normally set
1742 msg_flags_common_set = 0
1743
1744 # Flags set when a complete record has been received (e.g. MSG_EOR
1745 # for SCTP)
1746 msg_flags_eor_indicator = 0
1747
1748 # Flags set when a complete record has not been received
1749 # (e.g. MSG_TRUNC for datagram sockets)
1750 msg_flags_non_eor_indicator = 0
1751
1752 def checkFlags(self, flags, eor=None, checkset=0, checkunset=0, ignore=0):
1753 # Method to check the value of msg_flags returned by recvmsg[_into]().
1754 #
1755 # Checks that all bits in msg_flags_common_set attribute are
1756 # set in "flags" and all bits in msg_flags_common_unset are
1757 # unset.
1758 #
1759 # The "eor" argument specifies whether the flags should
1760 # indicate that a full record (or datagram) has been received.
1761 # If "eor" is None, no checks are done; otherwise, checks
1762 # that:
1763 #
1764 # * if "eor" is true, all bits in msg_flags_eor_indicator are
1765 # set and all bits in msg_flags_non_eor_indicator are unset
1766 #
1767 # * if "eor" is false, all bits in msg_flags_non_eor_indicator
1768 # are set and all bits in msg_flags_eor_indicator are unset
1769 #
1770 # If "checkset" and/or "checkunset" are supplied, they require
1771 # the given bits to be set or unset respectively, overriding
1772 # what the attributes require for those bits.
1773 #
1774 # If any bits are set in "ignore", they will not be checked,
1775 # regardless of the other inputs.
1776 #
1777 # Will raise Exception if the inputs require a bit to be both
1778 # set and unset, and it is not ignored.
1779
1780 defaultset = self.msg_flags_common_set
1781 defaultunset = self.msg_flags_common_unset
1782
1783 if eor:
1784 defaultset |= self.msg_flags_eor_indicator
1785 defaultunset |= self.msg_flags_non_eor_indicator
1786 elif eor is not None:
1787 defaultset |= self.msg_flags_non_eor_indicator
1788 defaultunset |= self.msg_flags_eor_indicator
1789
1790 # Function arguments override defaults
1791 defaultset &= ~checkunset
1792 defaultunset &= ~checkset
1793
1794 # Merge arguments with remaining defaults, and check for conflicts
1795 checkset |= defaultset
1796 checkunset |= defaultunset
1797 inboth = checkset & checkunset & ~ignore
1798 if inboth:
1799 raise Exception("contradictory set, unset requirements for flags "
1800 "{0:#x}".format(inboth))
1801
1802 # Compare with given msg_flags value
1803 mask = (checkset | checkunset) & ~ignore
1804 self.assertEqual(flags & mask, checkset & mask)
1805
1806
1807class RecvmsgIntoMixin(SendrecvmsgBase):
1808 # Mixin to implement doRecvmsg() using recvmsg_into().
1809
1810 def doRecvmsg(self, sock, bufsize, *args):
1811 buf = bytearray(bufsize)
1812 result = sock.recvmsg_into([buf], *args)
1813 self.registerRecvmsgResult(result)
1814 self.assertGreaterEqual(result[0], 0)
1815 self.assertLessEqual(result[0], bufsize)
1816 return (bytes(buf[:result[0]]),) + result[1:]
1817
1818
1819class SendrecvmsgDgramFlagsBase(SendrecvmsgBase):
1820 # Defines flags to be checked in msg_flags for datagram sockets.
1821
1822 @property
1823 def msg_flags_non_eor_indicator(self):
1824 return super().msg_flags_non_eor_indicator | socket.MSG_TRUNC
1825
1826
1827class SendrecvmsgSCTPFlagsBase(SendrecvmsgBase):
1828 # Defines flags to be checked in msg_flags for SCTP sockets.
1829
1830 @property
1831 def msg_flags_eor_indicator(self):
1832 return super().msg_flags_eor_indicator | socket.MSG_EOR
1833
1834
1835class SendrecvmsgConnectionlessBase(SendrecvmsgBase):
1836 # Base class for tests on connectionless-mode sockets. Users must
1837 # supply sockets on attributes cli and serv to be mapped to
1838 # cli_sock and serv_sock respectively.
1839
1840 @property
1841 def serv_sock(self):
1842 return self.serv
1843
1844 @property
1845 def cli_sock(self):
1846 return self.cli
1847
1848 @property
1849 def sendmsg_to_server_defaults(self):
1850 return ([], [], 0, self.serv_addr)
1851
1852 def sendToServer(self, msg):
1853 return self.cli_sock.sendto(msg, self.serv_addr)
1854
1855
1856class SendrecvmsgConnectedBase(SendrecvmsgBase):
1857 # Base class for tests on connected sockets. Users must supply
1858 # sockets on attributes serv_conn and cli_conn (representing the
1859 # connections *to* the server and the client), to be mapped to
1860 # cli_sock and serv_sock respectively.
1861
1862 @property
1863 def serv_sock(self):
1864 return self.cli_conn
1865
1866 @property
1867 def cli_sock(self):
1868 return self.serv_conn
1869
1870 def checkRecvmsgAddress(self, addr1, addr2):
1871 # Address is currently "unspecified" for a connected socket,
1872 # so we don't examine it
1873 pass
1874
1875
1876class SendrecvmsgServerTimeoutBase(SendrecvmsgBase):
1877 # Base class to set a timeout on server's socket.
1878
1879 def setUp(self):
1880 super().setUp()
1881 self.serv_sock.settimeout(self.fail_timeout)
1882
1883
1884class SendmsgTests(SendrecvmsgServerTimeoutBase):
1885 # Tests for sendmsg() which can use any socket type and do not
1886 # involve recvmsg() or recvmsg_into().
1887
1888 def testSendmsg(self):
1889 # Send a simple message with sendmsg().
1890 self.assertEqual(self.serv_sock.recv(len(MSG)), MSG)
1891
1892 def _testSendmsg(self):
1893 self.assertEqual(self.sendmsgToServer([MSG]), len(MSG))
1894
1895 def testSendmsgDataGenerator(self):
1896 # Send from buffer obtained from a generator (not a sequence).
1897 self.assertEqual(self.serv_sock.recv(len(MSG)), MSG)
1898
1899 def _testSendmsgDataGenerator(self):
1900 self.assertEqual(self.sendmsgToServer((o for o in [MSG])),
1901 len(MSG))
1902
1903 def testSendmsgAncillaryGenerator(self):
1904 # Gather (empty) ancillary data from a generator.
1905 self.assertEqual(self.serv_sock.recv(len(MSG)), MSG)
1906
1907 def _testSendmsgAncillaryGenerator(self):
1908 self.assertEqual(self.sendmsgToServer([MSG], (o for o in [])),
1909 len(MSG))
1910
1911 def testSendmsgArray(self):
1912 # Send data from an array instead of the usual bytes object.
1913 self.assertEqual(self.serv_sock.recv(len(MSG)), MSG)
1914
1915 def _testSendmsgArray(self):
1916 self.assertEqual(self.sendmsgToServer([array.array("B", MSG)]),
1917 len(MSG))
1918
1919 def testSendmsgGather(self):
1920 # Send message data from more than one buffer (gather write).
1921 self.assertEqual(self.serv_sock.recv(len(MSG)), MSG)
1922
1923 def _testSendmsgGather(self):
1924 self.assertEqual(self.sendmsgToServer([MSG[:3], MSG[3:]]), len(MSG))
1925
1926 def testSendmsgBadArgs(self):
1927 # Check that sendmsg() rejects invalid arguments.
1928 self.assertEqual(self.serv_sock.recv(1000), b"done")
1929
1930 def _testSendmsgBadArgs(self):
1931 self.assertRaises(TypeError, self.cli_sock.sendmsg)
1932 self.assertRaises(TypeError, self.sendmsgToServer,
1933 b"not in an iterable")
1934 self.assertRaises(TypeError, self.sendmsgToServer,
1935 object())
1936 self.assertRaises(TypeError, self.sendmsgToServer,
1937 [object()])
1938 self.assertRaises(TypeError, self.sendmsgToServer,
1939 [MSG, object()])
1940 self.assertRaises(TypeError, self.sendmsgToServer,
1941 [MSG], object())
1942 self.assertRaises(TypeError, self.sendmsgToServer,
1943 [MSG], [], object())
1944 self.assertRaises(TypeError, self.sendmsgToServer,
1945 [MSG], [], 0, object())
1946 self.sendToServer(b"done")
1947
1948 def testSendmsgBadCmsg(self):
1949 # Check that invalid ancillary data items are rejected.
1950 self.assertEqual(self.serv_sock.recv(1000), b"done")
1951
1952 def _testSendmsgBadCmsg(self):
1953 self.assertRaises(TypeError, self.sendmsgToServer,
1954 [MSG], [object()])
1955 self.assertRaises(TypeError, self.sendmsgToServer,
1956 [MSG], [(object(), 0, b"data")])
1957 self.assertRaises(TypeError, self.sendmsgToServer,
1958 [MSG], [(0, object(), b"data")])
1959 self.assertRaises(TypeError, self.sendmsgToServer,
1960 [MSG], [(0, 0, object())])
1961 self.assertRaises(TypeError, self.sendmsgToServer,
1962 [MSG], [(0, 0)])
1963 self.assertRaises(TypeError, self.sendmsgToServer,
1964 [MSG], [(0, 0, b"data", 42)])
1965 self.sendToServer(b"done")
1966
1967 @requireAttrs(socket, "CMSG_SPACE")
1968 def testSendmsgBadMultiCmsg(self):
1969 # Check that invalid ancillary data items are rejected when
1970 # more than one item is present.
1971 self.assertEqual(self.serv_sock.recv(1000), b"done")
1972
1973 @testSendmsgBadMultiCmsg.client_skip
1974 def _testSendmsgBadMultiCmsg(self):
1975 self.assertRaises(TypeError, self.sendmsgToServer,
1976 [MSG], [0, 0, b""])
1977 self.assertRaises(TypeError, self.sendmsgToServer,
1978 [MSG], [(0, 0, b""), object()])
1979 self.sendToServer(b"done")
1980
1981 def testSendmsgExcessCmsgReject(self):
1982 # Check that sendmsg() rejects excess ancillary data items
1983 # when the number that can be sent is limited.
1984 self.assertEqual(self.serv_sock.recv(1000), b"done")
1985
1986 def _testSendmsgExcessCmsgReject(self):
1987 if not hasattr(socket, "CMSG_SPACE"):
1988 # Can only send one item
1989 with self.assertRaises(socket.error) as cm:
1990 self.sendmsgToServer([MSG], [(0, 0, b""), (0, 0, b"")])
1991 self.assertIsNone(cm.exception.errno)
1992 self.sendToServer(b"done")
1993
1994 def testSendmsgAfterClose(self):
1995 # Check that sendmsg() fails on a closed socket.
1996 pass
1997
1998 def _testSendmsgAfterClose(self):
1999 self.cli_sock.close()
2000 self.assertRaises(socket.error, self.sendmsgToServer, [MSG])
2001
2002
2003class SendmsgStreamTests(SendmsgTests):
2004 # Tests for sendmsg() which require a stream socket and do not
2005 # involve recvmsg() or recvmsg_into().
2006
2007 def testSendmsgExplicitNoneAddr(self):
2008 # Check that peer address can be specified as None.
2009 self.assertEqual(self.serv_sock.recv(len(MSG)), MSG)
2010
2011 def _testSendmsgExplicitNoneAddr(self):
2012 self.assertEqual(self.sendmsgToServer([MSG], [], 0, None), len(MSG))
2013
2014 def testSendmsgTimeout(self):
2015 # Check that timeout works with sendmsg().
2016 self.assertEqual(self.serv_sock.recv(512), b"a"*512)
2017 self.assertTrue(self.misc_event.wait(timeout=self.fail_timeout))
2018
2019 def _testSendmsgTimeout(self):
2020 try:
2021 self.cli_sock.settimeout(0.03)
2022 with self.assertRaises(socket.timeout):
2023 while True:
2024 self.sendmsgToServer([b"a"*512])
2025 finally:
2026 self.misc_event.set()
2027
2028 # XXX: would be nice to have more tests for sendmsg flags argument.
2029
2030 # Linux supports MSG_DONTWAIT when sending, but in general, it
2031 # only works when receiving. Could add other platforms if they
2032 # support it too.
2033 @skipWithClientIf(sys.platform not in {"linux2"},
2034 "MSG_DONTWAIT not known to work on this platform when "
2035 "sending")
2036 def testSendmsgDontWait(self):
2037 # Check that MSG_DONTWAIT in flags causes non-blocking behaviour.
2038 self.assertEqual(self.serv_sock.recv(512), b"a"*512)
2039 self.assertTrue(self.misc_event.wait(timeout=self.fail_timeout))
2040
2041 @testSendmsgDontWait.client_skip
2042 def _testSendmsgDontWait(self):
2043 try:
2044 with self.assertRaises(socket.error) as cm:
2045 while True:
2046 self.sendmsgToServer([b"a"*512], [], socket.MSG_DONTWAIT)
2047 self.assertIn(cm.exception.errno,
2048 (errno.EAGAIN, errno.EWOULDBLOCK))
2049 finally:
2050 self.misc_event.set()
2051
2052
2053class SendmsgConnectionlessTests(SendmsgTests):
2054 # Tests for sendmsg() which require a connectionless-mode
2055 # (e.g. datagram) socket, and do not involve recvmsg() or
2056 # recvmsg_into().
2057
2058 def testSendmsgNoDestAddr(self):
2059 # Check that sendmsg() fails when no destination address is
2060 # given for unconnected socket.
2061 pass
2062
2063 def _testSendmsgNoDestAddr(self):
2064 self.assertRaises(socket.error, self.cli_sock.sendmsg,
2065 [MSG])
2066 self.assertRaises(socket.error, self.cli_sock.sendmsg,
2067 [MSG], [], 0, None)
2068
2069
2070class RecvmsgGenericTests(SendrecvmsgBase):
2071 # Tests for recvmsg() which can also be emulated using
2072 # recvmsg_into(), and can use any socket type.
2073
2074 def testRecvmsg(self):
2075 # Receive a simple message with recvmsg[_into]().
2076 msg, ancdata, flags, addr = self.doRecvmsg(self.serv_sock, len(MSG))
2077 self.assertEqual(msg, MSG)
2078 self.checkRecvmsgAddress(addr, self.cli_addr)
2079 self.assertEqual(ancdata, [])
2080 self.checkFlags(flags, eor=True)
2081
2082 def _testRecvmsg(self):
2083 self.sendToServer(MSG)
2084
2085 def testRecvmsgExplicitDefaults(self):
2086 # Test recvmsg[_into]() with default arguments provided explicitly.
2087 msg, ancdata, flags, addr = self.doRecvmsg(self.serv_sock,
2088 len(MSG), 0, 0)
2089 self.assertEqual(msg, MSG)
2090 self.checkRecvmsgAddress(addr, self.cli_addr)
2091 self.assertEqual(ancdata, [])
2092 self.checkFlags(flags, eor=True)
2093
2094 def _testRecvmsgExplicitDefaults(self):
2095 self.sendToServer(MSG)
2096
2097 def testRecvmsgShorter(self):
2098 # Receive a message smaller than buffer.
2099 msg, ancdata, flags, addr = self.doRecvmsg(self.serv_sock,
2100 len(MSG) + 42)
2101 self.assertEqual(msg, MSG)
2102 self.checkRecvmsgAddress(addr, self.cli_addr)
2103 self.assertEqual(ancdata, [])
2104 self.checkFlags(flags, eor=True)
2105
2106 def _testRecvmsgShorter(self):
2107 self.sendToServer(MSG)
2108
Charles-François Natali8619cd72011-10-03 19:43:15 +02002109 # FreeBSD < 8 doesn't always set the MSG_TRUNC flag when a truncated
2110 # datagram is received (issue #13001).
2111 @support.requires_freebsd_version(8)
Nick Coghlan96fe56a2011-08-22 11:55:57 +10002112 def testRecvmsgTrunc(self):
2113 # Receive part of message, check for truncation indicators.
2114 msg, ancdata, flags, addr = self.doRecvmsg(self.serv_sock,
2115 len(MSG) - 3)
2116 self.assertEqual(msg, MSG[:-3])
2117 self.checkRecvmsgAddress(addr, self.cli_addr)
2118 self.assertEqual(ancdata, [])
2119 self.checkFlags(flags, eor=False)
2120
Charles-François Natali8619cd72011-10-03 19:43:15 +02002121 @support.requires_freebsd_version(8)
Nick Coghlan96fe56a2011-08-22 11:55:57 +10002122 def _testRecvmsgTrunc(self):
2123 self.sendToServer(MSG)
2124
2125 def testRecvmsgShortAncillaryBuf(self):
2126 # Test ancillary data buffer too small to hold any ancillary data.
2127 msg, ancdata, flags, addr = self.doRecvmsg(self.serv_sock,
2128 len(MSG), 1)
2129 self.assertEqual(msg, MSG)
2130 self.checkRecvmsgAddress(addr, self.cli_addr)
2131 self.assertEqual(ancdata, [])
2132 self.checkFlags(flags, eor=True)
2133
2134 def _testRecvmsgShortAncillaryBuf(self):
2135 self.sendToServer(MSG)
2136
2137 def testRecvmsgLongAncillaryBuf(self):
2138 # Test large ancillary data buffer.
2139 msg, ancdata, flags, addr = self.doRecvmsg(self.serv_sock,
2140 len(MSG), 10240)
2141 self.assertEqual(msg, MSG)
2142 self.checkRecvmsgAddress(addr, self.cli_addr)
2143 self.assertEqual(ancdata, [])
2144 self.checkFlags(flags, eor=True)
2145
2146 def _testRecvmsgLongAncillaryBuf(self):
2147 self.sendToServer(MSG)
2148
2149 def testRecvmsgAfterClose(self):
2150 # Check that recvmsg[_into]() fails on a closed socket.
2151 self.serv_sock.close()
2152 self.assertRaises(socket.error, self.doRecvmsg, self.serv_sock, 1024)
2153
2154 def _testRecvmsgAfterClose(self):
2155 pass
2156
2157 def testRecvmsgTimeout(self):
2158 # Check that timeout works.
2159 try:
2160 self.serv_sock.settimeout(0.03)
2161 self.assertRaises(socket.timeout,
2162 self.doRecvmsg, self.serv_sock, len(MSG))
2163 finally:
2164 self.misc_event.set()
2165
2166 def _testRecvmsgTimeout(self):
2167 self.assertTrue(self.misc_event.wait(timeout=self.fail_timeout))
2168
2169 @requireAttrs(socket, "MSG_PEEK")
2170 def testRecvmsgPeek(self):
2171 # Check that MSG_PEEK in flags enables examination of pending
2172 # data without consuming it.
2173
2174 # Receive part of data with MSG_PEEK.
2175 msg, ancdata, flags, addr = self.doRecvmsg(self.serv_sock,
2176 len(MSG) - 3, 0,
2177 socket.MSG_PEEK)
2178 self.assertEqual(msg, MSG[:-3])
2179 self.checkRecvmsgAddress(addr, self.cli_addr)
2180 self.assertEqual(ancdata, [])
2181 # Ignoring MSG_TRUNC here (so this test is the same for stream
2182 # and datagram sockets). Some wording in POSIX seems to
2183 # suggest that it needn't be set when peeking, but that may
2184 # just be a slip.
2185 self.checkFlags(flags, eor=False,
2186 ignore=getattr(socket, "MSG_TRUNC", 0))
2187
2188 # Receive all data with MSG_PEEK.
2189 msg, ancdata, flags, addr = self.doRecvmsg(self.serv_sock,
2190 len(MSG), 0,
2191 socket.MSG_PEEK)
2192 self.assertEqual(msg, MSG)
2193 self.checkRecvmsgAddress(addr, self.cli_addr)
2194 self.assertEqual(ancdata, [])
2195 self.checkFlags(flags, eor=True)
2196
2197 # Check that the same data can still be received normally.
2198 msg, ancdata, flags, addr = self.doRecvmsg(self.serv_sock, len(MSG))
2199 self.assertEqual(msg, MSG)
2200 self.checkRecvmsgAddress(addr, self.cli_addr)
2201 self.assertEqual(ancdata, [])
2202 self.checkFlags(flags, eor=True)
2203
2204 @testRecvmsgPeek.client_skip
2205 def _testRecvmsgPeek(self):
2206 self.sendToServer(MSG)
2207
2208 @requireAttrs(socket.socket, "sendmsg")
2209 def testRecvmsgFromSendmsg(self):
2210 # Test receiving with recvmsg[_into]() when message is sent
2211 # using sendmsg().
2212 self.serv_sock.settimeout(self.fail_timeout)
2213 msg, ancdata, flags, addr = self.doRecvmsg(self.serv_sock, len(MSG))
2214 self.assertEqual(msg, MSG)
2215 self.checkRecvmsgAddress(addr, self.cli_addr)
2216 self.assertEqual(ancdata, [])
2217 self.checkFlags(flags, eor=True)
2218
2219 @testRecvmsgFromSendmsg.client_skip
2220 def _testRecvmsgFromSendmsg(self):
2221 self.assertEqual(self.sendmsgToServer([MSG[:3], MSG[3:]]), len(MSG))
2222
2223
2224class RecvmsgGenericStreamTests(RecvmsgGenericTests):
2225 # Tests which require a stream socket and can use either recvmsg()
2226 # or recvmsg_into().
2227
2228 def testRecvmsgEOF(self):
2229 # Receive end-of-stream indicator (b"", peer socket closed).
2230 msg, ancdata, flags, addr = self.doRecvmsg(self.serv_sock, 1024)
2231 self.assertEqual(msg, b"")
2232 self.checkRecvmsgAddress(addr, self.cli_addr)
2233 self.assertEqual(ancdata, [])
2234 self.checkFlags(flags, eor=None) # Might not have end-of-record marker
2235
2236 def _testRecvmsgEOF(self):
2237 self.cli_sock.close()
2238
2239 def testRecvmsgOverflow(self):
2240 # Receive a message in more than one chunk.
2241 seg1, ancdata, flags, addr = self.doRecvmsg(self.serv_sock,
2242 len(MSG) - 3)
2243 self.checkRecvmsgAddress(addr, self.cli_addr)
2244 self.assertEqual(ancdata, [])
2245 self.checkFlags(flags, eor=False)
2246
2247 seg2, ancdata, flags, addr = self.doRecvmsg(self.serv_sock, 1024)
2248 self.checkRecvmsgAddress(addr, self.cli_addr)
2249 self.assertEqual(ancdata, [])
2250 self.checkFlags(flags, eor=True)
2251
2252 msg = seg1 + seg2
2253 self.assertEqual(msg, MSG)
2254
2255 def _testRecvmsgOverflow(self):
2256 self.sendToServer(MSG)
2257
2258
2259class RecvmsgTests(RecvmsgGenericTests):
2260 # Tests for recvmsg() which can use any socket type.
2261
2262 def testRecvmsgBadArgs(self):
2263 # Check that recvmsg() rejects invalid arguments.
2264 self.assertRaises(TypeError, self.serv_sock.recvmsg)
2265 self.assertRaises(ValueError, self.serv_sock.recvmsg,
2266 -1, 0, 0)
2267 self.assertRaises(ValueError, self.serv_sock.recvmsg,
2268 len(MSG), -1, 0)
2269 self.assertRaises(TypeError, self.serv_sock.recvmsg,
2270 [bytearray(10)], 0, 0)
2271 self.assertRaises(TypeError, self.serv_sock.recvmsg,
2272 object(), 0, 0)
2273 self.assertRaises(TypeError, self.serv_sock.recvmsg,
2274 len(MSG), object(), 0)
2275 self.assertRaises(TypeError, self.serv_sock.recvmsg,
2276 len(MSG), 0, object())
2277
2278 msg, ancdata, flags, addr = self.serv_sock.recvmsg(len(MSG), 0, 0)
2279 self.assertEqual(msg, MSG)
2280 self.checkRecvmsgAddress(addr, self.cli_addr)
2281 self.assertEqual(ancdata, [])
2282 self.checkFlags(flags, eor=True)
2283
2284 def _testRecvmsgBadArgs(self):
2285 self.sendToServer(MSG)
2286
2287
2288class RecvmsgIntoTests(RecvmsgIntoMixin, RecvmsgGenericTests):
2289 # Tests for recvmsg_into() which can use any socket type.
2290
2291 def testRecvmsgIntoBadArgs(self):
2292 # Check that recvmsg_into() rejects invalid arguments.
2293 buf = bytearray(len(MSG))
2294 self.assertRaises(TypeError, self.serv_sock.recvmsg_into)
2295 self.assertRaises(TypeError, self.serv_sock.recvmsg_into,
2296 len(MSG), 0, 0)
2297 self.assertRaises(TypeError, self.serv_sock.recvmsg_into,
2298 buf, 0, 0)
2299 self.assertRaises(TypeError, self.serv_sock.recvmsg_into,
2300 [object()], 0, 0)
2301 self.assertRaises(TypeError, self.serv_sock.recvmsg_into,
2302 [b"I'm not writable"], 0, 0)
2303 self.assertRaises(TypeError, self.serv_sock.recvmsg_into,
2304 [buf, object()], 0, 0)
2305 self.assertRaises(ValueError, self.serv_sock.recvmsg_into,
2306 [buf], -1, 0)
2307 self.assertRaises(TypeError, self.serv_sock.recvmsg_into,
2308 [buf], object(), 0)
2309 self.assertRaises(TypeError, self.serv_sock.recvmsg_into,
2310 [buf], 0, object())
2311
2312 nbytes, ancdata, flags, addr = self.serv_sock.recvmsg_into([buf], 0, 0)
2313 self.assertEqual(nbytes, len(MSG))
2314 self.assertEqual(buf, bytearray(MSG))
2315 self.checkRecvmsgAddress(addr, self.cli_addr)
2316 self.assertEqual(ancdata, [])
2317 self.checkFlags(flags, eor=True)
2318
2319 def _testRecvmsgIntoBadArgs(self):
2320 self.sendToServer(MSG)
2321
2322 def testRecvmsgIntoGenerator(self):
2323 # Receive into buffer obtained from a generator (not a sequence).
2324 buf = bytearray(len(MSG))
2325 nbytes, ancdata, flags, addr = self.serv_sock.recvmsg_into(
2326 (o for o in [buf]))
2327 self.assertEqual(nbytes, len(MSG))
2328 self.assertEqual(buf, bytearray(MSG))
2329 self.checkRecvmsgAddress(addr, self.cli_addr)
2330 self.assertEqual(ancdata, [])
2331 self.checkFlags(flags, eor=True)
2332
2333 def _testRecvmsgIntoGenerator(self):
2334 self.sendToServer(MSG)
2335
2336 def testRecvmsgIntoArray(self):
2337 # Receive into an array rather than the usual bytearray.
2338 buf = array.array("B", [0] * len(MSG))
2339 nbytes, ancdata, flags, addr = self.serv_sock.recvmsg_into([buf])
2340 self.assertEqual(nbytes, len(MSG))
Nadeem Vawda3d1706f2011-08-22 09:46:56 +02002341 self.assertEqual(buf.tobytes(), MSG)
Nick Coghlan96fe56a2011-08-22 11:55:57 +10002342 self.checkRecvmsgAddress(addr, self.cli_addr)
2343 self.assertEqual(ancdata, [])
2344 self.checkFlags(flags, eor=True)
2345
2346 def _testRecvmsgIntoArray(self):
2347 self.sendToServer(MSG)
2348
2349 def testRecvmsgIntoScatter(self):
2350 # Receive into multiple buffers (scatter write).
2351 b1 = bytearray(b"----")
2352 b2 = bytearray(b"0123456789")
2353 b3 = bytearray(b"--------------")
2354 nbytes, ancdata, flags, addr = self.serv_sock.recvmsg_into(
2355 [b1, memoryview(b2)[2:9], b3])
2356 self.assertEqual(nbytes, len(b"Mary had a little lamb"))
2357 self.assertEqual(b1, bytearray(b"Mary"))
2358 self.assertEqual(b2, bytearray(b"01 had a 9"))
2359 self.assertEqual(b3, bytearray(b"little lamb---"))
2360 self.checkRecvmsgAddress(addr, self.cli_addr)
2361 self.assertEqual(ancdata, [])
2362 self.checkFlags(flags, eor=True)
2363
2364 def _testRecvmsgIntoScatter(self):
2365 self.sendToServer(b"Mary had a little lamb")
2366
2367
2368class CmsgMacroTests(unittest.TestCase):
2369 # Test the functions CMSG_LEN() and CMSG_SPACE(). Tests
2370 # assumptions used by sendmsg() and recvmsg[_into](), which share
2371 # code with these functions.
2372
2373 # Match the definition in socketmodule.c
Serhiy Storchaka5cfc79d2014-02-07 10:06:39 +02002374 try:
2375 import _testcapi
2376 except ImportError:
2377 socklen_t_limit = 0x7fffffff
2378 else:
2379 socklen_t_limit = min(0x7fffffff, _testcapi.INT_MAX)
Nick Coghlan96fe56a2011-08-22 11:55:57 +10002380
2381 @requireAttrs(socket, "CMSG_LEN")
2382 def testCMSG_LEN(self):
2383 # Test CMSG_LEN() with various valid and invalid values,
2384 # checking the assumptions used by recvmsg() and sendmsg().
2385 toobig = self.socklen_t_limit - socket.CMSG_LEN(0) + 1
2386 values = list(range(257)) + list(range(toobig - 257, toobig))
2387
2388 # struct cmsghdr has at least three members, two of which are ints
2389 self.assertGreater(socket.CMSG_LEN(0), array.array("i").itemsize * 2)
2390 for n in values:
2391 ret = socket.CMSG_LEN(n)
2392 # This is how recvmsg() calculates the data size
2393 self.assertEqual(ret - socket.CMSG_LEN(0), n)
2394 self.assertLessEqual(ret, self.socklen_t_limit)
2395
2396 self.assertRaises(OverflowError, socket.CMSG_LEN, -1)
2397 # sendmsg() shares code with these functions, and requires
2398 # that it reject values over the limit.
2399 self.assertRaises(OverflowError, socket.CMSG_LEN, toobig)
2400 self.assertRaises(OverflowError, socket.CMSG_LEN, sys.maxsize)
2401
2402 @requireAttrs(socket, "CMSG_SPACE")
2403 def testCMSG_SPACE(self):
2404 # Test CMSG_SPACE() with various valid and invalid values,
2405 # checking the assumptions used by sendmsg().
2406 toobig = self.socklen_t_limit - socket.CMSG_SPACE(1) + 1
2407 values = list(range(257)) + list(range(toobig - 257, toobig))
2408
2409 last = socket.CMSG_SPACE(0)
2410 # struct cmsghdr has at least three members, two of which are ints
2411 self.assertGreater(last, array.array("i").itemsize * 2)
2412 for n in values:
2413 ret = socket.CMSG_SPACE(n)
2414 self.assertGreaterEqual(ret, last)
2415 self.assertGreaterEqual(ret, socket.CMSG_LEN(n))
2416 self.assertGreaterEqual(ret, n + socket.CMSG_LEN(0))
2417 self.assertLessEqual(ret, self.socklen_t_limit)
2418 last = ret
2419
2420 self.assertRaises(OverflowError, socket.CMSG_SPACE, -1)
2421 # sendmsg() shares code with these functions, and requires
2422 # that it reject values over the limit.
2423 self.assertRaises(OverflowError, socket.CMSG_SPACE, toobig)
2424 self.assertRaises(OverflowError, socket.CMSG_SPACE, sys.maxsize)
2425
2426
2427class SCMRightsTest(SendrecvmsgServerTimeoutBase):
2428 # Tests for file descriptor passing on Unix-domain sockets.
2429
2430 # Invalid file descriptor value that's unlikely to evaluate to a
2431 # real FD even if one of its bytes is replaced with a different
2432 # value (which shouldn't actually happen).
2433 badfd = -0x5555
2434
2435 def newFDs(self, n):
2436 # Return a list of n file descriptors for newly-created files
2437 # containing their list indices as ASCII numbers.
2438 fds = []
2439 for i in range(n):
2440 fd, path = tempfile.mkstemp()
2441 self.addCleanup(os.unlink, path)
2442 self.addCleanup(os.close, fd)
2443 os.write(fd, str(i).encode())
2444 fds.append(fd)
2445 return fds
2446
2447 def checkFDs(self, fds):
2448 # Check that the file descriptors in the given list contain
2449 # their correct list indices as ASCII numbers.
2450 for n, fd in enumerate(fds):
2451 os.lseek(fd, 0, os.SEEK_SET)
2452 self.assertEqual(os.read(fd, 1024), str(n).encode())
2453
2454 def registerRecvmsgResult(self, result):
2455 self.addCleanup(self.closeRecvmsgFDs, result)
2456
2457 def closeRecvmsgFDs(self, recvmsg_result):
2458 # Close all file descriptors specified in the ancillary data
2459 # of the given return value from recvmsg() or recvmsg_into().
2460 for cmsg_level, cmsg_type, cmsg_data in recvmsg_result[1]:
2461 if (cmsg_level == socket.SOL_SOCKET and
2462 cmsg_type == socket.SCM_RIGHTS):
2463 fds = array.array("i")
Nadeem Vawda3d1706f2011-08-22 09:46:56 +02002464 fds.frombytes(cmsg_data[:
Nick Coghlan96fe56a2011-08-22 11:55:57 +10002465 len(cmsg_data) - (len(cmsg_data) % fds.itemsize)])
2466 for fd in fds:
2467 os.close(fd)
2468
2469 def createAndSendFDs(self, n):
2470 # Send n new file descriptors created by newFDs() to the
2471 # server, with the constant MSG as the non-ancillary data.
2472 self.assertEqual(
2473 self.sendmsgToServer([MSG],
2474 [(socket.SOL_SOCKET,
2475 socket.SCM_RIGHTS,
2476 array.array("i", self.newFDs(n)))]),
2477 len(MSG))
2478
2479 def checkRecvmsgFDs(self, numfds, result, maxcmsgs=1, ignoreflags=0):
2480 # Check that constant MSG was received with numfds file
2481 # descriptors in a maximum of maxcmsgs control messages (which
2482 # must contain only complete integers). By default, check
2483 # that MSG_CTRUNC is unset, but ignore any flags in
2484 # ignoreflags.
2485 msg, ancdata, flags, addr = result
2486 self.assertEqual(msg, MSG)
2487 self.checkRecvmsgAddress(addr, self.cli_addr)
2488 self.checkFlags(flags, eor=True, checkunset=socket.MSG_CTRUNC,
2489 ignore=ignoreflags)
2490
2491 self.assertIsInstance(ancdata, list)
2492 self.assertLessEqual(len(ancdata), maxcmsgs)
2493 fds = array.array("i")
2494 for item in ancdata:
2495 self.assertIsInstance(item, tuple)
2496 cmsg_level, cmsg_type, cmsg_data = item
2497 self.assertEqual(cmsg_level, socket.SOL_SOCKET)
2498 self.assertEqual(cmsg_type, socket.SCM_RIGHTS)
2499 self.assertIsInstance(cmsg_data, bytes)
2500 self.assertEqual(len(cmsg_data) % SIZEOF_INT, 0)
Nadeem Vawda3d1706f2011-08-22 09:46:56 +02002501 fds.frombytes(cmsg_data)
Nick Coghlan96fe56a2011-08-22 11:55:57 +10002502
2503 self.assertEqual(len(fds), numfds)
2504 self.checkFDs(fds)
2505
2506 def testFDPassSimple(self):
2507 # Pass a single FD (array read from bytes object).
2508 self.checkRecvmsgFDs(1, self.doRecvmsg(self.serv_sock,
2509 len(MSG), 10240))
2510
2511 def _testFDPassSimple(self):
2512 self.assertEqual(
2513 self.sendmsgToServer(
2514 [MSG],
2515 [(socket.SOL_SOCKET,
2516 socket.SCM_RIGHTS,
Nadeem Vawda3d1706f2011-08-22 09:46:56 +02002517 array.array("i", self.newFDs(1)).tobytes())]),
Nick Coghlan96fe56a2011-08-22 11:55:57 +10002518 len(MSG))
2519
2520 def testMultipleFDPass(self):
2521 # Pass multiple FDs in a single array.
2522 self.checkRecvmsgFDs(4, self.doRecvmsg(self.serv_sock,
2523 len(MSG), 10240))
2524
2525 def _testMultipleFDPass(self):
2526 self.createAndSendFDs(4)
2527
2528 @requireAttrs(socket, "CMSG_SPACE")
2529 def testFDPassCMSG_SPACE(self):
2530 # Test using CMSG_SPACE() to calculate ancillary buffer size.
2531 self.checkRecvmsgFDs(
2532 4, self.doRecvmsg(self.serv_sock, len(MSG),
2533 socket.CMSG_SPACE(4 * SIZEOF_INT)))
2534
2535 @testFDPassCMSG_SPACE.client_skip
2536 def _testFDPassCMSG_SPACE(self):
2537 self.createAndSendFDs(4)
2538
2539 def testFDPassCMSG_LEN(self):
2540 # Test using CMSG_LEN() to calculate ancillary buffer size.
2541 self.checkRecvmsgFDs(1,
2542 self.doRecvmsg(self.serv_sock, len(MSG),
2543 socket.CMSG_LEN(4 * SIZEOF_INT)),
2544 # RFC 3542 says implementations may set
2545 # MSG_CTRUNC if there isn't enough space
2546 # for trailing padding.
2547 ignoreflags=socket.MSG_CTRUNC)
2548
2549 def _testFDPassCMSG_LEN(self):
2550 self.createAndSendFDs(1)
2551
Charles-Francois Natalidd225e42013-05-20 19:08:19 +02002552 @unittest.skipIf(sys.platform == "darwin", "skipping, see issue #12958")
Nick Coghlan96fe56a2011-08-22 11:55:57 +10002553 @requireAttrs(socket, "CMSG_SPACE")
2554 def testFDPassSeparate(self):
2555 # Pass two FDs in two separate arrays. Arrays may be combined
2556 # into a single control message by the OS.
2557 self.checkRecvmsgFDs(2,
2558 self.doRecvmsg(self.serv_sock, len(MSG), 10240),
2559 maxcmsgs=2)
2560
2561 @testFDPassSeparate.client_skip
Charles-Francois Natalidd225e42013-05-20 19:08:19 +02002562 @unittest.skipIf(sys.platform == "darwin", "skipping, see issue #12958")
Nick Coghlan96fe56a2011-08-22 11:55:57 +10002563 def _testFDPassSeparate(self):
2564 fd0, fd1 = self.newFDs(2)
2565 self.assertEqual(
2566 self.sendmsgToServer([MSG], [(socket.SOL_SOCKET,
2567 socket.SCM_RIGHTS,
2568 array.array("i", [fd0])),
2569 (socket.SOL_SOCKET,
2570 socket.SCM_RIGHTS,
2571 array.array("i", [fd1]))]),
2572 len(MSG))
2573
Charles-Francois Natalidd225e42013-05-20 19:08:19 +02002574 @unittest.skipIf(sys.platform == "darwin", "skipping, see issue #12958")
Nick Coghlan96fe56a2011-08-22 11:55:57 +10002575 @requireAttrs(socket, "CMSG_SPACE")
2576 def testFDPassSeparateMinSpace(self):
2577 # Pass two FDs in two separate arrays, receiving them into the
2578 # minimum space for two arrays.
2579 self.checkRecvmsgFDs(2,
2580 self.doRecvmsg(self.serv_sock, len(MSG),
2581 socket.CMSG_SPACE(SIZEOF_INT) +
2582 socket.CMSG_LEN(SIZEOF_INT)),
2583 maxcmsgs=2, ignoreflags=socket.MSG_CTRUNC)
2584
2585 @testFDPassSeparateMinSpace.client_skip
Charles-Francois Natalidd225e42013-05-20 19:08:19 +02002586 @unittest.skipIf(sys.platform == "darwin", "skipping, see issue #12958")
Nick Coghlan96fe56a2011-08-22 11:55:57 +10002587 def _testFDPassSeparateMinSpace(self):
2588 fd0, fd1 = self.newFDs(2)
2589 self.assertEqual(
2590 self.sendmsgToServer([MSG], [(socket.SOL_SOCKET,
2591 socket.SCM_RIGHTS,
2592 array.array("i", [fd0])),
2593 (socket.SOL_SOCKET,
2594 socket.SCM_RIGHTS,
2595 array.array("i", [fd1]))]),
2596 len(MSG))
2597
2598 def sendAncillaryIfPossible(self, msg, ancdata):
2599 # Try to send msg and ancdata to server, but if the system
2600 # call fails, just send msg with no ancillary data.
2601 try:
2602 nbytes = self.sendmsgToServer([msg], ancdata)
2603 except socket.error as e:
2604 # Check that it was the system call that failed
2605 self.assertIsInstance(e.errno, int)
2606 nbytes = self.sendmsgToServer([msg])
2607 self.assertEqual(nbytes, len(msg))
2608
2609 def testFDPassEmpty(self):
2610 # Try to pass an empty FD array. Can receive either no array
2611 # or an empty array.
2612 self.checkRecvmsgFDs(0, self.doRecvmsg(self.serv_sock,
2613 len(MSG), 10240),
2614 ignoreflags=socket.MSG_CTRUNC)
2615
2616 def _testFDPassEmpty(self):
2617 self.sendAncillaryIfPossible(MSG, [(socket.SOL_SOCKET,
2618 socket.SCM_RIGHTS,
2619 b"")])
2620
2621 def testFDPassPartialInt(self):
2622 # Try to pass a truncated FD array.
2623 msg, ancdata, flags, addr = self.doRecvmsg(self.serv_sock,
2624 len(MSG), 10240)
2625 self.assertEqual(msg, MSG)
2626 self.checkRecvmsgAddress(addr, self.cli_addr)
2627 self.checkFlags(flags, eor=True, ignore=socket.MSG_CTRUNC)
2628 self.assertLessEqual(len(ancdata), 1)
2629 for cmsg_level, cmsg_type, cmsg_data in ancdata:
2630 self.assertEqual(cmsg_level, socket.SOL_SOCKET)
2631 self.assertEqual(cmsg_type, socket.SCM_RIGHTS)
2632 self.assertLess(len(cmsg_data), SIZEOF_INT)
2633
2634 def _testFDPassPartialInt(self):
2635 self.sendAncillaryIfPossible(
2636 MSG,
2637 [(socket.SOL_SOCKET,
2638 socket.SCM_RIGHTS,
Nadeem Vawda3d1706f2011-08-22 09:46:56 +02002639 array.array("i", [self.badfd]).tobytes()[:-1])])
Nick Coghlan96fe56a2011-08-22 11:55:57 +10002640
2641 @requireAttrs(socket, "CMSG_SPACE")
2642 def testFDPassPartialIntInMiddle(self):
2643 # Try to pass two FD arrays, the first of which is truncated.
2644 msg, ancdata, flags, addr = self.doRecvmsg(self.serv_sock,
2645 len(MSG), 10240)
2646 self.assertEqual(msg, MSG)
2647 self.checkRecvmsgAddress(addr, self.cli_addr)
2648 self.checkFlags(flags, eor=True, ignore=socket.MSG_CTRUNC)
2649 self.assertLessEqual(len(ancdata), 2)
2650 fds = array.array("i")
2651 # Arrays may have been combined in a single control message
2652 for cmsg_level, cmsg_type, cmsg_data in ancdata:
2653 self.assertEqual(cmsg_level, socket.SOL_SOCKET)
2654 self.assertEqual(cmsg_type, socket.SCM_RIGHTS)
Nadeem Vawda3d1706f2011-08-22 09:46:56 +02002655 fds.frombytes(cmsg_data[:
Nick Coghlan96fe56a2011-08-22 11:55:57 +10002656 len(cmsg_data) - (len(cmsg_data) % fds.itemsize)])
2657 self.assertLessEqual(len(fds), 2)
2658 self.checkFDs(fds)
2659
2660 @testFDPassPartialIntInMiddle.client_skip
2661 def _testFDPassPartialIntInMiddle(self):
2662 fd0, fd1 = self.newFDs(2)
2663 self.sendAncillaryIfPossible(
2664 MSG,
2665 [(socket.SOL_SOCKET,
2666 socket.SCM_RIGHTS,
Nadeem Vawda3d1706f2011-08-22 09:46:56 +02002667 array.array("i", [fd0, self.badfd]).tobytes()[:-1]),
Nick Coghlan96fe56a2011-08-22 11:55:57 +10002668 (socket.SOL_SOCKET,
2669 socket.SCM_RIGHTS,
2670 array.array("i", [fd1]))])
2671
2672 def checkTruncatedHeader(self, result, ignoreflags=0):
2673 # Check that no ancillary data items are returned when data is
2674 # truncated inside the cmsghdr structure.
2675 msg, ancdata, flags, addr = result
2676 self.assertEqual(msg, MSG)
2677 self.checkRecvmsgAddress(addr, self.cli_addr)
2678 self.assertEqual(ancdata, [])
2679 self.checkFlags(flags, eor=True, checkset=socket.MSG_CTRUNC,
2680 ignore=ignoreflags)
2681
2682 def testCmsgTruncNoBufSize(self):
2683 # Check that no ancillary data is received when no buffer size
2684 # is specified.
2685 self.checkTruncatedHeader(self.doRecvmsg(self.serv_sock, len(MSG)),
2686 # BSD seems to set MSG_CTRUNC only
2687 # if an item has been partially
2688 # received.
2689 ignoreflags=socket.MSG_CTRUNC)
2690
2691 def _testCmsgTruncNoBufSize(self):
2692 self.createAndSendFDs(1)
2693
2694 def testCmsgTrunc0(self):
2695 # Check that no ancillary data is received when buffer size is 0.
2696 self.checkTruncatedHeader(self.doRecvmsg(self.serv_sock, len(MSG), 0),
2697 ignoreflags=socket.MSG_CTRUNC)
2698
2699 def _testCmsgTrunc0(self):
2700 self.createAndSendFDs(1)
2701
2702 # Check that no ancillary data is returned for various non-zero
2703 # (but still too small) buffer sizes.
2704
2705 def testCmsgTrunc1(self):
2706 self.checkTruncatedHeader(self.doRecvmsg(self.serv_sock, len(MSG), 1))
2707
2708 def _testCmsgTrunc1(self):
2709 self.createAndSendFDs(1)
2710
2711 def testCmsgTrunc2Int(self):
2712 # The cmsghdr structure has at least three members, two of
2713 # which are ints, so we still shouldn't see any ancillary
2714 # data.
2715 self.checkTruncatedHeader(self.doRecvmsg(self.serv_sock, len(MSG),
2716 SIZEOF_INT * 2))
2717
2718 def _testCmsgTrunc2Int(self):
2719 self.createAndSendFDs(1)
2720
2721 def testCmsgTruncLen0Minus1(self):
2722 self.checkTruncatedHeader(self.doRecvmsg(self.serv_sock, len(MSG),
2723 socket.CMSG_LEN(0) - 1))
2724
2725 def _testCmsgTruncLen0Minus1(self):
2726 self.createAndSendFDs(1)
2727
2728 # The following tests try to truncate the control message in the
2729 # middle of the FD array.
2730
2731 def checkTruncatedArray(self, ancbuf, maxdata, mindata=0):
2732 # Check that file descriptor data is truncated to between
2733 # mindata and maxdata bytes when received with buffer size
2734 # ancbuf, and that any complete file descriptor numbers are
2735 # valid.
2736 msg, ancdata, flags, addr = self.doRecvmsg(self.serv_sock,
2737 len(MSG), ancbuf)
2738 self.assertEqual(msg, MSG)
2739 self.checkRecvmsgAddress(addr, self.cli_addr)
2740 self.checkFlags(flags, eor=True, checkset=socket.MSG_CTRUNC)
2741
2742 if mindata == 0 and ancdata == []:
2743 return
2744 self.assertEqual(len(ancdata), 1)
2745 cmsg_level, cmsg_type, cmsg_data = ancdata[0]
2746 self.assertEqual(cmsg_level, socket.SOL_SOCKET)
2747 self.assertEqual(cmsg_type, socket.SCM_RIGHTS)
2748 self.assertGreaterEqual(len(cmsg_data), mindata)
2749 self.assertLessEqual(len(cmsg_data), maxdata)
2750 fds = array.array("i")
Nadeem Vawda3d1706f2011-08-22 09:46:56 +02002751 fds.frombytes(cmsg_data[:
Nick Coghlan96fe56a2011-08-22 11:55:57 +10002752 len(cmsg_data) - (len(cmsg_data) % fds.itemsize)])
2753 self.checkFDs(fds)
2754
2755 def testCmsgTruncLen0(self):
2756 self.checkTruncatedArray(ancbuf=socket.CMSG_LEN(0), maxdata=0)
2757
2758 def _testCmsgTruncLen0(self):
2759 self.createAndSendFDs(1)
2760
2761 def testCmsgTruncLen0Plus1(self):
2762 self.checkTruncatedArray(ancbuf=socket.CMSG_LEN(0) + 1, maxdata=1)
2763
2764 def _testCmsgTruncLen0Plus1(self):
2765 self.createAndSendFDs(2)
2766
2767 def testCmsgTruncLen1(self):
2768 self.checkTruncatedArray(ancbuf=socket.CMSG_LEN(SIZEOF_INT),
2769 maxdata=SIZEOF_INT)
2770
2771 def _testCmsgTruncLen1(self):
2772 self.createAndSendFDs(2)
2773
2774 def testCmsgTruncLen2Minus1(self):
2775 self.checkTruncatedArray(ancbuf=socket.CMSG_LEN(2 * SIZEOF_INT) - 1,
2776 maxdata=(2 * SIZEOF_INT) - 1)
2777
2778 def _testCmsgTruncLen2Minus1(self):
2779 self.createAndSendFDs(2)
2780
2781
2782class RFC3542AncillaryTest(SendrecvmsgServerTimeoutBase):
2783 # Test sendmsg() and recvmsg[_into]() using the ancillary data
2784 # features of the RFC 3542 Advanced Sockets API for IPv6.
2785 # Currently we can only handle certain data items (e.g. traffic
2786 # class, hop limit, MTU discovery and fragmentation settings)
2787 # without resorting to unportable means such as the struct module,
2788 # but the tests here are aimed at testing the ancillary data
2789 # handling in sendmsg() and recvmsg() rather than the IPv6 API
2790 # itself.
2791
2792 # Test value to use when setting hop limit of packet
2793 hop_limit = 2
2794
2795 # Test value to use when setting traffic class of packet.
2796 # -1 means "use kernel default".
2797 traffic_class = -1
2798
2799 def ancillaryMapping(self, ancdata):
2800 # Given ancillary data list ancdata, return a mapping from
2801 # pairs (cmsg_level, cmsg_type) to corresponding cmsg_data.
2802 # Check that no (level, type) pair appears more than once.
2803 d = {}
2804 for cmsg_level, cmsg_type, cmsg_data in ancdata:
2805 self.assertNotIn((cmsg_level, cmsg_type), d)
2806 d[(cmsg_level, cmsg_type)] = cmsg_data
2807 return d
2808
2809 def checkHopLimit(self, ancbufsize, maxhop=255, ignoreflags=0):
2810 # Receive hop limit into ancbufsize bytes of ancillary data
2811 # space. Check that data is MSG, ancillary data is not
2812 # truncated (but ignore any flags in ignoreflags), and hop
2813 # limit is between 0 and maxhop inclusive.
2814 self.serv_sock.setsockopt(socket.IPPROTO_IPV6,
2815 socket.IPV6_RECVHOPLIMIT, 1)
2816 self.misc_event.set()
2817 msg, ancdata, flags, addr = self.doRecvmsg(self.serv_sock,
2818 len(MSG), ancbufsize)
2819
2820 self.assertEqual(msg, MSG)
2821 self.checkRecvmsgAddress(addr, self.cli_addr)
2822 self.checkFlags(flags, eor=True, checkunset=socket.MSG_CTRUNC,
2823 ignore=ignoreflags)
2824
2825 self.assertEqual(len(ancdata), 1)
2826 self.assertIsInstance(ancdata[0], tuple)
2827 cmsg_level, cmsg_type, cmsg_data = ancdata[0]
2828 self.assertEqual(cmsg_level, socket.IPPROTO_IPV6)
2829 self.assertEqual(cmsg_type, socket.IPV6_HOPLIMIT)
2830 self.assertIsInstance(cmsg_data, bytes)
2831 self.assertEqual(len(cmsg_data), SIZEOF_INT)
2832 a = array.array("i")
Nadeem Vawda3d1706f2011-08-22 09:46:56 +02002833 a.frombytes(cmsg_data)
Nick Coghlan96fe56a2011-08-22 11:55:57 +10002834 self.assertGreaterEqual(a[0], 0)
2835 self.assertLessEqual(a[0], maxhop)
2836
2837 @requireAttrs(socket, "IPV6_RECVHOPLIMIT", "IPV6_HOPLIMIT")
2838 def testRecvHopLimit(self):
2839 # Test receiving the packet hop limit as ancillary data.
2840 self.checkHopLimit(ancbufsize=10240)
2841
2842 @testRecvHopLimit.client_skip
2843 def _testRecvHopLimit(self):
2844 # Need to wait until server has asked to receive ancillary
2845 # data, as implementations are not required to buffer it
2846 # otherwise.
2847 self.assertTrue(self.misc_event.wait(timeout=self.fail_timeout))
2848 self.sendToServer(MSG)
2849
2850 @requireAttrs(socket, "CMSG_SPACE", "IPV6_RECVHOPLIMIT", "IPV6_HOPLIMIT")
2851 def testRecvHopLimitCMSG_SPACE(self):
2852 # Test receiving hop limit, using CMSG_SPACE to calculate buffer size.
2853 self.checkHopLimit(ancbufsize=socket.CMSG_SPACE(SIZEOF_INT))
2854
2855 @testRecvHopLimitCMSG_SPACE.client_skip
2856 def _testRecvHopLimitCMSG_SPACE(self):
2857 self.assertTrue(self.misc_event.wait(timeout=self.fail_timeout))
2858 self.sendToServer(MSG)
2859
2860 # Could test receiving into buffer sized using CMSG_LEN, but RFC
2861 # 3542 says portable applications must provide space for trailing
2862 # padding. Implementations may set MSG_CTRUNC if there isn't
2863 # enough space for the padding.
2864
2865 @requireAttrs(socket.socket, "sendmsg")
2866 @requireAttrs(socket, "IPV6_RECVHOPLIMIT", "IPV6_HOPLIMIT")
2867 def testSetHopLimit(self):
2868 # Test setting hop limit on outgoing packet and receiving it
2869 # at the other end.
2870 self.checkHopLimit(ancbufsize=10240, maxhop=self.hop_limit)
2871
2872 @testSetHopLimit.client_skip
2873 def _testSetHopLimit(self):
2874 self.assertTrue(self.misc_event.wait(timeout=self.fail_timeout))
2875 self.assertEqual(
2876 self.sendmsgToServer([MSG],
2877 [(socket.IPPROTO_IPV6, socket.IPV6_HOPLIMIT,
2878 array.array("i", [self.hop_limit]))]),
2879 len(MSG))
2880
2881 def checkTrafficClassAndHopLimit(self, ancbufsize, maxhop=255,
2882 ignoreflags=0):
2883 # Receive traffic class and hop limit into ancbufsize bytes of
2884 # ancillary data space. Check that data is MSG, ancillary
2885 # data is not truncated (but ignore any flags in ignoreflags),
2886 # and traffic class and hop limit are in range (hop limit no
2887 # more than maxhop).
2888 self.serv_sock.setsockopt(socket.IPPROTO_IPV6,
2889 socket.IPV6_RECVHOPLIMIT, 1)
2890 self.serv_sock.setsockopt(socket.IPPROTO_IPV6,
2891 socket.IPV6_RECVTCLASS, 1)
2892 self.misc_event.set()
2893 msg, ancdata, flags, addr = self.doRecvmsg(self.serv_sock,
2894 len(MSG), ancbufsize)
2895
2896 self.assertEqual(msg, MSG)
2897 self.checkRecvmsgAddress(addr, self.cli_addr)
2898 self.checkFlags(flags, eor=True, checkunset=socket.MSG_CTRUNC,
2899 ignore=ignoreflags)
2900 self.assertEqual(len(ancdata), 2)
2901 ancmap = self.ancillaryMapping(ancdata)
2902
2903 tcdata = ancmap[(socket.IPPROTO_IPV6, socket.IPV6_TCLASS)]
2904 self.assertEqual(len(tcdata), SIZEOF_INT)
2905 a = array.array("i")
Nadeem Vawda3d1706f2011-08-22 09:46:56 +02002906 a.frombytes(tcdata)
Nick Coghlan96fe56a2011-08-22 11:55:57 +10002907 self.assertGreaterEqual(a[0], 0)
2908 self.assertLessEqual(a[0], 255)
2909
2910 hldata = ancmap[(socket.IPPROTO_IPV6, socket.IPV6_HOPLIMIT)]
2911 self.assertEqual(len(hldata), SIZEOF_INT)
2912 a = array.array("i")
Nadeem Vawda3d1706f2011-08-22 09:46:56 +02002913 a.frombytes(hldata)
Nick Coghlan96fe56a2011-08-22 11:55:57 +10002914 self.assertGreaterEqual(a[0], 0)
2915 self.assertLessEqual(a[0], maxhop)
2916
2917 @requireAttrs(socket, "IPV6_RECVHOPLIMIT", "IPV6_HOPLIMIT",
2918 "IPV6_RECVTCLASS", "IPV6_TCLASS")
2919 def testRecvTrafficClassAndHopLimit(self):
2920 # Test receiving traffic class and hop limit as ancillary data.
2921 self.checkTrafficClassAndHopLimit(ancbufsize=10240)
2922
2923 @testRecvTrafficClassAndHopLimit.client_skip
2924 def _testRecvTrafficClassAndHopLimit(self):
2925 self.assertTrue(self.misc_event.wait(timeout=self.fail_timeout))
2926 self.sendToServer(MSG)
2927
2928 @requireAttrs(socket, "CMSG_SPACE", "IPV6_RECVHOPLIMIT", "IPV6_HOPLIMIT",
2929 "IPV6_RECVTCLASS", "IPV6_TCLASS")
2930 def testRecvTrafficClassAndHopLimitCMSG_SPACE(self):
2931 # Test receiving traffic class and hop limit, using
2932 # CMSG_SPACE() to calculate buffer size.
2933 self.checkTrafficClassAndHopLimit(
2934 ancbufsize=socket.CMSG_SPACE(SIZEOF_INT) * 2)
2935
2936 @testRecvTrafficClassAndHopLimitCMSG_SPACE.client_skip
2937 def _testRecvTrafficClassAndHopLimitCMSG_SPACE(self):
2938 self.assertTrue(self.misc_event.wait(timeout=self.fail_timeout))
2939 self.sendToServer(MSG)
2940
2941 @requireAttrs(socket.socket, "sendmsg")
2942 @requireAttrs(socket, "CMSG_SPACE", "IPV6_RECVHOPLIMIT", "IPV6_HOPLIMIT",
2943 "IPV6_RECVTCLASS", "IPV6_TCLASS")
2944 def testSetTrafficClassAndHopLimit(self):
2945 # Test setting traffic class and hop limit on outgoing packet,
2946 # and receiving them at the other end.
2947 self.checkTrafficClassAndHopLimit(ancbufsize=10240,
2948 maxhop=self.hop_limit)
2949
2950 @testSetTrafficClassAndHopLimit.client_skip
2951 def _testSetTrafficClassAndHopLimit(self):
2952 self.assertTrue(self.misc_event.wait(timeout=self.fail_timeout))
2953 self.assertEqual(
2954 self.sendmsgToServer([MSG],
2955 [(socket.IPPROTO_IPV6, socket.IPV6_TCLASS,
2956 array.array("i", [self.traffic_class])),
2957 (socket.IPPROTO_IPV6, socket.IPV6_HOPLIMIT,
2958 array.array("i", [self.hop_limit]))]),
2959 len(MSG))
2960
2961 @requireAttrs(socket.socket, "sendmsg")
2962 @requireAttrs(socket, "CMSG_SPACE", "IPV6_RECVHOPLIMIT", "IPV6_HOPLIMIT",
2963 "IPV6_RECVTCLASS", "IPV6_TCLASS")
2964 def testOddCmsgSize(self):
2965 # Try to send ancillary data with first item one byte too
2966 # long. Fall back to sending with correct size if this fails,
2967 # and check that second item was handled correctly.
2968 self.checkTrafficClassAndHopLimit(ancbufsize=10240,
2969 maxhop=self.hop_limit)
2970
2971 @testOddCmsgSize.client_skip
2972 def _testOddCmsgSize(self):
2973 self.assertTrue(self.misc_event.wait(timeout=self.fail_timeout))
2974 try:
2975 nbytes = self.sendmsgToServer(
2976 [MSG],
2977 [(socket.IPPROTO_IPV6, socket.IPV6_TCLASS,
Nadeem Vawda3d1706f2011-08-22 09:46:56 +02002978 array.array("i", [self.traffic_class]).tobytes() + b"\x00"),
Nick Coghlan96fe56a2011-08-22 11:55:57 +10002979 (socket.IPPROTO_IPV6, socket.IPV6_HOPLIMIT,
2980 array.array("i", [self.hop_limit]))])
2981 except socket.error as e:
2982 self.assertIsInstance(e.errno, int)
2983 nbytes = self.sendmsgToServer(
2984 [MSG],
2985 [(socket.IPPROTO_IPV6, socket.IPV6_TCLASS,
2986 array.array("i", [self.traffic_class])),
2987 (socket.IPPROTO_IPV6, socket.IPV6_HOPLIMIT,
2988 array.array("i", [self.hop_limit]))])
2989 self.assertEqual(nbytes, len(MSG))
2990
2991 # Tests for proper handling of truncated ancillary data
2992
2993 def checkHopLimitTruncatedHeader(self, ancbufsize, ignoreflags=0):
2994 # Receive hop limit into ancbufsize bytes of ancillary data
2995 # space, which should be too small to contain the ancillary
2996 # data header (if ancbufsize is None, pass no second argument
2997 # to recvmsg()). Check that data is MSG, MSG_CTRUNC is set
2998 # (unless included in ignoreflags), and no ancillary data is
2999 # returned.
3000 self.serv_sock.setsockopt(socket.IPPROTO_IPV6,
3001 socket.IPV6_RECVHOPLIMIT, 1)
3002 self.misc_event.set()
3003 args = () if ancbufsize is None else (ancbufsize,)
3004 msg, ancdata, flags, addr = self.doRecvmsg(self.serv_sock,
3005 len(MSG), *args)
3006
3007 self.assertEqual(msg, MSG)
3008 self.checkRecvmsgAddress(addr, self.cli_addr)
3009 self.assertEqual(ancdata, [])
3010 self.checkFlags(flags, eor=True, checkset=socket.MSG_CTRUNC,
3011 ignore=ignoreflags)
3012
3013 @requireAttrs(socket, "IPV6_RECVHOPLIMIT", "IPV6_HOPLIMIT")
3014 def testCmsgTruncNoBufSize(self):
3015 # Check that no ancillary data is received when no ancillary
3016 # buffer size is provided.
3017 self.checkHopLimitTruncatedHeader(ancbufsize=None,
3018 # BSD seems to set
3019 # MSG_CTRUNC only if an item
3020 # has been partially
3021 # received.
3022 ignoreflags=socket.MSG_CTRUNC)
3023
3024 @testCmsgTruncNoBufSize.client_skip
3025 def _testCmsgTruncNoBufSize(self):
3026 self.assertTrue(self.misc_event.wait(timeout=self.fail_timeout))
3027 self.sendToServer(MSG)
3028
3029 @requireAttrs(socket, "IPV6_RECVHOPLIMIT", "IPV6_HOPLIMIT")
3030 def testSingleCmsgTrunc0(self):
3031 # Check that no ancillary data is received when ancillary
3032 # buffer size is zero.
3033 self.checkHopLimitTruncatedHeader(ancbufsize=0,
3034 ignoreflags=socket.MSG_CTRUNC)
3035
3036 @testSingleCmsgTrunc0.client_skip
3037 def _testSingleCmsgTrunc0(self):
3038 self.assertTrue(self.misc_event.wait(timeout=self.fail_timeout))
3039 self.sendToServer(MSG)
3040
3041 # Check that no ancillary data is returned for various non-zero
3042 # (but still too small) buffer sizes.
3043
3044 @requireAttrs(socket, "IPV6_RECVHOPLIMIT", "IPV6_HOPLIMIT")
3045 def testSingleCmsgTrunc1(self):
3046 self.checkHopLimitTruncatedHeader(ancbufsize=1)
3047
3048 @testSingleCmsgTrunc1.client_skip
3049 def _testSingleCmsgTrunc1(self):
3050 self.assertTrue(self.misc_event.wait(timeout=self.fail_timeout))
3051 self.sendToServer(MSG)
3052
3053 @requireAttrs(socket, "IPV6_RECVHOPLIMIT", "IPV6_HOPLIMIT")
3054 def testSingleCmsgTrunc2Int(self):
3055 self.checkHopLimitTruncatedHeader(ancbufsize=2 * SIZEOF_INT)
3056
3057 @testSingleCmsgTrunc2Int.client_skip
3058 def _testSingleCmsgTrunc2Int(self):
3059 self.assertTrue(self.misc_event.wait(timeout=self.fail_timeout))
3060 self.sendToServer(MSG)
3061
3062 @requireAttrs(socket, "IPV6_RECVHOPLIMIT", "IPV6_HOPLIMIT")
3063 def testSingleCmsgTruncLen0Minus1(self):
3064 self.checkHopLimitTruncatedHeader(ancbufsize=socket.CMSG_LEN(0) - 1)
3065
3066 @testSingleCmsgTruncLen0Minus1.client_skip
3067 def _testSingleCmsgTruncLen0Minus1(self):
3068 self.assertTrue(self.misc_event.wait(timeout=self.fail_timeout))
3069 self.sendToServer(MSG)
3070
3071 @requireAttrs(socket, "IPV6_RECVHOPLIMIT", "IPV6_HOPLIMIT")
3072 def testSingleCmsgTruncInData(self):
3073 # Test truncation of a control message inside its associated
3074 # data. The message may be returned with its data truncated,
3075 # or not returned at all.
3076 self.serv_sock.setsockopt(socket.IPPROTO_IPV6,
3077 socket.IPV6_RECVHOPLIMIT, 1)
3078 self.misc_event.set()
3079 msg, ancdata, flags, addr = self.doRecvmsg(
3080 self.serv_sock, len(MSG), socket.CMSG_LEN(SIZEOF_INT) - 1)
3081
3082 self.assertEqual(msg, MSG)
3083 self.checkRecvmsgAddress(addr, self.cli_addr)
3084 self.checkFlags(flags, eor=True, checkset=socket.MSG_CTRUNC)
3085
3086 self.assertLessEqual(len(ancdata), 1)
3087 if ancdata:
3088 cmsg_level, cmsg_type, cmsg_data = ancdata[0]
3089 self.assertEqual(cmsg_level, socket.IPPROTO_IPV6)
3090 self.assertEqual(cmsg_type, socket.IPV6_HOPLIMIT)
3091 self.assertLess(len(cmsg_data), SIZEOF_INT)
3092
3093 @testSingleCmsgTruncInData.client_skip
3094 def _testSingleCmsgTruncInData(self):
3095 self.assertTrue(self.misc_event.wait(timeout=self.fail_timeout))
3096 self.sendToServer(MSG)
3097
3098 def checkTruncatedSecondHeader(self, ancbufsize, ignoreflags=0):
3099 # Receive traffic class and hop limit into ancbufsize bytes of
3100 # ancillary data space, which should be large enough to
3101 # contain the first item, but too small to contain the header
3102 # of the second. Check that data is MSG, MSG_CTRUNC is set
3103 # (unless included in ignoreflags), and only one ancillary
3104 # data item is returned.
3105 self.serv_sock.setsockopt(socket.IPPROTO_IPV6,
3106 socket.IPV6_RECVHOPLIMIT, 1)
3107 self.serv_sock.setsockopt(socket.IPPROTO_IPV6,
3108 socket.IPV6_RECVTCLASS, 1)
3109 self.misc_event.set()
3110 msg, ancdata, flags, addr = self.doRecvmsg(self.serv_sock,
3111 len(MSG), ancbufsize)
3112
3113 self.assertEqual(msg, MSG)
3114 self.checkRecvmsgAddress(addr, self.cli_addr)
3115 self.checkFlags(flags, eor=True, checkset=socket.MSG_CTRUNC,
3116 ignore=ignoreflags)
3117
3118 self.assertEqual(len(ancdata), 1)
3119 cmsg_level, cmsg_type, cmsg_data = ancdata[0]
3120 self.assertEqual(cmsg_level, socket.IPPROTO_IPV6)
3121 self.assertIn(cmsg_type, {socket.IPV6_TCLASS, socket.IPV6_HOPLIMIT})
3122 self.assertEqual(len(cmsg_data), SIZEOF_INT)
3123 a = array.array("i")
Nadeem Vawda3d1706f2011-08-22 09:46:56 +02003124 a.frombytes(cmsg_data)
Nick Coghlan96fe56a2011-08-22 11:55:57 +10003125 self.assertGreaterEqual(a[0], 0)
3126 self.assertLessEqual(a[0], 255)
3127
3128 # Try the above test with various buffer sizes.
3129
3130 @requireAttrs(socket, "CMSG_SPACE", "IPV6_RECVHOPLIMIT", "IPV6_HOPLIMIT",
3131 "IPV6_RECVTCLASS", "IPV6_TCLASS")
3132 def testSecondCmsgTrunc0(self):
3133 self.checkTruncatedSecondHeader(socket.CMSG_SPACE(SIZEOF_INT),
3134 ignoreflags=socket.MSG_CTRUNC)
3135
3136 @testSecondCmsgTrunc0.client_skip
3137 def _testSecondCmsgTrunc0(self):
3138 self.assertTrue(self.misc_event.wait(timeout=self.fail_timeout))
3139 self.sendToServer(MSG)
3140
3141 @requireAttrs(socket, "CMSG_SPACE", "IPV6_RECVHOPLIMIT", "IPV6_HOPLIMIT",
3142 "IPV6_RECVTCLASS", "IPV6_TCLASS")
3143 def testSecondCmsgTrunc1(self):
3144 self.checkTruncatedSecondHeader(socket.CMSG_SPACE(SIZEOF_INT) + 1)
3145
3146 @testSecondCmsgTrunc1.client_skip
3147 def _testSecondCmsgTrunc1(self):
3148 self.assertTrue(self.misc_event.wait(timeout=self.fail_timeout))
3149 self.sendToServer(MSG)
3150
3151 @requireAttrs(socket, "CMSG_SPACE", "IPV6_RECVHOPLIMIT", "IPV6_HOPLIMIT",
3152 "IPV6_RECVTCLASS", "IPV6_TCLASS")
3153 def testSecondCmsgTrunc2Int(self):
3154 self.checkTruncatedSecondHeader(socket.CMSG_SPACE(SIZEOF_INT) +
3155 2 * SIZEOF_INT)
3156
3157 @testSecondCmsgTrunc2Int.client_skip
3158 def _testSecondCmsgTrunc2Int(self):
3159 self.assertTrue(self.misc_event.wait(timeout=self.fail_timeout))
3160 self.sendToServer(MSG)
3161
3162 @requireAttrs(socket, "CMSG_SPACE", "IPV6_RECVHOPLIMIT", "IPV6_HOPLIMIT",
3163 "IPV6_RECVTCLASS", "IPV6_TCLASS")
3164 def testSecondCmsgTruncLen0Minus1(self):
3165 self.checkTruncatedSecondHeader(socket.CMSG_SPACE(SIZEOF_INT) +
3166 socket.CMSG_LEN(0) - 1)
3167
3168 @testSecondCmsgTruncLen0Minus1.client_skip
3169 def _testSecondCmsgTruncLen0Minus1(self):
3170 self.assertTrue(self.misc_event.wait(timeout=self.fail_timeout))
3171 self.sendToServer(MSG)
3172
3173 @requireAttrs(socket, "CMSG_SPACE", "IPV6_RECVHOPLIMIT", "IPV6_HOPLIMIT",
3174 "IPV6_RECVTCLASS", "IPV6_TCLASS")
3175 def testSecomdCmsgTruncInData(self):
3176 # Test truncation of the second of two control messages inside
3177 # its associated data.
3178 self.serv_sock.setsockopt(socket.IPPROTO_IPV6,
3179 socket.IPV6_RECVHOPLIMIT, 1)
3180 self.serv_sock.setsockopt(socket.IPPROTO_IPV6,
3181 socket.IPV6_RECVTCLASS, 1)
3182 self.misc_event.set()
3183 msg, ancdata, flags, addr = self.doRecvmsg(
3184 self.serv_sock, len(MSG),
3185 socket.CMSG_SPACE(SIZEOF_INT) + socket.CMSG_LEN(SIZEOF_INT) - 1)
3186
3187 self.assertEqual(msg, MSG)
3188 self.checkRecvmsgAddress(addr, self.cli_addr)
3189 self.checkFlags(flags, eor=True, checkset=socket.MSG_CTRUNC)
3190
3191 cmsg_types = {socket.IPV6_TCLASS, socket.IPV6_HOPLIMIT}
3192
3193 cmsg_level, cmsg_type, cmsg_data = ancdata.pop(0)
3194 self.assertEqual(cmsg_level, socket.IPPROTO_IPV6)
3195 cmsg_types.remove(cmsg_type)
3196 self.assertEqual(len(cmsg_data), SIZEOF_INT)
3197 a = array.array("i")
Nadeem Vawda3d1706f2011-08-22 09:46:56 +02003198 a.frombytes(cmsg_data)
Nick Coghlan96fe56a2011-08-22 11:55:57 +10003199 self.assertGreaterEqual(a[0], 0)
3200 self.assertLessEqual(a[0], 255)
3201
3202 if ancdata:
3203 cmsg_level, cmsg_type, cmsg_data = ancdata.pop(0)
3204 self.assertEqual(cmsg_level, socket.IPPROTO_IPV6)
3205 cmsg_types.remove(cmsg_type)
3206 self.assertLess(len(cmsg_data), SIZEOF_INT)
3207
3208 self.assertEqual(ancdata, [])
3209
3210 @testSecomdCmsgTruncInData.client_skip
3211 def _testSecomdCmsgTruncInData(self):
3212 self.assertTrue(self.misc_event.wait(timeout=self.fail_timeout))
3213 self.sendToServer(MSG)
3214
3215
3216# Derive concrete test classes for different socket types.
3217
3218class SendrecvmsgUDPTestBase(SendrecvmsgDgramFlagsBase,
3219 SendrecvmsgConnectionlessBase,
3220 ThreadedSocketTestMixin, UDPTestBase):
3221 pass
3222
3223@requireAttrs(socket.socket, "sendmsg")
3224@unittest.skipUnless(thread, 'Threading required for this test.')
3225class SendmsgUDPTest(SendmsgConnectionlessTests, SendrecvmsgUDPTestBase):
3226 pass
3227
3228@requireAttrs(socket.socket, "recvmsg")
3229@unittest.skipUnless(thread, 'Threading required for this test.')
3230class RecvmsgUDPTest(RecvmsgTests, SendrecvmsgUDPTestBase):
3231 pass
3232
3233@requireAttrs(socket.socket, "recvmsg_into")
3234@unittest.skipUnless(thread, 'Threading required for this test.')
3235class RecvmsgIntoUDPTest(RecvmsgIntoTests, SendrecvmsgUDPTestBase):
3236 pass
3237
3238
3239class SendrecvmsgUDP6TestBase(SendrecvmsgDgramFlagsBase,
3240 SendrecvmsgConnectionlessBase,
3241 ThreadedSocketTestMixin, UDP6TestBase):
Charles-François Natali37114bb2013-07-09 19:15:43 +02003242
3243 def checkRecvmsgAddress(self, addr1, addr2):
3244 # Called to compare the received address with the address of
3245 # the peer, ignoring scope ID
3246 self.assertEqual(addr1[:-1], addr2[:-1])
Nick Coghlan96fe56a2011-08-22 11:55:57 +10003247
3248@requireAttrs(socket.socket, "sendmsg")
Ross Lagerwall8d459f02012-07-08 09:53:57 +02003249@unittest.skipUnless(support.IPV6_ENABLED, 'IPv6 required for this test.')
Nick Coghlan96fe56a2011-08-22 11:55:57 +10003250@requireSocket("AF_INET6", "SOCK_DGRAM")
3251@unittest.skipUnless(thread, 'Threading required for this test.')
3252class SendmsgUDP6Test(SendmsgConnectionlessTests, SendrecvmsgUDP6TestBase):
3253 pass
3254
3255@requireAttrs(socket.socket, "recvmsg")
Ross Lagerwall8d459f02012-07-08 09:53:57 +02003256@unittest.skipUnless(support.IPV6_ENABLED, 'IPv6 required for this test.')
Nick Coghlan96fe56a2011-08-22 11:55:57 +10003257@requireSocket("AF_INET6", "SOCK_DGRAM")
3258@unittest.skipUnless(thread, 'Threading required for this test.')
3259class RecvmsgUDP6Test(RecvmsgTests, SendrecvmsgUDP6TestBase):
3260 pass
3261
3262@requireAttrs(socket.socket, "recvmsg_into")
Ross Lagerwall8d459f02012-07-08 09:53:57 +02003263@unittest.skipUnless(support.IPV6_ENABLED, 'IPv6 required for this test.')
Nick Coghlan96fe56a2011-08-22 11:55:57 +10003264@requireSocket("AF_INET6", "SOCK_DGRAM")
3265@unittest.skipUnless(thread, 'Threading required for this test.')
3266class RecvmsgIntoUDP6Test(RecvmsgIntoTests, SendrecvmsgUDP6TestBase):
3267 pass
3268
3269@requireAttrs(socket.socket, "recvmsg")
Ross Lagerwall8d459f02012-07-08 09:53:57 +02003270@unittest.skipUnless(support.IPV6_ENABLED, 'IPv6 required for this test.')
Nick Coghlan96fe56a2011-08-22 11:55:57 +10003271@requireAttrs(socket, "IPPROTO_IPV6")
3272@requireSocket("AF_INET6", "SOCK_DGRAM")
3273@unittest.skipUnless(thread, 'Threading required for this test.')
3274class RecvmsgRFC3542AncillaryUDP6Test(RFC3542AncillaryTest,
3275 SendrecvmsgUDP6TestBase):
3276 pass
3277
3278@requireAttrs(socket.socket, "recvmsg_into")
Ross Lagerwall8d459f02012-07-08 09:53:57 +02003279@unittest.skipUnless(support.IPV6_ENABLED, 'IPv6 required for this test.')
Nick Coghlan96fe56a2011-08-22 11:55:57 +10003280@requireAttrs(socket, "IPPROTO_IPV6")
3281@requireSocket("AF_INET6", "SOCK_DGRAM")
3282@unittest.skipUnless(thread, 'Threading required for this test.')
3283class RecvmsgIntoRFC3542AncillaryUDP6Test(RecvmsgIntoMixin,
3284 RFC3542AncillaryTest,
3285 SendrecvmsgUDP6TestBase):
3286 pass
3287
3288
3289class SendrecvmsgTCPTestBase(SendrecvmsgConnectedBase,
3290 ConnectedStreamTestMixin, TCPTestBase):
3291 pass
3292
3293@requireAttrs(socket.socket, "sendmsg")
3294@unittest.skipUnless(thread, 'Threading required for this test.')
3295class SendmsgTCPTest(SendmsgStreamTests, SendrecvmsgTCPTestBase):
3296 pass
3297
3298@requireAttrs(socket.socket, "recvmsg")
3299@unittest.skipUnless(thread, 'Threading required for this test.')
3300class RecvmsgTCPTest(RecvmsgTests, RecvmsgGenericStreamTests,
3301 SendrecvmsgTCPTestBase):
3302 pass
3303
3304@requireAttrs(socket.socket, "recvmsg_into")
3305@unittest.skipUnless(thread, 'Threading required for this test.')
3306class RecvmsgIntoTCPTest(RecvmsgIntoTests, RecvmsgGenericStreamTests,
3307 SendrecvmsgTCPTestBase):
3308 pass
3309
3310
3311class SendrecvmsgSCTPStreamTestBase(SendrecvmsgSCTPFlagsBase,
3312 SendrecvmsgConnectedBase,
3313 ConnectedStreamTestMixin, SCTPStreamBase):
3314 pass
3315
3316@requireAttrs(socket.socket, "sendmsg")
3317@requireSocket("AF_INET", "SOCK_STREAM", "IPPROTO_SCTP")
3318@unittest.skipUnless(thread, 'Threading required for this test.')
3319class SendmsgSCTPStreamTest(SendmsgStreamTests, SendrecvmsgSCTPStreamTestBase):
3320 pass
3321
3322@requireAttrs(socket.socket, "recvmsg")
3323@requireSocket("AF_INET", "SOCK_STREAM", "IPPROTO_SCTP")
3324@unittest.skipUnless(thread, 'Threading required for this test.')
3325class RecvmsgSCTPStreamTest(RecvmsgTests, RecvmsgGenericStreamTests,
3326 SendrecvmsgSCTPStreamTestBase):
Antoine Pitrou92f8b002012-12-16 16:40:04 +01003327
3328 def testRecvmsgEOF(self):
3329 try:
3330 super(RecvmsgSCTPStreamTest, self).testRecvmsgEOF()
3331 except OSError as e:
3332 if e.errno != errno.ENOTCONN:
3333 raise
3334 self.skipTest("sporadic ENOTCONN (kernel issue?) - see issue #13876")
Nick Coghlan96fe56a2011-08-22 11:55:57 +10003335
3336@requireAttrs(socket.socket, "recvmsg_into")
3337@requireSocket("AF_INET", "SOCK_STREAM", "IPPROTO_SCTP")
3338@unittest.skipUnless(thread, 'Threading required for this test.')
3339class RecvmsgIntoSCTPStreamTest(RecvmsgIntoTests, RecvmsgGenericStreamTests,
3340 SendrecvmsgSCTPStreamTestBase):
Antoine Pitroud5a070f2012-12-18 23:44:36 +01003341
3342 def testRecvmsgEOF(self):
3343 try:
3344 super(RecvmsgIntoSCTPStreamTest, self).testRecvmsgEOF()
3345 except OSError as e:
3346 if e.errno != errno.ENOTCONN:
3347 raise
3348 self.skipTest("sporadic ENOTCONN (kernel issue?) - see issue #13876")
Nick Coghlan96fe56a2011-08-22 11:55:57 +10003349
3350
3351class SendrecvmsgUnixStreamTestBase(SendrecvmsgConnectedBase,
3352 ConnectedStreamTestMixin, UnixStreamBase):
3353 pass
3354
3355@requireAttrs(socket.socket, "sendmsg")
3356@requireAttrs(socket, "AF_UNIX")
3357@unittest.skipUnless(thread, 'Threading required for this test.')
3358class SendmsgUnixStreamTest(SendmsgStreamTests, SendrecvmsgUnixStreamTestBase):
3359 pass
3360
3361@requireAttrs(socket.socket, "recvmsg")
3362@requireAttrs(socket, "AF_UNIX")
3363@unittest.skipUnless(thread, 'Threading required for this test.')
3364class RecvmsgUnixStreamTest(RecvmsgTests, RecvmsgGenericStreamTests,
3365 SendrecvmsgUnixStreamTestBase):
3366 pass
3367
3368@requireAttrs(socket.socket, "recvmsg_into")
3369@requireAttrs(socket, "AF_UNIX")
3370@unittest.skipUnless(thread, 'Threading required for this test.')
3371class RecvmsgIntoUnixStreamTest(RecvmsgIntoTests, RecvmsgGenericStreamTests,
3372 SendrecvmsgUnixStreamTestBase):
3373 pass
3374
3375@requireAttrs(socket.socket, "sendmsg", "recvmsg")
3376@requireAttrs(socket, "AF_UNIX", "SOL_SOCKET", "SCM_RIGHTS")
3377@unittest.skipUnless(thread, 'Threading required for this test.')
3378class RecvmsgSCMRightsStreamTest(SCMRightsTest, SendrecvmsgUnixStreamTestBase):
3379 pass
3380
3381@requireAttrs(socket.socket, "sendmsg", "recvmsg_into")
3382@requireAttrs(socket, "AF_UNIX", "SOL_SOCKET", "SCM_RIGHTS")
3383@unittest.skipUnless(thread, 'Threading required for this test.')
3384class RecvmsgIntoSCMRightsStreamTest(RecvmsgIntoMixin, SCMRightsTest,
3385 SendrecvmsgUnixStreamTestBase):
3386 pass
3387
3388
3389# Test interrupting the interruptible send/receive methods with a
3390# signal when a timeout is set. These tests avoid having multiple
3391# threads alive during the test so that the OS cannot deliver the
3392# signal to the wrong one.
3393
3394class InterruptedTimeoutBase(unittest.TestCase):
3395 # Base class for interrupted send/receive tests. Installs an
3396 # empty handler for SIGALRM and removes it on teardown, along with
3397 # any scheduled alarms.
3398
3399 def setUp(self):
3400 super().setUp()
3401 orig_alrm_handler = signal.signal(signal.SIGALRM,
3402 lambda signum, frame: None)
3403 self.addCleanup(signal.signal, signal.SIGALRM, orig_alrm_handler)
3404 self.addCleanup(self.setAlarm, 0)
3405
3406 # Timeout for socket operations
3407 timeout = 4.0
3408
3409 # Provide setAlarm() method to schedule delivery of SIGALRM after
3410 # given number of seconds, or cancel it if zero, and an
3411 # appropriate time value to use. Use setitimer() if available.
3412 if hasattr(signal, "setitimer"):
3413 alarm_time = 0.05
3414
3415 def setAlarm(self, seconds):
3416 signal.setitimer(signal.ITIMER_REAL, seconds)
3417 else:
3418 # Old systems may deliver the alarm up to one second early
3419 alarm_time = 2
3420
3421 def setAlarm(self, seconds):
3422 signal.alarm(seconds)
3423
3424
3425# Require siginterrupt() in order to ensure that system calls are
3426# interrupted by default.
3427@requireAttrs(signal, "siginterrupt")
3428@unittest.skipUnless(hasattr(signal, "alarm") or hasattr(signal, "setitimer"),
3429 "Don't have signal.alarm or signal.setitimer")
3430class InterruptedRecvTimeoutTest(InterruptedTimeoutBase, UDPTestBase):
3431 # Test interrupting the recv*() methods with signals when a
3432 # timeout is set.
3433
3434 def setUp(self):
3435 super().setUp()
3436 self.serv.settimeout(self.timeout)
3437
3438 def checkInterruptedRecv(self, func, *args, **kwargs):
3439 # Check that func(*args, **kwargs) raises socket.error with an
3440 # errno of EINTR when interrupted by a signal.
3441 self.setAlarm(self.alarm_time)
3442 with self.assertRaises(socket.error) as cm:
3443 func(*args, **kwargs)
3444 self.assertNotIsInstance(cm.exception, socket.timeout)
3445 self.assertEqual(cm.exception.errno, errno.EINTR)
3446
3447 def testInterruptedRecvTimeout(self):
3448 self.checkInterruptedRecv(self.serv.recv, 1024)
3449
3450 def testInterruptedRecvIntoTimeout(self):
3451 self.checkInterruptedRecv(self.serv.recv_into, bytearray(1024))
3452
3453 def testInterruptedRecvfromTimeout(self):
3454 self.checkInterruptedRecv(self.serv.recvfrom, 1024)
3455
3456 def testInterruptedRecvfromIntoTimeout(self):
3457 self.checkInterruptedRecv(self.serv.recvfrom_into, bytearray(1024))
3458
3459 @requireAttrs(socket.socket, "recvmsg")
3460 def testInterruptedRecvmsgTimeout(self):
3461 self.checkInterruptedRecv(self.serv.recvmsg, 1024)
3462
3463 @requireAttrs(socket.socket, "recvmsg_into")
3464 def testInterruptedRecvmsgIntoTimeout(self):
3465 self.checkInterruptedRecv(self.serv.recvmsg_into, [bytearray(1024)])
3466
3467
3468# Require siginterrupt() in order to ensure that system calls are
3469# interrupted by default.
3470@requireAttrs(signal, "siginterrupt")
3471@unittest.skipUnless(hasattr(signal, "alarm") or hasattr(signal, "setitimer"),
3472 "Don't have signal.alarm or signal.setitimer")
3473@unittest.skipUnless(thread, 'Threading required for this test.')
3474class InterruptedSendTimeoutTest(InterruptedTimeoutBase,
3475 ThreadSafeCleanupTestCase,
3476 SocketListeningTestMixin, TCPTestBase):
3477 # Test interrupting the interruptible send*() methods with signals
3478 # when a timeout is set.
3479
3480 def setUp(self):
3481 super().setUp()
3482 self.serv_conn = self.newSocket()
3483 self.addCleanup(self.serv_conn.close)
3484 # Use a thread to complete the connection, but wait for it to
3485 # terminate before running the test, so that there is only one
3486 # thread to accept the signal.
3487 cli_thread = threading.Thread(target=self.doConnect)
3488 cli_thread.start()
3489 self.cli_conn, addr = self.serv.accept()
3490 self.addCleanup(self.cli_conn.close)
3491 cli_thread.join()
3492 self.serv_conn.settimeout(self.timeout)
3493
3494 def doConnect(self):
3495 self.serv_conn.connect(self.serv_addr)
3496
3497 def checkInterruptedSend(self, func, *args, **kwargs):
3498 # Check that func(*args, **kwargs), run in a loop, raises
3499 # socket.error with an errno of EINTR when interrupted by a
3500 # signal.
3501 with self.assertRaises(socket.error) as cm:
3502 while True:
3503 self.setAlarm(self.alarm_time)
3504 func(*args, **kwargs)
3505 self.assertNotIsInstance(cm.exception, socket.timeout)
3506 self.assertEqual(cm.exception.errno, errno.EINTR)
3507
Ned Deilyc5640382014-02-03 13:58:31 -08003508 # Issue #12958: The following tests have problems on OS X prior to 10.7
3509 @support.requires_mac_ver(10, 7)
Nick Coghlan96fe56a2011-08-22 11:55:57 +10003510 def testInterruptedSendTimeout(self):
3511 self.checkInterruptedSend(self.serv_conn.send, b"a"*512)
3512
Ned Deilyc5640382014-02-03 13:58:31 -08003513 @support.requires_mac_ver(10, 7)
Nick Coghlan96fe56a2011-08-22 11:55:57 +10003514 def testInterruptedSendtoTimeout(self):
3515 # Passing an actual address here as Python's wrapper for
3516 # sendto() doesn't allow passing a zero-length one; POSIX
3517 # requires that the address is ignored since the socket is
3518 # connection-mode, however.
3519 self.checkInterruptedSend(self.serv_conn.sendto, b"a"*512,
3520 self.serv_addr)
3521
Ned Deilyc5640382014-02-03 13:58:31 -08003522 @support.requires_mac_ver(10, 7)
Nick Coghlan96fe56a2011-08-22 11:55:57 +10003523 @requireAttrs(socket.socket, "sendmsg")
3524 def testInterruptedSendmsgTimeout(self):
3525 self.checkInterruptedSend(self.serv_conn.sendmsg, [b"a"*512])
3526
3527
Victor Stinner45df8202010-04-28 22:31:17 +00003528@unittest.skipUnless(thread, 'Threading required for this test.')
Thomas Wouters0e3f5912006-08-11 14:57:12 +00003529class TCPCloserTest(ThreadedTCPSocketTest):
3530
3531 def testClose(self):
3532 conn, addr = self.serv.accept()
3533 conn.close()
3534
3535 sd = self.cli
3536 read, write, err = select.select([sd], [], [], 1.0)
3537 self.assertEqual(read, [sd])
Guido van Rossum7d0a8262007-05-21 23:13:11 +00003538 self.assertEqual(sd.recv(1), b'')
Thomas Wouters0e3f5912006-08-11 14:57:12 +00003539
Jeremy Hylton5accbdb2007-08-03 20:40:09 +00003540 # Calling close() many times should be safe.
3541 conn.close()
3542 conn.close()
3543
Thomas Wouters0e3f5912006-08-11 14:57:12 +00003544 def _testClose(self):
Christian Heimes5e696852008-04-09 08:37:03 +00003545 self.cli.connect((HOST, self.port))
Thomas Wouters0e3f5912006-08-11 14:57:12 +00003546 time.sleep(1.0)
3547
Serhiy Storchaka79080682013-11-03 21:31:18 +02003548@unittest.skipUnless(hasattr(socket, 'socketpair'),
3549 'test needs socket.socketpair()')
Victor Stinner45df8202010-04-28 22:31:17 +00003550@unittest.skipUnless(thread, 'Threading required for this test.')
Dave Cole331708b2004-08-09 04:51:41 +00003551class BasicSocketPairTest(SocketPairTest):
3552
3553 def __init__(self, methodName='runTest'):
3554 SocketPairTest.__init__(self, methodName=methodName)
3555
Antoine Pitrou2e55fec2010-09-14 21:24:25 +00003556 def _check_defaults(self, sock):
3557 self.assertIsInstance(sock, socket.socket)
3558 if hasattr(socket, 'AF_UNIX'):
3559 self.assertEqual(sock.family, socket.AF_UNIX)
3560 else:
3561 self.assertEqual(sock.family, socket.AF_INET)
3562 self.assertEqual(sock.type, socket.SOCK_STREAM)
3563 self.assertEqual(sock.proto, 0)
3564
Antoine Pitrou9e0b8642010-09-14 18:00:02 +00003565 def _testDefaults(self):
Antoine Pitrou2e55fec2010-09-14 21:24:25 +00003566 self._check_defaults(self.cli)
Antoine Pitrou9e0b8642010-09-14 18:00:02 +00003567
3568 def testDefaults(self):
Antoine Pitrou2e55fec2010-09-14 21:24:25 +00003569 self._check_defaults(self.serv)
Antoine Pitrou9e0b8642010-09-14 18:00:02 +00003570
Dave Cole331708b2004-08-09 04:51:41 +00003571 def testRecv(self):
3572 msg = self.serv.recv(1024)
3573 self.assertEqual(msg, MSG)
3574
3575 def _testRecv(self):
3576 self.cli.send(MSG)
3577
3578 def testSend(self):
3579 self.serv.send(MSG)
3580
3581 def _testSend(self):
3582 msg = self.cli.recv(1024)
3583 self.assertEqual(msg, MSG)
3584
Victor Stinner45df8202010-04-28 22:31:17 +00003585@unittest.skipUnless(thread, 'Threading required for this test.')
Guido van Rossum24e4af82002-06-12 19:18:08 +00003586class NonBlockingTCPTests(ThreadedTCPSocketTest):
3587
3588 def __init__(self, methodName='runTest'):
3589 ThreadedTCPSocketTest.__init__(self, methodName=methodName)
3590
3591 def testSetBlocking(self):
Guido van Rossum8c943832002-08-08 01:00:28 +00003592 # Testing whether set blocking works
Serhiy Storchaka441d30f2013-01-19 12:26:26 +02003593 self.serv.setblocking(True)
3594 self.assertIsNone(self.serv.gettimeout())
3595 self.serv.setblocking(False)
3596 self.assertEqual(self.serv.gettimeout(), 0.0)
Guido van Rossum24e4af82002-06-12 19:18:08 +00003597 start = time.time()
3598 try:
3599 self.serv.accept()
3600 except socket.error:
3601 pass
3602 end = time.time()
Benjamin Petersonc9c0f202009-06-30 23:06:06 +00003603 self.assertTrue((end - start) < 1.0, "Error setting non-blocking mode.")
Guido van Rossum24e4af82002-06-12 19:18:08 +00003604
3605 def _testSetBlocking(self):
Barry Warsaw6870bba2001-03-23 17:40:16 +00003606 pass
Barry Warsawcf3d4b51997-01-03 20:03:32 +00003607
Serhiy Storchaka5cfc79d2014-02-07 10:06:39 +02003608 @support.cpython_only
3609 def testSetBlocking_overflow(self):
3610 # Issue 15989
3611 import _testcapi
3612 if _testcapi.UINT_MAX >= _testcapi.ULONG_MAX:
3613 self.skipTest('needs UINT_MAX < ULONG_MAX')
3614 self.serv.setblocking(False)
3615 self.assertEqual(self.serv.gettimeout(), 0.0)
3616 self.serv.setblocking(_testcapi.UINT_MAX + 1)
3617 self.assertIsNone(self.serv.gettimeout())
3618
3619 _testSetBlocking_overflow = support.cpython_only(_testSetBlocking)
3620
Serhiy Storchaka79080682013-11-03 21:31:18 +02003621 @unittest.skipUnless(hasattr(socket, 'SOCK_NONBLOCK'),
3622 'test needs socket.SOCK_NONBLOCK')
3623 @support.requires_linux_version(2, 6, 28)
3624 def testInitNonBlocking(self):
3625 # reinit server socket
3626 self.serv.close()
3627 self.serv = socket.socket(socket.AF_INET, socket.SOCK_STREAM |
3628 socket.SOCK_NONBLOCK)
3629 self.port = support.bind_port(self.serv)
3630 self.serv.listen(1)
3631 # actual testing
3632 start = time.time()
3633 try:
3634 self.serv.accept()
3635 except socket.error:
Antoine Pitroub1c54962010-10-14 15:05:38 +00003636 pass
Serhiy Storchaka79080682013-11-03 21:31:18 +02003637 end = time.time()
3638 self.assertTrue((end - start) < 1.0, "Error creating with non-blocking mode.")
3639
3640 def _testInitNonBlocking(self):
3641 pass
Antoine Pitroub1c54962010-10-14 15:05:38 +00003642
Antoine Pitrou600232b2011-01-05 21:03:42 +00003643 def testInheritFlags(self):
3644 # Issue #7995: when calling accept() on a listening socket with a
3645 # timeout, the resulting socket should not be non-blocking.
3646 self.serv.settimeout(10)
3647 try:
3648 conn, addr = self.serv.accept()
3649 message = conn.recv(len(MSG))
3650 finally:
3651 conn.close()
3652 self.serv.settimeout(None)
3653
3654 def _testInheritFlags(self):
3655 time.sleep(0.1)
3656 self.cli.connect((HOST, self.port))
3657 time.sleep(0.5)
3658 self.cli.send(MSG)
3659
Guido van Rossum24e4af82002-06-12 19:18:08 +00003660 def testAccept(self):
Guido van Rossum8c943832002-08-08 01:00:28 +00003661 # Testing non-blocking accept
Guido van Rossum24e4af82002-06-12 19:18:08 +00003662 self.serv.setblocking(0)
Guido van Rossum41360a41998-03-26 19:42:58 +00003663 try:
Guido van Rossum24e4af82002-06-12 19:18:08 +00003664 conn, addr = self.serv.accept()
3665 except socket.error:
3666 pass
3667 else:
3668 self.fail("Error trying to do non-blocking accept.")
3669 read, write, err = select.select([self.serv], [], [])
3670 if self.serv in read:
3671 conn, addr = self.serv.accept()
Brian Curtin21ebbb72010-11-02 02:07:09 +00003672 conn.close()
Guido van Rossum24e4af82002-06-12 19:18:08 +00003673 else:
3674 self.fail("Error trying to do accept after select.")
Guido van Rossum67f7a382002-06-06 21:08:16 +00003675
Guido van Rossum24e4af82002-06-12 19:18:08 +00003676 def _testAccept(self):
Guido van Rossumb6cc7d22002-07-19 12:46:46 +00003677 time.sleep(0.1)
Christian Heimes5e696852008-04-09 08:37:03 +00003678 self.cli.connect((HOST, self.port))
Guido van Rossum24e4af82002-06-12 19:18:08 +00003679
3680 def testConnect(self):
Guido van Rossum8c943832002-08-08 01:00:28 +00003681 # Testing non-blocking connect
Guido van Rossum24e4af82002-06-12 19:18:08 +00003682 conn, addr = self.serv.accept()
Brian Curtin21ebbb72010-11-02 02:07:09 +00003683 conn.close()
Guido van Rossum24e4af82002-06-12 19:18:08 +00003684
3685 def _testConnect(self):
Guido van Rossum7b8bac12002-06-13 16:07:04 +00003686 self.cli.settimeout(10)
Christian Heimes5e696852008-04-09 08:37:03 +00003687 self.cli.connect((HOST, self.port))
Guido van Rossum24e4af82002-06-12 19:18:08 +00003688
3689 def testRecv(self):
Guido van Rossum8c943832002-08-08 01:00:28 +00003690 # Testing non-blocking recv
Guido van Rossum24e4af82002-06-12 19:18:08 +00003691 conn, addr = self.serv.accept()
3692 conn.setblocking(0)
3693 try:
3694 msg = conn.recv(len(MSG))
3695 except socket.error:
3696 pass
3697 else:
3698 self.fail("Error trying to do non-blocking recv.")
3699 read, write, err = select.select([conn], [], [])
3700 if conn in read:
3701 msg = conn.recv(len(MSG))
Brian Curtin21ebbb72010-11-02 02:07:09 +00003702 conn.close()
Guido van Rossum76489682002-06-12 20:38:30 +00003703 self.assertEqual(msg, MSG)
Guido van Rossum24e4af82002-06-12 19:18:08 +00003704 else:
3705 self.fail("Error during select call to non-blocking socket.")
3706
3707 def _testRecv(self):
Christian Heimes5e696852008-04-09 08:37:03 +00003708 self.cli.connect((HOST, self.port))
Guido van Rossumb6cc7d22002-07-19 12:46:46 +00003709 time.sleep(0.1)
Guido van Rossum24e4af82002-06-12 19:18:08 +00003710 self.cli.send(MSG)
3711
Victor Stinner45df8202010-04-28 22:31:17 +00003712@unittest.skipUnless(thread, 'Threading required for this test.')
Guido van Rossum24e4af82002-06-12 19:18:08 +00003713class FileObjectClassTestCase(SocketConnectedTest):
Jeremy Hylton5accbdb2007-08-03 20:40:09 +00003714 """Unit tests for the object returned by socket.makefile()
3715
Antoine Pitrou834bd812010-10-13 16:17:14 +00003716 self.read_file is the io object returned by makefile() on
Jeremy Hylton5accbdb2007-08-03 20:40:09 +00003717 the client connection. You can read from this file to
3718 get output from the server.
3719
Antoine Pitrou834bd812010-10-13 16:17:14 +00003720 self.write_file is the io object returned by makefile() on the
Jeremy Hylton5accbdb2007-08-03 20:40:09 +00003721 server connection. You can write to this file to send output
3722 to the client.
3723 """
Guido van Rossum24e4af82002-06-12 19:18:08 +00003724
Guido van Rossume9f66142002-08-07 15:46:19 +00003725 bufsize = -1 # Use default buffer size
Marc-André Lemburg8f36af72011-02-25 15:42:01 +00003726 encoding = 'utf-8'
Antoine Pitrou834bd812010-10-13 16:17:14 +00003727 errors = 'strict'
3728 newline = None
3729
3730 read_mode = 'rb'
3731 read_msg = MSG
3732 write_mode = 'wb'
3733 write_msg = MSG
Guido van Rossume9f66142002-08-07 15:46:19 +00003734
Guido van Rossum24e4af82002-06-12 19:18:08 +00003735 def __init__(self, methodName='runTest'):
3736 SocketConnectedTest.__init__(self, methodName=methodName)
3737
3738 def setUp(self):
Antoine Pitrou98b46702010-09-18 22:59:00 +00003739 self.evt1, self.evt2, self.serv_finished, self.cli_finished = [
3740 threading.Event() for i in range(4)]
Guido van Rossum24e4af82002-06-12 19:18:08 +00003741 SocketConnectedTest.setUp(self)
Antoine Pitrou834bd812010-10-13 16:17:14 +00003742 self.read_file = self.cli_conn.makefile(
3743 self.read_mode, self.bufsize,
3744 encoding = self.encoding,
3745 errors = self.errors,
3746 newline = self.newline)
Guido van Rossum24e4af82002-06-12 19:18:08 +00003747
3748 def tearDown(self):
Antoine Pitrou98b46702010-09-18 22:59:00 +00003749 self.serv_finished.set()
Antoine Pitrou834bd812010-10-13 16:17:14 +00003750 self.read_file.close()
3751 self.assertTrue(self.read_file.closed)
3752 self.read_file = None
Guido van Rossum24e4af82002-06-12 19:18:08 +00003753 SocketConnectedTest.tearDown(self)
3754
3755 def clientSetUp(self):
3756 SocketConnectedTest.clientSetUp(self)
Antoine Pitrou834bd812010-10-13 16:17:14 +00003757 self.write_file = self.serv_conn.makefile(
3758 self.write_mode, self.bufsize,
3759 encoding = self.encoding,
3760 errors = self.errors,
3761 newline = self.newline)
Guido van Rossum24e4af82002-06-12 19:18:08 +00003762
3763 def clientTearDown(self):
Antoine Pitrou98b46702010-09-18 22:59:00 +00003764 self.cli_finished.set()
Antoine Pitrou834bd812010-10-13 16:17:14 +00003765 self.write_file.close()
3766 self.assertTrue(self.write_file.closed)
3767 self.write_file = None
Guido van Rossum24e4af82002-06-12 19:18:08 +00003768 SocketConnectedTest.clientTearDown(self)
3769
Antoine Pitrou68e5c042011-02-25 23:07:44 +00003770 def testReadAfterTimeout(self):
3771 # Issue #7322: A file object must disallow further reads
3772 # after a timeout has occurred.
3773 self.cli_conn.settimeout(1)
3774 self.read_file.read(3)
3775 # First read raises a timeout
3776 self.assertRaises(socket.timeout, self.read_file.read, 1)
3777 # Second read is disallowed
3778 with self.assertRaises(IOError) as ctx:
3779 self.read_file.read(1)
3780 self.assertIn("cannot read from timed out object", str(ctx.exception))
3781
3782 def _testReadAfterTimeout(self):
3783 self.write_file.write(self.write_msg[0:3])
3784 self.write_file.flush()
3785 self.serv_finished.wait()
3786
Guido van Rossum24e4af82002-06-12 19:18:08 +00003787 def testSmallRead(self):
Guido van Rossum8c943832002-08-08 01:00:28 +00003788 # Performing small file read test
Antoine Pitrou834bd812010-10-13 16:17:14 +00003789 first_seg = self.read_file.read(len(self.read_msg)-3)
3790 second_seg = self.read_file.read(3)
Guido van Rossumab659962002-06-12 21:29:43 +00003791 msg = first_seg + second_seg
Antoine Pitrou834bd812010-10-13 16:17:14 +00003792 self.assertEqual(msg, self.read_msg)
Guido van Rossum24e4af82002-06-12 19:18:08 +00003793
3794 def _testSmallRead(self):
Antoine Pitrou834bd812010-10-13 16:17:14 +00003795 self.write_file.write(self.write_msg)
3796 self.write_file.flush()
Guido van Rossum24e4af82002-06-12 19:18:08 +00003797
Guido van Rossum8c943832002-08-08 01:00:28 +00003798 def testFullRead(self):
3799 # read until EOF
Antoine Pitrou834bd812010-10-13 16:17:14 +00003800 msg = self.read_file.read()
3801 self.assertEqual(msg, self.read_msg)
Guido van Rossum8c943832002-08-08 01:00:28 +00003802
3803 def _testFullRead(self):
Antoine Pitrou834bd812010-10-13 16:17:14 +00003804 self.write_file.write(self.write_msg)
3805 self.write_file.close()
Guido van Rossum8c943832002-08-08 01:00:28 +00003806
Guido van Rossum24e4af82002-06-12 19:18:08 +00003807 def testUnbufferedRead(self):
Guido van Rossum8c943832002-08-08 01:00:28 +00003808 # Performing unbuffered file read test
Antoine Pitrou834bd812010-10-13 16:17:14 +00003809 buf = type(self.read_msg)()
Guido van Rossum24e4af82002-06-12 19:18:08 +00003810 while 1:
Antoine Pitrou834bd812010-10-13 16:17:14 +00003811 char = self.read_file.read(1)
Guido van Rossum8c943832002-08-08 01:00:28 +00003812 if not char:
Guido van Rossum24e4af82002-06-12 19:18:08 +00003813 break
Guido van Rossum8c943832002-08-08 01:00:28 +00003814 buf += char
Antoine Pitrou834bd812010-10-13 16:17:14 +00003815 self.assertEqual(buf, self.read_msg)
Guido van Rossum24e4af82002-06-12 19:18:08 +00003816
3817 def _testUnbufferedRead(self):
Antoine Pitrou834bd812010-10-13 16:17:14 +00003818 self.write_file.write(self.write_msg)
3819 self.write_file.flush()
Guido van Rossum24e4af82002-06-12 19:18:08 +00003820
3821 def testReadline(self):
Guido van Rossum8c943832002-08-08 01:00:28 +00003822 # Performing file readline test
Antoine Pitrou834bd812010-10-13 16:17:14 +00003823 line = self.read_file.readline()
3824 self.assertEqual(line, self.read_msg)
Guido van Rossum24e4af82002-06-12 19:18:08 +00003825
3826 def _testReadline(self):
Antoine Pitrou834bd812010-10-13 16:17:14 +00003827 self.write_file.write(self.write_msg)
3828 self.write_file.flush()
Guido van Rossum24e4af82002-06-12 19:18:08 +00003829
Jeremy Hylton5accbdb2007-08-03 20:40:09 +00003830 def testCloseAfterMakefile(self):
3831 # The file returned by makefile should keep the socket open.
3832 self.cli_conn.close()
3833 # read until EOF
Antoine Pitrou834bd812010-10-13 16:17:14 +00003834 msg = self.read_file.read()
3835 self.assertEqual(msg, self.read_msg)
Jeremy Hylton5accbdb2007-08-03 20:40:09 +00003836
3837 def _testCloseAfterMakefile(self):
Antoine Pitrou834bd812010-10-13 16:17:14 +00003838 self.write_file.write(self.write_msg)
3839 self.write_file.flush()
Jeremy Hylton5accbdb2007-08-03 20:40:09 +00003840
3841 def testMakefileAfterMakefileClose(self):
Antoine Pitrou834bd812010-10-13 16:17:14 +00003842 self.read_file.close()
Jeremy Hylton5accbdb2007-08-03 20:40:09 +00003843 msg = self.cli_conn.recv(len(MSG))
Antoine Pitrou834bd812010-10-13 16:17:14 +00003844 if isinstance(self.read_msg, str):
3845 msg = msg.decode()
3846 self.assertEqual(msg, self.read_msg)
Jeremy Hylton5accbdb2007-08-03 20:40:09 +00003847
3848 def _testMakefileAfterMakefileClose(self):
Antoine Pitrou834bd812010-10-13 16:17:14 +00003849 self.write_file.write(self.write_msg)
3850 self.write_file.flush()
Jeremy Hylton5accbdb2007-08-03 20:40:09 +00003851
Tim Peters116d83c2004-03-28 02:20:45 +00003852 def testClosedAttr(self):
Antoine Pitrou834bd812010-10-13 16:17:14 +00003853 self.assertTrue(not self.read_file.closed)
Tim Peters116d83c2004-03-28 02:20:45 +00003854
3855 def _testClosedAttr(self):
Antoine Pitrou834bd812010-10-13 16:17:14 +00003856 self.assertTrue(not self.write_file.closed)
Tim Peters116d83c2004-03-28 02:20:45 +00003857
Amaury Forgeot d'Arc9d24ff02008-11-20 23:15:52 +00003858 def testAttributes(self):
Antoine Pitrou834bd812010-10-13 16:17:14 +00003859 self.assertEqual(self.read_file.mode, self.read_mode)
3860 self.assertEqual(self.read_file.name, self.cli_conn.fileno())
Amaury Forgeot d'Arc9d24ff02008-11-20 23:15:52 +00003861
3862 def _testAttributes(self):
Antoine Pitrou834bd812010-10-13 16:17:14 +00003863 self.assertEqual(self.write_file.mode, self.write_mode)
3864 self.assertEqual(self.write_file.name, self.serv_conn.fileno())
Amaury Forgeot d'Arc9d24ff02008-11-20 23:15:52 +00003865
Gregory P. Smithde3369f2009-01-12 04:50:11 +00003866 def testRealClose(self):
Antoine Pitrou834bd812010-10-13 16:17:14 +00003867 self.read_file.close()
3868 self.assertRaises(ValueError, self.read_file.fileno)
Gregory P. Smithde3369f2009-01-12 04:50:11 +00003869 self.cli_conn.close()
3870 self.assertRaises(socket.error, self.cli_conn.getsockname)
3871
3872 def _testRealClose(self):
3873 pass
3874
3875
Gregory P. Smithaafdca82010-01-04 04:50:36 +00003876class FileObjectInterruptedTestCase(unittest.TestCase):
3877 """Test that the file object correctly handles EINTR internally."""
3878
3879 class MockSocket(object):
3880 def __init__(self, recv_funcs=()):
3881 # A generator that returns callables that we'll call for each
3882 # call to recv().
3883 self._recv_step = iter(recv_funcs)
3884
3885 def recv_into(self, buffer):
3886 data = next(self._recv_step)()
3887 assert len(buffer) >= len(data)
3888 buffer[:len(data)] = data
3889 return len(data)
3890
3891 def _decref_socketios(self):
3892 pass
3893
3894 def _textiowrap_for_test(self, buffering=-1):
3895 raw = socket.SocketIO(self, "r")
3896 if buffering < 0:
3897 buffering = io.DEFAULT_BUFFER_SIZE
3898 if buffering == 0:
3899 return raw
3900 buffer = io.BufferedReader(raw, buffering)
3901 text = io.TextIOWrapper(buffer, None, None)
3902 text.mode = "rb"
3903 return text
3904
3905 @staticmethod
3906 def _raise_eintr():
Antoine Pitrou24d659d2011-10-23 23:49:42 +02003907 raise socket.error(errno.EINTR, "interrupted")
Gregory P. Smithaafdca82010-01-04 04:50:36 +00003908
3909 def _textiowrap_mock_socket(self, mock, buffering=-1):
3910 raw = socket.SocketIO(mock, "r")
3911 if buffering < 0:
3912 buffering = io.DEFAULT_BUFFER_SIZE
3913 if buffering == 0:
3914 return raw
3915 buffer = io.BufferedReader(raw, buffering)
3916 text = io.TextIOWrapper(buffer, None, None)
3917 text.mode = "rb"
3918 return text
3919
3920 def _test_readline(self, size=-1, buffering=-1):
3921 mock_sock = self.MockSocket(recv_funcs=[
3922 lambda : b"This is the first line\nAnd the sec",
3923 self._raise_eintr,
3924 lambda : b"ond line is here\n",
3925 lambda : b"",
3926 lambda : b"", # XXX(gps): io library does an extra EOF read
3927 ])
3928 fo = mock_sock._textiowrap_for_test(buffering=buffering)
Ezio Melottib3aedd42010-11-20 19:04:17 +00003929 self.assertEqual(fo.readline(size), "This is the first line\n")
3930 self.assertEqual(fo.readline(size), "And the second line is here\n")
Gregory P. Smithaafdca82010-01-04 04:50:36 +00003931
3932 def _test_read(self, size=-1, buffering=-1):
3933 mock_sock = self.MockSocket(recv_funcs=[
3934 lambda : b"This is the first line\nAnd the sec",
3935 self._raise_eintr,
3936 lambda : b"ond line is here\n",
3937 lambda : b"",
3938 lambda : b"", # XXX(gps): io library does an extra EOF read
3939 ])
3940 expecting = (b"This is the first line\n"
3941 b"And the second line is here\n")
3942 fo = mock_sock._textiowrap_for_test(buffering=buffering)
3943 if buffering == 0:
3944 data = b''
3945 else:
3946 data = ''
Marc-André Lemburg8f36af72011-02-25 15:42:01 +00003947 expecting = expecting.decode('utf-8')
Gregory P. Smithaafdca82010-01-04 04:50:36 +00003948 while len(data) != len(expecting):
3949 part = fo.read(size)
3950 if not part:
3951 break
3952 data += part
Ezio Melottib3aedd42010-11-20 19:04:17 +00003953 self.assertEqual(data, expecting)
Gregory P. Smithaafdca82010-01-04 04:50:36 +00003954
3955 def test_default(self):
3956 self._test_readline()
3957 self._test_readline(size=100)
3958 self._test_read()
3959 self._test_read(size=100)
3960
3961 def test_with_1k_buffer(self):
3962 self._test_readline(buffering=1024)
3963 self._test_readline(size=100, buffering=1024)
3964 self._test_read(buffering=1024)
3965 self._test_read(size=100, buffering=1024)
3966
3967 def _test_readline_no_buffer(self, size=-1):
3968 mock_sock = self.MockSocket(recv_funcs=[
3969 lambda : b"a",
3970 lambda : b"\n",
3971 lambda : b"B",
3972 self._raise_eintr,
3973 lambda : b"b",
3974 lambda : b"",
3975 ])
3976 fo = mock_sock._textiowrap_for_test(buffering=0)
Ezio Melottib3aedd42010-11-20 19:04:17 +00003977 self.assertEqual(fo.readline(size), b"a\n")
3978 self.assertEqual(fo.readline(size), b"Bb")
Gregory P. Smithaafdca82010-01-04 04:50:36 +00003979
3980 def test_no_buffer(self):
3981 self._test_readline_no_buffer()
3982 self._test_readline_no_buffer(size=4)
3983 self._test_read(buffering=0)
3984 self._test_read(size=100, buffering=0)
3985
3986
Guido van Rossume9f66142002-08-07 15:46:19 +00003987class UnbufferedFileObjectClassTestCase(FileObjectClassTestCase):
3988
3989 """Repeat the tests from FileObjectClassTestCase with bufsize==0.
Tim Peters469cdad2002-08-08 20:19:19 +00003990
Guido van Rossume9f66142002-08-07 15:46:19 +00003991 In this case (and in this case only), it should be possible to
3992 create a file object, read a line from it, create another file
3993 object, read another line from it, without loss of data in the
Georg Brandl24420152008-05-26 16:32:26 +00003994 first file object's buffer. Note that http.client relies on this
Guido van Rossume9f66142002-08-07 15:46:19 +00003995 when reading multiple requests from the same socket."""
3996
3997 bufsize = 0 # Use unbuffered mode
3998
3999 def testUnbufferedReadline(self):
Guido van Rossum8c943832002-08-08 01:00:28 +00004000 # Read a line, create a new file object, read another line with it
Antoine Pitrou834bd812010-10-13 16:17:14 +00004001 line = self.read_file.readline() # first line
4002 self.assertEqual(line, b"A. " + self.write_msg) # first line
4003 self.read_file = self.cli_conn.makefile('rb', 0)
4004 line = self.read_file.readline() # second line
4005 self.assertEqual(line, b"B. " + self.write_msg) # second line
Guido van Rossume9f66142002-08-07 15:46:19 +00004006
4007 def _testUnbufferedReadline(self):
Antoine Pitrou834bd812010-10-13 16:17:14 +00004008 self.write_file.write(b"A. " + self.write_msg)
4009 self.write_file.write(b"B. " + self.write_msg)
4010 self.write_file.flush()
Guido van Rossume9f66142002-08-07 15:46:19 +00004011
Gregory P. Smithde3369f2009-01-12 04:50:11 +00004012 def testMakefileClose(self):
4013 # The file returned by makefile should keep the socket open...
4014 self.cli_conn.close()
4015 msg = self.cli_conn.recv(1024)
Antoine Pitrou834bd812010-10-13 16:17:14 +00004016 self.assertEqual(msg, self.read_msg)
Gregory P. Smithde3369f2009-01-12 04:50:11 +00004017 # ...until the file is itself closed
Antoine Pitrou834bd812010-10-13 16:17:14 +00004018 self.read_file.close()
Gregory P. Smithde3369f2009-01-12 04:50:11 +00004019 self.assertRaises(socket.error, self.cli_conn.recv, 1024)
4020
4021 def _testMakefileClose(self):
Antoine Pitrou834bd812010-10-13 16:17:14 +00004022 self.write_file.write(self.write_msg)
4023 self.write_file.flush()
Gregory P. Smithde3369f2009-01-12 04:50:11 +00004024
4025 def testMakefileCloseSocketDestroy(self):
4026 refcount_before = sys.getrefcount(self.cli_conn)
Antoine Pitrou834bd812010-10-13 16:17:14 +00004027 self.read_file.close()
Gregory P. Smithde3369f2009-01-12 04:50:11 +00004028 refcount_after = sys.getrefcount(self.cli_conn)
4029 self.assertEqual(refcount_before - 1, refcount_after)
4030
4031 def _testMakefileCloseSocketDestroy(self):
4032 pass
4033
Antoine Pitrou98b46702010-09-18 22:59:00 +00004034 # Non-blocking ops
Antoine Pitrou834bd812010-10-13 16:17:14 +00004035 # NOTE: to set `read_file` as non-blocking, we must call
Antoine Pitrou98b46702010-09-18 22:59:00 +00004036 # `cli_conn.setblocking` and vice-versa (see setUp / clientSetUp).
4037
4038 def testSmallReadNonBlocking(self):
4039 self.cli_conn.setblocking(False)
Antoine Pitrou834bd812010-10-13 16:17:14 +00004040 self.assertEqual(self.read_file.readinto(bytearray(10)), None)
4041 self.assertEqual(self.read_file.read(len(self.read_msg) - 3), None)
Antoine Pitrou98b46702010-09-18 22:59:00 +00004042 self.evt1.set()
4043 self.evt2.wait(1.0)
Antoine Pitrou834bd812010-10-13 16:17:14 +00004044 first_seg = self.read_file.read(len(self.read_msg) - 3)
Antoine Pitrou43bf0452011-04-04 01:21:37 +02004045 if first_seg is None:
4046 # Data not arrived (can happen under Windows), wait a bit
4047 time.sleep(0.5)
4048 first_seg = self.read_file.read(len(self.read_msg) - 3)
Antoine Pitrou98b46702010-09-18 22:59:00 +00004049 buf = bytearray(10)
Antoine Pitrou834bd812010-10-13 16:17:14 +00004050 n = self.read_file.readinto(buf)
Antoine Pitrou98b46702010-09-18 22:59:00 +00004051 self.assertEqual(n, 3)
4052 msg = first_seg + buf[:n]
Antoine Pitrou834bd812010-10-13 16:17:14 +00004053 self.assertEqual(msg, self.read_msg)
4054 self.assertEqual(self.read_file.readinto(bytearray(16)), None)
4055 self.assertEqual(self.read_file.read(1), None)
Antoine Pitrou98b46702010-09-18 22:59:00 +00004056
4057 def _testSmallReadNonBlocking(self):
4058 self.evt1.wait(1.0)
Antoine Pitrou834bd812010-10-13 16:17:14 +00004059 self.write_file.write(self.write_msg)
4060 self.write_file.flush()
Antoine Pitrou98b46702010-09-18 22:59:00 +00004061 self.evt2.set()
4062 # Avoid cloding the socket before the server test has finished,
4063 # otherwise system recv() will return 0 instead of EWOULDBLOCK.
4064 self.serv_finished.wait(5.0)
4065
4066 def testWriteNonBlocking(self):
4067 self.cli_finished.wait(5.0)
4068 # The client thread can't skip directly - the SkipTest exception
4069 # would appear as a failure.
4070 if self.serv_skipped:
4071 self.skipTest(self.serv_skipped)
4072
4073 def _testWriteNonBlocking(self):
4074 self.serv_skipped = None
4075 self.serv_conn.setblocking(False)
4076 # Try to saturate the socket buffer pipe with repeated large writes.
Charles-François Natali5fd26422013-08-29 19:01:40 +02004077 BIG = b"x" * support.SOCK_MAX_SIZE
Antoine Pitrou98b46702010-09-18 22:59:00 +00004078 LIMIT = 10
4079 # The first write() succeeds since a chunk of data can be buffered
Antoine Pitrou834bd812010-10-13 16:17:14 +00004080 n = self.write_file.write(BIG)
Antoine Pitrou98b46702010-09-18 22:59:00 +00004081 self.assertGreater(n, 0)
4082 for i in range(LIMIT):
Antoine Pitrou834bd812010-10-13 16:17:14 +00004083 n = self.write_file.write(BIG)
Antoine Pitrou98b46702010-09-18 22:59:00 +00004084 if n is None:
4085 # Succeeded
4086 break
4087 self.assertGreater(n, 0)
4088 else:
4089 # Let us know that this test didn't manage to establish
4090 # the expected conditions. This is not a failure in itself but,
4091 # if it happens repeatedly, the test should be fixed.
4092 self.serv_skipped = "failed to saturate the socket buffer"
4093
Gregory P. Smithde3369f2009-01-12 04:50:11 +00004094
Guido van Rossum8c943832002-08-08 01:00:28 +00004095class LineBufferedFileObjectClassTestCase(FileObjectClassTestCase):
4096
4097 bufsize = 1 # Default-buffered for reading; line-buffered for writing
4098
4099
4100class SmallBufferedFileObjectClassTestCase(FileObjectClassTestCase):
4101
4102 bufsize = 2 # Exercise the buffering code
Guido van Rossume9f66142002-08-07 15:46:19 +00004103
Thomas Woutersb2137042007-02-01 18:02:27 +00004104
Antoine Pitrou834bd812010-10-13 16:17:14 +00004105class UnicodeReadFileObjectClassTestCase(FileObjectClassTestCase):
4106 """Tests for socket.makefile() in text mode (rather than binary)"""
4107
4108 read_mode = 'r'
Marc-André Lemburg8f36af72011-02-25 15:42:01 +00004109 read_msg = MSG.decode('utf-8')
Antoine Pitrou834bd812010-10-13 16:17:14 +00004110 write_mode = 'wb'
4111 write_msg = MSG
4112 newline = ''
4113
4114
4115class UnicodeWriteFileObjectClassTestCase(FileObjectClassTestCase):
4116 """Tests for socket.makefile() in text mode (rather than binary)"""
4117
4118 read_mode = 'rb'
4119 read_msg = MSG
4120 write_mode = 'w'
Marc-André Lemburg8f36af72011-02-25 15:42:01 +00004121 write_msg = MSG.decode('utf-8')
Antoine Pitrou834bd812010-10-13 16:17:14 +00004122 newline = ''
4123
4124
4125class UnicodeReadWriteFileObjectClassTestCase(FileObjectClassTestCase):
4126 """Tests for socket.makefile() in text mode (rather than binary)"""
4127
4128 read_mode = 'r'
Marc-André Lemburg8f36af72011-02-25 15:42:01 +00004129 read_msg = MSG.decode('utf-8')
Antoine Pitrou834bd812010-10-13 16:17:14 +00004130 write_mode = 'w'
Marc-André Lemburg8f36af72011-02-25 15:42:01 +00004131 write_msg = MSG.decode('utf-8')
Antoine Pitrou834bd812010-10-13 16:17:14 +00004132 newline = ''
4133
4134
Guido van Rossumd8faa362007-04-27 19:54:29 +00004135class NetworkConnectionTest(object):
4136 """Prove network connection."""
Guido van Rossum7d0a8262007-05-21 23:13:11 +00004137
Guido van Rossumd8faa362007-04-27 19:54:29 +00004138 def clientSetUp(self):
Christian Heimes5e696852008-04-09 08:37:03 +00004139 # We're inherited below by BasicTCPTest2, which also inherits
4140 # BasicTCPTest, which defines self.port referenced below.
4141 self.cli = socket.create_connection((HOST, self.port))
Guido van Rossumd8faa362007-04-27 19:54:29 +00004142 self.serv_conn = self.cli
4143
4144class BasicTCPTest2(NetworkConnectionTest, BasicTCPTest):
4145 """Tests that NetworkConnection does not break existing TCP functionality.
4146 """
4147
4148class NetworkConnectionNoServer(unittest.TestCase):
Guido van Rossum7d0a8262007-05-21 23:13:11 +00004149
Antoine Pitrou4b92b5f2010-09-07 21:05:49 +00004150 class MockSocket(socket.socket):
4151 def connect(self, *args):
4152 raise socket.timeout('timed out')
4153
4154 @contextlib.contextmanager
4155 def mocked_socket_module(self):
4156 """Return a socket which times out on connect"""
4157 old_socket = socket.socket
4158 socket.socket = self.MockSocket
4159 try:
4160 yield
4161 finally:
4162 socket.socket = old_socket
4163
4164 def test_connect(self):
Benjamin Petersonee8712c2008-05-20 21:35:26 +00004165 port = support.find_unused_port()
Antoine Pitrou4b92b5f2010-09-07 21:05:49 +00004166 cli = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
Brian Curtin21ebbb72010-11-02 02:07:09 +00004167 self.addCleanup(cli.close)
Antoine Pitrou4b92b5f2010-09-07 21:05:49 +00004168 with self.assertRaises(socket.error) as cm:
4169 cli.connect((HOST, port))
4170 self.assertEqual(cm.exception.errno, errno.ECONNREFUSED)
4171
4172 def test_create_connection(self):
4173 # Issue #9792: errors raised by create_connection() should have
4174 # a proper errno attribute.
4175 port = support.find_unused_port()
4176 with self.assertRaises(socket.error) as cm:
4177 socket.create_connection((HOST, port))
Trent Nelson45bb6132012-10-17 06:15:15 -04004178
4179 # Issue #16257: create_connection() calls getaddrinfo() against
4180 # 'localhost'. This may result in an IPV6 addr being returned
4181 # as well as an IPV4 one:
4182 # >>> socket.getaddrinfo('localhost', port, 0, SOCK_STREAM)
4183 # >>> [(2, 2, 0, '', ('127.0.0.1', 41230)),
4184 # (26, 2, 0, '', ('::1', 41230, 0, 0))]
4185 #
4186 # create_connection() enumerates through all the addresses returned
4187 # and if it doesn't successfully bind to any of them, it propagates
4188 # the last exception it encountered.
4189 #
4190 # On Solaris, ENETUNREACH is returned in this circumstance instead
4191 # of ECONNREFUSED. So, if that errno exists, add it to our list of
4192 # expected errnos.
4193 expected_errnos = [ errno.ECONNREFUSED, ]
4194 if hasattr(errno, 'ENETUNREACH'):
4195 expected_errnos.append(errno.ENETUNREACH)
4196
4197 self.assertIn(cm.exception.errno, expected_errnos)
Antoine Pitrou4b92b5f2010-09-07 21:05:49 +00004198
4199 def test_create_connection_timeout(self):
4200 # Issue #9792: create_connection() should not recast timeout errors
4201 # as generic socket errors.
4202 with self.mocked_socket_module():
4203 with self.assertRaises(socket.timeout):
4204 socket.create_connection((HOST, 1234))
4205
Guido van Rossumd8faa362007-04-27 19:54:29 +00004206
Victor Stinner45df8202010-04-28 22:31:17 +00004207@unittest.skipUnless(thread, 'Threading required for this test.')
Guido van Rossumd8faa362007-04-27 19:54:29 +00004208class NetworkConnectionAttributesTest(SocketTCPTest, ThreadableTest):
4209
4210 def __init__(self, methodName='runTest'):
4211 SocketTCPTest.__init__(self, methodName=methodName)
4212 ThreadableTest.__init__(self)
4213
4214 def clientSetUp(self):
Gregory P. Smithb4066372010-01-03 03:28:29 +00004215 self.source_port = support.find_unused_port()
Guido van Rossumd8faa362007-04-27 19:54:29 +00004216
4217 def clientTearDown(self):
4218 self.cli.close()
4219 self.cli = None
4220 ThreadableTest.clientTearDown(self)
4221
4222 def _justAccept(self):
4223 conn, addr = self.serv.accept()
Brian Curtin21ebbb72010-11-02 02:07:09 +00004224 conn.close()
Guido van Rossumd8faa362007-04-27 19:54:29 +00004225
4226 testFamily = _justAccept
4227 def _testFamily(self):
Christian Heimes5e696852008-04-09 08:37:03 +00004228 self.cli = socket.create_connection((HOST, self.port), timeout=30)
Brian Curtin21ebbb72010-11-02 02:07:09 +00004229 self.addCleanup(self.cli.close)
Guido van Rossumd8faa362007-04-27 19:54:29 +00004230 self.assertEqual(self.cli.family, 2)
4231
Gregory P. Smitha81d8812010-01-03 15:09:32 +00004232 testSourceAddress = _justAccept
4233 def _testSourceAddress(self):
Gregory P. Smithb4066372010-01-03 03:28:29 +00004234 self.cli = socket.create_connection((HOST, self.port), timeout=30,
4235 source_address=('', self.source_port))
Brian Curtin21ebbb72010-11-02 02:07:09 +00004236 self.addCleanup(self.cli.close)
Gregory P. Smithb4066372010-01-03 03:28:29 +00004237 self.assertEqual(self.cli.getsockname()[1], self.source_port)
Gregory P. Smitha81d8812010-01-03 15:09:32 +00004238 # The port number being used is sufficient to show that the bind()
4239 # call happened.
Gregory P. Smithb4066372010-01-03 03:28:29 +00004240
Guido van Rossumd8faa362007-04-27 19:54:29 +00004241 testTimeoutDefault = _justAccept
4242 def _testTimeoutDefault(self):
Georg Brandlf78e02b2008-06-10 17:40:04 +00004243 # passing no explicit timeout uses socket's global default
Benjamin Petersonc9c0f202009-06-30 23:06:06 +00004244 self.assertTrue(socket.getdefaulttimeout() is None)
Georg Brandlf78e02b2008-06-10 17:40:04 +00004245 socket.setdefaulttimeout(42)
4246 try:
4247 self.cli = socket.create_connection((HOST, self.port))
Brian Curtin21ebbb72010-11-02 02:07:09 +00004248 self.addCleanup(self.cli.close)
Georg Brandlf78e02b2008-06-10 17:40:04 +00004249 finally:
4250 socket.setdefaulttimeout(None)
Ezio Melottib3aedd42010-11-20 19:04:17 +00004251 self.assertEqual(self.cli.gettimeout(), 42)
Georg Brandlf78e02b2008-06-10 17:40:04 +00004252
4253 testTimeoutNone = _justAccept
4254 def _testTimeoutNone(self):
4255 # None timeout means the same as sock.settimeout(None)
Benjamin Petersonc9c0f202009-06-30 23:06:06 +00004256 self.assertTrue(socket.getdefaulttimeout() is None)
Georg Brandlf78e02b2008-06-10 17:40:04 +00004257 socket.setdefaulttimeout(30)
4258 try:
4259 self.cli = socket.create_connection((HOST, self.port), timeout=None)
Brian Curtin21ebbb72010-11-02 02:07:09 +00004260 self.addCleanup(self.cli.close)
Georg Brandlf78e02b2008-06-10 17:40:04 +00004261 finally:
4262 socket.setdefaulttimeout(None)
4263 self.assertEqual(self.cli.gettimeout(), None)
Guido van Rossumd8faa362007-04-27 19:54:29 +00004264
4265 testTimeoutValueNamed = _justAccept
4266 def _testTimeoutValueNamed(self):
Christian Heimes5e696852008-04-09 08:37:03 +00004267 self.cli = socket.create_connection((HOST, self.port), timeout=30)
Guido van Rossumd8faa362007-04-27 19:54:29 +00004268 self.assertEqual(self.cli.gettimeout(), 30)
4269
4270 testTimeoutValueNonamed = _justAccept
4271 def _testTimeoutValueNonamed(self):
Christian Heimes5e696852008-04-09 08:37:03 +00004272 self.cli = socket.create_connection((HOST, self.port), 30)
Brian Curtin21ebbb72010-11-02 02:07:09 +00004273 self.addCleanup(self.cli.close)
Guido van Rossumd8faa362007-04-27 19:54:29 +00004274 self.assertEqual(self.cli.gettimeout(), 30)
4275
Victor Stinner45df8202010-04-28 22:31:17 +00004276@unittest.skipUnless(thread, 'Threading required for this test.')
Guido van Rossumd8faa362007-04-27 19:54:29 +00004277class NetworkConnectionBehaviourTest(SocketTCPTest, ThreadableTest):
4278
4279 def __init__(self, methodName='runTest'):
4280 SocketTCPTest.__init__(self, methodName=methodName)
4281 ThreadableTest.__init__(self)
4282
4283 def clientSetUp(self):
4284 pass
4285
4286 def clientTearDown(self):
4287 self.cli.close()
4288 self.cli = None
4289 ThreadableTest.clientTearDown(self)
4290
4291 def testInsideTimeout(self):
4292 conn, addr = self.serv.accept()
Brian Curtin21ebbb72010-11-02 02:07:09 +00004293 self.addCleanup(conn.close)
Guido van Rossumd8faa362007-04-27 19:54:29 +00004294 time.sleep(3)
Guido van Rossum7d0a8262007-05-21 23:13:11 +00004295 conn.send(b"done!")
Guido van Rossumd8faa362007-04-27 19:54:29 +00004296 testOutsideTimeout = testInsideTimeout
4297
4298 def _testInsideTimeout(self):
Christian Heimes5e696852008-04-09 08:37:03 +00004299 self.cli = sock = socket.create_connection((HOST, self.port))
Guido van Rossumd8faa362007-04-27 19:54:29 +00004300 data = sock.recv(5)
Guido van Rossum7d0a8262007-05-21 23:13:11 +00004301 self.assertEqual(data, b"done!")
Guido van Rossumd8faa362007-04-27 19:54:29 +00004302
4303 def _testOutsideTimeout(self):
Christian Heimes5e696852008-04-09 08:37:03 +00004304 self.cli = sock = socket.create_connection((HOST, self.port), timeout=1)
Benjamin Petersonc9c0f202009-06-30 23:06:06 +00004305 self.assertRaises(socket.timeout, lambda: sock.recv(5))
Guido van Rossumd8faa362007-04-27 19:54:29 +00004306
4307
Raymond Hettinger11a35f52003-06-29 04:40:22 +00004308class TCPTimeoutTest(SocketTCPTest):
4309
4310 def testTCPTimeout(self):
4311 def raise_timeout(*args, **kwargs):
4312 self.serv.settimeout(1.0)
4313 self.serv.accept()
Benjamin Petersonc9c0f202009-06-30 23:06:06 +00004314 self.assertRaises(socket.timeout, raise_timeout,
Raymond Hettinger11a35f52003-06-29 04:40:22 +00004315 "Error generating a timeout exception (TCP)")
4316
4317 def testTimeoutZero(self):
4318 ok = False
4319 try:
4320 self.serv.settimeout(0.0)
4321 foo = self.serv.accept()
4322 except socket.timeout:
4323 self.fail("caught timeout instead of error (TCP)")
4324 except socket.error:
4325 ok = True
4326 except:
4327 self.fail("caught unexpected exception (TCP)")
4328 if not ok:
4329 self.fail("accept() returned success when we did not expect it")
4330
Serhiy Storchaka79080682013-11-03 21:31:18 +02004331 @unittest.skipUnless(hasattr(signal, 'alarm'),
4332 'test needs signal.alarm()')
Thomas Wouters0e3f5912006-08-11 14:57:12 +00004333 def testInterruptedTimeout(self):
4334 # XXX I don't know how to do this test on MSWindows or any other
4335 # plaform that doesn't support signal.alarm() or os.kill(), though
4336 # the bug should have existed on all platforms.
Thomas Wouters0e3f5912006-08-11 14:57:12 +00004337 self.serv.settimeout(5.0) # must be longer than alarm
4338 class Alarm(Exception):
4339 pass
4340 def alarm_handler(signal, frame):
4341 raise Alarm
4342 old_alarm = signal.signal(signal.SIGALRM, alarm_handler)
4343 try:
4344 signal.alarm(2) # POSIX allows alarm to be up to 1 second early
4345 try:
4346 foo = self.serv.accept()
4347 except socket.timeout:
4348 self.fail("caught timeout instead of Alarm")
4349 except Alarm:
4350 pass
4351 except:
Christian Heimesbbe741d2008-03-28 10:53:29 +00004352 self.fail("caught other exception instead of Alarm:"
4353 " %s(%s):\n%s" %
4354 (sys.exc_info()[:2] + (traceback.format_exc(),)))
Thomas Wouters0e3f5912006-08-11 14:57:12 +00004355 else:
4356 self.fail("nothing caught")
Christian Heimesbbe741d2008-03-28 10:53:29 +00004357 finally:
4358 signal.alarm(0) # shut off alarm
Thomas Wouters0e3f5912006-08-11 14:57:12 +00004359 except Alarm:
4360 self.fail("got Alarm in wrong place")
4361 finally:
4362 # no alarm can be pending. Safe to restore old handler.
4363 signal.signal(signal.SIGALRM, old_alarm)
4364
Ezio Melotti7f78ddc2011-11-18 18:33:14 +02004365class UDPTimeoutTest(SocketUDPTest):
Raymond Hettinger11a35f52003-06-29 04:40:22 +00004366
4367 def testUDPTimeout(self):
4368 def raise_timeout(*args, **kwargs):
4369 self.serv.settimeout(1.0)
4370 self.serv.recv(1024)
Benjamin Petersonc9c0f202009-06-30 23:06:06 +00004371 self.assertRaises(socket.timeout, raise_timeout,
Raymond Hettinger11a35f52003-06-29 04:40:22 +00004372 "Error generating a timeout exception (UDP)")
4373
4374 def testTimeoutZero(self):
4375 ok = False
4376 try:
4377 self.serv.settimeout(0.0)
4378 foo = self.serv.recv(1024)
4379 except socket.timeout:
4380 self.fail("caught timeout instead of error (UDP)")
4381 except socket.error:
4382 ok = True
4383 except:
4384 self.fail("caught unexpected exception (UDP)")
4385 if not ok:
4386 self.fail("recv() returned success when we did not expect it")
4387
4388class TestExceptions(unittest.TestCase):
4389
4390 def testExceptionTree(self):
Benjamin Petersonc9c0f202009-06-30 23:06:06 +00004391 self.assertTrue(issubclass(socket.error, Exception))
4392 self.assertTrue(issubclass(socket.herror, socket.error))
4393 self.assertTrue(issubclass(socket.gaierror, socket.error))
4394 self.assertTrue(issubclass(socket.timeout, socket.error))
Raymond Hettinger11a35f52003-06-29 04:40:22 +00004395
Serhiy Storchaka79080682013-11-03 21:31:18 +02004396@unittest.skipUnless(sys.platform == 'linux', 'Linux specific test')
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00004397class TestLinuxAbstractNamespace(unittest.TestCase):
4398
4399 UNIX_PATH_MAX = 108
4400
4401 def testLinuxAbstractNamespace(self):
Guido van Rossum32c4ac02007-08-15 03:56:40 +00004402 address = b"\x00python-test-hello\x00\xff"
Victor Stinner1d5eb342011-01-03 14:30:46 +00004403 with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as s1:
4404 s1.bind(address)
4405 s1.listen(1)
4406 with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as s2:
4407 s2.connect(s1.getsockname())
4408 with s1.accept()[0] as s3:
4409 self.assertEqual(s1.getsockname(), address)
4410 self.assertEqual(s2.getpeername(), address)
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00004411
4412 def testMaxName(self):
Guido van Rossum32c4ac02007-08-15 03:56:40 +00004413 address = b"\x00" + b"h" * (self.UNIX_PATH_MAX - 1)
Victor Stinner1d5eb342011-01-03 14:30:46 +00004414 with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as s:
4415 s.bind(address)
4416 self.assertEqual(s.getsockname(), address)
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00004417
4418 def testNameOverflow(self):
4419 address = "\x00" + "h" * self.UNIX_PATH_MAX
Victor Stinner1d5eb342011-01-03 14:30:46 +00004420 with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as s:
4421 self.assertRaises(socket.error, s.bind, address)
Thomas Wouters49fd7fa2006-04-21 10:40:58 +00004422
Antoine Pitrou6ec29e22011-12-16 14:46:36 +01004423 def testStrName(self):
4424 # Check that an abstract name can be passed as a string.
4425 s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
4426 try:
4427 s.bind("\x00python\x00test\x00")
4428 self.assertEqual(s.getsockname(), b"\x00python\x00test\x00")
4429 finally:
4430 s.close()
4431
Serhiy Storchaka79080682013-11-03 21:31:18 +02004432@unittest.skipUnless(hasattr(socket, 'AF_UNIX'), 'test needs socket.AF_UNIX')
Antoine Pitrou6ec29e22011-12-16 14:46:36 +01004433class TestUnixDomain(unittest.TestCase):
4434
4435 def setUp(self):
4436 self.sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
4437
4438 def tearDown(self):
4439 self.sock.close()
4440
4441 def encoded(self, path):
4442 # Return the given path encoded in the file system encoding,
4443 # or skip the test if this is not possible.
4444 try:
4445 return os.fsencode(path)
4446 except UnicodeEncodeError:
4447 self.skipTest(
4448 "Pathname {0!a} cannot be represented in file "
4449 "system encoding {1!r}".format(
4450 path, sys.getfilesystemencoding()))
4451
Antoine Pitrou16374872011-12-16 15:04:12 +01004452 def bind(self, sock, path):
4453 # Bind the socket
4454 try:
4455 sock.bind(path)
4456 except OSError as e:
4457 if str(e) == "AF_UNIX path too long":
4458 self.skipTest(
4459 "Pathname {0!a} is too long to serve as a AF_UNIX path"
4460 .format(path))
4461 else:
4462 raise
4463
Antoine Pitrou6ec29e22011-12-16 14:46:36 +01004464 def testStrAddr(self):
4465 # Test binding to and retrieving a normal string pathname.
4466 path = os.path.abspath(support.TESTFN)
Antoine Pitrou16374872011-12-16 15:04:12 +01004467 self.bind(self.sock, path)
Antoine Pitrou6ec29e22011-12-16 14:46:36 +01004468 self.addCleanup(support.unlink, path)
4469 self.assertEqual(self.sock.getsockname(), path)
4470
4471 def testBytesAddr(self):
4472 # Test binding to a bytes pathname.
4473 path = os.path.abspath(support.TESTFN)
Antoine Pitrou16374872011-12-16 15:04:12 +01004474 self.bind(self.sock, self.encoded(path))
Antoine Pitrou6ec29e22011-12-16 14:46:36 +01004475 self.addCleanup(support.unlink, path)
4476 self.assertEqual(self.sock.getsockname(), path)
4477
4478 def testSurrogateescapeBind(self):
4479 # Test binding to a valid non-ASCII pathname, with the
4480 # non-ASCII bytes supplied using surrogateescape encoding.
4481 path = os.path.abspath(support.TESTFN_UNICODE)
4482 b = self.encoded(path)
Antoine Pitrou16374872011-12-16 15:04:12 +01004483 self.bind(self.sock, b.decode("ascii", "surrogateescape"))
Antoine Pitrou6ec29e22011-12-16 14:46:36 +01004484 self.addCleanup(support.unlink, path)
4485 self.assertEqual(self.sock.getsockname(), path)
4486
4487 def testUnencodableAddr(self):
4488 # Test binding to a pathname that cannot be encoded in the
4489 # file system encoding.
4490 if support.TESTFN_UNENCODABLE is None:
4491 self.skipTest("No unencodable filename available")
4492 path = os.path.abspath(support.TESTFN_UNENCODABLE)
Antoine Pitrou16374872011-12-16 15:04:12 +01004493 self.bind(self.sock, path)
Antoine Pitrou6ec29e22011-12-16 14:46:36 +01004494 self.addCleanup(support.unlink, path)
4495 self.assertEqual(self.sock.getsockname(), path)
Raymond Hettinger11a35f52003-06-29 04:40:22 +00004496
Victor Stinner45df8202010-04-28 22:31:17 +00004497@unittest.skipUnless(thread, 'Threading required for this test.')
Thomas Wouters477c8d52006-05-27 19:21:47 +00004498class BufferIOTest(SocketConnectedTest):
4499 """
4500 Test the buffer versions of socket.recv() and socket.send().
4501 """
4502 def __init__(self, methodName='runTest'):
4503 SocketConnectedTest.__init__(self, methodName=methodName)
4504
Antoine Pitrou25480782010-03-17 22:50:28 +00004505 def testRecvIntoArray(self):
Antoine Pitrou2f89aa62008-08-02 21:02:48 +00004506 buf = bytearray(1024)
Thomas Wouters73e5a5b2006-06-08 15:35:45 +00004507 nbytes = self.cli_conn.recv_into(buf)
Thomas Wouters477c8d52006-05-27 19:21:47 +00004508 self.assertEqual(nbytes, len(MSG))
Guido van Rossum7d0a8262007-05-21 23:13:11 +00004509 msg = buf[:len(MSG)]
Thomas Wouters477c8d52006-05-27 19:21:47 +00004510 self.assertEqual(msg, MSG)
4511
Antoine Pitrou25480782010-03-17 22:50:28 +00004512 def _testRecvIntoArray(self):
Guido van Rossumb5b22702007-05-18 18:55:53 +00004513 buf = bytes(MSG)
Thomas Wouters477c8d52006-05-27 19:21:47 +00004514 self.serv_conn.send(buf)
4515
Antoine Pitrou25480782010-03-17 22:50:28 +00004516 def testRecvIntoBytearray(self):
4517 buf = bytearray(1024)
4518 nbytes = self.cli_conn.recv_into(buf)
4519 self.assertEqual(nbytes, len(MSG))
4520 msg = buf[:len(MSG)]
4521 self.assertEqual(msg, MSG)
4522
4523 _testRecvIntoBytearray = _testRecvIntoArray
4524
4525 def testRecvIntoMemoryview(self):
4526 buf = bytearray(1024)
4527 nbytes = self.cli_conn.recv_into(memoryview(buf))
4528 self.assertEqual(nbytes, len(MSG))
4529 msg = buf[:len(MSG)]
4530 self.assertEqual(msg, MSG)
4531
4532 _testRecvIntoMemoryview = _testRecvIntoArray
4533
4534 def testRecvFromIntoArray(self):
Antoine Pitrou2f89aa62008-08-02 21:02:48 +00004535 buf = bytearray(1024)
Thomas Wouters73e5a5b2006-06-08 15:35:45 +00004536 nbytes, addr = self.cli_conn.recvfrom_into(buf)
Thomas Wouters477c8d52006-05-27 19:21:47 +00004537 self.assertEqual(nbytes, len(MSG))
Guido van Rossum7d0a8262007-05-21 23:13:11 +00004538 msg = buf[:len(MSG)]
Thomas Wouters477c8d52006-05-27 19:21:47 +00004539 self.assertEqual(msg, MSG)
4540
Antoine Pitrou25480782010-03-17 22:50:28 +00004541 def _testRecvFromIntoArray(self):
Guido van Rossumb5b22702007-05-18 18:55:53 +00004542 buf = bytes(MSG)
Thomas Wouters477c8d52006-05-27 19:21:47 +00004543 self.serv_conn.send(buf)
4544
Antoine Pitrou25480782010-03-17 22:50:28 +00004545 def testRecvFromIntoBytearray(self):
4546 buf = bytearray(1024)
4547 nbytes, addr = self.cli_conn.recvfrom_into(buf)
4548 self.assertEqual(nbytes, len(MSG))
4549 msg = buf[:len(MSG)]
4550 self.assertEqual(msg, MSG)
4551
4552 _testRecvFromIntoBytearray = _testRecvFromIntoArray
4553
4554 def testRecvFromIntoMemoryview(self):
4555 buf = bytearray(1024)
4556 nbytes, addr = self.cli_conn.recvfrom_into(memoryview(buf))
4557 self.assertEqual(nbytes, len(MSG))
4558 msg = buf[:len(MSG)]
4559 self.assertEqual(msg, MSG)
4560
4561 _testRecvFromIntoMemoryview = _testRecvFromIntoArray
4562
Benjamin Petersonfbf648e2014-01-13 22:59:38 -05004563 def testRecvFromIntoSmallBuffer(self):
4564 # See issue #20246.
4565 buf = bytearray(8)
4566 self.assertRaises(ValueError, self.cli_conn.recvfrom_into, buf, 1024)
4567
4568 def _testRecvFromIntoSmallBuffer(self):
Stefan Krah6b2e5592014-01-21 22:58:40 +01004569 self.serv_conn.send(MSG)
Benjamin Petersonfbf648e2014-01-13 22:59:38 -05004570
Benjamin Petersonbd1d12e2014-01-14 00:27:42 -05004571 def testRecvFromIntoEmptyBuffer(self):
4572 buf = bytearray()
4573 self.cli_conn.recvfrom_into(buf)
4574 self.cli_conn.recvfrom_into(buf, 0)
4575
4576 _testRecvFromIntoEmptyBuffer = _testRecvFromIntoArray
4577
Christian Heimes043d6f62008-01-07 17:19:16 +00004578
4579TIPC_STYPE = 2000
4580TIPC_LOWER = 200
4581TIPC_UPPER = 210
4582
4583def isTipcAvailable():
4584 """Check if the TIPC module is loaded
4585
4586 The TIPC module is not loaded automatically on Ubuntu and probably
4587 other Linux distros.
4588 """
4589 if not hasattr(socket, "AF_TIPC"):
4590 return False
4591 if not os.path.isfile("/proc/modules"):
4592 return False
4593 with open("/proc/modules") as f:
4594 for line in f:
4595 if line.startswith("tipc "):
4596 return True
Christian Heimes043d6f62008-01-07 17:19:16 +00004597 return False
4598
Serhiy Storchaka79080682013-11-03 21:31:18 +02004599@unittest.skipUnless(isTipcAvailable(),
4600 "TIPC module is not loaded, please 'sudo modprobe tipc'")
Antoine Pitrou86aed0b2011-10-02 23:33:19 +02004601class TIPCTest(unittest.TestCase):
Christian Heimes043d6f62008-01-07 17:19:16 +00004602 def testRDM(self):
4603 srv = socket.socket(socket.AF_TIPC, socket.SOCK_RDM)
4604 cli = socket.socket(socket.AF_TIPC, socket.SOCK_RDM)
Antoine Pitrou86aed0b2011-10-02 23:33:19 +02004605 self.addCleanup(srv.close)
4606 self.addCleanup(cli.close)
Christian Heimes043d6f62008-01-07 17:19:16 +00004607
4608 srv.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
4609 srvaddr = (socket.TIPC_ADDR_NAMESEQ, TIPC_STYPE,
4610 TIPC_LOWER, TIPC_UPPER)
4611 srv.bind(srvaddr)
4612
4613 sendaddr = (socket.TIPC_ADDR_NAME, TIPC_STYPE,
4614 TIPC_LOWER + int((TIPC_UPPER - TIPC_LOWER) / 2), 0)
4615 cli.sendto(MSG, sendaddr)
4616
4617 msg, recvaddr = srv.recvfrom(1024)
4618
4619 self.assertEqual(cli.getsockname(), recvaddr)
4620 self.assertEqual(msg, MSG)
4621
4622
Serhiy Storchaka79080682013-11-03 21:31:18 +02004623@unittest.skipUnless(isTipcAvailable(),
4624 "TIPC module is not loaded, please 'sudo modprobe tipc'")
Antoine Pitrou86aed0b2011-10-02 23:33:19 +02004625class TIPCThreadableTest(unittest.TestCase, ThreadableTest):
Christian Heimes043d6f62008-01-07 17:19:16 +00004626 def __init__(self, methodName = 'runTest'):
4627 unittest.TestCase.__init__(self, methodName = methodName)
4628 ThreadableTest.__init__(self)
4629
4630 def setUp(self):
4631 self.srv = socket.socket(socket.AF_TIPC, socket.SOCK_STREAM)
Antoine Pitrou86aed0b2011-10-02 23:33:19 +02004632 self.addCleanup(self.srv.close)
Christian Heimes043d6f62008-01-07 17:19:16 +00004633 self.srv.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
4634 srvaddr = (socket.TIPC_ADDR_NAMESEQ, TIPC_STYPE,
4635 TIPC_LOWER, TIPC_UPPER)
4636 self.srv.bind(srvaddr)
4637 self.srv.listen(5)
4638 self.serverExplicitReady()
4639 self.conn, self.connaddr = self.srv.accept()
Antoine Pitrou86aed0b2011-10-02 23:33:19 +02004640 self.addCleanup(self.conn.close)
Christian Heimes043d6f62008-01-07 17:19:16 +00004641
4642 def clientSetUp(self):
4643 # The is a hittable race between serverExplicitReady() and the
4644 # accept() call; sleep a little while to avoid it, otherwise
4645 # we could get an exception
4646 time.sleep(0.1)
4647 self.cli = socket.socket(socket.AF_TIPC, socket.SOCK_STREAM)
Antoine Pitrou86aed0b2011-10-02 23:33:19 +02004648 self.addCleanup(self.cli.close)
Christian Heimes043d6f62008-01-07 17:19:16 +00004649 addr = (socket.TIPC_ADDR_NAME, TIPC_STYPE,
4650 TIPC_LOWER + int((TIPC_UPPER - TIPC_LOWER) / 2), 0)
4651 self.cli.connect(addr)
4652 self.cliaddr = self.cli.getsockname()
4653
4654 def testStream(self):
4655 msg = self.conn.recv(1024)
4656 self.assertEqual(msg, MSG)
4657 self.assertEqual(self.cliaddr, self.connaddr)
4658
4659 def _testStream(self):
4660 self.cli.send(MSG)
4661 self.cli.close()
4662
4663
Giampaolo Rodolàb383dbb2010-09-08 22:44:12 +00004664@unittest.skipUnless(thread, 'Threading required for this test.')
4665class ContextManagersTest(ThreadedTCPSocketTest):
4666
4667 def _testSocketClass(self):
4668 # base test
4669 with socket.socket() as sock:
4670 self.assertFalse(sock._closed)
4671 self.assertTrue(sock._closed)
4672 # close inside with block
4673 with socket.socket() as sock:
4674 sock.close()
4675 self.assertTrue(sock._closed)
4676 # exception inside with block
4677 with socket.socket() as sock:
4678 self.assertRaises(socket.error, sock.sendall, b'foo')
4679 self.assertTrue(sock._closed)
4680
4681 def testCreateConnectionBase(self):
4682 conn, addr = self.serv.accept()
Brian Curtin21ebbb72010-11-02 02:07:09 +00004683 self.addCleanup(conn.close)
Giampaolo Rodolàb383dbb2010-09-08 22:44:12 +00004684 data = conn.recv(1024)
4685 conn.sendall(data)
4686
4687 def _testCreateConnectionBase(self):
4688 address = self.serv.getsockname()
4689 with socket.create_connection(address) as sock:
4690 self.assertFalse(sock._closed)
4691 sock.sendall(b'foo')
4692 self.assertEqual(sock.recv(1024), b'foo')
4693 self.assertTrue(sock._closed)
4694
4695 def testCreateConnectionClose(self):
4696 conn, addr = self.serv.accept()
Brian Curtin21ebbb72010-11-02 02:07:09 +00004697 self.addCleanup(conn.close)
Giampaolo Rodolàb383dbb2010-09-08 22:44:12 +00004698 data = conn.recv(1024)
4699 conn.sendall(data)
4700
4701 def _testCreateConnectionClose(self):
4702 address = self.serv.getsockname()
4703 with socket.create_connection(address) as sock:
4704 sock.close()
4705 self.assertTrue(sock._closed)
4706 self.assertRaises(socket.error, sock.sendall, b'foo')
4707
Antoine Pitrouacd0fda2010-10-23 17:01:44 +00004708
Antoine Pitroub1c54962010-10-14 15:05:38 +00004709@unittest.skipUnless(hasattr(socket, "SOCK_CLOEXEC"),
4710 "SOCK_CLOEXEC not defined")
4711@unittest.skipUnless(fcntl, "module fcntl not available")
4712class CloexecConstantTest(unittest.TestCase):
Charles-François Natali239bb962011-06-03 12:55:15 +02004713 @support.requires_linux_version(2, 6, 28)
Antoine Pitroub1c54962010-10-14 15:05:38 +00004714 def test_SOCK_CLOEXEC(self):
Victor Stinner1d5eb342011-01-03 14:30:46 +00004715 with socket.socket(socket.AF_INET,
4716 socket.SOCK_STREAM | socket.SOCK_CLOEXEC) as s:
4717 self.assertTrue(s.type & socket.SOCK_CLOEXEC)
4718 self.assertTrue(fcntl.fcntl(s, fcntl.F_GETFD) & fcntl.FD_CLOEXEC)
Antoine Pitroub1c54962010-10-14 15:05:38 +00004719
4720
4721@unittest.skipUnless(hasattr(socket, "SOCK_NONBLOCK"),
4722 "SOCK_NONBLOCK not defined")
4723class NonblockConstantTest(unittest.TestCase):
4724 def checkNonblock(self, s, nonblock=True, timeout=0.0):
4725 if nonblock:
4726 self.assertTrue(s.type & socket.SOCK_NONBLOCK)
4727 self.assertEqual(s.gettimeout(), timeout)
4728 else:
4729 self.assertFalse(s.type & socket.SOCK_NONBLOCK)
4730 self.assertEqual(s.gettimeout(), None)
4731
Charles-François Natali239bb962011-06-03 12:55:15 +02004732 @support.requires_linux_version(2, 6, 28)
Antoine Pitroub1c54962010-10-14 15:05:38 +00004733 def test_SOCK_NONBLOCK(self):
4734 # a lot of it seems silly and redundant, but I wanted to test that
4735 # changing back and forth worked ok
Victor Stinner1d5eb342011-01-03 14:30:46 +00004736 with socket.socket(socket.AF_INET,
4737 socket.SOCK_STREAM | socket.SOCK_NONBLOCK) as s:
4738 self.checkNonblock(s)
4739 s.setblocking(1)
4740 self.checkNonblock(s, False)
4741 s.setblocking(0)
4742 self.checkNonblock(s)
4743 s.settimeout(None)
4744 self.checkNonblock(s, False)
4745 s.settimeout(2.0)
4746 self.checkNonblock(s, timeout=2.0)
4747 s.setblocking(1)
4748 self.checkNonblock(s, False)
Antoine Pitroub1c54962010-10-14 15:05:38 +00004749 # defaulttimeout
4750 t = socket.getdefaulttimeout()
4751 socket.setdefaulttimeout(0.0)
Victor Stinner1d5eb342011-01-03 14:30:46 +00004752 with socket.socket() as s:
4753 self.checkNonblock(s)
Antoine Pitroub1c54962010-10-14 15:05:38 +00004754 socket.setdefaulttimeout(None)
Victor Stinner1d5eb342011-01-03 14:30:46 +00004755 with socket.socket() as s:
4756 self.checkNonblock(s, False)
Antoine Pitroub1c54962010-10-14 15:05:38 +00004757 socket.setdefaulttimeout(2.0)
Victor Stinner1d5eb342011-01-03 14:30:46 +00004758 with socket.socket() as s:
4759 self.checkNonblock(s, timeout=2.0)
Antoine Pitroub1c54962010-10-14 15:05:38 +00004760 socket.setdefaulttimeout(None)
Victor Stinner1d5eb342011-01-03 14:30:46 +00004761 with socket.socket() as s:
4762 self.checkNonblock(s, False)
Antoine Pitroub1c54962010-10-14 15:05:38 +00004763 socket.setdefaulttimeout(t)
4764
Giampaolo Rodolàb383dbb2010-09-08 22:44:12 +00004765
Kristján Valur Jónsson10f383a2012-04-07 11:23:31 +00004766@unittest.skipUnless(os.name == "nt", "Windows specific")
4767@unittest.skipUnless(multiprocessing, "need multiprocessing")
4768class TestSocketSharing(SocketTCPTest):
4769 # This must be classmethod and not staticmethod or multiprocessing
4770 # won't be able to bootstrap it.
4771 @classmethod
4772 def remoteProcessServer(cls, q):
4773 # Recreate socket from shared data
4774 sdata = q.get()
4775 message = q.get()
4776
4777 s = socket.fromshare(sdata)
4778 s2, c = s.accept()
4779
4780 # Send the message
4781 s2.sendall(message)
4782 s2.close()
4783 s.close()
4784
4785 def testShare(self):
4786 # Transfer the listening server socket to another process
4787 # and service it from there.
4788
4789 # Create process:
4790 q = multiprocessing.Queue()
4791 p = multiprocessing.Process(target=self.remoteProcessServer, args=(q,))
4792 p.start()
4793
4794 # Get the shared socket data
4795 data = self.serv.share(p.pid)
4796
4797 # Pass the shared socket to the other process
4798 addr = self.serv.getsockname()
4799 self.serv.close()
4800 q.put(data)
4801
4802 # The data that the server will send us
4803 message = b"slapmahfro"
4804 q.put(message)
4805
4806 # Connect
4807 s = socket.create_connection(addr)
4808 # listen for the data
4809 m = []
4810 while True:
4811 data = s.recv(100)
4812 if not data:
4813 break
4814 m.append(data)
4815 s.close()
4816 received = b"".join(m)
4817 self.assertEqual(received, message)
4818 p.join()
4819
4820 def testShareLength(self):
4821 data = self.serv.share(os.getpid())
4822 self.assertRaises(ValueError, socket.fromshare, data[:-1])
4823 self.assertRaises(ValueError, socket.fromshare, data+b"foo")
4824
4825 def compareSockets(self, org, other):
4826 # socket sharing is expected to work only for blocking socket
4827 # since the internal python timout value isn't transfered.
4828 self.assertEqual(org.gettimeout(), None)
4829 self.assertEqual(org.gettimeout(), other.gettimeout())
4830
4831 self.assertEqual(org.family, other.family)
4832 self.assertEqual(org.type, other.type)
4833 # If the user specified "0" for proto, then
4834 # internally windows will have picked the correct value.
4835 # Python introspection on the socket however will still return
4836 # 0. For the shared socket, the python value is recreated
4837 # from the actual value, so it may not compare correctly.
4838 if org.proto != 0:
4839 self.assertEqual(org.proto, other.proto)
4840
4841 def testShareLocal(self):
4842 data = self.serv.share(os.getpid())
4843 s = socket.fromshare(data)
4844 try:
4845 self.compareSockets(self.serv, s)
4846 finally:
4847 s.close()
4848
4849 def testTypes(self):
4850 families = [socket.AF_INET, socket.AF_INET6]
4851 types = [socket.SOCK_STREAM, socket.SOCK_DGRAM]
4852 for f in families:
4853 for t in types:
Kristján Valur Jónsson52a11f12012-04-07 20:38:44 +00004854 try:
4855 source = socket.socket(f, t)
4856 except OSError:
4857 continue # This combination is not supported
Kristján Valur Jónsson10f383a2012-04-07 11:23:31 +00004858 try:
4859 data = source.share(os.getpid())
4860 shared = socket.fromshare(data)
4861 try:
4862 self.compareSockets(source, shared)
4863 finally:
4864 shared.close()
4865 finally:
4866 source.close()
4867
4868
Guido van Rossumb995eb72002-07-31 16:08:40 +00004869def test_main():
Thomas Wouters0e3f5912006-08-11 14:57:12 +00004870 tests = [GeneralModuleTests, BasicTCPTest, TCPCloserTest, TCPTimeoutTest,
Ronald Oussoren94f25282010-05-05 19:11:21 +00004871 TestExceptions, BufferIOTest, BasicTCPTest2, BasicUDPTest, UDPTimeoutTest ]
Walter Dörwald21d3a322003-05-01 17:45:56 +00004872
4873 tests.extend([
4874 NonBlockingTCPTests,
4875 FileObjectClassTestCase,
Gregory P. Smithaafdca82010-01-04 04:50:36 +00004876 FileObjectInterruptedTestCase,
Walter Dörwald21d3a322003-05-01 17:45:56 +00004877 UnbufferedFileObjectClassTestCase,
4878 LineBufferedFileObjectClassTestCase,
Thomas Woutersb2137042007-02-01 18:02:27 +00004879 SmallBufferedFileObjectClassTestCase,
Antoine Pitrou834bd812010-10-13 16:17:14 +00004880 UnicodeReadFileObjectClassTestCase,
4881 UnicodeWriteFileObjectClassTestCase,
4882 UnicodeReadWriteFileObjectClassTestCase,
Guido van Rossumd8faa362007-04-27 19:54:29 +00004883 NetworkConnectionNoServer,
4884 NetworkConnectionAttributesTest,
4885 NetworkConnectionBehaviourTest,
Giampaolo Rodolàb383dbb2010-09-08 22:44:12 +00004886 ContextManagersTest,
Antoine Pitroub1c54962010-10-14 15:05:38 +00004887 CloexecConstantTest,
4888 NonblockConstantTest
Walter Dörwald21d3a322003-05-01 17:45:56 +00004889 ])
Serhiy Storchaka79080682013-11-03 21:31:18 +02004890 tests.append(BasicSocketPairTest)
4891 tests.append(TestUnixDomain)
4892 tests.append(TestLinuxAbstractNamespace)
4893 tests.extend([TIPCTest, TIPCThreadableTest])
Charles-François Natali47413c12011-10-06 19:47:44 +02004894 tests.extend([BasicCANTest, CANTest])
Charles-François Natali10b8cf42011-11-10 19:21:37 +01004895 tests.extend([BasicRDSTest, RDSTest])
Nick Coghlan96fe56a2011-08-22 11:55:57 +10004896 tests.extend([
4897 CmsgMacroTests,
4898 SendmsgUDPTest,
4899 RecvmsgUDPTest,
4900 RecvmsgIntoUDPTest,
4901 SendmsgUDP6Test,
4902 RecvmsgUDP6Test,
4903 RecvmsgRFC3542AncillaryUDP6Test,
4904 RecvmsgIntoRFC3542AncillaryUDP6Test,
4905 RecvmsgIntoUDP6Test,
4906 SendmsgTCPTest,
4907 RecvmsgTCPTest,
4908 RecvmsgIntoTCPTest,
4909 SendmsgSCTPStreamTest,
4910 RecvmsgSCTPStreamTest,
4911 RecvmsgIntoSCTPStreamTest,
4912 SendmsgUnixStreamTest,
4913 RecvmsgUnixStreamTest,
4914 RecvmsgIntoUnixStreamTest,
4915 RecvmsgSCMRightsStreamTest,
4916 RecvmsgIntoSCMRightsStreamTest,
4917 # These are slow when setitimer() is not available
4918 InterruptedRecvTimeoutTest,
4919 InterruptedSendTimeoutTest,
Kristján Valur Jónsson10f383a2012-04-07 11:23:31 +00004920 TestSocketSharing,
Nick Coghlan96fe56a2011-08-22 11:55:57 +10004921 ])
Thomas Wouters0e3f5912006-08-11 14:57:12 +00004922
Benjamin Petersonee8712c2008-05-20 21:35:26 +00004923 thread_info = support.threading_setup()
4924 support.run_unittest(*tests)
4925 support.threading_cleanup(*thread_info)
Guido van Rossum24e4af82002-06-12 19:18:08 +00004926
4927if __name__ == "__main__":
Guido van Rossumb995eb72002-07-31 16:08:40 +00004928 test_main()