bcit-ci/CodeIgniter

View on GitHub
system/libraries/Xmlrpc.php

Summary

Maintainability
F
1 wk
Test Coverage
<?php
/**
 * CodeIgniter
 *
 * An open source application development framework for PHP
 *
 * This content is released under the MIT License (MIT)
 *
 * Copyright (c) 2014 - 2018, British Columbia Institute of Technology
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 *
 * @package    CodeIgniter
 * @author    EllisLab Dev Team
 * @copyright    Copyright (c) 2008 - 2014, EllisLab, Inc. (https://ellislab.com/)
 * @copyright    Copyright (c) 2014 - 2018, British Columbia Institute of Technology (http://bcit.ca/)
 * @license    http://opensource.org/licenses/MIT    MIT License
 * @link    https://codeigniter.com
 * @since    Version 1.0.0
 * @filesource
 */
defined('BASEPATH') OR exit('No direct script access allowed');

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        EllisLab Dev Team
 * @link        https://codeigniter.com/user_guide/libraries/xmlrpc.html
 */
class CI_Xmlrpc {

    /**
     * Debug flag
     *
     * @var    bool
     */
    public $debug        = FALSE;

    /**
     * I4 data type
     *
     * @var    string
     */
    public $xmlrpcI4    = 'i4';

    /**
     * Integer data type
     *
     * @var    string
     */
    public $xmlrpcInt    = 'int';

    /**
     * Boolean data type
     *
     * @var    string
     */
    public $xmlrpcBoolean    = 'boolean';

    /**
     * Double data type
     *
     * @var    string
     */
    public $xmlrpcDouble    = 'double';

    /**
     * String data type
     *
     * @var    string
     */
    public $xmlrpcString    = 'string';

    /**
     * DateTime format
     *
     * @var    string
     */
    public $xmlrpcDateTime    = 'dateTime.iso8601';

    /**
     * Base64 data type
     *
     * @var    string
     */
    public $xmlrpcBase64    = 'base64';

    /**
     * Array data type
     *
     * @var    string
     */
    public $xmlrpcArray    = 'array';

    /**
     * Struct data type
     *
     * @var    string
     */
    public $xmlrpcStruct    = 'struct';

    /**
     * Data types list
     *
     * @var    array
     */
    public $xmlrpcTypes    = array();

    /**
     * Valid parents list
     *
     * @var    array
     */
    public $valid_parents    = array();

    /**
     * Response error numbers list
     *
     * @var    array
     */
    public $xmlrpcerr        = array();

    /**
     * Response error messages list
     *
     * @var    string[]
     */
    public $xmlrpcstr        = array();

    /**
     * Encoding charset
     *
     * @var    string
     */
    public $xmlrpc_defencoding    = 'UTF-8';

    /**
     * XML-RPC client name
     *
     * @var    string
     */
    public $xmlrpcName        = 'XML-RPC for CodeIgniter';

    /**
     * XML-RPC version
     *
     * @var    string
     */
    public $xmlrpcVersion        = '1.1';

    /**
     * Start of user errors
     *
     * @var    int
     */
    public $xmlrpcerruser        = 800;

    /**
     * Start of XML parse errors
     *
     * @var    int
     */
    public $xmlrpcerrxml        = 100;

    /**
     * Backslash replacement value
     *
     * @var    string
     */
    public $xmlrpc_backslash    = '';

    /**
     * XML-RPC Client object
     *
     * @var    object
     */
    public $client;

    /**
     * XML-RPC Method name
     *
     * @var    string
     */
    public $method;

    /**
     * XML-RPC Data
     *
     * @var    array
     */
    public $data;

    /**
     * XML-RPC Message
     *
     * @var    string
     */
    public $message            = '';

    /**
     * Request error message
     *
     * @var    string
     */
    public $error            = '';

    /**
     * XML-RPC result object
     *
     * @var    object
     */
    public $result;

    /**
     * XML-RPC Response
     *
     * @var    array
     */
    public $response        = array(); // Response from remote server

