694 lines
23 KiB
PHP
694 lines
23 KiB
PHP
|
<?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 __construct($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 __construct($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');
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|