<?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');

}





// ------------------------------------------------------------------------



/**

 * XML-RPC request handler class

 *

 * @package		CodeIgniter

 * @subpackage	Libraries

 * @category	XML-RPC

 * @author		ExpressionEngine Dev Team

 * @link		http://codeigniter.com/user_guide/libraries/xmlrpc.html

 */

class CI_Xmlrpc {



	var $debug			= FALSE;	// Debugging on or off

	var $xmlrpcI4		= 'i4';

	var $xmlrpcInt		= 'int';

	var $xmlrpcBoolean	= 'boolean';

	var $xmlrpcDouble	= 'double';

	var $xmlrpcString	= 'string';

	var $xmlrpcDateTime	= 'dateTime.iso8601';

	var $xmlrpcBase64	= 'base64';

	var $xmlrpcArray	= 'array';

	var $xmlrpcStruct	= 'struct';



	var $xmlrpcTypes	= array();

	var $valid_parents	= array();

	var $xmlrpcerr		= array();	// Response numbers

	var $xmlrpcstr		= array();  // Response strings



	var $xmlrpc_defencoding = 'UTF-8';

	var $xmlrpcName			= 'XML-RPC for CodeIgniter';

	var $xmlrpcVersion		= '1.1';

	var $xmlrpcerruser		= 800; // Start of user errors

	var $xmlrpcerrxml		= 100; // Start of XML Parse errors

	var $xmlrpc_backslash	= ''; // formulate backslashes for escaping regexp



	var $client;

	var $method;

	var $data;

	var $message			= '';

	var $error				= '';		// Error string for request

	var $result;

	var $response			= array();  // Response from remote server



	var $xss_clean			= TRUE;



	//-------------------------------------

	//  VALUES THAT MULTIPLE CLASSES NEED

	//-------------------------------------



	public function __construct($config = array())

	{

		$this->xmlrpcName		= $this->xmlrpcName;

		$this->xmlrpc_backslash = chr(92).chr(92);



		// Types for info sent back and forth

		$this->xmlrpcTypes = array(

			$this->xmlrpcI4	 		=> '1',

			$this->xmlrpcInt		=> '1',

			$this->xmlrpcBoolean	=> '1',

			$this->xmlrpcString		=> '1',

			$this->xmlrpcDouble		=> '1',

			$this->xmlrpcDateTime	=> '1',

			$this->xmlrpcBase64		=> '1',

			$this->xmlrpcArray		=> '2',

			$this->xmlrpcStruct		=> '3'

			);



		// Array of Valid Parents for Various XML-RPC elements

		$this->valid_parents = array('BOOLEAN'			=> array('VALUE'),

									 'I4'				=> array('VALUE'),

									 'INT'				=> array('VALUE'),

									 'STRING'			=> array('VALUE'),

									 'DOUBLE'			=> array('VALUE'),

									 'DATETIME.ISO8601'	=> array('VALUE'),

									 'BASE64'			=> array('VALUE'),

									 'ARRAY'			=> array('VALUE'),

									 'STRUCT'			=> array('VALUE'),

									 'PARAM'			=> array('PARAMS'),

									 'METHODNAME'		=> array('METHODCALL'),

									 'PARAMS'			=> array('METHODCALL', 'METHODRESPONSE'),

									 'MEMBER'			=> array('STRUCT'),

									 'NAME'				=> array('MEMBER'),

									 'DATA'				=> array('ARRAY'),

									 'FAULT'			=> array('METHODRESPONSE'),

									 'VALUE'			=> array('MEMBER', 'DATA', 'PARAM', 'FAULT')

									 );





		// XML-RPC Responses

		$this->xmlrpcerr['unknown_method'] = '1';

		$this->xmlrpcstr['unknown_method'] = 'This is not a known method for this XML-RPC Server';

		$this->xmlrpcerr['invalid_return'] = '2';

		$this->xmlrpcstr['invalid_return'] = 'The XML data received was either invalid or not in the correct form for XML-RPC.  Turn on debugging to examine the XML data further.';

		$this->xmlrpcerr['incorrect_params'] = '3';

		$this->xmlrpcstr['incorrect_params'] = 'Incorrect parameters were passed to method';

		$this->xmlrpcerr['introspect_unknown'] = '4';

		$this->xmlrpcstr['introspect_unknown'] = "Cannot inspect signature for request: method unknown";

		$this->xmlrpcerr['http_error'] = '5';

		$this->xmlrpcstr['http_error'] = "Did not receive a '200 OK' response from remote server.";

		$this->xmlrpcerr['no_data'] = '6';

		$this->xmlrpcstr['no_data'] ='No data received from server.';



		$this->initialize($config);



		log_message('debug', "XML-RPC Class Initialized");

	}





	//-------------------------------------

	//  Initialize Prefs

	//-------------------------------------



