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