    /**
     * XSS Filter flag
     *
     * @var    bool
     */
    public $xss_clean        = TRUE;

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

    /**
     * Constructor
     *
     * Initializes property default values
     *
     * @param    array    $config
     * @return    void
     */
    public function __construct($config = array())
    {
        $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('info', 'XML-RPC Class Initialized');
    }

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

    /**
     * Initialize
     *
     * @param    array    $config
     * @return    void
     */
    public function initialize($config = array())
    {
        if (count($config) > 0)
        {
            foreach ($config as $key => $val)
            {
                if (isset($this->$key))
                {
                    $this->$key = $val;
                }
            }
        }
    }

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

    /**
     * Parse server URL
     *
     * @param    string    $url
     * @param    int    $port
     * @param    string    $proxy
     * @param    int    $proxy_port
     * @return    void
     */
    public function server($url, $port = 80, $proxy = FALSE, $proxy_port = 8080)
    {
        if (stripos($url, 'http') !== 0)
        {
            $url = 'http://'.$url;
        }

        $parts = parse_url($url);

        if (isset($parts['user'], $parts['pass']))
        {
            $parts['host'] = $parts['user'].':'.$parts['pass'].'@'.$parts['host'];
        }

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

        if ( ! empty($parts['query']))
        {
            $path .= '?'.$parts['query'];
        }

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

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

    /**
     * Set Timeout
     *
     * @param    int    $seconds
     * @return    void
     */
    public function timeout($seconds = 5)
    {
        if ($this->client !== NULL && is_int($seconds))
        {
            $this->client->timeout = $seconds;
        }
    }

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

    /**
     * Set Methods
     *
     * @param    string    $function    Method name
     * @return    void
     */
    public function method($function)
    {
        $this->method = $function;
    }

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

    /**
     * Take Array of Data and Create Objects
     *
     * @param    array    $incoming
     * @return    void
     */
    public function request($incoming)
    {
        if ( ! is_array($incoming))
        {
            // Send Error
            return;
        }

        $this->data = array();

        foreach ($incoming as $key => $value)
        {
            $this->data[$key] = $this->values_parsing($value);
        }
    }

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

    /**
     * Set Debug
     *
     * @param    bool    $flag
     * @return    void
     */
    public function set_debug($flag = TRUE)
    {
        $this->debug = ($flag === TRUE);
    }

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

    /**
     * Values Parsing
     *
     * @param    mixed    $value
     * @return    object
     */
    public function values_parsing($value)
    {
        if (is_array($value) && array_key_exists(0, $value))
        {
            if ( ! isset($value[1], $this->xmlrpcTypes[$value[1]]))
            {
                $temp = new XML_RPC_Values($value[0], (is_array($value[0]) ? 'array' : 'string'));
            }
            else
            {
                if (is_array($value[0]) && ($value[1] === 'struct' OR $value[1] === 'array'))
                {
                    foreach (array_keys($value[0]) as $k)
                    {
                        $value[0][$k] = $this->values_parsing($value[0][$k]);
                    }
                }

                $temp = new XML_RPC_Values($value[0], $value[1]);
            }
        }
        else
        {
            $temp = new XML_RPC_Values($value, 'string');
        }

        return $temp;
    }

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

    /**
     * Sends XML-RPC Request
     *
     * @return    bool
     */
    public 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) OR ! is_object($this->result->val))
        {
            $this->error = $this->result->errstr;
            return FALSE;
        }

        $this->response = $this->result->decode();
        return TRUE;
    }

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

    /**
     * Returns Error
     *
     * @return    string
     */
    public function display_error()
    {
        return $this->error;
    }

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

    /**
     * Returns Remote Server Response
     *
     * @return    string
     */
    public function display_response()
    {
        return $this->response;
    }

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

    /**
     * Sends an Error Message for Server Request
     *
     * @param    int    $number
     * @param    string    $message
     * @return    object
     */
    public function send_error_message($number, $message)
    {
        return new XML_RPC_Response(0, $number, $message);
    }

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

    /**
     * Send Response for Server Request
     *
     * @param    array    $response
     * @return    object
     */
    public 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
        return new XML_RPC_Response($this->values_parsing($response));
    }

} // END XML_RPC Class