	function initialize($config = array())

	{

		if (count($config) > 0)

		{

			foreach ($config as $key => $val)

			{

				if (isset($this->$key))

				{

					$this->$key = $val;

				}

			}

		}

	}

	// END



	//-------------------------------------

	//  Take URL and parse it

	//-------------------------------------



	function server($url, $port=80)

	{

		if (substr($url, 0, 4) != "http")

		{

			$url = "http://".$url;

		}



		$parts = parse_url($url);



		$path = ( ! isset($parts['path'])) ? '/' : $parts['path'];



		if (isset($parts['query']) && $parts['query'] != '')

		{

			$path .= '?'.$parts['query'];

		}



		$this->client = new XML_RPC_Client($path, $parts['host'], $port);

	}

	// END



	//-------------------------------------

	//  Set Timeout

	//-------------------------------------



	function timeout($seconds=5)

	{

		if ( ! is_null($this->client) && is_int($seconds))

		{

			$this->client->timeout = $seconds;

		}

	}

	// END



	//-------------------------------------

	//  Set Methods

	//-------------------------------------



	function method($function)

	{

		$this->method = $function;

	}

	// END



	//-------------------------------------

	//  Take Array of Data and Create Objects

	//-------------------------------------



	function request($incoming)

	{

		if ( ! is_array($incoming))

		{

			// Send Error

		}



		$this->data = array();



		foreach ($incoming as $key => $value)

		{

			$this->data[$key] = $this->values_parsing($value);

		}

	}

	// END





	//-------------------------------------

	//  Set Debug

	//-------------------------------------



	function set_debug($flag = TRUE)

	{

		$this->debug = ($flag == TRUE) ? TRUE : FALSE;

	}



	//-------------------------------------

	//  Values Parsing

	//-------------------------------------



	function values_parsing($value, $return = FALSE)

	{

		if (is_array($value) && array_key_exists(0, $value))

		{

			if ( ! isset($value['1']) OR ( ! isset($this->xmlrpcTypes[$value['1']])))

			{

				if (is_array($value[0]))

				{

					$temp = new XML_RPC_Values($value['0'], 'array');

				}

				else

				{

					$temp = new XML_RPC_Values($value['0'], 'string');

				}

			}

			elseif (is_array($value['0']) && ($value['1'] == 'struct' OR $value['1'] == 'array'))

			{

				while (list($k) = each($value['0']))

				{

					$value['0'][$k] = $this->values_parsing($value['0'][$k], TRUE);

				}



				$temp = new XML_RPC_Values($value['0'], $value['1']);

			}

			else

			{

				$temp = new XML_RPC_Values($value['0'], $value['1']);

			}

		}

		else

		{

			$temp = new XML_RPC_Values($value, 'string');

		}



		return $temp;

	}

	// END





	//-------------------------------------

	//  Sends XML-RPC Request

	//-------------------------------------



	function send_request()

	{

		$this->message = new XML_RPC_Message($this->method,$this->data);

		$this->message->debug = $this->debug;



		if ( ! $this->result = $this->client->send($this->message))

		{

			$this->error = $this->result->errstr;

			return FALSE;

		}

		elseif ( ! is_object($this->result->val))

		{

			$this->error = $this->result->errstr;

			return FALSE;

		}



		$this->response = $this->result->decode();



		return TRUE;

	}

	// END



	//-------------------------------------

	//  Returns Error

	//-------------------------------------



	function display_error()

	{

		return $this->error;

	}

	// END



	//-------------------------------------

	//  Returns Remote Server Response

	//-------------------------------------



	function display_response()

	{

		return $this->response;

	}

	// END



	//-------------------------------------

	//  Sends an Error Message for Server Request

	//-------------------------------------



	function send_error_message($number, $message)

	{

		return new XML_RPC_Response('0',$number, $message);

	}

	// END





	//-------------------------------------

	//  Send Response for Server Request

	//-------------------------------------



	function send_response($response)

	{

		// $response should be array of values, which will be parsed

		// based on their data and type into a valid group of XML-RPC values



		$response = $this->values_parsing($response);



		return new XML_RPC_Response($response);

	}

	// END



} // END XML_RPC Class







/**

 * XML-RPC Client class

 *

 * @category	XML-RPC

 * @author		ExpressionEngine Dev Team

 * @link		http://codeigniter.com/user_guide/libraries/xmlrpc.html

 */

class XML_RPC_Client extends CI_Xmlrpc

{

	var $path			= '';

	var $server			= '';

	var $port			= 80;

	var $errno			= '';

	var $errstring		= '';

	var $timeout		= 5;

	var $no_multicall	= FALSE;



	public function __construct($path, $server, $port=80)

	{

		parent::__construct();



		$this->port = $port;

		$this->server = $server;

		$this->path = $path;

	}



	function send($msg)

