comodojo / xmlrpc

src/Comodojo/Xmlrpc/XmlrpcEncoder.php

<?php namespace Comodojo\Xmlrpc;

use \Comodojo\Exception\XmlrpcException;
use \XMLWriter;
use \Exception;

/** 
 * XML-RPC encoder
 *
 * Main features:
 * - support for <nil /> and <ex:nil />
 * - implements true, XML compliant, HTML numeric entities conversion
 * - support for CDATA values
 *
 * @package     Comodojo Spare Parts
 * @author      Marco Giovinazzi <marco.giovinazzi@comodojo.org>
 * @license     MIT
 *
 * LICENSE:
 * 
 * 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.
 */

class XmlrpcEncoder {

    /**
     * Request/Response encoding
     *
     * @var string
     */
    private $encoding;

    /**
     * References of special values (base64, datetime, cdata)
     *
     * @var array
     */
    private $special_types = array();

    /**
     * ex:nil switch (for apache rpc compatibility)
     *
     * @var bool
     */
    private $use_ex_nil = false;

    /**
     * Constructor method
     */
    final public function __construct() {

        $this->encoding = defined("XMLRPC_DEFAULT_ENCODING") ? strtolower(XMLRPC_DEFAULT_ENCODING) : 'utf-8';

    }

    /**
     * Set encoding 
     *
     * @param   string   $encoding
     *
     * @return  \Comodojo\Xmlrpc\XmlrpcEncoder
     */
    final public function setEncoding($encoding) {

        $this->encoding = $encoding;

        return $this;

    }

    /**
     * Get encoding 
     *
     * @return  string
     */
    final public function getEncoding() {

        return $this->encoding;

    }

    /**
     * Handle base64 and datetime values 
     *
     * @param   mixed    $value  The referenced value
     * @param   string   $type   The type of value
     *
     * @return  \Comodojo\Xmlrpc\XmlrpcEncoder
     */
    final public function setValueType(&$value, $type) {

        if ( empty($value) || !in_array(strtolower($type), array("base64", "datetime", "cdata")) ) throw new XmlrpcException("Invalid value type");

        $this->special_types[$value] = strtolower($type);

        return $this;

    }

    /**
     * Use <ex:nil /> instead of <nil /> (apache xmlrpc compliant)
     *
     * @param   bool    $mode
     *
     * @return  \Comodojo\Xmlrpc\XmlrpcEncoder 
     */
    final public function useExNil($mode = true) {

        $this->use_ex_nil = filter_var($mode, FILTER_VALIDATE_BOOLEAN);

        return $this;

    }

    /**
     * Encode an xmlrpc response
     *
     * It expects a scalar, array or NULL as $data and will try to encode it as a valid xmlrpc response.
     *
     * @param   mixed   $data
     *
     * @return  string  xmlrpc formatted response
     *
     * @throws  \Comodojo\Exception\XmlrpcException
     * @throws  \Exception
     */
    public function encodeResponse($data) {

        $xml = new XMLWriter(); 

        $xml->openMemory();

        $xml->setIndent(false);

        $xml->startDocument('1.0', $this->encoding); 

        $xml->startElement("methodResponse");

            $xml->startElement("params");

                $xml->startElement("param");

                    $xml->startElement("value");

                    try {
                    
                        $this->encodeValue($xml, $data);

                    } catch (XmlrpcException $xe) {
                        
                        throw $xe;

                    } catch (Exception $e) {
                        
                        throw $e;

                    }

                    $xml->endElement();

                $xml->endElement();

            $xml->endElement();

        $xml->endElement();

        $xml->endDocument();

        return trim($xml->outputMemory());

    }

    /**
     * Encode an xmlrpc call
     *
     * It expects an array of values as $data and will try to encode it as a valid xmlrpc call.
     *
     * @param   string  $method
     * @param   array   $data
     *
     * @return  string  xmlrpc formatted call
     *
     * @throws  \Comodojo\Exception\XmlrpcException
     * @throws  \Exception
     */
    public function encodeCall($method, $data = array()) {

        $xml = new XMLWriter(); 

        $xml->openMemory();

        $xml->setIndent(false);

        $xml->startDocument('1.0', $this->encoding); 

        $xml->startElement("methodCall");

            $xml->writeElement("methodName", trim($method));

            $xml->startElement("params");

            try {
                        
                foreach ( $data as $d ) {

                    $xml->startElement("param");

                        $xml->startElement("value");

                            $this->encodeValue($xml, $d);

                        $xml->endElement();

                    $xml->endElement();

                }

            } catch (XmlrpcException $xe) {
                        
                throw $xe;

            }

            $xml->endElement();

        $xml->endElement();

        $xml->endDocument();

        return trim($xml->outputMemory());

    }