/**
 * XML-RPC Client class
 *
 * @category    XML-RPC
 * @author        EllisLab Dev Team
 * @link        https://codeigniter.com/user_guide/libraries/xmlrpc.html
 */
class XML_RPC_Client extends CI_Xmlrpc
{
    /**
     * Path
     *
     * @var    string
     */
    public $path            = '';

    /**
     * Server hostname
     *
     * @var    string
     */
    public $server            = '';

    /**
     * Server port
     *
     * @var    int
     */
    public $port            = 80;

    /**
     *
     * Server username
     *
     * @var    string
     */
    public $username;

    /**
     * Server password
     *
     * @var    string
     */
    public $password;

    /**
     * Proxy hostname
     *
     * @var    string
     */
    public $proxy            = FALSE;

    /**
     * Proxy port
     *
     * @var    int
     */
    public $proxy_port        = 8080;

    /**
     * Error number
     *
     * @var    string
     */
    public $errno            = '';

    /**
     * Error message
     *
     * @var    string
     */
    public $errstring        = '';

    /**
     * Timeout in seconds
     *
     * @var    int
     */
    public $timeout        = 5;

    /**
     * No Multicall flag
     *
     * @var    bool
     */
    public $no_multicall    = FALSE;

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

    /**
     * Constructor
     *
     * @param    string    $path
     * @param    object    $server
     * @param    int    $port
     * @param    string    $proxy
     * @param    int    $proxy_port
     * @return    void
     */
    public function __construct($path, $server, $port = 80, $proxy = FALSE, $proxy_port = 8080)
    {
        parent::__construct();

        $url = parse_url('http://'.$server);

        if (isset($url['user'], $url['pass']))
        {
            $this->username = $url['user'];
            $this->password = $url['pass'];
        }

        $this->port = $port;
        $this->server = $url['host'];
        $this->path = $path;
        $this->proxy = $proxy;
        $this->proxy_port = $proxy_port;
    }

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

    /**
     * Send message
     *
     * @param    mixed    $msg
     * @return    object
     */
    public function send($msg)
    {
        if (is_array($msg))
        {
            // Multi-call disabled
            return new XML_RPC_Response(0, $this->xmlrpcerr['multicall_recursion'], $this->xmlrpcstr['multicall_recursion']);
        }

        return $this->sendPayload($msg);
    }

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

    /**
     * Send payload
     *
     * @param    object    $msg
     * @return    object
     */
    public function sendPayload($msg)
    {
        if ($this->proxy === FALSE)
        {
            $server = $this->server;
            $port = $this->port;
        }
        else
        {
            $server = $this->proxy;
            $port = $this->proxy_port;
        }

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

        if ( ! is_resource($fp))
        {
            error_log($this->xmlrpcstr['http_error']);
            return new XML_RPC_Response(0, $this->xmlrpcerr['http_error'], $this->xmlrpcstr['http_error']);
        }

        if (empty($msg->payload))
        {
            // $msg = XML_RPC_Messages
            $msg->createPayload();
        }

        $r = "\r\n";
        $op = 'POST '.$this->path.' HTTP/1.0'.$r
            .'Host: '.$this->server.$r
            .'Content-Type: text/xml'.$r
            .(isset($this->username, $this->password) ? 'Authorization: Basic '.base64_encode($this->username.':'.$this->password).$r : '')
            .'User-Agent: '.$this->xmlrpcName.$r
            .'Content-Length: '.strlen($msg->payload).$r.$r
            .$msg->payload;

        stream_set_timeout($fp, $this->timeout); // set timeout for subsequent operations

        for ($written = $timestamp = 0, $length = strlen($op); $written < $length; $written += $result)
        {
            if (($result = fwrite($fp, substr($op, $written))) === FALSE)
            {
                break;
            }
            // See https://bugs.php.net/bug.php?id=39598 and http://php.net/manual/en/function.fwrite.php#96951
            elseif ($result === 0)
            {
                if ($timestamp === 0)
                {
                    $timestamp = time();
                }
                elseif ($timestamp < (time() - $this->timeout))
                {
                    $result = FALSE;
                    break;
                }
            }
            else
            {
                $timestamp = 0;
            }
        }

        if ($result === FALSE)
        {
            error_log($this->xmlrpcstr['http_error']);
            return new XML_RPC_Response(0, $this->xmlrpcerr['http_error'], $this->xmlrpcstr['http_error']);
        }

        $resp = $msg->parseResponse($fp);
        fclose($fp);
        return $resp;
    }

} // END XML_RPC_Client Class