	{

		if (is_array($msg))

		{

			// Multi-call disabled

			$r = new XML_RPC_Response(0, $this->xmlrpcerr['multicall_recursion'],$this->xmlrpcstr['multicall_recursion']);

			return $r;

		}



		return $this->sendPayload($msg);

	}



	function sendPayload($msg)

	{

		$fp = @fsockopen($this->server, $this->port,$this->errno, $this->errstr, $this->timeout);



		if ( ! is_resource($fp))

		{

			error_log($this->xmlrpcstr['http_error']);

			$r = new XML_RPC_Response(0, $this->xmlrpcerr['http_error'],$this->xmlrpcstr['http_error']);

			return $r;

		}



		if (empty($msg->payload))

		{

			// $msg = XML_RPC_Messages

			$msg->createPayload();

		}



		$r = "\r\n";

		$op  = "POST {$this->path} HTTP/1.0$r";

		$op .= "Host: {$this->server}$r";

		$op .= "Content-Type: text/xml$r";

		$op .= "User-Agent: {$this->xmlrpcName}$r";

		$op .= "Content-Length: ".strlen($msg->payload). "$r$r";

		$op .= $msg->payload;





		if ( ! fputs($fp, $op, strlen($op)))

		{

			error_log($this->xmlrpcstr['http_error']);

			$r = new XML_RPC_Response(0, $this->xmlrpcerr['http_error'], $this->xmlrpcstr['http_error']);

			return $r;

		}

		$resp = $msg->parseResponse($fp);

		fclose($fp);

		return $resp;

	}



} // end class XML_RPC_Client





/**

 * XML-RPC Response class

 *

 * @category	XML-RPC

 * @author		ExpressionEngine Dev Team

 * @link		http://codeigniter.com/user_guide/libraries/xmlrpc.html

 */

class XML_RPC_Response

{

	var $val = 0;

	var $errno = 0;

	var $errstr = '';

	var $headers = array();

	var $xss_clean = TRUE;



	public function __construct($val, $code = 0, $fstr = '')

	{

		if ($code != 0)

		{

			// error

			$this->errno = $code;

			$this->errstr = htmlentities($fstr);

		}

		else if ( ! is_object($val))

		{

			// programmer error, not an object

			error_log("Invalid type '" . gettype($val) . "' (value: $val) passed to XML_RPC_Response.  Defaulting to empty value.");

			$this->val = new XML_RPC_Values();

		}

		else

		{

			$this->val = $val;

		}

	}



	function faultCode()

	{

		return $this->errno;

	}



	function faultString()

	{

		return $this->errstr;

	}



	function value()

	{

		return $this->val;

	}



	function prepare_response()

	{

		$result = "<methodResponse>\n";

		if ($this->errno)

		{

			$result .= '<fault>

	<value>

		<struct>

			<member>

				<name>faultCode</name>

				<value><int>' . $this->errno . '</int></value>

			</member>

			<member>

				<name>faultString</name>

				<value><string>' . $this->errstr . '</string></value>

			</member>

		</struct>

	</value>

</fault>';

		}

		else

		{

			$result .= "<params>\n<param>\n" .

					$this->val->serialize_class() .

					"</param>\n</params>";

		}

		$result .= "\n</methodResponse>";

		return $result;

	}



	function decode($array=FALSE)

	{

		$CI =& get_instance();

		

		if ($array !== FALSE && is_array($array))

		{

			while (list($key) = each($array))

			{

				if (is_array($array[$key]))

				{

					$array[$key] = $this->decode($array[$key]);

				}

				else

				{

					$array[$key] = ($this->xss_clean) ? $CI->security->xss_clean($array[$key]) : $array[$key];

				}

			}



			$result = $array;

		}

		else

		{

			$result = $this->xmlrpc_decoder($this->val);



			if (is_array($result))

			{

				$result = $this->decode($result);

			}

			else

			{

				$result = ($this->xss_clean) ? $CI->security->xss_clean($result) : $result;

			}

		}



		return $result;

	}







	//-------------------------------------

	//  XML-RPC Object to PHP Types

	//-------------------------------------



	function xmlrpc_decoder($xmlrpc_val)

	{

		$kind = $xmlrpc_val->kindOf();



		if ($kind == 'scalar')

		{

			return $xmlrpc_val->scalarval();

		}

		elseif ($kind == 'array')

		{

			reset($xmlrpc_val->me);

			list($a,$b) = each($xmlrpc_val->me);

			$size = count($b);



			$arr = array();



			for ($i = 0; $i < $size; $i++)

			{

				$arr[] = $this->xmlrpc_decoder($xmlrpc_val->me['array'][$i]);

			}

			return $arr;

		}

		elseif ($kind == 'struct')

		{

			reset($xmlrpc_val->me['struct']);

			$arr = array();



			while (list($key,$value) = each($xmlrpc_val->me['struct']))

			{

				$arr[$key] = $this->xmlrpc_decoder($value);

			}

			return $arr;

		}

	}





