Que maneira Python você sugeriria para verificar os registros do banco de dados whois?
https://stackoverflow.com/questions/50394
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPergunta
Estou tentando colocar em funcionamento um serviço da web que realmente requer a verificação de bancos de dados whois.O que estou fazendo agora é feio e gostaria de evitá-lo o máximo que puder:Eu chamo o comando gwhois e analiso sua saída.Feio.
Fiz algumas pesquisas para tentar encontrar uma maneira pitônica de realizar essa tarefa.Geralmente não recebo quase nada - este antigo link da lista de discussão tem uma maneira de verificar se o domínio existe.Não era exatamente o que eu estava procurando...Mesmo assim, foi a melhor resposta que o Google me deu - todo o resto é apenas um monte de perguntas sem resposta.
Algum de vocês conseguiu colocar algum método em funcionamento?Eu apreciaria muito algumas dicas, ou devo apenas fazer isso de maneira opensource, sentar e codificar algo sozinho?:)
Solução
Não há nada de errado em usar um utilitário de linha de comando para fazer o que você deseja.Se você colocar um belo invólucro em torno do serviço, poderá implementar os componentes internos como quiser!Por exemplo:
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
Agora, independentemente de você criar seu próprio urllib ou não, use um utilitário de linha de comando (como você está fazendo) ou importe uma biblioteca de terceiros e use-a (como você está dizendo), essa interface permanece a mesma.
Esta abordagem geralmente não é considerada feia - às vezes, os utilitários de comando fazem o que você deseja e você deve ser capaz de aproveitá-los.Se a velocidade acabar sendo um gargalo, sua abstração tornará o processo de mudança para uma implementação nativa do Python transparente para o código do seu cliente.
A praticidade supera a pureza - isso é o que é Pythonic.:)
Outras dicas
Veja isso:http://code.google.com/p/pywhois/
pywhois - Módulo Python para recuperar informações WHOIS de domínios
Meta:- Crie um módulo Python simples e importável que produzirá dados WHOIS analisados para um determinado domínio.- Capaz de extrair dados para todos os TLDs populares (com, org, net, ...) - Consultar um servidor WHOIS diretamente em vez de passar por um serviço web intermediário como muitos outros fazem.- Funciona com Python 2.4+ e sem dependências externas
Exemplo:
>>> 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
...
Encontrei esta pergunta no processo de minha própria pesquisa por uma biblioteca python whois.
Não sei se concordo com a resposta de cdleary que usa uma biblioteca que embrulha um comando é sempre o melhor caminho a seguir - mas posso ver as razões pelas quais ele disse isso.
Pró:cmd-line whois cuida de todo o trabalho pesado (chamadas de soquete, análise, etc.)
Vigarista:não portátil;O módulo pode não funcionar dependendo do comando whois subjacente.Mais lento, desde a execução de um comando e provavelmente um shell além do comando whois.Afetado se não UNIX (Windows), UNIX diferente, UNIX mais antigo ou Comando Whois mais antigo
Estou procurando um módulo whois que possa lidar com pesquisas de IP whois e não estou interessado em codificar meu próprio cliente whois.
Aqui estão os módulos que experimentei (levemente) e mais informações sobre eles:
pywhoisapi:
- Lar: http://code.google.com/p/pywhoisapi/
- Projeto:Cliente REST acessando o serviço ARIN whois REST
- Prós:Capaz de lidar com pesquisas de endereço IP
- Contras:Capaz de extrair informações de servidores whois de outros RIRs?
BulkWhois
- Lar: http://pypi.python.org/pypi/BulkWhois/0.2.1
- Projeto:cliente telnet acessando a interface de consulta telnet whois do RIR (?)
- Prós:Capaz de lidar com pesquisas de endereço IP
- Contras:Capaz de extrair informações de servidores whois de outros RIRs?
pywhois:
- Lar: http://code.google.com/p/pywhois/
- Projeto:Cliente REST acessando serviços whois RRID
- Prós:Acessa muitos RRIDs;tem ramificação python 3.x
- Contras:não parece lidar com pesquisas de endereço IP
python-whois:
- Lar: http://code.google.com/p/python-whois/
- Projeto:envolve o comando "whois"
- Contras:não parece lidar com pesquisas de endereço IP
whoisclient - fork do python-whois
- Lar: http://gitorious.org/python-whois
- Projeto:envolve o comando "whois"
- Depende de:IPy.py
- Contras:não parece lidar com pesquisas de endereço IP
Atualizar:Acabei usando pywhoisapi para as pesquisas reversas de IP que estava fazendo
Aqui está o cliente whois reimplementado em Python:http://code.activestate.com/recipes/577364-whois-client/
Não sei se o gwhois faz algo especial com a saída do servidor;entretanto, você pode conectar-se simplesmente ao servidor whois na porta whois (43), enviar sua consulta, ler todos os dados da resposta e analisá-los.Para tornar a vida um pouco mais fácil, você poderia usar a classe telnetlib.Telnet (mesmo que o protocolo whois seja muito mais simples que o protocolo telnet) em vez de soquetes simples.
As partes complicadas:
- qual servidor whois você perguntará?RIPE, ARIN, APNIC, LACNIC, AFRINIC, JPNIC, VERIO etc. LACNIC poderia ser uma alternativa útil, pois tendem a responder com dados úteis a solicitações fora de seu domínio.
- quais são as opções e argumentos exatos para cada servidor whois?alguns oferecem ajuda, outros não.Em geral, nomes de domínio simples funcionam sem opções especiais.
Outra maneira de fazer isso é usar urllib2 módulo para analisar o serviço whois de alguma outra página (existem muitos sites como esse).Mas isso parece ainda mais um hack do que o que você faz agora, e lhe daria uma dependência de qualquer site whois que você escolher, o que é ruim.
Odeio dizer isso, mas a menos que você queira reimplementar whois no seu programa (o que seria reinventar a roda), executando whois no sistema operacional e analisar a saída (ou seja, o que você está fazendo agora) parece ser a maneira certa de fazer isso.
Analisar outra página da Web não seria tão ruim (assumindo que o HTML deles não seria muito ruim), mas na verdade me amarraria a eles - se eles estiverem inativos, eu estou inativo :)
Na verdade encontrei um projeto antigo no sourceforge: rwhois.py.O que me assusta um pouco é que a última atualização deles é de 2003.Mas, pode parecer um bom lugar para começar a reimplementação do que faço agora...Bem, de qualquer maneira, me senti obrigado a postar o link para este projeto, apenas para referência futura.
import socket
socket.gethostbyname_ex('url.com')
se retornar um gaierror você sabe que não está registrado em nenhum DNS
aqui está uma solução pronta para uso que funciona para mim;escrito para Python 3.1 (ao fazer backport para Py2.x, tome cuidado especial com as distinções de bytes/texto Unicode).seu único ponto de acesso é o método DRWHO.whois(), que espera que um nome de domínio seja transmitido;ele tentará então resolver o nome usando o provedor configurado como DRWHO.whois_providers[ '*' ] (uma solução mais completa poderia diferenciar os prestadores de acordo com o domínio de topo). DRWHO.whois() retornará um dicionário com uma única entrada text, que contém o texto de resposta enviado de volta pelo servidor WHOIS.Novamente, uma solução mais completa tentaria analisar o texto (o que deve ser feito separadamente para cada provedor, pois não existe um formato padrão) e retornar um formato mais estruturado (por exemplo, definir um sinalizador available que especifica se o domínio parece ou não disponível).divirta-se!
##########################################################################
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' ] )
