Subversion-Projekte lars-tiefland.php_share

<?php

/**

 * This file holds the Net_DIME_Message and Net_DIME_Record classes and all

 * constants defined for the Net_DIME package.

 *

 * PHP versions 4 and 5

 *

 * Copyright (c) 2002-2007 The PHP Group

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions are met:

 *

 * 1. Redistributions of source code must retain the above copyright notice,

 *    this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright notice,

 *    this list of conditions and the following disclaimer in the documentation

 *    and/or other materials provided with the distribution.

 * 3. The name of the authors may not be used to endorse or promote products

 *    derived from this software without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE

 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

 * POSSIBILITY OF SUCH DAMAGE.

 *

 * @category   Networking

 * @package    Net_DIME

 * @author     Shane Caraveo <shane@caraveo.com>

 * @author     Ralf Hofmann <ralf.hofmann@verdisoft.com>

 * @author     Jan Schneider <jan@horde.org>

 * @copyright  2002-2007 The PHP Group

 * @license    http://www.opensource.org/licenses/bsd-license.php BSD License

 * @link       http://pear.php.net/package/Net_DIME

 * @example    test/dime_record_test.php For example of usage.

 */

/** PEAR */

require_once 'PEAR.php';

define('NET_DIME_TYPE_UNCHANGED', 0x00);

define('NET_DIME_TYPE_MEDIA', 0x01);

define('NET_DIME_TYPE_URI', 0x02);

define('NET_DIME_TYPE_UNKNOWN', 0x03);

define('NET_DIME_TYPE_NONE', 0x04);

define('NET_DIME_VERSION', 0x0001);

define('NET_DIME_RECORD_HEADER', 12);

define('NET_DIME_FLAGS', 0);

define('NET_DIME_OPTS_LEN', 1);

define('NET_DIME_ID_LEN', 2);

define('NET_DIME_TYPE_LEN', 3);

define('NET_DIME_DATA_LEN', 4);

define('NET_DIME_OPTS', 5);

define('NET_DIME_ID', 6);

define('NET_DIME_TYPE', 7);

define('NET_DIME_DATA', 8);

/**

 * Net_DIME_Record encodes and decodes single DIME records.

 *

 * @category   Networking

 * @package    Net_DIME

 * @author     Shane Caraveo <shane@caraveo.com>

 * @author     Ralf Hofmann <ralf.hofmann@verdisoft.com>

 * @author     Jan Schneider <jan@horde.org>

 * @copyright  2002-2007 The PHP Group

 * @license    http://www.opensource.org/licenses/bsd-license.php BSD License

 * @see        Net_DIME_Message

 * @link       http://pear.php.net/package/Net_DIME

 * @link       http://www.ietf.org/internet-drafts/draft-nielsen-dime-02.txt

 */

class Net_DIME_Record {

    // these are used to hold the padded length

    var $OPTS_LENGTH = 0;

    var $ID_LENGTH = 0;

    var $TYPE_LENGTH = 0;

    var $DATA_LENGTH = 0;

    var $_haveOpts = false;

    var $_haveID = false;

    var $_haveType = false;

    var $_haveData = false;

    var $debug = false;

    var $padstr = "\0";

    /**

     * Elements

     * [NET_DIME_FLAGS],    16 bits: VERSION:MB:ME:CF:TYPE_T

     * [NET_DIME_OPTS_LEN], 16 bits: OPTIONS_LENGTH

     * [NET_DIME_ID_LEN],   16 bits: ID_LENGTH

     * [NET_DIME_TYPE_LEN], 16 bits: TYPE_LENGTH

     * [NET_DIME_DATA_LEN], 32 bits: DATA_LENGTH

	 * [NET_DIME_OPTS]             : OPTIONS

	 * [NET_DIME_ID]     		   : ID

	 * [NET_DIME_TYPE]             : TYPE

	 * [NET_DIME_DATA]             : DATA

     */

    var $Elements = array(NET_DIME_FLAGS => 0,  NET_DIME_OPTS_LEN => 0,

	                      NET_DIME_ID_LEN => 0, NET_DIME_TYPE_LEN => 0,

     					  NET_DIME_DATA_LEN => 0,

	 					  NET_DIME_OPTS => '',

						  NET_DIME_ID => '',

						  NET_DIME_TYPE => '',

						  NET_DIME_DATA => '');