	//-------------------------------------

	//  ISO-8601 time to server or UTC time

	//-------------------------------------



	function iso8601_decode($time, $utc=0)

	{

		// return a timet in the localtime, or UTC

		$t = 0;

		if (preg_match('/([0-9]{4})([0-9]{2})([0-9]{2})T([0-9]{2}):([0-9]{2}):([0-9]{2})/', $time, $regs))

		{

			$fnc = ($utc == 1) ? 'gmmktime' : 'mktime';

			$t = $fnc($regs[4], $regs[5], $regs[6], $regs[2], $regs[3], $regs[1]);

		}

		return $t;

	}



} // End Response Class







/**

 * XML-RPC Message class

 *

 * @category	XML-RPC

 * @author		ExpressionEngine Dev Team

 * @link		http://codeigniter.com/user_guide/libraries/xmlrpc.html

 */

class XML_RPC_Message extends CI_Xmlrpc

{

	var $payload;

	var $method_name;

	var $params			= array();

	var $xh				= array();



	public function __construct($method, $pars=0)

	{

		parent::__construct();



		$this->method_name = $method;

		if (is_array($pars) && count($pars) > 0)

		{

			for ($i=0; $i<count($pars); $i++)

			{

				// $pars[$i] = XML_RPC_Values

				$this->params[] = $pars[$i];

			}

		}

	}



	//-------------------------------------

	//  Create Payload to Send

	//-------------------------------------



	function createPayload()

	{

		$this->payload = "<?xml version=\"1.0\"?".">\r\n<methodCall>\r\n";

		$this->payload .= '<methodName>' . $this->method_name . "</methodName>\r\n";

		$this->payload .= "<params>\r\n";



		for ($i=0; $i<count($this->params); $i++)

		{

			// $p = XML_RPC_Values

			$p = $this->params[$i];

			$this->payload .= "<param>\r\n".$p->serialize_class()."</param>\r\n";

		}



		$this->payload .= "</params>\r\n</methodCall>\r\n";

	}



	//-------------------------------------

	//  Parse External XML-RPC Server's Response

	//-------------------------------------



	function parseResponse($fp)

	{

		$data = '';



		while ($datum = fread($fp, 4096))

		{

			$data .= $datum;

		}



		//-------------------------------------

		//  DISPLAY HTTP CONTENT for DEBUGGING

		//-------------------------------------



		if ($this->debug === TRUE)

		{

			echo "<pre>";

			echo "---DATA---\n" . htmlspecialchars($data) . "\n---END DATA---\n\n";

			echo "</pre>";

		}



		//-------------------------------------

		//  Check for data

		//-------------------------------------



		if ($data == "")

		{

			error_log($this->xmlrpcstr['no_data']);

			$r = new XML_RPC_Response(0, $this->xmlrpcerr['no_data'], $this->xmlrpcstr['no_data']);

			return $r;

		}





		//-------------------------------------

		//  Check for HTTP 200 Response

		//-------------------------------------



		if (strncmp($data, 'HTTP', 4) == 0 && ! preg_match('/^HTTP\/[0-9\.]+ 200 /', $data))

		{

			$errstr= substr($data, 0, strpos($data, "\n")-1);

			$r = new XML_RPC_Response(0, $this->xmlrpcerr['http_error'], $this->xmlrpcstr['http_error']. ' (' . $errstr . ')');

			return $r;

		}



		//-------------------------------------

		//  Create and Set Up XML Parser

		//-------------------------------------



		$parser = xml_parser_create($this->xmlrpc_defencoding);



		$this->xh[$parser]					= array();

		$this->xh[$parser]['isf']			= 0;

		$this->xh[$parser]['ac']			= '';

		$this->xh[$parser]['headers']		= array();

		$this->xh[$parser]['stack']			= array();

		$this->xh[$parser]['valuestack']	= array();

		$this->xh[$parser]['isf_reason']	= 0;



		xml_set_object($parser, $this);

		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');





		//-------------------------------------

		//  GET HEADERS

		//-------------------------------------



		$lines = explode("\r\n", $data);

		while (($line = array_shift($lines)))

		{

			if (strlen($line) < 1)

			{

				break;

			}

			$this->xh[$parser]['headers'][] = $line;

		}

		$data = implode("\r\n", $lines);





		//-------------------------------------

		//  PARSE XML DATA

		//-------------------------------------



		if ( ! xml_parse($parser, $data, count($data)))

		{

			$errstr = sprintf('XML error: %s at line %d',

					xml_error_string(xml_get_error_code($parser)),

					xml_get_current_line_number($parser));

			//error_log($errstr);

			$r = new XML_RPC_Response(0, $this->xmlrpcerr['invalid_return'], $this->xmlrpcstr['invalid_return']);

			xml_parser_free($parser);

			return $r;

		}

		xml_parser_free($parser);



		// ---------------------------------------

		//  Got Ourselves Some Badness, It Seems

		// ---------------------------------------



		if ($this->xh[$parser]['isf'] > 1)

		{

			if ($this->debug === TRUE)

			{

				echo "---Invalid Return---\n";

				echo $this->xh[$parser]['isf_reason'];

				echo "---Invalid Return---\n\n";

			}



			$r = new XML_RPC_Response(0, $this->xmlrpcerr['invalid_return'],$this->xmlrpcstr['invalid_return'].' '.$this->xh[$parser]['isf_reason']);

			return $r;

		}

		elseif ( ! is_object($this->xh[$parser]['value']))

		{

			$r = new XML_RPC_Response(0, $this->xmlrpcerr['invalid_return'],$this->xmlrpcstr['invalid_return'].' '.$this->xh[$parser]['isf_reason']);

			return $r;

		}



		//-------------------------------------

		//  DISPLAY XML CONTENT for DEBUGGING

		//-------------------------------------



		if ($this->debug === TRUE)

		{

			echo "<pre>";



			if (count($this->xh[$parser]['headers'] > 0))

			{

				echo "---HEADERS---\n";

				foreach ($this->xh[$parser]['headers'] as $header)

				{

					echo "$header\n";

				}

				echo "---END HEADERS---\n\n";

			}



			echo "---DATA---\n" . htmlspecialchars($data) . "\n---END DATA---\n\n";



			echo "---PARSED---\n" ;

			var_dump($this->xh[$parser]['value']);

			echo "\n---END PARSED---</pre>";

		}



		//-------------------------------------

		//  SEND RESPONSE

		//-------------------------------------



		$v = $this->xh[$parser]['value'];



		if ($this->xh[$parser]['isf'])

		{

			$errno_v = $v->me['struct']['faultCode'];

			$errstr_v = $v->me['struct']['faultString'];

			$errno = $errno_v->scalarval();



			if ($errno == 0)

			{

				// FAULT returned, errno needs to reflect that

				$errno = -1;

			}



			$r = new XML_RPC_Response($v, $errno, $errstr_v->scalarval());

		}

		else

		{

			$r = new XML_RPC_Response($v);

		}



		$r->headers = $this->xh[$parser]['headers'];

		return $r;

	}



