¿Qué forma de Python sugeriría para verificar los registros de la base de datos whois?
https://stackoverflow.com/questions/50394
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPregunta
Estoy intentando poner en funcionamiento un servicio web que realmente requiere verificar las bases de datos whois.Lo que estoy haciendo ahora es feo y me gustaría evitarlo tanto como pueda:Llamo al comando gwhois y analizo su salida.Feo.
Hice una búsqueda para intentar encontrar una forma pitónica de realizar esta tarea.Generalmente no obtuve casi nada. este antiguo enlace de la lista de discusión tiene una manera de verificar si el dominio existe.No es lo que estaba buscando...Pero aun así, fue la mejor respuesta que me dio Google; todo lo demás son sólo un montón de preguntas sin respuesta.
¿Alguno de ustedes ha logrado poner en funcionamiento algún método?Agradecería mucho algunos consejos, ¿o debería hacerlo de forma abierta, sentarme y codificar algo por mi cuenta?:)
Solución
No hay nada de malo en usar una utilidad de línea de comandos para hacer lo que quieras.Si le pones un buen envoltorio al servicio, ¡puedes implementar las partes internas como quieras!Por ejemplo:
class Whois(object):
_whois_by_query_cache = {}
def __init__(self, query):
"""Initializes the instance variables to defaults. See :meth:`lookup`
for details on how to submit the query."""
self.query = query
self.domain = None
# ... other fields.
def lookup(self):
"""Submits the `whois` query and stores results internally."""
# ... implementation
Ahora, ya sea que utilices urllib o no, utilices una utilidad de línea de comandos (como lo estás haciendo) o importes una biblioteca de terceros y la uses (como Estás diciendo), esta interfaz sigue siendo la misma.
Este enfoque generalmente no se considera feo en absoluto. A veces las utilidades de comando hacen lo que quieres y deberías poder aprovecharlas..Si la velocidad termina siendo un cuello de botella, su abstracción hace que el proceso de cambio a una implementación nativa de Python sea transparente para el código de su cliente.
La practicidad vence a la pureza - eso es lo que es Pythonic.:)
Otros consejos
Mira este:http://code.google.com/p/pywhois/
pywhois: módulo de Python para recuperar información WHOIS de dominios
Meta:- Cree un módulo Python simple e importable que producirá datos de WHOIS analizados para un dominio determinado.- Capaz de extraer datos para todos los TLD populares (com, org, net, ...) - Consulte un servidor Whois directamente en lugar de pasar por un servicio web intermedio como lo hacen muchos otros.- Funciona con Python 2.4+ y sin dependencias externas
Ejemplo:
>>> import pywhois
>>> w = pywhois.whois('google.com')
>>> w.expiration_date
['14-sep-2011']
>>> w.emails
['contact-admin@google.com',
'dns-admin@google.com',
'dns-admin@google.com',
'dns-admin@google.com']
>>> print w
...
Encontré esta pregunta en el proceso de mi propia búsqueda de una biblioteca whois de Python.
No sé si estoy de acuerdo con la respuesta de CdLeary de que usar una biblioteca que envuelve un comando es siempre la mejor manera de hacerlo, pero puedo ver sus razones por las que dijo esto.
Pro:cmd-line whois se encarga de todo el trabajo duro (llamadas a socket, análisis, etc.)
Estafa:no portátil;Es posible que el módulo no funcione dependiendo del comando whois subyacente.Más lento, ya que se ejecuta un comando y muy probablemente un shell además del comando whois.Afectado si no unix (Windows), un comando WHOIS ONIX diferente, ONIX más antiguo o más antiguo
Estoy buscando un módulo whois que pueda manejar búsquedas de IP whois y no estoy interesado en codificar mi propio cliente whois.
Aquí están los módulos que probé (ligeramente) y más información al respecto:
pywhoisapi:
- Hogar: http://code.google.com/p/pywhoisapi/
- Diseño:Cliente REST accediendo al servicio REST whois de ARIN
- Ventajas:Capaz de manejar búsquedas de direcciones IP
- Contras:¿Puede extraer información de los servidores whois de otros RIR?
BulkWhois
- Hogar: http://pypi.python.org/pypi/BulkWhois/0.2.1
- Diseño:Cliente telnet accediendo a la interfaz de consulta telnet whois desde RIR(?)
- Ventajas:Capaz de manejar búsquedas de direcciones IP
- Contras:¿Puede extraer información de los servidores whois de otros RIR?
pywhois:
- Hogar: http://code.google.com/p/pywhois/
- Diseño:Cliente REST accediendo a servicios whois RRID
- Ventajas:Accede a muchos RRID;tiene rama Python 3.x
- Contras:no parece manejar búsquedas de direcciones IP
Python-whois:
- Hogar: http://code.google.com/p/python-whois/
- Diseño:envuelve el comando "whois"
- Contras:no parece manejar búsquedas de direcciones IP
whoisclient - bifurcación de python-whois
- Hogar: http://gitorious.org/python-whois
- Diseño:envuelve el comando "whois"
- Depende de:IPy.py
- Contras:no parece manejar búsquedas de direcciones IP
Actualizar:Terminé usando pywhoisapi para las búsquedas inversas de IP que estaba haciendo
Aquí está el cliente whois reimplementado en Python:http://code.activestate.com/recipes/577364-whois-client/
No sé si gwhois hace algo especial con la salida del servidor;sin embargo, puede conectarse fácilmente al servidor whois en el puerto whois (43), enviar su consulta, leer todos los datos de la respuesta y analizarlos.Para hacer la vida un poco más fácil, podrías usar la clase telnetlib.Telnet (incluso si el protocolo whois es mucho más simple que el protocolo telnet) en lugar de sockets simples.
Las partes difíciles:
- ¿A qué servidor whois le preguntarás?RIPE, ARIN, APNIC, LACNIC, AFRINIC, JPNIC, VERIO, etc. LACNIC podría ser un recurso útil, ya que tienden a responder con datos útiles a solicitudes fuera de su dominio.
- ¿Cuáles son las opciones y argumentos exactos para cada servidor whois?algunos ofrecen ayuda, otros no.En general, los nombres de dominio simples funcionan sin opciones especiales.
Otra forma de hacerlo es utilizar urllib2 módulo para analizar el servicio whois de alguna otra página (existen muchos sitios como ese).Pero eso parece un truco aún mayor que lo que haces ahora, y te daría dependencia del sitio whois que elijas, lo cual es malo.
Odio decirlo, pero a menos que quieras volver a implementar whois en su programa (que sería reinventar la rueda), ejecutando whois en el sistema operativo y analizar el resultado (es decir, lo que está haciendo ahora) parece la forma correcta de hacerlo.
Analizar otra página web no sería tan malo (asumiendo que su html no sería muy malo), pero en realidad me vincularía a ellos: si están caídos, yo estoy caído :)
De hecho, encontré un proyecto antiguo en sourceforge: rwhois.py.Lo que me asusta un poco es que su última actualización es del 2003.Pero podría parecer un buen lugar para comenzar a reimplementar lo que hago ahora mismo...Bueno, de todos modos me sentí obligado a publicar el enlace a este proyecto, sólo como referencia adicional.
import socket
socket.gethostbyname_ex('url.com')
Si devuelve un gaierror, sabes que no está registrado en ningún DNS.
aquí hay una solución lista para usar que funciona para mí;escrito para Python 3.1 (al realizar el backport a Py2.x, tenga especial cuidado con las distinciones de bytes/texto Unicode).su único punto de acceso es el método DRWHO.whois(), que espera que se pase un nombre de dominio;Luego intentará resolver el nombre utilizando el proveedor configurado como DRWHO.whois_providers[ '*' ] (una solución más completa podría diferenciar a los proveedores según el dominio de nivel superior). DRWHO.whois() devolverá un diccionario con una sola entrada text, que contiene el texto de respuesta enviado por el servidor WHOIS.Nuevamente, una solución más completa sería intentar analizar el texto (lo que debe hacerse por separado para cada proveedor, ya que no existe un formato estándar) y devolver un formato más estructurado (por ejemplo, establecer una bandera available que especifica si el dominio parece disponible o no).¡divertirse!
##########################################################################
import asyncore as _sys_asyncore
from asyncore import loop as _sys_asyncore_loop
import socket as _sys_socket
##########################################################################
class _Whois_request( _sys_asyncore.dispatcher_with_send, object ):
# simple whois requester
# original code by Frederik Lundh
#-----------------------------------------------------------------------
whoisPort = 43
#-----------------------------------------------------------------------
def __init__(self, consumer, host, provider ):
_sys_asyncore.dispatcher_with_send.__init__(self)
self.consumer = consumer
self.query = host
self.create_socket( _sys_socket.AF_INET, _sys_socket.SOCK_STREAM )
self.connect( ( provider, self.whoisPort, ) )
#-----------------------------------------------------------------------
def handle_connect(self):
self.send( bytes( '%s\r\n' % ( self.query, ), 'utf-8' ) )
#-----------------------------------------------------------------------
def handle_expt(self):
self.close() # connection failed, shutdown
self.consumer.abort()
#-----------------------------------------------------------------------
def handle_read(self):
# get data from server
self.consumer.feed( self.recv( 2048 ) )
#-----------------------------------------------------------------------
def handle_close(self):
self.close()
self.consumer.close()
##########################################################################
class _Whois_consumer( object ):
# original code by Frederik Lundh
#-----------------------------------------------------------------------
def __init__( self, host, provider, result ):
self.texts_as_bytes = []
self.host = host
self.provider = provider
self.result = result
#-----------------------------------------------------------------------
def feed( self, text ):
self.texts_as_bytes.append( text.strip() )
#-----------------------------------------------------------------------
def abort(self):
del self.texts_as_bytes[:]
self.finalize()
#-----------------------------------------------------------------------
def close(self):
self.finalize()
#-----------------------------------------------------------------------
def finalize( self ):
# join bytestrings and decode them (witha a guessed encoding):
text_as_bytes = b'\n'.join( self.texts_as_bytes )
self.result[ 'text' ] = text_as_bytes.decode( 'utf-8' )
##########################################################################
class DRWHO:
#-----------------------------------------------------------------------
whois_providers = {
'~isa': 'DRWHO/whois-providers',
'*': 'whois.opensrs.net', }
#-----------------------------------------------------------------------
def whois( self, domain ):
R = {}
provider = self._get_whois_provider( '*' )
self._fetch_whois( provider, domain, R )
return R
#-----------------------------------------------------------------------
def _get_whois_provider( self, top_level_domain ):
providers = self.whois_providers
R = providers.get( top_level_domain, None )
if R is None:
R = providers[ '*' ]
return R
#-----------------------------------------------------------------------
def _fetch_whois( self, provider, domain, pod ):
#.....................................................................
consumer = _Whois_consumer( domain, provider, pod )
request = _Whois_request( consumer, domain, provider )
#.....................................................................
_sys_asyncore_loop() # loops until requests have been processed
#=========================================================================
DRWHO = DRWHO()
domain = 'example.com'
whois = DRWHO.whois( domain )
print( whois[ 'text' ] )
