[Last Call] Learn how to a build a cloud-first strategyRegister Now

x
  • Status: Solved
  • Priority: Medium
  • Security: Public
  • Views: 343
  • Last Modified:

How to use this function in conjunction with a html form?

Hi Folks, I have a function which I need to feed an array. Now I'd like to use a textbox in which I can paste some domains after which I can press a button and get the results. I pasted some code which I started with.

Regards,

Peter
<?php
 
require_once "Whois.php";
 
if   ( $_REQUEST["SUBMIT"]  )
/* If SUBMIT button is pressed start validation */
 
{
 function my_whois($array)
{
 
   $answers = array();
   $server = "whois.denic.de";
   foreach ($array as $query)
   {
      $whois = new Net_Whois;
      $answers["$query"] = $whois->query($query, $server);
      unset($whois);
   }
   return($answers);
}
 
 
for ($i=0;$i<(count($array))+1;$i++)
{
echo my_whois($array[$i]);
}
 
 
}
else /* Show form */
{
?>
 
<form method="POST" action="<?php echo $_SERVER["PHP_SELF"]?><name="invoer">
<textarea name="Name" rows=5 cols=20 wrap="off"></textarea>
 
<input type="submit" value="SUBMIT" name="SUBMIT">
</form>
 
<?php
}
?>

Open in new window

0
PeterdeB
Asked:
PeterdeB
  • 8
  • 7
1 Solution
 
Ray PaseurCommented:
OK, we will need to turn the information in the textarea into an array.  I'll show how to do that.
0
 
Ray PaseurCommented:

<?php // RAY_whois_array.php
 
@include_once "Whois.php";
 
// IF ANY POST DATA
if   (!empty($_POST))
{
// BREAK TEXTAREA ON COMMAS AND FEED ARRAY TO my_whois() FUNCTION
   $my_answers = my_whois(explode(',', $_POST["my_textarea"]));
   var_dump($my_answers);
}
// END PROCESSING POSTED DATA
?>
<form method="POST" action="<?php echo $_SERVER["PHP_SELF"]?>">
<textarea name="my_textarea" rows=5 cols=20 wrap="off"></textarea>
<input type="submit" value="SUBMIT" name="SUBMIT">
</form>
 
<?php
// FUNCTION TO DO QUERIES
function my_whois($array)
{
 
   $answers = array();
   $server = "whois.denic.de";
   foreach ($array as $query)
   {
      $query = trim($query);
      $whois = new Net_Whois;
      $answers["$query"] = $whois->query($query, $server);
      unset($whois);
   }
   return($answers);
}
?>

Open in new window

0
 
Ray PaseurCommented:
I changed require to @include so I could test for parse errors.

The assumption here is that the URLs in the textarea are separated by commas. Note I added a trim() to the function to eliminate any whitespace around the URLs.

HTH, ~Ray
0
Independent Software Vendors: We Want Your Opinion

We value your feedback.

Take our survey and automatically be enter to win anyone of the following:
Yeti Cooler, Amazon eGift Card, and Movie eGift Card!

 
PeterdeBAuthor Commented:
Hi Ray, I'm testing it in php expert editor and it gives HTTP 404 ERROR cannot find page. And after some fiddling I managed to get the textbox thus without the 404 error but after pressing the button it showed half the function in text.

Regards,

Peter
0
 
Ray PaseurCommented:
Try just putting it on the server and running it.  That's what I did.  Obviously I could not use the Whois class, but the parse and run part was fine in the "real world"
0
 
PeterdeBAuthor Commented:
Correction > some problem with my temp files caused the 404 error sorry for that. But the button press still results in showing part of the php code in text.

Peter
0
 
PeterdeBAuthor Commented:
But when I used the first script, which validated a single domain, it did return the desired results, so that cannot be the cause?

Peter
0
 
Ray PaseurCommented:
Can you please grab the "view source" and post it in the code snippet?  Thanks!
0
 