	// ------------------------------------

	//  Begin Return Message Parsing section

	// ------------------------------------



	// quick explanation of components:

	//   ac - used to accumulate values

	//   isf - used to indicate a fault

	//   lv - used to indicate "looking for a value": implements

	//		the logic to allow values with no types to be strings

	//   params - used to store parameters in method calls

	//   method - used to store method name

	//	 stack - array with parent tree of the xml element,

	//			 used to validate the nesting of elements



	//-------------------------------------

	//  Start Element Handler

	//-------------------------------------



	function open_tag($the_parser, $name, $attrs)

	{

		// If invalid nesting, then return

		if ($this->xh[$the_parser]['isf'] > 1) return;



		// Evaluate and check for correct nesting of XML elements



		if (count($this->xh[$the_parser]['stack']) == 0)

		{

			if ($name != 'METHODRESPONSE' && $name != 'METHODCALL')

			{

				$this->xh[$the_parser]['isf'] = 2;

				$this->xh[$the_parser]['isf_reason'] = 'Top level XML-RPC element is missing';

				return;

			}

		}

		else

		{

			// not top level element: see if parent is OK

			if ( ! in_array($this->xh[$the_parser]['stack'][0], $this->valid_parents[$name], TRUE))

			{

				$this->xh[$the_parser]['isf'] = 2;

				$this->xh[$the_parser]['isf_reason'] = "XML-RPC element $name cannot be child of ".$this->xh[$the_parser]['stack'][0];

				return;

			}

		}



		switch($name)

		{

			case 'STRUCT':

			case 'ARRAY':

				// Creates array for child elements



				$cur_val = array('value' => array(),

								 'type'	 => $name);



				array_unshift($this->xh[$the_parser]['valuestack'], $cur_val);

			break;

			case 'METHODNAME':

			case 'NAME':

				$this->xh[$the_parser]['ac'] = '';

			break;

			case 'FAULT':

				$this->xh[$the_parser]['isf'] = 1;

			break;

			case 'PARAM':

				$this->xh[$the_parser]['value'] = NULL;

			break;

			case 'VALUE':

				$this->xh[$the_parser]['vt'] = 'value';

				$this->xh[$the_parser]['ac'] = '';

				$this->xh[$the_parser]['lv'] = 1;

			break;

			case 'I4':

			case 'INT':

			case 'STRING':

			case 'BOOLEAN':

			case 'DOUBLE':

			case 'DATETIME.ISO8601':

			case 'BASE64':

				if ($this->xh[$the_parser]['vt'] != 'value')

				{

					//two data elements inside a value: an error occurred!

					$this->xh[$the_parser]['isf'] = 2;

					$this->xh[$the_parser]['isf_reason'] = "'Twas a $name element following a ".$this->xh[$the_parser]['vt']." element inside a single value";

					return;

				}



				$this->xh[$the_parser]['ac'] = '';

			break;

			case 'MEMBER':

				// Set name of <member> to nothing to prevent errors later if no <name> is found

				$this->xh[$the_parser]['valuestack'][0]['name'] = '';



				// Set NULL value to check to see if value passed for this param/member

				$this->xh[$the_parser]['value'] = NULL;

			break;

			case 'DATA':

			case 'METHODCALL':

			case 'METHODRESPONSE':

			case 'PARAMS':

				// valid elements that add little to processing

			break;

			default:

				/// An Invalid Element is Found, so we have trouble

				$this->xh[$the_parser]['isf'] = 2;

				$this->xh[$the_parser]['isf_reason'] = "Invalid XML-RPC element found: $name";

			break;

		}



		// Add current element name to stack, to allow validation of nesting

		array_unshift($this->xh[$the_parser]['stack'], $name);



		if ($name != 'VALUE') $this->xh[$the_parser]['lv'] = 0;

	}

