\n";
} else {
$rs .= "\n";
}
$charsetEncoder = Charset::instance();
foreach ($val as $key2 => $val2) {
$rs .= '' . $charsetEncoder->encodeEntities($key2, PhpXmlRpc::$xmlrpc_internalencoding, $charsetEncoding) . "\n";
//$rs.=$this->serializeval($val2);
$rs .= $val2->serialize($charsetEncoding);
$rs .= "\n";
}
$rs .= '';
break;
case 2:
// array
$rs .= "\n\n";
foreach ($val as $element) {
//$rs.=$this->serializeval($val[$i]);
$rs .= $element->serialize($charsetEncoding);
}
$rs .= "\n";
break;
default:
break;
}
return $rs;
}
/**
* Returns xml representation of the value. XML prologue not included.
*
* @param string $charsetEncoding the charset to be used for serialization. if null, US-ASCII is assumed
*
* @return string
*/
public function serialize($charsetEncoding = '')
{
// add check? slower, but helps to avoid recursion in serializing broken xmlrpc values...
//if (is_object($o) && (get_class($o) == 'xmlrpcval' || is_subclass_of($o, 'xmlrpcval')))
//{
reset($this->me);
// list($typ, $val) = each($this->me);
$typ = key($this->me);
$val = current($this->me);
return '' . $this->serializedata($typ, $val, $charsetEncoding) . "\n";
//}
}
/**
* Checks whether a struct member with a given name is present.
* Works only on xmlrpc values of type struct.
*
* @param string $key the name of the struct member to be looked up
*
* @return boolean
*
* @deprecated use array access, e.g. isset($val[$key])
*/
public function structmemexists($key)
{
return array_key_exists($key, $this->me['struct']);
}
/**
* Returns the value of a given struct member (an xmlrpc value object in itself).
* Will raise a php warning if struct member of given name does not exist.
*
* @param string $key the name of the struct member to be looked up
*
* @return Value
*
* @deprecated use array access, e.g. $val[$key]
*/
public function structmem($key)
{
return $this->me['struct'][$key];
}
/**
* Reset internal pointer for xmlrpc values of type struct.
* @deprecated iterate directly over the object using foreach instead
*/
public function structreset()
{
reset($this->me['struct']);
}
/**
* Return next member element for xmlrpc values of type struct.
*
* @return Value
*
* @deprecated iterate directly over the object using foreach instead
*/
public function structeach()
{
return each($this->me['struct']);
}
/**
* Returns the value of a scalar xmlrpc value.
*
* @return mixed
*/
public function scalarval()
{
reset($this->me);
// list(, $b) = each($this->me);
$toss = key($this->me);
$b = current($this->me);
return $b;
}
/**
* Returns the type of the xmlrpc value.
* For integers, 'int' is always returned in place of 'i4'.
*
* @return string
*/
public function scalartyp()
{
reset($this->me);
// list($a,) = each($this->me);
$a = key($this->me);
$toss = current($this->me);
if ($a == static::$xmlrpcI4) {
$a = static::$xmlrpcInt;
}
return $a;
}
/**
* Returns the m-th member of an xmlrpc value of struct type.
*
* @param integer $key the index of the value to be retrieved (zero based)
*
* @return Value
*
* @deprecated use array access, e.g. $val[$key]
*/
public function arraymem($key)
{
return $this->me['array'][$key];
}
/**
* Returns the number of members in an xmlrpc value of array type.
*
* @return integer
*
* @deprecated use count() instead
*/
public function arraysize()
{
return count($this->me['array']);
}
/**
* Returns the number of members in an xmlrpc value of struct type.
*
* @return integer
*
* @deprecated use count() instead
*/
public function structsize()
{
return count($this->me['struct']);
}
/**
* Returns the number of members in an xmlrpc value:
* - 0 for uninitialized values
* - 1 for scalars
* - the number of elements for structs and arrays
*
* @return integer
*/
public function count()
{
switch ($this->mytype) {
case 3:
return count($this->me['struct']);
case 2:
return count($this->me['array']);
case 1:
return 1;
default:
return 0;
}
}
/**
* Implements the IteratorAggregate interface
*
* @return ArrayIterator
*/
public function getIterator() {
switch ($this->mytype) {
case 3:
return new \ArrayIterator($this->me['struct']);
case 2:
return new \ArrayIterator($this->me['array']);
case 1:
return new \ArrayIterator($this->me);
default:
return new \ArrayIterator();
}
return new \ArrayIterator();
}
public function offsetSet($offset, $value) {
switch ($this->mytype) {
case 3:
if (!($value instanceof \PhpXmlRpc\Value)) {
throw new \Exception('It is only possible to add Value objects to an XML-RPC Struct');
}
if (is_null($offset)) {
// disallow struct members with empty names
throw new \Exception('It is not possible to add anonymous members to an XML-RPC Struct');
} else {
$this->me['struct'][$offset] = $value;
}
return;
case 2:
if (!($value instanceof \PhpXmlRpc\Value)) {
throw new \Exception('It is only possible to add Value objects to an XML-RPC Array');
}
if (is_null($offset)) {
$this->me['array'][] = $value;
} else {
// nb: we are not checking that $offset is above the existing array range...
$this->me['array'][$offset] = $value;
}
return;
case 1:
// todo: handle i4 vs int
reset($this->me);
// list($type,) = each($this->me);
$type = key($this->me);
$toss = current($this->me);
if ($type != $offset) {
throw new \Exception('');
}
$this->me[$type] = $value;
return;
default:
// it would be nice to allow empty values to be be turned into non-empty ones this way, but we miss info to do so
throw new \Exception("XML-RPC Value is of type 'undef' and its value can not be set using array index");
}
}
public function offsetExists($offset) {
switch ($this->mytype) {
case 3:
return isset($this->me['struct'][$offset]);
case 2:
return isset($this->me['array'][$offset]);
case 1:
// todo: handle i4 vs int
return $offset == $this->scalartyp();
default:
return false;
}
}
public function offsetUnset($offset) {
switch ($this->mytype) {
case 3:
unset($this->me['struct'][$offset]);
return;
case 2:
unset($this->me['array'][$offset]);
return;
case 1:
// can not remove value from a scalar
throw new \Exception("XML-RPC Value is of type 'scalar' and its value can not be unset using array index");
default:
throw new \Exception("XML-RPC Value is of type 'undef' and its value can not be unset using array index");
}
}
public function offsetGet($offset) {
switch ($this->mytype) {
case 3:
return isset($this->me['struct'][$offset]) ? $this->me['struct'][$offset] : null;
case 2:
return isset($this->me['array'][$offset]) ? $this->me['array'][$offset] : null;
case 1:
// on bad type: null or exception?
reset($this->me);
// list($type, $value) = each($this->me);
$type = key($this->me);
$value = current($this->me);
return $type == $offset ? $value : null;
default:
// return null or exception?
throw new \Exception("XML-RPC Value is of type 'undef' and can not be accessed using array index");
}
}
}
/**
* PHP-XMLRPC "wrapper" class.
* Generate stubs to transparently access xmlrpc methods as php functions and vice-versa.
* Note: this class implements the PROXY pattern, but it is not named so to avoid confusion with http proxies.
*
* @todo use some better templating system for code generation?
* @todo implement method wrapping with preservation of php objs in calls
* @todo when wrapping methods without obj rebuilding, use return_type = 'phpvals' (faster)
*/
class Wrapper
{
/// used to hold a reference to object instances whose methods get wrapped by wrapPhpFunction(), in 'create source' mode
public static $objHolder = array();
/**
* Given a string defining a php type or phpxmlrpc type (loosely defined: strings
* accepted come from javadoc blocks), return corresponding phpxmlrpc type.
* Notes:
* - for php 'resource' types returns empty string, since resources cannot be serialized;
* - for php class names returns 'struct', since php objects can be serialized as xmlrpc structs
* - for php arrays always return array, even though arrays sometimes serialize as json structs
* - for 'void' and 'null' returns 'undefined'
*
* @param string $phpType
*
* @return string
*/
public function php2XmlrpcType($phpType)
{
switch (strtolower($phpType)) {
case 'string':
return Value::$xmlrpcString;
case 'integer':
case Value::$xmlrpcInt: // 'int'
case Value::$xmlrpcI4:
return Value::$xmlrpcInt;
case Value::$xmlrpcDouble: // 'double'
return Value::$xmlrpcDouble;
case 'bool':
case Value::$xmlrpcBoolean: // 'boolean'
case 'false':
case 'true':
return Value::$xmlrpcBoolean;
case Value::$xmlrpcArray: // 'array':
return Value::$xmlrpcArray;
case 'object':
case Value::$xmlrpcStruct: // 'struct'
return Value::$xmlrpcStruct;
case Value::$xmlrpcBase64:
return Value::$xmlrpcBase64;
case 'resource':
return '';
default:
if (class_exists($phpType)) {
return Value::$xmlrpcStruct;
} else {
// unknown: might be any 'extended' xmlrpc type
return Value::$xmlrpcValue;
}
}
}
/**
* Given a string defining a phpxmlrpc type return the corresponding php type.
*
* @param string $xmlrpcType
*
* @return string
*/
public function xmlrpc2PhpType($xmlrpcType)
{
switch (strtolower($xmlrpcType)) {
case 'base64':
case 'datetime.iso8601':
case 'string':
return Value::$xmlrpcString;
case 'int':
case 'i4':
return 'integer';
case 'struct':
case 'array':
return 'array';
case 'double':
return 'float';
case 'undefined':
return 'mixed';
case 'boolean':
case 'null':
default:
// unknown: might be any xmlrpc type
return strtolower($xmlrpcType);
}
}
/**
* Given a user-defined PHP function, create a PHP 'wrapper' function that can
* be exposed as xmlrpc method from an xmlrpc server object and called from remote
* clients (as well as its corresponding signature info).
*
* Since php is a typeless language, to infer types of input and output parameters,
* it relies on parsing the javadoc-style comment block associated with the given
* function. Usage of xmlrpc native types (such as datetime.dateTime.iso8601 and base64)
* in the @param tag is also allowed, if you need the php function to receive/send
* data in that particular format (note that base64 encoding/decoding is transparently
* carried out by the lib, while datetime vals are passed around as strings)
*
* Known limitations:
* - only works for user-defined functions, not for PHP internal functions
* (reflection does not support retrieving number/type of params for those)
* - functions returning php objects will generate special structs in xmlrpc responses:
* when the xmlrpc decoding of those responses is carried out by this same lib, using
* the appropriate param in php_xmlrpc_decode, the php objects will be rebuilt.
* In short: php objects can be serialized, too (except for their resource members),
* using this function.
* Other libs might choke on the very same xml that will be generated in this case
* (i.e. it has a nonstandard attribute on struct element tags)
*
* Note that since rel. 2.0RC3 the preferred method to have the server call 'standard'
* php functions (ie. functions not expecting a single Request obj as parameter)
* is by making use of the functions_parameters_type class member.
*
* @param callable $callable the PHP user function to be exposed as xmlrpc method/ a closure, function name, array($obj, 'methodname') or array('class', 'methodname') are ok
* @param string $newFuncName (optional) name for function to be created. Used only when return_source in $extraOptions is true
* @param array $extraOptions (optional) array of options for conversion. valid values include:
* - bool return_source when true, php code w. function definition will be returned, instead of a closure
* - bool encode_php_objs let php objects be sent to server using the 'improved' xmlrpc notation, so server can deserialize them as php objects
* - bool decode_php_objs --- WARNING !!! possible security hazard. only use it with trusted servers ---
* - bool suppress_warnings remove from produced xml any warnings generated at runtime by the php function being invoked
*
* @return array|false false on error, or an array containing the name of the new php function,
* its signature and docs, to be used in the server dispatch map
*
* @todo decide how to deal with params passed by ref in function definition: bomb out or allow?
* @todo finish using phpdoc info to build method sig if all params are named but out of order
* @todo add a check for params of 'resource' type
* @todo add some trigger_errors / error_log when returning false?
* @todo what to do when the PHP function returns NULL? We are currently returning an empty string value...
* @todo add an option to suppress php warnings in invocation of user function, similar to server debug level 3?
* @todo add a verbatim_object_copy parameter to allow avoiding usage the same obj instance?
* @todo add an option to allow generated function to skip validation of number of parameters, as that is done by the server anyway
*/
public function wrapPhpFunction($callable, $newFuncName = '', $extraOptions = array())
{
$buildIt = isset($extraOptions['return_source']) ? !($extraOptions['return_source']) : true;
if (is_string($callable) && strpos($callable, '::') !== false) {
$callable = explode('::', $callable);
}
if (is_array($callable)) {
if (count($callable) < 2 || (!is_string($callable[0]) && !is_object($callable[0]))) {
error_log('XML-RPC: ' . __METHOD__ . ': syntax for function to be wrapped is wrong');
return false;
}
if (is_string($callable[0])) {
$plainFuncName = implode('::', $callable);
} elseif (is_object($callable[0])) {
$plainFuncName = get_class($callable[0]) . '->' . $callable[1];
}
$exists = method_exists($callable[0], $callable[1]);
} else if ($callable instanceof \Closure) {
// we do not support creating code which wraps closures, as php does not allow to serialize them
if (!$buildIt) {
error_log('XML-RPC: ' . __METHOD__ . ': a closure can not be wrapped in generated source code');
return false;
}
$plainFuncName = 'Closure';
$exists = true;
} else {
$plainFuncName = $callable;
$exists = function_exists($callable);
}
if (!$exists) {
error_log('XML-RPC: ' . __METHOD__ . ': function to be wrapped is not defined: ' . $plainFuncName);
return false;
}
$funcDesc = $this->introspectFunction($callable, $plainFuncName);
if (!$funcDesc) {
return false;
}
$funcSigs = $this->buildMethodSignatures($funcDesc);
if ($buildIt) {
$callable = $this->buildWrapFunctionClosure($callable, $extraOptions, $plainFuncName, $funcDesc);
} else {
$newFuncName = $this->newFunctionName($callable, $newFuncName, $extraOptions);
$code = $this->buildWrapFunctionSource($callable, $newFuncName, $extraOptions, $plainFuncName, $funcDesc);
}
$ret = array(
'function' => $callable,
'signature' => $funcSigs['sigs'],
'docstring' => $funcDesc['desc'],
'signature_docs' => $funcSigs['sigsDocs'],
);
if (!$buildIt) {
$ret['function'] = $newFuncName;
$ret['source'] = $code;
}
return $ret;
}
/**
* Introspect a php callable and its phpdoc block and extract information about its signature
*
* @param callable $callable
* @param string $plainFuncName
* @return array|false
*/
protected function introspectFunction($callable, $plainFuncName)
{
// start to introspect PHP code
if (is_array($callable)) {
$func = new \ReflectionMethod($callable[0], $callable[1]);
if ($func->isPrivate()) {
error_log('XML-RPC: ' . __METHOD__ . ': method to be wrapped is private: ' . $plainFuncName);
return false;
}
if ($func->isProtected()) {
error_log('XML-RPC: ' . __METHOD__ . ': method to be wrapped is protected: ' . $plainFuncName);
return false;
}
if ($func->isConstructor()) {
error_log('XML-RPC: ' . __METHOD__ . ': method to be wrapped is the constructor: ' . $plainFuncName);
return false;
}
if ($func->isDestructor()) {
error_log('XML-RPC: ' . __METHOD__ . ': method to be wrapped is the destructor: ' . $plainFuncName);
return false;
}
if ($func->isAbstract()) {
error_log('XML-RPC: ' . __METHOD__ . ': method to be wrapped is abstract: ' . $plainFuncName);
return false;
}
/// @todo add more checks for static vs. nonstatic?
} else {
$func = new \ReflectionFunction($callable);
}
if ($func->isInternal()) {
// Note: from PHP 5.1.0 onward, we will possibly be able to use invokeargs
// instead of getparameters to fully reflect internal php functions ?
error_log('XML-RPC: ' . __METHOD__ . ': function to be wrapped is internal: ' . $plainFuncName);
return false;
}
// retrieve parameter names, types and description from javadoc comments
// function description
$desc = '';
// type of return val: by default 'any'
$returns = Value::$xmlrpcValue;
// desc of return val
$returnsDocs = '';
// type + name of function parameters
$paramDocs = array();
$docs = $func->getDocComment();
if ($docs != '') {
$docs = explode("\n", $docs);
$i = 0;
foreach ($docs as $doc) {
$doc = trim($doc, " \r\t/*");
if (strlen($doc) && strpos($doc, '@') !== 0 && !$i) {
if ($desc) {
$desc .= "\n";
}
$desc .= $doc;
} elseif (strpos($doc, '@param') === 0) {
// syntax: @param type $name [desc]
if (preg_match('/@param\s+(\S+)\s+(\$\S+)\s*(.+)?/', $doc, $matches)) {
$name = strtolower(trim($matches[2]));
//$paramDocs[$name]['name'] = trim($matches[2]);
$paramDocs[$name]['doc'] = isset($matches[3]) ? $matches[3] : '';
$paramDocs[$name]['type'] = $matches[1];
}
$i++;
} elseif (strpos($doc, '@return') === 0) {
// syntax: @return type [desc]
if (preg_match('/@return\s+(\S+)(\s+.+)?/', $doc, $matches)) {
$returns = $matches[1];
if (isset($matches[2])) {
$returnsDocs = trim($matches[2]);
}
}
}
}
}
// execute introspection of actual function prototype
$params = array();
$i = 0;
foreach ($func->getParameters() as $paramObj) {
$params[$i] = array();
$params[$i]['name'] = '$' . $paramObj->getName();
$params[$i]['isoptional'] = $paramObj->isOptional();
$i++;
}
return array(
'desc' => $desc,
'docs' => $docs,
'params' => $params, // array, positionally indexed
'paramDocs' => $paramDocs, // array, indexed by name
'returns' => $returns,
'returnsDocs' =>$returnsDocs,
);
}
/**
* Given the method description given by introspection, create method signature data
*
* @todo support better docs with multiple types separated by pipes by creating multiple signatures
* (this is questionable, as it might produce a big matrix of possible signatures with many such occurrences)
*
* @param array $funcDesc as generated by self::introspectFunction()
*
* @return array
*/
protected function buildMethodSignatures($funcDesc)
{
$i = 0;
$parsVariations = array();
$pars = array();
$pNum = count($funcDesc['params']);
foreach ($funcDesc['params'] as $param) {
/* // match by name real param and documented params
$name = strtolower($param['name']);
if (!isset($funcDesc['paramDocs'][$name])) {
$funcDesc['paramDocs'][$name] = array();
}
if (!isset($funcDesc['paramDocs'][$name]['type'])) {
$funcDesc['paramDocs'][$name]['type'] = 'mixed';
}*/
if ($param['isoptional']) {
// this particular parameter is optional. save as valid previous list of parameters
$parsVariations[] = $pars;
}
$pars[] = "\$p$i";
$i++;
if ($i == $pNum) {
// last allowed parameters combination
$parsVariations[] = $pars;
}
}
if (count($parsVariations) == 0) {
// only known good synopsis = no parameters
$parsVariations[] = array();
}
$sigs = array();
$sigsDocs = array();
foreach ($parsVariations as $pars) {
// build a signature
$sig = array($this->php2XmlrpcType($funcDesc['returns']));
$pSig = array($funcDesc['returnsDocs']);
for ($i = 0; $i < count($pars); $i++) {
$name = strtolower($funcDesc['params'][$i]['name']);
if (isset($funcDesc['paramDocs'][$name]['type'])) {
$sig[] = $this->php2XmlrpcType($funcDesc['paramDocs'][$name]['type']);
} else {
$sig[] = Value::$xmlrpcValue;
}
$pSig[] = isset($funcDesc['paramDocs'][$name]['doc']) ? $funcDesc['paramDocs'][$name]['doc'] : '';
}
$sigs[] = $sig;
$sigsDocs[] = $pSig;
}
return array(
'sigs' => $sigs,
'sigsDocs' => $sigsDocs
);
}
/**
* Creates a closure that will execute $callable
* @todo validate params? In theory all validation is left to the dispatch map...
* @todo add support for $catchWarnings
*
* @param $callable
* @param array $extraOptions
* @param string $plainFuncName
* @param string $funcDesc
* @return \Closure
*/
protected function buildWrapFunctionClosure($callable, $extraOptions, $plainFuncName, $funcDesc)
{
$function = function($req) use($callable, $extraOptions, $funcDesc)
{
$nameSpace = '\\PhpXmlRpc\\';
$encoderClass = $nameSpace.'Encoder';
$responseClass = $nameSpace.'Response';
$valueClass = $nameSpace.'Value';
// validate number of parameters received
// this should be optional really, as we assume the server does the validation
$minPars = count($funcDesc['params']);
$maxPars = $minPars;
foreach ($funcDesc['params'] as $i => $param) {
if ($param['isoptional']) {
// this particular parameter is optional. We assume later ones are as well
$minPars = $i;
break;
}
}
$numPars = $req->getNumParams();
if ($numPars < $minPars || $numPars > $maxPars) {
return new $responseClass(0, 3, 'Incorrect parameters passed to method');
}
$encoder = new $encoderClass();
$options = array();
if (isset($extraOptions['decode_php_objs']) && $extraOptions['decode_php_objs']) {
$options[] = 'decode_php_objs';
}
$params = $encoder->decode($req, $options);
$result = call_user_func_array($callable, $params);
if (! is_a($result, $responseClass)) {
if ($funcDesc['returns'] == Value::$xmlrpcDateTime || $funcDesc['returns'] == Value::$xmlrpcBase64) {
$result = new $valueClass($result, $funcDesc['returns']);
} else {
$options = array();
if (isset($extraOptions['encode_php_objs']) && $extraOptions['encode_php_objs']) {
$options[] = 'encode_php_objs';
}
$result = $encoder->encode($result, $options);
}
$result = new $responseClass($result);
}
return $result;
};
return $function;
}
/**
* Return a name for a new function, based on $callable, insuring its uniqueness
* @param mixed $callable a php callable, or the name of an xmlrpc method
* @param string $newFuncName when not empty, it is used instead of the calculated version
* @return string
*/
protected function newFunctionName($callable, $newFuncName, $extraOptions)
{
// determine name of new php function
$prefix = isset($extraOptions['prefix']) ? $extraOptions['prefix'] : 'xmlrpc';
if ($newFuncName == '') {
if (is_array($callable)) {
if (is_string($callable[0])) {
$xmlrpcFuncName = "{$prefix}_" . implode('_', $callable);
} else {
$xmlrpcFuncName = "{$prefix}_" . get_class($callable[0]) . '_' . $callable[1];
}
} else {
if ($callable instanceof \Closure) {
$xmlrpcFuncName = "{$prefix}_closure";
} else {
$callable = preg_replace(array('/\./', '/[^a-zA-Z0-9_\x7f-\xff]/'),
array('_', ''), $callable);
$xmlrpcFuncName = "{$prefix}_$callable";
}
}
} else {
$xmlrpcFuncName = $newFuncName;
}
while (function_exists($xmlrpcFuncName)) {
$xmlrpcFuncName .= 'x';
}
return $xmlrpcFuncName;
}
/**
* @param $callable
* @param string $newFuncName
* @param array $extraOptions
* @param string $plainFuncName
* @param array $funcDesc
* @return string
*
* @todo add a nice phpdoc block in the generated source
*/
protected function buildWrapFunctionSource($callable, $newFuncName, $extraOptions, $plainFuncName, $funcDesc)
{
$namespace = '\\PhpXmlRpc\\';
$encodePhpObjects = isset($extraOptions['encode_php_objs']) ? (bool)$extraOptions['encode_php_objs'] : false;
$decodePhpObjects = isset($extraOptions['decode_php_objs']) ? (bool)$extraOptions['decode_php_objs'] : false;
$catchWarnings = isset($extraOptions['suppress_warnings']) && $extraOptions['suppress_warnings'] ? '@' : '';
$i = 0;
$parsVariations = array();
$pars = array();
$pNum = count($funcDesc['params']);
foreach ($funcDesc['params'] as $param) {
if ($param['isoptional']) {
// this particular parameter is optional. save as valid previous list of parameters
$parsVariations[] = $pars;
}
$pars[] = "\$p[$i]";
$i++;
if ($i == $pNum) {
// last allowed parameters combination
$parsVariations[] = $pars;
}
}
if (count($parsVariations) == 0) {
// only known good synopsis = no parameters
$parsVariations[] = array();
$minPars = 0;
$maxPars = 0;
} else {
$minPars = count($parsVariations[0]);
$maxPars = count($parsVariations[count($parsVariations)-1]);
}
// build body of new function
$innerCode = "\$paramCount = \$req->getNumParams();\n";
$innerCode .= "if (\$paramCount < $minPars || \$paramCount > $maxPars) return new {$namespace}Response(0, " . PhpXmlRpc::$xmlrpcerr['incorrect_params'] . ", '" . PhpXmlRpc::$xmlrpcstr['incorrect_params'] . "');\n";
$innerCode .= "\$encoder = new {$namespace}Encoder();\n";
if ($decodePhpObjects) {
$innerCode .= "\$p = \$encoder->decode(\$req, array('decode_php_objs'));\n";
} else {
$innerCode .= "\$p = \$encoder->decode(\$req);\n";
}
// since we are building source code for later use, if we are given an object instance,
// we go out of our way and store a pointer to it in a static class var var...
if (is_array($callable) && is_object($callable[0])) {
self::$objHolder[$newFuncName] = $callable[0];
$innerCode .= "\$obj = PhpXmlRpc\\Wrapper::\$objHolder['$newFuncName'];\n";
$realFuncName = '$obj->' . $callable[1];
} else {
$realFuncName = $plainFuncName;
}
foreach ($parsVariations as $i => $pars) {
$innerCode .= "if (\$paramCount == " . count($pars) . ") \$retval = {$catchWarnings}$realFuncName(" . implode(',', $pars) . ");\n";
if ($i < (count($parsVariations) - 1))
$innerCode .= "else\n";
}
$innerCode .= "if (is_a(\$retval, '{$namespace}Response')) return \$retval; else\n";
if ($funcDesc['returns'] == Value::$xmlrpcDateTime || $funcDesc['returns'] == Value::$xmlrpcBase64) {
$innerCode .= "return new {$namespace}Response(new {$namespace}Value(\$retval, '{$funcDesc['returns']}'));";
} else {
if ($encodePhpObjects) {
$innerCode .= "return new {$namespace}Response(\$encoder->encode(\$retval, array('encode_php_objs')));\n";
} else {
$innerCode .= "return new {$namespace}Response(\$encoder->encode(\$retval));\n";
}
}
// shall we exclude functions returning by ref?
// if($func->returnsReference())
// return false;
$code = "function $newFuncName(\$req) {\n" . $innerCode . "\n}";
return $code;
}
/**
* Given a user-defined PHP class or php object, map its methods onto a list of
* PHP 'wrapper' functions that can be exposed as xmlrpc methods from an xmlrpc server
* object and called from remote clients (as well as their corresponding signature info).
*
* @param string|object $className the name of the class whose methods are to be exposed as xmlrpc methods, or an object instance of that class
* @param array $extraOptions see the docs for wrapPhpMethod for basic options, plus
* - string method_type 'static', 'nonstatic', 'all' and 'auto' (default); the latter will switch between static and non-static depending on whether $className is a class name or object instance
* - string method_filter a regexp used to filter methods to wrap based on their names
* - string prefix used for the names of the xmlrpc methods created
*
* @return array|false false on failure
*/
public function wrapPhpClass($className, $extraOptions = array())
{
$methodFilter = isset($extraOptions['method_filter']) ? $extraOptions['method_filter'] : '';
$methodType = isset($extraOptions['method_type']) ? $extraOptions['method_type'] : 'auto';
$prefix = isset($extraOptions['prefix']) ? $extraOptions['prefix'] : '';
$results = array();
$mList = get_class_methods($className);
foreach ($mList as $mName) {
if ($methodFilter == '' || preg_match($methodFilter, $mName)) {
$func = new \ReflectionMethod($className, $mName);
if (!$func->isPrivate() && !$func->isProtected() && !$func->isConstructor() && !$func->isDestructor() && !$func->isAbstract()) {
if (($func->isStatic() && ($methodType == 'all' || $methodType == 'static' || ($methodType == 'auto' && is_string($className)))) ||
(!$func->isStatic() && ($methodType == 'all' || $methodType == 'nonstatic' || ($methodType == 'auto' && is_object($className))))
) {
$methodWrap = $this->wrapPhpFunction(array($className, $mName), '', $extraOptions);
if ($methodWrap) {
if (is_object($className)) {
$realClassName = get_class($className);
}else {
$realClassName = $className;
}
$results[$prefix."$realClassName.$mName"] = $methodWrap;
}
}
}
}
}
return $results;
}
/**
* Given an xmlrpc client and a method name, register a php wrapper function
* that will call it and return results using native php types for both
* params and results. The generated php function will return a Response
* object for failed xmlrpc calls.
*
* Known limitations:
* - server must support system.methodsignature for the wanted xmlrpc method
* - for methods that expose many signatures, only one can be picked (we
* could in principle check if signatures differ only by number of params
* and not by type, but it would be more complication than we can spare time)
* - nested xmlrpc params: the caller of the generated php function has to
* encode on its own the params passed to the php function if these are structs
* or arrays whose (sub)members include values of type datetime or base64
*
* Notes: the connection properties of the given client will be copied
* and reused for the connection used during the call to the generated
* php function.
* Calling the generated php function 'might' be slow: a new xmlrpc client
* is created on every invocation and an xmlrpc-connection opened+closed.
* An extra 'debug' param is appended to param list of xmlrpc method, useful
* for debugging purposes.
*
* @todo allow caller to give us the method signature instead of querying for it, or just say 'skip it'
* @todo if we can not retrieve method signature, create a php function with varargs
* @todo allow the created function to throw exceptions on method calls failures
* @todo if caller did not specify a specific sig, shall we support all of them?
* It might be hard (hence slow) to match based on type and number of arguments...
*
* @param Client $client an xmlrpc client set up correctly to communicate with target server
* @param string $methodName the xmlrpc method to be mapped to a php function
* @param array $extraOptions array of options that specify conversion details. Valid options include
* - integer signum the index of the method signature to use in mapping (if method exposes many sigs)
* - integer timeout timeout (in secs) to be used when executing function/calling remote method
* - string protocol 'http' (default), 'http11' or 'https'
* - string new_function_name the name of php function to create, when return_source is used. If unspecified, lib will pick an appropriate name
* - string return_source if true return php code w. function definition instead of function itself (closure)
* - bool encode_php_objs let php objects be sent to server using the 'improved' xmlrpc notation, so server can deserialize them as php objects
* - bool decode_php_objs --- WARNING !!! possible security hazard. only use it with trusted servers ---
* - mixed return_on_fault a php value to be returned when the xmlrpc call fails/returns a fault response (by default the Response object is returned in this case). If a string is used, '%faultCode%' and '%faultString%' tokens will be substituted with actual error values
* - bool debug set it to 1 or 2 to see debug results of querying server for method synopsis
* - int simple_client_copy set it to 1 to have a lightweight copy of the $client object made in the generated code (only used when return_source = true)
*
* @return \closure|array|false false on failure, closure by default and array for return_source = true
*/
public function wrapXmlrpcMethod($client, $methodName, $extraOptions = array())
{
$newFuncName = isset($extraOptions['new_function_name']) ? $extraOptions['new_function_name'] : '';
$buildIt = isset($extraOptions['return_source']) ? !($extraOptions['return_source']) : true;
$mSig = $this->retrieveMethodSignature($client, $methodName, $extraOptions);
if (!$mSig) {
return false;
}
if ($buildIt) {
return $this->buildWrapMethodClosure($client, $methodName, $extraOptions, $mSig);
} else {
// if in 'offline' mode, retrieve method description too.
// in online mode, favour speed of operation
$mDesc = $this->retrieveMethodHelp($client, $methodName, $extraOptions);
$newFuncName = $this->newFunctionName($methodName, $newFuncName, $extraOptions);
$results = $this->buildWrapMethodSource($client, $methodName, $extraOptions, $newFuncName, $mSig, $mDesc);
/* was: $results = $this->build_remote_method_wrapper_code($client, $methodName,
$newFuncName, $mSig, $mDesc, $timeout, $protocol, $simpleClientCopy,
$prefix, $decodePhpObjects, $encodePhpObjects, $decodeFault,
$faultResponse, $namespace);*/
$results['function'] = $newFuncName;
return $results;
}
}
/**
* Retrieves an xmlrpc method signature from a server which supports system.methodSignature
* @param Client $client
* @param string $methodName
* @param array $extraOptions
* @return false|array
*/
protected function retrieveMethodSignature($client, $methodName, array $extraOptions = array())
{
$namespace = '\\PhpXmlRpc\\';
$reqClass = $namespace . 'Request';
$valClass = $namespace . 'Value';
$decoderClass = $namespace . 'Encoder';
$debug = isset($extraOptions['debug']) ? ($extraOptions['debug']) : 0;
$timeout = isset($extraOptions['timeout']) ? (int)$extraOptions['timeout'] : 0;
$protocol = isset($extraOptions['protocol']) ? $extraOptions['protocol'] : '';
$sigNum = isset($extraOptions['signum']) ? (int)$extraOptions['signum'] : 0;
$req = new $reqClass('system.methodSignature');
$req->addparam(new $valClass($methodName));
$client->setDebug($debug);
$response = $client->send($req, $timeout, $protocol);
if ($response->faultCode()) {
error_log('XML-RPC: ' . __METHOD__ . ': could not retrieve method signature from remote server for method ' . $methodName);
return false;
}
$mSig = $response->value();
if ($client->return_type != 'phpvals') {
$decoder = new $decoderClass();
$mSig = $decoder->decode($mSig);
}
if (!is_array($mSig) || count($mSig) <= $sigNum) {
error_log('XML-RPC: ' . __METHOD__ . ': could not retrieve method signature nr.' . $sigNum . ' from remote server for method ' . $methodName);
return false;
}
return $mSig[$sigNum];
}
/**
* @param Client $client
* @param string $methodName
* @param array $extraOptions
* @return string in case of any error, an empty string is returned, no warnings generated
*/
protected function retrieveMethodHelp($client, $methodName, array $extraOptions = array())
{
$namespace = '\\PhpXmlRpc\\';
$reqClass = $namespace . 'Request';
$valClass = $namespace . 'Value';
$debug = isset($extraOptions['debug']) ? ($extraOptions['debug']) : 0;
$timeout = isset($extraOptions['timeout']) ? (int)$extraOptions['timeout'] : 0;
$protocol = isset($extraOptions['protocol']) ? $extraOptions['protocol'] : '';
$mDesc = '';
$req = new $reqClass('system.methodHelp');
$req->addparam(new $valClass($methodName));
$client->setDebug($debug);
$response = $client->send($req, $timeout, $protocol);
if (!$response->faultCode()) {
$mDesc = $response->value();
if ($client->return_type != 'phpvals') {
$mDesc = $mDesc->scalarval();
}
}
return $mDesc;
}
/**
* @param Client $client
* @param string $methodName
* @param array $extraOptions
* @param string $mSig
* @return \Closure
*
* @todo should we allow usage of parameter simple_client_copy to mean 'do not clone' in this case?
*/
protected function buildWrapMethodClosure($client, $methodName, array $extraOptions, $mSig)
{
// we clone the client, so that we can modify it a bit independently of the original
$clientClone = clone $client;
$function = function() use($clientClone, $methodName, $extraOptions, $mSig)
{
$timeout = isset($extraOptions['timeout']) ? (int)$extraOptions['timeout'] : 0;
$protocol = isset($extraOptions['protocol']) ? $extraOptions['protocol'] : '';
$encodePhpObjects = isset($extraOptions['encode_php_objs']) ? (bool)$extraOptions['encode_php_objs'] : false;
$decodePhpObjects = isset($extraOptions['decode_php_objs']) ? (bool)$extraOptions['decode_php_objs'] : false;
if (isset($extraOptions['return_on_fault'])) {
$decodeFault = true;
$faultResponse = $extraOptions['return_on_fault'];
} else {
$decodeFault = false;
}
$namespace = '\\PhpXmlRpc\\';
$reqClass = $namespace . 'Request';
$encoderClass = $namespace . 'Encoder';
$valueClass = $namespace . 'Value';
$encoder = new $encoderClass();
$encodeOptions = array();
if ($encodePhpObjects) {
$encodeOptions[] = 'encode_php_objs';
}
$decodeOptions = array();
if ($decodePhpObjects) {
$decodeOptions[] = 'decode_php_objs';
}
/// @todo check for insufficient nr. of args besides excess ones? note that 'source' version does not...
// support one extra parameter: debug
$maxArgs = count($mSig)-1; // 1st element is the return type
$currentArgs = func_get_args();
if (func_num_args() == ($maxArgs+1)) {
$debug = array_pop($currentArgs);
$clientClone->setDebug($debug);
}
$xmlrpcArgs = array();
foreach($currentArgs as $i => $arg) {
if ($i == $maxArgs) {
break;
}
$pType = $mSig[$i+1];
if ($pType == 'i4' || $pType == 'int' || $pType == 'boolean' || $pType == 'double' ||
$pType == 'string' || $pType == 'dateTime.iso8601' || $pType == 'base64' || $pType == 'null'
) {
// by building directly xmlrpc values when type is known and scalar (instead of encode() calls),
// we make sure to honour the xmlrpc signature
$xmlrpcArgs[] = new $valueClass($arg, $pType);
} else {
$xmlrpcArgs[] = $encoder->encode($arg, $encodeOptions);
}
}
$req = new $reqClass($methodName, $xmlrpcArgs);
// use this to get the maximum decoding flexibility
$clientClone->return_type = 'xmlrpcvals';
$resp = $clientClone->send($req, $timeout, $protocol);
if ($resp->faultcode()) {
if ($decodeFault) {
if (is_string($faultResponse) && ((strpos($faultResponse, '%faultCode%') !== false) ||
(strpos($faultResponse, '%faultString%') !== false))) {
$faultResponse = str_replace(array('%faultCode%', '%faultString%'),
array($resp->faultCode(), $resp->faultString()), $faultResponse);
}
return $faultResponse;
} else {
return $resp;
}
} else {
return $encoder->decode($resp->value(), $decodeOptions);
}
};
return $function;
}
/**
* @param Client $client
* @param string $methodName
* @param array $extraOptions
* @param string $newFuncName
* @param array $mSig
* @param string $mDesc
* @return array
*/
public function buildWrapMethodSource($client, $methodName, array $extraOptions, $newFuncName, $mSig, $mDesc='')
{
$timeout = isset($extraOptions['timeout']) ? (int)$extraOptions['timeout'] : 0;
$protocol = isset($extraOptions['protocol']) ? $extraOptions['protocol'] : '';
$encodePhpObjects = isset($extraOptions['encode_php_objs']) ? (bool)$extraOptions['encode_php_objs'] : false;
$decodePhpObjects = isset($extraOptions['decode_php_objs']) ? (bool)$extraOptions['decode_php_objs'] : false;
$clientCopyMode = isset($extraOptions['simple_client_copy']) ? (int)($extraOptions['simple_client_copy']) : 0;
$prefix = isset($extraOptions['prefix']) ? $extraOptions['prefix'] : 'xmlrpc';
if (isset($extraOptions['return_on_fault'])) {
$decodeFault = true;
$faultResponse = $extraOptions['return_on_fault'];
} else {
$decodeFault = false;
$faultResponse = '';
}
$namespace = '\\PhpXmlRpc\\';
$code = "function $newFuncName (";
if ($clientCopyMode < 2) {
// client copy mode 0 or 1 == full / partial client copy in emitted code
$verbatimClientCopy = !$clientCopyMode;
$innerCode = $this->buildClientWrapperCode($client, $verbatimClientCopy, $prefix, $namespace);
$innerCode .= "\$client->setDebug(\$debug);\n";
$this_ = '';
} else {
// client copy mode 2 == no client copy in emitted code
$innerCode = '';
$this_ = 'this->';
}
$innerCode .= "\$req = new {$namespace}Request('$methodName');\n";
if ($mDesc != '') {
// take care that PHP comment is not terminated unwillingly by method description
$mDesc = "/**\n* " . str_replace('*/', '* /', $mDesc) . "\n";
} else {
$mDesc = "/**\nFunction $newFuncName\n";
}
// param parsing
$innerCode .= "\$encoder = new {$namespace}Encoder();\n";
$plist = array();
$pCount = count($mSig);
for ($i = 1; $i < $pCount; $i++) {
$plist[] = "\$p$i";
$pType = $mSig[$i];
if ($pType == 'i4' || $pType == 'int' || $pType == 'boolean' || $pType == 'double' ||
$pType == 'string' || $pType == 'dateTime.iso8601' || $pType == 'base64' || $pType == 'null'
) {
// only build directly xmlrpc values when type is known and scalar
$innerCode .= "\$p$i = new {$namespace}Value(\$p$i, '$pType');\n";
} else {
if ($encodePhpObjects) {
$innerCode .= "\$p$i = \$encoder->encode(\$p$i, array('encode_php_objs'));\n";
} else {
$innerCode .= "\$p$i = \$encoder->encode(\$p$i);\n";
}
}
$innerCode .= "\$req->addparam(\$p$i);\n";
$mDesc .= '* @param ' . $this->xmlrpc2PhpType($pType) . " \$p$i\n";
}
if ($clientCopyMode < 2) {
$plist[] = '$debug=0';
$mDesc .= "* @param int \$debug when 1 (or 2) will enable debugging of the underlying {$prefix} call (defaults to 0)\n";
}
$plist = implode(', ', $plist);
$mDesc .= '* @return ' . $this->xmlrpc2PhpType($mSig[0]) . " (or an {$namespace}Response obj instance if call fails)\n*/\n";
$innerCode .= "\$res = \${$this_}client->send(\$req, $timeout, '$protocol');\n";
if ($decodeFault) {
if (is_string($faultResponse) && ((strpos($faultResponse, '%faultCode%') !== false) || (strpos($faultResponse, '%faultString%') !== false))) {
$respCode = "str_replace(array('%faultCode%', '%faultString%'), array(\$res->faultCode(), \$res->faultString()), '" . str_replace("'", "''", $faultResponse) . "')";
} else {
$respCode = var_export($faultResponse, true);
}
} else {
$respCode = '$res';
}
if ($decodePhpObjects) {
$innerCode .= "if (\$res->faultcode()) return $respCode; else return \$encoder->decode(\$res->value(), array('decode_php_objs'));";
} else {
$innerCode .= "if (\$res->faultcode()) return $respCode; else return \$encoder->decode(\$res->value());";
}
$code = $code . $plist . ") {\n" . $innerCode . "\n}\n";
return array('source' => $code, 'docstring' => $mDesc);
}
/**
* Similar to wrapXmlrpcMethod, but will generate a php class that wraps
* all xmlrpc methods exposed by the remote server as own methods.
* For more details see wrapXmlrpcMethod.
*
* For a slimmer alternative, see the code in demo/client/proxy.php
*
* Note that unlike wrapXmlrpcMethod, we always have to generate php code here. It seems that php 7 will have anon classes...
*
* @param Client $client the client obj all set to query the desired server
* @param array $extraOptions list of options for wrapped code. See the ones from wrapXmlrpcMethod plus
* - string method_filter regular expression
* - string new_class_name
* - string prefix
* - bool simple_client_copy set it to true to avoid copying all properties of $client into the copy made in the new class
*
* @return mixed false on error, the name of the created class if all ok or an array with code, class name and comments (if the appropriatevoption is set in extra_options)
*/
public function wrapXmlrpcServer($client, $extraOptions = array())
{
$methodFilter = isset($extraOptions['method_filter']) ? $extraOptions['method_filter'] : '';
$timeout = isset($extraOptions['timeout']) ? (int)$extraOptions['timeout'] : 0;
$protocol = isset($extraOptions['protocol']) ? $extraOptions['protocol'] : '';
$newClassName = isset($extraOptions['new_class_name']) ? $extraOptions['new_class_name'] : '';
$encodePhpObjects = isset($extraOptions['encode_php_objs']) ? (bool)$extraOptions['encode_php_objs'] : false;
$decodePhpObjects = isset($extraOptions['decode_php_objs']) ? (bool)$extraOptions['decode_php_objs'] : false;
$verbatimClientCopy = isset($extraOptions['simple_client_copy']) ? !($extraOptions['simple_client_copy']) : true;
$buildIt = isset($extraOptions['return_source']) ? !($extraOptions['return_source']) : true;
$prefix = isset($extraOptions['prefix']) ? $extraOptions['prefix'] : 'xmlrpc';
$namespace = '\\PhpXmlRpc\\';
$reqClass = $namespace . 'Request';
$decoderClass = $namespace . 'Encoder';
$req = new $reqClass('system.listMethods');
$response = $client->send($req, $timeout, $protocol);
if ($response->faultCode()) {
error_log('XML-RPC: ' . __METHOD__ . ': could not retrieve method list from remote server');
return false;
} else {
$mList = $response->value();
if ($client->return_type != 'phpvals') {
$decoder = new $decoderClass();
$mList = $decoder->decode($mList);
}
if (!is_array($mList) || !count($mList)) {
error_log('XML-RPC: ' . __METHOD__ . ': could not retrieve meaningful method list from remote server');
return false;
} else {
// pick a suitable name for the new function, avoiding collisions
if ($newClassName != '') {
$xmlrpcClassName = $newClassName;
} else {
$xmlrpcClassName = $prefix . '_' . preg_replace(array('/\./', '/[^a-zA-Z0-9_\x7f-\xff]/'),
array('_', ''), $client->server) . '_client';
}
while ($buildIt && class_exists($xmlrpcClassName)) {
$xmlrpcClassName .= 'x';
}
/// @todo add function setdebug() to new class, to enable/disable debugging
$source = "class $xmlrpcClassName\n{\npublic \$client;\n\n";
$source .= "function __construct()\n{\n";
$source .= $this->buildClientWrapperCode($client, $verbatimClientCopy, $prefix, $namespace);
$source .= "\$this->client = \$client;\n}\n\n";
$opts = array(
'return_source' => true,
'simple_client_copy' => 2, // do not produce code to copy the client object
'timeout' => $timeout,
'protocol' => $protocol,
'encode_php_objs' => $encodePhpObjects,
'decode_php_objs' => $decodePhpObjects,
'prefix' => $prefix,
);
/// @todo build phpdoc for class definition, too
foreach ($mList as $mName) {
if ($methodFilter == '' || preg_match($methodFilter, $mName)) {
// note: this will fail if server exposes 2 methods called f.e. do.something and do_something
$opts['new_function_name'] = preg_replace(array('/\./', '/[^a-zA-Z0-9_\x7f-\xff]/'),
array('_', ''), $mName);
$methodWrap = $this->wrapXmlrpcMethod($client, $mName, $opts);
if ($methodWrap) {
if (!$buildIt) {
$source .= $methodWrap['docstring'];
}
$source .= $methodWrap['source'] . "\n";
} else {
error_log('XML-RPC: ' . __METHOD__ . ': will not create class method to wrap remote method ' . $mName);
}
}
}
$source .= "}\n";
if ($buildIt) {
$allOK = 0;
eval($source . '$allOK=1;');
if ($allOK) {
return $xmlrpcClassName;
} else {
error_log('XML-RPC: ' . __METHOD__ . ': could not create class ' . $xmlrpcClassName . ' to wrap remote server ' . $client->server);
return false;
}
} else {
return array('class' => $xmlrpcClassName, 'code' => $source, 'docstring' => '');
}
}
}
}
/**
* Given necessary info, generate php code that will build a client object just like the given one.
* Take care that no full checking of input parameters is done to ensure that
* valid php code is emitted.
* @param Client $client
* @param bool $verbatimClientCopy when true, copy all of the state of the client, except for 'debug' and 'return_type'
* @param string $prefix used for the return_type of the created client
* @param string $namespace
*
* @return string
*/
protected function buildClientWrapperCode($client, $verbatimClientCopy, $prefix = 'xmlrpc', $namespace = '\\PhpXmlRpc\\' )
{
$code = "\$client = new {$namespace}Client('" . str_replace("'", "\'", $client->path) .
"', '" . str_replace("'", "\'", $client->server) . "', $client->port);\n";
// copy all client fields to the client that will be generated runtime
// (this provides for future expansion or subclassing of client obj)
if ($verbatimClientCopy) {
foreach ($client as $fld => $val) {
if ($fld != 'debug' && $fld != 'return_type') {
$val = var_export($val, true);
$code .= "\$client->$fld = $val;\n";
}
}
}
// only make sure that client always returns the correct data type
$code .= "\$client->return_type = '{$prefix}vals';\n";
//$code .= "\$client->setDebug(\$debug);\n";
return $code;
}
}
} // End of Namespace
namespace PhpXmlRpc\Helper
{
//use PhpXmlRpc\PhpXmlRpc;
use PhpXmlRpc\PhpXmlRpc;
use PhpXmlRpc\Value;
class Charset
{
// tables used for transcoding different charsets into us-ascii xml
protected $xml_iso88591_Entities = array("in" => array(), "out" => array());
/// @todo add to iso table the characters from cp_1252 range, i.e. 128 to 159?
/// These will NOT be present in true ISO-8859-1, but will save the unwary
/// windows user from sending junk (though no luck when receiving them...)
/*
protected $xml_cp1252_Entities = array('in' => array(), out' => array(
'€', '?', '‚', 'ƒ',
'„', '…', '†', '‡',
'ˆ', '‰', 'Š', '‹',
'Œ', '?', 'Ž', '?',
'?', '‘', '’', '“',
'”', '•', '–', '—',
'˜', '™', 'š', '›',
'œ', '?', 'ž', 'Ÿ'
));
*/
protected $charset_supersets = array(
'US-ASCII' => array('ISO-8859-1', 'ISO-8859-2', 'ISO-8859-3', 'ISO-8859-4',
'ISO-8859-5', 'ISO-8859-6', 'ISO-8859-7', 'ISO-8859-8',
'ISO-8859-9', 'ISO-8859-10', 'ISO-8859-11', 'ISO-8859-12',
'ISO-8859-13', 'ISO-8859-14', 'ISO-8859-15', 'UTF-8',
'EUC-JP', 'EUC-', 'EUC-KR', 'EUC-CN',),
);
protected static $instance = null;
/**
* This class is singleton for performance reasons.
*
* @return Charset
*/
public static function instance()
{
if (self::$instance === null) {
self::$instance = new self();
}
return self::$instance;
}
private function __construct()
{
for ($i = 0; $i < 32; $i++) {
$this->xml_iso88591_Entities["in"][] = chr($i);
$this->xml_iso88591_Entities["out"][] = "&#{$i};";
}
for ($i = 160; $i < 256; $i++) {
$this->xml_iso88591_Entities["in"][] = chr($i);
$this->xml_iso88591_Entities["out"][] = "&#{$i};";
}
/*for ($i = 128; $i < 160; $i++)
{
$this->xml_cp1252_Entities['in'][] = chr($i);
}*/
}
/**
* Convert a string to the correct XML representation in a target charset
* To help correct communication of non-ascii chars inside strings, regardless
* of the charset used when sending requests, parsing them, sending responses
* and parsing responses, an option is to convert all non-ascii chars present in the message
* into their equivalent 'charset entity'. Charset entities enumerated this way
* are independent of the charset encoding used to transmit them, and all XML
* parsers are bound to understand them.
* Note that in the std case we are not sending a charset encoding mime type
* along with http headers, so we are bound by RFC 3023 to emit strict us-ascii.
*
* @todo do a bit of basic benchmarking (strtr vs. str_replace)
* @todo make usage of iconv() or recode_string() or mb_string() where available
*
* @param string $data
* @param string $srcEncoding
* @param string $destEncoding
*
* @return string
*/
public function encodeEntities($data, $srcEncoding = '', $destEncoding = '')
{
if ($srcEncoding == '') {
// lame, but we know no better...
$srcEncoding = PhpXmlRpc::$xmlrpc_internalencoding;
}
switch (strtoupper($srcEncoding . '_' . $destEncoding)) {
case 'ISO-8859-1_':
case 'ISO-8859-1_US-ASCII':
$escapedData = str_replace(array('&', '"', "'", '<', '>'), array('&', '"', ''', '<', '>'), $data);
$escapedData = str_replace($this->xml_iso88591_Entities['in'], $this->xml_iso88591_Entities['out'], $escapedData);
break;
case 'ISO-8859-1_UTF-8':
$escapedData = str_replace(array('&', '"', "'", '<', '>'), array('&', '"', ''', '<', '>'), $data);
$escapedData = utf8_encode($escapedData);
break;
case 'ISO-8859-1_ISO-8859-1':
case 'US-ASCII_US-ASCII':
case 'US-ASCII_UTF-8':
case 'US-ASCII_':
case 'US-ASCII_ISO-8859-1':
case 'UTF-8_UTF-8':
//case 'CP1252_CP1252':
$escapedData = str_replace(array('&', '"', "'", '<', '>'), array('&', '"', ''', '<', '>'), $data);
break;
case 'UTF-8_':
case 'UTF-8_US-ASCII':
case 'UTF-8_ISO-8859-1':
// NB: this will choke on invalid UTF-8, going most likely beyond EOF
$escapedData = '';
// be kind to users creating string xmlrpc values out of different php types
$data = (string)$data;
$ns = strlen($data);
for ($nn = 0; $nn < $ns; $nn++) {
$ch = $data[$nn];
$ii = ord($ch);
//1 7 0bbbbbbb (127)
if ($ii < 128) {
/// @todo shall we replace this with a (supposedly) faster str_replace?
switch ($ii) {
case 34:
$escapedData .= '"';
break;
case 38:
$escapedData .= '&';
break;
case 39:
$escapedData .= ''';
break;
case 60:
$escapedData .= '<';
break;
case 62:
$escapedData .= '>';
break;
default:
$escapedData .= $ch;
} // switch
} //2 11 110bbbbb 10bbbbbb (2047)
elseif ($ii >> 5 == 6) {
$b1 = ($ii & 31);
$ii = ord($data[$nn + 1]);
$b2 = ($ii & 63);
$ii = ($b1 * 64) + $b2;
$ent = sprintf('&#%d;', $ii);
$escapedData .= $ent;
$nn += 1;
} //3 16 1110bbbb 10bbbbbb 10bbbbbb
elseif ($ii >> 4 == 14) {
$b1 = ($ii & 15);
$ii = ord($data[$nn + 1]);
$b2 = ($ii & 63);
$ii = ord($data[$nn + 2]);
$b3 = ($ii & 63);
$ii = ((($b1 * 64) + $b2) * 64) + $b3;
$ent = sprintf('&#%d;', $ii);
$escapedData .= $ent;
$nn += 2;
} //4 21 11110bbb 10bbbbbb 10bbbbbb 10bbbbbb
elseif ($ii >> 3 == 30) {
$b1 = ($ii & 7);
$ii = ord($data[$nn + 1]);
$b2 = ($ii & 63);
$ii = ord($data[$nn + 2]);
$b3 = ($ii & 63);
$ii = ord($data[$nn + 3]);
$b4 = ($ii & 63);
$ii = ((((($b1 * 64) + $b2) * 64) + $b3) * 64) + $b4;
$ent = sprintf('&#%d;', $ii);
$escapedData .= $ent;
$nn += 3;
}
}
break;
/*
case 'CP1252_':
case 'CP1252_US-ASCII':
$escapedData = str_replace(array('&', '"', "'", '<', '>'), array('&', '"', ''', '<', '>'), $data);
$escapedData = str_replace($this->xml_iso88591_Entities']['in'], $this->xml_iso88591_Entities['out'], $escapedData);
$escapedData = str_replace($this->xml_cp1252_Entities['in'], $this->xml_cp1252_Entities['out'], $escapedData);
break;
case 'CP1252_UTF-8':
$escapedData = str_replace(array('&', '"', "'", '<', '>'), array('&', '"', ''', '<', '>'), $data);
/// @todo we could use real UTF8 chars here instead of xml entities... (note that utf_8 encode all allone will NOT convert them)
$escapedData = str_replace($this->xml_cp1252_Entities['in'], $this->xml_cp1252_Entities['out'], $escapedData);
$escapedData = utf8_encode($escapedData);
break;
case 'CP1252_ISO-8859-1':
$escapedData = str_replace(array('&', '"', "'", '<', '>'), array('&', '"', ''', '<', '>'), $data);
// we might as well replace all funky chars with a '?' here, but we are kind and leave it to the receiving application layer to decide what to do with these weird entities...
$escapedData = str_replace($this->xml_cp1252_Entities['in'], $this->xml_cp1252_Entities['out'], $escapedData);
break;
*/
default:
$escapedData = '';
error_log('XML-RPC: ' . __METHOD__ . ": Converting from $srcEncoding to $destEncoding: not supported...");
}
return $escapedData;
}
/**
* Checks if a given charset encoding is present in a list of encodings or
* if it is a valid subset of any encoding in the list.
*
* @param string $encoding charset to be tested
* @param string|array $validList comma separated list of valid charsets (or array of charsets)
*
* @return bool
*/
public function isValidCharset($encoding, $validList)
{
if (is_string($validList)) {
$validList = explode(',', $validList);
}
if (@in_array(strtoupper($encoding), $validList)) {
return true;
} else {
if (array_key_exists($encoding, $this->charset_supersets)) {
foreach ($validList as $allowed) {
if (in_array($allowed, $this->charset_supersets[$encoding])) {
return true;
}
}
}
return false;
}
}
/**
* Used only for backwards compatibility
* @deprecated
*
* @param string $charset
*
* @return array
*
* @throws \Exception for unknown/unsupported charsets
*/
public function getEntities($charset)
{
switch ($charset)
{
case 'iso88591':
return $this->xml_iso88591_Entities;
default:
throw new \Exception('Unsupported charset: ' . $charset);
}
}
}
class Date
{
/**
* Given a timestamp, return the corresponding ISO8601 encoded string.
*
* Really, timezones ought to be supported
* but the XML-RPC spec says:
*
* "Don't assume a timezone. It should be specified by the server in its
* documentation what assumptions it makes about timezones."
*
* These routines always assume localtime unless
* $utc is set to 1, in which case UTC is assumed
* and an adjustment for locale is made when encoding
*
* @param int $timet (timestamp)
* @param int $utc (0 or 1)
*
* @return string
*/
public static function iso8601Encode($timet, $utc = 0)
{
if (!$utc) {
$t = strftime("%Y%m%dT%H:%M:%S", $timet);
} else {
if (function_exists('gmstrftime')) {
// gmstrftime doesn't exist in some versions
// of PHP
$t = gmstrftime("%Y%m%dT%H:%M:%S", $timet);
} else {
$t = strftime("%Y%m%dT%H:%M:%S", $timet - date('Z'));
}
}
return $t;
}
/**
* Given an ISO8601 date string, return a timet in the localtime, or UTC.
*
* @param string $idate
* @param int $utc either 0 or 1
*
* @return int (datetime)
*/
public static function iso8601Decode($idate, $utc = 0)
{
$t = 0;
if (preg_match('/([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;
}
}
//use PhpXmlRpc\PhpXmlRpc;
class Http
{
/**
* Decode a string that is encoded with "chunked" transfer encoding as defined in rfc2068 par. 19.4.6
* Code shamelessly stolen from nusoap library by Dietrich Ayala.
*
* @param string $buffer the string to be decoded
*
* @return string
*/
public static function decodeChunked($buffer)
{
// length := 0
$length = 0;
$new = '';
// read chunk-size, chunk-extension (if any) and crlf
// get the position of the linebreak
$chunkEnd = strpos($buffer, "\r\n") + 2;
$temp = substr($buffer, 0, $chunkEnd);
$chunkSize = hexdec(trim($temp));
$chunkStart = $chunkEnd;
while ($chunkSize > 0) {
$chunkEnd = strpos($buffer, "\r\n", $chunkStart + $chunkSize);
// just in case we got a broken connection
if ($chunkEnd == false) {
$chunk = substr($buffer, $chunkStart);
// append chunk-data to entity-body
$new .= $chunk;
$length += strlen($chunk);
break;
}
// read chunk-data and crlf
$chunk = substr($buffer, $chunkStart, $chunkEnd - $chunkStart);
// append chunk-data to entity-body
$new .= $chunk;
// length := length + chunk-size
$length += strlen($chunk);
// read chunk-size and crlf
$chunkStart = $chunkEnd + 2;
$chunkEnd = strpos($buffer, "\r\n", $chunkStart) + 2;
if ($chunkEnd == false) {
break; //just in case we got a broken connection
}
$temp = substr($buffer, $chunkStart, $chunkEnd - $chunkStart);
$chunkSize = hexdec(trim($temp));
$chunkStart = $chunkEnd;
}
return $new;
}
/**
* Parses HTTP an http response headers and separates them from the body.
*
* @param string $data the http response,headers and body. It will be stripped of headers
* @param bool $headersProcessed when true, we assume that response inflating and dechunking has been already carried out
*
* @return array with keys 'headers' and 'cookies'
* @throws \Exception
*/
public function parseResponseHeaders(&$data, $headersProcessed = false, $debug=0)
{
$httpResponse = array('raw_data' => $data, 'headers'=> array(), 'cookies' => array());
// Support "web-proxy-tunelling" connections for https through proxies
if (preg_match('/^HTTP\/1\.[0-1] 200 Connection established/', $data)) {
// Look for CR/LF or simple LF as line separator,
// (even though it is not valid http)
$pos = strpos($data, "\r\n\r\n");
if ($pos || is_int($pos)) {
$bd = $pos + 4;
} else {
$pos = strpos($data, "\n\n");
if ($pos || is_int($pos)) {
$bd = $pos + 2;
} else {
// No separation between response headers and body: fault?
$bd = 0;
}
}
if ($bd) {
// this filters out all http headers from proxy.
// maybe we could take them into account, too?
$data = substr($data, $bd);
} else {
error_log('XML-RPC: ' . __METHOD__ . ': HTTPS via proxy error, tunnel connection possibly failed');
throw new \Exception(PhpXmlRpc::$xmlrpcstr['http_error'] . ' (HTTPS via proxy error, tunnel connection possibly failed)', PhpXmlRpc::$xmlrpcerr['http_error']);
}
}
// Strip HTTP 1.1 100 Continue header if present
while (preg_match('/^HTTP\/1\.1 1[0-9]{2} /', $data)) {
$pos = strpos($data, 'HTTP', 12);
// server sent a Continue header without any (valid) content following...
// give the client a chance to know it
if (!$pos && !is_int($pos)) {
// works fine in php 3, 4 and 5
break;
}
$data = substr($data, $pos);
}
if (!preg_match('/^HTTP\/[0-9.]+ 200 /', $data)) {
$errstr = substr($data, 0, strpos($data, "\n") - 1);
error_log('XML-RPC: ' . __METHOD__ . ': HTTP error, got response: ' . $errstr);
throw new \Exception(PhpXmlRpc::$xmlrpcstr['http_error'] . ' (' . $errstr . ')', PhpXmlRpc::$xmlrpcerr['http_error']);
}
// be tolerant to usage of \n instead of \r\n to separate headers and data
// (even though it is not valid http)
$pos = strpos($data, "\r\n\r\n");
if ($pos || is_int($pos)) {
$bd = $pos + 4;
} else {
$pos = strpos($data, "\n\n");
if ($pos || is_int($pos)) {
$bd = $pos + 2;
} else {
// No separation between response headers and body: fault?
// we could take some action here instead of going on...
$bd = 0;
}
}
// be tolerant to line endings, and extra empty lines
$ar = preg_split("/\r?\n/", trim(substr($data, 0, $pos)));
// while (list(, $line) = @each($ar)) {
foreach ($ar as $tossKey => $line) {
// take care of multi-line headers and cookies
$arr = explode(':', $line, 2);
if (count($arr) > 1) {
$headerName = strtolower(trim($arr[0]));
/// @todo some other headers (the ones that allow a CSV list of values)
/// do allow many values to be passed using multiple header lines.
/// We should add content to $xmlrpc->_xh['headers'][$headerName]
/// instead of replacing it for those...
if ($headerName == 'set-cookie' || $headerName == 'set-cookie2') {
if ($headerName == 'set-cookie2') {
// version 2 cookies:
// there could be many cookies on one line, comma separated
$cookies = explode(',', $arr[1]);
} else {
$cookies = array($arr[1]);
}
foreach ($cookies as $cookie) {
// glue together all received cookies, using a comma to separate them
// (same as php does with getallheaders())
if (isset($httpResponse['headers'][$headerName])) {
$httpResponse['headers'][$headerName] .= ', ' . trim($cookie);
} else {
$httpResponse['headers'][$headerName] = trim($cookie);
}
// parse cookie attributes, in case user wants to correctly honour them
// feature creep: only allow rfc-compliant cookie attributes?
// @todo support for server sending multiple time cookie with same name, but using different PATHs
$cookie = explode(';', $cookie);
foreach ($cookie as $pos => $val) {
$val = explode('=', $val, 2);
$tag = trim($val[0]);
$val = trim(@$val[1]);
/// @todo with version 1 cookies, we should strip leading and trailing " chars
if ($pos == 0) {
$cookiename = $tag;
$httpResponse['cookies'][$tag] = array();
$httpResponse['cookies'][$cookiename]['value'] = urldecode($val);
} else {
if ($tag != 'value') {
$httpResponse['cookies'][$cookiename][$tag] = $val;
}
}
}
}
} else {
$httpResponse['headers'][$headerName] = trim($arr[1]);
}
} elseif (isset($headerName)) {
/// @todo version1 cookies might span multiple lines, thus breaking the parsing above
$httpResponse['headers'][$headerName] .= ' ' . trim($line);
}
}
$data = substr($data, $bd);
if ($debug && count($httpResponse['headers'])) {
$msg = '';
foreach ($httpResponse['headers'] as $header => $value) {
$msg .= "HEADER: $header: $value\n";
}
foreach ($httpResponse['cookies'] as $header => $value) {
$msg .= "COOKIE: $header={$value['value']}\n";
}
Logger::instance()->debugMessage($msg);
}
// if CURL was used for the call, http headers have been processed,
// and dechunking + reinflating have been carried out
if (!$headersProcessed) {
// Decode chunked encoding sent by http 1.1 servers
if (isset($httpResponse['headers']['transfer-encoding']) && $httpResponse['headers']['transfer-encoding'] == 'chunked') {
if (!$data = Http::decodeChunked($data)) {
error_log('XML-RPC: ' . __METHOD__ . ': errors occurred when trying to rebuild the chunked data received from server');
throw new \Exception(PhpXmlRpc::$xmlrpcstr['dechunk_fail'], PhpXmlRpc::$xmlrpcerr['dechunk_fail']);
}
}
// Decode gzip-compressed stuff
// code shamelessly inspired from nusoap library by Dietrich Ayala
if (isset($httpResponse['headers']['content-encoding'])) {
$httpResponse['headers']['content-encoding'] = str_replace('x-', '', $httpResponse['headers']['content-encoding']);
if ($httpResponse['headers']['content-encoding'] == 'deflate' || $httpResponse['headers']['content-encoding'] == 'gzip') {
// if decoding works, use it. else assume data wasn't gzencoded
if (function_exists('gzinflate')) {
if ($httpResponse['headers']['content-encoding'] == 'deflate' && $degzdata = @gzuncompress($data)) {
$data = $degzdata;
if ($debug) {
Logger::instance()->debugMessage("---INFLATED RESPONSE---[" . strlen($data) . " chars]---\n$data\n---END---");
}
} elseif ($httpResponse['headers']['content-encoding'] == 'gzip' && $degzdata = @gzinflate(substr($data, 10))) {
$data = $degzdata;
if ($debug) {
Logger::instance()->debugMessage("---INFLATED RESPONSE---[" . strlen($data) . " chars]---\n$data\n---END---");
}
} else {
error_log('XML-RPC: ' . __METHOD__ . ': errors occurred when trying to decode the deflated data received from server');
throw new \Exception(PhpXmlRpc::$xmlrpcstr['decompress_fail'], PhpXmlRpc::$xmlrpcerr['decompress_fail']);
}
} else {
error_log('XML-RPC: ' . __METHOD__ . ': the server sent deflated data. Your php install must have the Zlib extension compiled in to support this.');
throw new \Exception(PhpXmlRpc::$xmlrpcstr['cannot_decompress'], PhpXmlRpc::$xmlrpcerr['cannot_decompress']);
}
}
}
} // end of 'if needed, de-chunk, re-inflate response'
return $httpResponse;
}
}
class Logger
{
protected static $instance = null;
/**
* This class is singleton, so that later we can move to DI patterns.
*
* @return Logger
*/
public static function instance()
{
if (self::$instance === null) {
self::$instance = new self();
}
return self::$instance;
}
/**
* Echoes a debug message, taking care of escaping it when not in console mode.
* NB: if the encoding of the message is not known or wrong, and we are working in web mode, there is no guarantee
* of 100% accuracy, which kind of defeats the purpose of debugging
*
* @param string $message
* @param string $encoding
*/
public function debugMessage($message, $encoding=null)
{
// US-ASCII is a warning for PHP and a fatal for HHVM
if ($encoding == 'US-ASCII') {
$encoding = 'UTF-8';
}
if (PHP_SAPI != 'cli') {
$flags = ENT_COMPAT | ENT_HTML401 | ENT_SUBSTITUTE;
if ($encoding != null) {
print "\n".htmlentities($message, $flags, $encoding)."\n
";
} else {
print "\n".htmlentities($message, $flags)."\n
";
}
} else {
print "\n$message\n";
}
// let the user see this now in case there's a time out later...
flush();
}
}
//use PhpXmlRpc\PhpXmlRpc;
//use PhpXmlRpc\Value;
/**
* Deals with parsing the XML.
*/
class XMLParser
{
// used to store state during parsing
// quick explanation of components:
// ac - used to accumulate values
// stack - array with genealogy of xml elements names:
// used to validate nesting of xmlrpc elements
// valuestack - array used for parsing arrays and structs
// lv - used to indicate "looking for a value": implements
// the logic to allow values with no types to be strings
// isf - used to indicate a parsing fault (2) or xmlrpc response fault (1)
// isf_reason - used for storing xmlrpc response fault string
// method - used to store method name
// params - used to store parameters in method calls
// pt - used to store the type of each received parameter. Useful if parameters are automatically decoded to php values
// rt - 'methodcall or 'methodresponse'
public $_xh = array(
'ac' => '',
'stack' => array(),
'valuestack' => array(),
'isf' => 0,
'isf_reason' => '',
'method' => false, // so we can check later if we got a methodname or not
'params' => array(),
'pt' => array(),
'rt' => '',
);
public $xmlrpc_valid_parents = array(
'VALUE' => array('MEMBER', 'DATA', 'PARAM', 'FAULT'),
'BOOLEAN' => array('VALUE'),
'I4' => array('VALUE'),
'INT' => array('VALUE'),
'STRING' => array('VALUE'),
'DOUBLE' => array('VALUE'),
'DATETIME.ISO8601' => array('VALUE'),
'BASE64' => array('VALUE'),
'MEMBER' => array('STRUCT'),
'NAME' => array('MEMBER'),
'DATA' => array('ARRAY'),
'ARRAY' => array('VALUE'),
'STRUCT' => array('VALUE'),
'PARAM' => array('PARAMS'),
'METHODNAME' => array('METHODCALL'),
'PARAMS' => array('METHODCALL', 'METHODRESPONSE'),
'FAULT' => array('METHODRESPONSE'),
'NIL' => array('VALUE'), // only used when extension activated
'EX:NIL' => array('VALUE'), // only used when extension activated
);
/**
* xml parser handler function for opening element tags.
*/
public function xmlrpc_se($parser, $name, $attrs, $acceptSingleVals = false)
{
// if invalid xmlrpc already detected, skip all processing
if ($this->_xh['isf'] < 2) {
// check for correct element nesting
// top level element can only be of 2 types
/// @todo optimization creep: save this check into a bool variable, instead of using count() every time:
/// there is only a single top level element in xml anyway
if (count($this->_xh['stack']) == 0) {
if ($name != 'METHODRESPONSE' && $name != 'METHODCALL' && (
$name != 'VALUE' && !$acceptSingleVals)
) {
$this->_xh['isf'] = 2;
$this->_xh['isf_reason'] = 'missing top level xmlrpc element';
return;
} else {
$this->_xh['rt'] = strtolower($name);
}
} else {
// not top level element: see if parent is OK
$parent = end($this->_xh['stack']);
if (!array_key_exists($name, $this->xmlrpc_valid_parents) || !in_array($parent, $this->xmlrpc_valid_parents[$name])) {
$this->_xh['isf'] = 2;
$this->_xh['isf_reason'] = "xmlrpc element $name cannot be child of $parent";
return;
}
}
switch ($name) {
// optimize for speed switch cases: most common cases first
case 'VALUE':
/// @todo we could check for 2 VALUE elements inside a MEMBER or PARAM element
$this->_xh['vt'] = 'value'; // indicator: no value found yet
$this->_xh['ac'] = '';
$this->_xh['lv'] = 1;
$this->_xh['php_class'] = null;
break;
case 'I4':
case 'INT':
case 'STRING':
case 'BOOLEAN':
case 'DOUBLE':
case 'DATETIME.ISO8601':
case 'BASE64':
if ($this->_xh['vt'] != 'value') {
//two data elements inside a value: an error occurred!
$this->_xh['isf'] = 2;
$this->_xh['isf_reason'] = "$name element following a {$this->_xh['vt']} element inside a single value";
return;
}
$this->_xh['ac'] = ''; // reset the accumulator
break;
case 'STRUCT':
case 'ARRAY':
if ($this->_xh['vt'] != 'value') {
//two data elements inside a value: an error occurred!
$this->_xh['isf'] = 2;
$this->_xh['isf_reason'] = "$name element following a {$this->_xh['vt']} element inside a single value";
return;
}
// create an empty array to hold child values, and push it onto appropriate stack
$curVal = array();
$curVal['values'] = array();
$curVal['type'] = $name;
// check for out-of-band information to rebuild php objs
// and in case it is found, save it
if (@isset($attrs['PHP_CLASS'])) {
$curVal['php_class'] = $attrs['PHP_CLASS'];
}
$this->_xh['valuestack'][] = $curVal;
$this->_xh['vt'] = 'data'; // be prepared for a data element next
break;
case 'DATA':
if ($this->_xh['vt'] != 'data') {
//two data elements inside a value: an error occurred!
$this->_xh['isf'] = 2;
$this->_xh['isf_reason'] = "found two data elements inside an array element";
return;
}
case 'METHODCALL':
case 'METHODRESPONSE':
case 'PARAMS':
// valid elements that add little to processing
break;
case 'METHODNAME':
case 'NAME':
/// @todo we could check for 2 NAME elements inside a MEMBER element
$this->_xh['ac'] = '';
break;
case 'FAULT':
$this->_xh['isf'] = 1;
break;
case 'MEMBER':
$this->_xh['valuestack'][count($this->_xh['valuestack']) - 1]['name'] = ''; // set member name to null, in case we do not find in the xml later on
//$this->_xh['ac']='';
// Drop trough intentionally
case 'PARAM':
// clear value type, so we can check later if no value has been passed for this param/member
$this->_xh['vt'] = null;
break;
case 'NIL':
case 'EX:NIL':
if (PhpXmlRpc::$xmlrpc_null_extension) {
if ($this->_xh['vt'] != 'value') {
//two data elements inside a value: an error occurred!
$this->_xh['isf'] = 2;
$this->_xh['isf_reason'] = "$name element following a {$this->_xh['vt']} element inside a single value";
return;
}
$this->_xh['ac'] = ''; // reset the accumulator
break;
}
// we do not support the extension, so
// drop through intentionally
default:
/// INVALID ELEMENT: RAISE ISF so that it is later recognized!!!
$this->_xh['isf'] = 2;
$this->_xh['isf_reason'] = "found not-xmlrpc xml element $name";
break;
}
// Save current element name to stack, to validate nesting
$this->_xh['stack'][] = $name;
/// @todo optimization creep: move this inside the big switch() above
if ($name != 'VALUE') {
$this->_xh['lv'] = 0;
}
}
}
/**
* Used in decoding xml chunks that might represent single xmlrpc values.
*/
public function xmlrpc_se_any($parser, $name, $attrs)
{
$this->xmlrpc_se($parser, $name, $attrs, true);
}
/**
* xml parser handler function for close element tags.
*/
public function xmlrpc_ee($parser, $name, $rebuildXmlrpcvals = true)
{
if ($this->_xh['isf'] < 2) {
// push this element name from stack
// NB: if XML validates, correct opening/closing is guaranteed and
// we do not have to check for $name == $currElem.
// we also checked for proper nesting at start of elements...
$currElem = array_pop($this->_xh['stack']);
switch ($name) {
case 'VALUE':
// This if() detects if no scalar was inside
if ($this->_xh['vt'] == 'value') {
$this->_xh['value'] = $this->_xh['ac'];
$this->_xh['vt'] = Value::$xmlrpcString;
}
if ($rebuildXmlrpcvals) {
// build the xmlrpc val out of the data received, and substitute it
$temp = new Value($this->_xh['value'], $this->_xh['vt']);
// in case we got info about underlying php class, save it
// in the object we're rebuilding
if (isset($this->_xh['php_class'])) {
$temp->_php_class = $this->_xh['php_class'];
}
// check if we are inside an array or struct:
// if value just built is inside an array, let's move it into array on the stack
$vscount = count($this->_xh['valuestack']);
if ($vscount && $this->_xh['valuestack'][$vscount - 1]['type'] == 'ARRAY') {
$this->_xh['valuestack'][$vscount - 1]['values'][] = $temp;
} else {
$this->_xh['value'] = $temp;
}
} else {
/// @todo this needs to treat correctly php-serialized objects,
/// since std deserializing is done by php_xmlrpc_decode,
/// which we will not be calling...
if (isset($this->_xh['php_class'])) {
}
// check if we are inside an array or struct:
// if value just built is inside an array, let's move it into array on the stack
$vscount = count($this->_xh['valuestack']);
if ($vscount && $this->_xh['valuestack'][$vscount - 1]['type'] == 'ARRAY') {
$this->_xh['valuestack'][$vscount - 1]['values'][] = $this->_xh['value'];
}
}
break;
case 'BOOLEAN':
case 'I4':
case 'INT':
case 'STRING':
case 'DOUBLE':
case 'DATETIME.ISO8601':
case 'BASE64':
$this->_xh['vt'] = strtolower($name);
/// @todo: optimization creep - remove the if/elseif cycle below
/// since the case() in which we are already did that
if ($name == 'STRING') {
$this->_xh['value'] = $this->_xh['ac'];
} elseif ($name == 'DATETIME.ISO8601') {
if (!preg_match('/^[0-9]{8}T[0-9]{2}:[0-9]{2}:[0-9]{2}$/', $this->_xh['ac'])) {
error_log('XML-RPC: ' . __METHOD__ . ': invalid value received in DATETIME: ' . $this->_xh['ac']);
}
$this->_xh['vt'] = Value::$xmlrpcDateTime;
$this->_xh['value'] = $this->_xh['ac'];
} elseif ($name == 'BASE64') {
/// @todo check for failure of base64 decoding / catch warnings
$this->_xh['value'] = base64_decode($this->_xh['ac']);
} elseif ($name == 'BOOLEAN') {
// special case here: we translate boolean 1 or 0 into PHP
// constants true or false.
// Strings 'true' and 'false' are accepted, even though the
// spec never mentions them (see eg. Blogger api docs)
// NB: this simple checks helps a lot sanitizing input, ie no
// security problems around here
if ($this->_xh['ac'] == '1' || strcasecmp($this->_xh['ac'], 'true') == 0) {
$this->_xh['value'] = true;
} else {
// log if receiving something strange, even though we set the value to false anyway
if ($this->_xh['ac'] != '0' && strcasecmp($this->_xh['ac'], 'false') != 0) {
error_log('XML-RPC: ' . __METHOD__ . ': invalid value received in BOOLEAN: ' . $this->_xh['ac']);
}
$this->_xh['value'] = false;
}
} elseif ($name == 'DOUBLE') {
// we have a DOUBLE
// we must check that only 0123456789-. are characters here
// NOTE: regexp could be much stricter than this...
if (!preg_match('/^[+-eE0123456789 \t.]+$/', $this->_xh['ac'])) {
/// @todo: find a better way of throwing an error than this!
error_log('XML-RPC: ' . __METHOD__ . ': non numeric value received in DOUBLE: ' . $this->_xh['ac']);
$this->_xh['value'] = 'ERROR_NON_NUMERIC_FOUND';
} else {
// it's ok, add it on
$this->_xh['value'] = (double)$this->_xh['ac'];
}
} else {
// we have an I4/INT
// we must check that only 0123456789- are characters here
if (!preg_match('/^[+-]?[0123456789 \t]+$/', $this->_xh['ac'])) {
/// @todo find a better way of throwing an error than this!
error_log('XML-RPC: ' . __METHOD__ . ': non numeric value received in INT: ' . $this->_xh['ac']);
$this->_xh['value'] = 'ERROR_NON_NUMERIC_FOUND';
} else {
// it's ok, add it on
$this->_xh['value'] = (int)$this->_xh['ac'];
}
}
$this->_xh['lv'] = 3; // indicate we've found a value
break;
case 'NAME':
$this->_xh['valuestack'][count($this->_xh['valuestack']) - 1]['name'] = $this->_xh['ac'];
break;
case 'MEMBER':
// add to array in the stack the last element built,
// unless no VALUE was found
if ($this->_xh['vt']) {
$vscount = count($this->_xh['valuestack']);
$this->_xh['valuestack'][$vscount - 1]['values'][$this->_xh['valuestack'][$vscount - 1]['name']] = $this->_xh['value'];
} else {
error_log('XML-RPC: ' . __METHOD__ . ': missing VALUE inside STRUCT in received xml');
}
break;
case 'DATA':
$this->_xh['vt'] = null; // reset this to check for 2 data elements in a row - even if they're empty
break;
case 'STRUCT':
case 'ARRAY':
// fetch out of stack array of values, and promote it to current value
$currVal = array_pop($this->_xh['valuestack']);
$this->_xh['value'] = $currVal['values'];
$this->_xh['vt'] = strtolower($name);
if (isset($currVal['php_class'])) {
$this->_xh['php_class'] = $currVal['php_class'];
}
break;
case 'PARAM':
// add to array of params the current value,
// unless no VALUE was found
if ($this->_xh['vt']) {
$this->_xh['params'][] = $this->_xh['value'];
$this->_xh['pt'][] = $this->_xh['vt'];
} else {
error_log('XML-RPC: ' . __METHOD__ . ': missing VALUE inside PARAM in received xml');
}
break;
case 'METHODNAME':
$this->_xh['method'] = preg_replace('/^[\n\r\t ]+/', '', $this->_xh['ac']);
break;
case 'NIL':
case 'EX:NIL':
if (PhpXmlRpc::$xmlrpc_null_extension) {
$this->_xh['vt'] = 'null';
$this->_xh['value'] = null;
$this->_xh['lv'] = 3;
break;
}
// drop through intentionally if nil extension not enabled
case 'PARAMS':
case 'FAULT':
case 'METHODCALL':
case 'METHORESPONSE':
break;
default:
// End of INVALID ELEMENT!
// shall we add an assert here for unreachable code???
break;
}
}
}
/**
* Used in decoding xmlrpc requests/responses without rebuilding xmlrpc Values.
*/
public function xmlrpc_ee_fast($parser, $name)
{
$this->xmlrpc_ee($parser, $name, false);
}
/**
* xml parser handler function for character data.
*/
public function xmlrpc_cd($parser, $data)
{
// skip processing if xml fault already detected
if ($this->_xh['isf'] < 2) {
// "lookforvalue==3" means that we've found an entire value
// and should discard any further character data
if ($this->_xh['lv'] != 3) {
$this->_xh['ac'] .= $data;
}
}
}
/**
* xml parser handler function for 'other stuff', ie. not char data or
* element start/end tag. In fact it only gets called on unknown entities...
*/
public function xmlrpc_dh($parser, $data)
{
// skip processing if xml fault already detected
if ($this->_xh['isf'] < 2) {
if (substr($data, 0, 1) == '&' && substr($data, -1, 1) == ';') {
$this->_xh['ac'] .= $data;
}
}
return true;
}
/**
* xml charset encoding guessing helper function.
* Tries to determine the charset encoding of an XML chunk received over HTTP.
* NB: according to the spec (RFC 3023), if text/xml content-type is received over HTTP without a content-type,
* we SHOULD assume it is strictly US-ASCII. But we try to be more tolerant of non conforming (legacy?) clients/servers,
* which will be most probably using UTF-8 anyway...
* In order of importance checks:
* 1. http headers
* 2. BOM
* 3. XML declaration
* 4. guesses using mb_detect_encoding()
*
* @param string $httpHeader the http Content-type header
* @param string $xmlChunk xml content buffer
* @param string $encodingPrefs comma separated list of character encodings to be used as default (when mb extension is enabled).
* This can also be set globally using PhpXmlRpc::$xmlrpc_detectencodings
* @return string the encoding determined. Null if it can't be determined and mbstring is enabled,
* PhpXmlRpc::$xmlrpc_defencoding if it can't be determined and mbstring is not enabled
*
* @todo explore usage of mb_http_input(): does it detect http headers + post data? if so, use it instead of hand-detection!!!
*/
public static function guessEncoding($httpHeader = '', $xmlChunk = '', $encodingPrefs = null)
{
// discussion: see http://www.yale.edu/pclt/encoding/
// 1 - test if encoding is specified in HTTP HEADERS
// Details:
// LWS: (\13\10)?( |\t)+
// token: (any char but excluded stuff)+
// quoted string: " (any char but double quotes and control chars)* "
// header: Content-type = ...; charset=value(; ...)*
// where value is of type token, no LWS allowed between 'charset' and value
// Note: we do not check for invalid chars in VALUE:
// this had better be done using pure ereg as below
// Note 2: we might be removing whitespace/tabs that ought to be left in if
// the received charset is a quoted string. But nobody uses such charset names...
/// @todo this test will pass if ANY header has charset specification, not only Content-Type. Fix it?
$matches = array();
if (preg_match('/;\s*charset\s*=([^;]+)/i', $httpHeader, $matches)) {
return strtoupper(trim($matches[1], " \t\""));
}
// 2 - scan the first bytes of the data for a UTF-16 (or other) BOM pattern
// (source: http://www.w3.org/TR/2000/REC-xml-20001006)
// NOTE: actually, according to the spec, even if we find the BOM and determine
// an encoding, we should check if there is an encoding specified
// in the xml declaration, and verify if they match.
/// @todo implement check as described above?
/// @todo implement check for first bytes of string even without a BOM? (It sure looks harder than for cases WITH a BOM)
if (preg_match('/^(\x00\x00\xFE\xFF|\xFF\xFE\x00\x00|\x00\x00\xFF\xFE|\xFE\xFF\x00\x00)/', $xmlChunk)) {
return 'UCS-4';
} elseif (preg_match('/^(\xFE\xFF|\xFF\xFE)/', $xmlChunk)) {
return 'UTF-16';
} elseif (preg_match('/^(\xEF\xBB\xBF)/', $xmlChunk)) {
return 'UTF-8';
}
// 3 - test if encoding is specified in the xml declaration
// Details:
// SPACE: (#x20 | #x9 | #xD | #xA)+ === [ \x9\xD\xA]+
// EQ: SPACE?=SPACE? === [ \x9\xD\xA]*=[ \x9\xD\xA]*
if (preg_match('/^<\?xml\s+version\s*=\s*' . "((?:\"[a-zA-Z0-9_.:-]+\")|(?:'[a-zA-Z0-9_.:-]+'))" .
'\s+encoding\s*=\s*' . "((?:\"[A-Za-z][A-Za-z0-9._-]*\")|(?:'[A-Za-z][A-Za-z0-9._-]*'))/",
$xmlChunk, $matches)) {
return strtoupper(substr($matches[2], 1, -1));
}
// 4 - if mbstring is available, let it do the guesswork
if (extension_loaded('mbstring')) {
if ($encodingPrefs == null && PhpXmlRpc::$xmlrpc_detectencodings != null) {
$encodingPrefs = PhpXmlRpc::$xmlrpc_detectencodings;
}
if ($encodingPrefs) {
$enc = mb_detect_encoding($xmlChunk, $encodingPrefs);
} else {
$enc = mb_detect_encoding($xmlChunk);
}
// NB: mb_detect likes to call it ascii, xml parser likes to call it US_ASCII...
// IANA also likes better US-ASCII, so go with it
if ($enc == 'ASCII') {
$enc = 'US-' . $enc;
}
return $enc;
} else {
// no encoding specified: as per HTTP1.1 assume it is iso-8859-1?
// Both RFC 2616 (HTTP 1.1) and 1945 (HTTP 1.0) clearly state that for text/xxx content types
// this should be the standard. And we should be getting text/xml as request and response.
// BUT we have to be backward compatible with the lib, which always used UTF-8 as default...
return PhpXmlRpc::$xmlrpc_defencoding;
}
}
/**
* Helper function: checks if an xml chunk as a charset declaration (BOM or in the xml declaration)
*
* @param string $xmlChunk
* @return bool
*/
public static function hasEncoding($xmlChunk)
{
// scan the first bytes of the data for a UTF-16 (or other) BOM pattern
// (source: http://www.w3.org/TR/2000/REC-xml-20001006)
if (preg_match('/^(\x00\x00\xFE\xFF|\xFF\xFE\x00\x00|\x00\x00\xFF\xFE|\xFE\xFF\x00\x00)/', $xmlChunk)) {
return true;
} elseif (preg_match('/^(\xFE\xFF|\xFF\xFE)/', $xmlChunk)) {
return true;
} elseif (preg_match('/^(\xEF\xBB\xBF)/', $xmlChunk)) {
return true;
}
// test if encoding is specified in the xml declaration
// Details:
// SPACE: (#x20 | #x9 | #xD | #xA)+ === [ \x9\xD\xA]+
// EQ: SPACE?=SPACE? === [ \x9\xD\xA]*=[ \x9\xD\xA]*
if (preg_match('/^<\?xml\s+version\s*=\s*' . "((?:\"[a-zA-Z0-9_.:-]+\")|(?:'[a-zA-Z0-9_.:-]+'))" .
'\s+encoding\s*=\s*' . "((?:\"[A-Za-z][A-Za-z0-9._-]*\")|(?:'[A-Za-z][A-Za-z0-9._-]*'))/",
$xmlChunk, $matches)) {
return true;
}
return false;
}
}
}