    /**
     * Encode an xmlrpc multicall
     *
     * It expects in input a key->val array where key
     * represent the method and val the parameters.
     *
     * @param   array   $data
     *
     * @return  string  xmlrpc formatted call
     *
     * @throws  \Comodojo\Exception\XmlrpcException
     * @throws  \Exception
     */
    public function encodeMulticall($data) {

        $packed_requests = array();

        foreach ( $data as $methodName => $params ) {

            if ( is_int($methodName) && count($params) == 2 ) {

                array_push($packed_requests, array(
                    "methodName"    =>  $params[0],
                    "params"        =>  $params[1]
                ));    

            } else {

                array_push($packed_requests, array(
                    "methodName"    =>  $methodName,
                    "params"        =>  $params
                ));

            }

        }

        return $this->encodeCall("system.multicall", array($packed_requests));

    }

    /**
     * Encode an xmlrpc error
     *
     * @param   int     $error_code
     * @param   string  $error_message
     *
     * @return  string  xmlrpc formatted error
     */
    public function encodeError($error_code, $error_message) {

        $payload  = '<?xml version="1.0" encoding="'.$this->encoding.'"?>';
        $payload .= "<methodResponse>";
        $payload .= $this->encodeFault($error_code, $error_message);
        $payload .= "</methodResponse>";

        return $payload;

    }

    /**
     * Encode an xmlrpc fault (without full xml document body)
     *
     * @param   int     $error_code
     * @param   string  $error_message
     *
     * @return  string  xmlrpc formatted error
     */
    private function encodeFault($error_code, $error_message) {

        $value = htmlentities($error_message, ENT_QUOTES, $this->encoding, false);

        $string = preg_replace_callback('/&([a-zA-Z][a-zA-Z0-9]+);/S', 'self::numericEntities', $value);

        $payload = "<fault>";
        $payload .= "<value>";
        $payload .= "<struct>";
        $payload .= "<member>";
        $payload .= "<name>faultCode</name>";
        $payload .= "<value><int>".$error_code."</int></value>";
        $payload .= "</member>";
        $payload .= "<member>";
        $payload .= "<name>faultString</name>";
        $payload .= "<value><string>".$string."</string></value>";
        $payload .= "</member>";
        $payload .= "</struct>";
        $payload .= "</value>";
        $payload .= "</fault>";

        return $payload;

    }

    /**
     * Encode a value using XMLWriter object $xml
     *
     * @param   XMLWriter    $xml
     * @param   mixed        $value
     *
     * @throws  \Comodojo\Exception\XmlrpcException
     */
    private function encodeValue(XMLWriter $xml, $value) {

        if ( $value === null ) $xml->writeRaw($this->use_ex_nil === true ? '<ex:nil />' : '<nil />');

        else if ( is_array($value) ) {

            if ( !self::catchStruct($value) ) $this->encodeArray($xml, $value);

            else $this->encodeStruct($xml, $value);

        } else if ( @array_key_exists($value, $this->special_types) ) {

            switch ( $this->special_types[$value] ) {

                case 'base64':

The case body in a switch statement must start on the line following the statement.

                    
                    $xml->writeElement("base64", $value);

                    break;
                
                case 'datetime':

The case body in a switch statement must start on the line following the statement.

                    
                    $xml->writeElement("dateTime.iso8601", self::timestampToIso8601Time($value));

                    break;
                
                case 'cdata':

The case body in a switch statement must start on the line following the statement.

                    
                    $xml->writeCData($value);

                    break;
                
            }

        } else if ( is_bool($value) ) {

            $xml->writeElement("boolean", $value ? 1 : 0);

        } else if ( is_double($value) ) {

            $xml->writeElement("double", $value);

        } else if ( is_integer($value) ) {
            
            $xml->writeElement("int", $value);

        } else if ( is_object($value) ) {

            $this->encodeObject($xml, $value);

        } else if ( is_string($value) ) {

            $value = htmlentities($value, ENT_QUOTES, $this->encoding, false);

            $string = preg_replace_callback('/&([a-zA-Z][a-zA-Z0-9]+);/S', 'self::numericEntities', $value);

            $xml->writeRaw("<string>".$string."</string>");

        } else throw new XmlrpcException("Unknown type for encoding");

    }

    /**
     * Encode an array using XMLWriter object $xml
     *
     * @param   XMLWriter    $xml
     * @param   mixed        $value
     */
    private function encodeArray(XMLWriter $xml, $value) {

        $xml->startElement("array");

            $xml->startElement("data");

                foreach ( $value as $entry ) {

                    $xml->startElement("value");

                    $this->encodeValue($xml, $entry);

                    $xml->endElement();

                }

            $xml->endElement();

        $xml->endElement();

    }