	// END





	//-------------------------------------

	//  End Element Handler

	//-------------------------------------



	function closing_tag($the_parser, $name)

	{

		if ($this->xh[$the_parser]['isf'] > 1) return;



		// Remove current element from stack and set variable

		// NOTE: If the XML validates, then we do not have to worry about

		// the opening and closing of elements.  Nesting is checked on the opening

		// tag so we be safe there as well.



		$curr_elem = array_shift($this->xh[$the_parser]['stack']);



		switch($name)

		{

			case 'STRUCT':

			case 'ARRAY':

				$cur_val = array_shift($this->xh[$the_parser]['valuestack']);

				$this->xh[$the_parser]['value'] = ( ! isset($cur_val['values'])) ? array() : $cur_val['values'];

				$this->xh[$the_parser]['vt']	= strtolower($name);

			break;

			case 'NAME':

				$this->xh[$the_parser]['valuestack'][0]['name'] = $this->xh[$the_parser]['ac'];

			break;

			case 'BOOLEAN':

			case 'I4':

			case 'INT':

			case 'STRING':

			case 'DOUBLE':

			case 'DATETIME.ISO8601':

			case 'BASE64':

				$this->xh[$the_parser]['vt'] = strtolower($name);



				if ($name == 'STRING')

				{

					$this->xh[$the_parser]['value'] = $this->xh[$the_parser]['ac'];

				}

				elseif ($name=='DATETIME.ISO8601')

				{

					$this->xh[$the_parser]['vt']	= $this->xmlrpcDateTime;

					$this->xh[$the_parser]['value'] = $this->xh[$the_parser]['ac'];

				}

				elseif ($name=='BASE64')

				{

					$this->xh[$the_parser]['value'] = base64_decode($this->xh[$the_parser]['ac']);

				}

				elseif ($name=='BOOLEAN')

				{

					// Translated BOOLEAN values to TRUE AND FALSE

					if ($this->xh[$the_parser]['ac'] == '1')

					{

						$this->xh[$the_parser]['value'] = TRUE;

					}

					else

					{

						$this->xh[$the_parser]['value'] = FALSE;

					}

				}

				elseif ($name=='DOUBLE')

				{

					// we have a DOUBLE

					// we must check that only 0123456789-.<space> are characters here

					if ( ! preg_match('/^[+-]?[eE0-9\t \.]+$/', $this->xh[$the_parser]['ac']))

					{

						$this->xh[$the_parser]['value'] = 'ERROR_NON_NUMERIC_FOUND';

					}

					else

					{

						$this->xh[$the_parser]['value'] = (double)$this->xh[$the_parser]['ac'];

					}

				}

				else

				{

					// we have an I4/INT

					// we must check that only 0123456789-<space> are characters here

					if ( ! preg_match('/^[+-]?[0-9\t ]+$/', $this->xh[$the_parser]['ac']))

					{

						$this->xh[$the_parser]['value'] = 'ERROR_NON_NUMERIC_FOUND';

					}

					else

					{

						$this->xh[$the_parser]['value'] = (int)$this->xh[$the_parser]['ac'];

					}

				}

				$this->xh[$the_parser]['ac'] = '';

				$this->xh[$the_parser]['lv'] = 3; // indicate we've found a value

			break;

			case 'VALUE':

				// This if() detects if no scalar was inside <VALUE></VALUE>

				if ($this->xh[$the_parser]['vt']=='value')

				{

					$this->xh[$the_parser]['value']	= $this->xh[$the_parser]['ac'];

					$this->xh[$the_parser]['vt']	= $this->xmlrpcString;

				}



				// build the XML-RPC value out of the data received, and substitute it

				$temp = new XML_RPC_Values($this->xh[$the_parser]['value'], $this->xh[$the_parser]['vt']);



				if (count($this->xh[$the_parser]['valuestack']) && $this->xh[$the_parser]['valuestack'][0]['type'] == 'ARRAY')

				{

					// Array

					$this->xh[$the_parser]['valuestack'][0]['values'][] = $temp;

				}

				else

				{

					// Struct

					$this->xh[$the_parser]['value'] = $temp;

				}

			break;

			case 'MEMBER':

				$this->xh[$the_parser]['ac']='';



				// If value add to array in the stack for the last element built

				if ($this->xh[$the_parser]['value'])

				{

					$this->xh[$the_parser]['valuestack'][0]['values'][$this->xh[$the_parser]['valuestack'][0]['name']] = $this->xh[$the_parser]['value'];

				}

			break;

			case 'DATA':

				$this->xh[$the_parser]['ac']='';

			break;

			case 'PARAM':

				if ($this->xh[$the_parser]['value'])

				{

					$this->xh[$the_parser]['params'][] = $this->xh[$the_parser]['value'];

				}

			break;

			case 'METHODNAME':

				$this->xh[$the_parser]['method'] = ltrim($this->xh[$the_parser]['ac']);

			break;

			case 'PARAMS':

			case 'FAULT':

			case 'METHODCALL':

			case 'METHORESPONSE':

				// We're all good kids with nuthin' to do

			break;

			default:

				// End of an Invalid Element.  Taken care of during the opening tag though

			break;

		}

	}



