src/Encoder.php

   1 <?php
   2
   3 namespace PhpXmlRpc;
   4
   5 use PhpXmlRpc\Helper\Logger;
   6 use PhpXmlRpc\Helper\XMLParser;
   7
   8 /**
   9  * A helper class to easily convert between Value objects and php native values
  10  * @todo implement an interface
  11  */
  12 class Encoder
  13 {
  14     /**
  15      * Takes an xmlrpc value in object format and translates it into native PHP types.
  16      *
  17      * Works with xmlrpc requests objects as input, too.
  18      *
  19      * Given proper options parameter, can rebuild generic php object instances (provided those have been encoded to
  20      * xmlrpc format using a corresponding option in php_xmlrpc_encode())
  21      * PLEASE NOTE that rebuilding php objects involves calling their constructor function.
  22      * This means that the remote communication end can decide which php code will get executed on your server, leaving
  23      * the door possibly open to 'php-injection' style of attacks (provided you have some classes defined on your server
  24      * that might wreak havoc if instances are built outside an appropriate context).
  25      * Make sure you trust the remote server/client before eanbling this!
  26      *
  27      * @author Dan Libby (dan@libby.com)
  28      *
  29      * @param Value|Request $xmlrpcVal
  30      * @param array $options if 'decode_php_objs' is set in the options array, xmlrpc structs can be decoded into php
  31      *                       objects; if 'dates_as_objects' is set xmlrpc datetimes are decoded as php DateTime objects
  32      *
  33      * @return mixed
  34      */
  35     public function decode($xmlrpcVal, $options = array())
  36     {
  37         switch ($xmlrpcVal->kindOf()) {
  38             case 'scalar':
  39                 if (in_array('extension_api', $options)) {
  40                     $val = reset($xmlrpcVal->me);
  41                     $typ = key($xmlrpcVal->me);
  42                     switch ($typ) {
  43                         case 'dateTime.iso8601':
  44                             $xmlrpcVal = array(
  45                                 'xmlrpc_type' => 'datetime',
  46                                 'scalar' => $val,
  47                                 'timestamp' => \PhpXmlRpc\Helper\Date::iso8601Decode($val)
  48                             );
  49                             return (object)$xmlrpcVal;
  50                         case 'base64':
  51                             $xmlrpcVal = array(
  52                                 'xmlrpc_type' => 'base64',
  53                                 'scalar' => $val
  54                             );
  55                             return (object)$xmlrpcVal;
  56                         default:
  57                             return $xmlrpcVal->scalarval();
  58                     }
  59                 }
  60                 if (in_array('dates_as_objects', $options) && $xmlrpcVal->scalartyp() == 'dateTime.iso8601') {
  61                     // we return a Datetime object instead of a string since now the constructor of xmlrpc value accepts
  62                     // safely strings, ints and datetimes, we cater to all 3 cases here
  63                     $out = $xmlrpcVal->scalarval();
  64                     if (is_string($out)) {
  65                         $out = strtotime($out);
  66                     }
  67                     if (is_int($out)) {
  68                         $result = new \DateTime();
  69                         $result->setTimestamp($out);
  70
  71                         return $result;
  72                     } elseif (is_a($out, 'DateTimeInterface')) {
  73                         return $out;
  74                     }
  75                 }
  76
  77                 return $xmlrpcVal->scalarval();
  78             case 'array':
  79                 $arr = array();
  80                 foreach($xmlrpcVal as $value) {
  81                     $arr[] = $this->decode($value, $options);
  82                 }
  83
  84                 return $arr;
  85             case 'struct':
  86                 // If user said so, try to rebuild php objects for specific struct vals.
  87                 /// @todo should we raise a warning for class not found?
  88                 // shall we check for proper subclass of xmlrpc value instead of presence of _php_class to detect
  89                 // what we can do?
  90                 if (in_array('decode_php_objs', $options) && $xmlrpcVal->_php_class != ''
  91                     && class_exists($xmlrpcVal->_php_class)
  92                 ) {
  93                     $obj = @new $xmlrpcVal->_php_class();
  94                     foreach ($xmlrpcVal as $key => $value) {
  95                         $obj->$key = $this->decode($value, $options);
  96                     }
  97
  98                     return $obj;
  99                 } else {
 100                     $arr = array();
 101                     foreach ($xmlrpcVal as $key => $value) {
 102                         $arr[$key] = $this->decode($value, $options);
 103                     }
 104
 105                     return $arr;
 106                 }
 107             case 'msg':
 108                 $paramCount = $xmlrpcVal->getNumParams();
 109                 $arr = array();
 110                 for ($i = 0; $i < $paramCount; $i++) {
 111                     $arr[] = $this->decode($xmlrpcVal->getParam($i), $options);
 112                 }
 113
 114                 return $arr;
 115         }
 116     }
 117
 118     /**
 119      * Takes native php types and encodes them into xmlrpc PHP object format.
 120      * It will not re-encode xmlrpc value objects.
 121      *
 122      * Feature creep -- could support more types via optional type argument
 123      * (string => datetime support has been added, ??? => base64 not yet)
 124      *
 125      * If given a proper options parameter, php object instances will be encoded into 'special' xmlrpc values, that can
 126      * later be decoded into php objects by calling php_xmlrpc_decode() with a corresponding option
 127      *
 128      * @author Dan Libby (dan@libby.com)
 129      *
 130      * @param mixed $phpVal the value to be converted into an xmlrpc value object
 131      * @param array $options can include 'encode_php_objs', 'auto_dates', 'null_extension' or 'extension_api'
 132      *
 133      * @return \PhpXmlrpc\Value
 134      */
 135     public function encode($phpVal, $options = array())
 136     {
 137         $type = gettype($phpVal);
 138         switch ($type) {
 139             case 'string':
 140                 /// @todo should we be stricter in the accepted dates (ie. reject more of invalid days & times)?
 141                 if (in_array('auto_dates', $options) && preg_match('/^[0-9]{8}T[0-9]{2}:[0-9]{2}:[0-9]{2}$/', $phpVal)) {
 142                     $xmlrpcVal = new Value($phpVal, Value::$xmlrpcDateTime);
 143                 } else {
 144                     $xmlrpcVal = new Value($phpVal, Value::$xmlrpcString);
 145                 }
 146                 break;
 147             case 'integer':
 148                 $xmlrpcVal = new Value($phpVal, Value::$xmlrpcInt);
 149                 break;
 150             case 'double':
 151                 $xmlrpcVal = new Value($phpVal, Value::$xmlrpcDouble);
 152                 break;
 153             // Add support for encoding/decoding of booleans, since they are supported in PHP
 154             case 'boolean':
 155                 $xmlrpcVal = new Value($phpVal, Value::$xmlrpcBoolean);
 156                 break;
 157             case 'array':
 158                 // PHP arrays can be encoded to either xmlrpc structs or arrays, depending on whether they are hashes
 159                 // or plain 0..n integer indexed
 160                 // A shorter one-liner would be
 161                 // $tmp = array_diff(array_keys($phpVal), range(0, count($phpVal)-1));
 162                 // but execution time skyrockets!
 163                 $j = 0;
 164                 $arr = array();
 165                 $ko = false;
 166                 foreach ($phpVal as $key => $val) {
 167                     $arr[$key] = $this->encode($val, $options);
 168                     if (!$ko && $key !== $j) {
 169                         $ko = true;
 170                     }
 171                     $j++;
 172                 }
 173                 if ($ko) {
 174                     $xmlrpcVal = new Value($arr, Value::$xmlrpcStruct);
 175                 } else {
 176                     $xmlrpcVal = new Value($arr, Value::$xmlrpcArray);
 177                 }
 178                 break;
 179             case 'object':
 180                 if (is_a($phpVal, 'PhpXmlRpc\Value')) {
 181                     $xmlrpcVal = $phpVal;
 182                 } elseif (is_a($phpVal, 'DateTimeInterface')) {
 183                     $xmlrpcVal = new Value($phpVal->format('Ymd\TH:i:s'), Value::$xmlrpcStruct);
 184                 } elseif (in_array('extension_api', $options) && $phpVal instanceof \stdClass && isset($phpVal->xmlrpc_type)) {
 185                     // Handle the 'pre-converted' base64 and datetime values
 186                     if (isset($phpVal->scalar)) {
 187                         switch ($phpVal->xmlrpc_type) {
 188                             case 'base64':
 189                                 $xmlrpcVal = new Value($phpVal->scalar, Value::$xmlrpcBase64);
 190                                 break;
 191                             case 'datetime':
 192                                 $xmlrpcVal = new Value($phpVal->scalar, Value::$xmlrpcDateTime);
 193                                 break;
 194                             default:
 195                                 $xmlrpcVal = new Value();
 196                         }
 197                     } else {
 198                         $xmlrpcVal = new Value();
 199                     }
 200
 201                 } else {
 202                     $arr = array();
 203                     foreach($phpVal as $k => $v) {
 204                         $arr[$k] = $this->encode($v, $options);
 205                     }
 206                     $xmlrpcVal = new Value($arr, Value::$xmlrpcStruct);
 207                     if (in_array('encode_php_objs', $options)) {
 208                         // let's save original class name into xmlrpc value:
 209                         // might be useful later on...
 210                         $xmlrpcVal->_php_class = get_class($phpVal);
 211                     }
 212                 }
 213                 break;
 214             case 'NULL':
 215                 if (in_array('extension_api', $options)) {
 216                     $xmlrpcVal = new Value('', Value::$xmlrpcString);
 217                 } elseif (in_array('null_extension', $options)) {
 218                     $xmlrpcVal = new Value('', Value::$xmlrpcNull);
 219                 } else {
 220                     $xmlrpcVal = new Value();
 221                 }
 222                 break;
 223             case 'resource':
 224                 if (in_array('extension_api', $options)) {
 225                     $xmlrpcVal = new Value((int)$phpVal, Value::$xmlrpcInt);
 226                 } else {
 227                     $xmlrpcVal = new Value();
 228                 }
 229                 break;
 230             // catch "user function", "unknown type"
 231             default:
 232                 // giancarlo pinerolo <ping@alt.it>
 233                 // it has to return an empty object in case, not a boolean.
 234                 $xmlrpcVal = new Value();
 235                 break;
 236         }
 237
 238         return $xmlrpcVal;
 239     }
 240
 241     /**
 242      * Convert the xml representation of a method response, method request or single
 243      * xmlrpc value into the appropriate object (a.k.a. deserialize).
 244      *
 245      * Q: is this a good name for this method? It does something quite different from 'decode' after all
 246      * (returning objects vs returns plain php values)...
 247      *
 248      * @param string $xmlVal
 249      * @param array $options
 250      *
 251      * @return mixed false on error, or an instance of either Value, Request or Response
 252      */
 253     public function decodeXml($xmlVal, $options = array())
 254     {
 255         // 'guestimate' encoding
 256         $valEncoding = XMLParser::guessEncoding('', $xmlVal);
 257         if ($valEncoding != '') {
 258
 259             // Since parsing will fail if
 260             // - charset is not specified in the xml prologue,
 261             // - the encoding is not UTF8 and
 262             // - there are non-ascii chars in the text,
 263             // we try to work round that...
 264             // The following code might be better for mb_string enabled installs, but makes the lib about 200% slower...
 265             //if (!is_valid_charset($valEncoding, array('UTF-8'))
 266             if (!in_array($valEncoding, array('UTF-8', 'US-ASCII')) && !XMLParser::hasEncoding($xmlVal)) {
 267                 if ($valEncoding == 'ISO-8859-1') {
 268                     $xmlVal = utf8_encode($xmlVal);
 269                 } else {
 270                     if (extension_loaded('mbstring')) {
 271                         $xmlVal = mb_convert_encoding($xmlVal, 'UTF-8', $valEncoding);
 272                     } else {
 273                         Logger::instance()->errorLog('XML-RPC: ' . __METHOD__ . ': invalid charset encoding of xml text: ' . $valEncoding);
 274                     }
 275                 }
 276             }
 277         }
 278
 279         // What if internal encoding is not in one of the 3 allowed? We use the broadest one, ie. utf8!
 280         if (!in_array(PhpXmlRpc::$xmlrpc_internalencoding, array('UTF-8', 'ISO-8859-1', 'US-ASCII'))) {
 281             $options = array(XML_OPTION_TARGET_ENCODING => 'UTF-8');
 282         } else {
 283             $options = array(XML_OPTION_TARGET_ENCODING => PhpXmlRpc::$xmlrpc_internalencoding);
 284         }
 285
 286         $xmlRpcParser = new XMLParser($options);
 287         $xmlRpcParser->parse($xmlVal, XMLParser::RETURN_XMLRPCVALS, XMLParser::ACCEPT_REQUEST | XMLParser::ACCEPT_RESPONSE | XMLParser::ACCEPT_VALUE | XMLParser::ACCEPT_FAULT);
 288
 289         if ($xmlRpcParser->_xh['isf'] > 1) {
 290             // test that $xmlrpc->_xh['value'] is an obj, too???
 291
 292             Logger::instance()->errorLog($xmlRpcParser->_xh['isf_reason']);
 293
 294             return false;
 295         }
 296
 297         switch ($xmlRpcParser->_xh['rt']) {
 298             case 'methodresponse':
 299                 $v = $xmlRpcParser->_xh['value'];
 300                 if ($xmlRpcParser->_xh['isf'] == 1) {
 301                     /** @var Value $vc */
 302                     $vc = $v['faultCode'];
 303                     /** @var Value $vs */
 304                     $vs = $v['faultString'];
 305                     $r = new Response(0, $vc->scalarval(), $vs->scalarval());
 306                 } else {
 307                     $r = new Response($v);
 308                 }
 309
 310                 return $r;
 311             case 'methodcall':
 312                 $req = new Request($xmlRpcParser->_xh['method']);
 313                 for ($i = 0; $i < count($xmlRpcParser->_xh['params']); $i++) {
 314                     $req->addParam($xmlRpcParser->_xh['params'][$i]);
 315                 }
 316
 317                 return $req;
 318             case 'value':
 319                 return $xmlRpcParser->_xh['value'];
 320             case 'fault':
 321                 // EPI api emulation
 322                 $v = $xmlRpcParser->_xh['value'];
 323                 // use a known error code
 324                 /** @var Value $vc */
 325                 $vc = isset($v['faultCode']) ? $v['faultCode']->scalarval() : PhpXmlRpc::$xmlrpcerr['invalid_return'];
 326                 /** @var Value $vs */
 327                 $vs = isset($v['faultString']) ? $v['faultString']->scalarval() : '';
 328                 if (!is_int($vc) || $vc == 0) {
 329                     $vc = PhpXmlRpc::$xmlrpcerr['invalid_return'];
 330                 }
 331                 return new Response(0, $vc, $vs);
 332             default:
 333                 return false;
 334         }
 335     }
 336
 337 }