def testMsgWaitallProblems2(self):
class ReceiveThread(threading.Thread):
def __init__(self, sock, sizes):
super(ReceiveThread, self).__init__()
self.sock = sock
self.sizes = sizes
def run(self):
cs, _ = self.sock.accept()
for size in self.sizes:
data = socketutil.receive_data(cs, size)
socketutil.send_data(cs, data)
cs.close()
ss = socketutil.create_socket(bind=("localhost", 0))
SIZES = [
1000, 10000, 32000, 32768, 32780, 41950, 41952, 42000, 65000,
65535, 65600, 80000, 999999
]
serverthread = ReceiveThread(ss, SIZES)
serverthread.setDaemon(True)
serverthread.start()
port = ss.getsockname()[1]
cs = socketutil.create_socket(connect=("localhost", port), timeout=2)
# test some sizes that might be problematic with MSG_WAITALL and check that they work fine
for size in SIZES:
socketutil.send_data(cs, b"x" * size)
data = socketutil.receive_data(cs, size)
assert size == len(data)
serverthread.join()
ss.close()
cs.close()
def testCreateBoundSockets(self):
s = socketutil.create_socket(bind=('127.0.0.1', 0))
assert socket.AF_INET == s.family
bs = socketutil.create_bc_socket(bind=('127.0.0.1', 0))
assert '127.0.0.1' == s.getsockname()[0]
assert '127.0.0.1' == bs.getsockname()[0]
s.close()
bs.close()
with pytest.raises(ValueError):
socketutil.create_socket(bind=('localhost', 12345),
connect=('localhost', 1234))
def testCreateBoundSockets6(self):
if not has_ipv6:
pytest.skip("no ipv6 capability")
s = socketutil.create_socket(bind=('::1', 0))
assert socket.AF_INET6 == s.family
bs = socketutil.create_bc_socket(bind=('::1', 0))
assert ':' in s.getsockname()[0]
assert ':' in bs.getsockname()[0]
s.close()
bs.close()
with pytest.raises(ValueError):
socketutil.create_socket(bind=('::1', 12345),
connect=('::1', 1234))
def testSend(self):
ss = socketutil.create_socket(bind=("localhost", 0))
port = ss.getsockname()[1]
cs = socketutil.create_socket(connect=("localhost", port))
socketutil.send_data(cs, b"foobar!" * 10)
cs.shutdown(socket.SHUT_WR)
a = ss.accept()
data = socketutil.receive_data(a[0], 5)
assert b"fooba" == data
data = socketutil.receive_data(a[0], 5)
assert b"r!foo" == data
a[0].close()
ss.close()
cs.close()
def testCreateBoundUnixSockets(self):
if not hasattr(socket, "AF_UNIX"):
pytest.skip("no unix domain sockets capability")
SOCKNAME = "test_unixsocket"
if os.path.exists(SOCKNAME):
os.remove(SOCKNAME)
s = socketutil.create_socket(bind=SOCKNAME)
assert socket.AF_UNIX == s.family
assert SOCKNAME == s.getsockname()
s.close()
if os.path.exists(SOCKNAME):
os.remove(SOCKNAME)
with pytest.raises(ValueError):
socketutil.create_socket(bind=SOCKNAME, connect=SOCKNAME)
def testContextAndSock(self):
cert_dir = "../../certs"
if not os.path.isdir(cert_dir):
cert_dir = "../certs"
if not os.path.isdir(cert_dir):
cert_dir = "./certs"
if not os.path.isdir(cert_dir):
raise IOError("cannot locate test certs directory")
try:
config.SSL = True
config.SSL_REQUIRECLIENTCERT = True
server_ctx = socketutil.get_ssl_context(
cert_dir + "/server_cert.pem", cert_dir + "/server_key.pem")
client_ctx = socketutil.get_ssl_context(
clientcert=cert_dir + "/client_cert.pem",
clientkey=cert_dir + "/client_key.pem")
assert server_ctx.verify_mode == ssl.CERT_REQUIRED
assert client_ctx.verify_mode == ssl.CERT_REQUIRED
assert client_ctx.check_hostname
sock = socketutil.create_socket(sslContext=server_ctx)
try:
assert hasattr(sock, "getpeercert")
finally:
sock.close()
finally:
config.SSL = False
def testAbstractNamespace(self):
if not hasattr(socket,
"AF_UNIX") and not sys.platform.startswith("linux"):
pytest.skip("no unix domain sockets capability, and not Linux")
SOCKNAME = "\0test_unixsocket_abstract_ns" # mind the \0 at the start
s = socketutil.create_socket(bind=SOCKNAME)
assert bytes(SOCKNAME, "ascii") == s.getsockname()
s.close()
def testMsgWaitallProblems(self):
ss = socketutil.create_socket(bind=("localhost", 0), timeout=2)
port = ss.getsockname()[1]
cs = socketutil.create_socket(connect=("localhost", port), timeout=2)
a = ss.accept()
# test some sizes that might be problematic with MSG_WAITALL and check that they work fine
for size in [
1000, 10000, 32000, 32768, 32780, 41950, 41952, 42000, 65000,
65535, 65600, 80000
]:
socketutil.send_data(cs, b"x" * size)
data = socketutil.receive_data(a[0], size)
socketutil.send_data(a[0], data)
data = socketutil.receive_data(cs, size)
assert size == len(data)
a[0].close()
ss.close()
cs.close()
def testSendUnix(self):
if not hasattr(socket, "AF_UNIX"):
pytest.skip("no unix domain sockets capability")
SOCKNAME = "test_unixsocket"
if os.path.exists(SOCKNAME):
os.remove(SOCKNAME)
ss = socketutil.create_socket(bind=SOCKNAME)
cs = socketutil.create_socket(connect=SOCKNAME)
socketutil.send_data(cs, b"foobar!" * 10)
cs.shutdown(socket.SHUT_WR)
a = ss.accept()
data = socketutil.receive_data(a[0], 5)
assert b"fooba" == data
data = socketutil.receive_data(a[0], 5)
assert b"r!foo" == data
a[0].close()
ss.close()
cs.close()
if os.path.exists(SOCKNAME):
os.remove(SOCKNAME)
def testServerPoolFull(self):
port = socketutil.find_probably_unused_port()
serv = SocketServer_Threadpool()
daemon = ServerCallback()
serv.init(daemon, "localhost", port)
serversock = serv.sock.getsockname()
csock1 = socketutil.create_socket(connect=serversock)
csock2 = socketutil.create_socket(connect=serversock)
try:
serv.events([serv.sock])
time.sleep(0.2)
assert daemon.received_denied_reasons == [None]
serv.events([serv.sock])
time.sleep(0.2)
assert len(daemon.received_denied_reasons) == 2
assert "no free workers, increase server threadpool size" in daemon.received_denied_reasons
finally:
csock1.close()
csock2.close()
serv.shutdown()
def testConnectCrash(self):
serv_thread = TestServerDOS_multiplex.ServerThread(
self.socket_server, ServerCallback_BrokenHandshake)
serv_thread.start()
time.sleep(0.2)
assert serv_thread.is_alive(), "server thread failed to start"
threadpool = getattr(serv_thread.serv, "pool", None)
if threadpool:
assert len(threadpool.idle) == 1
assert len(threadpool.busy) == 0
try:
host, port = serv_thread.locationStr.split(':')
port = int(port)
try:
# first connection attempt (will fail because server daemon _handshake crashes)
csock = socketutil.create_socket(connect=(host, port))
conn = socketutil.SocketConnection(csock, "uri")
protocol.recv_stub(conn, [protocol.MSG_CONNECTOK])
except errors.ConnectionClosedError:
pass
conn.close()
time.sleep(0.1)
if threadpool:
assert len(threadpool.idle) == 1
assert len(threadpool.busy) == 0
try:
# second connection attempt, should still work (i.e. server should still be running)
csock = socketutil.create_socket(connect=(host, port))
conn = socketutil.SocketConnection(csock, "uri")
protocol.recv_stub(conn, [protocol.MSG_CONNECTOK])
except errors.ConnectionClosedError:
pass
finally:
if conn:
conn.close()
serv_thread.stop_loop.set()
serv_thread.join()
def testCreateUnboundSockets(self):
s = socketutil.create_socket()
assert socket.AF_INET == s.family
bs = socketutil.create_bc_socket()
assert socket.AF_INET == bs.family
with contextlib.suppress(socket.error):
host, port = s.getsockname()
# can either fail with socket.error or return (host,0)
assert 0 == port
with contextlib.suppress(socket.error):
host, port = bs.getsockname()
# can either fail with socket.error or return (host,0)
assert 0 == port
s.close()
bs.close()
def testCreateUnboundSockets6(self):
if not has_ipv6:
pytest.skip("no ipv6 capability")
s = socketutil.create_socket(ipv6=True)
assert socket.AF_INET6 == s.family
bs = socketutil.create_bc_socket(ipv6=True)
assert socket.AF_INET6 == bs.family
with contextlib.suppress(socket.error):
host, port, _, _ = s.getsockname()
# can either fail with socket.error or return (host,0)
assert 0 == port
with contextlib.suppress(socket.error):
host, port, _, _ = bs.getsockname()
# can either fail with socket.error or return (host,0)
assert 0 == port
s.close()
bs.close()
def connect(host, port):
# connect to the server
csock = socketutil.create_socket(connect=(host, port))
conn = socketutil.SocketConnection(csock, "uri")
# send the handshake/connect data
ser = serializers.serializers_by_id[
serializers.MarshalSerializer.serializer_id]
data = ser.dumps({
"handshake": "hello",
"object": core.DAEMON_NAME
})
msg = protocol.SendingMessage(
protocol.MSG_CONNECT, 0, 0,
serializers.MarshalSerializer.serializer_id, data)
conn.send(msg.data)
# get the handshake/connect response
protocol.recv_stub(conn, [protocol.MSG_CONNECTOK])
return conn
def testCreateUnboundSockets(self):
s = socketutil.create_socket()
assert socket.AF_INET == s.family
bs = socketutil.create_bc_socket()
assert socket.AF_INET == bs.family
try:
host, port = s.getsockname()
# can either fail with socket.error or return (host,0)
assert 0 == port
except socket.error:
pass
try:
host, port = bs.getsockname()
# can either fail with socket.error or return (host,0)
assert 0 == port
except socket.error:
pass
s.close()
bs.close()
