/Lib/test/test_socket.py
Python | 5106 lines | 4716 code | 195 blank | 195 comment | 53 complexity | 8e8c39db65f88ba87ee1f97f7446911d MD5 | raw file
Possible License(s): 0BSD
Large files files are truncated, but you can click here to view the full file
- import unittest
- from test import support
- import errno
- import io
- import socket
- import select
- import tempfile
- import _testcapi
- import time
- import traceback
- import queue
- import sys
- import os
- import array
- import platform
- import contextlib
- from weakref import proxy
- import signal
- import math
- import pickle
- import struct
- try:
- import multiprocessing
- except ImportError:
- multiprocessing = False
- try:
- import fcntl
- except ImportError:
- fcntl = None
- HOST = support.HOST
- MSG = 'Michael Gilfix was here\u1234\r\n'.encode('utf-8') ## test unicode string and carriage return
- try:
- import _thread as thread
- import threading
- except ImportError:
- thread = None
- threading = None
- def _have_socket_can():
- """Check whether CAN sockets are supported on this host."""
- try:
- s = socket.socket(socket.PF_CAN, socket.SOCK_RAW, socket.CAN_RAW)
- except (AttributeError, OSError):
- return False
- else:
- s.close()
- return True
- def _have_socket_rds():
- """Check whether RDS sockets are supported on this host."""
- try:
- s = socket.socket(socket.PF_RDS, socket.SOCK_SEQPACKET, 0)
- except (AttributeError, OSError):
- return False
- else:
- s.close()
- return True
- HAVE_SOCKET_CAN = _have_socket_can()
- HAVE_SOCKET_RDS = _have_socket_rds()
- # Size in bytes of the int type
- SIZEOF_INT = array.array("i").itemsize
- class SocketTCPTest(unittest.TestCase):
- def setUp(self):
- self.serv = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
- self.port = support.bind_port(self.serv)
- self.serv.listen(1)
- def tearDown(self):
- self.serv.close()
- self.serv = None
- class SocketUDPTest(unittest.TestCase):
- def setUp(self):
- self.serv = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
- self.port = support.bind_port(self.serv)
- def tearDown(self):
- self.serv.close()
- self.serv = None
- class ThreadSafeCleanupTestCase(unittest.TestCase):
- """Subclass of unittest.TestCase with thread-safe cleanup methods.
- This subclass protects the addCleanup() and doCleanups() methods
- with a recursive lock.
- """
- if threading:
- def __init__(self, *args, **kwargs):
- super().__init__(*args, **kwargs)
- self._cleanup_lock = threading.RLock()
- def addCleanup(self, *args, **kwargs):
- with self._cleanup_lock:
- return super().addCleanup(*args, **kwargs)
- def doCleanups(self, *args, **kwargs):
- with self._cleanup_lock:
- return super().doCleanups(*args, **kwargs)
- class SocketCANTest(unittest.TestCase):
- """To be able to run this test, a `vcan0` CAN interface can be created with
- the following commands:
- # modprobe vcan
- # ip link add dev vcan0 type vcan
- # ifconfig vcan0 up
- """
- interface = 'vcan0'
- bufsize = 128
- """The CAN frame structure is defined in <linux/can.h>:
- struct can_frame {
- canid_t can_id; /* 32 bit CAN_ID + EFF/RTR/ERR flags */
- __u8 can_dlc; /* data length code: 0 .. 8 */
- __u8 data[8] __attribute__((aligned(8)));
- };
- """
- can_frame_fmt = "=IB3x8s"
- can_frame_size = struct.calcsize(can_frame_fmt)
- """The Broadcast Management Command frame structure is defined
- in <linux/can/bcm.h>:
- struct bcm_msg_head {
- __u32 opcode;
- __u32 flags;
- __u32 count;
- struct timeval ival1, ival2;
- canid_t can_id;
- __u32 nframes;
- struct can_frame frames[0];
- }
- `bcm_msg_head` must be 8 bytes aligned because of the `frames` member (see
- `struct can_frame` definition). Must use native not standard types for packing.
- """
- bcm_cmd_msg_fmt = "@3I4l2I"
- bcm_cmd_msg_fmt += "x" * (struct.calcsize(bcm_cmd_msg_fmt) % 8)
- def setUp(self):
- self.s = socket.socket(socket.PF_CAN, socket.SOCK_RAW, socket.CAN_RAW)
- self.addCleanup(self.s.close)
- try:
- self.s.bind((self.interface,))
- except OSError:
- self.skipTest('network interface `%s` does not exist' %
- self.interface)
- class SocketRDSTest(unittest.TestCase):
- """To be able to run this test, the `rds` kernel module must be loaded:
- # modprobe rds
- """
- bufsize = 8192
- def setUp(self):
- self.serv = socket.socket(socket.PF_RDS, socket.SOCK_SEQPACKET, 0)
- self.addCleanup(self.serv.close)
- try:
- self.port = support.bind_port(self.serv)
- except OSError:
- self.skipTest('unable to bind RDS socket')
- class ThreadableTest:
- """Threadable Test class
- The ThreadableTest class makes it easy to create a threaded
- client/server pair from an existing unit test. To create a
- new threaded class from an existing unit test, use multiple
- inheritance:
- class NewClass (OldClass, ThreadableTest):
- pass
- This class defines two new fixture functions with obvious
- purposes for overriding:
- clientSetUp ()
- clientTearDown ()
- Any new test functions within the class must then define
- tests in pairs, where the test name is preceeded with a
- '_' to indicate the client portion of the test. Ex:
- def testFoo(self):
- # Server portion
- def _testFoo(self):
- # Client portion
- Any exceptions raised by the clients during their tests
- are caught and transferred to the main thread to alert
- the testing framework.
- Note, the server setup function cannot call any blocking
- functions that rely on the client thread during setup,
- unless serverExplicitReady() is called just before
- the blocking call (such as in setting up a client/server
- connection and performing the accept() in setUp().
- """
- def __init__(self):
- # Swap the true setup function
- self.__setUp = self.setUp
- self.__tearDown = self.tearDown
- self.setUp = self._setUp
- self.tearDown = self._tearDown
- def serverExplicitReady(self):
- """This method allows the server to explicitly indicate that
- it wants the client thread to proceed. This is useful if the
- server is about to execute a blocking routine that is
- dependent upon the client thread during its setup routine."""
- self.server_ready.set()
- def _setUp(self):
- self.server_ready = threading.Event()
- self.client_ready = threading.Event()
- self.done = threading.Event()
- self.queue = queue.Queue(1)
- self.server_crashed = False
- # Do some munging to start the client test.
- methodname = self.id()
- i = methodname.rfind('.')
- methodname = methodname[i+1:]
- test_method = getattr(self, '_' + methodname)
- self.client_thread = thread.start_new_thread(
- self.clientRun, (test_method,))
- try:
- self.__setUp()
- except:
- self.server_crashed = True
- raise
- finally:
- self.server_ready.set()
- self.client_ready.wait()
- def _tearDown(self):
- self.__tearDown()
- self.done.wait()
- if self.queue.qsize():
- exc = self.queue.get()
- raise exc
- def clientRun(self, test_func):
- self.server_ready.wait()
- self.clientSetUp()
- self.client_ready.set()
- if self.server_crashed:
- self.clientTearDown()
- return
- if not hasattr(test_func, '__call__'):
- raise TypeError("test_func must be a callable function")
- try:
- test_func()
- except BaseException as e:
- self.queue.put(e)
- finally:
- self.clientTearDown()
- def clientSetUp(self):
- raise NotImplementedError("clientSetUp must be implemented.")
- def clientTearDown(self):
- self.done.set()
- thread.exit()
- class ThreadedTCPSocketTest(SocketTCPTest, ThreadableTest):
- def __init__(self, methodName='runTest'):
- SocketTCPTest.__init__(self, methodName=methodName)
- ThreadableTest.__init__(self)
- def clientSetUp(self):
- self.cli = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
- def clientTearDown(self):
- self.cli.close()
- self.cli = None
- ThreadableTest.clientTearDown(self)
- class ThreadedUDPSocketTest(SocketUDPTest, ThreadableTest):
- def __init__(self, methodName='runTest'):
- SocketUDPTest.__init__(self, methodName=methodName)
- ThreadableTest.__init__(self)
- def clientSetUp(self):
- self.cli = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
- def clientTearDown(self):
- self.cli.close()
- self.cli = None
- ThreadableTest.clientTearDown(self)
- class ThreadedCANSocketTest(SocketCANTest, ThreadableTest):
- def __init__(self, methodName='runTest'):
- SocketCANTest.__init__(self, methodName=methodName)
- ThreadableTest.__init__(self)
- def clientSetUp(self):
- self.cli = socket.socket(socket.PF_CAN, socket.SOCK_RAW, socket.CAN_RAW)
- try:
- self.cli.bind((self.interface,))
- except OSError:
- # skipTest should not be called here, and will be called in the
- # server instead
- pass
- def clientTearDown(self):
- self.cli.close()
- self.cli = None
- ThreadableTest.clientTearDown(self)
- class ThreadedRDSSocketTest(SocketRDSTest, ThreadableTest):
- def __init__(self, methodName='runTest'):
- SocketRDSTest.__init__(self, methodName=methodName)
- ThreadableTest.__init__(self)
- def clientSetUp(self):
- self.cli = socket.socket(socket.PF_RDS, socket.SOCK_SEQPACKET, 0)
- try:
- # RDS sockets must be bound explicitly to send or receive data
- self.cli.bind((HOST, 0))
- self.cli_addr = self.cli.getsockname()
- except OSError:
- # skipTest should not be called here, and will be called in the
- # server instead
- pass
- def clientTearDown(self):
- self.cli.close()
- self.cli = None
- ThreadableTest.clientTearDown(self)
- class SocketConnectedTest(ThreadedTCPSocketTest):
- """Socket tests for client-server connection.
- self.cli_conn is a client socket connected to the server. The
- setUp() method guarantees that it is connected to the server.
- """
- def __init__(self, methodName='runTest'):
- ThreadedTCPSocketTest.__init__(self, methodName=methodName)
- def setUp(self):
- ThreadedTCPSocketTest.setUp(self)
- # Indicate explicitly we're ready for the client thread to
- # proceed and then perform the blocking call to accept
- self.serverExplicitReady()
- conn, addr = self.serv.accept()
- self.cli_conn = conn
- def tearDown(self):
- self.cli_conn.close()
- self.cli_conn = None
- ThreadedTCPSocketTest.tearDown(self)
- def clientSetUp(self):
- ThreadedTCPSocketTest.clientSetUp(self)
- self.cli.connect((HOST, self.port))
- self.serv_conn = self.cli
- def clientTearDown(self):
- self.serv_conn.close()
- self.serv_conn = None
- ThreadedTCPSocketTest.clientTearDown(self)
- class SocketPairTest(unittest.TestCase, ThreadableTest):
- def __init__(self, methodName='runTest'):
- unittest.TestCase.__init__(self, methodName=methodName)
- ThreadableTest.__init__(self)
- def setUp(self):
- self.serv, self.cli = socket.socketpair()
- def tearDown(self):
- self.serv.close()
- self.serv = None
- def clientSetUp(self):
- pass
- def clientTearDown(self):
- self.cli.close()
- self.cli = None
- ThreadableTest.clientTearDown(self)
- # The following classes are used by the sendmsg()/recvmsg() tests.
- # Combining, for instance, ConnectedStreamTestMixin and TCPTestBase
- # gives a drop-in replacement for SocketConnectedTest, but different
- # address families can be used, and the attributes serv_addr and
- # cli_addr will be set to the addresses of the endpoints.
- class SocketTestBase(unittest.TestCase):
- """A base class for socket tests.
- Subclasses must provide methods newSocket() to return a new socket
- and bindSock(sock) to bind it to an unused address.
- Creates a socket self.serv and sets self.serv_addr to its address.
- """
- def setUp(self):
- self.serv = self.newSocket()
- self.bindServer()
- def bindServer(self):
- """Bind server socket and set self.serv_addr to its address."""
- self.bindSock(self.serv)
- self.serv_addr = self.serv.getsockname()
- def tearDown(self):
- self.serv.close()
- self.serv = None
- class SocketListeningTestMixin(SocketTestBase):
- """Mixin to listen on the server socket."""
- def setUp(self):
- super().setUp()
- self.serv.listen(1)
- class ThreadedSocketTestMixin(ThreadSafeCleanupTestCase, SocketTestBase,
- ThreadableTest):
- """Mixin to add client socket and allow client/server tests.
- Client socket is self.cli and its address is self.cli_addr. See
- ThreadableTest for usage information.
- """
- def __init__(self, *args, **kwargs):
- super().__init__(*args, **kwargs)
- ThreadableTest.__init__(self)
- def clientSetUp(self):
- self.cli = self.newClientSocket()
- self.bindClient()
- def newClientSocket(self):
- """Return a new socket for use as client."""
- return self.newSocket()
- def bindClient(self):
- """Bind client socket and set self.cli_addr to its address."""
- self.bindSock(self.cli)
- self.cli_addr = self.cli.getsockname()
- def clientTearDown(self):
- self.cli.close()
- self.cli = None
- ThreadableTest.clientTearDown(self)
- class ConnectedStreamTestMixin(SocketListeningTestMixin,
- ThreadedSocketTestMixin):
- """Mixin to allow client/server stream tests with connected client.
- Server's socket representing connection to client is self.cli_conn
- and client's connection to server is self.serv_conn. (Based on
- SocketConnectedTest.)
- """
- def setUp(self):
- super().setUp()
- # Indicate explicitly we're ready for the client thread to
- # proceed and then perform the blocking call to accept
- self.serverExplicitReady()
- conn, addr = self.serv.accept()
- self.cli_conn = conn
- def tearDown(self):
- self.cli_conn.close()
- self.cli_conn = None
- super().tearDown()
- def clientSetUp(self):
- super().clientSetUp()
- self.cli.connect(self.serv_addr)
- self.serv_conn = self.cli
- def clientTearDown(self):
- self.serv_conn.close()
- self.serv_conn = None
- super().clientTearDown()
- class UnixSocketTestBase(SocketTestBase):
- """Base class for Unix-domain socket tests."""
- # This class is used for file descriptor passing tests, so we
- # create the sockets in a private directory so that other users
- # can't send anything that might be problematic for a privileged
- # user running the tests.
- def setUp(self):
- self.dir_path = tempfile.mkdtemp()
- self.addCleanup(os.rmdir, self.dir_path)
- super().setUp()
- def bindSock(self, sock):
- path = tempfile.mktemp(dir=self.dir_path)
- sock.bind(path)
- self.addCleanup(support.unlink, path)
- class UnixStreamBase(UnixSocketTestBase):
- """Base class for Unix-domain SOCK_STREAM tests."""
- def newSocket(self):
- return socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
- class InetTestBase(SocketTestBase):
- """Base class for IPv4 socket tests."""
- host = HOST
- def setUp(self):
- super().setUp()
- self.port = self.serv_addr[1]
- def bindSock(self, sock):
- support.bind_port(sock, host=self.host)
- class TCPTestBase(InetTestBase):
- """Base class for TCP-over-IPv4 tests."""
- def newSocket(self):
- return socket.socket(socket.AF_INET, socket.SOCK_STREAM)
- class UDPTestBase(InetTestBase):
- """Base class for UDP-over-IPv4 tests."""
- def newSocket(self):
- return socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
- class SCTPStreamBase(InetTestBase):
- """Base class for SCTP tests in one-to-one (SOCK_STREAM) mode."""
- def newSocket(self):
- return socket.socket(socket.AF_INET, socket.SOCK_STREAM,
- socket.IPPROTO_SCTP)
- class Inet6TestBase(InetTestBase):
- """Base class for IPv6 socket tests."""
- host = support.HOSTv6
- class UDP6TestBase(Inet6TestBase):
- """Base class for UDP-over-IPv6 tests."""
- def newSocket(self):
- return socket.socket(socket.AF_INET6, socket.SOCK_DGRAM)
- # Test-skipping decorators for use with ThreadableTest.
- def skipWithClientIf(condition, reason):
- """Skip decorated test if condition is true, add client_skip decorator.
- If the decorated object is not a class, sets its attribute
- "client_skip" to a decorator which will return an empty function
- if the test is to be skipped, or the original function if it is
- not. This can be used to avoid running the client part of a
- skipped test when using ThreadableTest.
- """
- def client_pass(*args, **kwargs):
- pass
- def skipdec(obj):
- retval = unittest.skip(reason)(obj)
- if not isinstance(obj, type):
- retval.client_skip = lambda f: client_pass
- return retval
- def noskipdec(obj):
- if not (isinstance(obj, type) or hasattr(obj, "client_skip")):
- obj.client_skip = lambda f: f
- return obj
- return skipdec if condition else noskipdec
- def requireAttrs(obj, *attributes):
- """Skip decorated test if obj is missing any of the given attributes.
- Sets client_skip attribute as skipWithClientIf() does.
- """
- missing = [name for name in attributes if not hasattr(obj, name)]
- return skipWithClientIf(
- missing, "don't have " + ", ".join(name for name in missing))
- def requireSocket(*args):
- """Skip decorated test if a socket cannot be created with given arguments.
- When an argument is given as a string, will use the value of that
- attribute of the socket module, or skip the test if it doesn't
- exist. Sets client_skip attribute as skipWithClientIf() does.
- """
- err = None
- missing = [obj for obj in args if
- isinstance(obj, str) and not hasattr(socket, obj)]
- if missing:
- err = "don't have " + ", ".join(name for name in missing)
- else:
- callargs = [getattr(socket, obj) if isinstance(obj, str) else obj
- for obj in args]
- try:
- s = socket.socket(*callargs)
- except OSError as e:
- # XXX: check errno?
- err = str(e)
- else:
- s.close()
- return skipWithClientIf(
- err is not None,
- "can't create socket({0}): {1}".format(
- ", ".join(str(o) for o in args), err))
- #######################################################################
- ## Begin Tests
- class GeneralModuleTests(unittest.TestCase):
- def test_repr(self):
- s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
- with s:
- self.assertIn('fd=%i' % s.fileno(), repr(s))
- self.assertIn('family=%s' % socket.AF_INET, repr(s))
- self.assertIn('type=%s' % socket.SOCK_STREAM, repr(s))
- self.assertIn('proto=0', repr(s))
- self.assertNotIn('raddr', repr(s))
- s.bind(('127.0.0.1', 0))
- self.assertIn('laddr', repr(s))
- self.assertIn(str(s.getsockname()), repr(s))
- self.assertIn('[closed]', repr(s))
- self.assertNotIn('laddr', repr(s))
- def test_weakref(self):
- s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
- p = proxy(s)
- self.assertEqual(p.fileno(), s.fileno())
- s.close()
- s = None
- try:
- p.fileno()
- except ReferenceError:
- pass
- else:
- self.fail('Socket proxy still exists')
- def testSocketError(self):
- # Testing socket module exceptions
- msg = "Error raising socket exception (%s)."
- with self.assertRaises(OSError, msg=msg % 'OSError'):
- raise OSError
- with self.assertRaises(OSError, msg=msg % 'socket.herror'):
- raise socket.herror
- with self.assertRaises(OSError, msg=msg % 'socket.gaierror'):
- raise socket.gaierror
- def testSendtoErrors(self):
- # Testing that sendto doens't masks failures. See #10169.
- s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
- self.addCleanup(s.close)
- s.bind(('', 0))
- sockname = s.getsockname()
- # 2 args
- with self.assertRaises(TypeError) as cm:
- s.sendto('\u2620', sockname)
- self.assertEqual(str(cm.exception),
- "'str' does not support the buffer interface")
- with self.assertRaises(TypeError) as cm:
- s.sendto(5j, sockname)
- self.assertEqual(str(cm.exception),
- "'complex' does not support the buffer interface")
- with self.assertRaises(TypeError) as cm:
- s.sendto(b'foo', None)
- self.assertIn('not NoneType',str(cm.exception))
- # 3 args
- with self.assertRaises(TypeError) as cm:
- s.sendto('\u2620', 0, sockname)
- self.assertEqual(str(cm.exception),
- "'str' does not support the buffer interface")
- with self.assertRaises(TypeError) as cm:
- s.sendto(5j, 0, sockname)
- self.assertEqual(str(cm.exception),
- "'complex' does not support the buffer interface")
- with self.assertRaises(TypeError) as cm:
- s.sendto(b'foo', 0, None)
- self.assertIn('not NoneType', str(cm.exception))
- with self.assertRaises(TypeError) as cm:
- s.sendto(b'foo', 'bar', sockname)
- self.assertIn('an integer is required', str(cm.exception))
- with self.assertRaises(TypeError) as cm:
- s.sendto(b'foo', None, None)
- self.assertIn('an integer is required', str(cm.exception))
- # wrong number of args
- with self.assertRaises(TypeError) as cm:
- s.sendto(b'foo')
- self.assertIn('(1 given)', str(cm.exception))
- with self.assertRaises(TypeError) as cm:
- s.sendto(b'foo', 0, sockname, 4)
- self.assertIn('(4 given)', str(cm.exception))
- def testCrucialConstants(self):
- # Testing for mission critical constants
- socket.AF_INET
- socket.SOCK_STREAM
- socket.SOCK_DGRAM
- socket.SOCK_RAW
- socket.SOCK_RDM
- socket.SOCK_SEQPACKET
- socket.SOL_SOCKET
- socket.SO_REUSEADDR
- def testHostnameRes(self):
- # Testing hostname resolution mechanisms
- hostname = socket.gethostname()
- try:
- ip = socket.gethostbyname(hostname)
- except OSError:
- # Probably name lookup wasn't set up right; skip this test
- self.skipTest('name lookup failure')
- self.assertTrue(ip.find('.') >= 0, "Error resolving host to ip.")
- try:
- hname, aliases, ipaddrs = socket.gethostbyaddr(ip)
- except OSError:
- # Probably a similar problem as above; skip this test
- self.skipTest('name lookup failure')
- all_host_names = [hostname, hname] + aliases
- fqhn = socket.getfqdn(ip)
- if not fqhn in all_host_names:
- self.fail("Error testing host resolution mechanisms. (fqdn: %s, all: %s)" % (fqhn, repr(all_host_names)))
- def test_host_resolution(self):
- for addr in ['0.1.1.~1', '1+.1.1.1', '::1q', '::1::2',
- '1:1:1:1:1:1:1:1:1']:
- self.assertRaises(OSError, socket.gethostbyname, addr)
- self.assertRaises(OSError, socket.gethostbyaddr, addr)
- for addr in [support.HOST, '10.0.0.1', '255.255.255.255']:
- self.assertEqual(socket.gethostbyname(addr), addr)
- # we don't test support.HOSTv6 because there's a chance it doesn't have
- # a matching name entry (e.g. 'ip6-localhost')
- for host in [support.HOST]:
- self.assertIn(host, socket.gethostbyaddr(host)[2])
- @unittest.skipUnless(hasattr(socket, 'sethostname'), "test needs socket.sethostname()")
- @unittest.skipUnless(hasattr(socket, 'gethostname'), "test needs socket.gethostname()")
- def test_sethostname(self):
- oldhn = socket.gethostname()
- try:
- socket.sethostname('new')
- except OSError as e:
- if e.errno == errno.EPERM:
- self.skipTest("test should be run as root")
- else:
- raise
- try:
- # running test as root!
- self.assertEqual(socket.gethostname(), 'new')
- # Should work with bytes objects too
- socket.sethostname(b'bar')
- self.assertEqual(socket.gethostname(), 'bar')
- finally:
- socket.sethostname(oldhn)
- @unittest.skipUnless(hasattr(socket, 'if_nameindex'),
- 'socket.if_nameindex() not available.')
- def testInterfaceNameIndex(self):
- interfaces = socket.if_nameindex()
- for index, name in interfaces:
- self.assertIsInstance(index, int)
- self.assertIsInstance(name, str)
- # interface indices are non-zero integers
- self.assertGreater(index, 0)
- _index = socket.if_nametoindex(name)
- self.assertIsInstance(_index, int)
- self.assertEqual(index, _index)
- _name = socket.if_indextoname(index)
- self.assertIsInstance(_name, str)
- self.assertEqual(name, _name)
- @unittest.skipUnless(hasattr(socket, 'if_nameindex'),
- 'socket.if_nameindex() not available.')
- def testInvalidInterfaceNameIndex(self):
- # test nonexistent interface index/name
- self.assertRaises(OSError, socket.if_indextoname, 0)
- self.assertRaises(OSError, socket.if_nametoindex, '_DEADBEEF')
- # test with invalid values
- self.assertRaises(TypeError, socket.if_nametoindex, 0)
- self.assertRaises(TypeError, socket.if_indextoname, '_DEADBEEF')
- @unittest.skipUnless(hasattr(sys, 'getrefcount'),
- 'test needs sys.getrefcount()')
- def testRefCountGetNameInfo(self):
- # Testing reference count for getnameinfo
- try:
- # On some versions, this loses a reference
- orig = sys.getrefcount(__name__)
- socket.getnameinfo(__name__,0)
- except TypeError:
- if sys.getrefcount(__name__) != orig:
- self.fail("socket.getnameinfo loses a reference")
- def testInterpreterCrash(self):
- # Making sure getnameinfo doesn't crash the interpreter
- try:
- # On some versions, this crashes the interpreter.
- socket.getnameinfo(('x', 0, 0, 0), 0)
- except OSError:
- pass
- def testNtoH(self):
- # This just checks that htons etc. are their own inverse,
- # when looking at the lower 16 or 32 bits.
- sizes = {socket.htonl: 32, socket.ntohl: 32,
- socket.htons: 16, socket.ntohs: 16}
- for func, size in sizes.items():
- mask = (1<<size) - 1
- for i in (0, 1, 0xffff, ~0xffff, 2, 0x01234567, 0x76543210):
- self.assertEqual(i & mask, func(func(i&mask)) & mask)
- swapped = func(mask)
- self.assertEqual(swapped & mask, mask)
- self.assertRaises(OverflowError, func, 1<<34)
- def testNtoHErrors(self):
- good_values = [ 1, 2, 3, 1, 2, 3 ]
- bad_values = [ -1, -2, -3, -1, -2, -3 ]
- for k in good_values:
- socket.ntohl(k)
- socket.ntohs(k)
- socket.htonl(k)
- socket.htons(k)
- for k in bad_values:
- self.assertRaises(OverflowError, socket.ntohl, k)
- self.assertRaises(OverflowError, socket.ntohs, k)
- self.assertRaises(OverflowError, socket.htonl, k)
- self.assertRaises(OverflowError, socket.htons, k)
- def testGetServBy(self):
- eq = self.assertEqual
- # Find one service that exists, then check all the related interfaces.
- # I've ordered this by protocols that have both a tcp and udp
- # protocol, at least for modern Linuxes.
- if (sys.platform.startswith(('freebsd', 'netbsd'))
- or sys.platform in ('linux', 'darwin')):
- # avoid the 'echo' service on this platform, as there is an
- # assumption breaking non-standard port/protocol entry
- services = ('daytime', 'qotd', 'domain')
- else:
- services = ('echo', 'daytime', 'domain')
- for service in services:
- try:
- port = socket.getservbyname(service, 'tcp')
- break
- except OSError:
- pass
- else:
- raise OSError
- # Try same call with optional protocol omitted
- port2 = socket.getservbyname(service)
- eq(port, port2)
- # Try udp, but don't barf if it doesn't exist
- try:
- udpport = socket.getservbyname(service, 'udp')
- except OSError:
- udpport = None
- else:
- eq(udpport, port)
- # Now make sure the lookup by port returns the same service name
- eq(socket.getservbyport(port2), service)
- eq(socket.getservbyport(port, 'tcp'), service)
- if udpport is not None:
- eq(socket.getservbyport(udpport, 'udp'), service)
- # Make sure getservbyport does not accept out of range ports.
- self.assertRaises(OverflowError, socket.getservbyport, -1)
- self.assertRaises(OverflowError, socket.getservbyport, 65536)
- def testDefaultTimeout(self):
- # Testing default timeout
- # The default timeout should initially be None
- self.assertEqual(socket.getdefaulttimeout(), None)
- s = socket.socket()
- self.assertEqual(s.gettimeout(), None)
- s.close()
- # Set the default timeout to 10, and see if it propagates
- socket.setdefaulttimeout(10)
- self.assertEqual(socket.getdefaulttimeout(), 10)
- s = socket.socket()
- self.assertEqual(s.gettimeout(), 10)
- s.close()
- # Reset the default timeout to None, and see if it propagates
- socket.setdefaulttimeout(None)
- self.assertEqual(socket.getdefaulttimeout(), None)
- s = socket.socket()
- self.assertEqual(s.gettimeout(), None)
- s.close()
- # Check that setting it to an invalid value raises ValueError
- self.assertRaises(ValueError, socket.setdefaulttimeout, -1)
- # Check that setting it to an invalid type raises TypeError
- self.assertRaises(TypeError, socket.setdefaulttimeout, "spam")
- @unittest.skipUnless(hasattr(socket, 'inet_aton'),
- 'test needs socket.inet_aton()')
- def testIPv4_inet_aton_fourbytes(self):
- # Test that issue1008086 and issue767150 are fixed.
- # It must return 4 bytes.
- self.assertEqual(b'\x00'*4, socket.inet_aton('0.0.0.0'))
- self.assertEqual(b'\xff'*4, socket.inet_aton('255.255.255.255'))
- @unittest.skipUnless(hasattr(socket, 'inet_pton'),
- 'test needs socket.inet_pton()')
- def testIPv4toString(self):
- from socket import inet_aton as f, inet_pton, AF_INET
- g = lambda a: inet_pton(AF_INET, a)
- assertInvalid = lambda func,a: self.assertRaises(
- (OSError, ValueError), func, a
- )
- self.assertEqual(b'\x00\x00\x00\x00', f('0.0.0.0'))
- self.assertEqual(b'\xff\x00\xff\x00', f('255.0.255.0'))
- self.assertEqual(b'\xaa\xaa\xaa\xaa', f('170.170.170.170'))
- self.assertEqual(b'\x01\x02\x03\x04', f('1.2.3.4'))
- self.assertEqual(b'\xff\xff\xff\xff', f('255.255.255.255'))
- assertInvalid(f, '0.0.0.')
- assertInvalid(f, '300.0.0.0')
- assertInvalid(f, 'a.0.0.0')
- assertInvalid(f, '1.2.3.4.5')
- assertInvalid(f, '::1')
- self.assertEqual(b'\x00\x00\x00\x00', g('0.0.0.0'))
- self.assertEqual(b'\xff\x00\xff\x00', g('255.0.255.0'))
- self.assertEqual(b'\xaa\xaa\xaa\xaa', g('170.170.170.170'))
- self.assertEqual(b'\xff\xff\xff\xff', g('255.255.255.255'))
- assertInvalid(g, '0.0.0.')
- assertInvalid(g, '300.0.0.0')
- assertInvalid(g, 'a.0.0.0')
- assertInvalid(g, '1.2.3.4.5')
- assertInvalid(g, '::1')
- @unittest.skipUnless(hasattr(socket, 'inet_pton'),
- 'test needs socket.inet_pton()')
- def testIPv6toString(self):
- try:
- from socket import inet_pton, AF_INET6, has_ipv6
- if not has_ipv6:
- self.skipTest('IPv6 not available')
- except ImportError:
- self.skipTest('could not import needed symbols from socket')
- if sys.platform == "win32":
- try:
- inet_pton(AF_INET6, '::')
- except OSError as e:
- if e.winerror == 10022:
- self.skipTest('IPv6 might not be supported')
- f = lambda a: inet_pton(AF_INET6, a)
- assertInvalid = lambda a: self.assertRaises(
- (OSError, ValueError), f, a
- )
- self.assertEqual(b'\x00' * 16, f('::'))
- self.assertEqual(b'\x00' * 16, f('0::0'))
- self.assertEqual(b'\x00\x01' + b'\x00' * 14, f('1::'))
- self.assertEqual(
- b'\x45\xef\x76\xcb\x00\x1a\x56\xef\xaf\xeb\x0b\xac\x19\x24\xae\xae',
- f('45ef:76cb:1a:56ef:afeb:bac:1924:aeae')
- )
- self.assertEqual(
- b'\xad\x42\x0a\xbc' + b'\x00' * 4 + b'\x01\x27\x00\x00\x02\x54\x00\x02',
- f('ad42:abc::127:0:254:2')
- )
- self.assertEqual(b'\x00\x12\x00\x0a' + b'\x00' * 12, f('12:a::'))
- assertInvalid('0x20::')
- assertInvalid(':::')
- assertInvalid('::0::')
- assertInvalid('1::abc::')
- assertInvalid('1::abc::def')
- assertInvalid('1:2:3:4:5:6:')
- assertInvalid('1:2:3:4:5:6')
- assertInvalid('1:2:3:4:5:6:7:8:')
- assertInvalid('1:2:3:4:5:6:7:8:0')
- self.assertEqual(b'\x00' * 12 + b'\xfe\x2a\x17\x40',
- f('::254.42.23.64')
- )
- self.assertEqual(
- b'\x00\x42' + b'\x00' * 8 + b'\xa2\x9b\xfe\x2a\x17\x40',
- f('42::a29b:254.42.23.64')
- )
- self.assertEqual(
- b'\x00\x42\xa8\xb9\x00\x00\x00\x02\xff\xff\xa2\x9b\xfe\x2a\x17\x40',
- f('42:a8b9:0:2:ffff:a29b:254.42.23.64')
- )
- assertInvalid('255.254.253.252')
- assertInvalid('1::260.2.3.0')
- assertInvalid('1::0.be.e.0')
- assertInvalid('1:2:3:4:5:6:7:1.2.3.4')
- assertInvalid('::1.2.3.4:0')
- assertInvalid('0.100.200.0:3:4:5:6:7:8')
- @unittest.skipUnless(hasattr(socket, 'inet_ntop'),
- 'test needs socket.inet_ntop()')
- def testStringToIPv4(self):
- from socket import inet_ntoa as f, inet_ntop, AF_INET
- g = lambda a: inet_ntop(AF_INET, a)
- assertInvalid = lambda func,a: self.assertRaises(
- (OSError, ValueError), func, a
- )
- self.assertEqual('1.0.1.0', f(b'\x01\x00\x01\x00'))
- self.assertEqual('170.85.170.85', f(b'\xaa\x55\xaa\x55'))
- self.assertEqual('255.255.255.255', f(b'\xff\xff\xff\xff'))
- self.assertEqual('1.2.3.4', f(b'\x01\x02\x03\x04'))
- assertInvalid(f, b'\x00' * 3)
- assertInvalid(f, b'\x00' * 5)
- assertInvalid(f, b'\x00' * 16)
- self.assertEqual('1.0.1.0', g(b'\x01\x00\x01\x00'))
- self.assertEqual('170.85.170.85', g(b'\xaa\x55\xaa\x55'))
- self.assertEqual('255.255.255.255', g(b'\xff\xff\xff\xff'))
- assertInvalid(g, b'\x00' * 3)
- assertInvalid(g, b'\x00' * 5)
- assertInvalid(g, b'\x00' * 16)
- @unittest.skipUnless(hasattr(socket, 'inet_ntop'),
- 'test needs socket.inet_ntop()')
- def testStringToIPv6(self):
- try:
- from socket import inet_ntop, AF_INET6, has_ipv6
- if not has_ipv6:
- self.skipTest('IPv6 not available')
- except ImportError:
- self.skipTest('could not import needed symbols from socket')
- if sys.platform == "win32":
- try:
- inet_ntop(AF_INET6, b'\x00' * 16)
- except OSError as e:
- if e.winerror == 10022:
- self.skipTest('IPv6 might not be supported')
- f = lambda a: inet_ntop(AF_INET6, a)
- assertInvalid = lambda a: self.assertRaises(
- (OSError, ValueError), f, a
- )
- self.assertEqual('::', f(b'\x00' * 16))
- self.assertEqual('::1', f(b'\x00' * 15 + b'\x01'))
- self.assertEqual(
- 'aef:b01:506:1001:ffff:9997:55:170',
- f(b'\x0a\xef\x0b\x01\x05\x06\x10\x01\xff\xff\x99\x97\x00\x55\x01\x70')
- )
- assertInvalid(b'\x12' * 15)
- assertInvalid(b'\x12' * 17)
- assertInvalid(b'\x12' * 4)
- # XXX The following don't test module-level functionality...
- def testSockName(self):
- # Testing getsockname()
- port = support.find_unused_port()
- sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
- self.addCleanup(sock.close)
- sock.bind(("0.0.0.0", port))
- name = sock.getsockname()
- # XXX(nnorwitz): http://tinyurl.com/os5jz seems to indicate
- # it reasonable to get the host's addr in addition to 0.0.0.0.
- # At least for eCos. This is required for the S/390 to pass.
- try:
- my_ip_addr = socket.gethostbyname(socket.gethostname())
- except OSError:
- # Probably name lookup wasn't set up right; skip this test
- self.skipTest('name lookup failure')
- self.assertIn(name[0], ("0.0.0.0", my_ip_addr), '%s invalid' % name[0])
- self.assertEqual(name[1], port)
- def testGetSockOpt(self):
- # Testing getsockopt()
- # We know a socket should start without reuse==0
- sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
- self.addCleanup(sock.close)
- reuse = sock.getsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR)
- self.assertFalse(reuse != 0, "initial mode is reuse")
- def testSetSockOpt(self):
- # Testing setsockopt()
- sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
- self.addCleanup(sock.close)
- sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
- reuse = sock.getsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR)
- self.assertFalse(reuse == 0, "failed to set reuse mode")
- def testSendAfterClose(self):
- # testing send() after close() with timeout
- sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
- sock.settimeout(1)
- sock.close()
- self.assertRaises(OSError, sock.send, b"spam")
- def testNewAttributes(self):
- # testing .family, .type and .protocol
- sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
- self.assertEqual(sock.family, socket.AF_INET)
- if hasattr(socket, 'SOCK_CLOEXEC'):
- self.assertIn(sock.type,
- (socket.SOCK_STREAM | socket.SOCK_CLOEXEC,
- socket.SOCK_STREAM))
- else:
- self.assertEqual(sock.type, socket.SOCK_STREAM)
- self.assertEqual(sock.proto, 0)
- sock.close()
- def test_getsockaddrarg(self):
- host = '0.0.0.0'
- port = support.find_unused_port()
- big_port = port + 65536
- neg_port = port - 65536
- sock = socket.socket()
- try:
- self.assertRaises(OverflowError, sock.bind, (host, big_port))
- self.assertRaises(OverflowError, sock.bind, (host, neg_port))
- sock.bind((host, port))
- finally:
- sock.close()
- @unittest.skipUnless(os.name == "nt", "Windows specific")
- def test_sock_ioctl(self):
- self.assertTrue(hasattr(socket.socket, 'ioctl'))
- self.assertTrue(hasattr(socket, 'SIO_RCVALL'))
- self.assertTrue(hasattr(socket, 'RCVALL_ON'))
- self.assertTrue(hasattr(socket, 'RCVALL_OFF'))
- self.assertTrue(hasattr(socket, 'SIO_KEEPALIVE_VALS'))
- s = socket.socket()
- self.addCleanup(s.close)
- self.assertRaises(ValueError, s.ioctl, -1, None)
- s.ioctl(socket.SIO_KEEPALIVE_VALS, (1, 100, 100))
- def testGetaddrinfo(self):
- try:
- socket.getaddrinfo('localhost', 80)
- except socket.gaierror as err:
- if err.errno == socket.EAI_SERVICE:
- # see http://bugs.python.org/issue1282647
- self.skipTest("buggy libc version")
- raise
- # len of every sequence is supposed to be == 5
- for info in socket.getaddrinfo(HOST, None):
- self.assertEqual(len(info), 5)
- # host can be a domain name, a string representation of an
- # IPv4/v6 address or None
- socket.getaddrinfo('localhost', 80)
- socket.getaddrinfo('127.0.0.1', 80)
- socket.getaddrinfo(None, 80)
- if support.IPV6_ENABLED:
- socket.getaddrinfo('::1', 80)
- # port can be a string service name such as "http", a numeric
- # port number or None
- socket.getaddrinfo(HOST, "http")
- socket.getaddrinfo(HOST, 80)
- socket.getaddrinfo(HOST, None)
- # test family and socktype filters
- infos = socket.getaddrinfo(HOST, 80, socket.AF_INET, socket.SOCK_STREAM)
- for family, type, _, _, _ in infos:
- self.assertEqual(family, socket.AF_INET)
- self.assertEqual(str(family), 'AddressFamily.AF_INET')
- self.assertEqual(type, socket.SOCK_STREAM)
- self.assertEqual(str(type), 'SocketType.SOCK_STREAM')
- infos = socket.getaddrinfo(HOST, None, 0, socket.SOCK_STREAM)
- for _, socktype, _, _, _ in infos:
- self.assertEqual(socktype, socket.SOCK_STREAM)
- # test proto and flags arguments
- socket.getaddrinfo(HOST, None, 0, 0, socket.SOL_TCP)
- socket.getaddrinfo(HOST, None, 0, 0, 0, socket.AI_PASSIVE)
- # a server willing to support both IPv4 and IPv6 will
- # usually do this
- socket.getaddrinfo(None, 0, socket.AF_UNSPEC, socket.SOCK_STREAM, 0,
- socket.AI_PASSIVE)
- # test keyword arguments
- a = socket.getaddrinfo(HOST, None)
- b = socket.getaddrinfo(host=HOST, port=None)
- self.assertEqual(a, b)
- a = socket.getaddrinfo(HOST, None, socket.AF_INET)
- b = socket.getaddrinfo(HOST, None, family=socket.AF_INET)
- self.assertEqual(a, b)
- a = socket.getaddrinfo(HOST, None, 0, socket.SOCK_STREAM)
- b = socket.getaddrinfo(HOST, None, type=socket.SOCK_STREAM)
- self.assertEqual(a, b)
- a = socket.getaddrinfo(HOST, None, 0, 0, socket.SOL_TCP)
- b = socket.getaddrinfo(HOST, None, proto=socket.SOL_TCP)
- self.assertEqual(a, b)
- a = socket.getaddrinfo(HOST, None, 0, 0, 0, socket.AI_PASSIVE)
- b = socket.getaddrinfo(HOST, None, flags=socket.AI_PASSIVE)
- self.assertEqual(a, b)
- a = socket.getaddrinfo(None, 0, socket.AF_UNSPEC, socket.SOCK_STREAM, 0,
- socket.AI_PASSIVE)
- b = socket.getaddrinfo(host=None, port=0, family=socket.AF_UNSPEC,
- type=socket.SOCK_STREAM, proto=0,
- flags=socket.AI_PASSIVE)
- self.assertEqual(a, b)
- # Issue #6697.
- self.assertRaises(UnicodeEncodeError, socket.getaddrinfo, 'localhost', '\uD800')
- # Issue 17269
- if hasattr(socket, 'AI_NUMERICSERV'):
- socket.getaddrinfo("localhost", None, 0, 0, 0, socket.AI_NUMERICSERV)
- def test_getnameinfo(self):
- # only IP addresses are allowed
- self.assertRaises(OSError, socket.getnameinfo, ('mail.python.org',0), 0)
- @unittest.skipUnless(support.is_resource_enabled('network'),
- 'network is not enabled')
- def test_idna(self):
- # Check for internet access before running test (issue #12804).
- try:
- socket.gethostbyname('python.org')
- except socket.gaierror as e:
- if e.errno == socket.EAI_NODATA:
- self.skipTest('internet access required for this test')
- # these should all be successful
- socket.gethostbyname('испытание.python.org')
- socket.gethostbyname_ex('испытание.python.org')
- socket.getaddrinfo('испытание.python.org',0,socket.AF_UNSPEC,socket.SOCK_STREAM)
- # this may not work if the forward lookup choses the IPv6 address, as that doesn't
- # have a reverse entry yet
- # socket.gethostbyaddr('испытание.python.org')
- def check_sendall_interrupted(self, with_timeout):
- # socketpair() is not stricly required, but it makes things easier.
- if not hasattr(signal, 'alarm') or not hasattr(socket, 'socketpair'):
- self.skipTest("signal.alarm and socket.socketpair required for this test")
- # Our signal handlers clobber the C errno by calling a math function
- # with an invalid domain value.
- def ok_handler(*args):
- self.assertRaises(ValueError, math.acosh, 0)
- def raising_handler(*args):
- self.assertRaises(ValueError, math.acosh, 0)
- 1 // 0
- c, s = socket.socketpair()
- old_alarm = signal.signal(signal.SIGALRM, raising_handler)
- try:
- if with_timeout:
- # Just above the one second minimum for signal.alarm
- c.settimeout(1.5)
- with self.assertRaises(ZeroDivisionError):
- signal.alarm(1)
- c.sendall(b"x" * support.SOCK_MAX_SIZE)
- if with_timeout:
- signal.signal(signal.SIGALRM, ok_handler)
- signal.alarm(1)
- self.assertRaises(socket.timeout, c.sendall,
- b"x" * support.SOCK_MAX_SIZE)
- finally:
- signal.alarm(0)
- signal.signal(signal.SIGALRM, old_alarm)
- c.close()
- s.close()
- def test_sendall_interrupted(self):
- self.check_sendall_interrupted(False)
- def test_sendall_interrupted_with_timeout(self):
- self.check_sendall_interrupted(True)
- def test_dealloc_warn(self):
- sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
- r = repr(sock)
- with self.assertWarns(ResourceWarning) as cm:
- sock = None
- support.gc_collect()
- self.assertIn(r, str(cm.warning.args[0]))
- # An open socket file object gets dereferenced after the socket
- sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
- f = sock.makefile('rb')
- r = repr(sock)
- sock = None
- support.gc_collect()
- with self.assertWarns(ResourceWarning):
- f = None
- support.gc_collect()
- def test_name_closed_socketio(self):
- with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
- fp = sock.makefile("rb")
- fp.close()
- self.assertEqual(repr(fp), "<_io.BufferedReader name=-1>")
- def test_unusable_closed_socketio(self):
- with socket.socket() as sock:
- fp = sock.makefile("rb", buffering=0)
- self.assertTrue(fp.readable())
- self.assertFalse(fp.writable())
- self.assertFalse(fp.seekable())
- fp.close()
- self.assertRaises(ValueError, fp.readable)
- self.assertRaises(ValueError, fp.writable)
- self.assertRaises(ValueError, fp.seekable)
- def test_pickle(self):
- sock = socket.socket()
- with sock:
- for protocol in range(pickle.HIGHEST_PROTOCOL + 1):
- self.assertRaises(TypeError, pickle.dumps, sock, protocol)
- def test_listen_backlog(self):
- for backlog in 0, -1:
- srv = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
- srv.bind((HOST, 0))
- srv.listen(backlog)
- srv.close()
- # Issue 15989
- srv = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
- srv.bind((HOST, 0))
- self.assertRaises(OverflowError, srv.listen, _testcapi.INT_MAX + 1)
- srv.close()
- @unittest.skipUnless(support.IPV6_ENABLED, 'IPv6 required for this test.')
- def test_flowinfo(self):
- self.assertRaises(OverflowError, socket.getnameinfo,
- (support.HOSTv6, 0, 0xffffffff), 0)
- with socket.socket(socket.AF_INET6, socket.SOCK_STREAM) as s:
- self.assertRaises(OverflowError, s.bind, (support.HOSTv6, 0, -10))
- def test_str_for_enums(self):
- # Make sure that the AF_* and SOCK_* constants have enum-like string
- # reprs.
- with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
- self.assertEqual(str(s.family), 'AddressFamily.AF_INET')
- self.assertEqual(str(s.type), 'SocketType.SOCK_STREAM')
- @unittest.skipIf(os.name == 'nt', 'Will not work on Windows')
- def test_uknown_socket_family_repr(self):
- # Test that when created with a family that's not one of the known
- # AF_*/SOCK_* constants, socket.family just returns the number.
- #
- # To do this we fool socket.socket into believing it already has an
- # open fd because on this path it doesn't actually verify the family and
- # type and populates the socket object.
- #
- # On Windows this trick won't work, so the test is skipped.
- fd, _ = tempfile.mkstemp()
- with socket.socket(family=42424, t…
Large files files are truncated, but you can click here to view the full file