PeterdeBAuthor Commented:
Ray here is the script which validates a sinlge domani and works from my pc



// this is the script which validates a snigle domain and works
// from my pc
 
<?php
require_once "Whois.php";
 
$server = "whois.denic.de";
$query  = "phpcrawler.de";     // get information about
                               // this domain
$whois = new Net_Whois;
$data = $whois->query($query, $server);
echo $data;
?>

Open in new window

0
 
Ray PaseurCommented:
Right.  

Can you post the source for the Whois class?  If so, I can put it on my server and test with the "real thing"

Thanks, ~Ray
0
 
PeterdeBAuthor Commented:
Here are the whois and socket source files. But again > when I validated a single domain from my pc it worked.

Peter

Btw it also requires PEAR.

<?php
/**
 * Whois.php
 *
 * PHP Version 4
 *
 * Copyright (c) 1997-2003 The PHP Group
 * Portions Copyright (c) 1980, 1993 The Regents of the University of
 *   California.  All rights reserved.
 *
 * This source file is subject to version 2.02 of the PHP license,
 * that is bundled with this package in the file LICENSE, and is
 * available at through the world-wide-web at
 * http://www.php.net/license/2_02.txt.
 * If you did not receive a copy of the PHP license and are unable to
 * obtain it through the world-wide-web, please send a note to
 * license@php.net so we can mail you a copy immediately.
 *
 * @category  Net
 * @package   Net_Whois
 * @author    Seamus Venasse <seamus.venasse@polaris.ca>
 * @copyright 1997-2003 The PHP Group
 * @copyright 1980-1993 The Regents of the University of California (Portions)
 * @license   http://www.php.net/license/2_02.txt PHP 2.02
 * @version   CVS: $Id: Whois.php,v 1.18 2008/12/20 09:09:30 clockwerx Exp $
 * @link      http://pear.php.net/package/Net_Whois
 */
 
require_once 'PEAR.php';
 
/**
 * Looks up records in the databases maintained by several Network Information
 * Centres (NICs).  This class uses PEAR's Net_Socket:: class.
 *
 * @category Net
 * @package  Net_Whois
 * @author   Seamus Venasse <seamus.venasse@polaris.ca>
 * @license  http://www.php.net/license/2_02.txt PHP 2.02
 * @link     http://pear.php.net/package/Net_Whois
 */
class Net_Whois extends PEAR
{
 
    // {{{ properties
 
    /**
     * List of NICs to query
     *
     * @var array
     * @access private
     */
    var $_nicServers = array (
        "NICHOST"           => "whois.crsnic.net",
        "INICHOST"          => "whois.networksolutions.com",
        "DNICHOST"          => "whois.nic.mil",
        "GNICHOST"          => "whois.nic.gov",
        "ANICHOST"          => "whois.arin.net",
        "RNICHOST"          => "whois.ripe.net",
        "PNICHOST"          => "whois.apnic.net",
        "RUNICHOST"         => "whois.ripn.net",
        "MNICHOST"          => "whois.ra.net",
        "QNICHOST_TAIL"     => ".whois-servers.net",
        "SNICHOST"          => "whois.6bone.net",
        "BNICHOST"          => "whois.registro.br"
    );
 
    /**
     * Search string of server to search on
     *
     * @var string
     * @access private
     */
    var $_whoisServerID = "Whois Server: ";
 
    /**
     * Server to search for IP address lookups
     *
     * @var array
     * @access private
     */
    var $_ipNicServers = array ("RNICHOST", "PNICHOST", "BNICHOST");
 
    /**
     * List of error codes and text
     *
     * @var array
     * @access private
     */
    var $_errorCodes = array (
        010 => 'Unable to create a socket object',
        011 => 'Unable to open socket',
        012 => 'Write to socket failed',
        013 => 'Read from socket failed'
    );
    // }}}
 
    // {{{ constructor
    /**
     * Constructs a new Net_Whois object
     *
     * @access public
     */
    function Net_Whois()
    {
        $this->PEAR();
    }
    // }}}
 