/**
 * XML-RPC Response class
 *
 * @category    XML-RPC
 * @author        EllisLab Dev Team
 * @link        https://codeigniter.com/user_guide/libraries/xmlrpc.html
 */
class XML_RPC_Response
{

    /**
     * Value
     *
     * @var    mixed
     */
    public $val        = 0;

    /**
     * Error number
     *
     * @var    int
     */
    public $errno        = 0;

    /**
     * Error message
     *
     * @var    string
     */
    public $errstr        = '';

    /**
     * Headers list
     *
     * @var    array
     */
    public $headers        = array();

    /**
     * XSS Filter flag
     *
     * @var    bool
     */
    public $xss_clean    = TRUE;

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

    /**
     * Constructor
     *
     * @param    mixed    $val
     * @param    int    $code
     * @param    string    $fstr
     * @return    void
     */
    public function __construct($val, $code = 0, $fstr = '')
    {
        if ($code !== 0)
        {
            // error
            $this->errno = $code;
            $this->errstr = htmlspecialchars($fstr, ENT_XML1 | ENT_NOQUOTES, 'UTF-8');
        }
        elseif ( ! 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;
        }
    }

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

    /**
     * Fault code
     *
     * @return    int
     */
    public function faultCode()
    {
        return $this->errno;
    }

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

    /**
     * Fault string
     *
     * @return    string
     */
    public function faultString()
    {
        return $this->errstr;
    }

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

    /**
     * Value
     *
     * @return    mixed
     */
    public function value()
    {
        return $this->val;
    }

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

    /**
     * Prepare response
     *
     * @return    string    xml
     */
    public function prepare_response()
    {
        return "<methodResponse>\n"
            .($this->errno
                ? '<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>'
                : "<params>\n<param>\n".$this->val->serialize_class()."</param>\n</params>")
            ."\n</methodResponse>";
    }

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

    /**
     * Decode
     *
     * @param    mixed    $array
     * @return    array
     */
    public function decode($array = NULL)
    {
        $CI =& get_instance();

        if (is_array($array))
        {
            foreach ($array as $key => &$value)
            {
                if (is_array($value))
                {
                    $array[$key] = $this->decode($value);
                }
                elseif ($this->xss_clean)
                {
                    $array[$key] = $CI->security->xss_clean($value);
                }
            }

            return $array;
        }

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

        if (is_array($result))
        {
            $result = $this->decode($result);
        }
        elseif ($this->xss_clean)
        {
            $result = $CI->security->xss_clean($result);
        }

        return $result;
    }

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

    /**
     * XML-RPC Object to PHP Types
     *
     * @param    object
     * @return    array
     */
    public function xmlrpc_decoder($xmlrpc_val)
    {
        $kind = $xmlrpc_val->kindOf();

        if ($kind === 'scalar')
        {
            return $xmlrpc_val->scalarval();
        }
        elseif ($kind === 'array')
        {
            reset($xmlrpc_val->me);
            $b = current($xmlrpc_val->me);
            $arr = array();

            for ($i = 0, $size = count($b); $i < $size; $i++)
            {
                $arr[] = $this->xmlrpc_decoder($xmlrpc_val->me['array'][$i]);
            }
            return $arr;
        }
        elseif ($kind === 'struct')
        {
            reset($xmlrpc_val->me['struct']);
            $arr = array();

            foreach ($xmlrpc_val->me['struct'] as $key => &$value)
            {
                $arr[$key] = $this->xmlrpc_decoder($value);
            }

            return $arr;
        }
    }

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

