Que maneira Python que você sugeriria para verificar os registros do banco de dados Whois?

votos
8

Eu estou tentando obter um webservice em funcionamento que realmente requer para verificar bancos de dados Whois. O que eu estou fazendo agora é feio e eu gostaria de evitá-lo tanto quanto eu puder: Eu chamo gwhois comando e analisar sua saída. Feio.

Eu fiz alguma pesquisa para tentar encontrar uma maneira Python para fazer esta tarefa. Geralmente eu tenho muito mais nada - este link lista de discussão de idade tem uma maneira de verificar se existem domínio. Muito não o que eu estava procurando ... Mas, ainda assim, era melhor anwser Google me deu - tudo o resto é apenas um monte de perguntas unanwsered.

Qualquer um de vocês conseguiram obter algum método instalado e funcionando? Eu gostaria muito de receber algumas dicas, ou devo fazê-lo apenas o opensource-way, sentar e código algo por mim? :)

Publicado 08/09/2008 em 19:43
fonte usuário
Em outras línguas...                            


9 respostas

votos
8

Olhe para isto: http://code.google.com/p/pywhois/

pywhois - Módulo Python para recuperar informações WHOIS de domínios

Objetivo: - Criar um módulo Python importable simples que irá produzir dados WHOIS analisado 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 ir através de um serviço web intermediário como muitos outros fazem. - Trabalha 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
...
Respondeu 02/11/2010 em 14:53
fonte usuário

votos
6

Encontrado esta pergunta no processo da minha própria busca de uma biblioteca whois python.

Não sei que estou de acordo com a resposta de cdleary que o uso de uma biblioteca que envolve um comando é sempre o melhor caminho a percorrer - mas eu posso ver as razões por que ele disse isso.

Pro:-line cmd whois lida com todo o trabalho duro (chamadas de soquete, análise, etc)

Con: não portátil; módulo pode não funcionar, dependendo de comando whois subjacente. Mais lento, uma vez que a execução de um comando e, provavelmente, shell, além de comando whois. Afetado se não UNIX (Windows), diferente UNIX, mais velho UNIX, ou mais velhos comando whois

Estou à procura de um módulo whois que pode lidar com pesquisas de IP Whois e eu não estou interessado em codificação meu próprio cliente whois.

Aqui estão os módulos que I (leve) experimentadas e mais informações sobre ele:

pywhoisapi:

  • Home: http://code.google.com/p/pywhoisapi/
  • cliente REST acesso ARIN serviço REST whois: Projeto
  • Prós: capaz de lidar com pesquisas de endereço IP
  • Contras: capaz de puxar informações de servidores Whois de outros RIRs?

BulkWhois

  • Home: http://pypi.python.org/pypi/BulkWhois/0.2.1
  • cliente telnet acesso interface de consulta telnet whois do RIR: Projeto (?)
  • Prós: capaz de lidar com pesquisas de endereço IP
  • Contras: capaz de puxar informações de servidores Whois de outros RIRs?

pywhois:

  • Home: http://code.google.com/p/pywhois/
  • cliente REST acesso a serviços Whois RRID: Projeto
  • Prós: Accessses muitos RRIDs; tem python ramo 3.x
  • Contras: não parece lidar com pesquisas de endereço IP

python-whois:

whoisclient - garfo de python-whois

Update: Acabei usando pywhoisapi para as pesquisas IP reversa que eu estava fazendo

Respondeu 05/07/2012 em 13:03
fonte usuário

votos
5

Não há nada de errado em usar um utilitário de linha de comando para fazer o que quiser. Se você colocar um bom invólucro em torno do serviço, você pode implementar os 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, se está ou não rolar o seu próprio usando urllib, envolver em torno de um utilitário de linha de comando (como você está fazendo), ou importar uma biblioteca de terceiros e usar isso (como você está dizendo ), essa interface permanece o mesmo.

Esta abordagem geralmente não é considerado feio em tudo - às vezes comandar utilitários fazer o que quiser e você deve ser capaz de aproveitá-los . Se a velocidade acaba sendo um gargalo, a sua abstração torna o processo de mudança para uma implementação Python nativa transparente para o código do cliente.

Praticidade bate pureza - que é o que é Pythonic. :)

Respondeu 10/09/2008 em 22:44
fonte usuário

votos
4

Aqui está o cliente whois re-implementado em Python: http://code.activestate.com/recipes/577364-whois-client/

Respondeu 31/03/2011 em 01:37
fonte usuário

votos
1

Eu não sei se gwhois faz algo especial com a saída do servidor; no entanto, você pode claramente se conectar ao servidor whois no whois porta (43), enviar a sua consulta, ler todos os dados na resposta e analisá-los. Para tornar a vida um pouco mais fácil, você pode usar a classe telnetlib.Telnet (mesmo se o protocolo WHOIS é muito mais simples do que o protocolo telnet) em vez de soquetes simples.

As partes difíceis:

  • qual servidor whois você vai perguntar? RIPE, ARIN, APNIC, LACNIC, AFRINIC, JPNIC, Verio etc LACNIC poderia ser um fallback útil, uma vez que eles tendem a responder com dados úteis para pedidos de fora do seu domínio.
  • quais são as opções exatas e argumentos para cada servidor whois? alguma oferta de ajuda, outros não. Em geral, nomes de domínio simples trabalhar sem quaisquer opções especiais.
Respondeu 16/09/2008 em 01:23
fonte usuário

votos
0

aqui é uma solução pronto-a-usar, que funciona para mim; escrito para Python 3.1 (quando backporting para Py2.x, tomar um cuidado especial com as distinções de texto bytes / Unicode). seu único ponto de acesso é o método DRWHO.whois(), que espera um nome de domínio a ser aprovada em; ele irá então tentar 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()irá retornar um dicionário com uma única entrada text, que contém o texto de resposta enviado de volta pelo servidor WHOIS. Mais uma vez, uma solução mais completa, então, tentar analisar o texto (que deve ser feita separadamente para cada provedor, como não existe um formato padrão) e retornar um formato mais estruturado (por exemplo, definir um sinalizadoravailableque especifica se ou não o domínio parece disponível). diverta-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' ] )
Respondeu 09/03/2010 em 17:17
fonte usuário

votos
0
import socket
socket.gethostbyname_ex('url.com')

se ele retorna um gaierror você sabe sabe que não é registrado com qualquer DNS

Respondeu 09/03/2010 em 11:07
fonte usuário

votos
0

Analisando outra página woulnd't ser tão ruim (assumindo que o seu html woulnd't ser muito ruim), mas seria realmente me amarrar a eles - se eles estão para baixo, eu estou para baixo :)

Na verdade, eu encontrei algum projeto antigo no SourceForge: rwhois.py . O que me assusta um pouco é que a sua última atualização é de 2003. Mas, pode parecer como um bom lugar para começar a reimplementação do que eu faço agora ... Bem, eu me senti obligued para postar o link para esse projeto de qualquer maneira, apenas para referência futura.

Respondeu 08/09/2008 em 20:00
fonte usuário

votos
0

Outra maneira de fazer isso é usar urllib2módulo para analisar o serviço Whois de alguma outra página (muitos sites como o que existe). Mas que parece ser ainda mais de um hack que o que você faz agora, e lhe daria uma dependência em qualquer site whois que você escolheu, o que é ruim.

Eu odeio dizer isso, mas se você quiser voltar a implementar whoisem seu programa (que seria re-inventar a roda), rodando whoisno sistema operacional e analisando a saída (ou seja, o que você está fazendo agora) parece ser o caminho certo para faça.

Respondeu 08/09/2008 em 19:53
fonte usuário

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more