    function Net_DIME_Record($debug = false)

    {

        $this->debug = $debug;

        if ($debug) {

            $this->padstr = '*';

        }

    }

    function setMB()

    {

        $this->Elements[NET_DIME_FLAGS] |= 0x0400;

    }

    function setME()

    {

        $this->Elements[NET_DIME_FLAGS] |= 0x0200;

    }

    function setCF()

    {

        $this->Elements[NET_DIME_FLAGS] |= 0x0100;

    }

    function isChunk()

    {

        return $this->Elements[NET_DIME_FLAGS] & 0x0100;

    }

    function isEnd()

    {

        return $this->Elements[NET_DIME_FLAGS] & 0x0200;

    }

    function isStart()

    {

        return $this->Elements[NET_DIME_FLAGS] & 0x0400;

    }

    function getID()

    {

        return $this->Elements[NET_DIME_ID];

    }

    function getType()

    {

        return $this->Elements[NET_DIME_TYPE];

    }

    function getData()

    {

        return $this->Elements[NET_DIME_DATA];

    }

    function getDataLength()

    {

        return $this->Elements[NET_DIME_DATA_LEN];

    }

    function setType($typestring, $type = NET_DIME_TYPE_UNKNOWN)

    {

        $typelen = strlen($typestring) & 0xFFFF;

        $type = $type << 4;

        $this->Elements[NET_DIME_FLAGS] = ($this->Elements[NET_DIME_FLAGS] & 0xFF0F) | $type;

        $this->Elements[NET_DIME_TYPE_LEN] = $typelen;

        $this->TYPE_LENGTH = $this->_getPadLength($typelen);

        $this->Elements[NET_DIME_TYPE] = $typestring;

    }

    function generateID()

    {

        $id = md5(time());

        $this->setID($id);

        return $id;

    }

    function setID($id)

    {

        $idlen = strlen($id) & 0xFFFF;

        $this->Elements[NET_DIME_ID_LEN] = $idlen;

        $this->ID_LENGTH = $this->_getPadLength($idlen);

        $this->Elements[NET_DIME_ID] = $id;

    }

    function setData($data, $size = 0)

    {

        $datalen = $size ? $size : strlen($data);

        $this->Elements[NET_DIME_DATA_LEN] = $datalen;

        $this->DATA_LENGTH = $this->_getPadLength($datalen);

        $this->Elements[NET_DIME_DATA] = $data;

    }

    function encode()

    {

		// Insert version.

	    $this->Elements[NET_DIME_FLAGS] = ($this->Elements[NET_DIME_FLAGS] & 0x07FF) | (NET_DIME_VERSION << 11);

        // The real DIME encoding.

        $format = '%c%c%c%c%c%c%c%c%c%c%c%c'

            . '%' . $this->OPTS_LENGTH . 's'

            . '%' . $this->ID_LENGTH . 's'

            . '%' . $this->TYPE_LENGTH . 's'

            . '%' . $this->DATA_LENGTH . 's';

        return sprintf($format,

	                   ($this->Elements[NET_DIME_FLAGS] & 0x0000FF00) >> 8,

    	               ($this->Elements[NET_DIME_FLAGS] & 0x000000FF),

        	           ($this->Elements[NET_DIME_OPTS_LEN] & 0x0000FF00) >> 8,

            	       ($this->Elements[NET_DIME_OPTS_LEN] & 0x000000FF),

        	           ($this->Elements[NET_DIME_ID_LEN] & 0x0000FF00) >> 8,

            	       ($this->Elements[NET_DIME_ID_LEN] & 0x000000FF),

        	           ($this->Elements[NET_DIME_TYPE_LEN] & 0x0000FF00) >> 8,

            	       ($this->Elements[NET_DIME_TYPE_LEN] & 0x000000FF),

                	   ($this->Elements[NET_DIME_DATA_LEN] & 0xFF000000) >> 24,

	                   ($this->Elements[NET_DIME_DATA_LEN] & 0x00FF0000) >> 16,

    	               ($this->Elements[NET_DIME_DATA_LEN] & 0x0000FF00) >> 8,

        	           ($this->Elements[NET_DIME_DATA_LEN] & 0x000000FF),

            	       str_pad($this->Elements[NET_DIME_OPTS], $this->OPTS_LENGTH, $this->padstr),

            	       str_pad($this->Elements[NET_DIME_ID], $this->ID_LENGTH, $this->padstr),

                	   str_pad($this->Elements[NET_DIME_TYPE], $this->TYPE_LENGTH, $this->padstr),

	                   str_pad($this->Elements[NET_DIME_DATA], $this->DATA_LENGTH, $this->padstr));

    }