    /**
     * ISO-8601 time to server or UTC time
     *
     * @param    string
     * @param    bool
     * @return    int    unix timestamp
     */
    public function iso8601_decode($time, $utc = FALSE)
    {
        // Return a time 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 === TRUE) ? 'gmmktime' : 'mktime';
            $t = $fnc($regs[4], $regs[5], $regs[6], $regs[2], $regs[3], $regs[1]);
        }
        return $t;
    }

} // END XML_RPC_Response Class

/**
 * XML-RPC Message class
 *
 * @category    XML-RPC
 * @author        EllisLab Dev Team
 * @link        https://codeigniter.com/user_guide/libraries/xmlrpc.html
 */
class XML_RPC_Message extends CI_Xmlrpc
{

    /**
     * Payload
     *
     * @var    string
     */
    public $payload;

    /**
     * Method name
     *
     * @var    string
     */
    public $method_name;

    /**
     * Parameter list
     *
     * @var    array
     */
    public $params        = array();

    /**
     * XH?
     *
     * @var    array
     */
    public $xh        = array();

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

    /**
     * Constructor
     *
     * @param    string    $method
     * @param    array    $pars
     * @return    void
     */
    public function __construct($method, $pars = FALSE)
    {
        parent::__construct();

        $this->method_name = $method;
        if (is_array($pars) && count($pars) > 0)
        {
            for ($i = 0, $c = count($pars); $i < $c; $i++)
            {
                // $pars[$i] = XML_RPC_Values
                $this->params[] = $pars[$i];
            }
        }
    }

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