	//-------------------------------------

	//  Parses Character Data

	//-------------------------------------



	function character_data($the_parser, $data)

	{

		if ($this->xh[$the_parser]['isf'] > 1) return; // XML Fault found already



		// If a value has not been found

		if ($this->xh[$the_parser]['lv'] != 3)

		{

			if ($this->xh[$the_parser]['lv'] == 1)

			{

				$this->xh[$the_parser]['lv'] = 2; // Found a value

			}



			if ( ! @isset($this->xh[$the_parser]['ac']))

			{

				$this->xh[$the_parser]['ac'] = '';

			}



			$this->xh[$the_parser]['ac'] .= $data;

		}

	}





	function addParam($par) { $this->params[]=$par; }



	function output_parameters($array=FALSE)

	{

		$CI =& get_instance();

		

		if ($array !== FALSE && is_array($array))

		{

			while (list($key) = each($array))

			{

				if (is_array($array[$key]))

				{

					$array[$key] = $this->output_parameters($array[$key]);

				}

				else

				{

					// 'bits' is for the MetaWeblog API image bits

					// @todo - this needs to be made more general purpose

					$array[$key] = ($key == 'bits' OR $this->xss_clean == FALSE) ? $array[$key] : $CI->security->xss_clean($array[$key]);

				}

			}



			$parameters = $array;

		}

		else

		{

			$parameters = array();



			for ($i = 0; $i < count($this->params); $i++)

			{

				$a_param = $this->decode_message($this->params[$i]);



				if (is_array($a_param))

				{

					$parameters[] = $this->output_parameters($a_param);

				}

				else

				{

					$parameters[] = ($this->xss_clean) ? $CI->security->xss_clean($a_param) : $a_param;

				}

			}

		}



		return $parameters;

	}





	function decode_message($param)

	{

		$kind = $param->kindOf();



		if ($kind == 'scalar')

		{

			return $param->scalarval();

		}

		elseif ($kind == 'array')

		{

			reset($param->me);

			list($a,$b) = each($param->me);



			$arr = array();



			for($i = 0; $i < count($b); $i++)

			{

				$arr[] = $this->decode_message($param->me['array'][$i]);

			}



			return $arr;

		}

		elseif ($kind == 'struct')

		{

			reset($param->me['struct']);



			$arr = array();



			while (list($key,$value) = each($param->me['struct']))

			{

				$arr[$key] = $this->decode_message($value);

			}



			return $arr;

		}

	}



} // End XML_RPC_Messages class







/**

 * XML-RPC Values class

 *

 * @category	XML-RPC

 * @author		ExpressionEngine Dev Team

 * @link		http://codeigniter.com/user_guide/libraries/xmlrpc.html

 */

class XML_RPC_Values extends CI_Xmlrpc

{

	var $me		= array();

	var $mytype	= 0;



	public function __construct($val=-1, $type='')

