home *** CD-ROM | disk | FTP | other *** search
/ PC World 2001 August / PCWorld_2001-08_cd.bin / Komunikace / phptriad / phptriadsetup2-11.exe / php / pear / Net / Dig.php < prev    next >
PHP Script  |  2001-03-12  |  10KB  |  446 lines
  1. <?php
  2. //
  3. // +----------------------------------------------------------------------+
  4. // | PHP version 4.0                                                      |
  5. // +----------------------------------------------------------------------+
  6. // | Copyright (c) 1997-2001 The PHP Group                                |
  7. // +----------------------------------------------------------------------+
  8. // | This source file is subject to version 2.02 of the PHP license,      |
  9. // | that is bundled with this package in the file LICENSE, and is        |
  10. // | available at through the world-wide-web at                           |
  11. // | http://www.php.net/license/2_02.txt.                                 |
  12. // | If you did not receive a copy of the PHP license and are unable to   |
  13. // | obtain it through the world-wide-web, please send a note to          |
  14. // | license@php.net so we can mail you a copy immediately.               |
  15. // +----------------------------------------------------------------------+
  16. // | Authors: Colin Viebrock <colin@easyDNS.com>                          |
  17. // +----------------------------------------------------------------------+
  18. //
  19. // $Id: Dig.php,v 1.1 2001/03/12 19:30:56 cmv Exp $
  20. //
  21. // A nice friendly OO interface to dig
  22. //
  23. require_once('PEAR.php');
  24.  
  25. class Net_Dig extends PEAR
  26. {
  27.     // {{{ Public Properties
  28.     
  29.     /**
  30.      * The address to dig
  31.      *
  32.      * @var string $address
  33.      * @access public
  34.      */
  35.     var $address;
  36.     
  37.     /**
  38.      * The server to use for digging
  39.      *
  40.      * @var string $server
  41.      * @access public
  42.      */
  43.     var $server;
  44.     
  45.     /**
  46.      * The type of DNS records to dig for
  47.      *
  48.      * @var string $query_type
  49.      * @access public
  50.      */
  51.     var $query_type;
  52.  
  53.     /**
  54.      * The last system command executed (for debugging)
  55.      *
  56.      * @var string $cmd
  57.      * @access public
  58.      */
  59.     var $cmd;
  60.  
  61.     /**
  62.      * The raw output of the system command (for debugging)
  63.      *
  64.      * @var string $raw_data
  65.      * @access public
  66.      */
  67.     var $raw_data;
  68.  
  69.     /**
  70.      * The location of the system dig program
  71.      *
  72.      * @var string $dig_prg
  73.      * @access public
  74.      */
  75.     var $dig_prog;
  76.  
  77.     /**
  78.      * The parsed result of the last dig
  79.      *
  80.      * @var string $result
  81.      * @access public
  82.      */
  83.     var $result;
  84.     
  85.     // }}}
  86.  
  87.  
  88.     // {{{ Net_Dig()
  89.     
  90.     /**
  91.      * The Net_Dig constructor
  92.          * Called when a new Net_Dig object is initialized
  93.      *
  94.      * @param string           [$address] The address to dig (can be set 
  95.      *                                using the $address property as well)
  96.      *
  97.      * @return object Net_Dig   $obj   A new Net_Dig object
  98.      *
  99.      * @access public
  100.      * @author Colin Viebrock <colin@easyDNS.com>
  101.      * @since  PHP 4.0.5
  102.      */
  103.     function Net_Dig($address = false)
  104.     {
  105.  
  106.         $this->address = $address;
  107.         $this->server = false;
  108.         $this->query_type = false;
  109.  
  110.         $this->cmd = '';
  111.         $this->raw_data = '';
  112.  
  113.         $this->result = false;
  114.  
  115.         $this->dig_prog = trim(`which dig`);
  116.         if (!$this->dig_prog) {
  117.             $this = new PEAR_Error("Couldn't find system dig program");
  118.         }
  119.  
  120.     }
  121.  
  122.     // }}}
  123.  
  124.  
  125.  
  126.     // {{{ dig()
  127.     
  128.     /**
  129.      * Does a dig of the given address (or $this->address)
  130.      *
  131.      * @param string           [$address] The address to dig (can be set 
  132.      *                                using the $address property as well)
  133.      *
  134.      * @return object Net_Dig_result    $obj   A new Net_Dig_result object
  135.      *
  136.      * @access public
  137.      * @author Colin Viebrock <colin@easyDNS.com>
  138.      * @since  PHP 4.0.5
  139.      */
  140.     function dig($address=false)
  141.     {
  142.  
  143.         if ($address) {
  144.             $this->address = $address;
  145.         }
  146.  
  147.         if (!$this->address) {
  148.             return new PEAR_Error("No address specified");
  149.         }
  150.  
  151.         if (!$this->_validate_type()) {
  152.             return new PEAR_Error($this->query_type." is an invalid query type");
  153.         }
  154.  
  155.         $cmd = escapeshellcmd(
  156.             sprintf("%s %s %s %s",
  157.                 $this->dig_prog,
  158.                 ($this->server        ? '@'.$this->server : ''),
  159.                 $this->address,
  160.                 ($this->query_type    ? $this->query_type : '' )
  161.             )
  162.         );
  163.  
  164.         $this->cmd = $cmd;
  165.  
  166.  
  167.         $this->raw_data = `$cmd`;
  168.         $this->raw_data = trim(    $this->raw_data );
  169.  
  170.         return $this->_parse_data();
  171.  
  172.     }
  173.     
  174.     // }}}
  175.  
  176.  
  177.     // {{{ _validate_type()
  178.     
  179.     /**
  180.      * Validates the value of $this->query_type
  181.      *
  182.      * @return boolean    $return   True if $this->query_type is a 
  183.      *                                valid dig query, otherwise false
  184.      *
  185.      * @access private
  186.      * @author Colin Viebrock <colin@easyDNS.com>
  187.      * @since  PHP 4.0.5
  188.      */
  189.     function _validate_type()
  190.     {
  191.         $return = true;
  192.         if ($this->query_type) {
  193.             $this->query_type = strtolower($this->query_type);
  194.             switch ($this->query_type) {
  195.                 case 'a':
  196.                 case 'any':
  197.                 case 'mx':
  198.                 case 'ns':
  199.                 case 'soa':
  200.                 case 'hinfo':
  201.                 case 'axfr':
  202.                 case 'txt':
  203.                 break;
  204.                 default:
  205.                 $return = false;
  206.             }
  207.         }
  208.         return $return;
  209.     }
  210.     
  211.     // }}}
  212.  
  213.  
  214.  
  215.     // {{{ _parse_data()
  216.     
  217.     /**
  218.      * Parses the raw data in $this->raw_data
  219.      *
  220.      * @return obj Net_Dig_result  $return   A Net_Dig_result object
  221.      *
  222.      * @access private
  223.      * @author Colin Viebrock <colin@easyDNS.com>
  224.      * @since  PHP 4.0.5
  225.      */
  226.     function _parse_data()
  227.     {
  228.  
  229.         if (!$this->raw_data) {
  230.             return new PEAR_Error("No raw data to parse");
  231.         }
  232.  
  233.         $regex = '/' .
  234.             '^;(.*?)' .
  235.             ';; QUESTION SECTION\:(.*?)' .
  236.             '(;; ANSWER SECTION\:(.*?))?' .
  237.             '(;; AUTHORITY SECTION\:(.*?))?' .
  238.             '(;; ADDITIONAL SECTION\:(.*?))?' .
  239.             '(;;.*)' .
  240.             '/ims';
  241.  
  242.         if (preg_match($regex, $this->raw_data, $matches)) {
  243.  
  244.             $result = new Net_Dig_result;
  245.  
  246.             /* Start parsing the data */
  247.  
  248.  
  249.             /* the header ... */
  250.  
  251.  
  252.             $temp = explode("\n", trim($matches[1]));
  253.             if (preg_match('/DiG (.*?) /i', $temp[0], $m)) {
  254.                 $result->dig_version         = trim($m[1]);
  255.             }
  256.             if (preg_match('/status: (.*?), id: (.*?)$/i', $temp[3], $m)) {
  257.                 $result->status            = trim($m[1]);
  258.                 $result->id            = trim($m[2]);
  259.             }
  260.  
  261.             if (preg_match('/flags: (.*?); query: (.*?), answer: (.*?), authority: (.*?), additional: (.*?)$/i', $temp[4], $m)) {
  262.                 $result->flags            = trim($m[1]);
  263.                 $result->query_count        = (int)trim($m[2]);
  264.                 $result->answer_count        = (int)trim($m[3]);
  265.                 $result->authority_count    = (int)trim($m[4]);
  266.                 $result->additional_count    = (int)trim($m[5]);
  267.             }
  268.  
  269.  
  270.             /* query section */
  271.  
  272.             $line = trim(preg_replace('/^(;*)/', '', trim($matches[2])));
  273.             list($host, $class, $type) = preg_split('/[\s]+/', $line, 3);
  274.             $result->query[] = new Net_Dig_resource($host, false, $class, $type, false);
  275.  
  276.  
  277.             /* answer section */
  278.  
  279.             $temp = trim($matches[4]);
  280.             if ($temp) {
  281.                 $temp = explode("\n", $temp);
  282.                 if (count($temp)) {
  283.                     foreach($temp as $line) {
  284.                         $result->answer[] = $this->_parse_resource($line);
  285.                     }
  286.                 }
  287.             }
  288.  
  289.  
  290.             /* authority section */
  291.  
  292.             $temp = trim($matches[6]);
  293.             if ($temp) {
  294.                 $temp = explode("\n", $temp);
  295.                 if (count($temp)) {
  296.                     foreach($temp as $line) {
  297.                         $result->authority[] = $this->_parse_resource($line);
  298.                     }
  299.                 }
  300.             }
  301.  
  302.  
  303.             /* additional section */
  304.  
  305.             $temp = trim($matches[8]);
  306.             if ($temp) {
  307.                 $temp = explode("\n", $temp);
  308.                 if (count($temp)) {
  309.                     foreach($temp as $line) {
  310.                         $result->additional[] = $this->_parse_resource($line);
  311.                     }
  312.                 }
  313.             }
  314.  
  315.             /* footer */
  316.  
  317.             $temp = explode("\n", trim($matches[9]));
  318.             if (preg_match('/query time: (.*?)$/i', $temp[0], $m)) {
  319.                 $result->query_time    = trim($m[1]);
  320.             }
  321.             if (preg_match('/server: (.*?)#(.*?)\(/i', $temp[1], $m)) {
  322.                 $result->dig_server    = trim($m[1]);
  323.                 $result->dig_port    = trim($m[2]);
  324.             }
  325.  
  326.             /* done */
  327.  
  328.             $result->consistency_check = (
  329.                 (count($result->query) == $result->query_count) &&
  330.                 (count($result->answer) == $result->answer_count) &&
  331.                 (count($result->authority) == $result->authority_count) &&
  332.                 (count($result->additional) == $result->additional_count)
  333.             );
  334.  
  335.             return $result;
  336.  
  337.         }
  338.  
  339.         return new PEAR_Error("Can't parse raw data");
  340.     }
  341.     
  342.     // }}}
  343.  
  344.  
  345.     // {{{ _parse_resource()
  346.     
  347.     /**
  348.      * Parses a resource record line
  349.      *
  350.      * @param string           $line    The line to parse
  351.      *
  352.      * @return obj Net_Dig_resource  $return   A Net_Dig_resource object
  353.      *
  354.      * @access private
  355.      * @author Colin Viebrock <colin@easyDNS.com>
  356.      * @since  PHP 4.0.5
  357.      */
  358.     function _parse_resource($line)
  359.     {
  360.  
  361.         /* trim and remove leading ;, if present */        
  362.  
  363.         $line = trim(preg_replace('/^(;*)/', '', trim($line)));
  364.  
  365.         if ($line) {
  366.             list($host, $ttl, $class, $type, $data) = preg_split('/[\s]+/', $line, 5);
  367.             return new Net_Dig_resource($host, $ttl, $class, $type, $data);
  368.         }
  369.  
  370.         return false;
  371.  
  372.     }
  373.  
  374.     // }}}
  375.  
  376. }
  377.  
  378.  
  379.  
  380. class Net_Dig_result {
  381.  
  382.     // {{{ Public Properties
  383.  
  384.     var $status;
  385.     var $id;
  386.     var $flags;
  387.     var $query_count;
  388.     var $answer_count;
  389.     var $authority_count;
  390.     var $additional_count;
  391.  
  392.     var $dig_version;
  393.     var $dig_server;
  394.     var $dig_port;
  395.  
  396.     var $query;
  397.     var $answer;
  398.     var $authority;
  399.     var $additional;
  400.  
  401.     var $consistency_check;
  402.  
  403.     function Net_Dig_result() {
  404.         $this->status = false;
  405.         $this->id = false;
  406.         $this->flags = false;
  407.         $this->query_count = false;
  408.         $this->answer_count = false;
  409.         $this->authority_count = false;
  410.         $this->additional_count = false;
  411.  
  412.         $this->dig_version = false;
  413.         $this->dig_server = false;
  414.         $this->dig_port = false;
  415.  
  416.         $this->query = array();
  417.         $this->answer = array();
  418.         $this->authority = array();
  419.         $this->additional = array();
  420.  
  421.         $this->consistency_check = false;
  422.  
  423.     }
  424.  
  425. }
  426.  
  427. class Net_Dig_resource {
  428.  
  429.     var $host;
  430.     var $ttl;
  431.     var $class;
  432.     var $type;
  433.     var $data;
  434.  
  435.     function Net_Dig_resource($host=false, $ttl=false, $class=false, $type=false, $data=false) {
  436.         $this->host    = $host;
  437.         $this->ttl    = $ttl;
  438.         $this->class    = $class;
  439.         $this->type    = $type;
  440.         $this->data    = $data;
  441.     }
  442.  
  443. }
  444.  
  445. ?>
  446.