def _connect(self):
"""Connect to the remote server and start reader/writer greenlets."""
# NB. this method isn't safe to call directly; must only be called
# via connect() which adds the necessary locking
self.state = STATE_CONNECTING
try:
try:
addrinfo = socket.getaddrinfo(self.host, self.port, socket.AF_INET6, socket.SOCK_STREAM)
except socket.gaierror:
addrinfo = socket.getaddrinfo(self.host, self.port, socket.AF_INET, socket.SOCK_STREAM)
(family, socktype, proto, canonname, sockaddr) = addrinfo[0]
self.sock = socket.socket(family, socktype, proto)
self.sock.connect(sockaddr)
except:
self.state = STATE_DISCONNECTED
raise
# Set up channel state
self.channel_id = 1
self.channels = {}
# Set up connection greenlets
self.queue = Queue(self.MAX_SEND_QUEUE)
reader = gevent.spawn(self.do_read, self.sock)
writer = gevent.spawn(self.do_write, self.sock, self.queue)
reader.link(lambda reader: writer.kill())
writer.link(lambda writer: reader.kill())
self.reader = reader
self.writer = writer
def _connect(self):
"""Connect to the remote server and start reader/writer greenlets."""
# NB. this method isn't safe to call directly; must only be called
# via connect() which adds the necessary locking
self.state = STATE_CONNECTING
try:
try:
addrinfo = socket.getaddrinfo(self.host, self.port, socket.AF_INET6, socket.SOCK_STREAM)
except socket.gaierror:
addrinfo = socket.getaddrinfo(self.host, self.port, socket.AF_INET, socket.SOCK_STREAM)
(family, socktype, proto, canonname, sockaddr) = addrinfo[0]
self.sock = socket.socket(family, socktype, proto)
self.sock.connect(sockaddr)
except:
self.state = STATE_DISCONNECTED
raise
# Set up channel state
self.channel_id = 1
self.channels = {}
# Set up connection greenlets
self.queue = Queue(self.MAX_SEND_QUEUE)
reader = gevent.spawn(self.do_read, self.sock)
writer = gevent.spawn(self.do_write, self.sock, self.queue)
reader.link(lambda reader: writer.kill())
writer.link(lambda writer: reader.kill())
self.reader = reader
self.writer = writer
def test_error(self):
socket.getaddrinfo('host', 25, socket.AF_INET).AndReturn([
(None, None, None, None, 'sockaddr')
])
socket.create_connection('sockaddr', IgnoreArg(),
IgnoreArg()).AndRaise(socket.error('error'))
self.mox.ReplayAll()
with self.assertRaises(socket.error):
self.socket_creator(('host', 25), 'timeout', 'source')
def test_socket_error(self):
socket.getaddrinfo('host', 25, socket.AF_UNSPEC, socket.SOCK_STREAM,
socket.IPPROTO_IP, socket.AI_PASSIVE).AndReturn([
(11, 12, 13, None, 'sockaddr')
])
socket.socket(11, 12, 13).AndRaise(socket.error)
self.mox.ReplayAll()
with self.assertRaises(socket.error):
util.create_listeners(('host', 25))
def test_successful(self):
socket.getaddrinfo('host', 25, socket.AF_INET).AndReturn([
(None, None, None, None, 'sockaddr')
])
socket.create_connection('sockaddr', IgnoreArg(),
IgnoreArg()).AndReturn('socket')
self.mox.ReplayAll()
ret = self.socket_creator(('host', 25), 'timeout', 'source')
self.assertEqual('socket', ret)
def test_getaddrinfo_mp(self):
"""This test would make gevent's hub threadpool kill upon hub
destruction in child block forever. Gipc resolves this by killing
threadpool even harder.
"""
import gevent.socket as socket
socket.getaddrinfo("localhost", 21)
p = start_process(target=complchild_test_getaddrinfo_mp)
p.join(timeout=1)
assert p.exitcode == 0
def test_successful(self):
socket.getaddrinfo('host', 25, socket.AF_UNSPEC, socket.SOCK_STREAM,
socket.IPPROTO_IP, socket.AI_PASSIVE).AndReturn([
(11, 12, 13, None, 'sockaddr')
])
socket.socket(11, 12, 13).AndReturn(self.sock)
self.sock.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_V6ONLY, 1)
self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.sock.setblocking(0)
self.sock.bind('sockaddr')
self.sock.listen(socket.SOMAXCONN)
self.mox.ReplayAll()
listeners = util.create_listeners(('host', 25))
self.assertEqual([self.sock], listeners)
def check(self, url, host_info):
host_info[self.description()] = None
if host_info["ssl checked"].get():
return None
else:
host_ip = socket.getaddrinfo(url, 443)[0][4][0]
try:
sock = socket.socket()
except socket.error:
host_info[self.description()] = False
return False
try:
sock = ssl.wrap_socket(sock,
ca_certs="/etc/ssl/certs/ca-certificates.crt",
cert_reqs=ssl.CERT_NONE,
ssl_version=ssl.PROTOCOL_SSLv3,
)
sock.connect((host_ip, 443))
cert = sock.getpeercert()
usedcipher = str(sock.cipher())
except ssl.SSLError:
host_info[self.description()] = False
return False
if (re.search(r'SSLv3', usedcipher)):
host_info[self.description()] = True
return True
host_info[self.description()] = False
return False
def register_addresslist(cls, addresslist):
for addr in addresslist:
port = 80
if ":" in addr:
addr, port = addr.split(":")
port = int(port)
cls.addresses += socket.getaddrinfo(addr, port, socket.AF_INET, socket.SOCK_STREAM, socket.SOL_TCP, 0)
def check(self, url, host_info):
host_info[self.description()] = None
host_ip = socket.getaddrinfo(url, 443)[0][4][0]
try:
sock = socket.socket()
sock.connect((host_ip, 443))
except socket.error:
host_info["ssl checked"].set(True)
host_info[self.description()] = True
return True
try:
sock = ssl.wrap_socket(sock,
ca_certs="/etc/ssl/certs/ca-certificates.crt",
cert_reqs=ssl.CERT_NONE,
)
cert = sock.getpeercert()
except ssl.SSLError:
host_info["ssl checked"].set(True)
host_info[self.description()] = True
return True
host_info["ssl checked"].set(False)
host_info[self.description()] = False
return False
def detect_ipv6():
try:
addrinfo = socket.getaddrinfo("www.google.com", 80)
af, _, _, _, _ = addrinfo[0]
return af == socket.AF_INET6 # @UndefinedVariable
except:
return False
def bind_local_sock_by_addr(addr):
addrinfo = socket.getaddrinfo(addr[0], addr[1], 0, socket.SOCK_DGRAM,
socket.SOL_UDP)
af, socktype, proto, _, remoteaddr = addrinfo[0]
sock = socket.socket(af, socktype, proto)
sock.connect(remoteaddr)
return sock
def create_connection_ipv4(address,
timeout=None,
source_address=None,
only_ports=None):
"""Attempts to mimick to :py:func:`socket.create_connection`, but
connections are only made to IPv4 addresses.
:param only_ports: If given, can be a list to limit which ports are
restricted to IPv4. Connections to all other ports may
be IPv6.
"""
host, port = address
if only_ports and port not in only_ports:
return socket.create_connection(address, timeout, source_address)
last_exc = None
for res in socket.getaddrinfo(host, port, socket.AF_INET):
_, _, _, _, sockaddr = res
try:
return socket.create_connection(sockaddr, timeout, source_address)
except socket.error as exc:
last_exc = exc
if last_exc is not None:
raise last_exc
else:
raise socket.error('getaddrinfo returns an empty list')
def create(self):
family, socktype, proto, canonname, sockaddr = \
socket.getaddrinfo(self.server, self.port, 0,
socket.SOCK_DGRAM, 0, socket.AI_PASSIVE)[0]
self.socket = socket.socket(family, socktype)
self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.socket.bind(sockaddr)
def create(self):
family, socktype, proto, canonname, sockaddr = \
socket.getaddrinfo(self.server, self.port, 0,
socket.SOCK_STREAM, 0, 0)[0]
self.socket = socket.socket(family, socktype)
self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.socket.connect(sockaddr)
def __init__(self, *args, **kwargs):
Connection.__init__(self, *args, **kwargs)
self.connected_event = Event()
self._write_queue = Queue()
self._callbacks = {}
self._push_watchers = defaultdict(set)
sockerr = None
addresses = socket.getaddrinfo(self.host, self.port, socket.AF_UNSPEC, socket.SOCK_STREAM)
for (af, socktype, proto, canonname, sockaddr) in addresses:
try:
self._socket = socket.socket(af, socktype, proto)
if self.ssl_options:
self._socket = ssl.wrap_socket(self._socket, **self.ssl_options)
self._socket.settimeout(1.0)
self._socket.connect(sockaddr)
sockerr = None
break
except socket.error as err:
sockerr = err
if sockerr:
raise socket.error(sockerr.errno, "Tried connecting to %s. Last error: %s" % ([a[4] for a in addresses], sockerr.strerror))
if self.sockopts:
for args in self.sockopts:
self._socket.setsockopt(*args)
self._read_watcher = gevent.spawn(self.handle_read)
self._write_watcher = gevent.spawn(self.handle_write)
self._send_options_message()
def _dnsQuery(hostname, serveListr='system', tcp=False):
u'''纯粹的查询，并没有过滤之类的功能
server:
'system'
'8.8.8.8'
['8.8.8.8','8.8.4.4']
返回值
['1.1.1.1','2.2.2.2']
'''
if serveListr == 'system':
try:
res = socket.getaddrinfo(hostname, 80, 0, socket.SOCK_STREAM,
socket.IPPROTO_TCP)
return [r[4][0] for r in res]
except Exception:
info = traceback.format_exc()
logging.debug(
u'[DNS][_dnsQuery][socket.getaddrinfo] 解析失败，host=%s 详细信息：' %
hostname)
logging.debug('%s\r\n\r\n' % info)
return []
else:
t = dnsPool.spawn(_dnspythonQuery, hostname, serveListr, tcp)
return t.get(True)
def __init__(self,
host,
port,
max_connection=1024,
request_model=Request,
use_ipv6=False):
"""
初始化server
@args:
host 主机ip :string
port 监听端口 :int
max_connection 最大连接数 :int
request_model 请求处理模板 :type
"""
self.host = host
self.port = port
self.max_connection = max_connection
if use_ipv6:
self.server = socket.socket(socket.AF_INET6)
self.server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR,
True)
ipv6_addr = socket.getaddrinfo(host, port)[0][-1]
self.server.bind(ipv6_addr)
else:
self.server = socket.socket()
self.server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR,
True)
self.server.bind((host, port))
self.request_model = request_model
def detect_ipv6():
try:
addrinfo = socket.getaddrinfo("www.google.com", 80)
af, _, _, _, _ = addrinfo[0]
return af == socket.AF_INET6 # @UndefinedVariable
except:
return False
def get_listening_sockets(sport):
sockets = []
# Use two sockets, one for IPv4, one for IPv6. IPv4-to-IPv6 mapped
# addresses do not work reliably everywhere (under linux it may have
# been disabled in /proc/sys/net/ipv6/bind_ipv6_only).
for res in socket.getaddrinfo(None, sport, socket.AF_UNSPEC,
socket.SOCK_STREAM, 0, socket.AI_PASSIVE):
af, socktype, proto, canonname, sa = res
try:
s = None
s = socket.socket(af, socktype, proto)
if af == socket.AF_INET6:
# Bind v6 only when AF_INET6, otherwise either v4 or v6 bind
# will fail.
s.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_V6ONLY, 1)
s.bind(sa)
s.listen(1)
sockets.append(s)
logger.debug("Listening on %s:%d" % sa[:2])
except socket.error, msg:
logger.error("Error binding to %s:%d: %s" % (sa[0], sa[1], msg[1]))
if s:
s.close()
while sockets:
sockets.pop().close()
# Make sure we fail immediately if we cannot get a socket
raise msg
def check(self, url, host_info):
host_info[self.description()] = None
host_ip = socket.getaddrinfo(url, 443)[0][4][0]
try:
sock = socket.socket()
sock.connect((host_ip, 443))
except socket.error:
host_info["ssl checked"].set(True)
host_info[self.description()] = True
return True
try:
sock = ssl.wrap_socket(
sock,
ca_certs="/etc/ssl/certs/ca-certificates.crt",
cert_reqs=ssl.CERT_NONE,
)
cert = sock.getpeercert()
except ssl.SSLError:
host_info["ssl checked"].set(True)
host_info[self.description()] = True
return True
host_info["ssl checked"].set(False)
host_info[self.description()] = False
return False
def bootstrap_from_dns(self):
"""
Fetches CM server list from WebAPI and replaces the current one
"""
self._LOG.debug("Attempting bootstrap via DNS")
try:
answer = socket.getaddrinfo("cm0.steampowered.com",
27017,
socket.AF_INET,
proto=socket.IPPROTO_TCP)
except Exception as exp:
self._LOG.error("DNS boostrap failed: %s" % str(exp))
return False
servers = list(map(lambda addr: addr[4], answer))
if servers:
self.clear()
self.merge_list(servers)
return True
else:
self._LOG.error(
"DNS boostrap: cm0.steampowered.com resolved no A records")
return False
def __init__(self, *args, **kwargs):
Connection.__init__(self, *args, **kwargs)
self.connected_event = Event()
self._write_queue = Queue()
self._callbacks = {}
self._push_watchers = defaultdict(set)
sockerr = None
addresses = socket.getaddrinfo(self.host, self.port, socket.AF_UNSPEC, socket.SOCK_STREAM)
for (af, socktype, proto, canonname, sockaddr) in addresses:
try:
self._socket = socket.socket(af, socktype, proto)
if self.ssl_options:
self._socket = ssl.wrap_socket(self._socket, **self.ssl_options)
self._socket.settimeout(1.0)
self._socket.connect(sockaddr)
sockerr = None
break
except socket.error as err:
sockerr = err
if sockerr:
raise socket.error(sockerr.errno, "Tried connecting to %s. Last error: %s" % ([a[4] for a in addresses], sockerr.strerror))
if self.sockopts:
for args in self.sockopts:
self._socket.setsockopt(*args)
self._read_watcher = gevent.spawn(self.handle_read)
self._write_watcher = gevent.spawn(self.handle_write)
self._send_options_message()
def test_AI_CANONNAME(self):
# Not all systems support AI_CANONNAME; notably tha manylinux
# resolvers *sometimes* do not. Specifically, sometimes they
# provide the canonical name *only* on the first result.
args = (
# host
TestGeventOrg.HOSTNAME,
# port
None,
# family
socket.AF_INET,
# type
0,
# proto
0,
# flags
socket.AI_CANONNAME)
gevent_result = gevent_socket.getaddrinfo(*args)
self.assertEqual(gevent_result[0][3], 'readthedocs.io')
real_result = socket.getaddrinfo(*args)
self.NORMALIZE_GAI_IGNORE_CANONICAL_NAME = not all(
r[3] for r in real_result)
try:
self.assertEqualResults(real_result, gevent_result, 'getaddrinfo')
finally:
del self.NORMALIZE_GAI_IGNORE_CANONICAL_NAME
def get_listening_sockets(sport):
sockets = []
# Use two sockets, one for IPv4, one for IPv6. IPv4-to-IPv6 mapped
# addresses do not work reliably everywhere (under linux it may have
# been disabled in /proc/sys/net/ipv6/bind_ipv6_only).
for res in socket.getaddrinfo(None, sport, socket.AF_UNSPEC,
socket.SOCK_STREAM, 0, socket.AI_PASSIVE):
af, socktype, proto, canonname, sa = res
try:
s = None
s = socket.socket(af, socktype, proto)
if af == socket.AF_INET6:
# Bind v6 only when AF_INET6, otherwise either v4 or v6 bind
# will fail.
s.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_V6ONLY, 1)
s.bind(sa)
s.listen(1)
sockets.append(s)
logger.debug("Listening on %s:%d" % sa[:2])
except socket.error, msg:
logger.error("Error binding to %s:%d: %s" %
(sa[0], sa[1], msg[1]))
if s:
s.close()
while sockets:
sockets.pop().close()
# Make sure we fail immediately if we cannot get a socket
raise msg
def _getaddrinfo(self, host, family):
self.logger.debug("Resolving %s", host)
try:
info = getaddrinfo(host, 0, family, SOCK_DGRAM)
return set(map(itemgetter(0), map(itemgetter(-1), info)))
except gaierror as e:
self.logger.error("Failed to resolve %s: %s", host, e)
return set()
def bind_local_udp(tcpsock):
tcpaddr = tcpsock.getsockname()
addrinfo = socket.getaddrinfo(tcpaddr[0], 0, 0, socket.SOCK_DGRAM,
socket.SOL_UDP)
af, socktype, proto, _, localaddr = addrinfo[0]
udpsock = socket.socket(af, socktype, proto)
udpsock.bind(localaddr)
return udpsock
def __init__(self, ip, port, relayfactory, timeout=30, maxclient=200):
self.ip = ip
self.port = port
self.timeout = timeout
self.relayfactory = relayfactory
self.pool = Pool(maxclient)
addrinfo = socket.getaddrinfo(ip, port, 0, socket.SOCK_STREAM, socket.SOL_TCP)
af, socktype, proto, _, localaddr = addrinfo[0]
self.server = StreamServer(localaddr, self._handle, spawn=self.pool)
def connect(self, destpair):
for res in socket.getaddrinfo(destpair[0], destpair[1], self.family, self.type, self.proto):
af, socktype, proto, _canonname, sa = res
ip = IPAddress(sa[0])
if self._force_direct_connect or config['type'] is None or not config['enabled'] or config['last_error'] or any(ip in network for network in local_networks):
self.setproxy()
else:
self.setproxy(proxytype=type_to_int(config['type']), addr=config['host'], port=config['port'], rdns=True, username=config['username'], password=config['password'])
socks.socksocket.connect(self, sa)
break
def __init__(self, ip, port, relayfactory, timeout=30, maxclient=200):
self.ip = ip
self.port = port
self.timeout = timeout
self.relayfactory = relayfactory
self.pool = Pool(maxclient)
addrinfo = socket.getaddrinfo(ip, port, 0, socket.SOCK_STREAM,
socket.SOL_TCP)
af, socktype, proto, _, localaddr = addrinfo[0]
self.server = StreamServer(localaddr, self._handle, spawn=self.pool)
def run(self):
addrs = socket.getaddrinfo(self.listen_ip, self.listen_port, 0,
socket.SOCK_STREAM, socket.SOL_TCP)
af, socktype, proto, canonname, sa = addrs[0]
listen_socket = socket.socket(af, socktype, proto)
listen_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
listen_socket.setsockopt(socket.SOL_TCP, socket.TCP_NODELAY, 1)
listen_socket.bind(sa)
listen_socket.listen(1024)
gevent.joinall([gevent.spawn(self.get_connection, listen_socket)])
def test_enums(self):
# https://github.com/gevent/gevent/issues/1310
# On Python 3, getaddrinfo does special things to make sure that
# the fancy enums are returned.
gai = gevent_socket.getaddrinfo('example.com', 80, socket.AF_INET,
socket.SOCK_STREAM, socket.IPPROTO_TCP)
af, socktype, _proto, _canonname, _sa = gai[0]
self.assertIs(socktype, socket.SOCK_STREAM)
self.assertIs(af, socket.AF_INET)
def resolve_fn(d, timeout=4):
ips = None
try:
with gevent.Timeout(timeout, False):
ips = {
f[4][0]
for f in socket.getaddrinfo(d, 80, socket.AF_INET, 0,
socket.IPPROTO_TCP)
}
except socket.gaierror as ex:
pass
return d, ips
def connect(self):
host, port = (self.host, self.port)
#Clean out the buffers
self._buffer.clear()
#If the existing socket is not None close it
if self._socket is not None:
self.close()
# Resolve the hostname and connect (ipv6 ready)
sock = None
try:
for info in socket.getaddrinfo(host, port, socket.AF_UNSPEC,
socket.SOCK_STREAM):
family, socktype, proto, canonname, sockaddr = info
#Validate the socket will make
try:
sock = socket.socket(family, socktype, proto)
#Set Keepalives
sock.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
except socket.error, msg:
print('Socket Error: %s' % msg)
sock = None
continue
#Wrap in ssl if asked
if self.SSL:
print('Starting SSL')
try:
ctx = SSL.Context(SSL.SSLv23_METHOD)
sock = SSL.Connection(ctx, sock)
except SSL.Error, err:
print('Could not Initiate SSL: %s' % err)
sock = None
continue
#Try to establish the connection
try:
print('Trying Connect(%s)' % repr(sockaddr))
sock.settimeout(10)
sock.connect(sockaddr)
except socket.error, msg:
print('Socket Error: %s' % msg)
if self.SSL:
sock.shutdown()
sock.close()
sock = None
continue
def listen_all(self):
for res in socket.getaddrinfo(self.host, self.port,
socket.AF_UNSPEC, socket.SOCK_DGRAM,
0, socket.AI_PASSIVE):
print "dl_server: listening to", res
af, socktype, proto, canonname, sa = res
try:
self.receive_socket = socket.socket(af, socktype, proto)
except socket.error, msg:
self.receive_socket = None
continue
try:
self.receive_socket.bind(sa)
except socket.error, msg:
self.receive_socket.close()
self.receive_socket = None
continue
def create_connection(address,
timeout=socket._GLOBAL_DEFAULT_TIMEOUT,
source_address=None,
socket_options=None):
"""Connect to *address* and return the socket object.
Convenience function. Connect to *address* (a 2-tuple ``(host,
port)``) and return the socket object. Passing the optional
*timeout* parameter will set the timeout on the socket instance
before attempting to connect. If no *timeout* is supplied, the
global default timeout setting returned by :func:`getdefaulttimeout`
is used. If *source_address* is set it must be a tuple of (host, port)
for the socket to bind as a source address before making the connection.
An host of '' or port 0 tells the OS to use the default.
"""
host, port = address
err = None
for res in socket.getaddrinfo(host, port, 0, socket.SOCK_STREAM):
af, socktype, proto, canonname, sa = res
sock = None
try:
sock = socket.socket(af, socktype, proto)
# If provided, set socket level options before connecting.
# This is the only addition urllib3 makes to this function.
_set_socket_options(sock, socket_options)
if timeout is not socket._GLOBAL_DEFAULT_TIMEOUT:
sock.settimeout(timeout)
if source_address:
sock.bind(source_address)
sock.connect(sa)
return sock
except socket.error as _:
err = _
if sock is not None:
sock.close()
if err is not None:
raise err
else:
raise socket.error("getaddrinfo returns an empty list")
def create_connection(address, timeout=socket._GLOBAL_DEFAULT_TIMEOUT, source_address=None):
"""Connect to *address* and return the socket object.
Convenience function. Connect to *address* (a 2-tuple ``(host,
port)``) and return the socket object. Passing the optional
*timeout* parameter will set the timeout on the socket instance
before attempting to connect. If no *timeout* is supplied, the
global default timeout setting returned by :func:`getdefaulttimeout`
is used. If *source_address* is set it must be a tuple of (host, port)
for the socket to bind as a source address before making the connection.
An host of '' or port 0 tells the OS to use the default.
"""
host, port = address
err = None
force_direct_connect = host == globalconfig['reconnect.routerip'] and True or False
for res in socket.getaddrinfo(host, port, 0 if socket.has_ipv6 else socket.AF_INET, socket.SOCK_STREAM):
af, socktype, proto, _canonname, sa = res
sock = None
try:
sock = socket.socket(af, socktype, proto, force_direct_connect=force_direct_connect)
if timeout is not socket._GLOBAL_DEFAULT_TIMEOUT:
sock.settimeout(timeout)
if source_address:
sock.bind(source_address)
sock.connect(sa)
return sock
except socket.error:
err = sys.exc_info()[1]
# without exc_clear(), if connect() fails once, the socket is referenced by the frame in exc_info
# and the next bind() fails (see test__socket.TestCreateConnection)
# that does not happen with regular sockets though, because _socket.socket.connect() is a built-in.
# this is similar to "getnameinfo loses a reference" failure in test_socket.py
sys.exc_clear()
if sock is not None:
sock.close()
if err is not None:
raise err
else:
raise socket.error("getaddrinfo returns an empty list")
def create_listeners(address,
family=socket.AF_UNSPEC,
socktype=socket.SOCK_STREAM,
proto=socket.IPPROTO_IP):
"""Uses :func:`socket.getaddrinfo` to create listening sockets for
available socket parameters. For example, giving *address* as
``('localhost', 80)`` on a system with IPv6 would return one socket bound
to ``127.0.0.1`` and one bound to ``::1`.
May also be used for ``socket.AF_UNIX`` with a file path to produce a
single unix domain socket listening on that path.
:param address: A ``(host, port)`` tuple to listen on.
:param family: the socket family, default ``AF_UNSPEC``.
:param socktype: the socket type, default ``SOCK_STREAM``.
:param proto: the socket protocol, default ``IPPROTO_IP``.
"""
if family == socket.AF_UNIX:
sock = socket.socket(family, socktype, proto)
_init_socket(sock, address)
return [sock]
elif not isinstance(address, tuple) or len(address) != 2:
raise ValueError(address)
flags = socket.AI_PASSIVE
host, port = address
listeners = []
last_exc = None
for res in socket.getaddrinfo(host, port, family, socktype, proto, flags):
fam, typ, prt, _, sockaddr = res
try:
sock = socket.socket(fam, typ, prt)
_init_socket(sock, sockaddr)
except socket.error as exc:
last_exc = exc
else:
listeners.append(sock)
if last_exc and not listeners:
raise last_exc
return listeners
def create_listeners(address,
family=socket.AF_UNSPEC,
socktype=socket.SOCK_STREAM,
proto=socket.IPPROTO_IP):
"""Uses :func:`socket.getaddrinfo` to create listening sockets for
available socket parameters. For example, giving *address* as
``('localhost', 80)`` on a system with IPv6 would return one socket bound
to ``127.0.0.1`` and one bound to ``::1`.
May also be used for ``socket.AF_UNIX`` with a file path to produce a
single unix domain socket listening on that path.
:param address: A ``(host, port)`` tuple to listen on.
:param family: the socket family, default ``AF_UNSPEC``.
:param socktype: the socket type, default ``SOCK_STREAM``.
:param proto: the socket protocol, default ``IPPROTO_IP``.
"""
if family == socket.AF_UNIX:
sock = socket.socket(family, socktype, proto)
_init_socket(sock, address)
return [sock]
elif not isinstance(address, tuple) or len(address) != 2:
raise ValueError(address)
flags = socket.AI_PASSIVE
host, port = address
listeners = []
last_exc = None
for res in socket.getaddrinfo(host, port, family, socktype, proto, flags):
fam, typ, prt, _, sockaddr = res
try:
sock = socket.socket(fam, typ, prt)
_init_socket(sock, sockaddr)
except socket.error as exc:
last_exc = exc
else:
listeners.append(sock)
if last_exc and not listeners:
raise last_exc
return listeners
def _dnsQuery(hostname, serveListr='system', tcp=False):
u'''纯粹的查询，并没有过滤之类的功能
server:
'system'
'8.8.8.8'
['8.8.8.8','8.8.4.4']
返回值
['1.1.1.1','2.2.2.2']
'''
if serveListr == 'system':
try:
res = socket.getaddrinfo(hostname, 80, 0, socket.SOCK_STREAM, socket.IPPROTO_TCP)
return [r[4][0] for r in res]
except Exception:
info = traceback.format_exc()
logging.debug(u'[DNS][_dnsQuery][socket.getaddrinfo] 解析失败，host=%s 详细信息：' % hostname)
logging.debug('%s\r\n\r\n' % info)
return []
else:
t = dnsPool.spawn(_dnspythonQuery, hostname, serveListr, tcp)
return t.get(True)
def _connect(self):
"""这部分是真正的建立与reids的tcp连接"""
# we want to mimic what socket.create_connection does to support
# ipv4/ipv6, but we want to set options prior to calling
# socket.connect()
err = None
for res in socket.getaddrinfo(self.host, self.port, 0,
socket.SOCK_STREAM):
family, socktype, proto, canonname, socket_address = res
sock = None
try:
sock = socket.socket(family, socktype, proto)
# TCP_NODELAY
sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
# TCP_KEEPALIVE
if self.socket_keepalive:
sock.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
for k, v in iteritems(self.socket_keepalive_options):
sock.setsockopt(socket.SOL_TCP, k, v)
# set the socket_connect_timeout before we connect
sock.settimeout(self.socket_connect_timeout)
# connect
sock.connect(socket_address)
# set the socket_timeout now that we're connected
sock.settimeout(self.socket_timeout)
return sock
except socket.error as _:
err = _
if sock is not None:
sock.close()
if err is not None:
raise err
raise socket.error("socket.getaddrinfo returned an empty list")
def _create_connection(address,
timeout=socket._GLOBAL_DEFAULT_TIMEOUT,
source_address=None,
prepare=None):
# Taken from:
# https://github.com/python/cpython/blob/0f40482fde59ff307569fa5676183dd8432809a8/Lib/socket.py#L771
# Licensed under the PSFL, version 2
# Copyright (c) 2001-now Python Software Foundation
host, port = address
err = None
for res in socket.getaddrinfo(host, port, 0, socket.SOCK_STREAM):
af, socktype, proto, canonname, sa = res
sock = None
try:
sock = socket(af, socktype, proto)
if timeout is not socket._GLOBAL_DEFAULT_TIMEOUT:
sock.settimeout(timeout)
if source_address:
sock.bind(source_address)
if prepare:
prepare(sock)
sock.connect(sa)
# Break explicitly a reference cycle
err = None
return sock
except socket.error as e:
err = e
if sock is not None:
sock.close()
if err is not None:
try:
raise err
finally:
# Break explicitly a reference cycle
err = None
else:
raise socket.error("getaddrinfo returns an empty list")
def _connect(self):
"""这部分是真正的建立与reids的tcp连接"""
# we want to mimic what socket.create_connection does to support
# ipv4/ipv6, but we want to set options prior to calling
# socket.connect()
err = None
for res in socket.getaddrinfo(self.host, self.port, 0,
socket.SOCK_STREAM):
family, socktype, proto, canonname, socket_address = res
sock = None
try:
sock = socket.socket(family, socktype, proto)
# TCP_NODELAY
sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
# TCP_KEEPALIVE
if self.socket_keepalive:
sock.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
for k, v in iteritems(self.socket_keepalive_options):
sock.setsockopt(socket.SOL_TCP, k, v)
# set the socket_connect_timeout before we connect
sock.settimeout(self.socket_connect_timeout)
# connect
sock.connect(socket_address)
# set the socket_timeout now that we're connected
sock.settimeout(self.socket_timeout)
return sock
except socket.error as _:
err = _
if sock is not None:
sock.close()
if err is not None:
raise err
raise socket.error("socket.getaddrinfo returned an empty list")
def _do_connect(endpoint):
net, addr = endpoint
if net in ('unix',):
is_tcp = False
addrinfo = [(AF_UNIX, SOCK_STREAM, 0, '', addr)]
else:
is_tcp = True
addrinfo = getaddrinfo(addr[0], addr[1], 0, SOCK_STREAM)
if not addrinfo:
raise ValueError('no addresses for %r' % (endpoint,))
exc = RuntimeError # pylint can't figure it out otherwise
for family, socktype, proto, canonname, address in addrinfo:
sock = socket(family, socktype, proto)
try:
sock.connect(address)
except:
exc = sys.exc_info()[1]
continue
if is_tcp:
sock.setsockopt(IPPROTO_TCP, TCP_NODELAY, 1) # pylint: disable=E1101
return sock
raise exc
def create_connection_ipv4(address, timeout=None, source_address=None,
only_ports=None):
"""Attempts to mimick to :py:func:`socket.create_connection`, but
connections are only made to IPv4 addresses.
:param only_ports: If given, can be a list to limit which ports are
restricted to IPv4. Connections to all other ports may
be IPv6.
"""
host, port = address
if only_ports and port not in only_ports:
return socket.create_connection(address, timeout, source_address)
last_exc = None
for res in socket.getaddrinfo(host, port, socket.AF_INET):
_, _, _, _, sockaddr = res
try:
return socket.create_connection(sockaddr, timeout, source_address)
except socket.error as exc:
last_exc = exc
if last_exc is not None:
raise last_exc
else:
raise socket.error('getaddrinfo returns an empty list')
def test_unspec(self):
self.assertEqual(gevent_socket.getaddrinfo('gevent.org', None, socket.AF_UNSPEC), self.getresult())
def test_inet(self):
self.assertEqual(gevent_socket.getaddrinfo('gevent.org', None, socket.AF_INET), self.getresult())
def _handshake(self):
"""
Perform handshake/authentication with a connecting client
Outline:
1. Client connects
2. We fake RFB 3.8 protocol and require VNC authentication [also supports RFB 3.3]
3. Client accepts authentication method
4. We send an authentication challenge
5. Client sends the authentication response
6. We check the authentication
7. We initiate a connection with the backend server and perform basic
RFB 3.8 handshake with it.
Upon return, self.client and self.server are sockets
connected to the client and the backend server, respectively.
"""
self.client.send(rfb.RFB_VERSION_3_8 + "\n")
client_version_str = self.client.recv(1024)
client_version = rfb.check_version(client_version_str)
if not client_version:
self.error("Invalid version: %s" % client_version_str)
raise gevent.GreenletExit
# Both for RFB 3.3 and 3.8
self.debug("Requesting authentication")
auth_request = rfb.make_auth_request(rfb.RFB_AUTHTYPE_VNC,
version=client_version)
self.client.send(auth_request)
# The client gets to propose an authtype only for RFB 3.8
if client_version == rfb.RFB_VERSION_3_8:
res = self.client.recv(1024)
type = rfb.parse_client_authtype(res)
if type == rfb.RFB_AUTHTYPE_ERROR:
self.warn("Client refused authentication: %s" % res[1:])
else:
self.debug("Client requested authtype %x" % type)
if type != rfb.RFB_AUTHTYPE_VNC:
self.error("Wrong auth type: %d" % type)
self.client.send(rfb.to_u32(rfb.RFB_AUTH_ERROR))
raise gevent.GreenletExit
# Generate the challenge
challenge = os.urandom(16)
self.client.send(challenge)
response = self.client.recv(1024)
if len(response) != 16:
self.error("Wrong response length %d, should be 16" % len(response))
raise gevent.GreenletExit
if rfb.check_password(challenge, response, self.password):
self.debug("Authentication successful!")
else:
self.warn("Authentication failed")
self.client.send(rfb.to_u32(rfb.RFB_AUTH_ERROR))
raise gevent.GreenletExit
# Accept the authentication
self.client.send(rfb.to_u32(rfb.RFB_AUTH_SUCCESS))
# Try to connect to the server
tries = 50
while tries:
tries -= 1
# Initiate server connection
for res in socket.getaddrinfo(self.daddr, self.dport, socket.AF_UNSPEC,
socket.SOCK_STREAM, 0, socket.AI_PASSIVE):
af, socktype, proto, canonname, sa = res
try:
self.server = socket.socket(af, socktype, proto)
except socket.error, msg:
self.server = None
continue
try:
self.debug("Connecting to %s:%s" % sa[:2])
self.server.connect(sa)
self.debug("Connection to %s:%s successful" % sa[:2])
except socket.error, msg:
self.server.close()
self.server = None
continue
# We succesfully connected to the server
tries = 0
break
def test_unspec(self):
self.assertEqualResults(self.getresult(),
gevent_socket.getaddrinfo(TestGeventOrg.HOSTNAME, None, socket.AF_UNSPEC),
'getaddrinfo')
def test_inet(self):
self.assertEqualResults(self.getresult(),
gevent_socket.getaddrinfo(TestGeventOrg.HOSTNAME, None, socket.AF_INET),
'getaddrinfo')
def _app(self, environ, start_response):
start_response('200 OK', [('Content-Type','text/plain')])
yield "{0}\n".format(socket.getaddrinfo('www.baidu.com', 80))
def worker(host):
try:
return socket.getaddrinfo(host, port, family, socktype, proto, flags)
except Exception as e:
return e
def test_error(self):
socket.getaddrinfo('host', 25, socket.AF_INET).AndReturn([(None, None, None, None, 'sockaddr')])
socket.create_connection('sockaddr', IgnoreArg(), IgnoreArg()).AndRaise(socket.error('error'))
self.mox.ReplayAll()
with self.assertRaises(socket.error):
self.socket_creator(('host', 25), 'timeout', 'source')
import socket import gevent.socket as gevent_socket gevent_socket.getaddrinfo(u'gevent.org', None, socket.AF_INET)
def _perform_server_handshake(self):
"""
Initiate a connection with the backend server and perform basic
RFB 3.8 handshake with it.
Return a socket connected to the backend server.
"""
server = None
tries = VncAuthProxy.connect_retries
while tries:
tries -= 1
# Initiate server connection
for res in socket.getaddrinfo(self.daddr, self.dport,
socket.AF_UNSPEC,
socket.SOCK_STREAM, 0,
socket.AI_PASSIVE):
af, socktype, proto, canonname, sa = res
try:
server = socket.socket(af, socktype, proto)
except socket.error:
server = None
continue
# Set socket timeout for the initial handshake
server.settimeout(VncAuthProxy.server_timeout)
try:
self.debug("Connecting to %s:%s", *sa[:2])
server.connect(sa)
self.debug("Connection to %s:%s successful", *sa[:2])
except socket.error as err:
self.debug("Failed to perform sever hanshake, retrying...")
server.close()
server = None
continue
# We succesfully connected to the server
tries = 0
break
# Wait and retry
gevent.sleep(VncAuthProxy.retry_wait)
if server is None:
raise InternalError("Failed to connect to server")
version = server.recv(1024)
if not rfb.check_version(version):
raise InternalError("Unsupported RFB version: %s"
% version.strip())
server.send(rfb.RFB_VERSION_3_8 + "\n")
res = server.recv(1024)
types = rfb.parse_auth_request(res)
if not types:
raise InternalError("Error handshaking with the server")
else:
self.debug("Supported authentication types: %s",
" ".join([str(x) for x in types]))
if rfb.RFB_AUTHTYPE_NONE not in types:
raise InternalError("Error, server demands authentication")
server.send(rfb.to_u8(rfb.RFB_AUTHTYPE_NONE))
# Check authentication response
res = server.recv(4)
res = rfb.from_u32(res)
if res != 0:
raise InternalError("Authentication error")
# Reset the timeout for the rest of the session
server.settimeout(None)
self.server = server
def test_no_addresses(self):
socket.getaddrinfo('host', 25, socket.AF_INET).AndReturn([])
self.mox.ReplayAll()
with self.assertRaises(socket.error):
self.socket_creator(('host', 25), 'timeout', 'source')
def test_successful(self):
socket.getaddrinfo('host', 25, socket.AF_INET).AndReturn([(None, None, None, None, 'sockaddr')])
socket.create_connection('sockaddr', IgnoreArg(), IgnoreArg()).AndReturn('socket')
self.mox.ReplayAll()
ret = self.socket_creator(('host', 25), 'timeout', 'source')
self.assertEqual('socket', ret)
