def getnameinfo(address, flags):
dns.build_resolver()
try:
host, port = address
except (ValueError, TypeError):
if not isinstance(address, tuple):
del address
raise TypeError('getnameinfo() argument must be a tuple')
else:
raise socket.gaierror(
socket.EAI_NONAME, "Name or service not known")
if (flags & socket.NI_NAMEREQD) and (flags & socket.NI_NUMERICHOST):
raise socket.gaierror(
socket.EAI_NONAME, "Name or service not known")
if dns.is_ipv4(host):
try:
name = dns.reversename.from_address(host)
results = dns.resolver_obj.query(name, dns.rdatatype.PTR)
if len(results) > 1:
raise socket.error(
"sockaddr resolved to multiple addresses")
host = results[0].target.to_text(omit_final_dot=True)
except dns.exception.Timeout, exc:
if flags & socket.NI_NAMEREQD:
raise socket.gaierror(socket.EAI_AGAIN, 'Lookup timed out')
except dns.resolver.NXDOMAIN:
return (host, str(port))
def fake_gethostbyname(hostname):
try:
host_ip = None
# for templates/index.py
if hostname == config.get("broker", "bind_address"):
host_ip = gethostbyname_orig(hostname)
else:
# faking hostip
fake_hosts = config.get("unittest", "fake_hosts_location")
hostfilename = fake_hosts + hostname
# strip domain part
if not os.path.exists(hostfilename) and hostname.find(".") > -1:
hostfilename = fake_hosts + hostname[: hostname.find(".")]
hostfile = open(hostfilename).readlines()
primary_name = hostfile[0].split()[2]
ip_re = re.compile(r"^\s*([a-z0-9]+)\s+[a-z0-9]+\s+([0-9\.]+)")
for line in hostfile:
m = ip_re.search(line)
if m and primary_name == m.group(1):
host_ip = m.group(2)
break
if host_ip == None:
raise gaierror(-2, "Name or service not known")
return host_ip
except IOError, e:
# To have the cause in aqd.log
raise gaierror(-2, "Name or service not known %s" % e)
def getnameinfo(sockaddr, flags):
"""Replacement for Python's socket.getnameinfo.
Currently only supports IPv4.
"""
host, port = sockaddr
if (flags & socket.NI_NAMEREQD) and (flags & socket.NI_NUMERICHOST):
# Conflicting flags. Punt.
raise socket.gaierror(
(socket.EAI_NONAME, 'Name or service not known'))
if is_ipv4_addr(host):
try:
rrset = resolver.query(
dns.reversename.from_address(host), dns.rdatatype.PTR)
if len(rrset) > 1:
raise socket.error('sockaddr resolved to multiple addresses')
host = rrset[0].target.to_text(omit_final_dot=True)
except dns.exception.Timeout, e:
if flags & socket.NI_NAMEREQD:
raise socket.gaierror((socket.EAI_AGAIN, 'Lookup timed out'))
except dns.exception.DNSException, e:
if flags & socket.NI_NAMEREQD:
raise socket.gaierror(
(socket.EAI_NONAME, 'Name or service not known'))
def do_resolve(query, dnsserver, timeout, queobj):
if isinstance(query, basestring):
qtype = dnslib.QTYPE.AAAA if ':' in dnsserver else dnslib.QTYPE.A
query = dnslib.DNSRecord(q=dnslib.DNSQuestion(query, qtype=qtype))
query_data = query.pack()
sock_family = socket.AF_INET6 if ':' in dnsserver else socket.AF_INET
sock = socket.socket(sock_family)
rfile = None
try:
sock.settimeout(timeout or None)
sock.connect(parse_hostport(dnsserver, 53))
sock.send(struct.pack('>h', len(query_data)) + query_data)
rfile = sock.makefile('r', 1024)
reply_data_length = rfile.read(2)
if len(reply_data_length) < 2:
raise socket.gaierror(11004, 'getaddrinfo %r from %r failed' % (query, dnsserver))
reply_data = rfile.read(struct.unpack('>h', reply_data_length)[0])
record = dnslib.DNSRecord.parse(reply_data)
iplist = [str(x.rdata) for x in record.rr if x.rtype in (1, 28, 255)]
if any(x in blacklist for x in iplist):
logging.debug('query=%r dnsserver=%r record bad iplist=%r', query, dnsserver, iplist)
raise socket.gaierror(11004, 'getaddrinfo %r from %r failed' % (query, dnsserver))
else:
logging.debug('query=%r dnsserver=%r record iplist=%s', query, dnsserver, iplist)
queobj.put(record)
except socket.error as e:
logging.debug('query=%r dnsserver=%r failed %r', query, dnsserver, e)
queobj.put(e)
finally:
if rfile:
rfile.close()
sock.close()
def test_no_internet(monkeypatch):
# No crash occur if the computer don't have access to internet.
from socket import gaierror
monkeypatch.setattr(boc_currency_provider, 'urlopen', exception_raiser(gaierror()))
monkeypatch.setattr(yahoo_currency_provider, 'urlopen', exception_raiser(gaierror()))
with raises(RateProviderUnavailable):
boc_currency_provider.BOCProviderPlugin().wrapped_get_currency_rates(
'USD', date(2008, 5, 20), date(2008, 5, 20)
)
yahoo_currency_provider.YahooProviderPlugin().wrapped_get_currency_rates(
'LVL', date(2008, 5, 20), date(2008, 5, 20)
)
def dnslib_resolve_over_tcp(query, dnsservers, timeout, **kwargs):
"""dns query over tcp"""
if not isinstance(query, (basestring, dnslib.DNSRecord)):
raise TypeError("query argument requires string/DNSRecord")
blacklist = kwargs.get("blacklist", ())
def do_resolve(query, dnsserver, timeout, queobj):
if isinstance(query, basestring):
qtype = dnslib.QTYPE.AAAA if ":" in dnsserver else dnslib.QTYPE.A
query = dnslib.DNSRecord(q=dnslib.DNSQuestion(query, qtype=qtype))
query_data = query.pack()
sock_family = socket.AF_INET6 if ":" in dnsserver else socket.AF_INET
sock = socket.socket(sock_family)
rfile = None
try:
sock.settimeout(timeout or None)
sock.connect(parse_hostport(dnsserver, 53))
sock.send(struct.pack(">h", len(query_data)) + query_data)
rfile = sock.makefile("r", 1024)
reply_data_length = rfile.read(2)
if len(reply_data_length) < 2:
raise socket.gaierror(11004, "getaddrinfo %r from %r failed" % (query, dnsserver))
reply_data = rfile.read(struct.unpack(">h", reply_data_length)[0])
record = dnslib.DNSRecord.parse(reply_data)
iplist = [str(x.rdata) for x in record.rr if x.rtype in (1, 28, 255)]
if any(x in blacklist for x in iplist):
logging.debug("query=%r dnsserver=%r record bad iplist=%r", query, dnsserver, iplist)
raise socket.gaierror(11004, "getaddrinfo %r from %r failed" % (query, dnsserver))
else:
logging.debug("query=%r dnsserver=%r record iplist=%s", query, dnsserver, iplist)
queobj.put(record)
except socket.error as e:
logging.debug("query=%r dnsserver=%r failed %r", query, dnsserver, e)
queobj.put(e)
finally:
if rfile:
rfile.close()
sock.close()
queobj = Queue.Queue()
for dnsserver in dnsservers:
thread.start_new_thread(do_resolve, (query, dnsserver, timeout, queobj))
for i in range(len(dnsservers)):
try:
result = queobj.get(timeout)
except Queue.Empty:
raise socket.gaierror(11004, "getaddrinfo %r from %r failed" % (query, dnsservers))
if result and not isinstance(result, Exception):
return result
elif i == len(dnsservers) - 1:
logging.warning("dnslib_resolve_over_tcp %r with %s return %r", query, dnsservers, result)
raise socket.gaierror(11004, "getaddrinfo %r from %r failed" % (query, dnsservers))
def test_should_reject_false(self, lookup_call):
import socket
lookup_call.side_effect = socket.gaierror("foobar")
dnsbl = self._make_one()
self.assertFalse(dnsbl.should_reject({"ip_address": "10.0.100.1"}))
lookup_call.assert_called_with("1.100.0.10.xbl.spamhaus.org.")
def getaddrinfo(self, host, port, family=0, socktype=0, proto=0, flags=0):
"""
Mock for L{socket.getaddrinfo}.
@param host: see L{socket.getaddrinfo}
@param port: see L{socket.getaddrinfo}
@param family: see L{socket.getaddrinfo}
@param socktype: see L{socket.getaddrinfo}
@param proto: see L{socket.getaddrinfo}
@param flags: see L{socket.getaddrinfo}
@return: L{socket.getaddrinfo}
"""
self.calls.append((host, port, family, socktype, proto, flags))
results = self.results[host]
if results:
return results
else:
raise gaierror(EAI_NONAME,
'nodename nor servname provided, or not known')
def test_connection_error(self):
reason = socket.gaierror(8, 'nodename nor servname provided')
self.urlopen_mock.side_effect = urllib2.URLError(reason)
tasks.fetch_manifest('url', self.upload.pk)
self.check_validation(
'No manifest was found at that URL. Check the address and try '
'again.')
def get_google_ipranges(dnsserver = '8.8.4.4'):
query = '_netblocks.google.com'
timeout=10
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
ipranges=[]
ipset=netaddr.IPSet()
try:
query = dnslib.DNSRecord(q=dnslib.DNSQuestion(query,dnslib.QTYPE.TXT))
query_data = query.pack()
sock.sendto(query_data, (dnsserver, 53))
ins, _, _ = select.select([sock], [], [], timeout)
for sock in ins:
reply_data, reply_address = sock.recvfrom(512)
reply_server = reply_address[0]
record = dnslib.DNSRecord.parse(reply_data)
# print record.rr[0].rdata
ipranges = [ netaddr.IPNetwork(x) for x in re.findall(r'[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+/[0-9]+',str(record.rr[0].rdata)) ]
ipset=netaddr.IPSet(ipranges)
except socket.error as e:
print 'handle dns query=%s socket: %r', query, e
raise socket.gaierror(11004, 'getaddrinfo %r from %r failed' % (query, dnsserver))
finally:
sock.close()
return (ipranges,ipset)
def dummy_gethostbyname(self, host):
if host in ("localhost", "127.0.0.1"):
return "127.0.0.1"
elif re.match(r"\d+\.\d+\.\d+\.\d+", host):
return host
else:
raise socket.gaierror("Dummy test error")
def getnameinfo (addr, flags):
"""
Replacement for Python's socket.getnameinfo.
The flags can be:
* NI_NAMEREQD If set, then an error is returned if the hostname cannot be determined.
* NI_DGRAM: If set, then the service is datagram (UDP) based rather than stream (TCP) based. This is required for the few ports (512-514) that have different services for UDP and TCP.
* NI_NOFQDN: If set, return only the hostname part of the fully qualified domain name for local hosts.
* NI_NUMERICHOST: If set, then the numeric form of the hostname is returned. (When not set, this will still happen in case the node's name cannot be determined.)
* NI_NUMERICSERV: If set, then the numeric form of the service address is returned. (When not set, this will still happen in case the service's name cannot be determined.)
:param flags: the modifer flags
"""
if (flags & socket.NI_NAMEREQD) and (flags & socket.NI_NUMERICHOST):
# Conflicting flags. Punt.
raise socket.gaierror((socket.EAI_NONAME, 'Name or service not known'))
resolved = Event()
def _resolve_callback(result, errorno):
try:
if errorno:
e = pycares.errno.errorcode[errorno]
msg = pycares.errno.strerror(errorno)
resolved.send_exception(socket.gaierror(e, msg))
else:
resolved.send(result)
except Exception, e:
resolved.send_exception(e)
def test_gaierror(self):
"""
L{error.getConnectError} converts to a L{error.UnknownHostError} given
a C{socket.gaierror} instance.
"""
result = error.getConnectError(socket.gaierror(12, "hello"))
self.assertCorrectException(12, "hello", result, error.UnknownHostError)
def _fast_getaddrinfo(host, *args, **kwargs):
def needs_dns_resolving(host2):
try:
ipaddress.ip_address(host2)
return False # already valid IP
except ValueError:
pass # not an IP
if str(host) in ('localhost', 'localhost.',):
return False
return True
try:
if needs_dns_resolving(host):
answers = dns.resolver.query(host)
addr = str(answers[0])
else:
addr = host
except dns.exception.DNSException as e:
# dns failed for some reason, e.g. dns.resolver.NXDOMAIN
# this is normal. Simply report back failure:
raise socket.gaierror(11001, 'getaddrinfo failed') from e
except BaseException as e:
# Possibly internal error in dnspython :( see #4483
# Fall back to original socket.getaddrinfo to resolve dns.
print_error('dnspython failed to resolve dns with error:', e)
addr = host
return socket._getaddrinfo(addr, *args, **kwargs)
def httpLocThatRequiresAProxy(loc):
import networking
if networking.config._useProxy:
return fauxrootOpen(loc)
sleep()
sockErr = socket.gaierror(110, 'Connection timed out')
raise urllib2.URLError(sockErr)
def test_run_command_exception_gaierror(self):
"""Testing socket.gaierror in run_command."""
self.connection._telnet = mock.Mock()
self.connection._telnet.write = mock.Mock()
self.connection._telnet.write.side_effect = socket.gaierror('except')
self.connection.run_command('test')
self.assertFalse(self.connection._connected)
def connect_to_cli(server=None, as_file=True, socket_timeout=1.0, attempts=5, retry_delay=0.3):
'''Returns connected CLI interface socket (as file object, unless as_file=False),
where one can send same commands (as lines) as to "pacmd" tool
or pulseaudio startup files (e.g. "default.pa").
"server" option can be specified to use non-standard unix socket path
(when passed absolute path string) or remote tcp socket,
when passed remote host address (to use default port) or (host, port) tuple.
Be sure to adjust "socket_timeout" option for tcp sockets over laggy internet.
Returned file object has line-buffered output,
so there should be no need to use flush() after every command.
Be sure to read from the socket line-by-line until
"### EOF" or timeout for commands that have output (e.g. "dump\\n").
If default server socket is used (i.e. not specified),
server pid will be signaled to load module-cli between connection attempts.
Completely separate protocol from the regular API, as wrapped by libpulse.
PulseError is raised on any failure.'''
import socket, errno, signal, time
s, n = None, attempts if attempts > 0 else None
try:
pid_path, sock_af, sock_t = None, socket.AF_UNIX, socket.SOCK_STREAM
if not server: server, pid_path = map(c.pa.runtime_path, ['cli', 'pid'])
else:
if not is_list(server):
server = c.force_str(server)
if not server.startswith('/'): server = server, 4712 # default port
if is_list(server):
try:
addrinfo = socket.getaddrinfo(
server[0], server[1], 0, sock_t, socket.IPPROTO_TCP )
if not addrinfo: raise socket.gaierror('No addrinfo for socket: {}'.format(server))
except (socket.gaierror, socket.error) as err:
raise PulseError( 'Failed to resolve socket parameters'
' (address, family) via getaddrinfo: {!r} - {} {}'.format(server, type(err), err) )
sock_af, sock_t, _, _, server = addrinfo[0]
s = socket.socket(sock_af, sock_t)
s.settimeout(socket_timeout)
while True:
ts = c.mono_time()
try: s.connect(server)
except socket.error as err:
if err.errno not in [errno.ECONNREFUSED, errno.ENOENT, errno.ECONNABORTED]: raise
else: break
if n:
n -= 1
if n <= 0: raise PulseError('Number of connection attempts ({}) exceeded'.format(attempts))
if pid_path:
with open(pid_path) as src: os.kill(int(src.read().strip()), signal.SIGUSR2)
time.sleep(max(0, retry_delay - (c.mono_time() - ts)))
if as_file: res = s.makefile('rw', 1)
else: res, s = s, None # to avoid closing this socket
return res
except Exception as err: # CallError, socket.error, IOError (pidfile), OSError (os.kill)
raise PulseError( 'Failed to connect to pulse'
' cli socket {!r}: {} {}'.format(server, type(err), err) )
finally:
if s: s.close()
def _urlopen(self, req, timeout=None):
url = req.get_full_url()
if url == 'impossible url':
raise ValueError()
if url == 'http://dwqkndwqpihqdw.com':
msg = 'Name or service not known'
raise urllib2.URLError(socket.gaierror(-2, msg))
if url in ('http://google.com', 'http://goodauth'):
return FakeResult()
if url == 'http://badauth':
raise urllib2.HTTPError(url, 401, '', {}, None)
if url == 'http://timeout':
raise urllib2.URLError(socket.timeout())
if url == 'http://error':
raise urllib2.HTTPError(url, 500, 'Error', {}, None)
if url == 'http://newplace':
res = FakeResult()
res.body = url + ' ' + req.headers['Authorization']
return res
if url == 'http://xheaders':
res = FakeResult()
headers = req.headers.items()
headers.sort()
res.body = str(headers)
return res
raise ValueError(url)
def mocked_socket_gethostbyname(domain):
claimed_domains = ["google.com"]
if domain not in claimed_domains:
from socket import gaierror
raise gaierror("[Errno -2] Name or service not known")
else:
return '216.58.221.46'
def test_retry_dns_error(self):
with mock.patch('socket.gethostbyname',
side_effect=socket.gaierror(-5, 'No address associated with hostname')):
crawler = get_crawler(SimpleSpider)
with LogCapture() as l:
yield crawler.crawl("http://example.com/")
self._assert_retried(l)
def test_is_eventlet_bug105(self):
fake_dns = mock.Mock()
fake_dns.getaddrinfo.side_effect = socket.gaierror(errno.EBADF)
with mock.patch.dict('sys.modules', {
'eventlet.support.greendns': fake_dns}):
self.assertTrue(utils.is_eventlet_bug105())
fake_dns.getaddrinfo.assert_called_once()
def testDefaultExceptionHandler(self):
"""Ensures exception handles swallows (retries)"""
mock_http_content = 'content'.encode('utf8')
for exception_arg in (
http_client.BadStatusLine('line'),
http_client.IncompleteRead('partial'),
http_client.ResponseNotReady(),
socket.error(),
socket.gaierror(),
httplib2.ServerNotFoundError(),
ValueError(),
oauth2client.client.HttpAccessTokenRefreshError(status=503),
exceptions.RequestError(),
exceptions.BadStatusCodeError(
{'status': 503}, mock_http_content, 'url'),
exceptions.RetryAfterError(
{'status': 429}, mock_http_content, 'url', 0)):
retry_args = http_wrapper.ExceptionRetryArgs(
http={'connections': {}}, http_request=_MockHttpRequest(),
exc=exception_arg, num_retries=0, max_retry_wait=0,
total_wait_sec=0)
# Disable time.sleep for this handler as it is called with
# a minimum value of 1 second.
with patch('time.sleep', return_value=None):
http_wrapper.HandleExceptionsAndRebuildHttpConnections(
retry_args)
def start(self):
"""This method fires up the daemon server based on initialized parameters of the class"""
# initialize the server instance with given resources
register_socket('trex_daemon_server')
try:
print "Firing up TRex REST daemon @ port {trex_port} ...\n".format( trex_port = self.trex_daemon_port )
logger.info("Firing up TRex REST daemon @ port {trex_port} ...".format( trex_port = self.trex_daemon_port ))
logger.info("current working dir is: {0}".format(self.TREX_PATH) )
logger.info("current files dir is : {0}".format(self.trex_files_path) )
logger.debug("Starting TRex server. Registering methods to process.")
logger.info(self.get_trex_version(base64 = False))
self.server = SimpleJSONRPCServer( (self.trex_host, self.trex_daemon_port) )
except socket.error as e:
if e.errno == errno.EADDRINUSE:
logger.error("TRex server requested address already in use. Aborting server launching.")
print "TRex server requested address already in use. Aborting server launching."
raise socket.error(errno.EADDRINUSE, "TRex daemon requested address already in use. "
"Server launch aborted. Please make sure no other process is "
"using the desired server properties.")
elif isinstance(e, socket.gaierror) and e.errno == -3:
# handling Temporary failure in name resolution exception
raise socket.gaierror(-3, "Temporary failure in name resolution.\n"
"Make sure provided hostname has DNS resolving.")
else:
raise
# set further functionality and peripherals to server instance
self.server.register_function(self.add)
self.server.register_function(self.cancel_reservation)
self.server.register_function(self.connectivity_check)
self.server.register_function(self.connectivity_check, 'check_connectivity') # alias
self.server.register_function(self.force_trex_kill)
self.server.register_function(self.get_file)
self.server.register_function(self.get_files_list)
self.server.register_function(self.get_files_path)
self.server.register_function(self.get_running_info)
self.server.register_function(self.get_running_status)
self.server.register_function(self.get_trex_cmds)
self.server.register_function(self.get_trex_daemon_log)
self.server.register_function(self.get_trex_log)
self.server.register_function(self.get_trex_version)
self.server.register_function(self.is_reserved)
self.server.register_function(self.is_running)
self.server.register_function(self.kill_all_trexes)
self.server.register_function(self.push_file)
self.server.register_function(self.reserve_trex)
self.server.register_function(self.start_trex)
self.server.register_function(self.stop_trex)
self.server.register_function(self.wait_until_kickoff_finish)
signal.signal(signal.SIGTSTP, self.stop_handler)
signal.signal(signal.SIGTERM, self.stop_handler)
try:
self.zmq_monitor.start()
self.server.serve_forever()
except KeyboardInterrupt:
logger.info("Daemon shutdown request detected." )
finally:
self.zmq_monitor.join() # close ZMQ monitor thread resources
self.server.shutdown()
def __init__(self, url, host, trip_queue):
self.url = url
self.host = host
self.trip_queue = trip_queue
try:
self.addr = gethostbyname(host)
except gaierror as err:
raise gaierror(err)
def test_check_hostname_check(self, mc_socket):
mc_socket.gethostbyname.side_effect = socket.gaierror()
builder = self.get_test_builder()
for name in ["*", "256.0.0.1"]:
with pytest.raises(BuilderError):
builder.checked = False
builder.hostname = name
builder.check()
def test_connection_error(self):
reason = socket.gaierror(8, 'nodename nor servname provided')
self.urlopen_mock.side_effect = urllib2.URLError(reason)
tasks.fetch_manifest('url', self.upload.pk)
self.check_validation(
'No manifest was found at that URL. Check the address and make'
' sure the manifest is served with the HTTP header '
'"Content-Type: application/x-web-app-manifest+json".')
def getaddrinfo(host, port, family=0, socktype=0, proto=0, flags=0):
socktype = socktype or socket.SOCK_STREAM
try:
addrs = dns.resolve(host)
except dns.resolver.NXDOMAIN:
raise socket.gaierror(-2, "Name or service not known")
return [(socket.AF_INET, socktype, proto, '', (addr, port))
for addr in addrs]
def dnslib_resolve_over_udp(query, dnsservers, timeout, **kwargs):
"""
http://gfwrev.blogspot.com/2009/11/gfwdns.html
http://zh.wikipedia.org/wiki/%E5%9F%9F%E5%90%8D%E6%9C%8D%E5%8A%A1%E5%99%A8%E7%BC%93%E5%AD%98%E6%B1%A1%E6%9F%93
http://support.microsoft.com/kb/241352
"""
if not isinstance(query, (basestring, dnslib.DNSRecord)):
raise TypeError('query argument requires string/DNSRecord')
blacklist = kwargs.get('blacklist', ())
turstservers = kwargs.get('turstservers', ())
dns_v4_servers = [x for x in dnsservers if ':' not in x]
dns_v6_servers = [x for x in dnsservers if ':' in x]
sock_v4 = sock_v6 = None
socks = []
if dns_v4_servers:
sock_v4 = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
socks.append(sock_v4)
if dns_v6_servers:
sock_v6 = socket.socket(socket.AF_INET6, socket.SOCK_DGRAM)
socks.append(sock_v6)
timeout_at = time.time() + timeout
try:
for _ in xrange(4):
try:
for dnsserver in dns_v4_servers:
if isinstance(query, basestring):
query = dnslib.DNSRecord(q=dnslib.DNSQuestion(query))
query_data = query.pack()
sock_v4.sendto(query_data, parse_hostport(dnsserver, 53))
for dnsserver in dns_v6_servers:
if isinstance(query, basestring):
query = dnslib.DNSRecord(q=dnslib.DNSQuestion(query, qtype=dnslib.QTYPE.AAAA))
query_data = query.pack()
sock_v6.sendto(query_data, parse_hostport(dnsserver, 53))
while time.time() < timeout_at:
ins, _, _ = select.select(socks, [], [], 0.1)
for sock in ins:
reply_data, reply_address = sock.recvfrom(512)
reply_server = reply_address[0]
record = dnslib.DNSRecord.parse(reply_data)
iplist = [str(x.rdata) for x in record.rr if x.rtype in (1, 28, 255)]
if any(x in blacklist for x in iplist):
logging.warning('query=%r dnsservers=%r record bad iplist=%r', query, dnsservers, iplist)
elif record.header.rcode and not iplist and reply_server in turstservers:
logging.info('query=%r trust reply_server=%r record rcode=%s', query, reply_server, record.header.rcode)
return record
elif iplist:
logging.debug('query=%r reply_server=%r record iplist=%s', query, reply_server, iplist)
return record
else:
logging.debug('query=%r reply_server=%r record null iplist=%s', query, reply_server, iplist)
continue
except socket.error as e:
logging.warning('handle dns query=%s socket: %r', query, e)
raise socket.gaierror(11004, 'getaddrinfo %r from %r failed' % (query, dnsservers))
finally:
for sock in socks:
sock.close()
def _family_to_rdtype(family):
if family == socket.AF_INET:
rdtype = dns.rdatatype.A
elif family == socket.AF_INET6:
rdtype = dns.rdatatype.AAAA
else:
raise socket.gaierror(socket.EAI_FAMILY,
'Address family not supported')
return rdtype
def _family_to_rdtype(family):
if family == socket.AF_INET:
rdtype = dns.rdatatype.A
elif family == socket.AF_INET6:
rdtype = dns.rdatatype.AAAA
else:
raise socket.gaierror(socket.EAI_FAMILY,
'Address family not supported')
return rdtype
def test_retry_with_timeout(self, mock_connect):
con = Connection()
con.connection = Mock()
mock_connect.side_effect = socket.gaierror("")
retry_request = Retry(timeout=1, retry_delay=0.1, backoff=1)
self.assertRaises(socket.gaierror, retry_request(con.request), action="/")
self.assertGreater(mock_connect.call_count, 1, "Retry logic failed")
def mock_gethostbyaddr(addr):
if addr == resolvable_ip:
return ("unittestServer", None, None)
elif addr == unresolvable_ip1:
raise socket.gaierror()
elif addr == unresolvable_ip2:
raise socket.herror()
else:
raise socket.timeout()
def test_wait_for_port_no_address_closed(self):
error = socket.gaierror(socket.EAI_NODATA, 'What address?')
with patch('socket.getaddrinfo', autospec=True,
side_effect=error) as gai_mock:
with patch('socket.socket') as socket_mock:
wait_for_port('asdf', 26, closed=True)
gai_mock.assert_called_once_with('asdf', 26, socket.AF_INET,
socket.SOCK_STREAM)
self.assertEqual(socket_mock.call_count, 0)
async def ping(dest_addr, timeout=10, family=None):
"""
Returns either the delay (in seconds) or raises an exception.
:param dest_addr:
:param timeout:
:param family:
"""
loop = asyncio.get_event_loop()
info = await loop.getaddrinfo(dest_addr, 0)
logger.debug("%s getaddrinfo result=%s", dest_addr, info)
if family is not None:
info = list(filter(lambda i: i[0] == family, info))
if len(info) == 0:
raise socket.gaierror("%s hostname not found for address family %s" % (dest_addr, family))
resolved = random.choice(info)
family = resolved[0]
addr = resolved[4]
logger.debug("%s resolved addr=%s", dest_addr, addr)
if family == socket.AddressFamily.AF_INET:
icmp = proto_icmp
else:
icmp = proto_icmp6
try:
my_socket = socket.socket(family, socket.SOCK_RAW, icmp)
my_socket.setblocking(False)
except OSError as e:
msg = e.strerror
if e.errno == 1:
# Operation not permitted
msg += (
" - Note that ICMP messages can only be sent from processes"
" running as root."
)
raise OSError(msg)
raise
my_id = uuid.uuid4().int & 0xFFFF
await _send_one_ping(my_socket, addr, my_id, timeout, family)
delay = await _receive_one_ping(my_socket, my_id, timeout)
my_socket.close()
return delay
def get_socket_info(host,
port=0,
family=0,
socktype=0,
protocol=0,
force_unique_address=None,
pick_random=False):
log_params = [port, family, socktype, protocol]
log.debug('Resolving addr: %r (params: %s)', host, log_params)
host = re.sub(r'^\[|\]$', '', host)
try:
addrinfo = socket.getaddrinfo(host, port, family, socktype, protocol)
if not addrinfo:
raise socket.gaierror('No addrinfo for host: {}'.format(host))
except (socket.gaierror, socket.error) as err:
raise AddressError('Failed to resolve host:'
' {!r} (params: {}) - {} {}'.format(
host, log_params, type(err), err))
ai_af, ai_addr = set(), list()
for family, _, _, hostname, addr in addrinfo:
ai_af.add(family)
ai_addr.append((addr[0], family))
if pick_random: return random.choice(ai_addr)
if len(ai_af) > 1:
af_names = dict(
(v, k) for k, v in vars(socket).viewitems() if k.startswith('AF_'))
ai_af_names = list(af_names.get(af, str(af)) for af in ai_af)
if socket.AF_INET not in ai_af:
log.fatal(
'Ambiguous socket host specification (matches address famlies: %s),'
' refusing to pick one at random - specify socket family instead. Addresses: %s',
', '.join(ai_af_names), ', '.join(ai_addr))
raise AddressError
(log.warn if force_unique_address is None else log.info)\
( 'Specified host matches more than one address'
' family (%s), using it as IPv4 (AF_INET)', ai_af_names )
af = socket.AF_INET
else:
af = list(ai_af)[0]
for addr, family in ai_addr:
if family == af: break
else: raise AddressError
ai_addr_unique = set(ai_addr)
if len(ai_addr_unique) > 1:
if force_unique_address:
raise AddressError('Address matches more than one host: {}'.format(
ai_addr_unique))
log.warn(
'Specified host matches more than'
' one address (%s), using first one: %s', ai_addr_unique, addr)
return af, addr
def test_is_dns_resolvable(self, mocked_gethostbyname):
"""is_dns_resolvable() should return True if a FQDN is resolvable, False otherwise."""
import socket
fqdn = 'foo.bar.suse.de'
mocked_gethostbyname.return_value = '192.168.0.1'
assert is_dns_resolvable(fqdn) is True
mocked_gethostbyname.side_effect = socket.gaierror()
assert is_dns_resolvable(fqdn) is False
def test_open_resolve_failure():
m = mox.Mox()
m.StubOutWithMock(socket, 'gethostbyname')
socket.gethostbyname('www.google.com').AndRaise(
socket.gaierror(errno.EADDRNOTAVAIL, 'Could not resolve host.'))
m.ReplayAll()
with pytest.raises(urllib_error.URLError):
Web().open('http://www.google.com')
m.UnsetStubs()
m.VerifyAll()
def test_error_on_connectivity_errors(self, m_getuid,
m_get_avail_resources, capsys):
"""Raise UrlError on connectivity issues"""
m_get_avail_resources.side_effect = util.UrlError(
socket.gaierror(-2, "Name or service not known"))
cfg = FakeConfig()
with pytest.raises(util.UrlError):
action_status(mock.MagicMock(), cfg)
def mapIPtoNode(ip):
""" Attempts to get the hostname of the machine with ip address ip."""
try:
(hostname, aliaslist, ipaddrlist) = socket.gethostbyaddr(ip)
except socket.gaierror(error, string):
raise PTexception("toolParser.paradynParse: could not get node name"\
" for IP address %d. System error msg: %s" % \
(ip, string))
else:
return hostname
def test_exception_HTTPBadGateway(self):
req = Request.blank('http://example.com/testform')
# -2 socket error should trigger HTTPBadGateway
self.set_exception(socket.gaierror(-2))
res = req.get_response(proxy_exact_request)
self.assertEqual(res.status_code, 502)
self.assertTrue('502 Bad Gateway' in res.body)
def _getaddrinfo(host=None, service=None, family=AF_UNSPEC, socktype=0,
proto=0, flags=0, _orig_gai=resolver._getaddrinfo):
if flags & (socket.AI_ADDRCONFIG | socket.AI_V4MAPPED) != 0:
# Not implemented. We raise a gaierror as opposed to a
# NotImplementedError as it helps callers handle errors more
# appropriately. [Issue #316]
raise socket.gaierror(socket.EAI_SYSTEM)
res = _orig_gai(host, service, family, socktype, proto, flags)
_exc_clear()
return res
def fast_getaddrinfo(host, *args, **kwargs):
try:
if str(host) not in ('localhost', 'localhost.',):
answers = dns.resolver.query(host)
addr = str(answers[0])
else:
addr = host
except:
raise socket.gaierror(11001, 'getaddrinfo failed')
else:
return socket._getaddrinfo(addr, *args, **kwargs)
def testAcquireError(self):
""" Tests error handling when acquiring a TSM connection. """
_TransportMock.error = SSHException("")
self.assertRaises(PersistenceError, self._connectionPool.acquire)
_TransportMock.error = socket.error("")
self.assertRaises(PersistenceError, self._connectionPool.acquire)
_TransportMock.error = socket.gaierror("")
self.assertRaises(PersistenceError, self._connectionPool.acquire)
def check_destpair(self, destpair):
if isinstance(destpair[0], basestring):
try:
destpair = str(destpair[0]), destpair[1]
except ValueError:
raise _socket.gaierror("Couldn't coerce %r to str. Invalid hostname." % destpair[0])
if (type(destpair) in (list, tuple) == False) or (len(destpair) < 2) or (type(destpair[0]) != str) or (type(destpair[1]) != int):
raise GeneralProxyError((5, _generalerrors[5]))
return destpair
def test_retry_connection(self):
con = Connection(timeout=0.2, retry_delay=0.1)
con.connection = Mock()
connect_method = 'libcloud.common.base.Connection.request'
with patch(connect_method) as mock_connect:
try:
mock_connect.side_effect = socket.gaierror('')
con.request('/')
except socket.gaierror:
pass
def do_resolve(query, dnsserver, timeout, queobj):
if isinstance(query, basestring):
qtype = dnslib.QTYPE.AAAA if ':' in dnsserver else dnslib.QTYPE.A
query = dnslib.DNSRecord(q=dnslib.DNSQuestion(query, qtype=qtype))
query_data = query.pack()
sock_family = socket.AF_INET6 if ':' in dnsserver else socket.AF_INET
sock = socket.socket(sock_family)
rfile = None
try:
sock.settimeout(timeout or None)
sock.connect(parse_hostport(dnsserver, 53))
sock.send(struct.pack('>h', len(query_data)) + query_data)
rfile = sock.makefile('r', 1024)
reply_data_length = rfile.read(2)
if len(reply_data_length) < 2:
raise socket.gaierror(
11004,
'getaddrinfo %r from %r failed' % (query, dnsserver))
reply_data = rfile.read(struct.unpack('>h', reply_data_length)[0])
record = dnslib.DNSRecord.parse(reply_data)
iplist = [
str(x.rdata) for x in record.rr if x.rtype in (1, 28, 255)
]
if any(x in blacklist for x in iplist):
logging.debug('query=%r dnsserver=%r record bad iplist=%r',
query, dnsserver, iplist)
raise socket.gaierror(
11004,
'getaddrinfo %r from %r failed' % (query, dnsserver))
else:
logging.debug('query=%r dnsserver=%r record iplist=%s', query,
dnsserver, iplist)
queobj.put(record)
except socket.error as e:
logging.debug('query=%r dnsserver=%r failed %r', query, dnsserver,
e)
queobj.put(e)
finally:
if rfile:
rfile.close()
sock.close()
def test_resolve_error(self, output_spy, virtual_socket):
vsocket = virtual_socket
vsocket.gsock.addrinfodata['localhost#22'] = socket.gaierror(
8, 'hostname nor servname provided, or not known')
s = self.ssh.Socket('localhost', 22)
conf = self._conf()
output_spy.begin()
with pytest.raises(SystemExit):
list(s._resolve(conf.ipvo))
lines = output_spy.flush()
assert len(lines) == 1
assert 'hostname nor servname provided' in lines[-1]
def test__logs_resolution_failures(self):
# Some ISPs configure their DNS to resolve to an ads page when a domain
# doesn't exist. This ensures resolving fails so the test passes.
exception = socket.gaierror()
exception.errno = random.choice(
list(config._gen_addresses_where_possible_suppress))
exception.strerror = '[Errno ...] ...'
self.patch(config, '_gen_addresses').side_effect = exception
with FakeLogger(config.__name__) as logger:
config._get_addresses("no-way-this-exists.maas.io")
self.assertThat(logger.output.strip(), DocTestMatches(
"Could not resolve no-way-this-exists.maas.io: [Errno ...] ..."))
def test_connection_socket_connect_error(self):
get_response = Object()
get_response.hostname = self._filer.host()
self._init_filer(get_response=get_response)
self._socket_connect_mock.side_effect = socket.gaierror()
with self.assertRaises(exception.HostUnreachable) as error:
self._filer.test()
self._socket_connect_mock.assert_called_once_with(
(self._host, self._port))
self.assertEqual('Unable to reach host', error.exception.message)
def setUp(self):
super(TC, self).setUp()
self.fixture.add_response('get', 'http://localhost:8000/foo')
self.fixture.add_error('get', 'http://localhost:8000/foo',
socket.gaierror('unknown name'))
self.fixture.add_connect_timeout('get',
'http://localhost:8000/foo')
self.fixture.add_read_timeout('get',
'http://localhost:8000/foo',
filter=lambda *a, **kw: True)
self.fixture.add_unreachable_host('get',
'http://localhost:8000/foo')
def test_is_ignored(exception_handler):
# test that CoreExceptionHandler ignores specific exceptions
# by type
assert exception_handler._is_ignored(OSError(113, 'Any'))
assert exception_handler._is_ignored(ConnectionResetError(10054, 'Any'))
# by class
assert exception_handler._is_ignored(gaierror('Any'))
# by class and substring
assert exception_handler._is_ignored(RuntimeError('Message that contains invalid info-hash'))
def test_request_resources_error_on_network_disconnected(
self, m_request_resources, FakeConfig):
"""Raise error get_available_resources can't contact backend"""
cfg = FakeConfig()
urlerror = exceptions.UrlError(
socket.gaierror(-2, "Name or service not known"))
m_request_resources.side_effect = urlerror
with pytest.raises(exceptions.UrlError) as exc:
get_available_resources(cfg)
assert urlerror == exc.value
def test_route_with_ipv6(self, mock_exec, mock_gethostbyname):
self.agent.api_url = 'http://[fc00:1111::1]:8081/v1'
mock_gethostbyname.side_effect = socket.gaierror()
mock_exec.return_value = (
"""fc00:101::1 dev br-ctlplane src fc00:101::4 metric 0
cache """, "")
self.agent.set_agent_advertise_addr()
self.assertEqual(('fc00:101::4', 9990), self.agent.advertise_address)
mock_exec.assert_called_once_with('ip', 'route', 'get', 'fc00:1111::1')
mock_gethostbyname.assert_called_once_with('fc00:1111::1')
def _side_effect(host, *args):
try:
return {
'github.com': [
(2, 1, 6, '', ('192.30.255.112', 0)),
(2, 1, 6, '', ('192.30.255.113', 0)),
],
'ipv6host.foo': [
(socket.AF_INET6, 1, 6, '', ('2001:a71::1', 0, 0, 0)),
],
}[host]
except KeyError:
raise socket.gaierror(-2, 'Name or service not known')
def lookup_fn(self, host, port, family=None, socktype=None, proto=None, flags=None):
"""
Mocking real resolver for unit testing purpose
"""
if host not in self.results:
raise socket.gaierror("Host not found: %s" % host)
logging.debug("Mocking resolve %s=>%s", host, self.results[host])
if isinstance(self.results[host], IOError):
raise self.results[host]
return [(self.results[host][1], None, None, None, (self.results[host][0], port))]
def __init__(self, address, base_port):
if address == '*':
self.ip_addr = '*'
self.base_port = base_port
self.is_ipv6 = False
else:
try:
addr_tuple = getaddrinfo(address, base_port)[0][4]
except gaierror:
raise gaierror("Hostname '%s' could not be resolved" % address)
self.ip_addr = addr_tuple[0]
self.base_port = addr_tuple[1]
self.is_ipv6 = True if len(addr_tuple) == 4 else False
def testGetOnGce_NotInMemory_NotOnDisk_CheckServerErrors(self):
errors = (six.moves.urllib.error.URLError(''),
six.moves.urllib.error.HTTPError(None, None, None, None,
None), socket.timeout(''),
socket.error(''), socket.herror(''), socket.gaierror(''),
six.moves.http_client.BadStatusLine(''))
for error in errors:
self._SetUpServerResponse(errors=error)
on_gce_cache = gce_cache._OnGCECache()
self.assertIs(on_gce_cache.GetOnGCE(), False)
self.assertIs(on_gce_cache.connected, False)
self.AssertFileExistsWithContents('False', self.tempfilepath)
def get_host_ip():
try:
ip = socket.gethostbyname(socket.gethostname())
except Exception:
try:
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.connect(('8.8.8.8', 80))
ip = s.getsockname()[0]
finally:
s.close()
if not ip:
raise socket.gaierror(-2, 'Name or service not known')
return ip
def _side_effect(host, *args):
try:
return {
"github.com": [
(2, 1, 6, "", ("192.30.255.112", 0)),
(2, 1, 6, "", ("192.30.255.113", 0)),
],
"ipv6host.foo": [
(socket.AF_INET6, 1, 6, "", ("2001:a71::1", 0, 0, 0)),
],
}[host]
except KeyError:
raise socket.gaierror(-2, "Name or service not known")
def test_route_with_ip(self, mock_exec, mock_gethostbyname):
self.agent.api_url = 'http://1.2.1.2:8081/v1'
mock_gethostbyname.side_effect = socket.gaierror()
mock_exec.return_value = (
"""1.2.1.2 via 192.168.122.1 dev eth0 src 192.168.122.56
cache """, "")
self.agent.set_agent_advertise_addr()
self.assertEqual(('192.168.122.56', 9990),
self.agent.advertise_address)
mock_exec.assert_called_once_with('ip', 'route', 'get', '1.2.1.2')
mock_gethostbyname.assert_called_once_with('1.2.1.2')
