Quick Navigator

Search Site

Unix VPS
A - Starter
B - Basic
C - Preferred
D - Commercial
MPS - Dedicated
Previous VPSs
* Sign Up! *

Contact Us
Online Help
Domain Status
Man Pages

Virtual Servers

Topology Map

Server Agreement
Year 2038

USA Flag



Man Pages

Manual Reference Pages  -  NET::WHOIS::GENERIC (3)

.ds Aq ’


Net::Whois::Generic - a pure-Perl implementation of a multi source Whois client.



Net::Whois::Generic is my first attempt to unify Whois information from different sources. Historically Net::Whois::RIPE was the first written, then Net::Whois::Object was added to provide a RPSL encapsultation of the data returned from RIPE database, with an API more object oriented.

Net::Whois::Generic is a new interface designed to be more generic and to encapsulate data from various sources (RIPE, but also AFRINIC, APNIC...) The current implementation is barely a proof of concept, AFRINIC and APNIC are the only other sources implemented, but I expect to turn it into a generic/robust implementation based on the users feedback.

    my $c = Net::Whois::Generic->new( disconnected => 1, unfiltered => 1 );

    my ($org) = $c->query( ORG-AFNC1-AFRINIC, { type => organisation } );
    # $org is a Net::Whois::Object::Organisation::AFRINIC object;
    my @o = $c->query(;
    # @o contains various Net::Whois::Object:Inetnum::APNIC, and Net::Whois::Object::Information objects

As Net::Whois::Generic started as an improvment of Net::Whois::RIPE, and have a good amount of code in common, for this reason (and some others) it is currently bundled inside the the Net::Whois::RIPE package. This might change in the future although.


new( CB%options )

Constructor. Returns a new Net::Whois::Generic object with an open connection to the RIPE Database service of choice (defaulting to

The %options hash migth contain configuration options for the RIPE Database server. Not all options provided by the RIPE Database server are suitable for this implementation, but the idea is to provide everything someone can show a use for. The options currently recognized are:
<B>hostnameB> (IPv4 address or DNS name. Default is The hostname or IP address of the service to connect to
<B>portB> (integer, default is 43) The TCP port of the service to connect to
<B>timeoutB> (integer, default is 5) The time-out (in seconds) for the TCP connection.
<B>referralB> (boolean, default is false) When true, prevents the server from using the referral mechanism for domain lookups, so that the RIPE Database server returns an object in the RIPE Database with the exact match with the lookup argument, rather than doing a referral lookup.
<B>recursiveB> (boolean, default is false) When set to true, prevents recursion into queried objects for personal information. This prevents lots of unsolicited objects from showing up on queries.
<B>groupingB> (boolean, default is false) When true enables object grouping in server responses. There’s little utility to enable this option, as the objects will be parsed and returned on a much reasonable format most of the time. For the brave or more knowledgeable people that want to have they answers in plain text, this can help stablishing a ’good’ ordering for the RPSL objects returned by a query (’good’ is RIPE NCC’s definition of ’good’ in this case).
<B>unfilteredB> (boolean, default is false) When true enables unfiltered object output responses. This produces objects that can be presented back to the RIPE Database for updating.
<B>typesB> (list of valid RIPE Database object types, default is empty, meaning all types) Restrict the RPSL object types allowed in the response to those in the list. Using this option will cause the Net::Whois::Generic object to query the RIPE Database for the available object types for validating the list. The response will be cached for speed and bandwidth.
<B>disconnectedB> (boolean, default is false) Prevents the constructor from automatically opening a connection to the service specified (conneting the socket is the default behavior). When set (true), the programmer is responsible for calling connect in order to stablish a connection to the RIPE Database service desired.

hostname( [$hostname] )

Accessor to the hostname. Accepts an optional hostname, always return the current hostname.


Accessor to the port. Accepts an optional port, always return the current port.


Accessor to the timeout configuration option. Accepts an optional timeout, always return the current timeout.


Accessor to the referral configuration option. Accepts an optional referral, always return the current referral.


Accessor to the recursive configuration option. Accepts an optional recursive, always return the current recursive.


Accessor to the grouping configuration option. Accepts an optional grouping, always return the current grouping.


Accessor to the unfiltered configuration option.


Initiates a connection with the current object’s configuration.


Accessor to the IO::Select object coordinating the I/O to the IO::Socket object used by this module to communicate with the RIPE Database Server. You shouldn’t use this object, but the send() and query( $query_string ) methods instead.


Read-only accessor to the IO::Socket object used by this module.


Sends a message to the RIPE Database server instance to which we’re connected to. Dies if it cannot write, or if there’s no open connection to the server.

Return true if the message could be written to the socket, false otherwise.


Reconnects to the server in case we lost connection.


Disconnects this client from the server. This renders the client useless until you call connect() again. This method is called by DESTROY() as part of an object’s clean-up process.


Returns true if this instance is connected to the RIPE Database service configured.


Net::Whois::Generic object destructor. Called by the Perl interpreter upon destruction of an instance.

_find_rir( CB$query_string )

Guess the associated RIR based on the query.

adapt_query( CB$query_string[, CB$rir] )

Adapt a query to set various parameter (whois server, query options...) based on the query. Takes an optional parameter $rir, to force a specific RIR to be used.

query( CB$query, [\%options] )

 ******************************** EXPERIMENTAL ************************************
   This method is a work in progress, the API and behaviour are subject to change

Query the the appropriate RIR database and return Net::Whois::Objects

This method accepts 2 optional parameters

’type’ which is a regex used to filter the query result: Only the object whose type matches the ’type’ parameter are returned

’attribute’ which is a regex used to filter the query result: Only the value of the attributes matching the ’attribute’ parameter are returned

Note that if ’attribute’ is specified strings are returned, instead of Net::Whois::Objects

Net::Whois:Generic->query() deprecates Net::Whois::Object->query() since release 2.005 of Net::Whois::RIPE


Return a list of known object types from the RIPE Database.

RIPE currently returns 21 types (Limerik have been removed): as-block as-set aut-num domain filter-set inet6num inetnum inet-rtr irt key-cert mntner organisation peering-set person poem poetic-form role route route6 route-set rtr-set

Due to some strange mis-behaviour in the protocol (or documentation?) the RIPE Database server won’t allow a keep-alive token with this query, meaning the connection will be terminated after this query.

_process_response( CB$response )

Process a response (error code, error message...)


Arnaud Arhuman Assad, <arhuman at>


<B>UpdateB> Update of objects from database other than RIPE is not currently implemented...
<B>SourcesB> Currently the only sources implemented are RIPE, AFRINIC, and APNIC.
<B>MaturityB> The Net::Whois::Generic interface is highly experimental. There are probably bugs, without any doubt missing documentation and examples but please don’t hesitate to contact me to suggest corrections and improvments.


Please report any bugs or feature requests to bug-net-whois-ripe at, or through the web interface at <>. I will be notified, and then you’ll automatically be notified of progress on your bug as I make changes.


There are several tools similar to Net::Whois::Generic, I’ll list some of them below and some reasons why Net::Whois::Generic exists anyway:

Net::Whois::IANA - A universal WHOIS extractor: update not possible, no RPSL parser

Net::Whois::ARIN - ARIN whois client: update not possible, only subset of ARIN objects handled

Net::Whois::Parser - Module for parsing whois information: no query handling, parser can (must?) be added

Net::Whois::RIPE - RIPE whois client: the basis for Net::Whois::Generic but only handle RIPE.


You can find documentation for this module with the perldoc command.

    perldoc Net::Whois::Generic

You can also look for information at:
o RT: CPAN’s request tracker


o AnnoCPAN: Annotated CPAN documentation


o CPAN Ratings


o Search CPAN



Thanks to Jaguar Networks which grants me time to work on this module.


Copyright 2013 Arnaud Arhuman Assad, all rights reserved.

This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself.

Search for    or go to Top of page |  Section 3 |  Main Index

perl v5.20.3 NET::WHOIS::GENERIC (3) 2015-05-20

Powered by GSP Visit the GSP FreeBSD Man Page Interface.
Output converted with manServer 1.07.