    function _getPadLength($len)

    {

        $pad = 0;

        if ($len) {

            $pad = $len % 4;

            if ($pad) $pad = 4 - $pad;

        }

        return $len + $pad;

    }

    function decode($data)

    {

        // Real DIME decoding.

        $this->Elements[NET_DIME_FLAGS]    = (hexdec(bin2hex($data[0])) << 8)

            + hexdec(bin2hex($data[1]));

        $this->Elements[NET_DIME_OPTS_LEN] = (hexdec(bin2hex($data[2])) << 8)

            + hexdec(bin2hex($data[3]));

        $this->Elements[NET_DIME_ID_LEN]   = (hexdec(bin2hex($data[4])) << 8)

            + hexdec(bin2hex($data[5]));

        $this->Elements[NET_DIME_TYPE_LEN] = (hexdec(bin2hex($data[6])) << 8)

            + hexdec(bin2hex($data[7]));

        $this->Elements[NET_DIME_DATA_LEN] = (hexdec(bin2hex($data[8])) << 24)

            + (hexdec(bin2hex($data[9])) << 16)

            + (hexdec(bin2hex($data[10])) << 8)

            + hexdec(bin2hex($data[11]));

        $p = 12;

		$version = (($this->Elements[NET_DIME_FLAGS] >> 11) & 0x001F);

		if ($version == NET_DIME_VERSION) {

	        $this->OPTS_LENGTH = $this->_getPadLength($this->Elements[NET_DIME_OPTS_LEN]);

	        $this->ID_LENGTH = $this->_getPadLength($this->Elements[NET_DIME_ID_LEN]);

	        $this->TYPE_LENGTH = $this->_getPadLength($this->Elements[NET_DIME_TYPE_LEN]);

	        $this->DATA_LENGTH = $this->_getPadLength($this->Elements[NET_DIME_DATA_LEN]);

	        $datalen = strlen($data);

	        $this->Elements[NET_DIME_OPTS] = substr($data, $p, $this->Elements[NET_DIME_OPTS_LEN]);

	        $this->_haveOpts = (strlen($this->Elements[NET_DIME_OPTS]) == $this->Elements[NET_DIME_OPTS_LEN]);

	        if ($this->_haveOpts) {

	            $p += $this->OPTS_LENGTH;

		        $this->Elements[NET_DIME_ID] = substr($data, $p, $this->Elements[NET_DIME_ID_LEN]);

		        $this->_haveID = (strlen($this->Elements[NET_DIME_ID]) == $this->Elements[NET_DIME_ID_LEN]);

		        if ($this->_haveID) {

		            $p += $this->ID_LENGTH;

		            $this->Elements[NET_DIME_TYPE] = substr($data, $p, $this->Elements[NET_DIME_TYPE_LEN]);

		            $this->_haveType = (strlen($this->Elements[NET_DIME_TYPE]) == $this->Elements[NET_DIME_TYPE_LEN]);

		            if ($this->_haveType) {

		                $p += $this->TYPE_LENGTH;

		                $this->Elements[NET_DIME_DATA] = substr($data, $p, $this->Elements[NET_DIME_DATA_LEN]);

		                $this->_haveData = (strlen($this->Elements[NET_DIME_DATA]) == $this->Elements[NET_DIME_DATA_LEN]);

		                if ($this->_haveData) {

		                    $p += $this->DATA_LENGTH;

		                } else {

		                    $p += strlen($this->Elements[NET_DIME_DATA]);

		                }

		            } else {

		                $p += strlen($this->Elements[NET_DIME_TYPE]);

					}

		        } else {

		            $p += strlen($this->Elements[NET_DIME_ID]);

				}

		    } else {

		    	$p += strlen($this->Elements[NET_DIME_OPTS]);

	        }

		}

        return substr($data, $p);

    }