    /**
     * Encode an object using XMLWriter object $xml
     *
     * @param   XMLWriter    $xml
     * @param   mixed        $value
     *
     * @throws  \Comodojo\Exception\XmlrpcException
     */
    private function encodeObject(XMLWriter $xml, $value) {

        if ( $value instanceof \DateTime ) $xml->writeElement("dateTime.iso8601", self::timestampToIso8601Time($value->format('U')));

        else throw new XmlrpcException("Unknown type for encoding");

    }

    /**
     * Encode a struct using XMLWriter object $xml
     *
     * @param   XMLWriter    $xml
     * @param   mixed        $value
     *
     * @throws  \Comodojo\Exception\XmlrpcException
     */
    private function encodeStruct(XMLWriter $xml, $value) {

        $xml->startElement("struct");

        foreach ( $value as $k => $v ) {

            $xml->startElement("member");

                $xml->writeElement("name", $k);

                $xml->startElement("value");

                    $this->encodeValue($xml, $v);

                $xml->endElement();

            $xml->endElement();

        }

        $xml->endElement();

    }

    /**
     * Return true if $value is a struct, false otherwise
     *
     * @param   mixed   $value
     *
     * @return  bool
     */
    private static function catchStruct($value) {

        $values = count($value);

        for ( $i = 0; $i < $values; $i++ ) if ( !array_key_exists($i, $value) ) return true;

        return false;

    }

    /**
     * Convert timestamp to Iso8601
     *
     * @param   int     $timestamp
     *
     * @return  string  Iso8601 formatted date
     */
    private static function timestampToIso8601Time($timestamp) {
    
        return date("Ymd\TH:i:s", $timestamp);

    }

