You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
612 lines
15 KiB
612 lines
15 KiB
<?php if ( ! defined('BASEPATH')) exit('No direct script access allowed'); |
|
/** |
|
* CodeIgniter |
|
* |
|
* An open source application development framework for PHP 5.1.6 or newer |
|
* |
|
* @package CodeIgniter |
|
* @author ExpressionEngine Dev Team |
|
* @copyright Copyright (c) 2008 - 2011, EllisLab, Inc. |
|
* @license http://codeigniter.com/user_guide/license.html |
|
* @link http://codeigniter.com |
|
* @since Version 1.0 |
|
* @filesource |
|
*/ |
|
|
|
if ( ! function_exists('xml_parser_create')) |
|
{ |
|
show_error('Your PHP installation does not support XML'); |
|
} |
|
|
|
if ( ! class_exists('CI_Xmlrpc')) |
|
{ |
|
show_error('You must load the Xmlrpc class before loading the Xmlrpcs class in order to create a server.'); |
|
} |
|
|
|
// ------------------------------------------------------------------------ |
|
|
|
/** |
|
* XML-RPC server class |
|
* |
|
* @package CodeIgniter |
|
* @subpackage Libraries |
|
* @category XML-RPC |
|
* @author ExpressionEngine Dev Team |
|
* @link http://codeigniter.com/user_guide/libraries/xmlrpc.html |
|
*/ |
|
class CI_Xmlrpcs extends CI_Xmlrpc |
|
{ |
|
var $methods = array(); //array of methods mapped to function names and signatures |
|
var $debug_msg = ''; // Debug Message |
|
var $system_methods = array(); // XML RPC Server methods |
|
var $controller_obj; |
|
|
|
var $object = FALSE; |
|
|
|
/** |
|
* Constructor |
|
*/ |
|
public function __construct($config=array()) |
|
{ |
|
parent::__construct(); |
|
$this->set_system_methods(); |
|
|
|
if (isset($config['functions']) && is_array($config['functions'])) |
|
{ |
|
$this->methods = array_merge($this->methods, $config['functions']); |
|
} |
|
|
|
log_message('debug', "XML-RPC Server Class Initialized"); |
|
} |
|
|
|
// -------------------------------------------------------------------- |
|
|
|
/** |
|
* Initialize Prefs and Serve |
|
* |
|
* @access public |
|
* @param mixed |
|
* @return void |
|
*/ |
|
function initialize($config=array()) |
|
{ |
|
if (isset($config['functions']) && is_array($config['functions'])) |
|
{ |
|
$this->methods = array_merge($this->methods, $config['functions']); |
|
} |
|
|
|
if (isset($config['debug'])) |
|
{ |
|
$this->debug = $config['debug']; |
|
} |
|
|
|
if (isset($config['object']) && is_object($config['object'])) |
|
{ |
|
$this->object = $config['object']; |
|
} |
|
|
|
if (isset($config['xss_clean'])) |
|
{ |
|
$this->xss_clean = $config['xss_clean']; |
|
} |
|
} |
|
|
|
// -------------------------------------------------------------------- |
|
|
|
/** |
|
* Setting of System Methods |
|
* |
|
* @access public |
|
* @return void |
|
*/ |
|
function set_system_methods() |
|
{ |
|
$this->methods = array( |
|
'system.listMethods' => array( |
|
'function' => 'this.listMethods', |
|
'signature' => array(array($this->xmlrpcArray, $this->xmlrpcString), array($this->xmlrpcArray)), |
|
'docstring' => 'Returns an array of available methods on this server'), |
|
'system.methodHelp' => array( |
|
'function' => 'this.methodHelp', |
|
'signature' => array(array($this->xmlrpcString, $this->xmlrpcString)), |
|
'docstring' => 'Returns a documentation string for the specified method'), |
|
'system.methodSignature' => array( |
|
'function' => 'this.methodSignature', |
|
'signature' => array(array($this->xmlrpcArray, $this->xmlrpcString)), |
|
'docstring' => 'Returns an array describing the return type and required parameters of a method'), |
|
'system.multicall' => array( |
|
'function' => 'this.multicall', |
|
'signature' => array(array($this->xmlrpcArray, $this->xmlrpcArray)), |
|
'docstring' => 'Combine multiple RPC calls in one request. See http://www.xmlrpc.com/discuss/msgReader$1208 for details') |
|
); |
|
} |
|
|
|
// -------------------------------------------------------------------- |
|
|
|
/** |
|
* Main Server Function |
|
* |
|
* @access public |
|
* @return void |
|
*/ |
|
function serve() |
|
{ |
|
$r = $this->parseRequest(); |
|
$payload = '<?xml version="1.0" encoding="'.$this->xmlrpc_defencoding.'"?'.'>'."\n"; |
|
$payload .= $this->debug_msg; |
|
$payload .= $r->prepare_response(); |
|
|
|
header("Content-Type: text/xml"); |
|
header("Content-Length: ".strlen($payload)); |
|
exit($payload); |
|
} |
|
|
|
// -------------------------------------------------------------------- |
|
|
|
/** |
|
* Add Method to Class |
|
* |
|
* @access public |
|
* @param string method name |
|
* @param string function |
|
* @param string signature |
|
* @param string docstring |
|
* @return void |
|
*/ |
|
function add_to_map($methodname, $function, $sig, $doc) |
|
{ |
|
$this->methods[$methodname] = array( |
|
'function' => $function, |
|
'signature' => $sig, |
|
'docstring' => $doc |
|
); |
|
} |
|
|
|
// -------------------------------------------------------------------- |
|
|
|
/** |
|
* Parse Server Request |
|
* |
|
* @access public |
|
* @param string data |
|
* @return object xmlrpc response |
|
*/ |
|
function parseRequest($data='') |
|
{ |
|
global $HTTP_RAW_POST_DATA; |
|
|
|
//------------------------------------- |
|
// Get Data |
|
//------------------------------------- |
|
|
|
if ($data == '') |
|
{ |
|
$data = $HTTP_RAW_POST_DATA; |
|
} |
|
|
|
//------------------------------------- |
|
// Set up XML Parser |
|
//------------------------------------- |
|
|
|
$parser = xml_parser_create($this->xmlrpc_defencoding); |
|
$parser_object = new XML_RPC_Message("filler"); |
|
|
|
$parser_object->xh[$parser] = array(); |
|
$parser_object->xh[$parser]['isf'] = 0; |
|
$parser_object->xh[$parser]['isf_reason'] = ''; |
|
$parser_object->xh[$parser]['params'] = array(); |
|
$parser_object->xh[$parser]['stack'] = array(); |
|
$parser_object->xh[$parser]['valuestack'] = array(); |
|
$parser_object->xh[$parser]['method'] = ''; |
|
|
|
xml_set_object($parser, $parser_object); |
|
xml_parser_set_option($parser, XML_OPTION_CASE_FOLDING, true); |
|
xml_set_element_handler($parser, 'open_tag', 'closing_tag'); |
|
xml_set_character_data_handler($parser, 'character_data'); |
|
//xml_set_default_handler($parser, 'default_handler'); |
|
|
|
|
|
//------------------------------------- |
|
// PARSE + PROCESS XML DATA |
|
//------------------------------------- |
|
|
|
if ( ! xml_parse($parser, $data, 1)) |
|
{ |
|
// return XML error as a faultCode |
|
$r = new XML_RPC_Response(0, |
|
$this->xmlrpcerrxml + xml_get_error_code($parser), |
|
sprintf('XML error: %s at line %d', |
|
xml_error_string(xml_get_error_code($parser)), |
|
xml_get_current_line_number($parser))); |
|
xml_parser_free($parser); |
|
} |
|
elseif ($parser_object->xh[$parser]['isf']) |
|
{ |
|
return new XML_RPC_Response(0, $this->xmlrpcerr['invalid_return'], $this->xmlrpcstr['invalid_return']); |
|
} |
|
else |
|
{ |
|
xml_parser_free($parser); |
|
|
|
$m = new XML_RPC_Message($parser_object->xh[$parser]['method']); |
|
$plist=''; |
|
|
|
for ($i=0; $i < count($parser_object->xh[$parser]['params']); $i++) |
|
{ |
|
if ($this->debug === TRUE) |
|
{ |
|
$plist .= "$i - " . print_r(get_object_vars($parser_object->xh[$parser]['params'][$i]), TRUE). ";\n"; |
|
} |
|
|
|
$m->addParam($parser_object->xh[$parser]['params'][$i]); |
|
} |
|
|
|
if ($this->debug === TRUE) |
|
{ |
|
echo "<pre>"; |
|
echo "---PLIST---\n" . $plist . "\n---PLIST END---\n\n"; |
|
echo "</pre>"; |
|
} |
|
|
|
$r = $this->_execute($m); |
|
} |
|
|
|
//------------------------------------- |
|
// SET DEBUGGING MESSAGE |
|
//------------------------------------- |
|
|
|
if ($this->debug === TRUE) |
|
{ |
|
$this->debug_msg = "<!-- DEBUG INFO:\n\n".$plist."\n END DEBUG-->\n"; |
|
} |
|
|
|
return $r; |
|
} |
|
|
|
// -------------------------------------------------------------------- |
|
|
|
/** |
|
* Executes the Method |
|
* |
|
* @access protected |
|
* @param object |
|
* @return mixed |
|
*/ |
|
function _execute($m) |
|
{ |
|
$methName = $m->method_name; |
|
|
|
// Check to see if it is a system call |
|
$system_call = (strncmp($methName, 'system', 5) == 0) ? TRUE : FALSE; |
|
|
|
if ($this->xss_clean == FALSE) |
|
{ |
|
$m->xss_clean = FALSE; |
|
} |
|
|
|
//------------------------------------- |
|
// Valid Method |
|
//------------------------------------- |
|
|
|
if ( ! isset($this->methods[$methName]['function'])) |
|
{ |
|
return new XML_RPC_Response(0, $this->xmlrpcerr['unknown_method'], $this->xmlrpcstr['unknown_method']); |
|
} |
|
|
|
//------------------------------------- |
|
// Check for Method (and Object) |
|
//------------------------------------- |
|
|
|
$method_parts = explode(".", $this->methods[$methName]['function']); |
|
$objectCall = (isset($method_parts['1']) && $method_parts['1'] != "") ? TRUE : FALSE; |
|
|
|
if ($system_call === TRUE) |
|
{ |
|
if ( ! is_callable(array($this,$method_parts['1']))) |
|
{ |
|
return new XML_RPC_Response(0, $this->xmlrpcerr['unknown_method'], $this->xmlrpcstr['unknown_method']); |
|
} |
|
} |
|
else |
|
{ |
|
if ($objectCall && ! is_callable(array($method_parts['0'],$method_parts['1']))) |
|
{ |
|
return new XML_RPC_Response(0, $this->xmlrpcerr['unknown_method'], $this->xmlrpcstr['unknown_method']); |
|
} |
|
elseif ( ! $objectCall && ! is_callable($this->methods[$methName]['function'])) |
|
{ |
|
return new XML_RPC_Response(0, $this->xmlrpcerr['unknown_method'], $this->xmlrpcstr['unknown_method']); |
|
} |
|
} |
|
|
|
//------------------------------------- |
|
// Checking Methods Signature |
|
//------------------------------------- |
|
|
|
if (isset($this->methods[$methName]['signature'])) |
|
{ |
|
$sig = $this->methods[$methName]['signature']; |
|
for ($i=0; $i<count($sig); $i++) |
|
{ |
|
$current_sig = $sig[$i]; |
|
|
|
if (count($current_sig) == count($m->params)+1) |
|
{ |
|
for ($n=0; $n < count($m->params); $n++) |
|
{ |
|
$p = $m->params[$n]; |
|
$pt = ($p->kindOf() == 'scalar') ? $p->scalarval() : $p->kindOf(); |
|
|
|
if ($pt != $current_sig[$n+1]) |
|
{ |
|
$pno = $n+1; |
|
$wanted = $current_sig[$n+1]; |
|
|
|
return new XML_RPC_Response(0, |
|
$this->xmlrpcerr['incorrect_params'], |
|
$this->xmlrpcstr['incorrect_params'] . |
|
": Wanted {$wanted}, got {$pt} at param {$pno})"); |
|
} |
|
} |
|
} |
|
} |
|
} |
|
|
|
//------------------------------------- |
|
// Calls the Function |
|
//------------------------------------- |
|
|
|
if ($objectCall === TRUE) |
|
{ |
|
if ($method_parts[0] == "this" && $system_call == TRUE) |
|
{ |
|
return call_user_func(array($this, $method_parts[1]), $m); |
|
} |
|
else |
|
{ |
|
if ($this->object === FALSE) |
|
{ |
|
$CI =& get_instance(); |
|
return $CI->$method_parts['1']($m); |
|
} |
|
else |
|
{ |
|
return $this->object->$method_parts['1']($m); |
|
//return call_user_func(array(&$method_parts['0'],$method_parts['1']), $m); |
|
} |
|
} |
|
} |
|
else |
|
{ |
|
return call_user_func($this->methods[$methName]['function'], $m); |
|
} |
|
} |
|
|
|
// -------------------------------------------------------------------- |
|
|
|
/** |
|
* Server Function: List Methods |
|
* |
|
* @access public |
|
* @param mixed |
|
* @return object |
|
*/ |
|
function listMethods($m) |
|
{ |
|
$v = new XML_RPC_Values(); |
|
$output = array(); |
|
|
|
foreach ($this->methods as $key => $value) |
|
{ |
|
$output[] = new XML_RPC_Values($key, 'string'); |
|
} |
|
|
|
foreach ($this->system_methods as $key => $value) |
|
{ |
|
$output[]= new XML_RPC_Values($key, 'string'); |
|
} |
|
|
|
$v->addArray($output); |
|
return new XML_RPC_Response($v); |
|
} |
|
|
|
// -------------------------------------------------------------------- |
|
|
|
/** |
|
* Server Function: Return Signature for Method |
|
* |
|
* @access public |
|
* @param mixed |
|
* @return object |
|
*/ |
|
function methodSignature($m) |
|
{ |
|
$parameters = $m->output_parameters(); |
|
$method_name = $parameters[0]; |
|
|
|
if (isset($this->methods[$method_name])) |
|
{ |
|
if ($this->methods[$method_name]['signature']) |
|
{ |
|
$sigs = array(); |
|
$signature = $this->methods[$method_name]['signature']; |
|
|
|
for ($i=0; $i < count($signature); $i++) |
|
{ |
|
$cursig = array(); |
|
$inSig = $signature[$i]; |
|
for ($j=0; $j<count($inSig); $j++) |
|
{ |
|
$cursig[]= new XML_RPC_Values($inSig[$j], 'string'); |
|
} |
|
$sigs[]= new XML_RPC_Values($cursig, 'array'); |
|
} |
|
$r = new XML_RPC_Response(new XML_RPC_Values($sigs, 'array')); |
|
} |
|
else |
|
{ |
|
$r = new XML_RPC_Response(new XML_RPC_Values('undef', 'string')); |
|
} |
|
} |
|
else |
|
{ |
|
$r = new XML_RPC_Response(0,$this->xmlrpcerr['introspect_unknown'], $this->xmlrpcstr['introspect_unknown']); |
|
} |
|
return $r; |
|
} |
|
|
|
// -------------------------------------------------------------------- |
|
|
|
/** |
|
* Server Function: Doc String for Method |
|
* |
|
* @access public |
|
* @param mixed |
|
* @return object |
|
*/ |
|
function methodHelp($m) |
|
{ |
|
$parameters = $m->output_parameters(); |
|
$method_name = $parameters[0]; |
|
|
|
if (isset($this->methods[$method_name])) |
|
{ |
|
$docstring = isset($this->methods[$method_name]['docstring']) ? $this->methods[$method_name]['docstring'] : ''; |
|
|
|
return new XML_RPC_Response(new XML_RPC_Values($docstring, 'string')); |
|
} |
|
else |
|
{ |
|
return new XML_RPC_Response(0, $this->xmlrpcerr['introspect_unknown'], $this->xmlrpcstr['introspect_unknown']); |
|
} |
|
} |
|
|
|
// -------------------------------------------------------------------- |
|
|
|
/** |
|
* Server Function: Multi-call |
|
* |
|
* @access public |
|
* @param mixed |
|
* @return object |
|
*/ |
|
function multicall($m) |
|
{ |
|
// Disabled |
|
return new XML_RPC_Response(0, $this->xmlrpcerr['unknown_method'], $this->xmlrpcstr['unknown_method']); |
|
|
|
$parameters = $m->output_parameters(); |
|
$calls = $parameters[0]; |
|
|
|
$result = array(); |
|
|
|
foreach ($calls as $value) |
|
{ |
|
//$attempt = $this->_execute(new XML_RPC_Message($value[0], $value[1])); |
|
|
|
$m = new XML_RPC_Message($value[0]); |
|
$plist=''; |
|
|
|
for ($i=0; $i < count($value[1]); $i++) |
|
{ |
|
$m->addParam(new XML_RPC_Values($value[1][$i], 'string')); |
|
} |
|
|
|
$attempt = $this->_execute($m); |
|
|
|
if ($attempt->faultCode() != 0) |
|
{ |
|
return $attempt; |
|
} |
|
|
|
$result[] = new XML_RPC_Values(array($attempt->value()), 'array'); |
|
} |
|
|
|
return new XML_RPC_Response(new XML_RPC_Values($result, 'array')); |
|
} |
|
|
|
// -------------------------------------------------------------------- |
|
|
|
/** |
|
* Multi-call Function: Error Handling |
|
* |
|
* @access public |
|
* @param mixed |
|
* @return object |
|
*/ |
|
function multicall_error($err) |
|
{ |
|
$str = is_string($err) ? $this->xmlrpcstr["multicall_${err}"] : $err->faultString(); |
|
$code = is_string($err) ? $this->xmlrpcerr["multicall_${err}"] : $err->faultCode(); |
|
|
|
$struct['faultCode'] = new XML_RPC_Values($code, 'int'); |
|
$struct['faultString'] = new XML_RPC_Values($str, 'string'); |
|
|
|
return new XML_RPC_Values($struct, 'struct'); |
|
} |
|
|
|
// -------------------------------------------------------------------- |
|
|
|
/** |
|
* Multi-call Function: Processes method |
|
* |
|
* @access public |
|
* @param mixed |
|
* @return object |
|
*/ |
|
function do_multicall($call) |
|
{ |
|
if ($call->kindOf() != 'struct') |
|
{ |
|
return $this->multicall_error('notstruct'); |
|
} |
|
elseif ( ! $methName = $call->me['struct']['methodName']) |
|
{ |
|
return $this->multicall_error('nomethod'); |
|
} |
|
|
|
list($scalar_type,$scalar_value)=each($methName->me); |
|
$scalar_type = $scalar_type == $this->xmlrpcI4 ? $this->xmlrpcInt : $scalar_type; |
|
|
|
if ($methName->kindOf() != 'scalar' OR $scalar_type != 'string') |
|
{ |
|
return $this->multicall_error('notstring'); |
|
} |
|
elseif ($scalar_value == 'system.multicall') |
|
{ |
|
return $this->multicall_error('recursion'); |
|
} |
|
elseif ( ! $params = $call->me['struct']['params']) |
|
{ |
|
return $this->multicall_error('noparams'); |
|
} |
|
elseif ($params->kindOf() != 'array') |
|
{ |
|
return $this->multicall_error('notarray'); |
|
} |
|
|
|
list($a,$b)=each($params->me); |
|
$numParams = count($b); |
|
|
|
$msg = new XML_RPC_Message($scalar_value); |
|
for ($i = 0; $i < $numParams; $i++) |
|
{ |
|
$msg->params[] = $params->me['array'][$i]; |
|
} |
|
|
|
$result = $this->_execute($msg); |
|
|
|
if ($result->faultCode() != 0) |
|
{ |
|
return $this->multicall_error($result); |
|
} |
|
|
|
return new XML_RPC_Values(array($result->value()), 'array'); |
|
} |
|
|
|
} |
|
// END XML_RPC_Server class |
|
|
|
|
|
/* End of file Xmlrpcs.php */ |
|
/* Location: ./system/libraries/Xmlrpcs.php */ |