    function addData($data)

    {

        $datalen = strlen($data);

        $p = 0;

        if (!$this->_haveOpts) {

            $have = strlen($this->Elements[NET_DIME_OPTS]);

            $this->Elements[NET_DIME_OPTS] .= substr($data, $p, $this->Elements[NET_DIME_OPTS_LEN] - $have);

            $this->_haveOpts = strlen($this->Elements[NET_DIME_OPTS]) == $this->Elements[NET_DIME_OPTS_LEN];

            if (!$this->_haveOpts) {

                return null;

            }

            $p += $this->OPTS_LENGTH - $have;

        }

        if (!$this->_haveID) {

            $have = strlen($this->Elements[NET_DIME_ID]);

            $this->Elements[NET_DIME_ID] .= substr($data, $p, $this->Elements[NET_DIME_ID_LEN] - $have);

            $this->_haveID = strlen($this->Elements[NET_DIME_ID]) == $this->Elements[NET_DIME_ID_LEN];

            if (!$this->_haveID) {

                return null;

            }

            $p += $this->ID_LENGTH - $have;

        }

        if (!$this->_haveType && $p < $datalen) {

            $have = strlen($this->Elements[NET_DIME_TYPE]);

            $this->Elements[NET_DIME_TYPE] .= substr($data, $p, $this->Elements[NET_DIME_TYPE_LEN] - $have);

            $this->_haveType = strlen($this->Elements[NET_DIME_TYPE]) == $this->Elements[NET_DIME_TYPE_LEN];

            if (!$this->_haveType) {

                return null;

            }

            $p += $this->TYPE_LENGTH - $have;

        }

        if (!$this->_haveData && $p < $datalen) {

            $have = strlen($this->Elements[NET_DIME_DATA]);

            $this->Elements[NET_DIME_DATA] .= substr($data, $p, $this->Elements[NET_DIME_DATA_LEN] - $have);

            $this->_haveData = strlen($this->Elements[NET_DIME_DATA]) == $this->Elements[NET_DIME_DATA_LEN];

            if (!$this->_haveData) {

                return null;

            }

            $p += $this->DATA_LENGTH - $have;

        }

        return substr($data, $p);

    }

}

/**

 * Net_DIME_Message enables you to manipulate and build a DIME encapsulated

 * message.

 *

 * @category   Networking

 * @package    Net_DIME

 * @author     Shane Caraveo <shane@caraveo.com>

 * @author     Ralf Hofmann <ralf.hofmann@verdisoft.com>

 * @author     Jan Schneider <jan@horde.org>

 * @copyright  2002-2007 The PHP Group

 * @license    http://www.opensource.org/licenses/bsd-license.php BSD License

 * @see        Net_DIME_Message

 * @link       http://pear.php.net/package/Net_DIME

 * @link       http://www.ietf.org/internet-drafts/draft-nielsen-dime-02.txt

 * @example    test/dime_message_test.php For example of usage.

 * @todo       - Lots of stuff needs to be tested.

 *             - Definitely have to go through DIME spec and make things work

 *               right, most importantly, sec 3.3.

 *             - Make examples, document.

 */

class Net_DIME_Message {

    var $record_size = 4096;

    var $parts = array();

    var $currentPart = -1;

    var $stream = null;

    var $_currentRecord;

    var $_proc = array();

    var $type;

    var $typestr;

    var $mb = 1;

    var $me = 0;

    var $cf = 0;

    var $id = null;

    var $debug = false;

    /**

     * Constructor.

     *

     * @todo Integrate with PHP streams.

     *

     * @param resource $stream      A file pointer.

     * @param integer $record_size

     * @param boolean $debug

     */

    function Net_DIME_Message($stream = null, $record_size = 4096,

                              $debug = false)

    {

        $this->stream = $stream;

        $this->record_size = $record_size;

        $this->debug = $debug;

    }

    function _makeRecord($data, $typestr = '', $id = null,

                         $type = NET_DIME_TYPE_UNKNOWN)

