Platon Technologies
not logged in Login Registration
EnglishSlovak
open source software development celebrating 10 years of open source development! Wednesday, October 14, 2026
[BACK] [TXT][DIR] Up to [Platon] / Metafox / lib / Net

Diff for Metafox/lib/Net/Socket.php between version 1.1 and 1.2

version 1.1, 2005/06/05 12:14:33 version 1.2, 2015/11/24 17:21:06
Line 1 
Line 1 
 <?php  <?php
 //  /**
 // +----------------------------------------------------------------------+   * Net_Socket
 // | PHP Version 4                                                        |   *
 // +----------------------------------------------------------------------+   * PHP Version 4
 // | Copyright (c) 1997-2003 The PHP Group                                |   *
 // +----------------------------------------------------------------------+   * Copyright (c) 1997-2013 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        |   * This source file is subject to version 2.0 of the PHP license,
 // | available at through the world-wide-web at                           |   * that is bundled with this package in the file LICENSE, and is
 // | http://www.php.net/license/2_02.txt.                                 |   * available at through the world-wide-web at
 // | If you did not receive a copy of the PHP license and are unable to   |   * http://www.php.net/license/2_02.txt.
 // | obtain it through the world-wide-web, please send a note to          |   * If you did not receive a copy of the PHP license and are unable to
 // | license@php.net so we can mail you a copy immediately.               |   * 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>                           |   * Authors: Stig Bakken <ssb@php.net>
 // +----------------------------------------------------------------------+   *          Chuck Hagenbuch <chuck@horde.org>
 //   *
 // $Id$   * @category  Net
    * @package   Net_Socket
    * @author    Stig Bakken <ssb@php.net>
    * @author    Chuck Hagenbuch <chuck@horde.org>
    * @copyright 1997-2003 The PHP Group
    * @license   http://www.php.net/license/2_02.txt PHP 2.02
    * @link      http://pear.php.net/packages/Net_Socket
    */
   
 require_once 'PEAR.php';  require_once 'PEAR.php';
   
 define('NET_SOCKET_READ',  1);  define('NET_SOCKET_READ', 1);
 define('NET_SOCKET_WRITE', 2);  define('NET_SOCKET_WRITE', 2);
 define('NET_SOCKET_ERROR', 3);  define('NET_SOCKET_ERROR', 4);
   
 /**  /**
  * Generalized Socket class.   * Generalized Socket class.
  *   *
  * @version 1.1   * @category  Net
  * @author Stig Bakken <ssb@php.net>   * @package   Net_Socket
  * @author Chuck Hagenbuch <chuck@horde.org>   * @author    Stig Bakken <ssb@php.net>
    * @author    Chuck Hagenbuch <chuck@horde.org>
    * @copyright 1997-2003 The PHP Group
    * @license   http://www.php.net/license/2_02.txt PHP 2.02
    * @link      http://pear.php.net/packages/Net_Socket
  */   */
 class Net_Socket extends PEAR {  class Net_Socket extends PEAR
   {
     /**      /**
      * Socket file pointer.       * Socket file pointer.
      * @var resource $fp       * @var resource $fp
Line 65  class Net_Socket extends PEAR {
Line 76  class Net_Socket extends PEAR {
     var $port = 0;      var $port = 0;
   
     /**      /**
      * Number of seconds to wait on socket connections before assuming       * Number of seconds to wait on socket operations before assuming
      * there's no more data. Defaults to no timeout.       * there's no more data. Defaults to no timeout.
      * @var integer $timeout       * @var integer|float $timeout
      */       */
     var $timeout = false;      var $timeout = null;
   
     /**      /**
      * Number of bytes to read at a time in readLine() and       * Number of bytes to read at a time in readLine() and
Line 79  class Net_Socket extends PEAR {
Line 90  class Net_Socket extends PEAR {
     var $lineLength = 2048;      var $lineLength = 2048;
   
     /**      /**
        * The string to use as a newline terminator. Usually "\r\n" or "\n".
        * @var string $newline
        */
       var $newline = "\r\n";
   
       /**
      * Connect to the specified port. If called when the socket is       * Connect to the specified port. If called when the socket is
      * already connected, it disconnects and connects again.       * already connected, it disconnects and connects again.
      *       *
      * @param string  $addr        IP address or host name.       * @param string  $addr       IP address or host name (may be with protocol prefix).
      * @param integer $port        TCP port number.       * @param integer $port       TCP port number.
      * @param boolean $persistent  (optional) Whether the connection is       * @param boolean $persistent (optional) Whether the connection is
      *                             persistent (kept open between requests       *                            persistent (kept open between requests
      *                             by the web server).       *                            by the web server).
      * @param integer $timeout     (optional) How long to wait for data.       * @param integer $timeout    (optional) Connection socket timeout.
      * @param array   $options     See options for stream_context_create.       * @param array   $options    See options for stream_context_create.
      *       *
      * @access public       * @access public
      *       *
      * @return boolean | PEAR_Error  True on success or a PEAR_Error on failure.       * @return boolean|PEAR_Error  True on success or a PEAR_Error on failure.
      */       */
     function connect($addr, $port = 0, $persistent = null, $timeout = null, $options = null)      function connect($addr, $port = 0, $persistent = null,
                        $timeout = null, $options = null)
     {      {
         if (is_resource($this->fp)) {          if (is_resource($this->fp)) {
             @fclose($this->fp);              @fclose($this->fp);
Line 103  class Net_Socket extends PEAR {
Line 121  class Net_Socket extends PEAR {
   
         if (!$addr) {          if (!$addr) {
             return $this->raiseError('$addr cannot be empty');              return $this->raiseError('$addr cannot be empty');
         } elseif (strspn($addr, '.0123456789') == strlen($addr) ||          } else if (strspn($addr, ':.0123456789') == strlen($addr)) {
                   strstr($addr, '/') !== false) {              $this->addr = strpos($addr, ':') !== false ? '['.$addr.']' : $addr;
             $this->addr = $addr;  
         } else {          } else {
             $this->addr = @gethostbyname($addr);              $this->addr = $addr;
         }          }
   
         $this->port = $port % 65536;          $this->port = $port % 65536;
Line 116  class Net_Socket extends PEAR {
Line 133  class Net_Socket extends PEAR {
             $this->persistent = $persistent;              $this->persistent = $persistent;
         }          }
   
         if ($timeout !== null) {          $openfunc = $this->persistent ? 'pfsockopen' : 'fsockopen';
             $this->timeout = $timeout;          $errno    = 0;
           $errstr   = '';
   
           $old_track_errors = @ini_set('track_errors', 1);
   
           if ($timeout <= 0) {
               $timeout = @ini_get('default_socket_timeout');
         }          }
   
         $openfunc = $this->persistent ? 'pfsockopen' : 'fsockopen';  
         $errno = 0;  
         $errstr = '';  
         if ($options && function_exists('stream_context_create')) {          if ($options && function_exists('stream_context_create')) {
             if ($this->timeout) {  
                 $timeout = $this->timeout;  
             } else {  
                 $timeout = 0;  
             }  
             $context = stream_context_create($options);              $context = stream_context_create($options);
             $fp = @$openfunc($this->addr, $this->port, $errno, $errstr, $timeout, $context);  
         } else {              // Since PHP 5 fsockopen doesn't allow context specification
             if ($this->timeout) {              if (function_exists('stream_socket_client')) {
                 $fp = @$openfunc($this->addr, $this->port, $errno, $errstr, $this->timeout);                  $flags = STREAM_CLIENT_CONNECT;
   
                   if ($this->persistent) {
                       $flags = STREAM_CLIENT_PERSISTENT;
                   }
   
                   $addr = $this->addr . ':' . $this->port;
                   $fp   = stream_socket_client($addr, $errno, $errstr,
                                                $timeout, $flags, $context);
             } else {              } else {
                 $fp = @$openfunc($this->addr, $this->port, $errno, $errstr);                  $fp = @$openfunc($this->addr, $this->port, $errno,
                                    $errstr, $timeout, $context);
             }              }
           } else {
               $fp = @$openfunc($this->addr, $this->port, $errno, $errstr, $timeout);
         }          }
   
         if (!$fp) {          if (!$fp) {
               if ($errno == 0 && !strlen($errstr) && isset($php_errormsg)) {
                   $errstr = $php_errormsg;
               }
               @ini_set('track_errors', $old_track_errors);
             return $this->raiseError($errstr, $errno);              return $this->raiseError($errstr, $errno);
         }          }
   
           @ini_set('track_errors', $old_track_errors);
         $this->fp = $fp;          $this->fp = $fp;
           $this->setTimeout();
         return $this->setBlocking($this->blocking);          return $this->setBlocking($this->blocking);
     }      }
   
Line 152  class Net_Socket extends PEAR {
Line 183  class Net_Socket extends PEAR {
      * Disconnects from the peer, closes the socket.       * Disconnects from the peer, closes the socket.
      *       *
      * @access public       * @access public
      * @return mixed true on success or an error object otherwise       * @return mixed true on success or a PEAR_Error instance otherwise
      */       */
     function disconnect()      function disconnect()
     {      {
Line 166  class Net_Socket extends PEAR {
Line 197  class Net_Socket extends PEAR {
     }      }
   
     /**      /**
        * Set the newline character/sequence to use.
        *
        * @param string $newline  Newline character(s)
        * @return boolean True
        */
       function setNewline($newline)
       {
           $this->newline = $newline;
           return true;
       }
   
       /**
      * Find out if the socket is in blocking mode.       * Find out if the socket is in blocking mode.
      *       *
      * @access public       * @access public
Line 182  class Net_Socket extends PEAR {
Line 225  class Net_Socket extends PEAR {
      * if there is no data available, whereas it will block until there       * if there is no data available, whereas it will block until there
      * is data for blocking sockets.       * is data for blocking sockets.
      *       *
      * @param boolean $mode  True for blocking sockets, false for nonblocking.       * @param boolean $mode True for blocking sockets, false for nonblocking.
        *
      * @access public       * @access public
      * @return mixed true on success or an error object otherwise       * @return mixed true on success or a PEAR_Error instance otherwise
      */       */
     function setBlocking($mode)      function setBlocking($mode)
     {      {
Line 193  class Net_Socket extends PEAR {
Line 237  class Net_Socket extends PEAR {
         }          }
   
         $this->blocking = $mode;          $this->blocking = $mode;
         socket_set_blocking($this->fp, $this->blocking);          stream_set_blocking($this->fp, (int)$this->blocking);
         return true;          return true;
     }      }
   
Line 201  class Net_Socket extends PEAR {
Line 245  class Net_Socket extends PEAR {
      * Sets the timeout value on socket descriptor,       * Sets the timeout value on socket descriptor,
      * expressed in the sum of seconds and microseconds       * expressed in the sum of seconds and microseconds
      *       *
      * @param integer $seconds  Seconds.       * @param integer $seconds      Seconds.
      * @param integer $microseconds  Microseconds.       * @param integer $microseconds Microseconds, optional.
        *
        * @access public
        * @return mixed True on success or false on failure or
        *               a PEAR_Error instance when not connected
        */
       function setTimeout($seconds = null, $microseconds = null)
       {
           if (!is_resource($this->fp)) {
               return $this->raiseError('not connected');
           }
   
           if ($seconds === null && $microseconds === null) {
               $seconds      = (int) $this->timeout;
               $microseconds = (int) (($this->timeout - $seconds) * 1000000);
           } else {
               $this->timeout = $seconds + $microseconds/1000000;
           }
   
           if ($this->timeout > 0) {
               return stream_set_timeout($this->fp, (int) $seconds, (int) $microseconds);
           }
           else {
               return false;
           }
       }
   
       /**
        * 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       * @access public
      * @return mixed true on success or an error object otherwise       * @return mixed on success or an PEAR_Error object otherwise
      */       */
     function setTimeout($seconds, $microseconds)      function setWriteBuffer($size)
     {      {
         if (!is_resource($this->fp)) {          if (!is_resource($this->fp)) {
             return $this->raiseError('not connected');              return $this->raiseError('not connected');
         }          }
   
         return socket_set_timeout($this->fp, $seconds, $microseconds);          $returned = stream_set_write_buffer($this->fp, $size);
           if ($returned == 0) {
               return true;
           }
           return $this->raiseError('Cannot set write buffer.');
     }      }
   
     /**      /**
Line 227  class Net_Socket extends PEAR {
Line 307  class Net_Socket extends PEAR {
      * </p>       * </p>
      *       *
      * @access public       * @access public
      * @return mixed Array containing information about existing socket resource or an error object otherwise       * @return mixed Array containing information about existing socket
        *               resource or a PEAR_Error instance otherwise
      */       */
     function getStatus()      function getStatus()
     {      {
Line 235  class Net_Socket extends PEAR {
Line 316  class Net_Socket extends PEAR {
             return $this->raiseError('not connected');              return $this->raiseError('not connected');
         }          }
   
         return socket_get_status($this->fp);          return stream_get_meta_data($this->fp);
     }      }
   
     /**      /**
      * Get a specified line of data       * Get a specified line of data
      *       *
        * @param int $size Reading ends when size - 1 bytes have been read,
        *                  or a newline or an EOF (whichever comes first).
        *                  If no size is specified, it will keep reading from
        *                  the stream until it reaches the end of the line.
        *
      * @access public       * @access public
      * @return $size bytes of data from the socket, or a PEAR_Error if       * @return mixed $size bytes of data from the socket, or a PEAR_Error if
      *         not connected.       *         not connected. If an error occurs, FALSE is returned.
      */       */
     function gets($size)      function gets($size = null)
     {      {
         if (!is_resource($this->fp)) {          if (!is_resource($this->fp)) {
             return $this->raiseError('not connected');              return $this->raiseError('not connected');
         }          }
   
         return @fgets($this->fp, $size);          if (is_null($size)) {
               return @fgets($this->fp);
           } else {
               return @fgets($this->fp, $size);
           }
     }      }
   
     /**      /**
Line 260  class Net_Socket extends PEAR {
Line 350  class Net_Socket extends PEAR {
      * chunk; if you know the size of the data you're getting       * chunk; if you know the size of the data you're getting
      * beforehand, this is definitely the way to go.       * beforehand, this is definitely the way to go.
      *       *
      * @param integer $size  The number of bytes to read from the socket.       * @param integer $size The number of bytes to read from the socket.
        *
      * @access public       * @access public
      * @return $size bytes of data from the socket, or a PEAR_Error if       * @return $size bytes of data from the socket, or a PEAR_Error if
      *         not connected.       *         not connected.
Line 277  class Net_Socket extends PEAR {
Line 368  class Net_Socket extends PEAR {
     /**      /**
      * Write a specified amount of data.       * Write a specified amount of data.
      *       *
      * @param string  $data       Data to write.       * @param string  $data      Data to write.
      * @param integer $blocksize  Amount of data to write at once.       * @param integer $blocksize Amount of data to write at once.
      *                            NULL means all at once.       *                           NULL means all at once.
      *       *
      * @access public       * @access public
      * @return mixed true on success or an error object otherwise       * @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.
        *               If the socket times out, returns an instance of PEAR_Error.
      */       */
     function write($data, $blocksize = null)      function write($data, $blocksize = null)
     {      {
Line 291  class Net_Socket extends PEAR {
Line 386  class Net_Socket extends PEAR {
         }          }
   
         if (is_null($blocksize) && !OS_WINDOWS) {          if (is_null($blocksize) && !OS_WINDOWS) {
             return fwrite($this->fp, $data);              $written = @fwrite($this->fp, $data);
   
               // Check for timeout or lost connection
               if (!$written) {
                   $meta_data = $this->getStatus();
   
                   if (!is_array($meta_data)) {
                       return $meta_data; // PEAR_Error
                   }
   
                   if (!empty($meta_data['timed_out'])) {
                       return $this->raiseError('timed out');
                   }
               }
   
               return $written;
         } else {          } else {
             if (is_null($blocksize)) {              if (is_null($blocksize)) {
                 $blocksize = 1024;                  $blocksize = 1024;
             }              }
   
             $pos = 0;              $pos  = 0;
             $size = strlen($data);              $size = strlen($data);
             while ($pos < $size) {              while ($pos < $size) {
                 $written = @fwrite($this->fp, substr($data, $pos, $blocksize));                  $written = @fwrite($this->fp, substr($data, $pos, $blocksize));
                 if ($written === false) {  
                     return false;                  // Check for timeout or lost connection
                   if (!$written) {
                       $meta_data = $this->getStatus();
   
                       if (!is_array($meta_data)) {
                           return $meta_data; // PEAR_Error
                       }
   
                       if (!empty($meta_data['timed_out'])) {
                           return $this->raiseError('timed out');
                       }
   
                       return $written;
                 }                  }
   
                 $pos += $written;                  $pos += $written;
             }              }
   
Line 312  class Net_Socket extends PEAR {
Line 435  class Net_Socket extends PEAR {
     }      }
   
     /**      /**
      * Write a line of data to the socket, followed by a trailing "\r\n".       * Write a line of data to the socket, followed by a trailing newline.
        *
        * @param string $data Data to write
      *       *
      * @access public       * @access public
      * @return mixed fputs result, or an error       * @return mixed fwrite() result, or PEAR_Error when not connected
      */       */
     function writeLine($data)      function writeLine($data)
     {      {
Line 323  class Net_Socket extends PEAR {
Line 448  class Net_Socket extends PEAR {
             return $this->raiseError('not connected');              return $this->raiseError('not connected');
         }          }
   
         return fwrite($this->fp, $data . "\r\n");          return fwrite($this->fp, $data . $this->newline);
     }      }
   
     /**      /**
      * Tests for end-of-file on a socket descriptor.       * Tests for end-of-file on a socket descriptor.
      *       *
        * Also returns true if the socket is disconnected.
        *
      * @access public       * @access public
      * @return bool       * @return bool
      */       */
     function eof()      function eof()
     {      {
         return (is_resource($this->fp) && feof($this->fp));          return (!is_resource($this->fp) || feof($this->fp));
     }      }
   
     /**      /**
Line 402  class Net_Socket extends PEAR {
Line 529  class Net_Socket extends PEAR {
         }          }
   
         $string = '';          $string = '';
         while (($char = @fread($this->fp, 1)) != "\x00")  {          while (($char = @fread($this->fp, 1)) != "\x00") {
             $string .= $char;              $string .= $char;
         }          }
         return $string;          return $string;
     }      }
   
     /**      /**
      * Reads an IP Address and returns it in a dot formated string       * Reads an IP Address and returns it in a dot formatted string
      *       *
      * @access public       * @access public
      * @return Dot formated string, or a PEAR_Error if       * @return Dot formatted string, or a PEAR_Error if
      *         not connected.       *         not connected.
      */       */
     function readIPAddress()      function readIPAddress()
Line 422  class Net_Socket extends PEAR {
Line 549  class Net_Socket extends PEAR {
         }          }
   
         $buf = @fread($this->fp, 4);          $buf = @fread($this->fp, 4);
         return sprintf("%s.%s.%s.%s", ord($buf[0]), ord($buf[1]),          return sprintf('%d.%d.%d.%d', ord($buf[0]), ord($buf[1]),
                        ord($buf[2]), ord($buf[3]));                         ord($buf[2]), ord($buf[3]));
     }      }
   
Line 442  class Net_Socket extends PEAR {
Line 569  class Net_Socket extends PEAR {
         }          }
   
         $line = '';          $line = '';
   
         $timeout = time() + $this->timeout;          $timeout = time() + $this->timeout;
   
         while (!feof($this->fp) && (!$this->timeout || time() < $timeout)) {          while (!feof($this->fp) && (!$this->timeout || time() < $timeout)) {
             $line .= @fgets($this->fp, $this->lineLength);              $line .= @fgets($this->fp, $this->lineLength);
             if (substr($line, -1) == "\n") {              if (substr($line, -1) == "\n") {
                 return rtrim($line, "\r\n");                  return rtrim($line, $this->newline);
             }              }
         }          }
         return $line;          return $line;
Line 482  class Net_Socket extends PEAR {
Line 611  class Net_Socket extends PEAR {
      * Runs the equivalent of the select() system call on the socket       * Runs the equivalent of the select() system call on the socket
      * with a timeout specified by tv_sec and tv_usec.       * with a timeout specified by tv_sec and tv_usec.
      *       *
      * @param integer $state    Which of read/write/error to check for.       * @param integer $state   Which of read/write/error to check for.
      * @param integer $tv_sec   Number of seconds for timeout.       * @param integer $tv_sec  Number of seconds for timeout.
      * @param integer $tv_usec  Number of microseconds for timeout.       * @param integer $tv_usec Number of microseconds for timeout.
      *       *
      * @access public       * @access public
      * @return False if select fails, integer describing which of read/write/error       * @return False if select fails, integer describing which of read/write/error
Line 496  class Net_Socket extends PEAR {
Line 625  class Net_Socket extends PEAR {
             return $this->raiseError('not connected');              return $this->raiseError('not connected');
         }          }
   
         $read = null;          $read   = null;
         $write = null;          $write  = null;
         $except = null;          $except = null;
         if ($state & NET_SOCKET_READ) {          if ($state & NET_SOCKET_READ) {
             $read[] = $this->fp;              $read[] = $this->fp;
Line 508  class Net_Socket extends PEAR {
Line 637  class Net_Socket extends PEAR {
         if ($state & NET_SOCKET_ERROR) {          if ($state & NET_SOCKET_ERROR) {
             $except[] = $this->fp;              $except[] = $this->fp;
         }          }
         if (false === ($sr = stream_select($read, $write, $except, $tv_sec, $tv_usec))) {          if (false === ($sr = stream_select($read, $write, $except,
                                             $tv_sec, $tv_usec))) {
             return false;              return false;
         }          }
   
Line 525  class Net_Socket extends PEAR {
Line 655  class Net_Socket extends PEAR {
         return $result;          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 stream_socket_enable_crypto()
        *                         for values.
        *
        * @see    http://se.php.net/manual/en/function.stream-socket-enable-crypto.php
        * @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 {
               $msg = 'Net_Socket::enableCrypto() requires php version >= 5.1.0';
               return $this->raiseError($msg);
           }
       }
   
 }  }
Legend:
Removed from v.1.1  
changed lines
  Added in v.1.2
Platon Group <platon@platon.org> http://platon.org/
Copyright © 2002-2006 Platon Group
Site powered by Metafox CMS 		Go to Top