    /**
     * Create Payload to Send
     *
     * @return    void
     */
    public function createPayload()
    {
        $this->payload = '<?xml version="1.0"?'.">\r\n<methodCall>\r\n"
                .'<methodName>'.$this->method_name."</methodName>\r\n"
                ."<params>\r\n";

        for ($i = 0, $c = count($this->params); $i < $c; $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
     *
     * @param    resource
     * @return    object
     */
    public function parseResponse($fp)
    {
        $data = '';

        while ($datum = fread($fp, 4096))
        {
            $data .= $datum;
        }

        // Display HTTP content for debugging
        if ($this->debug === TRUE)
        {
            echo "<pre>---DATA---\n".htmlspecialchars($data)."\n---END DATA---\n\n</pre>";
        }

        // Check for data
        if ($data === '')
        {
            error_log($this->xmlrpcstr['no_data']);
            return new XML_RPC_Response(0, $this->xmlrpcerr['no_data'], $this->xmlrpcstr['no_data']);
        }

        // Check for HTTP 200 Response
        if (strpos($data, 'HTTP') === 0 && ! preg_match('/^HTTP\/[0-9\.]+ 200 /', $data))
        {
            $errstr = substr($data, 0, strpos($data, "\n")-1);
            return new XML_RPC_Response(0, $this->xmlrpcerr['http_error'], $this->xmlrpcstr['http_error'].' ('.$errstr.')');
        }

        //-------------------------------------
        // Create and Set Up XML Parser
        //-------------------------------------

        $parser = xml_parser_create($this->xmlrpc_defencoding);
        $pname = (string) $parser;
        $this->xh[$pname] = array(
            'isf'        => 0,
            'ac'        => '',
            'headers'    => array(),
            'stack'        => array(),
            'valuestack'    => array(),
            '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[$pname]['headers'][] = $line;
        }
        $data = implode("\r\n", $lines);

        // Parse XML data
        if ( ! xml_parse($parser, $data, TRUE))
        {
            $errstr = sprintf('XML error: %s at line %d',
                        xml_error_string(xml_get_error_code($parser)),
                        xml_get_current_line_number($parser));

            $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[$pname]['isf'] > 1)
        {
            if ($this->debug === TRUE)
            {
                echo "---Invalid Return---\n".$this->xh[$pname]['isf_reason']."---Invalid Return---\n\n";
            }

            return new XML_RPC_Response(0, $this->xmlrpcerr['invalid_return'], $this->xmlrpcstr['invalid_return'].' '.$this->xh[$pname]['isf_reason']);
        }
        elseif ( ! is_object($this->xh[$pname]['value']))
        {
            return new XML_RPC_Response(0, $this->xmlrpcerr['invalid_return'], $this->xmlrpcstr['invalid_return'].' '.$this->xh[$pname]['isf_reason']);
        }

        // Display XML content for debugging
        if ($this->debug === TRUE)
        {
            echo '<pre>';

            if (count($this->xh[$pname]['headers'] > 0))
            {
                echo "---HEADERS---\n";
                foreach ($this->xh[$pname]['headers'] as $header)
                {
                    echo $header."\n";
                }
                echo "---END HEADERS---\n\n";
            }

            echo "---DATA---\n".htmlspecialchars($data)."\n---END DATA---\n\n---PARSED---\n";
            var_dump($this->xh[$pname]['value']);
            echo "\n---END PARSED---</pre>";
        }

        // Send response
        $v = $this->xh[$pname]['value'];
        if ($this->xh[$pname]['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[$pname]['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
     *
     * @param    string
     * @param    string
     * @return    void
     */
    public function open_tag($the_parser, $name)
    {
        $the_parser = (string) $the_parser;

        // 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;
            }
        }
        // not top level element: see if parent is OK
        elseif ( ! 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'] = 'There is 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);

        $name === 'VALUE' OR $this->xh[$the_parser]['lv'] = 0;
    }

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

    /**
     * End Element Handler
     *
     * @param    string
     * @param    string
     * @return    void
     */
    public function closing_tag($the_parser, $name)
    {
        $the_parser = (string) $the_parser;

        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']) ? $cur_val['values'] : array();
                $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
                    $this->xh[$the_parser]['value'] = (bool) $this->xh[$the_parser]['ac'];
                }
                elseif ($name=='DOUBLE')
                {
                    // we have a DOUBLE
                    // we must check that only 0123456789-.<space> are characters here
                    $this->xh[$the_parser]['value'] = preg_match('/^[+-]?[eE0-9\t \.]+$/', $this->xh[$the_parser]['ac'])
                                        ? (float) $this->xh[$the_parser]['ac']
                                        : 'ERROR_NON_NUMERIC_FOUND';
                }
                else
                {
                    // we have an I4/INT
                    // we must check that only 0123456789-<space> are characters here
                    $this->xh[$the_parser]['value'] = preg_match('/^[+-]?[0-9\t ]+$/', $this->xh[$the_parser]['ac'])
                                        ? (int) $this->xh[$the_parser]['ac']
                                        : 'ERROR_NON_NUMERIC_FOUND';
                }
                $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;
        }
    }

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

    /**
     * Parse character data
     *
     * @param    string
     * @param    string
     * @return    void
     */
    public function character_data($the_parser, $data)
    {
        $the_parser = (string) $the_parser;

        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;
        }
    }

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

    /**
     * Add parameter
     *
     * @param    mixed
     * @return    void
     */
    public function addParam($par)
    {
        $this->params[] = $par;
    }

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