    // {{{ query()
    /**
     * Connect to the necessary servers to perform a domain whois query.  Prefix
     * queries with a "!" to lookup information in InterNIC handle database.
     * Add a "-arin" suffix to queries to lookup information in ARIN handle
     * database.
     *
     * @param string $domain          IP address or host name
     * @param string $userWhoisServer server to query (optional)
     *
     * @access public
     * @return mixed returns a PEAR_Error on failure, or a string on success
     */
    function query($domain, $userWhoisServer = null)
    {
        $domain = trim($domain);
 
        if (isset($userWhoisServer)) {
            $whoisServer = $userWhoisServer;
        } elseif (preg_match("/^!.*/", $domain)) {
            $whoisServer = $this->_nicServers["INICHOST"];
        } elseif (preg_match("/.*?-arin/i", $domain)) {
            $whoisServer = $this->_nicServers["ANICHOST"];
        } elseif (preg_match('/\.gov$/i', $domain)) {
            $whoisServer = $this->_nicServers["GNICHOST"];
        } elseif (preg_match('/\.mil$/i', $domain)) {
            $whoisServer = $this->_nicServers["DNICHOST"];
        } else {
            $whoisServer = $this->_chooseServer($domain);
        }
 
        $whoisData = $this->_connect($whoisServer, $domain);
        if (PEAR::isError($whoisData)) {
            return $whoisData;
        }
 
        return $whoisData;
    }
    // }}}
 
    // {{{ queryAPNIC()
    /**
     * Use the Asia/Pacific Network Information Center (APNIC) database.
     * It contains network numbers used in East Asia, Australia, New
     * Zealand, and the Pacific islands.
     *
     * @param string $domain IP address or host name
     *
     * @access public
     * @return mixed returns a PEAR_Error on failure, or a string on success
     */
    function queryAPNIC($domain)
    {
        return $this->query($domain, $this->_nicServers["PNICHOST"]);
    }
    // }}}
 
    // {{{ queryIPv6()
    /**
     * Use the IPv6 Resource Center (6bone) database.  It contains network
     * names and addresses for the IPv6 network.
     *
     * @param string $domain IP address or host name
     *
     * @access public
     * @return mixed returns a PEAR_Error on failure, or a string on success
     */
    function queryIPv6($domain)
    {
        return $this->query($domain, $this->_nicServers["SNICHOST"]);
    }
    // }}}
 
    // {{{ queryRADB()
    /**
     * Use the Route Arbiter Database (RADB) database.  It contains
     * route policy specifications for a large number of operators'
     * networks.
     *
     * @param string $ipAddress IP address
     *
     * @access public
     * @return mixed returns a PEAR_Error on failure, or a string on success
     */
    function queryRADB($ipAddress)
    {
        return $this->query($ipAddress, $this->_nicServers["MNICHOST"]);
    }
    // }}}
 
    // {{{ _chooseServer()
    /**
     * Determines the correct server to connect to based upon the domin
     *
     * @param string $domain IP address or host name
     *
     * @access private
     * @return string whois server host name
     */
    function _chooseServer($domain)
    {
        if (!strpos($domain, ".")) {
            return $this->_nicServers["NICHOST"];
        }
 
        $TLD = end(explode(".", $domain));
 
        if (is_numeric($TLD)) {
            $whoisServer = $this->_nicServers["ANICHOST"];
        } else {
            $whoisServer = $TLD . $this->_nicServers["QNICHOST_TAIL"];
        }
 
        return $whoisServer;
    }
    // }}}
 
