Source for file socket.php

Documentation is available at socket.php

  1. <?php
  2. /**
  3.  *  base include file for SimpleTest
  4.  *  @package    SimpleTest
  5.  *  @subpackage MockObjects
  6.  *  @version    $Id: socket.php 1723 2008-04-08 00:34:10Z lastcraft $
  7.  */
  8.  
  9. /**#@+
  10.  * include SimpleTest files
  11.  */
  12. require_once(dirname(__FILE__) . '/compatibility.php');
  13. /**#@-*/
  14.  
  15.  *    Stashes an error for later. Useful for constructors
  16.  *    until PHP gets exceptions.
  17.  *    @package SimpleTest
  18.  *    @subpackage WebTester
  19.  */
  20. class SimpleStickyError {
  21.     var $_error = 'Constructor not chained';
  22.  
  23.     /**
  24.      *    Sets the error to empty.
  25.      *    @access public
  26.      */
  27.     function SimpleStickyError() {
  28.         $this->_clearError();
  29.     }
  30.  
  31.     /**
  32.      *    Test for an outstanding error.
  33.      *    @return boolean           True if there is an error.
  34.      *    @access public
  35.      */
  36.     function isError() {
  37.         return ($this->_error != '');
  38.     }
  39.  
  40.     /**
  41.      *    Accessor for an outstanding error.
  42.      *    @return string     Empty string if no error otherwise
  43.      *                        the error message.
  44.      *    @access public
  45.      */
  46.     function getError() {
  47.         return $this->_error;
  48.     }
  49.  
  50.     /**
  51.      *    Sets the internal error.
  52.      *    @param string       Error message to stash.
  53.      *    @access protected
  54.      */
  55.     function _setError($error) {
  56.         $this->_error = $error;
  57.     }
  58.  
  59.     /**
  60.      *    Resets the error state to no error.
  61.      *    @access protected
  62.      */
  63.     function _clearError() {
  64.         $this->_setError('');
  65.     }
  66. }
  67.  
  68. /**
  69.  *    Wrapper for TCP/IP socket.
  70.  *    @package SimpleTest
  71.  *    @subpackage WebTester
  72.  */
  73. class SimpleSocket extends SimpleStickyError {
  74.     var $_handle;
  75.     var $_is_open = false;
  76.     var $_sent = '';
  77.     var $lock_size;
  78.  
  79.     /**
  80.      *    Opens a socket for reading and writing.
  81.      *    @param string $host          Hostname to send request to.
  82.      *    @param integer $port         Port on remote machine to open.
  83.      *    @param integer $timeout      Connection timeout in seconds.
  84.      *    @param integer $block_size   Size of chunk to read.
  85.      *    @access public
  86.      */
  87.     function SimpleSocket($host, $port, $timeout, $block_size = 255) {
  88.         $this->SimpleStickyError();
  89.         if (! ($this->_handle = $this->_openSocket($host, $port, $error_number, $error, $timeout))) {
  90.             $this->_setError("Cannot open [$host:$port] with [$error] within [$timeout] seconds");
  91.             return;
  92.         }
  93.         $this->_is_open = true;
  94.         $this->_block_size = $block_size;
  95.         SimpleTestCompatibility::setTimeout($this->_handle, $timeout);
  96.     }
  97.  
  98.     /**
  99.      *    Writes some data to the socket and saves alocal copy.
  100.      *    @param string $message       String to send to socket.
  101.      *    @return boolean              True if successful.
  102.      *    @access public
  103.      */
  104.     function write($message) {
  105.         if ($this->isError() || ! $this->isOpen()) {
  106.             return false;
  107.         }
  108.         $count = fwrite($this->_handle, $message);
  109.         if (! $count) {
  110.             if ($count === false) {
  111.                 $this->_setError('Cannot write to socket');
  112.                 $this->close();
  113.             }
  114.             return false;
  115.         }
  116.         fflush($this->_handle);
  117.         $this->_sent .= $message;
  118.         return true;
  119.     }
  120.  
  121.     /**
  122.      *    Reads data from the socket. The error suppresion
  123.      *    is a workaround for PHP4 always throwing a warning
  124.      *    with a secure socket.
  125.      *    @return integer/boolean           Incoming bytes. False
  126.      *                                      on error.
  127.      *    @access public
  128.      */
  129.     function read() {
  130.         if ($this->isError() || ! $this->isOpen()) {
  131.             return false;
  132.         }
  133.         $raw = @fread($this->_handle, $this->_block_size);
  134.         if ($raw === false) {
  135.             $this->_setError('Cannot read from socket');
  136.             $this->close();
  137.         }
  138.         return $raw;
  139.     }
  140.  
  141.     /**
  142.      *    Accessor for socket open state.
  143.      *    @return boolean           True if open.
  144.      *    @access public
  145.      */
  146.     function isOpen() {
  147.         return $this->_is_open;
  148.     }
  149.  
  150.     /**
  151.      *    Closes the socket preventing further reads.
  152.      *    Cannot be reopened once closed.
  153.      *    @return boolean           True if successful.
  154.      *    @access public
  155.      */
  156.     function close() {
  157.         $this->_is_open = false;
  158.         return fclose($this->_handle);
  159.     }
  160.  
  161.     /**
  162.      *    Accessor for content so far.
  163.      *    @return string        Bytes sent only.
  164.      *    @access public
  165.      */
  166.     function getSent() {
  167.         return $this->_sent;
  168.     }
  169.  
  170.     /**
  171.      *    Actually opens the low level socket.
  172.      *    @param string $host          Host to connect to.
  173.      *    @param integer $port         Port on host.
  174.      *    @param integer $error_number Recipient of error code.
  175.      *    @param string $error         Recipoent of error message.
  176.      *    @param integer $timeout      Maximum time to wait for connection.
  177.      *    @access protected
  178.      */
  179.     function _openSocket($host, $port, &$error_number, &$error, $timeout) {
  180.         return @fsockopen($host, $port, $error_number, $error, $timeout);
  181.     }
  182. }
  183.  
  184. /**
  185.  *    Wrapper for TCP/IP socket over TLS.
  186.  *    @package SimpleTest
  187.  *    @subpackage WebTester
  188.  */
  189. class SimpleSecureSocket extends SimpleSocket {
  190.  
  191.     /**
  192.      *    Opens a secure socket for reading and writing.
  193.      *    @param string $host      Hostname to send request to.
  194.      *    @param integer $port     Port on remote machine to open.
  195.      *    @param integer $timeout  Connection timeout in seconds.
  196.      *    @access public
  197.      */
  198.     function SimpleSecureSocket($host, $port, $timeout) {
  199.         $this->SimpleSocket($host, $port, $timeout);
  200.     }
  201.  
  202.     /**
  203.      *    Actually opens the low level socket.
  204.      *    @param string $host          Host to connect to.
  205.      *    @param integer $port         Port on host.
  206.      *    @param integer $error_number Recipient of error code.
  207.      *    @param string $error         Recipient of error message.
  208.      *    @param integer $timeout      Maximum time to wait for connection.
  209.      *    @access protected
  210.      */
  211.     function _openSocket($host, $port, &$error_number, &$error, $timeout) {
  212.         return parent::_openSocket("tls://$host", $port, $error_number, $error, $timeout);
  213.     }
  214. }
  215. ?>

Documentation generated on Sun, 04 May 2008 09:22:10 -0500 by phpDocumentor 1.3.0