Opcje wyszukiwania podręcznika man:
Lista stron man zaczynających się od znaku:
A   B   C   D   E   F   G   H   I   J   K   L   M   N   O   P   Q   R   S   T   U   V   W   X   Y   Z   ALPHA   NUM   OTHER   ALL
Net::XWhois(3pm)      User Contributed Perl Documentation     Net::XWhois(3pm)

       Net::XWhois - Whois Client Interface for Perl5.

        use Net::XWhois;

        $whois = new Net::XWhois Domain => "" ;
        $whois = new Net::XWhois Domain => "",
                                 Server => "",
                                 Retain => 1,
                                 Parser => {
                                    nameservers => 'nserver:\s+(\S+)',

       The Net::XWhois class provides a generic client framework for doing
       Whois queries and parsing server response.

       The class maintains an array of top level domains and whois servers
       associated with them. This allows the class to transparently serve
       requests for different tlds, selecting servers appropriate for the tld.
       The server details are, therefore, hidden from the user and ""
       (from InterNIC), (from RIPE) and "" (from
       are queried in the same manner. This behaviour can be overridden by
       specifying different bindings at object construction or by registering
       associations with the class. See "register_associations()" and "new()".

       One of the more important goals of this module is to enable the design
       of consistent and predictable interfaces to incompatible whois response
       formats. The Whois RFC (954) does not define a template for presenting
       server data; consequently there is a large variation in layout styles
       as well as content served across servers.

       (There is, however, a new standard called RPSL (RFC2622) used by RIPE
       (, the European main whois server.)

       To overcome this, Net::XWhois maintains another set of tables - parsing
       rulesets - for a few, popular response formats. (See "%PARSERS"). These
       parsing tables contain section names (labels) together with regular
       expressions that match the corresponding section text. The section text
       is accessed "via" labels which are available as data instance methods
       at runtime. By following a consistent nomenclature for labels, semanti-
       cally related information encoded in different formats can be accessed
       with the same methods.

       new ()
           Creates a Net::XWhois object. Takes an optional argument, a hash,
           that specifies the domain name to be queried. Calls lookup() if a
           name is provided. The argument hash can also specify a whois
           server, a parsing rule-set or a parsing rule-set format. (See "per-
           sonality()"). Omitting the argument will create an "empty" object
           that can be used for accessing class data.

       personality ()
           Alters an object's personality.  Takes a hash with following argu-
           ments.  (Note: These arguments can also be passed to the construc-

           Domain  Domain name to be queried.

           Server  Server to query.

           Parser  Parsing Rule-set.  See "%PARSERS".

                    Parser => {
                      name            => 'domain:\s+(\S+)\n',
                      nameservers     => 'nserver:\s+(\S+)',
                      contact_emails  => 'e-mail:\s+(\S+\@\S+)',

           Format  A pre-defined parser format like INTERNIC, INTERNIC_FORMAT,
                   RIPE, RIPE_CH, JAPAN etc.

                    Format => 'INTERNIC_CONTACT',

           Nocache Force XWhois to ignore the cached records.

           Error   Determines how a network connection error is handled. By
                   default Net::XWhois will croak() if it can't connect to the
                   whois server. The Error attribute specifies a function call
                   name that will be invoked when a network connection error
                   occurs. Possible values are croak, carp, confess (imported
                   from and ignore (a blank function provided by
                   Net::XWhois). You can, of course, write your own function
                   to do error handling, in which case you'd have to provide a
                   fully qualified function name. Example: main::logerr.

           Timeout Timeout value for establishing a network connection with
                   the server. The default value is 60 seconds.

           An associative array that contains parsing rule-sets for various
           response formats.  Keys of this array are format names and values
           are hash refs that contain section labels and corresponding parser
           code.  The parser code can either be a regex or a reference to a
           subroutine.  In the case of a subroutine, the whois 'response'
           information is available to the sub in $_[0].  Parsers can be added
           and extended with the register_parser() method.  Also see "Data
           Instance Methods".

             my %PARSERS  = (
              INTERNIC => {
               contact_tech    => 'Technical Contact.*?\n(.*?)(?=\...
               contact_zone    => 'Zone Contact.*?\n(.*?)(?=\s*\n[...
               contact_billing => 'Billing Contact.*?\n(.*?)(?=\s*...
               contact_emails  => \&example_email_parser
             { etc. ... },

            sub example_email_parser {

                # Note that the default internal implemenation for
                # the INTERNIC parser is not a user-supplied code
                # block.  This is just an instructive example.

                my @matches = $_[0] =~ /(\S+\@\S+)/sg;
                return @matches;

           See for the complete definition of %PARSERS.

           %WHOIS_PARSER is a table that associates each whois server with
           their output format.

               my %WHOIS_PARSER = (
               ''       => 'RPSL',
               ''        => 'INTERNIC',
               ''      => 'JAPAN',
               '' => 'GENERIC',
               ''        => 'INTERNIC',
               ''         => 'RIPE_CH',
               ''      => 'TAIWAN',
               ''   => 'INTERNIC',
               ''     => 'RIPE',
               ''      => 'RIPE',
               ''      => 'CANADA',
               ''         => 'INTERNIC',
               ''      => 'KOREA',
               ''        => 'INTERNIC',
               ''       => 'RPSL',
                   ( etc.....)

           Please note that there is a plethora of output formats, allthough
           there are RFCs on this issue, like for instance RFC2622, there are
           numerous different formats being used!

           %DOMAIN_ASSOC is a table that associates top level domain names
           with their respective whois servers. You'd need to modity this ta-
           ble if you wish to extend the module's functionality to handle a
           new set of domain names. Or alter existing information. regis-
           ter_association() provides an interface to this array. See
  for the complete definition.

               my %DOMAIN_ASSOC = (
               'al' => '',
               'am' => '',
               'at' => '',
               'au' => '',
               'az' => '',
               'ba' => '',
               'be' => '',

           Extend, modify and override entries in %PARSERS. Accepts a hash
           with three keys - Name, Retain and Parser. If the format definition
           for the specified format exists and the Retain key holds a true
           value, the keys from the specified Parser are added to the existing
           definition. A new definition is created when Retain is false/not

            my $w = new Net::Whois;
            $w->register_parser (
               Name   => "INTERNIC",
               Retain => 1,
               Parser => {
                   creation_time => 'created on (\S*?)\.\n',
                   some_randome_entity => \&random_entity_subroutine

           Instructions on how to create a workable random_entity_subroutine
           are availabe in the %PARSERS description, above.

           Override and add entries to %ASSOC. Accepts a hash that contains
           representation specs for a whois server. The keys of this hash are
           server machine names and values are list-refs to the associated
           response formats and the top-level domains handled by the servers.
           See Net/ for more details.

            my $w = new Net::XWhois;
            $w->register_association (
                '' => [ RIPE, [ qw/au/ ] ]

           By default, Net::XWhois caches all whois responses and commits
           them, as separate files, to /tmp/whois.  register_cache () gets and
           sets the cache directory. Setting to "undef" will disable caching.

            $w->register_cache ( "/some/place/else" );
            $w->register_cache ( undef );

       Data Instance Methods
           Access to the whois response data is provided via AUTOLOADED meth-
           ods specified in the Parser. The methods return scalar or list data
           depending on the context.

           Internic Parser provides the following methods:

           name()  Domain name.

                   Domain Status when provided.  When the domain is on hold,
                   this method will return "On Hold" string.

                   Nameservers along with their IPs.

                   Registrant's name and address.

                   Administrative Contact.

                   Technical Contact.

                   Zone Contact.

                   Billing Contact.

                   List of email addresses of contacts.

                   List of contact handles in the response.  Contact and
                   Domain handles are valid query data that can be used
                   instead of contact and domain names.

                   List of domain handles in the response.   Can be used for
                   sorting out reponses that contain multiple domain names.

           Does a whois lookup on the specified domain.  Takes the same argu-
           ments as new().

            my $w = new Net::XWhois;
            $w->lookup ( Domain => "" );
            print $w->response ();

       Look at example programs that come with this package. "whois" is a
       replacement for the standard RIPE/InterNIC whois client. "creation"
       overrides the Parser value at object init and gets the Creation Time of
       an InterNIC domain. "creation2" does the same thing by extending the
       Class Parser. "contacts" queries and prints information about domain's
       Tech/Billing/Admin contacts.

       contribs/ containts parsers for serveral whois servers, which have not
       been patched into the module.

       Vipul Ved Prakash <>

       Curt Powell <>, Matt Spiers <matt@pavil->, Richard Dice <>, Robert Chalmers
       <>, Steinar Overbeck Cook <>,
       Steve Weathers <>, Robert Puettmann
       <>, Martin H . Sluka" <>, Rob Woodard
       <>, Jon Gilbert, Erik Aronesty for patches, bug-
       reports and many cogent suggestions.

       Net::XWhois development has moved to the sourceforge mailing list, Please send all Net::XWhois related
       communication directly to the list address. The subscription interface
       is at:

        RFC 954  <>
        RFC 2622 <>

       Copyright (c) 1998-2001 Vipul Ved Prakash. All rights reserved. This
       program is free software; you can redistribute it and/or modify it
       under the same terms as Perl itself.

perl v5.8.8                       2006-09-02                  Net::XWhois(3pm)

Time taken: 0.00069 seconds

Created with the man page lookup class by Andrew Collington,