    {

        $record = new Net_DIME_Record($this->debug);

        if ($this->mb) {

            $record->setMB();

            // all subsequent records are not message begin!

            $this->mb = 0;

        }

        if ($this->me) {

            $record->setME();

        }

        if ($this->cf) {

            $record->setCF();

        }

        $record->setData($data);

        $record->setType($typestr,$type);

        if ($id) {

            $record->setID($id);

        }

        return $record->encode();

    }

    function startChunk($data, $typestr = '', $id = null,

                        $type = NET_DIME_TYPE_UNKNOWN)

    {

        $this->me = 0;

        $this->cf = 1;

        $this->type = $type;

        $this->typestr = $typestr;

        if ($id) {

            $this->id = $id;

        } else {

            $this->id = md5(time());

        }

        return $this->_makeRecord($data, $this->typestr, $this->id, $this->type);

    }

    function doChunk($data)

    {

        $this->me = 0;

        $this->cf = 1;

        return $this->_makeRecord($data, null, null, NET_DIME_TYPE_UNCHANGED);

    }

    function endChunk()

    {

        $this->cf = 0;

        $data = null;

        $rec = $this->_makeRecord($data, null, null, NET_DIME_TYPE_UNCHANGED);

        $this->id = 0;

        $this->cf = 0;

        $this->id = 0;

        $this->type = NET_DIME_TYPE_UNKNOWN;

        $this->typestr = null;

        return $rec;

    }

    function endMessage()

    {

        $this->me = 1;

        $data = null;

        $rec = $this->_makeRecord($data, null, null, NET_DIME_TYPE_NONE);

        $this->me = 0;

        $this->mb = 1;

        $this->id = 0;

        return $rec;

    }

    /**

     * Creates DIME records from a chunk of data and writes them to the stream

     * provided in the constructor.

     *

     * @param string $data

     * @param string $typestr

     * @param string $id

     * @param integer $type    One of the NET_DIME_TYPE_* constants.

     */

    function sendData($data, $typestr='', $id = null,

                      $type = NET_DIME_TYPE_UNKNOWN)

    {

        $len = strlen($data);

        if ($len > $this->record_size) {

            $chunk = substr($data, 0, $this->record_size);

            $p = $this->record_size;

            $rec = $this->startChunk($chunk, $typestr, $id, $type);

            fwrite($this->stream, $rec);

            while ($p < $len) {

                $chunk = substr($data, $p, $this->record_size);

                $p += $this->record_size;

                $rec = $this->doChunk($chunk);

                fwrite($this->stream, $rec);

            }

            $rec = $this->endChunk();

            fwrite($this->stream, $rec);

            return;

        }

        $rec = $this->_makeRecord($data, $typestr, $id, $type);

        fwrite($this->stream, $rec);

    }

    function sendEndMessage()

    {

        $rec = $this->endMessage();

        fwrite($this->stream, $rec);

    }

    /**

     * Reads a file, creates records and writes them to the stream provided in

     * the constructor.

     *

     * @param string $filename  A file name.

     * @param string $typestr

     * @param string $id

     * @param integer $type     One of the NET_DIME_TYPE_* constants.

     */

    function sendFile($filename, $typestr='', $id = null,

                      $type = NET_DIME_TYPE_UNKNOWN)

    {

        $f = fopen($filename, 'rb');

        if ($f) {

            if ($data = fread($f, $this->record_size)) {

                $this->startChunk($data, $typestr, $id, $type);

            }

            while ($data = fread($f, $this->record_size)) {

                $this->doChunk($data, $typestr, $id, $type);

            }

            $this->endChunk();

            fclose($f);

        }

    }

    /**

     * Encodes data in DIME.

     *

     * @param string $data

     * @param string $typestr

     * @param string $id

     * @param integer $type     One of the NET_DIME_TYPE_* constants.

     */

    function encodeData($data, $typestr = '', $id = null,

                        $type = NET_DIME_TYPE_UNKNOWN)

