home *** CD-ROM | disk | FTP | other *** search
/ PC Professionell 2004 December / PCpro_2004_12.ISO / files / webserver / xampp / xampp-perl-addon-1.4.9-installer.exe / DNS.pm < prev    next >
Encoding:
Perl POD Document  |  2004-02-24  |  18.0 KB  |  712 lines
  1. package Net::DNS;
  2. #
  3. # $Id: DNS.pm,v 2.107 2004/02/21 12:44:18 ctriv Exp $
  4. #
  5. use strict;
  6. use vars qw(
  7.     $HAVE_XS
  8.     $VERSION
  9.     $DNSSEC
  10.     @ISA
  11.     @EXPORT
  12.     %typesbyname
  13.     %typesbyval
  14.     %qtypesbyname
  15.     %qtypesbyval
  16.     %metatypesbyname
  17.     %metatypesbyval
  18.     %classesbyname
  19.     %classesbyval
  20.     %opcodesbyname
  21.     %opcodesbyval
  22.     %rcodesbyname
  23.     %rcodesbyval
  24. );
  25.  
  26.  
  27.  
  28. BEGIN {
  29.     require DynaLoader;
  30.     require Exporter;
  31.     
  32.     @ISA     = qw(Exporter DynaLoader);
  33.     $VERSION = '0.46';
  34.     $HAVE_XS = eval { __PACKAGE__->bootstrap(); 1 } ? 1 : 0;
  35. }
  36.  
  37. use Net::DNS::Resolver;
  38. use Net::DNS::Packet;
  39. use Net::DNS::Update;
  40. use Net::DNS::Header;
  41. use Net::DNS::Question;
  42. use Net::DNS::RR;
  43.  
  44. BEGIN {
  45.     $DNSSEC = eval { require Net::DNS::RR::SIG; 1 } ? 1 : 0;
  46. }
  47.  
  48.  
  49.  
  50. @EXPORT = qw(mx yxrrset nxrrset yxdomain nxdomain rr_add rr_del);
  51.  
  52. #
  53. # If you implement an RR record make sure you also add it to 
  54. # %Net::DNS::RR::RR hash otherwise it will be treated as unknown type.
  55. # 
  56.  
  57. # Do not use these tybesby hashes directly. Use the interface
  58. # functions, see below.
  59.  
  60. %typesbyname = (
  61.      'SIGZERO'   => 0,       # RFC2931 consider this a pseudo type
  62.     'A'            => 1,        # RFC 1035, Section 3.4.1
  63.     'NS'        => 2,        # RFC 1035, Section 3.3.11
  64.     'MD'        => 3,        # RFC 1035, Section 3.3.4 (obsolete)
  65.     'MF'        => 4,        # RFC 1035, Section 3.3.5 (obsolete)
  66.     'CNAME'        => 5,        # RFC 1035, Section 3.3.1
  67.     'SOA'        => 6,        # RFC 1035, Section 3.3.13
  68.     'MB'        => 7,        # RFC 1035, Section 3.3.3
  69.     'MG'        => 8,        # RFC 1035, Section 3.3.6
  70.     'MR'        => 9,        # RFC 1035, Section 3.3.8
  71.     'NULL'        => 10,        # RFC 1035, Section 3.3.10
  72.     'WKS'        => 11,        # RFC 1035, Section 3.4.2 (deprecated)
  73.     'PTR'        => 12,        # RFC 1035, Section 3.3.12
  74.     'HINFO'        => 13,        # RFC 1035, Section 3.3.2
  75.     'MINFO'     => 14,        # RFC 1035, Section 3.3.7
  76.     'MX'        => 15,        # RFC 1035, Section 3.3.9
  77.     'TXT'        => 16,        # RFC 1035, Section 3.3.14
  78.     'RP'        => 17,        # RFC 1183, Section 2.2
  79.     'AFSDB'        => 18,        # RFC 1183, Section 1
  80.     'X25'        => 19,        # RFC 1183, Section 3.1
  81.     'ISDN'        => 20,        # RFC 1183, Section 3.2
  82.     'RT'        => 21,        # RFC 1183, Section 3.3
  83.     'NSAP'        => 22,        # RFC 1706, Section 5
  84.     'NSAP_PTR'    => 23,        # RFC 1348 (obsolete)
  85.     # The following 2 RRs are impemented in Net::DNS::SEC
  86.      'SIG'        => 24,        # RFC 2535, Section 4.1
  87.      'KEY'        => 25,        # RFC 2535, Section 3.1
  88.      'PX'        => 26,        # RFC 2163,
  89.     'GPOS'        => 27,        # RFC 1712 (obsolete)
  90.     'AAAA'        => 28,        # RFC 1886, Section 2.1
  91.     'LOC'        => 29,        # RFC 1876
  92.     # The following RR is impemented in Net::DNS::SEC
  93.     'NXT'        => 30,        # RFC 2535, Section 5.2
  94.     'EID'        => 31,        # draft-ietf-nimrod-dns-xx.txt
  95.     'NIMLOC'    => 32,        # draft-ietf-nimrod-dns-xx.txt
  96.     'SRV'        => 33,        # RFC 2052
  97.     'ATMA'        => 34,        # ???
  98.     'NAPTR'        => 35,        # RFC 2168
  99.     'KX'        => 36,        # RFC 2230
  100.      'CERT'        => 37,        # RFC 2538
  101.     'DNAME'        => 39,        # RFC 2672
  102.     'OPT'          => 41,        # RFC 2671
  103.     # The following 4 RRs are impemented in Net::DNS::SEC
  104.     # Aug 2003: These RRs will be published as RFCs shortly 
  105.     'DS'        => 43,        # draft-ietf-dnsext-delegation-signer
  106.     'RRSIG'        => 46,        # draft-ietf-dnsext-dnssec-2535typecode-change
  107.     'NSEC'        => 47,        # draft-ietf-dnsext-dnssec-2535typecode-change
  108.     'DNSKEY'    => 48,        # draft-ietf-dnsext-dnssec-2535typecode-change
  109.     'UINFO'        => 100,        # non-standard
  110.     'UID'        => 101,        # non-standard
  111.     'GID'        => 102,        # non-standard
  112.     'UNSPEC'    => 103,        # non-standard
  113.     'TKEY'        => 249,        # RFC 2930
  114.     'TSIG'        => 250,        # RFC 2931
  115.     'IXFR'        => 251,        # RFC 1995
  116.     'AXFR'        => 252,        # RFC 1035
  117.     'MAILB'        => 253,        # RFC 1035 (MB, MG, MR)
  118.     'MAILA'        => 254,        # RFC 1035 (obsolete - see MX)
  119.     'ANY'        => 255,        # RFC 1035
  120. );
  121. %typesbyval = reverse %typesbyname;
  122.  
  123.  
  124. #
  125. # typesbyval and typesbyname functions are wrappers around the similarly named
  126. # hashes. They are used for 'unknown' DNS RR types (RFC3597)
  127.  
  128. # typesbyname returns they TYPEcode as a function of the TYPE
  129. # mnemonic. If the TYPE mapping is not specified the generic mnemonic
  130. # TYPE### is returned.
  131.  
  132.  
  133. # typesbyval returns they TYPE mnemonic as a function of the TYPE
  134. # code. If the TYPE mapping is not specified the generic mnemonic
  135. # TYPE### is returned.
  136. #
  137.  
  138. sub typesbyname {
  139.     my $name = uc shift;
  140.  
  141.     return $typesbyname{$name} if $typesbyname{$name};
  142.     
  143.     die "Net::DNS::typesbyval() argument is not TYPE### ($name)" unless 
  144.         $name =~ m/^\s*TYPE(\d+)\s*$/;  
  145.     
  146.     my $val = $1;
  147.     
  148.     die 'Net::DNS::typesbyval() argument larger than ' . 0xffff if $val > 0xffff;
  149.     
  150.     return $val;
  151. }
  152.  
  153.  
  154.  
  155. sub typesbyval {
  156.     my $val = shift;
  157.     
  158.     die "Net::DNS::typesbyname() argument is not numeric ($val)" unless 
  159.         $val =~ m/^\s*\d+\s*$/;  
  160.     
  161.     $val =~ s/\s*//g; 
  162.     $val =~ s/^0*//; 
  163.     
  164.     return $typesbyval{$val} if $typesbyval{$val};
  165.     
  166.     die 'Net::DNS::typesbyname() argument larger than '. 0xffff if 
  167.         $val > 0xffff;
  168.     
  169.     return "TYPE$val";
  170. }
  171.  
  172.  
  173.  
  174. #
  175. # Do not use these classesby hashes directly. See below. 
  176. #
  177.  
  178. %classesbyname = (
  179.     'IN'        => 1,        # RFC 1035
  180.     'CH'        => 3,        # RFC 1035
  181.     'HS'        => 4,        # RFC 1035
  182.     'NONE'        => 254,        # RFC 2136
  183.     'ANY'        => 255,        # RFC 1035
  184. );
  185. %classesbyval = reverse %classesbyname;
  186.  
  187.  
  188.  
  189. # classesbyval and classesbyname functions are wrappers around the
  190. # similarly named hashes. They are used for 'unknown' DNS RR classess
  191. # (RFC3597)
  192.  
  193. # See typesbyval and typesbyname, these beasts have the same functionality
  194.  
  195. sub classesbyname {
  196.     my $name = uc shift;
  197.     return $classesbyname{$name} if $classesbyname{$name};
  198.     
  199.     die "Net::DNS::classesbyval() argument is not CLASS### ($name)" unless 
  200.         $name =~ m/^\s*CLASS(\d+)\s*$/;
  201.     
  202.     my $val = $1;
  203.     
  204.     die 'Net::DNS::classesbyval() argument larger than '. 0xffff if $val > 0xffff;
  205.     
  206.     return $val;
  207. }
  208.  
  209.  
  210.  
  211. sub classesbyval {
  212.     my $val = shift;
  213.     
  214.     die "Net::DNS::classesbyname() argument is not numeric ($val)" unless 
  215.         $val=~/^\s*\d+\s*$/;
  216.     
  217.     $val =~ s/\s*//g;
  218.     $val =~ s/^0*//;
  219.     
  220.     return $classesbyval{$val} if $classesbyval{$val};
  221.     
  222.     die 'Net::DNS::classesbyname() argument larger than ' . 0xffff if $val > 0xffff;
  223.     
  224.     return "CLASS$val";
  225. }
  226.  
  227.  
  228.  
  229. # The qtypesbyval and metatypesbyval specify special typecodes
  230. # See rfc2929 and the relevant IANA registry
  231. # http://www.iana.org/assignments/dns-parameters
  232.  
  233.  
  234. %qtypesbyname = (
  235.     'IXFR'   => 251,  # incremental transfer                [RFC1995]
  236.     'AXFR'   => 252,  # transfer of an entire zone          [RFC1035]
  237.     'MAILB'  => 253,  # mailbox-related RRs (MB, MG or MR)     [RFC1035]
  238.     'MAILA'  => 254,  # mail agent RRs (Obsolete - see MX)     [RFC1035]
  239.     'ANY'    => 255,  # all records                         [RFC1035]
  240. );
  241. %qtypesbyval = reverse %qtypesbyname;
  242.  
  243.  
  244. %metatypesbyname = (
  245.     'TKEY'        => 249,    # Transaction Key   [RFC2930]
  246.     'TSIG'        => 250,    # Transaction Signature  [RFC2845]
  247.     'OPT'         => 41,     # RFC 2671
  248. );
  249. %metatypesbyval = reverse %metatypesbyname;
  250.  
  251.  
  252. %opcodesbyname = (
  253.     'QUERY'           => 0,        # RFC 1035
  254.     'IQUERY'       => 1,        # RFC 1035
  255.     'STATUS'       => 2,        # RFC 1035
  256.     'NS_NOTIFY_OP' => 4,        # RFC 1996
  257.     'UPDATE'       => 5,        # RFC 2136
  258. );
  259. %opcodesbyval = reverse %opcodesbyname;
  260.  
  261.  
  262. %rcodesbyname = (
  263.     'NOERROR'    => 0,        # RFC 1035
  264.     'FORMERR'    => 1,        # RFC 1035
  265.     'SERVFAIL'    => 2,        # RFC 1035
  266.     'NXDOMAIN'    => 3,        # RFC 1035
  267.     'NOTIMP'    => 4,        # RFC 1035
  268.     'REFUSED'    => 5,        # RFC 1035
  269.     'YXDOMAIN'    => 6,        # RFC 2136
  270.     'YXRRSET'    => 7,        # RFC 2136
  271.     'NXRRSET'    => 8,        # RFC 2136
  272.     'NOTAUTH'    => 9,        # RFC 2136
  273.     'NOTZONE'    => 10,        # RFC 2136
  274. );
  275. %rcodesbyval = reverse %rcodesbyname;
  276.  
  277.  
  278. sub version      { $VERSION; }
  279. sub PACKETSZ  () { 512; }
  280. sub HFIXEDSZ  () {  12; }
  281. sub QFIXEDSZ  () {   4; }
  282. sub RRFIXEDSZ () {  10; }
  283. sub INT32SZ   () {   4; }
  284. sub INT16SZ   () {   2; }
  285.  
  286.  
  287.  
  288. # mx()
  289. #
  290. # Usage:
  291. #    my @mxes = mx('example.com', 'IN');
  292. #
  293. sub mx {
  294.     my $res = ref $_[0] ? shift : Net::DNS::Resolver->new;
  295.  
  296.     my ($name, $class) = @_;
  297.     $class ||= 'IN';
  298.  
  299.     my $ans = $res->query($name, 'MX', $class) || return;
  300.  
  301.     # This construct is best read backwords.
  302.     #
  303.     # First we take the answer secion of the packet.
  304.     # Then we take just the MX records from that list
  305.     # Then we sort the list by preference
  306.     # Then we return it.
  307.     # We do this into an array to force list context.
  308.     my @ret = sort { $a->preference <=> $b->preference } 
  309.                  grep { $_->type eq 'MX'} $ans->answer;
  310.  
  311.  
  312.     return @ret;
  313. }
  314.  
  315. sub yxrrset {
  316.     return Net::DNS::RR->new_from_string(shift, 'yxrrset');
  317. }
  318.  
  319. sub nxrrset {
  320.     return Net::DNS::RR->new_from_string(shift, 'nxrrset');
  321. }
  322.  
  323. sub yxdomain {
  324.     return Net::DNS::RR->new_from_string(shift, 'yxdomain');
  325. }
  326.  
  327. sub nxdomain {
  328.     return Net::DNS::RR->new_from_string(shift, 'nxdomain');
  329. }
  330.  
  331. sub rr_add {
  332.     return Net::DNS::RR->new_from_string(shift, 'rr_add');
  333. }
  334.  
  335. sub rr_del {
  336.     return Net::DNS::RR->new_from_string(shift, 'rr_del');
  337. }
  338.  
  339. 1;
  340. __END__
  341.  
  342. =head1 NAME
  343.  
  344. Net::DNS - Perl interface to the DNS resolver
  345.  
  346. =head1 SYNOPSIS
  347.  
  348. C<use Net::DNS;>
  349.  
  350. =head1 DESCRIPTION
  351.  
  352. Net::DNS is a collection of Perl modules that act as a Domain
  353. Name System (DNS) resolver.  It allows the programmer to perform
  354. DNS queries that are beyond the capabilities of C<gethostbyname>
  355. and C<gethostbyaddr>.
  356.  
  357. The programmer should be somewhat familiar with the format of
  358. a DNS packet and its various sections.  See RFC 1035 or
  359. I<DNS and BIND> (Albitz & Liu) for details.
  360.  
  361. =head2 Resolver Objects
  362.  
  363. A resolver object is an instance of the
  364. L<Net::DNS::Resolver|Net::DNS::Resolver> class. A program can have
  365. multiple resolver objects, each maintaining its own state information
  366. such as the nameservers to be queried, whether recursion is desired,
  367. etc.
  368.  
  369. =head2 Packet Objects
  370.  
  371. L<Net::DNS::Resolver|Net::DNS::Resolver> queries return
  372. L<Net::DNS::Packet|Net::DNS::Packet> objects.  Packet objects have five
  373. sections:
  374.  
  375. =over 3
  376.  
  377. =item *
  378.  
  379. The header section, a L<Net::DNS::Header|Net::DNS::Header> object.
  380.  
  381. =item *
  382.  
  383. The question section, a list of L<Net::DNS::Question|Net::DNS::Question>
  384. objects.
  385.  
  386. =item *
  387.  
  388. The answer section, a list of L<Net::DNS::RR|Net::DNS::RR> objects.
  389.  
  390. =item *
  391.  
  392. The authority section, a list of L<Net::DNS::RR|Net::DNS::RR> objects.
  393.  
  394. =item *
  395.  
  396. The additional section, a list of L<Net::DNS::RR|Net::DNS::RR> objects.
  397.  
  398. =back
  399.  
  400. =head2 Update Objects
  401.  
  402. The L<Net::DNS::Update|Net::DNS::Update> package is a subclass of
  403. L<Net::DNS::Packet|Net::DNS::Packet> for creating packet objects to be
  404. used in dynamic updates.  
  405.  
  406. =head2 Header Objects
  407.  
  408. L<Net::DNS::Header|Net::DNS::Header> objects represent the header
  409. section of a DNS packet.
  410.  
  411. =head2 Question Objects
  412.  
  413. L<Net::DNS::Question|Net::DNS::Question> objects represent the question
  414. section of a DNS packet.
  415.  
  416. =head2 RR Objects
  417.  
  418. L<Net::DNS::RR|Net::DNS::RR> is the base class for DNS resource record
  419. (RR) objects in the answer, authority, and additional sections of a DNS
  420. packet.
  421.  
  422. Don't assume that RR objects will be of the type you requested -- always
  423. check an RR object's type before calling any of its methods.
  424.  
  425. =head1 METHODS
  426.  
  427. See the manual pages listed above for other class-specific methods.
  428.  
  429. =head2 version
  430.  
  431.     print Net::DNS->version, "\n";
  432.  
  433. Returns the version of Net::DNS.
  434.  
  435. =head2 mx
  436.  
  437.     # Use a default resolver -- can't get an error string this way.
  438.     use Net::DNS;
  439.     my @mx = mx("example.com");
  440.  
  441.     # Use your own resolver object.
  442.     use Net::DNS;
  443.     my $res = Net::DNS::Resolver->new;
  444.     my  @mx = mx($res, "example.com");
  445.  
  446. Returns a list of L<Net::DNS::RR::MX|Net::DNS::RR::MX> objects
  447. representing the MX records for the specified name; the list will be
  448. sorted by preference. Returns an empty list if the query failed or no MX
  449. records were found.
  450.  
  451. This method does not look up A records -- it only performs MX queries.
  452.  
  453. See L</EXAMPLES> for a more complete example.
  454.  
  455. =head2 yxrrset
  456.  
  457. Use this method to add an "RRset exists" prerequisite to a dynamic
  458. update packet.  There are two forms, value-independent and
  459. value-dependent:
  460.  
  461.     # RRset exists (value-independent)
  462.     $update->push(pre => yxrrset("host.example.com A"));
  463.  
  464. Meaning:  At least one RR with the specified name and type must
  465. exist.
  466.  
  467.     # RRset exists (value-dependent)
  468.     $packet->push(pre => yxrrset("host.example.com A 10.1.2.3"));
  469.  
  470. Meaning:  At least one RR with the specified name and type must
  471. exist and must have matching data.
  472.  
  473. Returns a C<Net::DNS::RR> object or C<undef> if the object couldn't
  474. be created.
  475.  
  476. =head2 nxrrset
  477.  
  478. Use this method to add an "RRset does not exist" prerequisite to
  479. a dynamic update packet.
  480.  
  481.     $packet->push(pre => nxrrset("host.example.com A"));
  482.  
  483. Meaning:  No RRs with the specified name and type can exist.
  484.  
  485. Returns a C<Net::DNS::RR> object or C<undef> if the object couldn't
  486. be created.
  487.  
  488. =head2 yxdomain
  489.  
  490. Use this method to add a "name is in use" prerequisite to a dynamic
  491. update packet.
  492.  
  493.     $packet->push(pre => yxdomain("host.example.com"));
  494.  
  495. Meaning:  At least one RR with the specified name must exist.
  496.  
  497. Returns a C<Net::DNS::RR> object or C<undef> if the object couldn't
  498. be created.
  499.  
  500. =head2 nxdomain
  501.  
  502. Use this method to add a "name is not in use" prerequisite to a
  503. dynamic update packet.
  504.  
  505.     $packet->push(pre => nxdomain("host.example.com"));
  506.  
  507. Meaning:  No RR with the specified name can exist.
  508.  
  509. Returns a C<Net::DNS::RR> object or C<undef> if the object couldn't
  510. be created.
  511.  
  512. =head2 rr_add
  513.  
  514. Use this method to add RRs to a zone.
  515.  
  516.     $packet->push(update => rr_add("host.example.com A 10.1.2.3"));
  517.  
  518. Meaning:  Add this RR to the zone.
  519.  
  520. RR objects created by this method should be added to the "update"
  521. section of a dynamic update packet.  The TTL defaults to 86400
  522. seconds (24 hours) if not specified.
  523.  
  524. Returns a C<Net::DNS::RR> object or C<undef> if the object couldn't
  525. be created.
  526.  
  527. =head2 rr_del
  528.  
  529. Use this method to delete RRs from a zone.  There are three forms:
  530. delete an RRset, delete all RRsets, and delete an RR.
  531.  
  532.     # Delete an RRset.
  533.     $packet->push(update => rr_del("host.example.com A"));
  534.  
  535. Meaning:  Delete all RRs having the specified name and type.
  536.  
  537.     # Delete all RRsets.
  538.     $packet->push(update => rr_del("host.example.com"));
  539.  
  540. Meaning:  Delete all RRs having the specified name.
  541.  
  542.     # Delete an RR.
  543.     $packet->push(update => rr_del("host.example.com A 10.1.2.3"));
  544.  
  545. Meaning:  Delete all RRs having the specified name, type, and data.
  546.  
  547. RR objects created by this method should be added to the "update"
  548. section of a dynamic update packet.
  549.  
  550. Returns a C<Net::DNS::RR> object or C<undef> if the object couldn't
  551. be created.
  552.  
  553. =head1 EXAMPLES
  554.  
  555. The following examples show how to use the C<Net::DNS> modules.
  556. See the other manual pages and the demo scripts included with the
  557. source code for additional examples.
  558.  
  559. See the C<Net::DNS::Update> manual page for an example of performing
  560. dynamic updates.
  561.  
  562. =head2 Look up a host's addresses.
  563.  
  564.   use Net::DNS;
  565.   my $res   = Net::DNS::Resolver->new;
  566.   my $query = $res->search("host.example.com");
  567.  
  568.   if ($query) {
  569.       foreach my $rr ($query->answer) {
  570.           next unless $rr->type eq "A";
  571.           print $rr->address, "\n";
  572.       }
  573.   } else {
  574.       warn "query failed: ", $res->errorstring, "\n";
  575.   }
  576.  
  577. =head2 Find the nameservers for a domain.
  578.  
  579.   use Net::DNS;
  580.   my $res   = Net::DNS::Resolver->new;
  581.   my $query = $res->query("example.com", "NS");
  582.  
  583.   if ($query) {
  584.       foreach $rr (grep { $_->type eq 'NS' } $query->answer) {
  585.           print $rr->nsdname, "\n";
  586.       }
  587.   }
  588.   else {
  589.       warn "query failed: ", $res->errorstring, "\n";
  590.   }
  591.  
  592. =head2 Find the MX records for a domain.
  593.  
  594.   use Net::DNS;
  595.   my $name = "example.com";
  596.   my $res  = Net::DNS::Resolver->new;
  597.   my @mx   = mx($res, $name);
  598.  
  599.   if (@mx) {
  600.       foreach $rr (@mx) {
  601.           print $rr->preference, " ", $rr->exchange, "\n";
  602.       }
  603.   } else {
  604.       warn "Can't find MX records for $name: ", $res->errorstring, "\n";
  605.   }
  606.  
  607.  
  608. =head2 Print a domain's SOA record in zone file format.
  609.  
  610.   use Net::DNS;
  611.   my $res   = Net::DNS::Resolver->new;
  612.   my $query = $res->query("example.com", "SOA");
  613.  
  614.   if ($query) {
  615.       ($query->answer)[0]->print;
  616.   } else {
  617.       print "query failed: ", $res->errorstring, "\n";
  618.   }
  619.  
  620. =head2 Perform a zone transfer and print all the records.
  621.  
  622.   use Net::DNS;
  623.   my $res  = Net::DNS::Resolver->new;
  624.   $res->nameservers("ns.example.com");
  625.  
  626.   my @zone = $res->axfr("example.com");
  627.  
  628.   foreach $rr (@zone) {
  629.       $rr->print;
  630.   }
  631.  
  632. =head2 Perform a background query and do some other work while waiting
  633. for the answer.
  634.  
  635.   use Net::DNS;
  636.   my $res    = Net::DNS::Resolver->new;
  637.   my $socket = $res->bgsend("host.example.com");
  638.  
  639.   until ($res->bgisready($socket)) {
  640.       # do some work here while waiting for the answer
  641.       # ...and some more here
  642.   }
  643.  
  644.   my $packet = $res->bgread($socket);
  645.   $packet->print;
  646.  
  647.  
  648. =head2 Send a background query and use select to determine when the answer
  649. has arrived.
  650.  
  651.   use Net::DNS;
  652.   use IO::Select;
  653.  
  654.   my $timeout = 5;
  655.   my $res     = Net::DNS::Resolver->new;
  656.   my $bgsock  = $res->bgsend("host.example.com");
  657.   my $sel     = IO::Select->new($bgsock);
  658.  
  659.   # Add more sockets to $sel if desired.
  660.   my @ready = $sel->can_read($timeout);
  661.   if (@ready) {
  662.       foreach my $sock (@ready) {
  663.           if ($sock == $bgsock) {
  664.               my $packet = $res->bgread($bgsock);
  665.               $packet->print;
  666.               $bgsock = undef;
  667.           }
  668.           # Check for the other sockets.
  669.           $sel->remove($sock);
  670.           $sock = undef;
  671.       }
  672.   } else {
  673.       warn "timed out after $timeout seconds\n";
  674.   }
  675.  
  676. =head1 BUGS
  677.  
  678. C<Net::DNS> is slow.
  679.  
  680. For other items to be fixed, please see the TODO file included with
  681. the source distribution.
  682.  
  683. =head1 COPYRIGHT
  684.  
  685. Copyright (c) 1997-2002 Michael Fuhr. 
  686.  
  687. Portions Copyright (c) 2002-2003 Chris Reinhardt.
  688.  
  689. All rights reserved.  This program is free software; you may redistribute
  690. it and/or modify it under the same terms as Perl itself.
  691.  
  692. =head1 AUTHOR INFORMATION
  693.  
  694. Net::DNS is currently maintained by a group, led by:
  695.     Chris Reinhardt
  696.     ctriv@net-dns.org
  697.  
  698. Net::DNS was created by:
  699.     Michael Fuhr
  700.     mike@fuhr.org
  701.  
  702. For more information see:
  703.     http://www.net-dns.org/
  704.  
  705. =head1 SEE ALSO
  706.  
  707. L<perl(1)>, L<Net::DNS::Resolver>, L<Net::DNS::Packet>, L<Net::DNS::Update>,
  708. L<Net::DNS::Header>, L<Net::DNS::Question>, L<Net::DNS::RR>, RFC 1035,
  709. I<DNS and BIND> by Paul Albitz & Cricket Liu
  710.  
  711. =cut
  712.