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 __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 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 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 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 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(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 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]