def test_tcpconnection_hostname_ip6(self):
hostname = _socket.gethostname()
try:
hostaddress, hostport = ip.resolve(hostname, 0, ip.PF_INET6)
except Exception:
hostaddress, hostport = None, 0
if hostaddress is not None:
serv = tcp.EchoServer(host="::")
conn = tcp.TcpConnection("tcp://%s:%d"%(hostname, serv.name()[1]),
ip.PF_INET6)
conn.readyRead.connect(self.__readdata)
QtCore.QTimer.singleShot(100, lambda:self.__send_data(conn))
QtCore.QTimer.singleShot(1000, self.app.quit)
self.app.exec_()
url = conn.url()
peerurl = conn.peerUrl()
self.assertIsInstance(url, URL)
self.assertEqual(url.scheme, "tcp")
self.assertEqual(conn.name(), (url.site.host, url.site.port))
self.assertEqual(conn.peerName(), (peerurl.site.host,
peerurl.site.port))
self.assertEqual(peerurl.site.host, "::1")
self.assertEqual(peerurl.site.port, serv.name()[1])
self.assertEqual(self.data, self.result)
conn.close()
def test_udplistener_hostname_IPv6_reuse(self):
hostname = socket.gethostname()
try:
hostaddress, hostport = ip.resolve(hostname, 0, ip.PF_INET6)
except Exception:
hostaddress, hostport = None, 0
if hostaddress is not None:
lock = UdpListener("udp://%s:0"%hostname, ip.PF_INET6, ("reuse",))
port = lock.name()[1]
self.assertRaises(Exception, UdpListener,
"udp://%s:%d"%(hostname, port), ip.PF_INET6)
l = UdpListener("udp://%s:%d"%(hostname, port),
ip.PF_INET6, ("reuse",))
url = l.url()
self.assertEqual(url.site.port, port)
s = socket.socket(ip.PF_INET6, socket.SOCK_DGRAM)
s.connect(l.name())
sockname = s.getsockname()[:2]
sockname = (sockname[0].partition("%")[0], sockname[1])
s.send(self.data)
time.sleep(_sec)
if sys.platform in ("win32", "darwin"): data, source = lock.receiveFrom()
else: data, source = l.receiveFrom()
self.assertEqual(data, self.data)
self.assertEqual(source, sockname)
lock.close()
s.close()
def connect(self, host, port, family=None):
"""Raises Exception if host cannot be resolved."""
host, port = ip.resolve(host, port,
family if family is not None else 0,
_socket.SOCK_STREAM)[:2]
self.connectToHost(host, port)
return self
def sendTo(self, data, host, port, family=None, resolve=True):
"""Raises Exception if host cannot be resolved."""
if resolve:
host, port = ip.resolve(host, port,
family if family is not None else 0,
_socket.SOCK_DGRAM)[:2]
return self.writeDatagram(data, QHostAddress(host), port)
def test_udplistener_localhost_IPv6(self):
try:
hostaddress, hostport = ip.resolve("localhost", 0, ip.PF_INET6)
except Exception:
hostaddress, hostport = None, 0
if hostaddress is not None:
l = UdpListener("udp://localhost:0", ip.PF_INET6)
s = socket.socket(ip.PF_INET6, socket.SOCK_DGRAM)
s.connect(l.name())
s.send(self.data)
time.sleep(_sec)
data, source = l.receiveFrom()
self.assertEqual(data, self.data)
self.assertEqual(source, s.getsockname()[:2])
s.close()
def test_udpsocket_localhost_IPv6(self):
try:
hostaddress, hostport = ip.resolve("localhost", 0, ip.PF_INET6)
except Exception:
hostaddress, hostport = None, 0
if hostaddress is not None:
l = socket.socket(ip.PF_INET6, socket.SOCK_DGRAM)
l.bind(("localhost",0))
addr, port = l.getsockname()[:2]
s = UdpSocket()
n = s.sendTo(self.data, "localhost", int(port), ip.PF_INET6)
self.assertEqual(n, len(self.data))
time.sleep(_sec)
data, source = l.recvfrom(1024)
self.assertEqual(data, self.data)
l.close()
def bind(self, host=None, port=0, family=None,
mode=QUdpSocket.DontShareAddress):
"""Raises Exception if UDP socket cannot be bound at specified
host and port."""
if not host:
if family==ip.PF_INET6: host = QHostAddress.AnyIPv6
else: host = QHostAddress.Any
if not QHostAddress(host) in (QHostAddress.Any,
QHostAddress.AnyIPv6):
host, port = ip.resolve(host, port,
family if family is not None else 0,
_socket.SOCK_DGRAM)[:2]
if not QUdpSocket.bind(self, QHostAddress(host), port, mode):
raise Exception(self.errorString())
self.__open = True
return self
def test_udplistener_hostname_IPv4(self):
hostname = socket.gethostname()
try:
hostaddress, hostport = ip.resolve(hostname, 0, ip.PF_INET)
except Exception:
hostaddress, hostport = None, 0
if hostaddress is not None:
l = UdpListener("udp://%s:0"%hostname, ip.PF_INET)
s = socket.socket(ip.PF_INET, socket.SOCK_DGRAM)
s.connect(l.name())
time.sleep(_sec)
sockname = s.getsockname()
s.send(self.data)
data, source = l.receiveFrom()
self.assertEqual(data, self.data)
self.assertEqual(source, sockname)
s.close()
def test_tcpserver_hostname_IPv6_nodelay(self):
hostname = _socket.gethostname()
try:
hostaddress, hostport = ip.resolve(hostname, 0, ip.PF_INET6)
except Exception:
hostaddress, hostport = None, 0
if hostaddress is not None:
s = tcp.TcpServer(host=hostname, family=ip.PF_INET6, options=("nodelay",))
s.newConnection.connect(self.__newconnection)
ref = weakref.ref(s)
url = s.url()
self.assertIsInstance(url, URL)
self.assertEqual(url.scheme, "tcp")
self.assertEqual(hostaddress.partition("%")[0], url.site.host)
self.assertEqual(s.name(), (url.site.host, url.site.port))
self.tryConnectToServer(s)
del s
self.assertIsNone(ref())
def __init__(self, host=None, port=0, family=None,
maxconnections=30, factory=TcpSocket, options=tuple(),
*args, **kwargs):
"""Raises Exception if TCP socket cannot be bound at specified
host and port."""
super().__init__(*args, **kwargs)
self.__factory = factory
self.__options = options if options is not None else tuple()
self.setMaxPendingConnections(maxconnections)
if not host:
if family==ip.PF_INET6: host = QHostAddress.AnyIPv6
else: host = QHostAddress.Any
if not QHostAddress(host) in (QHostAddress.Any,
QHostAddress.AnyIPv6):
host, port = ip.resolve(host, port,
family if family is not None else 0,
_socket.SOCK_STREAM)[:2]
if not self.listen(QHostAddress(host), int(port)):
raise Exception(self.errorString())
def test_udpsender_localhost_IPv6(self):
try:
hostaddress, hostport = ip.resolve("localhost", 0, ip.PF_INET6)
except Exception:
hostaddress, hostport = None, 0
if hostaddress is not None:
l = socket.socket(ip.PF_INET6, socket.SOCK_DGRAM)
l.bind(("localhost",0))
addr, port = l.getsockname()[:2]
s = UdpSender("udp://localhost:%d"%port, ip.PF_INET6)
url = s.url()
peerurl = s.peerUrl()
self.assertEqual((peerurl.site.host, peerurl.site.port),
l.getsockname()[:2])
n = s.send(self.data)
self.assertEqual(n, len(self.data))
time.sleep(_sec)
data, source = l.recvfrom(1024)
self.assertEqual(data, self.data)
self.assertEqual(source[:2], (url.site.host, url.site.port))
l.close()
def test_udpsender_hostname_IPv4(self):
hostname = socket.gethostname()
try:
hostaddress, hostport = ip.resolve(hostname, 0, ip.PF_INET)
except Exception:
hostaddress, hostport = None, 0
if hostaddress is not None:
l = socket.socket(ip.PF_INET, socket.SOCK_DGRAM)
l.bind((hostname, 0))
addr, port = l.getsockname()[:2]
s = UdpSender("udp://%s:%d"%(hostname, port), ip.PF_INET)
url = s.url()
peerurl = s.peerUrl()
sockname = l.getsockname()[:2]
self.assertEqual((peerurl.site.host, peerurl.site.port), sockname)
n = s.send(self.data)
self.assertEqual(n, len(self.data))
time.sleep(_sec)
data, source = l.recvfrom(1024)
self.assertEqual(data, self.data)
self.assertEqual(source, (url.site.host, url.site.port))
l.close()
def test_udplistener_localhost_IPv6_reuse(self):
try:
hostaddress, hostport = ip.resolve("localhost", 0, ip.PF_INET6)
except Exception:
hostaddress, hostport = None, 0
if hostaddress is not None:
lock = UdpListener("udp://localhost:0", ip.PF_INET6, ("reuse",))
port = lock.name()[1]
s = socket.socket(ip.PF_INET6, socket.SOCK_DGRAM)
self.assertRaises(Exception, UdpListener,
"udp://localhost:%d"%port, ip.PF_INET6)
l = UdpListener("udp://localhost:%d"%port,
ip.PF_INET6, ("reuse",))
url = l.url()
self.assertEqual(url.site.port, port)
s.connect((url.site.host, url.site.port))
s.send(self.data)
time.sleep(_sec)
if sys.platform in ("win32", ): data, source = lock.receiveFrom()
else: data, source = l.receiveFrom()
self.assertEqual(data, self.data)
self.assertEqual(source, s.getsockname()[:2])
lock.close()
s.close()