    // {{{ _connect()
    /**
     * Connects to the whois server and retrieves domain information
     *
     * @param string $nicServer FQDN of whois server to query
     * @param string $domain    Domain name to query
     *
     * @access private
     * @return mixed returns a PEAR_Error on failure, string of whois data on success
     */
    function _connect($nicServer, $domain)
    {
        include_once 'Socket.php';
 
        if (PEAR::isError($socket = new Net_Socket())) {
            return new PEAR_Error($this->_errorCodes[010], 10);
        }
 
        $result = $socket->connect($nicServer, getservbyname('whois', 'tcp'));
        if (PEAR::isError($result)) {
            $result = $socket->connect($nicServer, getservbyname('nicname',
                                                                 'tcp'));
            if (PEAR::isError($result)) {
                return new PEAR_Error($this->_errorCodes[011], 11);
            }
        }
        $socket->setBlocking(false);
        if (PEAR::isError($socket->writeLine($domain))) {
            return new PEAR_Error($this->_errorCodes[012], 12);
        }
 
        $nHost = null;
 
        $whoisData = $socket->readAll();
        if (PEAR::isError($whoisData)) {
            return new PEAR_Error($this->_errorCodes[013], 13);
        }
 
        $data = explode("\n", $whoisData);
        foreach ($data as $line) {
            $line = rtrim($line);
 
            // check for whois server redirection
            if (!isset($nHost)) {
                $pattern = "/" . $this->_whoisServerID . "(.*)/";
                if (preg_match($pattern, $line, $matches)) {
                    $nHost = $matches[1];
                } elseif ($nicServer == $this->_nicServers["ANICHOST"]) {
                    foreach ($this->_ipNicServers as $ipNicServer) {
                        if (strstr($line, $this->_nicServers[$ipNicServer])) {
                            $nHost = $this->_nicServers[$ipNicServer];
                        }
                    }
                }
            }
        }
 
        // this should fail, but we'll call it anyway and ignore the error
        $socket->disconnect();
 
        if ($nHost) {
            $tmpBuffer = $this->_connect($nHost, $domain);
            if (PEAR::isError($tmpBuffer)) {
                return $tmpBuffer;
            }
            $whoisData .= $tmpBuffer;
        }
 
        return $whoisData;
    }
    // }}}
}
?>
 
 
<?php
//
// +----------------------------------------------------------------------+
// | PHP Version 4                                                        |
// +----------------------------------------------------------------------+
// | Copyright (c) 1997-2003 The PHP Group                                |
// +----------------------------------------------------------------------+
// | This source file is subject to version 2.0 of the PHP license,       |
// | that is bundled with this package in the file LICENSE, and is        |
// | available at through the world-wide-web at                           |
// | http://www.php.net/license/2_02.txt.                                 |
// | If you did not receive a copy of the PHP license and are unable to   |
// | obtain it through the world-wide-web, please send a note to          |
// | license@php.net so we can mail you a copy immediately.               |
// +----------------------------------------------------------------------+
// | Authors: Stig Bakken <ssb@php.net>                                   |
// |          Chuck Hagenbuch <chuck@horde.org>                           |
// +----------------------------------------------------------------------+
//
// $Id: Socket.php,v 1.38 2008/02/15 18:24:17 chagenbu Exp $
 
require_once 'PEAR.php';
 
define('NET_SOCKET_READ',  1);
define('NET_SOCKET_WRITE', 2);
define('NET_SOCKET_ERROR', 4);
 
/**
 * Generalized Socket class.
 *
 * @version 1.1
 * @author Stig Bakken <ssb@php.net>
 * @author Chuck Hagenbuch <chuck@horde.org>
 */
class Net_Socket extends PEAR {
 
    /**
     * Socket file pointer.
     * @var resource $fp
     */
    var $fp = null;
 
    /**
     * Whether the socket is blocking. Defaults to true.
     * @var boolean $blocking
     */
    var $blocking = true;
 
    /**
     * Whether the socket is persistent. Defaults to false.
     * @var boolean $persistent
     */
    var $persistent = false;
 
    /**
     * The IP address to connect to.
     * @var string $addr
     */
    var $addr = '';
 
    /**
     * The port number to connect to.
     * @var integer $port
     */
    var $port = 0;
 