    {

        $len = strlen($data);

        $resp = '';

        if ($len > $this->record_size) {

            $chunk = substr($data, 0, $this->record_size);

            $p = $this->record_size;

            $resp .= $this->startChunk($chunk, $typestr, $id, $type);

            while ($p < $len) {

                $chunk = substr($data, $p, $this->record_size);

                $p += $this->record_size;

                $resp .= $this->doChunk($chunk);

            }

            $resp .= $this->endChunk();

        } else {

            $resp .= $this->_makeRecord($data, $typestr, $id, $type);

        }

        return $resp;

    }

    /**

     * Reads a file, creates records and writes them to the stream provided in

     * the constructor.

     *

     */

    function encodeFile($filename, $typestr = '', $id = null,

                        $type = NET_DIME_TYPE_UNKNOWN)

    {

        $f = fopen($filename, 'rb');

        if ($f) {

            if ($data = fread($f, $this->record_size)) {

                $resp = $this->startChunk($data, $typestr, $id, $type);

            }

            while ($data = fread($f, $this->record_size)) {

                $resp = $this->doChunk($data, $typestr, $id, $type);

            }

            $resp = $this->endChunk();

            fclose($f);

        }

        return $resp;

    }

    /**

     * Creates Net_DIME_Records from provided data.

     */

    function _processData(&$data)

    {

        $leftover = null;

        if (!$this->_currentRecord) {

            $this->_currentRecord = new Net_DIME_Record($this->debug);

            $data = $this->_currentRecord->decode($data);

        } else {

            $data = $this->_currentRecord->addData($data);

        }

        if ($this->_currentRecord->_haveData) {

            if (count($this->parts) == 0 &&

                !$this->_currentRecord->isStart()) {

                return PEAR::raiseError('First Message is not a DIME begin record!');

            }

            if ($this->_currentRecord->isEnd() &&

                $this->_currentRecord->getDataLength() == 0) {

                return;

            }

            if ($this->currentPart < 0 && !$this->_currentRecord->isChunk()) {

                $this->parts[] = array();

                $this->currentPart = count($this->parts) - 1;

                $this->parts[$this->currentPart]['id']   = $this->_currentRecord->getID();

                $this->parts[$this->currentPart]['type'] = $this->_currentRecord->getType();

                $this->parts[$this->currentPart]['data'] = $this->_currentRecord->getData();

                $this->currentPart = -1;

            } else {

                if ($this->currentPart < 0) {

                    $this->parts[] = array();

                    $this->currentPart = count($this->parts) - 1;

                    $this->parts[$this->currentPart]['id']   = $this->_currentRecord->getID();

                    $this->parts[$this->currentPart]['type'] = $this->_currentRecord->getType();

                    $this->parts[$this->currentPart]['data'] = $this->_currentRecord->getData();

                } else {

                    $this->parts[$this->currentPart]['data'] .= $this->_currentRecord->getData();

                    if (!$this->_currentRecord->isChunk()) {

                        // We reached the end of the chunk.

                        $this->currentPart = -1;

                    }

                }

            }

            if (!$this->_currentRecord->isEnd()) {

                $this->_currentRecord = null;

            }

        }

        return;

    }

    /**

     * Decodes a DIME encode string of data.

     */

    function decodeData(&$data)

    {

        while (strlen($data) >= NET_DIME_RECORD_HEADER) {

            $err = $this->_processData($data);

            if (PEAR::isError($err)) {

                return $err;

            }

        }

    }

    /**

     * Reads the stream and creates an array of records.

     *

     * The method can accept the start of a previously read buffer. This is

     * useful in situations where you need to read headers before discovering

     * that the data is DIME encoded, such as in the case of reading an HTTP

     * response.

     */

    function read($buf = null)

    {

        while ($data = fread($this->stream, 8192)) {

            if ($buf) {

                $data = $buf . $data;

                $buf = null;

            }

            if ($this->debug) {

                echo 'read: ' . strlen($data) . " bytes\n";

            }

            $err = $this->decodeData($data);

            if (PEAR::isError($err)) {

                return $err;

            }

            // Store any leftover data to be used again.

            // Should be < NET_DIME_RECORD_HEADER bytes.

            $buf = $data;

        }

        if (!$this->_currentRecord || !$this->_currentRecord->isEnd()) {

            return PEAR::raiseError('reached stream end without end record');

        }

    }

}