    /**
     * Output parameters
     *
     * @param    array    $array
     * @return    array
     */
    public function output_parameters(array $array = array())
    {
        $CI =& get_instance();

        if ( ! empty($array))
        {
            foreach ($array as $key => &$value)
            {
                if (is_array($value))
                {
                    $array[$key] = $this->output_parameters($value);
                }
                elseif ($key !== 'bits' && $this->xss_clean)
                {
                    // 'bits' is for the MetaWeblog API image bits
                    // @todo - this needs to be made more general purpose
                    $array[$key] = $CI->security->xss_clean($value);
                }
            }

            return $array;
        }

        $parameters = array();

        for ($i = 0, $c = count($this->params); $i < $c; $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;
    }

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

    /**
     * Decode message
     *
     * @param    object
     * @return    mixed
     */
    public function decode_message($param)
    {
        $kind = $param->kindOf();

        if ($kind === 'scalar')
        {
            return $param->scalarval();
        }
        elseif ($kind === 'array')
        {
            reset($param->me);
            $b = current($param->me);
            $arr = array();

            for ($i = 0, $c = count($b); $i < $c; $i++)
            {
                $arr[] = $this->decode_message($param->me['array'][$i]);
            }

            return $arr;
        }
        elseif ($kind === 'struct')
        {
            reset($param->me['struct']);
            $arr = array();

            foreach ($param->me['struct'] as $key => &$value)
            {
                $arr[$key] = $this->decode_message($value);
            }

            return $arr;
        }
    }

} // END XML_RPC_Message Class

/**
 * XML-RPC Values class
 *
 * @category    XML-RPC
 * @author        EllisLab Dev Team
 * @link        https://codeigniter.com/user_guide/libraries/xmlrpc.html
 */
class XML_RPC_Values extends CI_Xmlrpc
{
    /**
     * Value data
     *
     * @var    array
     */
    public $me    = array();

    /**
     * Value type
     *
     * @var    int
     */
    public $mytype    = 0;

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

    /**
     * Constructor
     *
     * @param    mixed    $val
     * @param    string    $type
     * @return    void
     */
    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);
            }
        }
    }

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

    /**
     * Add scalar value
     *
     * @param    scalar
     * @param    string
     * @return    int
     */
    public 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)
        {
            $val = (int) (strcasecmp($val, 'true') === 0 OR $val === 1 OR ($val === TRUE && strcasecmp($val, 'false')));
        }

        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;
    }

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

    /**
     * Add array value
     *
     * @param    array
     * @return    int
     */
    public 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;
    }

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

    /**
     * Add struct value
     *
     * @param    object
     * @return    int
     */
    public 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;
    }

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

    /**
     * Get value type
     *
     * @return    string
     */
    public function kindOf()
    {
        switch ($this->mytype)
        {
            case 3: return 'struct';
            case 2: return 'array';
            case 1: return 'scalar';
            default: return 'undef';
        }
    }

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

    /**
     * Serialize data
     *
     * @param    string
     * @param    mixed
     * @return    string
     */
    public function serializedata($typ, $val)
    {
        $rs = '';

        switch ($this->xmlrpcTypes[$typ])
        {
            case 3:
                // struct
                $rs .= "<struct>\n";
                reset($val);
                foreach ($val as $key2 => &$val2)
                {
                    $rs .= "<member>\n<name>{$key2}</name>\n".$this->serializeval($val2)."</member>\n";
                }
                $rs .= '</struct>';
                break;
            case 2:
                // array
                $rs .= "<array>\n<data>\n";
                for ($i = 0, $c = count($val); $i < $c; $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;
    }

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

    /**
     * Serialize class
     *
     * @return    string
     */
    public function serialize_class()
    {
        return $this->serializeval($this);
    }

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

    /**
     * Serialize value
     *
     * @param    object
     * @return    string
     */
    public function serializeval($o)
    {
        $array = $o->me;
        list($value, $type) = array(reset($array), key($array));
        return "<value>\n".$this->serializedata($type, $value)."</value>\n";
    }

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

    /**
     * Scalar value
     *
     * @return    mixed
     */
    public function scalarval()
    {
        return reset($this->me);
    }

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

    /**
     * Encode time in ISO-8601 form.
     * Useful for sending time in XML-RPC
     *
     * @param    int    unix timestamp
     * @param    bool
     * @return    string
    */
    public function iso8601_encode($time, $utc = FALSE)
    {
        return ($utc) ? strftime('%Y%m%dT%H:%i:%s', $time) : gmstrftime('%Y%m%dT%H:%i:%s', $time);
    }

} // END XML_RPC_Values Class