def wait(self, timeout):
with gevent.Timeout(timeout, False):
for index in range(1000):
try:
gevent_socket.gethostbyname('www.x%s.com' % index)
except socket.error:
pass
def wait(self, timeout):
with gevent.Timeout(timeout, False):
for index in range(1000):
try:
gevent_socket.gethostbyname('www.x%s.com' % index)
except socket.error:
pass
def wait(self, timeout):
with gevent.Timeout(timeout, False):
for index in xrange(1000000):
try:
gevent_socket.gethostbyname('www.x%s.com' % index)
except socket.error:
pass
raise AssertionError('Timeout was not raised')
def send(self, dest_addr, callback, psize=64):
"""
Send a ICMP echo request.
:dest_addr - where to send it
:callback - what to call when we get a response
:psize - how much data to send with it
"""
# make sure we dont have too many outstanding requests
while len(self.pings) >= self.max_outstanding:
gevent.sleep()
# figure out our id
packet_id = self.id
# increment our id, but wrap if we go over the max size for USHORT
self.id = (self.id + 1) % 2 ** 16
# make a spot for this ping in self.pings
self.pings[packet_id] = {'sent':False,'success':False,'error':False,'dest_addr':dest_addr,'dest_ip':None,'callback':callback}
# Resolve hostname
try:
dest_ip = socket.gethostbyname(dest_addr)
self.pings[packet_id]['dest_ip'] = dest_ip
except socket.gaierror as ex:
self.pings[packet_id]['error'] = True
self.pings[packet_id]['message'] = str(ex)
return
# Remove header size from packet size
psize = psize - 8
# Header is type (8), code (8), checksum (16), id (16), sequence (16)
my_checksum = 0
# Make a dummy heder with a 0 checksum.
header = struct.pack("bbHHh", ICMP_ECHO_REQUEST, 0, my_checksum, packet_id, 1)
bytes = struct.calcsize("d")
data = (psize - bytes) * "Q"
data = struct.pack("d", time.time()) + data
# Calculate the checksum on the data and the dummy header.
my_checksum = checksum(header + data)
# Now that we have the right checksum, we put that in. It's just easier
# to make up a new header than to stuff it into the dummy.
header = struct.pack(
"bbHHh", ICMP_ECHO_REQUEST, 0, socket.htons(my_checksum), packet_id, 1
)
packet = header + data
# note the send_time for checking for timeouts
self.pings[packet_id]['send_time'] = time.time()
# send the packet
self.socket.sendto(packet, (dest_ip, 1)) # Don't know about the 1
#mark the packet as sent
self.pings[packet_id]['sent'] = True
def _populate_resolved(self):
for dest in self._destination_hosts:
try:
self._resolved[dest[0]] = \
'::ffff:' + socket.gethostbyname(dest[0])
except socket.gaierror:
pass
def server(self):
print("Server spawned")
# setup socket
udps = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
udps.bind((self.listen_addr, self.listen_port))
# keep going till we are shuttin down
while not self.shutting_down.is_set():
data, addr = udps.recvfrom(1024)
p = DNSQuery(data)
domain = p.dominio
ip = '127.0.0.1'
if domain in self.resolutions:
ip = self.resolutions[domain]['ip']
self.resolutions[domain]['hits'] += 1
else:
try:
ip = socket.gethostbyname(domain)
self.resolutions[domain] = {}
self.resolutions[domain]['ip'] = ip
self.resolutions[domain]['hits'] = 1
except gevent.dns.DNSError:
pass
udps.sendto(p.respuesta(ip), addr)
gevent.sleep(0)
udps.close()
def send(self, dest_addr, callback, psize=64):
"""
Send a ICMP echo request.
:dest_addr - where to send it
:callback - what to call when we get a response
:psize - how much data to send with it
"""
# make sure we dont have too many outstanding requests
while len(self.pings) >= self.max_outstanding:
print 'Waiting'
gevent.sleep(self.timeout / 2)
#resolve hostnames
dest_addr = socket.gethostbyname(dest_addr)
# figure out our id
packet_id = self.id
# increment our id, but wrap if we go over the max size for USHORT
self.id = (self.id + 1) % 2**16
# make a spot for this ping in self.pings
self.pings[packet_id] = {
'sent': False,
'success': False,
'error': False,
'dest_addr': dest_addr,
'callback': callback
}
# Remove header size from packet size
psize = psize - 8
# Header is type (8), code (8), checksum (16), id (16), sequence (16)
my_checksum = 0
# Make a dummy heder with a 0 checksum.
header = struct.pack("bbHHh", ICMP_ECHO_REQUEST, 0, my_checksum,
packet_id, 1)
bytes = struct.calcsize("d")
data = (psize - bytes) * "Q"
data = struct.pack("d", time.time()) + data
# Calculate the checksum on the data and the dummy header.
my_checksum = checksum(header + data)
# Now that we have the right checksum, we put that in. It's just easier
# to make up a new header than to stuff it into the dummy.
header = struct.pack("bbHHh", ICMP_ECHO_REQUEST, 0,
socket.htons(my_checksum), packet_id, 1)
packet = header + data
# note the send_time for checking for timeouts
self.pings[packet_id]['send_time'] = time.time()
# send the packet
self.socket.sendto(packet, (dest_addr, 1)) # Don't know about the 1
#mark the packet as sent
self.pings[packet_id]['sent'] = True
print "Sent %s" % dest_addr
def start(self):
addr = None
try:
addr = (socket.gethostbyname(self.host), self.port)
except socket.gaierror:
logging.error('hostname not found')
return
logging.info(u'try to connect ... %r' % (addr, ))
self._socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
self._socket.connect(addr)
except socket.error:
logging.error('failed to connect ... %r' % (addr, ))
return
self._recv_queue = queue.Queue()
self._send_queue = queue.Queue()
self.login = False
self.shutdown = False
self._group.spawn(self._send_loop)
self._group.spawn(self._process_loop)
self._group.spawn(self._recv_loop)
self._group.spawn(self._ping_loop)
gevent.sleep(0)
self._send({
u'type': u'login',
u'id': unicode(self.login_id),
u'pass': unicode(self.auth_key)
})
def _populate_resolved(self):
for dest in self._destination_hosts:
try:
self._resolved[dest[0]] = \
'::ffff:' + socket.gethostbyname(dest[0])
except socket.gaierror:
pass
def __init__(self, **kwargs):
Greenlet.__init__(self)
self.address = kwargs.setdefault('address', self.ADDRESS)
self.ports = kwargs.setdefault('ports', self.PORTS)
self.concurrence = kwargs.setdefault('concurrence', self.CONCURRENCE)
self.timeout = kwargs.setdefault('timeout', self.TIMEOUT)
self.randomize = kwargs.setdefault('randomize', self.RANDOMIZE)
if isinstance(self.address, str):
try:
self.address = Address.blind_assertion(self.address)
except:
self.address = Address.blind_assertion(socket.gethostbyname(self.address))
if not isinstance(self.address, Address):
raise ValueError('address must be an IP address')
if not isinstance(self.ports, (list, tuple)):
raise ValueError('ports must be a list of ports')
if isinstance(self.timeout, int):
self.timeout = float(self.timeout)
if not isinstance(self.timeout, float):
raise ValueError('timeout must be a float value')
if not isinstance(self.concurrence, int):
raise ValueError('concurrence must be an integer')
if not isinstance(self.randomize, bool):
raise ValueError('randomize must be a boolean value')
self.results = None
def dns_resolve(url):
"""Resolve hostname in the given url, using cached results where possible.
Given a url, this function does DNS resolution on the contained hostname
and returns a 3-tuple giving: the URL with hostname replace by IP addr,
the original hostname string, and the resolved IP addr string.
The results of DNS resolution are cached to make sure this doesn't become
a bottleneck for the loadtest. If the hostname resolves to multiple
addresses then a random address is chosen.
"""
parts = urlparse.urlparse(url)
netloc = parts.netloc.rsplit(':')
if len(netloc) == 1:
netloc.append('80')
original = netloc[0]
addrs = _DNS_CACHE.get(original)
if addrs is None:
try:
addrs = gevent_socket.gethostbyname_ex(original)[2]
except AttributeError:
# gethostbyname_ex was introduced by gevent 1.0,
# fallback on gethostbyname instead.
logger.info('gevent.socket.gethostbyname_ex is not present, '
'Falling-back on gevent.socket.gethostbyname')
addrs = [gevent_socket.gethostbyname(original)]
_DNS_CACHE[original] = addrs
resolved = random.choice(addrs)
netloc = resolved + ':' + netloc[1]
parts = (parts.scheme, netloc) + parts[2:]
return urlparse.urlunparse(parts), original, resolved
def __init__(self, host, port):
self.behavior = Dummy()
self.behavior_name = 'dummy'
self.host = gethostbyname(host)
self.port = port
location = self.host, self.port
StreamServer.__init__(self, location)
def domain_lookup_check(queue_targets_origin, processed_targets, queue_targets, q_results):
"""
解析域名，检查域名有效性
"""
while True:
try:
url = queue_targets_origin.get_nowait()
except Queue.Empty as e:
break
# scheme netloc path
if url.find('://') < 0:
netloc = url[:url.find('/')] if url.find('/') > 0 else url
else:
scheme, netloc, path, params, query, fragment = urlparse.urlparse(url, 'http')
# host port
if netloc.find(':') >= 0:
_ = netloc.split(':')
host = _[0]
else:
host = netloc
try:
ip = g_socket.gethostbyname(host)
processed_targets.append(ip)
queue_targets.put((url, 0))
except Exception as e:
q_results.put('Invalid domain: %s' % host)
def _write_SOCKS5_address(self, addr, file):
"""
Return the host and port packed for the SOCKS5 protocol,
and the resolved address as a tuple object.
"""
host, port = addr
proxy_type, _, _, rdns, username, password = self.proxy
# If the given destination address is an IP address, we'll
# use the IPv4 address request even if remote resolving was specified.
try:
addr_bytes = socket.inet_aton(host)
file.write(b"\x01" + addr_bytes)
host = socket.inet_ntoa(addr_bytes)
except socket.error:
# Well it's not an IP number, so it's probably a DNS name.
if rdns:
# Resolve remotely
host_bytes = host.encode('idna')
file.write(b"\x03" + chr(len(host_bytes)).encode() +
host_bytes)
else:
# Resolve locally
addr_bytes = socket.inet_aton(socket.gethostbyname(host))
file.write(b"\x01" + addr_bytes)
host = socket.inet_ntoa(addr_bytes)
file.write(struct.pack(">H", port))
return host, port
def dns_resolve(url):
"""Resolve hostname in the given url, using cached results where possible.
Given a url, this function does DNS resolution on the contained hostname
and returns a 3-tuple giving: the URL with hostname replace by IP addr,
the original hostname string, and the resolved IP addr string.
The results of DNS resolution are cached to make sure this doesn't become
a bottleneck for the loadtest. If the hostname resolves to multiple
addresses then a random address is chosen.
"""
parts = urlparse.urlparse(url)
netloc = parts.netloc.rsplit(':')
if len(netloc) == 1:
netloc.append('80')
original = netloc[0]
addrs = _DNS_CACHE.get(original)
if addrs is None:
try:
addrs = gevent_socket.gethostbyname_ex(original)[2]
except AttributeError:
# gethostbyname_ex was introduced by gevent 1.0,
# fallback on gethostbyname instead.
logger.info('gevent.socket.gethostbyname_ex is not present, '
'Falling-back on gevent.socket.gethostbyname')
addrs = [gevent_socket.gethostbyname(original)]
_DNS_CACHE[original] = addrs
resolved = random.choice(addrs)
netloc = resolved + ':' + netloc[1]
parts = (parts.scheme, netloc) + parts[2:]
return urlparse.urlunparse(parts), original, resolved
def job(self, h, h_ip, addr):
# Ok, try again with name resolution
if not h_ip:
try:
h_ip = socket.gethostbyname(addr)
except Exception, exp:
pass
def start(self):
addr = None
try:
addr = (socket.gethostbyname(self.host), self.port)
except socket.gaierror:
logging.error('hostname not found')
return
logging.info(u'try to connect ... %r'%(addr,))
self._socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
self._socket.connect(addr)
except socket.error:
logging.error('failed to connect ... %r'%(addr,))
return
self._recv_queue = queue.Queue()
self._send_queue = queue.Queue()
self.login = False
self.shutdown = False
self._group.spawn(self._send_loop)
self._group.spawn(self._process_loop)
self._group.spawn(self._recv_loop)
self._group.spawn(self._ping_loop)
gevent.sleep(0)
self._send({ u'type' : u'login', u'id' : unicode(self.login_id), u'pass' : unicode(self.auth_key) })
def job(self, h, h_ip, addr):
# Ok, try again with name resolution
if not h_ip:
try:
h_ip = socket.gethostbyname(addr)
except Exception, exp:
pass
def socks5_connect(sock, target, rdns=True):
stream = sock.makefile()
# connect request
try:
reqaddr = "\x01" + socket.inet_aton(target[0])
except socket.error:
if rdns: reqaddr = '\x03' + fmt_string(target[0])
else:
reqaddr = "\x01" + socket.inet_aton(socket.gethostbyname(
target[0]))
s = "\x05\x01\x00" + reqaddr + struct.pack(">H", target[1])
stream.write(s)
stream.flush()
# connect response
resp = stream.read(4)
if not resp: raise EOFError()
if resp[0] != "\x05": raise GeneralProxyError(1)
if resp[1] != "\x00":
if ord(resp[1]) <= 8: raise Socks5Error(ord(resp[1]))
else: raise Socks5Error(9)
if resp[3] == "\x03": boundaddr = stream.read(stream.read(1))
elif resp[3] == "\x01": boundaddr = socket.inet_ntoa(stream.read(4))
else: raise GeneralProxyError(1)
boundport = struct.unpack(">H", stream.read(2))[0]
logger.debug('socks connected with %s:%s' % target)
return boundaddr, boundport
def check_domain(self, domain, timeout):
"""Check specified domain."""
resolver = dns.resolver.Resolver()
try:
answers = resolver.query(domain.name, "MX")
except dns.resolver.NoAnswer:
return
ip_list = []
for answer in answers:
address = None
try:
ipaddress.ip_address(str(answer.exchange))
except ValueError:
try:
address = socket.gethostbyname(str(answer.exchange))
except socket.gaierror:
pass
else:
address = str(answer.exchange)
finally:
if address is not None:
ip_list.append(address)
if len(ip_list) == 0:
return
jobs = [
gevent.spawn(self.query, ip_list, provider)
for provider in self.providers]
gevent.joinall(jobs, timeout)
for job in jobs:
if not job.successful():
continue
provider, results = job.value
self.store_domain_result(domain, provider, results)
def __init__(self): #get server ip (current machine) self.ip = self.ip = socket.gethostbyname(socket.gethostname()) print "Starting server: %s:1337" % self.ip self.chs = Characters.Characters()
def parse_address(address):
try:
hostname, port = address.rsplit(':', 1)
port = int(port)
except ValueError:
sys.exit('Expected HOST:PORT: %r' % address)
return gethostbyname(hostname), port
def __init__(self, args, db, host):
self.args = args
self.db = db
self.hostname = host
self.conn = None
self.admin_privs = False
self.logger = None
self.password = ''
self.username = ''
self.kerberos = True if self.args.kerberos else False
self.aesKey = None if not self.args.aesKey else self.args.aesKey
self.kdcHost = None if not self.args.kdcHost else self.args.kdcHost
self.failed_logins = 0
self.local_ip = None
try:
self.host = gethostbyname(self.hostname)
if self.args.kerberos:
self.host = self.hostname
except Exception as e:
logging.debug('Error resolving hostname {}: {}'.format(
self.hostname, e))
return
self.proto_flow()
def _resubscribe(self, url, sid=None):
headers = {'TIMEOUT': 'infinite'}
if sid is not None:
headers['SID'] = sid
else:
host = socket.gethostbyname(socket.gethostname())
headers.update({
"CALLBACK": '<http://%s:8989>' % host,
"NT": "upnp:event"
})
try:
response = requests.request(method="SUBSCRIBE", url=url,
headers=headers)
timeout = 50
try:
timeout = int(response.headers['timeout'].replace('Second-', ''))
except:
log.info("Error parse timeout")
print "Error parse timeout"
timeout = 50
try:
sid = response.headers['sid']
except:
log.info("Error parse sid")
print "Error parse sid"
gevent.spawn_later(timeout, self._resubscribe, url, sid)
except:
log.info("Error parse timeout")
gevent.spawn_later(10, self._resubscribe, url, sid)
def handle(self, sock, addr):
print 'connection from %s:%s' % addr
src = XSocket(socket = sock, secure = True)
#socks5 negotiation step2: specify command and destination
ver, cmd, rsv, atype = src.unpack('BBBB', 4)
if cmd != 0x01:
src.pack('BBBBIH', 0x05, 0x07, 0x00, 0x01, 0, 0)
return
if atype == 0x01: #ipv4
host, port = src.unpack('!IH', 6)
hostip = socket.inet_ntoa(struct.pack('!I', host))
elif atype == 0x03: #domain name
length = src.unpack('B', 1)[0]
hostname, port = src.unpack("!%dsH" % length, length + 2)
hostip = gethostbyname(hostname)
host = struct.unpack("!I", socket.inet_aton(hostip))[0]
elif atype == 0x04: #ipv6: TODO
src.pack('!BBBBIH', 0x05, 0x07, 0x00, 0x01, 0, 0)
return
else:
src.pack('!BBBBIH', 0x05, 0x07, 0x00, 0x01, 0, 0)
return
try:
dest = XSocket(addr = (hostip, port))
except IOError, ex:
print "%s:%d" % addr, "failed to connect to %s:%d" % (hostip, port)
src.pack('!BBBBIH', 0x05, 0x03, 0x00, 0x01, host, port)
return
def __init__(self, **kwargs):
Greenlet.__init__(self)
self.port = kwargs.setdefault('port', self.PORT)
self.address = kwargs.setdefault('address', self.ADDRESS)
self.timeout = kwargs.setdefault('timeout', self.TIMEOUT)
if self.port is None:
raise ValueError('no port given')
if not isinstance(self.port, int):
raise TypeError('port is not an int')
if isinstance(self.address, str):
try:
self.address = Address.blind_assertion(self.address)
except:
self.address = Address.blind_assertion(
socket.gethostbyname(self.address))
if not isinstance(self.address, Address):
raise ValueError('address must be an IP address or domain')
if isinstance(self.timeout, int):
self.timeout = float(self.timeout)
if not isinstance(self.timeout, float):
raise ValueError('timeout must be a float value')
self.state = None
def process_sock_request(self, client_sock):
recv = client_sock.recv(BUFFER)
if ord(recv[0]) != SOCK_V5 or ord(recv[2]) != RSV:
self.close_sock_and_exit(client_sock)
print 'sock request %s'%recv
addr_type = ord(recv[3])
if addr_type == ATYP_IP_V4:
addr = socket.inet_ntoa(recv[4:8])
elif addr_type == ATYP_DOMAINNAME:
addr_len = ord(recv[4])
addr = socket.gethostbyname(recv[5:5 + addr_len])
else:
# only ipv4 addr or domain name is supported.
self.close_sock_and_exit(client_sock)
port = ord(recv[-2]) * 256 + ord(recv[-1])
cmd = ord(recv[1])
if cmd == CMD_CONNECT:
# Only connect cmd is supported.
server_sock = self.connect_target_server_and_reply(client_sock,
addr, port, cmd)
else:
self.close_sock_and_exit(client_sock)
return server_sock
def __init__(self, host, port):
self.behavior = Dummy()
self.behavior_name = 'dummy'
self.host = gethostbyname(host)
self.port = port
location = self.host, self.port
StreamServer.__init__(self, location)
def parse_address(address):
try:
hostname, port = address.rsplit(':', 1)
port = int(port)
except ValueError:
sys.exit('Expected HOST:PORT: %r' % address)
return gethostbyname(hostname), port
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--id', required=True, type=int)
parser.add_argument('--output-prefix', required=True)
args = parser.parse_args()
if args.output_prefix is None:
global outputFile
outputFile = './data_{id:02d}'.format(id=args.id)
else:
outputFile = args.output_prefix + '{id:02d}'.format(id=args.id)
with contextlib.closing(socket.socket()) as s, \
contextlib.closing(s.makefile("r+b", bufsize=0)) as cf:
# This will actually return a random testnet node
their_ip = socket.gethostbyname("seed.tbtc.petertodd.org")
their_ip = knownNodes[args.id][0]
print 'Connecting to:', their_ip
my_ip = "127.0.0.1"
s.connect((their_ip, PORT))
stream = msg_stream(cf)
# Send Version packet
s.send(version_pkt(my_ip, their_ip).to_bytes())
print "Send version"
# Receive their Version
their_ver = stream.next()
print 'Got', their_ver
# Send Version acknolwedgement (Verack)
s.send(msg_verack().to_bytes())
print 'Sent verack'
# Fork off a handler, but keep a tee of the stream
stream = tee_and_handle(s, stream)
# Get Verack
their_verack = stream.next()
print 'Got', their_verack
# Send a ping!
every_ = 30
i_ = 0
try:
while True:
msg = msg_getblocks()
msg.locator.vHave.append(binascii.unhexlify(gen)[::-1])
s.send(msg.to_bytes())
if i_ % every_ == 0:
print >> sys.stderr, 'Sent getblocks'
i_ += 1
gevent.sleep(SLEEP_TIMEOUT)
except KeyboardInterrupt:
pass
def run(ip='0.0.0.2'):
# DEBUG
ip = socket.gethostbyname(WEBSERVER)
r = redis.Redis(host='redis')
while True:
data, peer = s.recvfrom(8192)
gevent.spawn(dns_handler, s, peer, data, r, ip)
def resolve(url):
parts = urlparse.urlparse(url)
netloc = parts.netloc.rsplit(':')
if len(netloc) == 1:
netloc.append('80')
netloc = ':'.join([gethostbyname(netloc[0]), netloc[1]])
parts = (parts.scheme, netloc) + parts[2:]
return urlparse.urlunparse(parts)
def parse_address(address):
""" Pareses the hosts and ports in the conf file.
"""
try:
hostname, portnumber = address.rsplit(' ', 1)
portnumber = int(portnumber) # Has to be a INT
except ValueError:
sys.exit('Expected HOST PORT: %r' % address)
return (gethostbyname(hostname), portnumber)
def start(self):
"""Starts the client's asynchronous processing units."""
address = (socket.gethostbyname(self.hostname), self.port)
logger.info("Connecting to %r" % (address, ))
self._socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self._socket.connect(address)
self._start_processors()
return self
def parse_address(address):
'return: remote forward address port 10.126.152.199 80'
try:
hostname, port = address.rsplit(':', 1)
port = int(port)
except ValueError:
sys.exit('Excepted HOST:PORT: %r' % address)
# print(gethostbyname(hostname), port)
return gethostbyname(hostname), port
def start(self):
"""Starts the client's asynchronous processing units."""
address = (socket.gethostbyname(self.hostname), self.port)
logger.info("Connecting to %r" % (address,))
self._socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self._socket.connect(address)
self._start_processors()
return self
def parse_address(address):
""" Pareses the hosts and ports in the conf file.
"""
try:
hostname, portnumber = address.rsplit(' ', 1)
portnumber = int(portnumber) # Has to be a INT
except ValueError:
sys.exit('Expected HOST PORT: %r' % address)
return (gethostbyname(hostname), portnumber)
def query(self, dnsbl):
'''Perform query using gevent'''
try:
result = socket.gethostbyname(self.build_query(dnsbl))
except socket.gaierror as err:
result = False
err = str(err)
if not 'Errno 3' in err:
Base.log.debug('Base.query.exception: %s %s' % (dnsbl, err))
return dnsbl, result
def start(self):
address = (socket.gethostbyname(self.hostname), self.port)
self._socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self._socket.connect(address)
self.send('listen 1')
self._group.spawn(self._send_loop)
self._group.spawn(self._process_loop)
self._group.spawn(self._recv_loop)
def job(url):
global finished
try:
try:
ip = socket.gethostbyname(url)
print '%s = %s' % (url, ip)
except socket.gaierror, ex:
print '%s failed with %s' % (url, ex)
finally:
finished += 1
def server(port):
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind(('0.0.0.0', port))
s.listen(500)
print('Server', socket.gethostbyname('0.0.0.0'), 'listening ...')
while True:
cli, (ip, cport) = s.accept()
conn_dict[ip] = cli
print("(%s,%s connected...)" % (ip, cport))
gevent.spawn(handle_request, cli)
def job(url):
global finished
try:
try:
ip = socket.gethostbyname(url)
print "{0}------>{1}".format(url, ip)
except socket.gaierror as ex:
print "{0} failed with {1}".format(url, ex)
finally:
finished += 1
def __init__(self, handler, mcast_ip='239.255.255.250', mcast_port=1900, bind=None):
if bind is None:
host = socket.gethostbyname(socket.gethostname())
port = 54321
bind = '{0}:{1}'.format(host, port)
self.bind = bind
self.mcast_ip = mcast_ip
self.mcast_port = mcast_port
self.clients = {}
self._handler = handler
def job(url):
global finished
try:
try:
ip = socket.gethostbyname(url)
print('%s = %s' % (url, ip))
except socket.gaierror as ex:
print('%s failed with %s' % (url, ex))
finally:
finished += 1
def job(url):
global finished
try:
try:
ip = socket.gethostbyname(url)
print "{0}------>{1}".format(url, ip)
except socket.gaierror as ex:
print "{0} failed with {1}".format(url, ex)
finally:
finished += 1
def job(url):
global finished
try:
try:
ip = socket.gethostbyname(url)
print(f'{url}={ip}')
except socket.gaierror as ex:
print(f'{url} failed with with {ex}')
finally:
finished += 1
def resolve(url):
parts = urlparse.urlparse(url)
netloc = parts.netloc.rsplit(':')
if len(netloc) == 1:
netloc.append('80')
original = netloc[0]
resolved = gethostbyname(original)
netloc = resolved + ':' + netloc[1]
parts = (parts.scheme, netloc) + parts[2:]
return urlparse.urlunparse(parts), original, resolved
def query_dnsbl(self, mx_list, provider):
"""Check given IP against given DNSBL provider."""
results = {}
for mx in mx_list:
reverse = ".".join(reversed(mx.address.split(".")))
pattern = "{}.{}.".format(reverse, provider)
try:
results[mx] = socket.gethostbyname(pattern)
except socket.gaierror:
results[mx] = False
return provider, results
def query(self, ip_list, provider):
"""Check given IP against given provider."""
results = {}
for ip in ip_list:
reverse = ".".join(reversed(ip.split(".")))
pattern = "{}.{}".format(reverse, provider)
try:
results[ip] = socket.gethostbyname(pattern)
except socket.gaierror:
results[ip] = False
return provider, results
def job(url):
global finished
try:
try:
ip = socket.gethostbyname(url)
print '%s = %s' % (url, ip)
except socket.gaierror:
ex = sys.exc_info()[1]
print '%s failed with %s' % (url, ex)
finally:
finished += 1
def query_dnsbl(self, mx_list, provider):
"""Check given IP against given DNSBL provider."""
results = {}
for mx in mx_list:
reverse = ".".join(reversed(mx.address.split(".")))
pattern = "{}.{}.".format(reverse, provider)
try:
results[mx] = socket.gethostbyname(pattern)
except socket.gaierror:
results[mx] = False
return provider, results
def job(url):
global finished
try:
try:
ip = socket.gethostbyname(url)
print ('%s = %s' % (url, ip))
except socket.gaierror:
ex = sys.exc_info()[1]
print ('%s failed with %s' % (url, ex))
finally:
finished += 1
def parse_address(address):
try:
urls = urlparse.urlparse(address)
address = urls.netloc or urls.path
_addr = address.split(':')
hostname, port = len(_addr) == 2 and _addr or (_addr[0], 80)
port = int(port)
except ValueError:
sys.exit('Expected HOST:PORT: %r' % address)
return gethostbyname(hostname), port
def __init__(self,
name,
port=None,
host=None,
listen=True,
*args,
**kwargs):
super(TCPOut, self).__init__(name, *args, **kwargs)
self.blockdiag_config["shape"] = "cloud"
self.port = port or DEFAULT_PORT
self.host = host or socket.gethostbyname(socket.gethostname())
def connect(self):
address = None
try:
address = (socket.gethostbyname(self.hostname), self.port)
except socket.gaierror: #@UndefinedVariable
self.logger.error('Hostname not found')
raise
self.logger.debug('Connecting to %r...', address)
self._socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) #@UndefinedVariable
if self.ssl:
self._socket = gevent.ssl.SSLSocket(self._socket)
self._socket.connect(address)
self.logger.debug('Connection established')
def dns_handler(s, peer, data, r):
request = DNSRecord.parse(data)
id = request.header.id
qname = request.q.qname
qtype = request.q.qtype
IP = r.get("IP:%s" % qname)
TXT = r.get("TXT:%s" % qname)
if not IP:
try:
IP = socket.gethostbyname(str(qname))
except Exception, e:
print 'Host not found'
IP = '0.0.0.0'
def naddr_to_zmq_endpoint(nid):
if '\0' in nid:
return None
try:
host, port = nid.split(':')
except ValueError:
return None
try:
return 'tcp://%s:%s' % (gethostbyname(host), port)
except socket.gaierror as e:
# XXX: perhaps we should retry in a few sec in case of EAI_ERRNO_TEMPORARY_FAILURE_IN_NAME_RESOLUTION?
if e.errno not in (socket.EAI_NONAME, EAI_ERRNO_TEMPORARY_FAILURE_IN_NAME_RESOLUTION):
err("%s\n%s" % (e, traceback.format_exc()))
return None
def dns_resolve(url):
if url in _CACHE:
return _CACHE[url]
parts = urlparse.urlparse(url)
netloc = parts.netloc.rsplit(':')
if len(netloc) == 1:
netloc.append('80')
original = netloc[0]
resolved = gethostbyname(original)
netloc = resolved + ':' + netloc[1]
parts = (parts.scheme, netloc) + parts[2:]
_CACHE[url] = urlparse.urlunparse(parts), original, resolved
return _CACHE[url]