    /**
     * Number of seconds to wait on socket connections before assuming
     * there's no more data. Defaults to no timeout.
     * @var integer $timeout
     */
    var $timeout = false;
 
    /**
     * Number of bytes to read at a time in readLine() and
     * readAll(). Defaults to 2048.
     * @var integer $lineLength
     */
    var $lineLength = 2048;
 
    /**
     * Connect to the specified port. If called when the socket is
     * already connected, it disconnects and connects again.
     *
     * @param string  $addr        IP address or host name.
     * @param integer $port        TCP port number.
     * @param boolean $persistent  (optional) Whether the connection is
     *                             persistent (kept open between requests
     *                             by the web server).
     * @param integer $timeout     (optional) How long to wait for data.
     * @param array   $options     See options for stream_context_create.
     *
     * @access public
     *
     * @return boolean | PEAR_Error  True on success or a PEAR_Error on failure.
     */
    function connect($addr, $port = 0, $persistent = null, $timeout = null, $options = null)
    {
        if (is_resource($this->fp)) {
            @fclose($this->fp);
            $this->fp = null;
        }
 
        if (!$addr) {
            return $this->raiseError('$addr cannot be empty');
        } elseif (strspn($addr, '.0123456789') == strlen($addr) ||
                  strstr($addr, '/') !== false) {
            $this->addr = $addr;
        } else {
            $this->addr = @gethostbyname($addr);
        }
 
        $this->port = $port % 65536;
 
        if ($persistent !== null) {
            $this->persistent = $persistent;
        }
 
        if ($timeout !== null) {
            $this->timeout = $timeout;
        }
 
        $openfunc = $this->persistent ? 'pfsockopen' : 'fsockopen';
        $errno = 0;
        $errstr = '';
        $old_track_errors = @ini_set('track_errors', 1);
        if ($options && function_exists('stream_context_create')) {
            if ($this->timeout) {
                $timeout = $this->timeout;
            } else {
                $timeout = 0;
            }
            $context = stream_context_create($options);
 
            // Since PHP 5 fsockopen doesn't allow context specification
            if (function_exists('stream_socket_client')) {
                $flags = $this->persistent ? STREAM_CLIENT_PERSISTENT : STREAM_CLIENT_CONNECT;
                $addr = $this->addr . ':' . $this->port;
                $fp = stream_socket_client($addr, $errno, $errstr, $timeout, $flags, $context);
            } else {
                $fp = @$openfunc($this->addr, $this->port, $errno, $errstr, $timeout, $context);
            }
        } else {
            if ($this->timeout) {
                $fp = @$openfunc($this->addr, $this->port, $errno, $errstr, $this->timeout);
            } else {
                $fp = @$openfunc($this->addr, $this->port, $errno, $errstr);
            }
        }
 
        if (!$fp) {
            if ($errno == 0 && isset($php_errormsg)) {
                $errstr = $php_errormsg;
            }
            @ini_set('track_errors', $old_track_errors);
            return $this->raiseError($errstr, $errno);
        }
 
        @ini_set('track_errors', $old_track_errors);
        $this->fp = $fp;
 
        return $this->setBlocking($this->blocking);
    }
 
    /**
     * Disconnects from the peer, closes the socket.
     *
     * @access public
     * @return mixed true on success or a PEAR_Error instance otherwise
     */
    function disconnect()
    {
        if (!is_resource($this->fp)) {
            return $this->raiseError('not connected');
        }
 
        @fclose($this->fp);
        $this->fp = null;
        return true;
    }
 
    /**
     * Find out if the socket is in blocking mode.
     *
     * @access public
     * @return boolean  The current blocking mode.
     */
    function isBlocking()
    {
        return $this->blocking;
    }
 
