home *** CD-ROM | disk | FTP | other *** search
/ PC World 2003 March / PCWorld_2003-03_cd.bin / Software / Vyzkuste / phptriad / phptriad2-2-1.exe / php / pear / Net / Socket.php < prev   
Encoding:
PHP Script  |  2001-11-13  |  9.8 KB  |  327 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.0 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: Stig Bakken <ssb@fast.no>                                   |
  17. // |          Chuck Hagenbuch <chuck@horde.org>                           |
  18. // +----------------------------------------------------------------------+
  19. //
  20. // $Id: Socket.php,v 1.7.2.2 2001/11/13 01:26:48 ssb Exp $
  21. //
  22.  
  23. require_once 'PEAR.php';
  24.  
  25. /**
  26.  * Generalized Socket class. More docs to be written.
  27.  *
  28.  * @version 0.2
  29.  * @author Stig Bakken <ssb@fast.no>
  30.  * @author Chuck Hagenbuch <chuck@horde.org>
  31.  */
  32. class Net_Socket extends PEAR {
  33.     
  34.     // {{{ properties
  35.     
  36.     /** Socket file pointer. */
  37.     var $fp = null;
  38.     
  39.     /** Whether the socket is blocking. */
  40.     var $blocking = true;
  41.     
  42.     /** Whether the socket is persistent. */
  43.     var $persistent;
  44.     
  45.     /** The IP address to connect to. */
  46.     var $addr = '';
  47.     
  48.     /** The port number to connect to. */
  49.     var $port = 0;
  50.     
  51.     /** Number of seconds to wait on socket connections before
  52.         assuming there's no more data. */
  53.     var $timeout = false;
  54.     
  55.     /** Number of bytes to read at a time in readLine() and
  56.         readAll(). */
  57.     var $lineLength = 2048;
  58.     // }}}
  59.     
  60.     
  61.     // {{{ constructor
  62.     /**
  63.      * Constructs a new Net_Socket object.
  64.      *
  65.      * @access public
  66.      */
  67.     function Net_Socket() {
  68.         $this->PEAR();
  69.     }
  70.     // }}}
  71.     
  72.     
  73.     // {{{ connect()
  74.     /**
  75.      * Connect to the specified port. If called when the socket is
  76.      * already connected, it disconnects and connects again.
  77.      *
  78.      * @param $addr string IP address or host name
  79.      * @param $port int TCP port number
  80.      * @param $persistent bool (optional) whether the connection is
  81.      *        persistent (kept open between requests by the web server)
  82.      * @param $timeout int (optional) how long to wait for data
  83.      * @access public
  84.      * @return mixed true on success or error object
  85.      */
  86.     function connect($addr, $port, $persistent = false, $timeout = false) {
  87.         if (is_resource($this->fp)) {
  88.             @fclose($this->fp);
  89.             $this->fp = null;
  90.         }
  91.         
  92.         if (strspn($addr, '.0123456789') == strlen($addr)) {
  93.             $this->addr = $addr;
  94.         } else {
  95.             $this->addr = gethostbyname($addr);
  96.         }
  97.         $this->port = $port % 65536;
  98.         $this->timeout = $timeout;
  99.         $openfunc = $persistent ? 'pfsockopen' : 'fsockopen';
  100.         $errno = 0;
  101.         $errstr = '';
  102.         if ($this->timeout) {
  103.             $fp = $openfunc($this->addr, $this->port, $errno, $errstr, $this->timeout);
  104.         } else {
  105.             $fp = $openfunc($this->addr, $this->port, $errno, $errstr);
  106.         }
  107.         
  108.         if (!$fp) {
  109.             return new PEAR_Error($errstr, $errno);
  110.         }
  111.         
  112.         socket_set_blocking($fp, $this->blocking);
  113.         $this->fp = $fp;
  114.         $this->persistent = $persistent;
  115.         return true;
  116.     }
  117.     // }}}
  118.     
  119.     // {{{ disconnect()
  120.     /**
  121.      * Disconnects from the peer, closes the socket.
  122.      *
  123.      * @access public
  124.      * @return mixed true on success or an error object otherwise
  125.      */
  126.     function disconnect() {
  127.         if (is_resource($this->fp)) {
  128.             fclose($this->fp);
  129.             $this->fp = null;
  130.             return true;
  131.         }
  132.         return new PEAR_Error("not connected");
  133.     }
  134.     // }}}
  135.     
  136.     // {{{ isBlocking()
  137.     /**
  138.      * Find out if the socket is in blocking mode.
  139.      *
  140.      * @access public
  141.      * @return bool the current blocking mode.
  142.      */
  143.     function isBlocking() {
  144.         return $this->blocking;
  145.     }
  146.     // }}}
  147.     
  148.     // {{{ setBlocking()
  149.     /**
  150.      * Sets whether the socket connection should be blocking or
  151.      * not. A read call to a non-blocking socket will return immediately
  152.      * if there is no data available, whereas it will block until there
  153.      * is data for blocking sockets.
  154.      *
  155.      * @param $mode bool true for blocking sockets, false for nonblocking
  156.      * @access public
  157.      */
  158.     function setBlocking($mode) {
  159.         $this->blocking = $mode;
  160.         if (is_resource($this->fp)) {
  161.             set_socket_blocking($this->fp, $mode);
  162.         }
  163.     }
  164.     // }}}
  165.     
  166.     // {{{ gets()
  167.     function gets($size) {
  168.         if (is_resource($this->fp)) {
  169.             return fgets($this->fp, $size);
  170.         }
  171.         return new PEAR_Error("not connected");
  172.     }
  173.     // }}}
  174.     
  175.     // {{{ read()
  176.     /**
  177.      * Read a specified amount of data. This is guaranteed to return,
  178.      * and has the added benefit of getting everything in one fread()
  179.      * chunk; if you know the size of the data you're getting
  180.      * beforehand, this is definitely the way to go.
  181.      *
  182.      * @param $size The number of bytes to read from the socket.
  183.      * @access public
  184.      * @return $size bytes of data from the socket, or a PEAR_Error if
  185.      *         not connected.
  186.      */
  187.     function read($size) {
  188.         if (is_resource($this->fp)) {
  189.             return fread($this->fp, $size);
  190.         }
  191.         return new PEAR_Error("not connected");
  192.     }
  193.     // }}}
  194.     
  195.     // {{{ write()
  196.     function write($data) {
  197.         if (is_resource($this->fp)) {
  198.             return fwrite($this->fp, $data);
  199.         }
  200.         return new PEAR_Error("not connected");
  201.     }
  202.     // }}}
  203.     
  204.     // {{{ writeLine()
  205.     /**
  206.      * Write a line of data to the socket, followed by a trailing "\r\n".
  207.      *
  208.      * @access public
  209.      * @return mixed fputs result, or an error
  210.      */
  211.     function writeLine ($data) {
  212.         if (is_resource($this->fp)) {
  213.             return fwrite($this->fp, "$data\r\n");
  214.         }
  215.         return new PEAR_Error("not connected");
  216.     }
  217.     // }}}
  218.     
  219.     // {{{ eof()
  220.     function eof() {
  221.         return (is_resource($this->fp) && feof($this->fp));
  222.     }
  223.     // }}}
  224.     
  225.     // {{{ readByte()
  226.     function readByte() {
  227.         if (is_resource($this->fp)) {
  228.             return ord(fread($this->fp, 1));
  229.         }
  230.         return new PEAR_Error("not connected");
  231.     }
  232.     // }}}
  233.     
  234.     // {{{ readWord()
  235.     function readWord() {
  236.         if (is_resource($this->fp)) {
  237.             $buf = fread($this->fp, 2);
  238.             return (ord($buf[0]) + (ord($buf[1]) << 8));
  239.         }
  240.         return new PEAR_Error("not connected");
  241.     }
  242.     // }}}
  243.     
  244.     // {{{ readInt()
  245.     function readInt() {
  246.         if (is_resource($this->fp)) {
  247.             $buf = fread($this->fp, 4);
  248.             return (ord($buf[0]) + (ord($buf[1]) << 8) +
  249.                     (ord($buf[2]) << 16) + (ord($buf[3]) << 24));
  250.         }
  251.         return new PEAR_Error("not connected");
  252.     }
  253.     // }}}
  254.     
  255.     // {{{ readString()
  256.     function readString() {
  257.         if (is_resource($this->fp)) {
  258.             $string = '';
  259.             while (($char = fread($this->fp, 1)) != "\x00")  {
  260.                 $string .= $char;
  261.             }
  262.             return $string;
  263.         }
  264.         return new PEAR_Error("not connected");
  265.     }
  266.     // }}}
  267.     
  268.     // {{{ readIPAddress()
  269.     function readIPAddress() {
  270.         if (is_resource($this->fp)) {
  271.             $buf = fread($this->fp, 4);
  272.             return sprintf("%s.%s.%s.%s", ord($buf[0]), ord($buf[1]),
  273.                            ord($buf[2]), ord($buf[3]));
  274.         }
  275.         return new PEAR_Error("not connected");
  276.     }
  277.     // }}}
  278.     
  279.     // {{{ readLine()
  280.     /**
  281.      * Read until either the end of the socket or a newline, whichever
  282.      * comes first. Strips the trailing newline from the returned data.
  283.      *
  284.      * @access public
  285.      * @return All available data up to a newline, without that
  286.      *         newline, or until the end of the socket.
  287.      */
  288.     function readLine() {
  289.         if (is_resource($this->fp)) {
  290.             $line = '';
  291.             $timeout = time() + $this->timeout;
  292.             while (!feof($this->fp) && (!$this->timeout || time() < $timeout)) {
  293.                 $line .= fgets($this->fp, $this->lineLength);
  294.                 if (strlen($line) >= 2 &&
  295.                     (substr($line, -2) == "\r\n" ||
  296.                      substr($line, -1) == "\n")) {
  297.                     return rtrim($line);
  298.                 }
  299.             }
  300.             return $line;
  301.         }
  302.         return new PEAR_ERROR("not connected");
  303.     }
  304.     // }}}
  305.     
  306.     // {{{ readAll()
  307.     /**
  308.      * Read until the socket closes. THIS FUNCTION WILL NOT EXIT if the
  309.      * socket is in blocking mode until the socket closes.
  310.      *
  311.      * @access public
  312.      * @return All data until the socket closes.
  313.      */
  314.     function readAll() {
  315.         if (is_resource($this->fp)) {
  316.             $data = '';
  317.             while (!feof($this->fp))
  318.                 $data .= fread($this->fp, $this->lineLength);
  319.             return $data;
  320.         }
  321.         return new PEAR_Error("not connected");
  322.     }
  323.     // }}}
  324.     
  325. }
  326. ?>
  327.