Net_DNS2
[ class tree: Net_DNS2 ] [ index: Net_DNS2 ] [ all elements ]

Source for file Resolver.php

Documentation is available at Resolver.php

  1. <?php
  2. /* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
  3.  
  4. /**
  5.  * DNS Library for handling lookups and updates.
  6.  *
  7.  * PHP Version 5
  8.  *
  9.  * Copyright (c) 2010, Mike Pultz <mike@mikepultz.com>.
  10.  * All rights reserved.
  11.  *
  12.  * Redistribution and use in source and binary forms, with or without
  13.  * modification, are permitted provided that the following conditions
  14.  * are met:
  15.  *
  16.  *   * Redistributions of source code must retain the above copyright
  17.  *     notice, this list of conditions and the following disclaimer.
  18.  *
  19.  *   * Redistributions in binary form must reproduce the above copyright
  20.  *     notice, this list of conditions and the following disclaimer in
  21.  *     the documentation and/or other materials provided with the
  22.  *     distribution.
  23.  *
  24.  *   * Neither the name of Mike Pultz nor the names of his contributors
  25.  *     may be used to endorse or promote products derived from this
  26.  *     software without specific prior written permission.
  27.  *
  28.  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  29.  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  30.  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  31.  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  32.  * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  33.  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  34.  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  35.  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  36.  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRIC
  37.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
  38.  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  39.  * POSSIBILITY OF SUCH DAMAGE.
  40.  *
  41.  * @category  Networking
  42.  * @package   Net_DNS2
  43.  * @author    Mike Pultz <mike@mikepultz.com>
  44.  * @copyright 2010 Mike Pultz <mike@mikepultz.com>
  45.  * @license   http://www.opensource.org/licenses/bsd-license.php  BSD License
  46.  * @version   SVN: $Id: Resolver.php 191 2013-04-07 23:28:20Z mike.pultz $
  47.  * @link      http://pear.php.net/package/Net_DNS2
  48.  * @since     File available since Release 0.6.0
  49.  *
  50.  */
  51.  
  52. /**
  53.  * This is the main resolver class, providing DNS query functions.
  54.  *
  55.  * @category Networking
  56.  * @package  Net_DNS2
  57.  * @author   Mike Pultz <mike@mikepultz.com>
  58.  * @license  http://www.opensource.org/licenses/bsd-license.php  BSD License
  59.  * @link     http://pear.php.net/package/Net_DNS2
  60.  * @see      Net_DNS2
  61.  *
  62.  */
  63. class Net_DNS2_Resolver extends Net_DNS2
  64. {
  65.     /**
  66.      * Constructor - creates a new Net_DNS2_Resolver object
  67.      *
  68.      * @param mixed $options either an array with options or null
  69.      *
  70.      * @access public
  71.      *
  72.      */
  73.     public function __construct(array $options = null)
  74.     {
  75.         parent::__construct($options);
  76.     }
  77.  
  78.     /**
  79.      * does a basic DNS lookup query
  80.      *
  81.      * @param string $name  the DNS name to loookup
  82.      * @param string $type  the name of the RR type to lookup
  83.      * @param string $class the name of the RR class to lookup
  84.      *
  85.      * @return Net_DNS_RR object
  86.      * @throws Net_DNS2_Exception
  87.      * @access public
  88.      *
  89.      */
  90.     public function query($name$type 'A'$class 'IN')
  91.     {
  92.         //
  93.         // make sure we have some name servers set
  94.         //
  95.         $this->checkServers(Net_DNS2::RESOLV_CONF);
  96.  
  97.         //
  98.         // we dont' support incremental zone tranfers; so if it's requested, a full
  99.         // zone transfer can be returned
  100.         //
  101.         if ($type == 'IXFR'{
  102.  
  103.             $type 'AXFR';
  104.         }
  105.  
  106.         //
  107.         // if the name *looks* too short, then append the domain from the config
  108.         //
  109.         if ( (strpos($name'.'=== false&& ($type != 'PTR') ) {
  110.  
  111.             $name .= '.' strtolower($this->domain);
  112.         }
  113.  
  114.         //
  115.         // create a new packet based on the input
  116.         //
  117.         $packet = new Net_DNS2_Packet_Request($name$type$class);
  118.  
  119.         //
  120.         // check for an authentication method; either TSIG or SIG
  121.         //
  122.         if (   ($this->auth_signature instanceof Net_DNS2_RR_TSIG)
  123.             || ($this->auth_signature instanceof Net_DNS2_RR_SIG)
  124.         {
  125.             $packet->additional[]       $this->auth_signature;
  126.             $packet->header->arcount    = count($packet->additional);
  127.         }
  128.  
  129.         //
  130.         // check for the DNSSEC flag, and if it's true, then add an OPT
  131.         // RR to the additional section, and set the DO flag to 1.
  132.         //
  133.         if ($this->dnssec == true{
  134.  
  135.             //
  136.             // create a new OPT RR
  137.             //
  138.             $opt = new Net_DNS2_RR_OPT();
  139.  
  140.             //
  141.             // set the DO flag, and the other values
  142.             //
  143.             $opt->do = 1;
  144.             $opt->class = $this->dnssec_payload_size;
  145.  
  146.             //
  147.             // add the RR to the additional section.
  148.             //
  149.             $packet->additional[$opt;
  150.             $packet->header->arcount = count($packet->additional);
  151.         }
  152.  
  153.         //
  154.         // set the DNSSEC AD or CD bits
  155.         //
  156.         if ($this->dnssec_ad_flag == true{
  157.  
  158.             $packet->header->ad = 1;
  159.         }
  160.         if ($this->dnssec_cd_flag == true{
  161.  
  162.             $packet->header->cd = 1;
  163.         }
  164.  
  165.         //
  166.         // if caching is turned on, then check then hash the question, and
  167.         // do a cache lookup.
  168.         //
  169.         // don't use the cache for zone transfers
  170.         //
  171.         $packet_hash '';
  172.  
  173.         if ( ($this->use_cache == true&& ($this->cacheable($type== true) ) {
  174.  
  175.             //
  176.             // open the cache
  177.             //
  178.             $this->cache->open(
  179.                 $this->cache_file$this->cache_size$this->cache_serializer
  180.             );
  181.  
  182.             //
  183.             // build the key and check for it in the cache.
  184.             //
  185.             $packet_hash md5(
  186.                 $packet->question[0]->qname . '|' $packet->question[0]->qtype
  187.             );
  188.  
  189.             if ($this->cache->has($packet_hash)) {
  190.  
  191.                 return $this->cache->get($packet_hash);
  192.             }
  193.         }
  194.  
  195.         //
  196.         // set the RD (recursion desired) bit to 1 / 0 depending on the config
  197.         // setting.
  198.         //
  199.         if ($this->recurse == false{
  200.             $packet->header->rd = 0;
  201.         else {
  202.             $packet->header->rd = 1;
  203.         }
  204.  
  205.         //
  206.         // send the packet and get back the response
  207.         //
  208.         // *always* use TCP for zone transfers- does this cause any problems?
  209.         //
  210.         $response $this->sendPacket(
  211.             $packet($type == 'AXFR'? true : $this->use_tcp
  212.         );
  213.  
  214.         //
  215.         // if strict mode is enabled, then make sure that the name that was
  216.         // looked up is *actually* in the response object.
  217.         //
  218.         // only do this is strict_query_mode is turned on, AND we've received
  219.         // some answers; no point doing any else if there were no answers.
  220.         //
  221.         if ( ($this->strict_query_mode == true
  222.             && ($response->header->ancount > 0
  223.         {
  224.  
  225.             $found = false;
  226.  
  227.             //
  228.             // look for the requested name/type/class
  229.             //
  230.             foreach ($response->answer as $index => $object{
  231.  
  232.                 if ( (strcasecmp($object->name$name== 0)
  233.                     && ($object->type == $type)
  234.                     && ($object->class == $class)
  235.                 {
  236.                     $found = true;
  237.                     break;
  238.                 }
  239.             }
  240.  
  241.             //
  242.             // if it's not found, then unset the answer section; it's not correct to
  243.             // throw an exception here; if the hostname didn't exist, then 
  244.             // sendPacket() would have already thrown an NXDOMAIN error- so the host 
  245.             // *exists*, but just not the request type/class.
  246.             //
  247.             // the correct response in this case, is an empty answer section; the
  248.             // authority section may still have usual information, like a SOA record.
  249.             //
  250.             if ($found == false{
  251.                 
  252.                 $response->answer = array();
  253.                 $response->header->ancount = 0;
  254.             }
  255.         }
  256.  
  257.         //
  258.         // cache the response object
  259.         //
  260.         if ( ($this->use_cache == true&& ($this->cacheable($type== true) ) {
  261.  
  262.             $this->cache->put($packet_hash$response);
  263.         }
  264.  
  265.         return $response;
  266.     }
  267.  
  268.     /**
  269.      * does an inverse query for the given RR; most DNS servers do not implement
  270.      * inverse queries, but they should be able to return "not implemented"
  271.      *
  272.      * @param Net_DNS2_RR $rr the RR object to lookup
  273.      * 
  274.      * @return Net_DNS_RR object
  275.      * @throws Net_DNS2_Exception
  276.      * @access public
  277.      *
  278.      */
  279.     public function iquery(Net_DNS2_RR $rr)
  280.     {
  281.         //
  282.         // make sure we have some name servers set
  283.         //
  284.         $this->checkServers(Net_DNS2::RESOLV_CONF);
  285.  
  286.         //
  287.         // create an empty packet
  288.         //
  289.         $packet = new Net_DNS2_Packet_Request($rr->name'A''IN');
  290.  
  291.         //
  292.         // unset the question
  293.         //
  294.         $packet->question = array();
  295.         $packet->header->qdcount = 0;
  296.  
  297.         //
  298.         // set the opcode to IQUERY
  299.         //
  300.         $packet->header->opcode = Net_DNS2_Lookups::OPCODE_IQUERY;
  301.  
  302.         //
  303.         // add the given RR as the answer
  304.         //
  305.         $packet->answer[$rr;
  306.         $packet->header->ancount = 1;
  307.  
  308.         //
  309.         // check for an authentication method; either TSIG or SIG
  310.         //
  311.         if (   ($this->auth_signature instanceof Net_DNS2_RR_TSIG)
  312.             || ($this->auth_signature instanceof Net_DNS2_RR_SIG)
  313.         {
  314.             $packet->additional[]       $this->auth_signature;
  315.             $packet->header->arcount    = count($packet->additional);
  316.         }
  317.  
  318.         //
  319.         // send the packet and get back the response
  320.         //
  321.         return $this->sendPacket($packet$this->use_tcp);
  322.     }
  323. }
  324.  
  325. /*
  326.  * Local variables:
  327.  * tab-width: 4
  328.  * c-basic-offset: 4
  329.  * c-hanging-comment-ender-p: nil
  330.  * End:
  331.  */
  332. ?>

Documentation generated on Sun, 01 Dec 2013 01:30:20 +0000 by phpDocumentor 1.4.3. PEAR Logo Copyright © PHP Group 2004.