Provided by: libnet-dns-resolver-programmable-perl_0.009-1_all bug


       Net::DNS::Resolver::Programmable - programmable DNS resolver class for offline emulation
       of DNS


           use Net::DNS::Resolver::Programmable;
           use Net::DNS::RR;

           my $resolver = Net::DNS::Resolver::Programmable->new(
               records         => {
                   ''     => [
                       Net::DNS::RR->new('     NS'),
                       Net::DNS::RR->new('     A')
                   ''  => [
                       Net::DNS::RR->new('  A')

               resolver_code   => sub {
                   my ($domain, $rr_type, $class) = @_;
                   return ($result, $aa, @rrs);


       Net::DNS::Resolver::Programmable is a Net::DNS::Resolver descendant class that allows a
       virtual DNS to be emulated instead of querying the real DNS.  A set of static DNS records
       may be supplied, or arbitrary code may be specified as a means for retrieving DNS records,
       or even generating them on the fly.

       The following constructor is provided:

       new(%options): returns Net::DNS::Resolver::Programmable
           Creates a new programmed DNS resolver object.

           %options is a list of key/value pairs representing any of the following options:

               A reference to a hash of arrays containing a static set of Net::DNS::RR objects.
               The hash entries must be indexed by fully qualified domain names (lower-case,
               without any trailing dots), and the entries themselves must be arrays of the RR
               objects pertaining to these domain names.  For example:

                   records => {
                       ''     => [
                           Net::DNS::RR->new('     NS'),
                           Net::DNS::RR->new('     A')
                       '' => [
                           Net::DNS::RR->new(' A')
                       ''  => [
                           Net::DNS::RR->new('  A')

               If this option is specified, the resolver retrieves requested RRs from this data

               A code reference used as a call-back for dynamically retrieving requested RRs.

               The code must take the following query parameters as arguments: the domain, RR
               type, and class.

               It must return a list composed of: the response's RCODE (by name, as returned by
               Net::DNS::Header->rcode), the "aa" (authoritative answer) flag (boolean, use undef
               if you don't care), and the Net::DNS::RR answer objects.  If an error string is
               returned instead of a valid RCODE, a Net::DNS::Packet object is not constructed
               but an error condition for the resolver is signaled instead.

               For example:

                   resolver_code => sub {
                       my ($domain, $rr_type, $class) = @_;
                       return ($result, $aa, @rrs);

               If both this and the "records" option are specified, then statically programmed
               records are used in addition to any that are returned by the configured resolver

               These Net::DNS::Resolver options are also meaningful with
               Net::DNS::Resolver::Programmable.  See Net::DNS::Resolver for their descriptions.

   Instance methods
       The following instance methods of Net::DNS::Resolver are also supported by

       search: returns Net::DNS::Packet
       query: returns Net::DNS::Packet
       send: returns Net::DNS::Packet
           Performs an offline DNS query, using the statically programmed DNS RRs and/or the
           configured dynamic resolver code.  See the "new" constructor's "records" and
           "resolver_code" options.  See the descriptions of search, query, and send for details
           about the calling syntax of these methods.

       string: returns string
       searchlist: returns list of string
       defnames: returns boolean
       dnsrch: returns boolean
       debug: returns boolean
       errorstring: returns string
       answerfrom: returns string
       answersize: returns integer
           See "METHODS" in Net::DNS::Resolver.

       Currently the following methods of Net::DNS::Resolver are not supported: axfr, axfr_start,
       axfr_next, nameservers, port, srcport, srcaddr, bgsend, bgread, bgisready, tsig, retrans,
       retry, recurse, usevc, tcp_timeout, udp_timeout, persistent_tcp, persistent_udp, igntc,
       dnssec, cdflag, udppacketsize.  The effects of using these on
       Net::DNS::Resolver::Programmable objects are undefined.



       For availability, support, and license information, see the README file included with


       David Precious (BIGPRESH) "<>" took on maintainership in July 2017

       Original author Julian Mehnle "<>"


       Dick Franks (rwfranks)

       (This section was added by BIGPRESH in July 2017, so currently omits acknowledgements for
       those who contributed things in the past; I may retrospectively add them in future.)