    /**
     * Recode named entities into numeric ones
     *
     * @param   mixed   $matches
     *
     * @return  string  Iso8601 formatted date
     */
    private static function numericEntities($matches) {

This method is not used, and could be removed.

        static $table = array(
            'quot' => '"', 'amp' => '&', 'lt' => '<', 'gt' => '>', 'OElig' => 'Œ', 'oelig' => 'œ',
            'Scaron' => 'Š', 'scaron' => 'š', 'Yuml' => 'Ÿ', 'circ' => 'ˆ', 'tilde' => '˜', 'ensp' => ' ',
            'emsp' => ' ', 'thinsp' => ' ', 'zwnj' => '‌', 'zwj' => '‍', 'lrm' => '‎', 'rlm' => '‏',
            'ndash' => '–', 'mdash' => '—', 'lsquo' => '‘', 'rsquo' => '’', 'sbquo' => '‚', 'ldquo' => '“',
            'rdquo' => '”', 'bdquo' => '„', 'dagger' => '†', 'Dagger' => '‡', 'permil' => '‰', 'lsaquo' => '‹',
            'rsaquo' => '›', 'euro' => '€', 'fnof' => 'ƒ', 'Alpha' => 'Α', 'Beta' => 'Β', 'Gamma' => 'Γ',
            'Delta' => 'Δ', 'Epsilon' => 'Ε', 'Zeta' => 'Ζ', 'Eta' => 'Η', 'Theta' => 'Θ', 'Iota' => 'Ι',
            'Kappa' => 'Κ', 'Lambda' => 'Λ', 'Mu' => 'Μ', 'Nu' => 'Ν', 'Xi' => 'Ξ', 'Omicron' => 'Ο',
            'Pi' => 'Π', 'Rho' => 'Ρ', 'Sigma' => 'Σ', 'Tau' => 'Τ', 'Upsilon' => 'Υ', 'Phi' => 'Φ',
            'Chi' => 'Χ', 'Psi' => 'Ψ', 'Omega' => 'Ω', 'alpha' => 'α', 'beta' => 'β', 'gamma' => 'γ',
            'delta' => 'δ', 'epsilon' => 'ε', 'zeta' => 'ζ', 'eta' => 'η', 'theta' => 'θ', 'iota' => 'ι',
            'kappa' => 'κ', 'lambda' => 'λ', 'mu' => 'μ', 'nu' => 'ν', 'xi' => 'ξ', 'omicron' => 'ο',
            'pi' => 'π', 'rho' => 'ρ', 'sigmaf' => 'ς', 'sigma' => 'σ', 'tau' => 'τ', 'upsilon' => 'υ',
            'phi' => 'φ', 'chi' => 'χ', 'psi' => 'ψ', 'omega' => 'ω', 'thetasym' => 'ϑ', 'upsih' => 'ϒ',
            'piv' => 'ϖ', 'bull' => '•', 'hellip' => '…', 'prime' => '′', 'Prime' => '″', 'oline' => '‾',
            'frasl' => '⁄', 'weierp' => '℘', 'image' => 'ℑ', 'real' => 'ℜ', 'trade' => '™', 'alefsym' => 'ℵ',
            'larr' => '←', 'uarr' => '↑', 'rarr' => '→', 'darr' => '↓', 'harr' => '↔', 'crarr' => '↵',
            'lArr' => '⇐', 'uArr' => '⇑', 'rArr' => '⇒', 'dArr' => '⇓', 'hArr' => '⇔', 'forall' => '∀',
            'part' => '∂', 'exist' => '∃', 'empty' => '∅', 'nabla' => '∇', 'isin' => '∈', 'notin' => '∉',
            'ni' => '∋', 'prod' => '∏', 'sum' => '∑', 'minus' => '−', 'lowast' => '∗', 'radic' => '√',
            'prop' => '∝', 'infin' => '∞', 'ang' => '∠', 'and' => '∧', 'or' => '∨', 'cap' => '∩',
            'cup' => '∪', 'int' => '∫', 'there4' => '∴', 'sim' => '∼', 'cong' => '≅', 'asymp' => '≈',
            'ne' => '≠', 'equiv' => '≡', 'le' => '≤', 'ge' => '≥', 'sub' => '⊂', 'sup' => '⊃',
            'nsub' => '⊄', 'sube' => '⊆', 'supe' => '⊇', 'oplus' => '⊕', 'otimes' => '⊗', 'perp' => '⊥',
            'sdot' => '⋅', 'lceil' => '⌈', 'rceil' => '⌉', 'lfloor' => '⌊', 'rfloor' => '⌋', 'lang' => '〈',
            'rang' => '〉', 'loz' => '◊', 'spades' => '♠', 'clubs' => '♣', 'hearts' => '♥', 'diams' => '♦',
            'nbsp' => ' ', 'iexcl' => '¡', 'cent' => '¢', 'pound' => '£', 'curren' => '¤', 'yen' => '¥',
            'brvbar' => '¦', 'sect' => '§', 'uml' => '¨', 'copy' => '©', 'ordf' => 'ª', 'laquo' => '«',
            'not' => '¬', 'shy' => '­', 'reg' => '®', 'macr' => '¯', 'deg' => '°', 'plusmn' => '±',
            'sup2' => '²', 'sup3' => '³', 'acute' => '´', 'micro' => 'µ', 'para' => '¶', 'middot' => '·',
            'cedil' => '¸', 'sup1' => '¹', 'ordm' => 'º', 'raquo' => '»', 'frac14' => '¼', 'frac12' => '½',
            'frac34' => '¾', 'iquest' => '¿', 'Agrave' => 'À', 'Aacute' => 'Á', 'Acirc' => 'Â', 'Atilde' => 'Ã',
            'Auml' => 'Ä', 'Aring' => 'Å', 'AElig' => 'Æ', 'Ccedil' => 'Ç', 'Egrave' => 'È', 'Eacute' => 'É',
            'Ecirc' => 'Ê', 'Euml' => 'Ë', 'Igrave' => 'Ì', 'Iacute' => 'Í', 'Icirc' => 'Î', 'Iuml' => 'Ï',
            'ETH' => 'Ð', 'Ntilde' => 'Ñ', 'Ograve' => 'Ò', 'Oacute' => 'Ó', 'Ocirc' => 'Ô', 'Otilde' => 'Õ',
            'Ouml' => 'Ö', 'times' => '×', 'Oslash' => 'Ø', 'Ugrave' => 'Ù', 'Uacute' => 'Ú', 'Ucirc' => 'Û',
            'Uuml' => 'Ü', 'Yacute' => 'Ý', 'THORN' => 'Þ', 'szlig' => 'ß', 'agrave' => 'à', 'aacute' => 'á',
            'acirc' => 'â', 'atilde' => 'ã', 'auml' => 'ä', 'aring' => 'å', 'aelig' => 'æ', 'ccedil' => 'ç',
            'egrave' => 'è', 'eacute' => 'é', 'ecirc' => 'ê', 'euml' => 'ë', 'igrave' => 'ì', 'iacute' => 'í',
            'icirc' => 'î', 'iuml' => 'ï', 'eth' => 'ð', 'ntilde' => 'ñ', 'ograve' => 'ò', 'oacute' => 'ó',
            'ocirc' => 'ô', 'otilde' => 'õ', 'ouml' => 'ö', 'divide' => '÷', 'oslash' => 'ø', 'ugrave' => 'ù',
            'uacute' => 'ú', 'ucirc' => 'û', 'uuml' => 'ü', 'yacute' => 'ý', 'thorn' => 'þ', 'yuml' => 'ÿ'
        );
  
        // cleanup invalid entities
        return isset($table[$matches[1]]) ? $table[$matches[1]] : '';

    }

}