    /**
     * Sets whether the socket connection should be blocking or
     * not. A read call to a non-blocking socket will return immediately
     * if there is no data available, whereas it will block until there
     * is data for blocking sockets.
     *
     * @param boolean $mode  True for blocking sockets, false for nonblocking.
     * @access public
     * @return mixed true on success or a PEAR_Error instance otherwise
     */
    function setBlocking($mode)
    {
        if (!is_resource($this->fp)) {
            return $this->raiseError('not connected');
        }
 
        $this->blocking = $mode;
        socket_set_blocking($this->fp, $this->blocking);
        return true;
    }
 
    /**
     * Sets the timeout value on socket descriptor,
     * expressed in the sum of seconds and microseconds
     *
     * @param integer $seconds  Seconds.
     * @param integer $microseconds  Microseconds.
     * @access public
     * @return mixed true on success or a PEAR_Error instance otherwise
     */
    function setTimeout($seconds, $microseconds)
    {
        if (!is_resource($this->fp)) {
            return $this->raiseError('not connected');
        }
 
        return socket_set_timeout($this->fp, $seconds, $microseconds);
    }
 
    /**
     * Sets the file buffering size on the stream.
     * See php's stream_set_write_buffer for more information.
     *
     * @param integer $size     Write buffer size.
     * @access public
     * @return mixed on success or an PEAR_Error object otherwise
     */
    function setWriteBuffer($size)
    {
        if (!is_resource($this->fp)) {
            return $this->raiseError('not connected');
        }
 
        $returned = stream_set_write_buffer($this->fp, $size);
        if ($returned == 0) {
            return true;
        }
        return $this->raiseError('Cannot set write buffer.');
    }
 
    /**
     * Returns information about an existing socket resource.
     * Currently returns four entries in the result array:
     *
     * <p>
     * timed_out (bool) - The socket timed out waiting for data<br>
     * blocked (bool) - The socket was blocked<br>
     * eof (bool) - Indicates EOF event<br>
     * unread_bytes (int) - Number of bytes left in the socket buffer<br>
     * </p>
     *
     * @access public
     * @return mixed Array containing information about existing socket resource or a PEAR_Error instance otherwise
     */
    function getStatus()
    {
        if (!is_resource($this->fp)) {
            return $this->raiseError('not connected');
        }
 
        return socket_get_status($this->fp);
    }
 
    /**
     * Get a specified line of data
     *
     * @access public
     * @return $size bytes of data from the socket, or a PEAR_Error if
     *         not connected.
     */
    function gets($size)
    {
        if (!is_resource($this->fp)) {
            return $this->raiseError('not connected');
        }
 
        return @fgets($this->fp, $size);
    }
 
    /**
     * Read a specified amount of data. This is guaranteed to return,
     * and has the added benefit of getting everything in one fread()
     * chunk; if you know the size of the data you're getting
     * beforehand, this is definitely the way to go.
     *
     * @param integer $size  The number of bytes to read from the socket.
     * @access public
     * @return $size bytes of data from the socket, or a PEAR_Error if
     *         not connected.
     */
    function read($size)
    {
        if (!is_resource($this->fp)) {
            return $this->raiseError('not connected');
        }
 
        return @fread($this->fp, $size);
    }
 
    /**
     * Write a specified amount of data.
     *
     * @param string  $data       Data to write.
     * @param integer $blocksize  Amount of data to write at once.
     *                            NULL means all at once.
     *
     * @access public
     * @return mixed If the socket is not connected, returns an instance of PEAR_Error
     *               If the write succeeds, returns the number of bytes written
     *               If the write fails, returns false.
     */
    function write($data, $blocksize = null)
    {
        if (!is_resource($this->fp)) {
            return $this->raiseError('not connected');
        }
 
        if (is_null($blocksize) && !OS_WINDOWS) {
            return @fwrite($this->fp, $data);
        } else {
            if (is_null($blocksize)) {
                $blocksize = 1024;
            }
 
            $pos = 0;
            $size = strlen($data);
            while ($pos < $size) {
                $written = @fwrite($this->fp, substr($data, $pos, $blocksize));
                if ($written === false) {
                    return false;
                }
                $pos += $written;
            }
 
            return $pos;
        }
    }
 