	{

		parent::__construct();



		if ($val != -1 OR $type != '')

		{

			$type = $type == '' ? 'string' : $type;



			if ($this->xmlrpcTypes[$type] == 1)

			{

				$this->addScalar($val,$type);

			}

			elseif ($this->xmlrpcTypes[$type] == 2)

			{

				$this->addArray($val);

			}

			elseif ($this->xmlrpcTypes[$type] == 3)

			{

				$this->addStruct($val);

			}

		}

	}



	function addScalar($val, $type='string')

	{

		$typeof = $this->xmlrpcTypes[$type];



		if ($this->mytype==1)

		{

			echo '<strong>XML_RPC_Values</strong>: scalar can have only one value<br />';

			return 0;

		}



		if ($typeof != 1)

		{

			echo '<strong>XML_RPC_Values</strong>: not a scalar type (${typeof})<br />';

			return 0;

		}



		if ($type == $this->xmlrpcBoolean)

		{

			if (strcasecmp($val,'true')==0 OR $val==1 OR ($val==true && strcasecmp($val,'false')))

			{

				$val = 1;

			}

			else

			{

				$val=0;

			}

		}



		if ($this->mytype == 2)

		{

			// adding to an array here

			$ar = $this->me['array'];

			$ar[] = new XML_RPC_Values($val, $type);

			$this->me['array'] = $ar;

		}

		else

		{

			// a scalar, so set the value and remember we're scalar

			$this->me[$type] = $val;

			$this->mytype = $typeof;

		}

		return 1;

	}



	function addArray($vals)

	{

		if ($this->mytype != 0)

		{

			echo '<strong>XML_RPC_Values</strong>: already initialized as a [' . $this->kindOf() . ']<br />';

			return 0;

		}



		$this->mytype = $this->xmlrpcTypes['array'];

		$this->me['array'] = $vals;

		return 1;

	}



	function addStruct($vals)

	{

		if ($this->mytype != 0)

		{

			echo '<strong>XML_RPC_Values</strong>: already initialized as a [' . $this->kindOf() . ']<br />';

			return 0;

		}

		$this->mytype = $this->xmlrpcTypes['struct'];

		$this->me['struct'] = $vals;

		return 1;

	}



	function kindOf()

	{

		switch($this->mytype)

		{

			case 3:

				return 'struct';

				break;

			case 2:

				return 'array';

				break;

			case 1:

				return 'scalar';

				break;

			default:

				return 'undef';

		}

	}



	function serializedata($typ, $val)

	{

		$rs = '';



		switch($this->xmlrpcTypes[$typ])

		{

			case 3:

				// struct

				$rs .= "<struct>\n";

				reset($val);

				while (list($key2, $val2) = each($val))

				{

					$rs .= "<member>\n<name>{$key2}</name>\n";

					$rs .= $this->serializeval($val2);

					$rs .= "</member>\n";

				}

				$rs .= '</struct>';

			break;

			case 2:

				// array

				$rs .= "<array>\n<data>\n";

				for($i=0; $i < count($val); $i++)

				{

					$rs .= $this->serializeval($val[$i]);

				}

				$rs.="</data>\n</array>\n";

				break;

			case 1:

				// others

				switch ($typ)

				{

					case $this->xmlrpcBase64:

						$rs .= "<{$typ}>" . base64_encode((string)$val) . "</{$typ}>\n";

					break;

					case $this->xmlrpcBoolean:

						$rs .= "<{$typ}>" . ((bool)$val ? '1' : '0') . "</{$typ}>\n";

					break;

					case $this->xmlrpcString:

						$rs .= "<{$typ}>" . htmlspecialchars((string)$val). "</{$typ}>\n";

					break;

					default:

						$rs .= "<{$typ}>{$val}</{$typ}>\n";

					break;

				}

			default:

			break;

		}

		return $rs;

	}



	function serialize_class()

	{

		return $this->serializeval($this);

	}



	function serializeval($o)

	{

		$ar = $o->me;

		reset($ar);



		list($typ, $val) = each($ar);

		$rs = "<value>\n".$this->serializedata($typ, $val)."</value>\n";

		return $rs;

	}



	function scalarval()

	{

		reset($this->me);

		list($a,$b) = each($this->me);

		return $b;

	}





	//-------------------------------------

	// Encode time in ISO-8601 form.

	//-------------------------------------



	// Useful for sending time in XML-RPC



	function iso8601_encode($time, $utc=0)

	{

		if ($utc == 1)

		{

			$t = strftime("%Y%m%dT%H:%M:%S", $time);

		}

		else

		{

			if (function_exists('gmstrftime'))

				$t = gmstrftime("%Y%m%dT%H:%M:%S", $time);

			else

				$t = strftime("%Y%m%dT%H:%M:%S", $time - date('Z'));

		}

		return $t;

	}



}

// END XML_RPC_Values Class



/* End of file Xmlrpc.php */

/* Location: ./system/libraries/Xmlrpc.php */