cvs: php4 /pear/XML/RPC Client.php Definitions.php Message.php Parser.php Response.php Value.php
| From: | Sebastian Bergmann | Date: | Fri, 13 Oct 2000 08:42:40 +0000 |
| Subject: | cvs: php4 /pear/XML/RPC Client.php Definitions.php Message.php Parser.php Response.php Value.php | ||
| Groups: | php.cvs | ||
| Request: | Send a blank email to php-cvs+get-2039@lists.php.net to get a copy of this message | ||
sbergmann Fri Oct 13 01:42:40 2000 EDT
Added files:
/php4/pear/XML/RPC Client.php Definitions.php Message.php
Parser.php Response.php Value.php
Log:
Added preliminary rewrite of PEAR's XMLRPC interface. This is not working yet!
Index: php4/pear/XML/RPC/Client.php
+++ php4/pear/XML/RPC/Client.php
<?php
//
// +----------------------------------------------------------------------+
// | PHP version 4.0 |
// +----------------------------------------------------------------------+
// | Copyright (c) 1997, 1998, 1999, 2000 The PHP Group |
// +----------------------------------------------------------------------+
// | This source file is subject to version 2.02 of the PHP license, |
// | that is bundled with this package in the file LICENSE, and is |
// | available at through the world-wide-web at |
// | http://www.php.net/license/2_02.txt.
|
// | If you did not receive a copy of the PHP license and are unable to |
// | obtain it through the world-wide-web, please send a note to |
// | license@php.net so we can mail you a copy immediately. |
// +----------------------------------------------------------------------+
// | Authors: Sebastian Bergmann <sb@phpOpenTracker.de> |
// +----------------------------------------------------------------------+
//
// $Id: Client.php,v 1.1 2000/10/13 08:42:40 sbergmann Exp $
//
require_once "XML/RPC/Definitions.php";
require_once "XML/RPC/Message.php";
require_once "XML/RPC/Parser.php";
require_once "XML/RPC/Response.php";
require_once "XML/RPC/Value.php";
class XML_RPC_Client
{
}
?>
Index: php4/pear/XML/RPC/Definitions.php
+++ php4/pear/XML/RPC/Definitions.php
<?php
$XML_RPC_I4 = "i4";
$XML_RPC_Int = "int";
$XML_RPC_Boolean = "boolean";
$XML_RPC_Double = "double";
$XML_RPC_String = "string";
$XML_RPC_DateTime = "dateTime.iso8601";
$XML_RPC_Base64 = "base64";
$XML_RPC_Array = "array";
$XML_RPC_Struct = "struct";
$XML_RPC_defencoding = "UTF-8";
$XML_RPC_erruser = 800;
$XML_RPC_errxml = 100;
$XML_RPC_backslash = chr( 92 ) . chr( 92 );
$XML_RPC_twoslash = $XML_RPC_backslash . $XML_RPC_backslash;
$XML_RPC_twoslash = "2SLS";
$XML_RPC_Types = array( $XML_RPC_I4 => 1,
$XML_RPC_Int => 1,
$XML_RPC_Boolean => 1,
$XML_RPC_String => 1,
$XML_RPC_Double => 1,
$XML_RPC_DateTime => 1,
$XML_RPC_Base64 => 1,
$XML_RPC_Array => 2,
$XML_RPC_Struct => 3
);
$XML_RPC_Entities = array( "quot" => '"',
"amp" => "&",
"lt" => "<",
"gt" => ">",
"apos" => "'"
);
$XML_RPC_err[ "unknown_method" ] = 1;
$XML_RPC_str[ "unknown_method" ] = "Unknown method";
$XML_RPC_err[ "invalid_return" ] = 2;
$XML_RPC_str[ "invalid_return" ] = "Invalid return payload: enabling debugging
to examine incoming payload";
$XML_RPC_err[ "incorrect_params" ] = 3;
$XML_RPC_str[ "incorrect_params" ] = "Incorrect parameters passed to
method";
$XML_RPC_err[ "introspect_unknown" ] = 4;
$XML_RPC_str[ "introspect_unknown" ] = "Can't introspect: method
unknown";
$XML_RPC_err[ "http_error" ] = 5;
$XML_RPC_str[ "http_error" ] = "Didn't receive 200 OK from remote
server.";
$_xh=array();
?>
Index: php4/pear/XML/RPC/Message.php
+++ php4/pear/XML/RPC/Message.php
<?php
require_once "XML/RPC/Definitions.php";
require_once "XML/RPC/Response.php";
require_once "XML/RPC/Value.php";
class XML_RPC_Message
{
var $payload;
var $methodname;
var $params = array();
var $debug = 0;
function XML_RPC_Message( $meth, $pars = 0 )
{
$this->methodname = $meth;
if( is_array( $pars ) && sizeof( $pars ) > 0 )
{
for( $i = 0; $i < sizeof( $pars ); $i++ )
{
$this->addParam( $pars[ $i ] );
}
}
}
function xml_header()
{
return "<?xml version=\"1.0\"?>\n<methodCall>\n";
}
function xml_footer()
{
return "</methodCall>\n";
}
function createPayload()
{
$this->payload = $this->xml_header();
$this->payload .= "<methodName>" . $this->methodname .
"</methodName>\n";
$this->payload .= "<params>\n";
for( $i = 0; $i < sizeof( $this->params ); $i++ )
{
$p = $this->params[ $i ];
$this->payload .= "<param>\n" . $p->serialize() .
"</param>\n";
}
$this->payload .= "</params>\n";
$this->payload .= $this->xml_footer();
$this->payload = ereg_replace( "\n", "\r\n", $this->payload );
}
function method( $meth="" )
{
if( $meth != "" )
{
$this->methodname = $meth;
}
return $this->methodname;
}
function serialize()
{
$this->createPayload();
return $this->payload;
}
function addParam( $par )
{
$this->params[] = $par;
}
function getParam( $i )
{
return $this->params[ $i ];
}
function getNumParams()
{
return sizeof( $this->params );
}
function parseResponseFile( $fp )
{
$ipd="";
while( $data = fread( $fp, 32768 ) )
{
$ipd .= $data;
}
return $this->parseResponse( $ipd );
}
function parseResponse( $data = "" )
{
global $_xh, $XML_RPC_err, $XML_RPC_str;
global $XML_RPC_defencoding;
$parser = xml_parser_create( $XML_RPC_defencoding );
$_xh[ $parser ] = array();
$_xh[ $parser ][ "st" ] = "";
$_xh[ $parser ][ "cm" ] = 0;
$_xh[ $parser ][ "isf" ] = 0;
$_xh[ $parser ][ "ac" ] = "";
xml_parser_set_option( $parser, XML_OPTION_CASE_FOLDING, true );
xml_set_element_handler( $parser, "xmlrpc_se", "xmlrpc_ee" );
xml_set_character_data_handler( $parser, "xmlrpc_cd" );
xml_set_default_handler( $parser, "xmlrpc_dh" );
$XML_RPC_value = new XML_RPC_Value;
$hdrfnd = 0;
if( $this->debug )
{
print "<PRE>---GOT---\n" . htmlspecialchars( $data ) .
"\n---END---\n</PRE>";
}
if( ereg( "^HTTP", $data) && !ereg( "^HTTP/[0-9\.]+ 200 ", $data )
)
{
$errstr= substr( $data, 0, strpos( $data, "\n" ) - 1 );
error_log( "HTTP error, got response: " . $errstr );
$r = new XML_RPC_Response( 0, $XML_RPC_err[ "http_error" ], $XML_RPC_str[
"http_error" ] . " (" . $errstr . ")" );
xml_parser_free( $parser );
return $r;
}
if( ( !$hdrfnd ) && ereg( "^(.*)\r\n\r\n", $data, $_xh[ $parser ][
"ha"] ) )
{
$data = ereg_replace( "^.*\r\n\r\n", "", $data );
$hdrfnd = 1;
}
if( !xml_parse( $parser, $data, sizeof( $data ) ) )
{
if( ( xml_get_current_line_number( $parser ) ) == 1 )
{
$errstr = "XML error at line 1, check URL";
}
else
{
$errstr = sprintf( "XML error: %s at line %d", xml_error_string(
xml_get_error_code( $parser ) ), xml_get_current_line_number( $parser ) );
error_log( $errstr );
$r = new XML_RPC_Response( 0, $XML_RPC_err[ "invalid_return" ], $XML_RPC_str[
"invalid_return" ] );
xml_parser_free( $parser );
return $r;
}
xml_parser_free( $parser );
if( $this->debug )
{
print "<PRE>---EVALING---[" . strlen( $_xh[ $parser ][ "st" ] )
. " chars]---\n" . htmlspecialchars( $_xh[ $parser ][ "st" ] ) .
";\n---END---</PRE>";
}
if( strlen( $_xh[ $parser ][ "st" ] ) == 0 )
{
$r = new XML_RPC_Response( 0, $XML_RPC_err[ "invalid_return" ], $XML_RPC_str[
"invalid_return" ] );
}
else
{
eval( "$v=" . $_xh[ $parser ][ "st"] . "; $allOK=1;" );
if( $_xh[ $parser ][ "isf" ] )
{
$f = $v->structmem( "faultCode" );
$fs = $v->structmem( "faultString" );
$r = new XML_RPC_Response( $v, $f->scalarval(), $fs->scalarval() );
}
else
{
$r = new XML_RPC_Response( $v );
}
}
$r->hdrs = split( "\r?\n", $_xh[ $parser ][ "ha" ][ 1 ] );
return $r;
}
}
}
?>
Index: php4/pear/XML/RPC/Parser.php
+++ php4/pear/XML/RPC/Parser.php
<?php
//
// +----------------------------------------------------------------------+
// | PHP version 4.0 |
// +----------------------------------------------------------------------+
// | Copyright (c) 1997, 1998, 1999, 2000 The PHP Group |
// +----------------------------------------------------------------------+
// | This source file is subject to version 2.02 of the PHP license, |
// | that is bundled with this package in the file LICENSE, and is |
// | available at through the world-wide-web at |
// | http://www.php.net/license/2_02.txt.
|
// | If you did not receive a copy of the PHP license and are unable to |
// | obtain it through the world-wide-web, please send a note to |
// | license@php.net so we can mail you a copy immediately. |
// +----------------------------------------------------------------------+
// | Authors: Sebastian Bergmann <sb@phpOpenTracker.de> |
// +----------------------------------------------------------------------+
//
// $Id: Parser.php,v 1.1 2000/10/13 08:42:40 sbergmann Exp $
//
require_once "XML/RPC/Definitions.php";
require_once "XML/Parser.php";
class XML_RPC_Parser extends XML_Parser
{
var $st;
var $ac;
var $qt;
var $cm;
var $isf;
var $lv;
var $params;
var $method;
function XML_RPC_Parser()
{
$this->XML_Parser();
}
function iso8601_encode( $timet, $utc = 0 )
{
if( !$utc )
{
$t = strftime( "%Y%m%dT%H:%M:%S", $timet );
}
else
{
if( function_exists( "gmstrftime" ) )
{
$t = gmstrftime( "%Y%m%dT%H:%M:%S", $timet );
}
else
{
$t = strftime( "%Y%m%dT%H:%M:%S", $timet - date( "Z" ) );
}
}
return $t;
}
function iso8601_decode( $idate, $utc = 0 )
{
$t = 0;
if( ereg( "([0-9]{4})([0-9]{2})([0-9]{2})T([0-9]{2}):([0-9]{2}):([0-9]{2})", $idate,
$regs ) )
{
if( $utc )
{
$t = gmmktime( $regs[4], $regs[5], $regs[6], $regs[2], $regs[3], $regs[1] );
}
else
{
$t = mktime( $regs[4], $regs[5], $regs[6], $regs[2], $regs[3], $regs[1] );
}
}
return $t;
}
}
?>
Index: php4/pear/XML/RPC/Response.php
+++ php4/pear/XML/RPC/Response.php
<?php
require_once "XML/RPC/Definitions.php";
class XML_RPC_Response
{
var $xv;
var $fn;
var $fs;
var $hdrs;
function XML_RPC_Response( $val, $fcode = 0, $fstr = "" )
{
if( $fcode != 0 )
{
$this->fn = $fcode;
$this->fs = htmlspecialchars( $fstr );
}
else
{
$this->xv = $val;
}
}
function faultCode()
{
return $this->fn;
}
function faultString()
{
return $this->fs;
}
function value()
{
return $this->xv;
}
function serialize()
{
$rs = "<methodResponse>\n";
if( $this->fn )
{
$rs .= "<fault>
<value>
<struct>
<member>
<name>faultCode</name>
<value><int>" . $this->fn . "</int></value>
</member>
<member>
<name>faultString</name>
<value><string>" . $this->fs . "</string></value>
</member>
</struct>
</value>
</fault>";
}
else
{
$rs .= "<params>\n<param>\n" . $this->xv->serialize() .
"</param>\n</params>";
}
$rs .= "\n</methodResponse>";
return $rs;
}
}
?>
Index: php4/pear/XML/RPC/Value.php
+++ php4/pear/XML/RPC/Value.php
<?php
require_once "XML/RPC/Definitions.php";
class XML_RPC_Value
{
var $me = array();
var $mytype = 0;
function XML_RPC_Value( $val = -1, $type = "" )
{
global $XML_RPC_Types;
if( $val != -1 || $type != "" )
{
if( $type == "" )
{
$type = "string";
}
if( $XML_RPC_Types[ $type ] == 1 )
{
$this->addScalar( $val, $type );
}
else if( $XML_RPC_Types[ $type ] == 2 )
{
$this->addArray( $val );
}
else if( $XML_RPC_Types[ $type ] == 3 )
{
$this->addStruct( $val );
}
}
}
function addScalar( $val, $type = "string" )
{
global $XML_RPC_Types, $XML_RPC_Boolean;
if( $this->mytype == 1 )
{
echo "<B>xmlrpcval</B>: scalar can have only one value<BR>";
return 0;
}
$typeof = $XML_RPC_Types[ $type ];
if( $typeof != 1 )
{
echo "<B>xmlrpcval</B>: not a scalar type (${typeof})<BR>";
return 0;
}
if( $type == $XML_RPC_Boolean )
{
if( strcasecmp( $val, "true" ) == 0 || $val == 1 || $val == true )
{
$val = 1;
}
else
{
$val=0;
}
}
if( $this->mytype == 2 )
{
$ar = $this->me[ "array" ];
$ar[] = new XML_RPC_Value( $val, $type );
$this->me[ "array" ] = $ar;
}
else
{
$this->me[ $type ] = $val;
$this->mytype = $typeof;
}
return 1;
}
function addArray( $vals )
{
global $XML_RPC_Types;
if( $this->mytype != 0 )
{
echo "<B>xmlrpcval</B>: already initialized as a [" .
$this->kindOf() . "]<BR>";
return 0;
}
$this->mytype = $XML_RPC_Types[ "array" ];
$this->me[ "array" ] = $vals;
return 1;
}
function addStruct( $vals )
{
global $XML_RPC_Types;
if( $this->mytype != 0 )
{
echo "<B>xmlrpcval</B>: already initialized as a [" .
$this->kindOf() . "]<BR>";
return 0;
}
$this->mytype = $XML_RPC_Types[ "struct" ];
$this->me[ "struct" ] = $vals;
return 1;
}
function dump( $ar )
{
reset( $ar );
while( list( $key, $val ) = each( $ar ) )
{
echo "$key => $val<br>";
if( $key == "array" )
{
while( list( $key2, $val2 ) = each( $val ) )
{
echo "-- $key2 => $val2<br>";
}
}
}
}
function kindOf()
{
switch( $this->mytype )
{
case 3: return "struct";
break;
case 2: return "array";
break;
case 1: return "scalar";
break;
default: return "undef";
}
}
function serializedata( $typ, $val )
{
global $XML_RPC_Types, $XML_RPC_Base64, $XML_RPC_String;
$rs = "";
switch( $XML_RPC_Types[ $typ ] )
{
case 3: $rs .= "<struct>\n";
reset( $val );
while( list( $key2, $val2 ) = each( $val ) )
{
$rs .= "<member><name>${key2}</name>\n";
$rs .= $this->serializeval( $val2 );
$rs .= "</member>\n";
}
$rs .= "</struct>";
break;
case 2: $rs .= "<array>\n<data>\n";
for( $i = 0; $i < sizeof( $val ); $i++ )
{
$rs .= $this->serializeval( $val[ $i ] );
}
$rs .= "</data>\n</array>";
break;
case 1: switch( $typ )
{
case $XML_RPC_Base64: $rs .= "<${typ}>" . base64_encode($val) .
"</${typ}>";
break;
case $XML_RPC_Boolean: $rs.="<${typ}>" . ($val ? "1" :
"0") . "</${typ}>";
break;
case $XML_RPC_String: $rs .= "<${typ}>" .
htmlspecialchars($val). "</${typ}>";
break;
default: $rs .= "<${typ}>${val}</${typ}>";
}
break;
}
return $rs;
}
function serialize()
{
return $this->serializeval( $this );
}
function serializeval( $o )
{
global $XML_RPC_Types;
$rs = "";
$ar = $o->me;
reset( $ar );
list( $typ, $val ) = each( $ar );
$rs .= "<value>";
$rs .= $this->serializedata( $typ, $val );
$rs .=" </value>\n";
return $rs;
}
function structmem( $m )
{
$nv = $this->me[ "struct" ][ $m ];
return $nv;
}
function structreset()
{
reset( $this->me[ "struct" ] );
}
function structeach()
{
return each( $this->me[ "struct" ] );
}
function scalarval()
{
global $XML_RPC_Boolean, $XML_RPC_Base64;
reset( $this->me );
list( $a,$b ) = each( $this->me );
return $b;
}
function scalartyp()
{
global $XML_RPC_I4, $XML_RPC_Int;
reset( $this->me );
list( $a, $b ) = each( $this->me );
if( $a == $XML_RPC_I4)
{
$a=$XML_RPC_Int;
}
return $a;
}
function arraymem( $m )
{
$nv = $this->me[ "array" ][ $m ];
return $nv;
}
function arraysize()
{
reset( $this->me );
list( $a, $b ) = each( $this->me );
return sizeof($b);
}
}
?>