    /**
     * Write a line of data to the socket, followed by a trailing "\r\n".
     *
     * @access public
     * @return mixed fputs result, or an error
     */
    function writeLine($data)
    {
        if (!is_resource($this->fp)) {
            return $this->raiseError('not connected');
        }
 
        return fwrite($this->fp, $data . "\r\n");
    }
 
    /**
     * Tests for end-of-file on a socket descriptor.
     *
     * Also returns true if the socket is disconnected.
     *
     * @access public
     * @return bool
     */
    function eof()
    {
        return (!is_resource($this->fp) || feof($this->fp));
    }
 
    /**
     * Reads a byte of data
     *
     * @access public
     * @return 1 byte of data from the socket, or a PEAR_Error if
     *         not connected.
     */
    function readByte()
    {
        if (!is_resource($this->fp)) {
            return $this->raiseError('not connected');
        }
 
        return ord(@fread($this->fp, 1));
    }
 
    /**
     * Reads a word of data
     *
     * @access public
     * @return 1 word of data from the socket, or a PEAR_Error if
     *         not connected.
     */
    function readWord()
    {
        if (!is_resource($this->fp)) {
            return $this->raiseError('not connected');
        }
 
        $buf = @fread($this->fp, 2);
        return (ord($buf[0]) + (ord($buf[1]) << 8));
    }
 
    /**
     * Reads an int of data
     *
     * @access public
     * @return integer  1 int of data from the socket, or a PEAR_Error if
     *                  not connected.
     */
    function readInt()
    {
        if (!is_resource($this->fp)) {
            return $this->raiseError('not connected');
        }
 
        $buf = @fread($this->fp, 4);
        return (ord($buf[0]) + (ord($buf[1]) << 8) +
                (ord($buf[2]) << 16) + (ord($buf[3]) << 24));
    }
 
    /**
     * Reads a zero-terminated string of data
     *
     * @access public
     * @return string, or a PEAR_Error if
     *         not connected.
     */
    function readString()
    {
        if (!is_resource($this->fp)) {
            return $this->raiseError('not connected');
        }
 
        $string = '';
        while (($char = @fread($this->fp, 1)) != "\x00")  {
            $string .= $char;
        }
        return $string;
    }
 
    /**
     * Reads an IP Address and returns it in a dot formatted string
     *
     * @access public
     * @return Dot formatted string, or a PEAR_Error if
     *         not connected.
     */
    function readIPAddress()
    {
        if (!is_resource($this->fp)) {
            return $this->raiseError('not connected');
        }
 
        $buf = @fread($this->fp, 4);
        return sprintf('%d.%d.%d.%d', ord($buf[0]), ord($buf[1]),
                       ord($buf[2]), ord($buf[3]));
    }
 
    /**
     * Read until either the end of the socket or a newline, whichever
     * comes first. Strips the trailing newline from the returned data.
     *
     * @access public
     * @return All available data up to a newline, without that
     *         newline, or until the end of the socket, or a PEAR_Error if
     *         not connected.
     */
    function readLine()
    {
        if (!is_resource($this->fp)) {
            return $this->raiseError('not connected');
        }
 
        $line = '';
        $timeout = time() + $this->timeout;
        while (!feof($this->fp) && (!$this->timeout || time() < $timeout)) {
            $line .= @fgets($this->fp, $this->lineLength);
            if (substr($line, -1) == "\n") {
                return rtrim($line, "\r\n");
            }
        }
        return $line;
    }
 
    /**
     * Read until the socket closes, or until there is no more data in
     * the inner PHP buffer. If the inner buffer is empty, in blocking
     * mode we wait for at least 1 byte of data. Therefore, in
     * blocking mode, if there is no data at all to be read, this
     * function will never exit (unless the socket is closed on the
     * remote end).
     *
     * @access public
     *
     * @return string  All data until the socket closes, or a PEAR_Error if
     *                 not connected.
     */
    function readAll()
    {
        if (!is_resource($this->fp)) {
            return $this->raiseError('not connected');
        }
 
        $data = '';
        while (!feof($this->fp)) {
            $data .= @fread($this->fp, $this->lineLength);
        }
        return $data;
    }
 
