314 lines
8.7 KiB
Text
314 lines
8.7 KiB
Text
<?php
|
|
|
|
/*
|
|
Whois2.php PHP classes to conduct whois queries
|
|
|
|
Copyright (C)1999,2000 easyDNS Technologies Inc. & Mark Jeftovic
|
|
|
|
Maintained by Mark Jeftovic <markjr@easydns.com>
|
|
|
|
For the most recent version of this package:
|
|
|
|
http://www.easydns.com/~markjr/whois2/
|
|
|
|
This program is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU General Public License
|
|
as published by the Free Software Foundation; either version 2
|
|
of the License, or (at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
*/
|
|
|
|
class Whois {
|
|
// Full code and data version string (e.g. 'Whois2.php v3.01:16')
|
|
var $VERSION;
|
|
|
|
// This release of the package
|
|
var $CODE_VERSION = "3.0.1";
|
|
|
|
// Network Solutions registry server
|
|
var $NSI_REGISTRY = "whois.nsiregistry.net";
|
|
|
|
// Network Solutions registrar server (?)
|
|
var $NSI_REGISTRAR = "whois.networksolutions.com";
|
|
|
|
// Default WHOIS port
|
|
var $PORT = 43;
|
|
|
|
// Maximum number of retries on connection failure
|
|
var $RETRY = 0;
|
|
|
|
// Time to wait between retries
|
|
var $SLEEP = 2;
|
|
|
|
// Read buffer size (0 == char by char)
|
|
var $BUFFER = 0;
|
|
|
|
// Status response codes
|
|
var $STAT = array(
|
|
-1 => "error",
|
|
0 => "ready",
|
|
1 => "ok"
|
|
);
|
|
|
|
// Array to contain all query variables
|
|
var $Query = array(
|
|
"tld" => "",
|
|
"type" => "domain",
|
|
"string" => "",
|
|
"status",
|
|
"server"
|
|
);
|
|
|
|
// Various hacks. In a perfect world we don't need these.
|
|
var $HACKS = array(
|
|
// force "dom" keywork
|
|
"nsi_force_dom" => 1,
|
|
// set if nsiregistry gives wrong whois server for netsol
|
|
"nsi_referral_loop" => 0,
|
|
// ???
|
|
"wrong_netsol_whois" => "rs.internic.net",
|
|
// ???
|
|
"real_netsol_whois" => "whois.networksolutions.com",
|
|
// force english output on .jp for us ethnocentric types, unset or comment out for Japanese output
|
|
"force_slash_e" => "whois.nic.ad.jp",
|
|
// whois.nic.cx hangs forever
|
|
"cx_is_broken" => 1
|
|
);
|
|
|
|
// List of servers and handlers (loaded from servers.whois)
|
|
var $DATA = array();
|
|
|
|
/*
|
|
* Constructor function
|
|
*/
|
|
function Whois ($query = "") {
|
|
// Load DATA array
|
|
require("servers.whois");
|
|
|
|
// Set version
|
|
$this->VERSION = sprintf("Whois2.php v%s:%s", $this->CODE_VERSION, $this->DATA_VERSION);
|
|
|
|
// If domain to query was not set
|
|
if(!isSet($query)) {
|
|
// Configure to use default whois server
|
|
$this->Query["server"] = $this->NSI_REGISTRY;
|
|
return;
|
|
}
|
|
|
|
// Set domain to query in query array
|
|
$this->Query["string"] = strtolower($query);
|
|
|
|
// Determine top level whois server
|
|
$tld = $this->GetTld($this->Query["string"]);
|
|
if($tld) {
|
|
// If found, set tld and whois server in query array
|
|
$this->Query["server"] = $this->DATA[$tld][0];
|
|
$this->Query["tld"] = $tld;
|
|
|
|
// If a handler exists for the tld
|
|
if(isSet($this->DATA[$tld][1])) {
|
|
// Set fle/handler in query array
|
|
$handler = $this->DATA[$tld][1];
|
|
$this->Query["file"] = sprintf("%s.whois", $handler);
|
|
$this->Query["handler"] = $handler;
|
|
}
|
|
return;
|
|
}
|
|
|
|
// If top level domain not known, check availability in DNS
|
|
if(checkdnsrr($query, "A")) {
|
|
// Prepare to do lookup via the 'ipw' handler
|
|
$ip = gethostbyname($query);
|
|
$this->Query["server"] = "whois.arin.net";
|
|
$this->Query["host_ip"] = $ip;
|
|
$this->Query["file"] = "ipw.whois";
|
|
$this->Query["handler"] = "ipw";
|
|
$this->Query["string"] = $ip;
|
|
$this->Query["tld"] = "ipw";
|
|
|
|
// If query was an IP, determine the hostname
|
|
if ($query==$ip)
|
|
$this->Query["host_name"] = gethostbyaddr($ip);
|
|
else
|
|
$this->Query["host_name"] = $query;
|
|
|
|
return;
|
|
}
|
|
|
|
// If tld not known, and domain not in DNS, return error
|
|
unset($this->Query["server"]);
|
|
$this->Query["status"] = -1;
|
|
$this->Query["errstr"][] = $this->Query["string"]." domain is not supported";
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Open a socket to the whois server.
|
|
*
|
|
* Returns a socket connection pointer on success, or -1 on failure.
|
|
*/
|
|
function Connect () {
|
|
// Fail if server not set
|
|
if(!isSet($this->Query["server"]))
|
|
return(-1);
|
|
|
|
// Enter connection attempt loop
|
|
$server = $this->Query["server"];
|
|
$retry = 0;
|
|
while($retry <= $this->RETRY) {
|
|
// Set query status
|
|
$this->Query["status"] = "ready";
|
|
|
|
// Connect to whois port
|
|
$ptr = fsockopen($server, $this->PORT);
|
|
if($ptr > 0) {
|
|
$this->Query["status"]="ok";
|
|
return($ptr);
|
|
}
|
|
|
|
// Failed this attempt
|
|
$this->Query["status"] = "error";
|
|
$retry++;
|
|
|
|
// Sleep before retrying
|
|
sleep($this->SLEEP);
|
|
}
|
|
|
|
// If we get this far, it hasn't worked
|
|
return(-1);
|
|
}
|
|
|
|
/*
|
|
* Post-process result with handler class. On success, returns the result
|
|
* from the handler. On failure, returns passed in result unaltered.
|
|
*/
|
|
function Process (&$result) {
|
|
// Disable error reporting temporarily (probably not necessary)
|
|
$old_val = error_reporting(FALSE);
|
|
|
|
// If the handler has not already been included somehow, include it now
|
|
$HANDLER_FLAG = sprintf("__%s_HANDLER__", strtoupper($this->Query["handler"]));
|
|
if(!defined($HANDLER_FLAG))
|
|
include($this->Query["file"]);
|
|
|
|
// Restore error reporting
|
|
error_reporting($old_val);
|
|
|
|
// If the handler has still not been included, append to query errors list and return
|
|
if(!defined($HANDLER_FLAG)) {
|
|
$this->Query["errstr"][] = "Can't find ".$this->Query["tld"]." handler: ".$this->Query["file"];
|
|
return($result);
|
|
}
|
|
|
|
// Pass result to handler
|
|
$object = $this->Query["handler"];
|
|
$handler = new $object($result, $this->Query);
|
|
|
|
// If handler returned an error, append it to the query errors list
|
|
if(isSet($handler->Query["errstr"]))
|
|
$this->Query["errstr"][] = $handler->Query["errstr"];
|
|
|
|
// Return the result
|
|
return($handler->result);
|
|
}
|
|
|
|
/*
|
|
* Perform lookup. Returns an array. The 'rawdata' element contains an
|
|
* array of lines gathered from the whois query. If a top level domain
|
|
* handler class was found for the domain, other elements will have been
|
|
* populated too.
|
|
*/
|
|
function Lookup ($query = "") {
|
|
// If domain to query passed in, use it, otherwise use domain from initialisation
|
|
$string = !empty($query) ? $query : $this->Query["string"];
|
|
|
|
// If the '.cx' whois server is broken, return an error now (saves attempting and timing out)
|
|
if($this->HACKS["cx_is_broken"] && $this->Query["tld"] == "cx") {
|
|
$this->Query["errstr"][] = ".cx doesn't work. Turn off HACKS[\"cx_is_broken\"] if ".$this->Query["server"]." finally got fixed.";
|
|
return("");
|
|
}
|
|
|
|
// Connect to whois server, or return if failed
|
|
$ptr = $this->Connect();
|
|
if($ptr < 0) {
|
|
$this->Query["status"] = -1;
|
|
$this->Query["errstr"][] = "Connect failed to: ".$this->Query["server"];
|
|
return(array());
|
|
}
|
|
|
|
// Determining on server/hacks in operation, send appropriate request
|
|
if(($this->Query["server"] == $this->NSI_REGISTRY || $this->Query["server"] == $this->NSI_REGISTRAR) && $this->HACKS["nsi_force_dom"]) {
|
|
fputs($ptr, sprintf("dom %s\r\n", trim($string)));
|
|
}
|
|
elseif($this->Query["server"] == $this->HACKS["force_slash_e"]) {
|
|
fputs($ptr, sprintf("%s/e\r\n", trim($string)));
|
|
}
|
|
else {
|
|
fputs($ptr, sprintf("%s\r\n", trim($string)));
|
|
}
|
|
|
|
// Prepare to receive result
|
|
$raw = "";
|
|
$output = array();
|
|
while(!feof($ptr)) {
|
|
// If a buffer size is set, fetch line-by-line into an array
|
|
if($this->BUFFER)
|
|
$output[] = fgets($ptr, $this->BUFFER);
|
|
// If not, fetch char-by-char into a string
|
|
else
|
|
$raw .= fgetc($ptr);
|
|
}
|
|
|
|
// If captured char-by-char, convert to an array of lines
|
|
if(!$this->BUFFER)
|
|
$output = explode("\n", $raw);
|
|
|
|
// Drop empty last line
|
|
unset($output[count($output)-1]);
|
|
|
|
// Create result and set 'rawdata'
|
|
$result = array();
|
|
$result['rawdata'] = $output;
|
|
|
|
// If we have a handler, post-process it with that
|
|
if(isSet($this->DATA[$this->Query["tld"]][1]))
|
|
$result = $this->Process($result);
|
|
|
|
return($result);
|
|
}
|
|
|
|
/*
|
|
* Determine top-level whois server for a given domain
|
|
*/
|
|
function GetTld ($domain) {
|
|
// Loop through server/tld list
|
|
reset($this->DATA);
|
|
$curr_match = "";
|
|
while(list($tld, $param) = each($this->DATA)) {
|
|
// If the tld matches the end of the given domain
|
|
if(eregi("\.$tld$", $domain)) {
|
|
// If we have already found a match
|
|
if(!empty($curr_match)) {
|
|
// FIXME: we assume we'll never support a 3rd
|
|
// level registry. If we do, this breaks.
|
|
$curr_match = strchr($tld,".") ? $tld : $curr_match;
|
|
}
|
|
else
|
|
$curr_match = $tld;
|
|
}
|
|
}
|
|
|
|
return($curr_match);
|
|
}
|
|
|
|
}
|
|
|
|
?>
|