    /**
     * Runs the equivalent of the select() system call on the socket
     * with a timeout specified by tv_sec and tv_usec.
     *
     * @param integer $state    Which of read/write/error to check for.
     * @param integer $tv_sec   Number of seconds for timeout.
     * @param integer $tv_usec  Number of microseconds for timeout.
     *
     * @access public
     * @return False if select fails, integer describing which of read/write/error
     *         are ready, or PEAR_Error if not connected.
     */
    function select($state, $tv_sec, $tv_usec = 0)
    {
        if (!is_resource($this->fp)) {
            return $this->raiseError('not connected');
        }
 
        $read = null;
        $write = null;
        $except = null;
        if ($state & NET_SOCKET_READ) {
            $read[] = $this->fp;
        }
        if ($state & NET_SOCKET_WRITE) {
            $write[] = $this->fp;
        }
        if ($state & NET_SOCKET_ERROR) {
            $except[] = $this->fp;
        }
        if (false === ($sr = stream_select($read, $write, $except, $tv_sec, $tv_usec))) {
            return false;
        }
 
        $result = 0;
        if (count($read)) {
            $result |= NET_SOCKET_READ;
        }
        if (count($write)) {
            $result |= NET_SOCKET_WRITE;
        }
        if (count($except)) {
            $result |= NET_SOCKET_ERROR;
        }
        return $result;
    }
 
    /**
     * Turns encryption on/off on a connected socket.
     *
     * @param bool    $enabled  Set this parameter to true to enable encryption
     *                          and false to disable encryption.
     * @param integer $type     Type of encryption. See
     *                          http://se.php.net/manual/en/function.stream-socket-enable-crypto.php for values.
     *
     * @access public
     * @return false on error, true on success and 0 if there isn't enough data and the
     *         user should try again (non-blocking sockets only). A PEAR_Error object
     *         is returned if the socket is not connected
     */
    function enableCrypto($enabled, $type)
    {
        if (version_compare(phpversion(), "5.1.0", ">=")) {
            if (!is_resource($this->fp)) {
                return $this->raiseError('not connected');
            }
            return @stream_socket_enable_crypto($this->fp, $enabled, $type);
        } else {
            return $this->raiseError('Net_Socket::enableCrypto() requires php version >= 5.1.0');
        }
    }
 
}

Open in new window

0
 
Ray PaseurCommented:
OK, thanks.  I replaced the Whois.php class file with the attached code, just so I could get a clean test case.  It worked just fine.  You can see it on my server here:

http://www.laprbass.com/RAY_whois_array.php


<?php
/**
 * Whois.php
 * TEST VERSION
 */
class Net_Whois
{
   public function query($domain, $userWhoisServer = null)
   {
       return "DUMMY-DATA";
   }
}

Open in new window

0
 
PeterdeBAuthor Commented:
Then  this question is answered but I'll post another question to see if I can use the other supplied function, cause I cant get this working on my pc.

Thanks for the efforts,

Peter
0
 
PeterdeBAuthor Commented:
Thanks, too bad I cant get it working on my pc but perhaps the other function supplied in my first question will work out.

Peter
0
 
Ray PaseurCommented:
Thanks for the points.  I'm not sure I know why this would not work on your PC, but it may have something to do with short_tags or with the way PHP is parsed.  Hope there is a quick fix! ~Ray
0

Featured Post

What does it mean to be "Always On"?

Is your cloud always on? With an Always On cloud you won't have to worry about downtime for maintenance or software application code updates, ensuring that your bottom line isn't affected.

  • 8
  • 7
Tackle projects and never again get stuck behind a technical roadblock.
Join Now