2 // by Edd Dumbill (C) 1999-2002
\r
3 // <edd@usefulinc.com>
\r
5 // Copyright (c) 1999,2000,2002 Edd Dumbill.
\r
6 // All rights reserved.
\r
8 // Redistribution and use in source and binary forms, with or without
\r
9 // modification, are permitted provided that the following conditions
\r
12 // * Redistributions of source code must retain the above copyright
\r
13 // notice, this list of conditions and the following disclaimer.
\r
15 // * Redistributions in binary form must reproduce the above
\r
16 // copyright notice, this list of conditions and the following
\r
17 // disclaimer in the documentation and/or other materials provided
\r
18 // with the distribution.
\r
20 // * Neither the name of the "XML-RPC for PHP" nor the names of its
\r
21 // contributors may be used to endorse or promote products derived
\r
22 // from this software without specific prior written permission.
\r
24 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
\r
25 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
\r
26 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
\r
27 // FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
\r
28 // REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
\r
29 // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
\r
30 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
\r
31 // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
\r
32 // HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
\r
33 // STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
\r
34 // ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
\r
35 // OF THE POSSIBILITY OF SUCH DAMAGE.
\r
37 if(!function_exists('xml_parser_create'))
\r
39 // For PHP 4 onward, XML functionality is always compiled-in on windows:
\r
40 // no more need to dl-open it. It might have been compiled out on *nix...
\r
41 if(strtoupper(substr(PHP_OS, 0, 3) != 'WIN'))
\r
47 // G. Giunta 2005/01/29: declare global these variables,
\r
48 // so that xmlrpc.inc will work even if included from within a function
\r
49 // Milosch: 2005/08/07 - explicitly request these via $GLOBALS where used.
\r
50 $GLOBALS['xmlrpcI4']='i4';
\r
51 $GLOBALS['xmlrpcInt']='int';
\r
52 $GLOBALS['xmlrpcBoolean']='boolean';
\r
53 $GLOBALS['xmlrpcDouble']='double';
\r
54 $GLOBALS['xmlrpcString']='string';
\r
55 $GLOBALS['xmlrpcDateTime']='dateTime.iso8601';
\r
56 $GLOBALS['xmlrpcBase64']='base64';
\r
57 $GLOBALS['xmlrpcArray']='array';
\r
58 $GLOBALS['xmlrpcStruct']='struct';
\r
59 $GLOBALS['xmlrpcValue']='undefined';
\r
61 $GLOBALS['xmlrpcTypes']=array(
\r
62 $GLOBALS['xmlrpcI4'] => 1,
\r
63 $GLOBALS['xmlrpcInt'] => 1,
\r
64 $GLOBALS['xmlrpcBoolean'] => 1,
\r
65 $GLOBALS['xmlrpcString'] => 1,
\r
66 $GLOBALS['xmlrpcDouble'] => 1,
\r
67 $GLOBALS['xmlrpcDateTime'] => 1,
\r
68 $GLOBALS['xmlrpcBase64'] => 1,
\r
69 $GLOBALS['xmlrpcArray'] => 2,
\r
70 $GLOBALS['xmlrpcStruct'] => 3
\r
73 $GLOBALS['xmlrpc_valid_parents'] = array(
\r
74 'VALUE' => array('MEMBER', 'DATA', 'PARAM', 'FAULT'),
\r
75 'BOOLEAN' => array('VALUE'),
\r
76 'I4' => array('VALUE'),
\r
77 'INT' => array('VALUE'),
\r
78 'STRING' => array('VALUE'),
\r
79 'DOUBLE' => array('VALUE'),
\r
80 'DATETIME.ISO8601' => array('VALUE'),
\r
81 'BASE64' => array('VALUE'),
\r
82 'MEMBER' => array('STRUCT'),
\r
83 'NAME' => array('MEMBER'),
\r
84 'DATA' => array('ARRAY'),
\r
85 'ARRAY' => array('VALUE'),
\r
86 'STRUCT' => array('VALUE'),
\r
87 'PARAM' => array('PARAMS'),
\r
88 'METHODNAME' => array('METHODCALL'),
\r
89 'PARAMS' => array('METHODCALL', 'METHODRESPONSE'),
\r
90 'FAULT' => array('METHODRESPONSE'),
\r
91 'NIL' => array('VALUE'), // only used when extension activated
\r
92 'EX:NIL' => array('VALUE') // only used when extension activated
\r
95 // define extra types for supporting NULL (useful for json or <NIL/>)
\r
96 $GLOBALS['xmlrpcNull']='null';
\r
97 $GLOBALS['xmlrpcTypes']['null']=1;
\r
99 // Not in use anymore since 2.0. Shall we remove it?
\r
101 $GLOBALS['xmlEntities']=array(
\r
109 // tables used for transcoding different charsets into us-ascii xml
\r
111 $GLOBALS['xml_iso88591_Entities']=array();
\r
112 $GLOBALS['xml_iso88591_Entities']['in'] = array();
\r
113 $GLOBALS['xml_iso88591_Entities']['out'] = array();
\r
114 for ($i = 0; $i < 32; $i++)
\r
116 $GLOBALS['xml_iso88591_Entities']['in'][] = chr($i);
\r
117 $GLOBALS['xml_iso88591_Entities']['out'][] = '&#'.$i.';';
\r
119 for ($i = 160; $i < 256; $i++)
\r
121 $GLOBALS['xml_iso88591_Entities']['in'][] = chr($i);
\r
122 $GLOBALS['xml_iso88591_Entities']['out'][] = '&#'.$i.';';
\r
125 /// @todo add to iso table the characters from cp_1252 range, i.e. 128 to 159?
\r
126 /// These will NOT be present in true ISO-8859-1, but will save the unwary
\r
127 /// windows user from sending junk (though no luck when reciving them...)
\r
129 $GLOBALS['xml_cp1252_Entities']=array();
\r
130 for ($i = 128; $i < 160; $i++)
\r
132 $GLOBALS['xml_cp1252_Entities']['in'][] = chr($i);
\r
134 $GLOBALS['xml_cp1252_Entities']['out'] = array(
\r
135 '€', '?', '‚', 'ƒ',
\r
136 '„', '…', '†', '‡',
\r
137 'ˆ', '‰', 'Š', '‹',
\r
138 'Œ', '?', 'Ž', '?',
\r
139 '?', '‘', '’', '“',
\r
140 '”', '•', '–', '—',
\r
141 '˜', '™', 'š', '›',
\r
142 'œ', '?', 'ž', 'Ÿ'
\r
146 $GLOBALS['xmlrpcerr'] = array(
\r
147 'unknown_method'=>1,
\r
148 'invalid_return'=>2,
\r
149 'incorrect_params'=>3,
\r
150 'introspect_unknown'=>4,
\r
155 'invalid_request'=>15,
\r
157 'server_error'=>17,
\r
158 'multicall_error'=>18,
\r
159 'multicall_notstruct'=>9,
\r
160 'multicall_nomethod'=>10,
\r
161 'multicall_notstring'=>11,
\r
162 'multicall_recursion'=>12,
\r
163 'multicall_noparams'=>13,
\r
164 'multicall_notarray'=>14,
\r
166 'cannot_decompress'=>103,
\r
167 'decompress_fail'=>104,
\r
168 'dechunk_fail'=>105,
\r
169 'server_cannot_decompress'=>106,
\r
170 'server_decompress_fail'=>107
\r
173 $GLOBALS['xmlrpcstr'] = array(
\r
174 'unknown_method'=>'Unknown method',
\r
175 'invalid_return'=>'Invalid return payload: enable debugging to examine incoming payload',
\r
176 'incorrect_params'=>'Incorrect parameters passed to method',
\r
177 'introspect_unknown'=>"Can't introspect: method unknown",
\r
178 'http_error'=>"Didn't receive 200 OK from remote server.",
\r
179 'no_data'=>'No data received from server.',
\r
180 'no_ssl'=>'No SSL support compiled in.',
\r
181 'curl_fail'=>'CURL error',
\r
182 'invalid_request'=>'Invalid request payload',
\r
183 'no_curl'=>'No CURL support compiled in.',
\r
184 'server_error'=>'Internal server error',
\r
185 'multicall_error'=>'Received from server invalid multicall response',
\r
186 'multicall_notstruct'=>'system.multicall expected struct',
\r
187 'multicall_nomethod'=>'missing methodName',
\r
188 'multicall_notstring'=>'methodName is not a string',
\r
189 'multicall_recursion'=>'recursive system.multicall forbidden',
\r
190 'multicall_noparams'=>'missing params',
\r
191 'multicall_notarray'=>'params is not an array',
\r
193 'cannot_decompress'=>'Received from server compressed HTTP and cannot decompress',
\r
194 'decompress_fail'=>'Received from server invalid compressed HTTP',
\r
195 'dechunk_fail'=>'Received from server invalid chunked HTTP',
\r
196 'server_cannot_decompress'=>'Received from client compressed HTTP request and cannot decompress',
\r
197 'server_decompress_fail'=>'Received from client invalid compressed HTTP request'
\r
200 // The charset encoding used by the server for received messages and
\r
201 // by the client for received responses when received charset cannot be determined
\r
202 // or is not supported
\r
203 $GLOBALS['xmlrpc_defencoding']='UTF-8';
\r
205 // The encoding used internally by PHP.
\r
206 // String values received as xml will be converted to this, and php strings will be converted to xml
\r
207 // as if having been coded with this
\r
208 $GLOBALS['xmlrpc_internalencoding']='ISO-8859-1';
\r
210 $GLOBALS['xmlrpcName']='XML-RPC for PHP';
\r
211 $GLOBALS['xmlrpcVersion']='3.1.2';
\r
213 // let user errors start at 800
\r
214 $GLOBALS['xmlrpcerruser']=800;
\r
215 // let XML parse errors start at 100
\r
216 $GLOBALS['xmlrpcerrxml']=100;
\r
218 // formulate backslashes for escaping regexp
\r
219 // Not in use anymore since 2.0. Shall we remove it?
\r
221 $GLOBALS['xmlrpc_backslash']=chr(92).chr(92);
\r
223 // set to TRUE to enable correct decoding of <NIL/> and <EX:NIL/> values
\r
224 $GLOBALS['xmlrpc_null_extension']=false;
\r
226 // set to TRUE to enable encoding of php NULL values to <EX:NIL/> instead of <NIL/>
\r
227 $GLOBALS['xmlrpc_null_apache_encoding']=false;
\r
228 $GLOBALS['xmlrpc_null_apache_encoding_ns']='http://ws.apache.org/xmlrpc/namespaces/extensions';
\r
230 // used to store state during parsing
\r
231 // quick explanation of components:
\r
232 // ac - used to accumulate values
\r
233 // isf - used to indicate a parsing fault (2) or xmlrpcresp fault (1)
\r
234 // isf_reason - used for storing xmlrpcresp fault string
\r
235 // lv - used to indicate "looking for a value": implements
\r
236 // the logic to allow values with no types to be strings
\r
237 // params - used to store parameters in method calls
\r
238 // method - used to store method name
\r
239 // stack - array with genealogy of xml elements names:
\r
240 // used to validate nesting of xmlrpc elements
\r
241 $GLOBALS['_xh']=null;
\r
244 * Convert a string to the correct XML representation in a target charset
\r
245 * To help correct communication of non-ascii chars inside strings, regardless
\r
246 * of the charset used when sending requests, parsing them, sending responses
\r
247 * and parsing responses, an option is to convert all non-ascii chars present in the message
\r
248 * into their equivalent 'charset entity'. Charset entities enumerated this way
\r
249 * are independent of the charset encoding used to transmit them, and all XML
\r
250 * parsers are bound to understand them.
\r
251 * Note that in the std case we are not sending a charset encoding mime type
\r
252 * along with http headers, so we are bound by RFC 3023 to emit strict us-ascii.
\r
254 * @todo do a bit of basic benchmarking (strtr vs. str_replace)
\r
255 * @todo make usage of iconv() or recode_string() or mb_string() where available
\r
257 function xmlrpc_encode_entitites($data, $src_encoding='', $dest_encoding='')
\r
259 if ($src_encoding == '')
\r
261 // lame, but we know no better...
\r
262 $src_encoding = $GLOBALS['xmlrpc_internalencoding'];
\r
265 switch(strtoupper($src_encoding.'_'.$dest_encoding))
\r
267 case 'ISO-8859-1_':
\r
268 case 'ISO-8859-1_US-ASCII':
\r
269 $escaped_data = str_replace(array('&', '"', "'", '<', '>'), array('&', '"', ''', '<', '>'), $data);
\r
270 $escaped_data = str_replace($GLOBALS['xml_iso88591_Entities']['in'], $GLOBALS['xml_iso88591_Entities']['out'], $escaped_data);
\r
272 case 'ISO-8859-1_UTF-8':
\r
273 $escaped_data = str_replace(array('&', '"', "'", '<', '>'), array('&', '"', ''', '<', '>'), $data);
\r
274 $escaped_data = utf8_encode($escaped_data);
\r
276 case 'ISO-8859-1_ISO-8859-1':
\r
277 case 'US-ASCII_US-ASCII':
\r
278 case 'US-ASCII_UTF-8':
\r
280 case 'US-ASCII_ISO-8859-1':
\r
281 case 'UTF-8_UTF-8':
\r
282 //case 'CP1252_CP1252':
\r
283 $escaped_data = str_replace(array('&', '"', "'", '<', '>'), array('&', '"', ''', '<', '>'), $data);
\r
286 case 'UTF-8_US-ASCII':
\r
287 case 'UTF-8_ISO-8859-1':
\r
288 // NB: this will choke on invalid UTF-8, going most likely beyond EOF
\r
289 $escaped_data = '';
\r
290 // be kind to users creating string xmlrpcvals out of different php types
\r
291 $data = (string) $data;
\r
292 $ns = strlen ($data);
\r
293 for ($nn = 0; $nn < $ns; $nn++)
\r
297 //1 7 0bbbbbbb (127)
\r
300 /// @todo shall we replace this with a (supposedly) faster str_replace?
\r
303 $escaped_data .= '"';
\r
306 $escaped_data .= '&';
\r
309 $escaped_data .= ''';
\r
312 $escaped_data .= '<';
\r
315 $escaped_data .= '>';
\r
318 $escaped_data .= $ch;
\r
321 //2 11 110bbbbb 10bbbbbb (2047)
\r
322 else if ($ii>>5 == 6)
\r
325 $ii = ord($data[$nn+1]);
\r
327 $ii = ($b1 * 64) + $b2;
\r
328 $ent = sprintf ('&#%d;', $ii);
\r
329 $escaped_data .= $ent;
\r
332 //3 16 1110bbbb 10bbbbbb 10bbbbbb
\r
333 else if ($ii>>4 == 14)
\r
336 $ii = ord($data[$nn+1]);
\r
338 $ii = ord($data[$nn+2]);
\r
340 $ii = ((($b1 * 64) + $b2) * 64) + $b3;
\r
341 $ent = sprintf ('&#%d;', $ii);
\r
342 $escaped_data .= $ent;
\r
345 //4 21 11110bbb 10bbbbbb 10bbbbbb 10bbbbbb
\r
346 else if ($ii>>3 == 30)
\r
349 $ii = ord($data[$nn+1]);
\r
351 $ii = ord($data[$nn+2]);
\r
353 $ii = ord($data[$nn+3]);
\r
355 $ii = ((((($b1 * 64) + $b2) * 64) + $b3) * 64) + $b4;
\r
356 $ent = sprintf ('&#%d;', $ii);
\r
357 $escaped_data .= $ent;
\r
364 case 'CP1252_US-ASCII':
\r
365 $escaped_data = str_replace(array('&', '"', "'", '<', '>'), array('&', '"', ''', '<', '>'), $data);
\r
366 $escaped_data = str_replace($GLOBALS['xml_iso88591_Entities']['in'], $GLOBALS['xml_iso88591_Entities']['out'], $escaped_data);
\r
367 $escaped_data = str_replace($GLOBALS['xml_cp1252_Entities']['in'], $GLOBALS['xml_cp1252_Entities']['out'], $escaped_data);
\r
369 case 'CP1252_UTF-8':
\r
370 $escaped_data = str_replace(array('&', '"', "'", '<', '>'), array('&', '"', ''', '<', '>'), $data);
\r
371 /// @todo we could use real UTF8 chars here instead of xml entities... (note that utf_8 encode all allone will NOT convert them)
\r
372 $escaped_data = str_replace($GLOBALS['xml_cp1252_Entities']['in'], $GLOBALS['xml_cp1252_Entities']['out'], $escaped_data);
\r
373 $escaped_data = utf8_encode($escaped_data);
\r
375 case 'CP1252_ISO-8859-1':
\r
376 $escaped_data = str_replace(array('&', '"', "'", '<', '>'), array('&', '"', ''', '<', '>'), $data);
\r
377 // we might as well replave all funky chars with a '?' here, but we are kind and leave it to the receiving application layer to decide what to do with these weird entities...
\r
378 $escaped_data = str_replace($GLOBALS['xml_cp1252_Entities']['in'], $GLOBALS['xml_cp1252_Entities']['out'], $escaped_data);
\r
382 $escaped_data = '';
\r
383 error_log("Converting from $src_encoding to $dest_encoding: not supported...");
\r
385 return $escaped_data;
\r
388 /// xml parser handler function for opening element tags
\r
389 function xmlrpc_se($parser, $name, $attrs, $accept_single_vals=false)
\r
391 // if invalid xmlrpc already detected, skip all processing
\r
392 if ($GLOBALS['_xh']['isf'] < 2)
\r
394 // check for correct element nesting
\r
395 // top level element can only be of 2 types
\r
396 /// @todo optimization creep: save this check into a bool variable, instead of using count() every time:
\r
397 /// there is only a single top level element in xml anyway
\r
398 if (count($GLOBALS['_xh']['stack']) == 0)
\r
400 if ($name != 'METHODRESPONSE' && $name != 'METHODCALL' && (
\r
401 $name != 'VALUE' && !$accept_single_vals))
\r
403 $GLOBALS['_xh']['isf'] = 2;
\r
404 $GLOBALS['_xh']['isf_reason'] = 'missing top level xmlrpc element';
\r
409 $GLOBALS['_xh']['rt'] = strtolower($name);
\r
410 $GLOBALS['_xh']['rt'] = strtolower($name);
\r
415 // not top level element: see if parent is OK
\r
416 $parent = end($GLOBALS['_xh']['stack']);
\r
417 if (!array_key_exists($name, $GLOBALS['xmlrpc_valid_parents']) || !in_array($parent, $GLOBALS['xmlrpc_valid_parents'][$name]))
\r
419 $GLOBALS['_xh']['isf'] = 2;
\r
420 $GLOBALS['_xh']['isf_reason'] = "xmlrpc element $name cannot be child of $parent";
\r
427 // optimize for speed switch cases: most common cases first
\r
429 /// @todo we could check for 2 VALUE elements inside a MEMBER or PARAM element
\r
430 $GLOBALS['_xh']['vt']='value'; // indicator: no value found yet
\r
431 $GLOBALS['_xh']['ac']='';
\r
432 $GLOBALS['_xh']['lv']=1;
\r
433 $GLOBALS['_xh']['php_class']=null;
\r
440 case 'DATETIME.ISO8601':
\r
442 if ($GLOBALS['_xh']['vt']!='value')
\r
444 //two data elements inside a value: an error occurred!
\r
445 $GLOBALS['_xh']['isf'] = 2;
\r
446 $GLOBALS['_xh']['isf_reason'] = "$name element following a {$GLOBALS['_xh']['vt']} element inside a single value";
\r
449 $GLOBALS['_xh']['ac']=''; // reset the accumulator
\r
453 if ($GLOBALS['_xh']['vt']!='value')
\r
455 //two data elements inside a value: an error occurred!
\r
456 $GLOBALS['_xh']['isf'] = 2;
\r
457 $GLOBALS['_xh']['isf_reason'] = "$name element following a {$GLOBALS['_xh']['vt']} element inside a single value";
\r
460 // create an empty array to hold child values, and push it onto appropriate stack
\r
461 $cur_val = array();
\r
462 $cur_val['values'] = array();
\r
463 $cur_val['type'] = $name;
\r
464 // check for out-of-band information to rebuild php objs
\r
465 // and in case it is found, save it
\r
466 if (@isset($attrs['PHP_CLASS']))
\r
468 $cur_val['php_class'] = $attrs['PHP_CLASS'];
\r
470 $GLOBALS['_xh']['valuestack'][] = $cur_val;
\r
471 $GLOBALS['_xh']['vt']='data'; // be prepared for a data element next
\r
474 if ($GLOBALS['_xh']['vt']!='data')
\r
476 //two data elements inside a value: an error occurred!
\r
477 $GLOBALS['_xh']['isf'] = 2;
\r
478 $GLOBALS['_xh']['isf_reason'] = "found two data elements inside an array element";
\r
482 case 'METHODRESPONSE':
\r
484 // valid elements that add little to processing
\r
488 /// @todo we could check for 2 NAME elements inside a MEMBER element
\r
489 $GLOBALS['_xh']['ac']='';
\r
492 $GLOBALS['_xh']['isf']=1;
\r
495 $GLOBALS['_xh']['valuestack'][count($GLOBALS['_xh']['valuestack'])-1]['name']=''; // set member name to null, in case we do not find in the xml later on
\r
496 //$GLOBALS['_xh']['ac']='';
\r
497 // Drop trough intentionally
\r
499 // clear value type, so we can check later if no value has been passed for this param/member
\r
500 $GLOBALS['_xh']['vt']=null;
\r
504 if ($GLOBALS['xmlrpc_null_extension'])
\r
506 if ($GLOBALS['_xh']['vt']!='value')
\r
508 //two data elements inside a value: an error occurred!
\r
509 $GLOBALS['_xh']['isf'] = 2;
\r
510 $GLOBALS['_xh']['isf_reason'] = "$name element following a {$GLOBALS['_xh']['vt']} element inside a single value";
\r
513 $GLOBALS['_xh']['ac']=''; // reset the accumulator
\r
516 // we do not support the <NIL/> extension, so
\r
517 // drop through intentionally
\r
519 /// INVALID ELEMENT: RAISE ISF so that it is later recognized!!!
\r
520 $GLOBALS['_xh']['isf'] = 2;
\r
521 $GLOBALS['_xh']['isf_reason'] = "found not-xmlrpc xml element $name";
\r
525 // Save current element name to stack, to validate nesting
\r
526 $GLOBALS['_xh']['stack'][] = $name;
\r
528 /// @todo optimization creep: move this inside the big switch() above
\r
531 $GLOBALS['_xh']['lv']=0;
\r
536 /// Used in decoding xml chunks that might represent single xmlrpc values
\r
537 function xmlrpc_se_any($parser, $name, $attrs)
\r
539 xmlrpc_se($parser, $name, $attrs, true);
\r
542 /// xml parser handler function for close element tags
\r
543 function xmlrpc_ee($parser, $name, $rebuild_xmlrpcvals = true)
\r
545 if ($GLOBALS['_xh']['isf'] < 2)
\r
547 // push this element name from stack
\r
548 // NB: if XML validates, correct opening/closing is guaranteed and
\r
549 // we do not have to check for $name == $curr_elem.
\r
550 // we also checked for proper nesting at start of elements...
\r
551 $curr_elem = array_pop($GLOBALS['_xh']['stack']);
\r
556 // This if() detects if no scalar was inside <VALUE></VALUE>
\r
557 if ($GLOBALS['_xh']['vt']=='value')
\r
559 $GLOBALS['_xh']['value']=$GLOBALS['_xh']['ac'];
\r
560 $GLOBALS['_xh']['vt']=$GLOBALS['xmlrpcString'];
\r
563 if ($rebuild_xmlrpcvals)
\r
565 // build the xmlrpc val out of the data received, and substitute it
\r
566 $temp = new xmlrpcval($GLOBALS['_xh']['value'], $GLOBALS['_xh']['vt']);
\r
567 // in case we got info about underlying php class, save it
\r
568 // in the object we're rebuilding
\r
569 if (isset($GLOBALS['_xh']['php_class']))
\r
570 $temp->_php_class = $GLOBALS['_xh']['php_class'];
\r
571 // check if we are inside an array or struct:
\r
572 // if value just built is inside an array, let's move it into array on the stack
\r
573 $vscount = count($GLOBALS['_xh']['valuestack']);
\r
574 if ($vscount && $GLOBALS['_xh']['valuestack'][$vscount-1]['type']=='ARRAY')
\r
576 $GLOBALS['_xh']['valuestack'][$vscount-1]['values'][] = $temp;
\r
580 $GLOBALS['_xh']['value'] = $temp;
\r
585 /// @todo this needs to treat correctly php-serialized objects,
\r
586 /// since std deserializing is done by php_xmlrpc_decode,
\r
587 /// which we will not be calling...
\r
588 if (isset($GLOBALS['_xh']['php_class']))
\r
592 // check if we are inside an array or struct:
\r
593 // if value just built is inside an array, let's move it into array on the stack
\r
594 $vscount = count($GLOBALS['_xh']['valuestack']);
\r
595 if ($vscount && $GLOBALS['_xh']['valuestack'][$vscount-1]['type']=='ARRAY')
\r
597 $GLOBALS['_xh']['valuestack'][$vscount-1]['values'][] = $GLOBALS['_xh']['value'];
\r
606 case 'DATETIME.ISO8601':
\r
608 $GLOBALS['_xh']['vt']=strtolower($name);
\r
609 /// @todo: optimization creep - remove the if/elseif cycle below
\r
610 /// since the case() in which we are already did that
\r
611 if ($name=='STRING')
\r
613 $GLOBALS['_xh']['value']=$GLOBALS['_xh']['ac'];
\r
615 elseif ($name=='DATETIME.ISO8601')
\r
617 if (!preg_match('/^[0-9]{8}T[0-9]{2}:[0-9]{2}:[0-9]{2}$/', $GLOBALS['_xh']['ac']))
\r
619 error_log('XML-RPC: invalid value received in DATETIME: '.$GLOBALS['_xh']['ac']);
\r
621 $GLOBALS['_xh']['vt']=$GLOBALS['xmlrpcDateTime'];
\r
622 $GLOBALS['_xh']['value']=$GLOBALS['_xh']['ac'];
\r
624 elseif ($name=='BASE64')
\r
626 /// @todo check for failure of base64 decoding / catch warnings
\r
627 $GLOBALS['_xh']['value']=base64_decode($GLOBALS['_xh']['ac']);
\r
629 elseif ($name=='BOOLEAN')
\r
631 // special case here: we translate boolean 1 or 0 into PHP
\r
632 // constants true or false.
\r
633 // Strings 'true' and 'false' are accepted, even though the
\r
634 // spec never mentions them (see eg. Blogger api docs)
\r
635 // NB: this simple checks helps a lot sanitizing input, ie no
\r
636 // security problems around here
\r
637 if ($GLOBALS['_xh']['ac']=='1' || strcasecmp($GLOBALS['_xh']['ac'], 'true') == 0)
\r
639 $GLOBALS['_xh']['value']=true;
\r
643 // log if receiveing something strange, even though we set the value to false anyway
\r
644 if ($GLOBALS['_xh']['ac']!='0' && strcasecmp($GLOBALS['_xh']['ac'], 'false') != 0)
\r
645 error_log('XML-RPC: invalid value received in BOOLEAN: '.$GLOBALS['_xh']['ac']);
\r
646 $GLOBALS['_xh']['value']=false;
\r
649 elseif ($name=='DOUBLE')
\r
651 // we have a DOUBLE
\r
652 // we must check that only 0123456789-.<space> are characters here
\r
653 // NOTE: regexp could be much stricter than this...
\r
654 if (!preg_match('/^[+-eE0123456789 \t.]+$/', $GLOBALS['_xh']['ac']))
\r
656 /// @todo: find a better way of throwing an error than this!
\r
657 error_log('XML-RPC: non numeric value received in DOUBLE: '.$GLOBALS['_xh']['ac']);
\r
658 $GLOBALS['_xh']['value']='ERROR_NON_NUMERIC_FOUND';
\r
662 // it's ok, add it on
\r
663 $GLOBALS['_xh']['value']=(double)$GLOBALS['_xh']['ac'];
\r
668 // we have an I4/INT
\r
669 // we must check that only 0123456789-<space> are characters here
\r
670 if (!preg_match('/^[+-]?[0123456789 \t]+$/', $GLOBALS['_xh']['ac']))
\r
672 /// @todo find a better way of throwing an error than this!
\r
673 error_log('XML-RPC: non numeric value received in INT: '.$GLOBALS['_xh']['ac']);
\r
674 $GLOBALS['_xh']['value']='ERROR_NON_NUMERIC_FOUND';
\r
678 // it's ok, add it on
\r
679 $GLOBALS['_xh']['value']=(int)$GLOBALS['_xh']['ac'];
\r
682 //$GLOBALS['_xh']['ac']=''; // is this necessary?
\r
683 $GLOBALS['_xh']['lv']=3; // indicate we've found a value
\r
686 $GLOBALS['_xh']['valuestack'][count($GLOBALS['_xh']['valuestack'])-1]['name'] = $GLOBALS['_xh']['ac'];
\r
689 //$GLOBALS['_xh']['ac']=''; // is this necessary?
\r
690 // add to array in the stack the last element built,
\r
691 // unless no VALUE was found
\r
692 if ($GLOBALS['_xh']['vt'])
\r
694 $vscount = count($GLOBALS['_xh']['valuestack']);
\r
695 $GLOBALS['_xh']['valuestack'][$vscount-1]['values'][$GLOBALS['_xh']['valuestack'][$vscount-1]['name']] = $GLOBALS['_xh']['value'];
\r
697 error_log('XML-RPC: missing VALUE inside STRUCT in received xml');
\r
700 //$GLOBALS['_xh']['ac']=''; // is this necessary?
\r
701 $GLOBALS['_xh']['vt']=null; // reset this to check for 2 data elements in a row - even if they're empty
\r
705 // fetch out of stack array of values, and promote it to current value
\r
706 $curr_val = array_pop($GLOBALS['_xh']['valuestack']);
\r
707 $GLOBALS['_xh']['value'] = $curr_val['values'];
\r
708 $GLOBALS['_xh']['vt']=strtolower($name);
\r
709 if (isset($curr_val['php_class']))
\r
711 $GLOBALS['_xh']['php_class'] = $curr_val['php_class'];
\r
715 // add to array of params the current value,
\r
716 // unless no VALUE was found
\r
717 if ($GLOBALS['_xh']['vt'])
\r
719 $GLOBALS['_xh']['params'][]=$GLOBALS['_xh']['value'];
\r
720 $GLOBALS['_xh']['pt'][]=$GLOBALS['_xh']['vt'];
\r
723 error_log('XML-RPC: missing VALUE inside PARAM in received xml');
\r
726 $GLOBALS['_xh']['method']=preg_replace('/^[\n\r\t ]+/', '', $GLOBALS['_xh']['ac']);
\r
730 if ($GLOBALS['xmlrpc_null_extension'])
\r
732 $GLOBALS['_xh']['vt']='null';
\r
733 $GLOBALS['_xh']['value']=null;
\r
734 $GLOBALS['_xh']['lv']=3;
\r
737 // drop through intentionally if nil extension not enabled
\r
741 case 'METHORESPONSE':
\r
744 // End of INVALID ELEMENT!
\r
745 // shall we add an assert here for unreachable code???
\r
751 /// Used in decoding xmlrpc requests/responses without rebuilding xmlrpc values
\r
752 function xmlrpc_ee_fast($parser, $name)
\r
754 xmlrpc_ee($parser, $name, false);
\r
757 /// xml parser handler function for character data
\r
758 function xmlrpc_cd($parser, $data)
\r
760 // skip processing if xml fault already detected
\r
761 if ($GLOBALS['_xh']['isf'] < 2)
\r
763 // "lookforvalue==3" means that we've found an entire value
\r
764 // and should discard any further character data
\r
765 if($GLOBALS['_xh']['lv']!=3)
\r
767 // G. Giunta 2006-08-23: useless change of 'lv' from 1 to 2
\r
768 //if($GLOBALS['_xh']['lv']==1)
\r
770 // if we've found text and we're just in a <value> then
\r
771 // say we've found a value
\r
772 //$GLOBALS['_xh']['lv']=2;
\r
774 // we always initialize the accumulator before starting parsing, anyway...
\r
775 //if(!@isset($GLOBALS['_xh']['ac']))
\r
777 // $GLOBALS['_xh']['ac'] = '';
\r
779 $GLOBALS['_xh']['ac'].=$data;
\r
784 /// xml parser handler function for 'other stuff', ie. not char data or
\r
785 /// element start/end tag. In fact it only gets called on unknown entities...
\r
786 function xmlrpc_dh($parser, $data)
\r
788 // skip processing if xml fault already detected
\r
789 if ($GLOBALS['_xh']['isf'] < 2)
\r
791 if(substr($data, 0, 1) == '&' && substr($data, -1, 1) == ';')
\r
793 // G. Giunta 2006-08-25: useless change of 'lv' from 1 to 2
\r
794 //if($GLOBALS['_xh']['lv']==1)
\r
796 // $GLOBALS['_xh']['lv']=2;
\r
798 $GLOBALS['_xh']['ac'].=$data;
\r
804 class xmlrpc_client
\r
809 var $method='http';
\r
822 var $verifypeer=true;
\r
824 var $sslversion=0; // corresponds to CURL_SSLVERSION_DEFAULT
\r
825 var $no_multicall=false;
\r
828 var $proxy_user='';
\r
829 var $proxy_pass='';
\r
830 var $proxy_authtype=1;
\r
831 var $cookies=array();
\r
832 var $extracurlopts=array();
\r
835 * List of http compression methods accepted by the client for responses.
\r
836 * NB: PHP supports deflate, gzip compressions out of the box if compiled w. zlib
\r
838 * NNB: you can set it to any non-empty array for HTTP11 and HTTPS, since
\r
839 * in those cases it will be up to CURL to decide the compression methods
\r
840 * it supports. You might check for the presence of 'zlib' in the output of
\r
841 * curl_version() to determine wheter compression is supported or not
\r
843 var $accepted_compression = array();
\r
845 * Name of compression scheme to be used for sending requests.
\r
846 * Either null, gzip or deflate
\r
848 var $request_compression = '';
\r
850 * CURL handle: used for keep-alive connections (PHP 4.3.8 up, see:
\r
851 * http://curl.haxx.se/docs/faq.html#7.3)
\r
853 var $xmlrpc_curl_handle = null;
\r
854 /// Whether to use persistent connections for http 1.1 and https
\r
855 var $keepalive = false;
\r
856 /// Charset encodings that can be decoded without problems by the client
\r
857 var $accepted_charset_encodings = array();
\r
858 /// Charset encoding to be used in serializing request. NULL = use ASCII
\r
859 var $request_charset_encoding = '';
\r
861 * Decides the content of xmlrpcresp objects returned by calls to send()
\r
862 * valid strings are 'xmlrpcvals', 'phpvals' or 'xml'
\r
864 var $return_type = 'xmlrpcvals';
\r
866 * Sent to servers in http headers
\r
871 * @param string $path either the complete server URL or the PATH part of the xmlrc server URL, e.g. /xmlrpc/server.php
\r
872 * @param string $server the server name / ip address
\r
873 * @param integer $port the port the server is listening on, defaults to 80 or 443 depending on protocol used
\r
874 * @param string $method the http protocol variant: defaults to 'http', 'https' and 'http11' can be used if CURL is installed
\r
876 function __construct($path, $server='', $port='', $method='')
\r
878 // allow user to specify all params in $path
\r
879 if($server == '' and $port == '' and $method == '')
\r
881 $parts = parse_url($path);
\r
882 $server = $parts['host'];
\r
883 $path = isset($parts['path']) ? $parts['path'] : '';
\r
884 if(isset($parts['query']))
\r
886 $path .= '?'.$parts['query'];
\r
888 if(isset($parts['fragment']))
\r
890 $path .= '#'.$parts['fragment'];
\r
892 if(isset($parts['port']))
\r
894 $port = $parts['port'];
\r
896 if(isset($parts['scheme']))
\r
898 $method = $parts['scheme'];
\r
900 if(isset($parts['user']))
\r
902 $this->username = $parts['user'];
\r
904 if(isset($parts['pass']))
\r
906 $this->password = $parts['pass'];
\r
909 if($path == '' || $path[0] != '/')
\r
911 $this->path='/'.$path;
\r
917 $this->server=$server;
\r
924 $this->method=$method;
\r
927 // if ZLIB is enabled, let the client by default accept compressed responses
\r
928 if(function_exists('gzinflate') || (
\r
929 function_exists('curl_init') && (($info = curl_version()) &&
\r
930 ((is_string($info) && strpos($info, 'zlib') !== null) || isset($info['libz_version'])))
\r
933 $this->accepted_compression = array('gzip', 'deflate');
\r
936 // keepalives: enabled by default
\r
937 $this->keepalive = true;
\r
939 // by default the xml parser can support these 3 charset encodings
\r
940 $this->accepted_charset_encodings = array('UTF-8', 'ISO-8859-1', 'US-ASCII');
\r
942 // initialize user_agent string
\r
943 $this->user_agent = $GLOBALS['xmlrpcName'] . ' ' . $GLOBALS['xmlrpcVersion'];
\r
949 function xmlrpc_client($path, $server='', $port='', $method='')
\r
951 self::__construct($path, $server, $port, $method);
\r
955 * Enables/disables the echoing to screen of the xmlrpc responses received
\r
956 * @param integer $in values 0, 1 and 2 are supported (2 = echo sent msg too, before received response)
\r
959 function setDebug($in)
\r
965 * Add some http BASIC AUTH credentials, used by the client to authenticate
\r
966 * @param string $u username
\r
967 * @param string $p password
\r
968 * @param integer $t auth type. See curl_setopt man page for supported auth types. Defaults to CURLAUTH_BASIC (basic auth)
\r
971 function setCredentials($u, $p, $t=1)
\r
973 $this->username=$u;
\r
974 $this->password=$p;
\r
975 $this->authtype=$t;
\r
979 * Add a client-side https certificate
\r
980 * @param string $cert
\r
981 * @param string $certpass
\r
984 function setCertificate($cert, $certpass)
\r
986 $this->cert = $cert;
\r
987 $this->certpass = $certpass;
\r
991 * Add a CA certificate to verify server with (see man page about
\r
992 * CURLOPT_CAINFO for more details)
\r
993 * @param string $cacert certificate file name (or dir holding certificates)
\r
994 * @param bool $is_dir set to true to indicate cacert is a dir. defaults to false
\r
997 function setCaCertificate($cacert, $is_dir=false)
\r
1001 $this->cacertdir = $cacert;
\r
1005 $this->cacert = $cacert;
\r
1010 * Set attributes for SSL communication: private SSL key
\r
1011 * NB: does not work in older php/curl installs
\r
1012 * Thanks to Daniel Convissor
\r
1013 * @param string $key The name of a file containing a private SSL key
\r
1014 * @param string $keypass The secret password needed to use the private SSL key
\r
1017 function setKey($key, $keypass)
\r
1019 $this->key = $key;
\r
1020 $this->keypass = $keypass;
\r
1024 * Set attributes for SSL communication: verify server certificate
\r
1025 * @param bool $i enable/disable verification of peer certificate
\r
1028 function setSSLVerifyPeer($i)
\r
1030 $this->verifypeer = $i;
\r
1034 * Set attributes for SSL communication: verify match of server cert w. hostname
\r
1038 function setSSLVerifyHost($i)
\r
1040 $this->verifyhost = $i;
\r
1044 * Set attributes for SSL communication: SSL version to use. Best left at 0 (default value ): let cURL decide
\r
1048 public function setSSLVersion($i)
\r
1050 $this->sslversion = $i;
\r
1055 * @param string $proxyhost
\r
1056 * @param string $proxyport Defaults to 8080 for HTTP and 443 for HTTPS
\r
1057 * @param string $proxyusername Leave blank if proxy has public access
\r
1058 * @param string $proxypassword Leave blank if proxy has public access
\r
1059 * @param int $proxyauthtype set to constant CURLAUTH_NTLM to use NTLM auth with proxy
\r
1062 function setProxy($proxyhost, $proxyport, $proxyusername = '', $proxypassword = '', $proxyauthtype = 1)
\r
1064 $this->proxy = $proxyhost;
\r
1065 $this->proxyport = $proxyport;
\r
1066 $this->proxy_user = $proxyusername;
\r
1067 $this->proxy_pass = $proxypassword;
\r
1068 $this->proxy_authtype = $proxyauthtype;
\r
1072 * Enables/disables reception of compressed xmlrpc responses.
\r
1073 * Note that enabling reception of compressed responses merely adds some standard
\r
1074 * http headers to xmlrpc requests. It is up to the xmlrpc server to return
\r
1075 * compressed responses when receiving such requests.
\r
1076 * @param string $compmethod either 'gzip', 'deflate', 'any' or ''
\r
1079 function setAcceptedCompression($compmethod)
\r
1081 if ($compmethod == 'any')
\r
1082 $this->accepted_compression = array('gzip', 'deflate');
\r
1084 if ($compmethod == false )
\r
1085 $this->accepted_compression = array();
\r
1087 $this->accepted_compression = array($compmethod);
\r
1091 * Enables/disables http compression of xmlrpc request.
\r
1092 * Take care when sending compressed requests: servers might not support them
\r
1093 * (and automatic fallback to uncompressed requests is not yet implemented)
\r
1094 * @param string $compmethod either 'gzip', 'deflate' or ''
\r
1097 function setRequestCompression($compmethod)
\r
1099 $this->request_compression = $compmethod;
\r
1103 * Adds a cookie to list of cookies that will be sent to server.
\r
1104 * NB: setting any param but name and value will turn the cookie into a 'version 1' cookie:
\r
1105 * do not do it unless you know what you are doing
\r
1106 * @param string $name
\r
1107 * @param string $value
\r
1108 * @param string $path
\r
1109 * @param string $domain
\r
1110 * @param int $port
\r
1113 * @todo check correctness of urlencoding cookie value (copied from php way of doing it...)
\r
1115 function setCookie($name, $value='', $path='', $domain='', $port=null)
\r
1117 $this->cookies[$name]['value'] = urlencode($value);
\r
1118 if ($path || $domain || $port)
\r
1120 $this->cookies[$name]['path'] = $path;
\r
1121 $this->cookies[$name]['domain'] = $domain;
\r
1122 $this->cookies[$name]['port'] = $port;
\r
1123 $this->cookies[$name]['version'] = 1;
\r
1127 $this->cookies[$name]['version'] = 0;
\r
1132 * Directly set cURL options, for extra flexibility
\r
1133 * It allows eg. to bind client to a specific IP interface / address
\r
1134 * @param array $options
\r
1136 function SetCurlOptions( $options )
\r
1138 $this->extracurlopts = $options;
\r
1142 * Set user-agent string that will be used by this client instance
\r
1143 * in http headers sent to the server
\r
1145 function SetUserAgent( $agentstring )
\r
1147 $this->user_agent = $agentstring;
\r
1151 * Send an xmlrpc request
\r
1152 * @param mixed $msg The message object, or an array of messages for using multicall, or the complete xml representation of a request
\r
1153 * @param integer $timeout Connection timeout, in seconds, If unspecified, a platform specific timeout will apply
\r
1154 * @param string $method if left unspecified, the http protocol chosen during creation of the object will be used
\r
1155 * @return xmlrpcresp
\r
1158 function& send($msg, $timeout=0, $method='')
\r
1160 // if user deos not specify http protocol, use native method of this client
\r
1161 // (i.e. method set during call to constructor)
\r
1164 $method = $this->method;
\r
1167 if(is_array($msg))
\r
1169 // $msg is an array of xmlrpcmsg's
\r
1170 $r = $this->multicall($msg, $timeout, $method);
\r
1173 elseif(is_string($msg))
\r
1175 $n = new xmlrpcmsg('');
\r
1176 $n->payload = $msg;
\r
1180 // where msg is an xmlrpcmsg
\r
1181 $msg->debug=$this->debug;
\r
1183 if($method == 'https')
\r
1185 $r =& $this->sendPayloadHTTPS(
\r
1199 $this->proxy_user,
\r
1200 $this->proxy_pass,
\r
1201 $this->proxy_authtype,
\r
1208 elseif($method == 'http11')
\r
1210 $r =& $this->sendPayloadCURL(
\r
1224 $this->proxy_user,
\r
1225 $this->proxy_pass,
\r
1226 $this->proxy_authtype,
\r
1233 $r =& $this->sendPayloadHTTP10(
\r
1243 $this->proxy_user,
\r
1244 $this->proxy_pass,
\r
1245 $this->proxy_authtype
\r
1255 function &sendPayloadHTTP10($msg, $server, $port, $timeout=0,
\r
1256 $username='', $password='', $authtype=1, $proxyhost='',
\r
1257 $proxyport=0, $proxyusername='', $proxypassword='', $proxyauthtype=1)
\r
1264 // Only create the payload if it was not created previously
\r
1265 if(empty($msg->payload))
\r
1267 $msg->createPayload($this->request_charset_encoding);
\r
1270 $payload = $msg->payload;
\r
1271 // Deflate request body and set appropriate request headers
\r
1272 if(function_exists('gzdeflate') && ($this->request_compression == 'gzip' || $this->request_compression == 'deflate'))
\r
1274 if($this->request_compression == 'gzip')
\r
1276 $a = @gzencode($payload);
\r
1280 $encoding_hdr = "Content-Encoding: gzip\r\n";
\r
1285 $a = @gzcompress($payload);
\r
1289 $encoding_hdr = "Content-Encoding: deflate\r\n";
\r
1295 $encoding_hdr = '';
\r
1298 // thanks to Grant Rauscher <grant7@firstworld.net> for this
\r
1302 $credentials='Authorization: Basic ' . base64_encode($username . ':' . $password) . "\r\n";
\r
1303 if ($authtype != 1)
\r
1305 error_log('XML-RPC: '.__METHOD__.': warning. Only Basic auth is supported with HTTP 1.0');
\r
1309 $accepted_encoding = '';
\r
1310 if(is_array($this->accepted_compression) && count($this->accepted_compression))
\r
1312 $accepted_encoding = 'Accept-Encoding: ' . implode(', ', $this->accepted_compression) . "\r\n";
\r
1315 $proxy_credentials = '';
\r
1318 if($proxyport == 0)
\r
1320 $proxyport = 8080;
\r
1322 $connectserver = $proxyhost;
\r
1323 $connectport = $proxyport;
\r
1324 $uri = 'http://'.$server.':'.$port.$this->path;
\r
1325 if($proxyusername != '')
\r
1327 if ($proxyauthtype != 1)
\r
1329 error_log('XML-RPC: '.__METHOD__.': warning. Only Basic auth to proxy is supported with HTTP 1.0');
\r
1331 $proxy_credentials = 'Proxy-Authorization: Basic ' . base64_encode($proxyusername.':'.$proxypassword) . "\r\n";
\r
1336 $connectserver = $server;
\r
1337 $connectport = $port;
\r
1338 $uri = $this->path;
\r
1341 // Cookie generation, as per rfc2965 (version 1 cookies) or
\r
1342 // netscape's rules (version 0 cookies)
\r
1344 if (count($this->cookies))
\r
1347 foreach ($this->cookies as $name => $cookie)
\r
1349 if ($cookie['version'])
\r
1351 $version = ' $Version="' . $cookie['version'] . '";';
\r
1352 $cookieheader .= ' ' . $name . '="' . $cookie['value'] . '";';
\r
1353 if ($cookie['path'])
\r
1354 $cookieheader .= ' $Path="' . $cookie['path'] . '";';
\r
1355 if ($cookie['domain'])
\r
1356 $cookieheader .= ' $Domain="' . $cookie['domain'] . '";';
\r
1357 if ($cookie['port'])
\r
1358 $cookieheader .= ' $Port="' . $cookie['port'] . '";';
\r
1362 $cookieheader .= ' ' . $name . '=' . $cookie['value'] . ";";
\r
1365 $cookieheader = 'Cookie:' . $version . substr($cookieheader, 0, -1) . "\r\n";
\r
1368 // omit port if 80
\r
1369 $port = ($port == 80) ? '' : (':' . $port);
\r
1371 $op= 'POST ' . $uri. " HTTP/1.0\r\n" .
\r
1372 'User-Agent: ' . $this->user_agent . "\r\n" .
\r
1373 'Host: '. $server . $port . "\r\n" .
\r
1375 $proxy_credentials .
\r
1376 $accepted_encoding .
\r
1378 'Accept-Charset: ' . implode(',', $this->accepted_charset_encodings) . "\r\n" .
\r
1380 'Content-Type: ' . $msg->content_type . "\r\nContent-Length: " .
\r
1381 strlen($payload) . "\r\n\r\n" .
\r
1384 if($this->debug > 1)
\r
1386 print "<PRE>\n---SENDING---\n" . htmlentities($op) . "\n---END---\n</PRE>";
\r
1387 // let the client see this now in case http times out...
\r
1393 $fp=@fsockopen($connectserver, $connectport, $this->errno, $this->errstr, $timeout);
\r
1397 $fp=@fsockopen($connectserver, $connectport, $this->errno, $this->errstr);
\r
1401 if($timeout>0 && function_exists('stream_set_timeout'))
\r
1403 stream_set_timeout($fp, $timeout);
\r
1408 $this->errstr='Connect error: '.$this->errstr;
\r
1409 $r=new xmlrpcresp(0, $GLOBALS['xmlrpcerr']['http_error'], $this->errstr . ' (' . $this->errno . ')');
\r
1413 if(!fputs($fp, $op, strlen($op)))
\r
1416 $this->errstr='Write error';
\r
1417 $r=new xmlrpcresp(0, $GLOBALS['xmlrpcerr']['http_error'], $this->errstr);
\r
1422 // reset errno and errstr on successful socket connection
\r
1423 $this->errstr = '';
\r
1425 // G. Giunta 2005/10/24: close socket before parsing.
\r
1426 // should yield slightly better execution times, and make easier recursive calls (e.g. to follow http redirects)
\r
1430 // shall we check for $data === FALSE?
\r
1431 // as per the manual, it signals an error
\r
1432 $ipd.=fread($fp, 32768);
\r
1433 } while(!feof($fp));
\r
1435 $r =& $msg->parseResponse($ipd, false, $this->return_type);
\r
1443 function &sendPayloadHTTPS($msg, $server, $port, $timeout=0, $username='',
\r
1444 $password='', $authtype=1, $cert='',$certpass='', $cacert='', $cacertdir='',
\r
1445 $proxyhost='', $proxyport=0, $proxyusername='', $proxypassword='', $proxyauthtype=1,
\r
1446 $keepalive=false, $key='', $keypass='', $sslVersion = 0)
\r
1448 $r =& $this->sendPayloadCURL($msg, $server, $port, $timeout, $username,
\r
1449 $password, $authtype, $cert, $certpass, $cacert, $cacertdir, $proxyhost, $proxyport,
\r
1450 $proxyusername, $proxypassword, $proxyauthtype, 'https', $keepalive, $key, $keypass, $sslVersion);
\r
1455 * Contributed by Justin Miller <justin@voxel.net>
\r
1456 * Requires curl to be built into PHP
\r
1457 * NB: CURL versions before 7.11.10 cannot use proxy to talk to https servers!
\r
1460 function &sendPayloadCURL($msg, $server, $port, $timeout=0, $username='',
\r
1461 $password='', $authtype=1, $cert='', $certpass='', $cacert='', $cacertdir='',
\r
1462 $proxyhost='', $proxyport=0, $proxyusername='', $proxypassword='', $proxyauthtype=1, $method='https',
\r
1463 $keepalive=false, $key='', $keypass='', $sslVersion = 0)
\r
1465 if(!function_exists('curl_init'))
\r
1467 $this->errstr='CURL unavailable on this install';
\r
1468 $r=new xmlrpcresp(0, $GLOBALS['xmlrpcerr']['no_curl'], $GLOBALS['xmlrpcstr']['no_curl']);
\r
1471 if($method == 'https')
\r
1473 if(($info = curl_version()) &&
\r
1474 ((is_string($info) && strpos($info, 'OpenSSL') === null) || (is_array($info) && !isset($info['ssl_version']))))
\r
1476 $this->errstr='SSL unavailable on this install';
\r
1477 $r=new xmlrpcresp(0, $GLOBALS['xmlrpcerr']['no_ssl'], $GLOBALS['xmlrpcstr']['no_ssl']);
\r
1484 if($method == 'http')
\r
1494 // Only create the payload if it was not created previously
\r
1495 if(empty($msg->payload))
\r
1497 $msg->createPayload($this->request_charset_encoding);
\r
1500 // Deflate request body and set appropriate request headers
\r
1501 $payload = $msg->payload;
\r
1502 if(function_exists('gzdeflate') && ($this->request_compression == 'gzip' || $this->request_compression == 'deflate'))
\r
1504 if($this->request_compression == 'gzip')
\r
1506 $a = @gzencode($payload);
\r
1510 $encoding_hdr = 'Content-Encoding: gzip';
\r
1515 $a = @gzcompress($payload);
\r
1519 $encoding_hdr = 'Content-Encoding: deflate';
\r
1525 $encoding_hdr = '';
\r
1528 if($this->debug > 1)
\r
1530 print "<PRE>\n---SENDING---\n" . htmlentities($payload) . "\n---END---\n</PRE>";
\r
1531 // let the client see this now in case http times out...
\r
1535 if(!$keepalive || !$this->xmlrpc_curl_handle)
\r
1537 $curl = curl_init($method . '://' . $server . ':' . $port . $this->path);
\r
1540 $this->xmlrpc_curl_handle = $curl;
\r
1545 $curl = $this->xmlrpc_curl_handle;
\r
1548 // results into variable
\r
1549 curl_setopt($curl, CURLOPT_RETURNTRANSFER, 1);
\r
1553 curl_setopt($curl, CURLOPT_VERBOSE, 1);
\r
1555 curl_setopt($curl, CURLOPT_USERAGENT, $this->user_agent);
\r
1556 // required for XMLRPC: post the data
\r
1557 curl_setopt($curl, CURLOPT_POST, 1);
\r
1559 curl_setopt($curl, CURLOPT_POSTFIELDS, $payload);
\r
1561 // return the header too
\r
1562 curl_setopt($curl, CURLOPT_HEADER, 1);
\r
1564 // NB: if we set an empty string, CURL will add http header indicating
\r
1565 // ALL methods it is supporting. This is possibly a better option than
\r
1566 // letting the user tell what curl can / cannot do...
\r
1567 if(is_array($this->accepted_compression) && count($this->accepted_compression))
\r
1569 //curl_setopt($curl, CURLOPT_ENCODING, implode(',', $this->accepted_compression));
\r
1570 // empty string means 'any supported by CURL' (shall we catch errors in case CURLOPT_SSLKEY undefined ?)
\r
1571 if (count($this->accepted_compression) == 1)
\r
1573 curl_setopt($curl, CURLOPT_ENCODING, $this->accepted_compression[0]);
\r
1576 curl_setopt($curl, CURLOPT_ENCODING, '');
\r
1579 $headers = array('Content-Type: ' . $msg->content_type , 'Accept-Charset: ' . implode(',', $this->accepted_charset_encodings));
\r
1580 // if no keepalive is wanted, let the server know it in advance
\r
1583 $headers[] = 'Connection: close';
\r
1585 // request compression header
\r
1588 $headers[] = $encoding_hdr;
\r
1591 curl_setopt($curl, CURLOPT_HTTPHEADER, $headers);
\r
1592 // timeout is borked
\r
1595 curl_setopt($curl, CURLOPT_TIMEOUT, $timeout == 1 ? 1 : $timeout - 1);
\r
1598 if($username && $password)
\r
1600 curl_setopt($curl, CURLOPT_USERPWD, $username.':'.$password);
\r
1601 if (defined('CURLOPT_HTTPAUTH'))
\r
1603 curl_setopt($curl, CURLOPT_HTTPAUTH, $authtype);
\r
1605 else if ($authtype != 1)
\r
1607 error_log('XML-RPC: '.__METHOD__.': warning. Only Basic auth is supported by the current PHP/curl install');
\r
1611 if($method == 'https')
\r
1616 curl_setopt($curl, CURLOPT_SSLCERT, $cert);
\r
1618 // set cert password
\r
1621 curl_setopt($curl, CURLOPT_SSLCERTPASSWD, $certpass);
\r
1623 // whether to verify remote host's cert
\r
1624 curl_setopt($curl, CURLOPT_SSL_VERIFYPEER, $this->verifypeer);
\r
1625 // set ca certificates file/dir
\r
1628 curl_setopt($curl, CURLOPT_CAINFO, $cacert);
\r
1632 curl_setopt($curl, CURLOPT_CAPATH, $cacertdir);
\r
1634 // set key file (shall we catch errors in case CURLOPT_SSLKEY undefined ?)
\r
1637 curl_setopt($curl, CURLOPT_SSLKEY, $key);
\r
1639 // set key password (shall we catch errors in case CURLOPT_SSLKEY undefined ?)
\r
1642 curl_setopt($curl, CURLOPT_SSLKEYPASSWD, $keypass);
\r
1645 // Upgrade transparently to more stringent check for versions of php which do not support otherwise.
\r
1646 // Doing it in constructor would be cleaner; doing it here saves us a couple of function calls
\r
1647 if($this->verifyhost == 1 && $info = curl_version() && version_compare($info['version'], '7.28.1') >= 0)
\r
1649 $this->verifyhost = 2;
\r
1651 // whether to verify cert's common name (CN); 0 for no, 1 to verify that it exists, and 2 to verify that it matches the hostname used
\r
1652 curl_setopt($curl, CURLOPT_SSL_VERIFYHOST, $this->verifyhost);
\r
1653 // allow usage of different SSL versions
\r
1654 curl_setopt($curl, CURLOPT_SSLVERSION, $sslVersion);
\r
1660 if($proxyport == 0)
\r
1662 $proxyport = 8080; // NB: even for HTTPS, local connection is on port 8080
\r
1664 curl_setopt($curl, CURLOPT_PROXY, $proxyhost.':'.$proxyport);
\r
1665 //curl_setopt($curl, CURLOPT_PROXYPORT,$proxyport);
\r
1666 if($proxyusername)
\r
1668 curl_setopt($curl, CURLOPT_PROXYUSERPWD, $proxyusername.':'.$proxypassword);
\r
1669 if (defined('CURLOPT_PROXYAUTH'))
\r
1671 curl_setopt($curl, CURLOPT_PROXYAUTH, $proxyauthtype);
\r
1673 else if ($proxyauthtype != 1)
\r
1675 error_log('XML-RPC: '.__METHOD__.': warning. Only Basic auth to proxy is supported by the current PHP/curl install');
\r
1680 // NB: should we build cookie http headers by hand rather than let CURL do it?
\r
1681 // the following code does not honour 'expires', 'path' and 'domain' cookie attributes
\r
1682 // set to client obj the the user...
\r
1683 if (count($this->cookies))
\r
1685 $cookieheader = '';
\r
1686 foreach ($this->cookies as $name => $cookie)
\r
1688 $cookieheader .= $name . '=' . $cookie['value'] . '; ';
\r
1690 curl_setopt($curl, CURLOPT_COOKIE, substr($cookieheader, 0, -2));
\r
1693 foreach ($this->extracurlopts as $opt => $val)
\r
1695 curl_setopt($curl, $opt, $val);
\r
1698 $result = curl_exec($curl);
\r
1700 if ($this->debug > 1)
\r
1702 print "<PRE>\n---CURL INFO---\n";
\r
1703 foreach(curl_getinfo($curl) as $name => $val)
\r
1705 if (is_array($val))
\r
1707 $val = implode("\n", $val);
\r
1709 print $name . ': ' . htmlentities($val) . "\n";
\r
1712 print "---END---\n</PRE>";
\r
1715 if(!$result) /// @todo we should use a better check here - what if we get back '' or '0'?
\r
1717 $this->errstr='no response';
\r
1718 $resp=new xmlrpcresp(0, $GLOBALS['xmlrpcerr']['curl_fail'], $GLOBALS['xmlrpcstr']['curl_fail']. ': '. curl_error($curl));
\r
1719 curl_close($curl);
\r
1722 $this->xmlrpc_curl_handle = null;
\r
1729 curl_close($curl);
\r
1731 $resp =& $msg->parseResponse($result, true, $this->return_type);
\r
1732 // if we got back a 302, we can not reuse the curl handle for later calls
\r
1733 if($resp->faultCode() == $GLOBALS['xmlrpcerr']['http_error'] && $keepalive)
\r
1735 curl_close($curl);
\r
1736 $this->xmlrpc_curl_handle = null;
\r
1743 * Send an array of request messages and return an array of responses.
\r
1744 * Unless $this->no_multicall has been set to true, it will try first
\r
1745 * to use one single xmlrpc call to server method system.multicall, and
\r
1746 * revert to sending many successive calls in case of failure.
\r
1747 * This failure is also stored in $this->no_multicall for subsequent calls.
\r
1748 * Unfortunately, there is no server error code universally used to denote
\r
1749 * the fact that multicall is unsupported, so there is no way to reliably
\r
1750 * distinguish between that and a temporary failure.
\r
1751 * If you are sure that server supports multicall and do not want to
\r
1752 * fallback to using many single calls, set the fourth parameter to FALSE.
\r
1754 * NB: trying to shoehorn extra functionality into existing syntax has resulted
\r
1755 * in pretty much convoluted code...
\r
1757 * @param array $msgs an array of xmlrpcmsg objects
\r
1758 * @param integer $timeout connection timeout (in seconds)
\r
1759 * @param string $method the http protocol variant to be used
\r
1760 * @param boolean fallback When true, upon receiving an error during multicall, multiple single calls will be attempted
\r
1764 function multicall($msgs, $timeout=0, $method='', $fallback=true)
\r
1766 if ($method == '')
\r
1768 $method = $this->method;
\r
1770 if(!$this->no_multicall)
\r
1772 $results = $this->_try_multicall($msgs, $timeout, $method);
\r
1773 if(is_array($results))
\r
1775 // System.multicall succeeded
\r
1780 // either system.multicall is unsupported by server,
\r
1781 // or call failed for some other reason.
\r
1784 // Don't try it next time...
\r
1785 $this->no_multicall = true;
\r
1789 if (is_a($results, 'xmlrpcresp'))
\r
1791 $result = $results;
\r
1795 $result = new xmlrpcresp(0, $GLOBALS['xmlrpcerr']['multicall_error'], $GLOBALS['xmlrpcstr']['multicall_error']);
\r
1802 // override fallback, in case careless user tries to do two
\r
1803 // opposite things at the same time
\r
1807 $results = array();
\r
1810 // system.multicall is (probably) unsupported by server:
\r
1811 // emulate multicall via multiple requests
\r
1812 foreach($msgs as $msg)
\r
1814 $results[] =& $this->send($msg, $timeout, $method);
\r
1819 // user does NOT want to fallback on many single calls:
\r
1820 // since we should always return an array of responses,
\r
1821 // return an array with the same error repeated n times
\r
1822 foreach($msgs as $msg)
\r
1824 $results[] = $result;
\r
1831 * Attempt to boxcar $msgs via system.multicall.
\r
1832 * Returns either an array of xmlrpcreponses, an xmlrpc error response
\r
1833 * or false (when received response does not respect valid multicall syntax)
\r
1836 function _try_multicall($msgs, $timeout, $method)
\r
1838 // Construct multicall message
\r
1840 foreach($msgs as $msg)
\r
1842 $call['methodName'] = new xmlrpcval($msg->method(),'string');
\r
1843 $numParams = $msg->getNumParams();
\r
1844 $params = array();
\r
1845 for($i = 0; $i < $numParams; $i++)
\r
1847 $params[$i] = $msg->getParam($i);
\r
1849 $call['params'] = new xmlrpcval($params, 'array');
\r
1850 $calls[] = new xmlrpcval($call, 'struct');
\r
1852 $multicall = new xmlrpcmsg('system.multicall');
\r
1853 $multicall->addParam(new xmlrpcval($calls, 'array'));
\r
1855 // Attempt RPC call
\r
1856 $result =& $this->send($multicall, $timeout, $method);
\r
1858 if($result->faultCode() != 0)
\r
1860 // call to system.multicall failed
\r
1864 // Unpack responses.
\r
1865 $rets = $result->value();
\r
1867 if ($this->return_type == 'xml')
\r
1871 else if ($this->return_type == 'phpvals')
\r
1873 ///@todo test this code branch...
\r
1874 $rets = $result->value();
\r
1875 if(!is_array($rets))
\r
1877 return false; // bad return type from system.multicall
\r
1879 $numRets = count($rets);
\r
1880 if($numRets != count($msgs))
\r
1882 return false; // wrong number of return values.
\r
1885 $response = array();
\r
1886 for($i = 0; $i < $numRets; $i++)
\r
1889 if (!is_array($val)) {
\r
1892 switch(count($val))
\r
1895 if(!isset($val[0]))
\r
1897 return false; // Bad value
\r
1899 // Normal return value
\r
1900 $response[$i] = new xmlrpcresp($val[0], 0, '', 'phpvals');
\r
1903 /// @todo remove usage of @: it is apparently quite slow
\r
1904 $code = @$val['faultCode'];
\r
1905 if(!is_int($code))
\r
1909 $str = @$val['faultString'];
\r
1910 if(!is_string($str))
\r
1914 $response[$i] = new xmlrpcresp(0, $code, $str);
\r
1922 else // return type == 'xmlrpcvals'
\r
1924 $rets = $result->value();
\r
1925 if($rets->kindOf() != 'array')
\r
1927 return false; // bad return type from system.multicall
\r
1929 $numRets = $rets->arraysize();
\r
1930 if($numRets != count($msgs))
\r
1932 return false; // wrong number of return values.
\r
1935 $response = array();
\r
1936 for($i = 0; $i < $numRets; $i++)
\r
1938 $val = $rets->arraymem($i);
\r
1939 switch($val->kindOf())
\r
1942 if($val->arraysize() != 1)
\r
1944 return false; // Bad value
\r
1946 // Normal return value
\r
1947 $response[$i] = new xmlrpcresp($val->arraymem(0));
\r
1950 $code = $val->structmem('faultCode');
\r
1951 if($code->kindOf() != 'scalar' || $code->scalartyp() != 'int')
\r
1955 $str = $val->structmem('faultString');
\r
1956 if($str->kindOf() != 'scalar' || $str->scalartyp() != 'string')
\r
1960 $response[$i] = new xmlrpcresp(0, $code->scalarval(), $str->scalarval());
\r
1969 } // end class xmlrpc_client
\r
1978 var $hdrs = array();
\r
1979 var $_cookies = array();
\r
1980 var $content_type = 'text/xml';
\r
1981 var $raw_data = '';
\r
1984 * @param mixed $val either an xmlrpcval obj, a php value or the xml serialization of an xmlrpcval (a string)
\r
1985 * @param integer $fcode set it to anything but 0 to create an error response
\r
1986 * @param string $fstr the error string, in case of an error response
\r
1987 * @param string $valtyp either 'xmlrpcvals', 'phpvals' or 'xml'
\r
1989 * @todo add check that $val / $fcode / $fstr is of correct type???
\r
1990 * NB: as of now we do not do it, since it might be either an xmlrpcval or a plain
\r
1991 * php val, or a complete xml chunk, depending on usage of xmlrpc_client::send() inside which creator is called...
\r
1993 function __construct($val, $fcode = 0, $fstr = '', $valtyp='')
\r
1998 $this->errno = $fcode;
\r
1999 $this->errstr = $fstr;
\r
2000 //$this->errstr = htmlspecialchars($fstr); // XXX: encoding probably shouldn't be done here; fix later.
\r
2004 // successful response
\r
2005 $this->val = $val;
\r
2006 if ($valtyp == '')
\r
2008 // user did not declare type of response value: try to guess it
\r
2009 if (is_object($this->val) && is_a($this->val, 'xmlrpcval'))
\r
2011 $this->valtyp = 'xmlrpcvals';
\r
2013 else if (is_string($this->val))
\r
2015 $this->valtyp = 'xml';
\r
2020 $this->valtyp = 'phpvals';
\r
2025 // user declares type of resp value: believe him
\r
2026 $this->valtyp = $valtyp;
\r
2034 function xmlrpcresp($val, $fcode = 0, $fstr = '', $valtyp='')
\r
2036 self::__construct($val, $fcode, $fstr, $valtyp);
\r
2040 * Returns the error code of the response.
\r
2041 * @return integer the error code of this response (0 for not-error responses)
\r
2044 function faultCode()
\r
2046 return $this->errno;
\r
2050 * Returns the error code of the response.
\r
2051 * @return string the error string of this response ('' for not-error responses)
\r
2054 function faultString()
\r
2056 return $this->errstr;
\r
2060 * Returns the value received by the server.
\r
2061 * @return mixed the xmlrpcval object returned by the server. Might be an xml string or php value if the response has been created by specially configured xmlrpc_client objects
\r
2066 return $this->val;
\r
2070 * Returns an array with the cookies received from the server.
\r
2071 * Array has the form: $cookiename => array ('value' => $val, $attr1 => $val1, $attr2 = $val2, ...)
\r
2072 * with attributes being e.g. 'expires', 'path', domain'.
\r
2073 * NB: cookies sent as 'expired' by the server (i.e. with an expiry date in the past)
\r
2074 * are still present in the array. It is up to the user-defined code to decide
\r
2075 * how to use the received cookies, and whether they have to be sent back with the next
\r
2076 * request to the server (using xmlrpc_client::setCookie) or not
\r
2077 * @return array array of cookies received from the server
\r
2080 function cookies()
\r
2082 return $this->_cookies;
\r
2086 * Returns xml representation of the response. XML prologue not included
\r
2087 * @param string $charset_encoding the charset to be used for serialization. if null, US-ASCII is assumed
\r
2088 * @return string the xml representation of the response
\r
2091 function serialize($charset_encoding='')
\r
2093 if ($charset_encoding != '')
\r
2094 $this->content_type = 'text/xml; charset=' . $charset_encoding;
\r
2096 $this->content_type = 'text/xml';
\r
2097 if ($GLOBALS['xmlrpc_null_apache_encoding'])
\r
2099 $result = "<methodResponse xmlns:ex=\"".$GLOBALS['xmlrpc_null_apache_encoding_ns']."\">\n";
\r
2103 $result = "<methodResponse>\n";
\r
2107 // G. Giunta 2005/2/13: let non-ASCII response messages be tolerated by clients
\r
2108 // by xml-encoding non ascii chars
\r
2109 $result .= "<fault>\n" .
\r
2110 "<value>\n<struct><member><name>faultCode</name>\n<value><int>" . $this->errno .
\r
2111 "</int></value>\n</member>\n<member>\n<name>faultString</name>\n<value><string>" .
\r
2112 xmlrpc_encode_entitites($this->errstr, $GLOBALS['xmlrpc_internalencoding'], $charset_encoding) . "</string></value>\n</member>\n" .
\r
2113 "</struct>\n</value>\n</fault>";
\r
2117 if(!is_object($this->val) || !is_a($this->val, 'xmlrpcval'))
\r
2119 if (is_string($this->val) && $this->valtyp == 'xml')
\r
2121 $result .= "<params>\n<param>\n" .
\r
2123 "</param>\n</params>";
\r
2127 /// @todo try to build something serializable?
\r
2128 die('cannot serialize xmlrpcresp objects whose content is native php values');
\r
2133 $result .= "<params>\n<param>\n" .
\r
2134 $this->val->serialize($charset_encoding) .
\r
2135 "</param>\n</params>";
\r
2138 $result .= "\n</methodResponse>";
\r
2139 $this->payload = $result;
\r
2148 var $params=array();
\r
2150 var $content_type = 'text/xml';
\r
2153 * @param string $meth the name of the method to invoke
\r
2154 * @param array $pars array of parameters to be passed to the method (xmlrpcval objects)
\r
2156 function __construct($meth, $pars=0)
\r
2158 $this->methodname=$meth;
\r
2159 if(is_array($pars) && count($pars)>0)
\r
2161 for($i=0; $i<count($pars); $i++)
\r
2163 $this->addParam($pars[$i]);
\r
2171 function xmlrpcmsg($meth, $pars=0)
\r
2173 self::__construct($meth, $pars);
\r
2179 function xml_header($charset_encoding='')
\r
2181 if ($charset_encoding != '')
\r
2183 return "<?xml version=\"1.0\" encoding=\"$charset_encoding\" ?" . ">\n<methodCall>\n";
\r
2187 return "<?xml version=\"1.0\"?" . ">\n<methodCall>\n";
\r
2194 function xml_footer()
\r
2196 return '</methodCall>';
\r
2210 function createPayload($charset_encoding='')
\r
2212 if ($charset_encoding != '')
\r
2213 $this->content_type = 'text/xml; charset=' . $charset_encoding;
\r
2215 $this->content_type = 'text/xml';
\r
2216 $this->payload=$this->xml_header($charset_encoding);
\r
2217 $this->payload.='<methodName>' . xmlrpc_encode_entitites($this->methodname, $GLOBALS['xmlrpc_internalencoding'], $charset_encoding) . "</methodName>\n";
\r
2218 $this->payload.="<params>\n";
\r
2219 for($i=0; $i<count($this->params); $i++)
\r
2221 $p=$this->params[$i];
\r
2222 $this->payload.="<param>\n" . $p->serialize($charset_encoding) .
\r
2225 $this->payload.="</params>\n";
\r
2226 $this->payload.=$this->xml_footer();
\r
2230 * Gets/sets the xmlrpc method to be invoked
\r
2231 * @param string $meth the method to be set (leave empty not to set it)
\r
2232 * @return string the method that will be invoked
\r
2235 function method($meth='')
\r
2239 $this->methodname=$meth;
\r
2241 return $this->methodname;
\r
2245 * Returns xml representation of the message. XML prologue included
\r
2246 * @param string $charset_encoding
\r
2247 * @return string the xml representation of the message, xml prologue included
\r
2250 function serialize($charset_encoding='')
\r
2252 $this->createPayload($charset_encoding);
\r
2253 return $this->payload;
\r
2257 * Add a parameter to the list of parameters to be used upon method invocation
\r
2258 * @param xmlrpcval $par
\r
2259 * @return boolean false on failure
\r
2262 function addParam($par)
\r
2264 // add check: do not add to self params which are not xmlrpcvals
\r
2265 if(is_object($par) && is_a($par, 'xmlrpcval'))
\r
2267 $this->params[]=$par;
\r
2277 * Returns the nth parameter in the message. The index zero-based.
\r
2278 * @param integer $i the index of the parameter to fetch (zero based)
\r
2279 * @return xmlrpcval the i-th parameter
\r
2282 function getParam($i) { return $this->params[$i]; }
\r
2285 * Returns the number of parameters in the messge.
\r
2286 * @return integer the number of parameters currently set
\r
2289 function getNumParams() { return count($this->params); }
\r
2292 * Given an open file handle, read all data available and parse it as axmlrpc response.
\r
2293 * NB: the file handle is not closed by this function.
\r
2294 * NNB: might have trouble in rare cases to work on network streams, as we
\r
2295 * check for a read of 0 bytes instead of feof($fp).
\r
2296 * But since checking for feof(null) returns false, we would risk an
\r
2297 * infinite loop in that case, because we cannot trust the caller
\r
2298 * to give us a valid pointer to an open file...
\r
2300 * @param resource $fp stream pointer
\r
2301 * @return xmlrpcresp
\r
2302 * @todo add 2nd & 3rd param to be passed to ParseResponse() ???
\r
2304 function &parseResponseFile($fp)
\r
2307 while($data=fread($fp, 32768))
\r
2312 $r =& $this->parseResponse($ipd);
\r
2317 * Parses HTTP headers and separates them from data.
\r
2320 function &parseResponseHeaders(&$data, $headers_processed=false)
\r
2322 // Support "web-proxy-tunelling" connections for https through proxies
\r
2323 if(preg_match('/^HTTP\/1\.[0-1] 200 Connection established/', $data))
\r
2325 // Look for CR/LF or simple LF as line separator,
\r
2326 // (even though it is not valid http)
\r
2327 $pos = strpos($data,"\r\n\r\n");
\r
2328 if($pos || is_int($pos))
\r
2334 $pos = strpos($data,"\n\n");
\r
2335 if($pos || is_int($pos))
\r
2341 // No separation between response headers and body: fault?
\r
2347 // this filters out all http headers from proxy.
\r
2348 // maybe we could take them into account, too?
\r
2349 $data = substr($data, $bd);
\r
2353 error_log('XML-RPC: '.__METHOD__.': HTTPS via proxy error, tunnel connection possibly failed');
\r
2354 $r=new xmlrpcresp(0, $GLOBALS['xmlrpcerr']['http_error'], $GLOBALS['xmlrpcstr']['http_error']. ' (HTTPS via proxy error, tunnel connection possibly failed)');
\r
2359 // Strip HTTP 1.1 100 Continue header if present
\r
2360 while(preg_match('/^HTTP\/1\.1 1[0-9]{2} /', $data))
\r
2362 $pos = strpos($data, 'HTTP', 12);
\r
2363 // server sent a Continue header without any (valid) content following...
\r
2364 // give the client a chance to know it
\r
2365 if(!$pos && !is_int($pos)) // works fine in php 3, 4 and 5
\r
2369 $data = substr($data, $pos);
\r
2371 if(!preg_match('/^HTTP\/[0-9.]+ 200 /', $data))
\r
2373 $errstr= substr($data, 0, strpos($data, "\n")-1);
\r
2374 error_log('XML-RPC: '.__METHOD__.': HTTP error, got response: ' .$errstr);
\r
2375 $r=new xmlrpcresp(0, $GLOBALS['xmlrpcerr']['http_error'], $GLOBALS['xmlrpcstr']['http_error']. ' (' . $errstr . ')');
\r
2379 $GLOBALS['_xh']['headers'] = array();
\r
2380 $GLOBALS['_xh']['cookies'] = array();
\r
2382 // be tolerant to usage of \n instead of \r\n to separate headers and data
\r
2383 // (even though it is not valid http)
\r
2384 $pos = strpos($data,"\r\n\r\n");
\r
2385 if($pos || is_int($pos))
\r
2391 $pos = strpos($data,"\n\n");
\r
2392 if($pos || is_int($pos))
\r
2398 // No separation between response headers and body: fault?
\r
2399 // we could take some action here instead of going on...
\r
2403 // be tolerant to line endings, and extra empty lines
\r
2404 $ar = preg_split("/\r?\n/", trim(substr($data, 0, $pos)));
\r
2405 foreach($ar as $line)
\r
2407 // take care of multi-line headers and cookies
\r
2408 $arr = explode(':',$line,2);
\r
2409 if(count($arr) > 1)
\r
2411 $header_name = strtolower(trim($arr[0]));
\r
2412 /// @todo some other headers (the ones that allow a CSV list of values)
\r
2413 /// do allow many values to be passed using multiple header lines.
\r
2414 /// We should add content to $GLOBALS['_xh']['headers'][$header_name]
\r
2415 /// instead of replacing it for those...
\r
2416 if ($header_name == 'set-cookie' || $header_name == 'set-cookie2')
\r
2418 if ($header_name == 'set-cookie2')
\r
2420 // version 2 cookies:
\r
2421 // there could be many cookies on one line, comma separated
\r
2422 $cookies = explode(',', $arr[1]);
\r
2426 $cookies = array($arr[1]);
\r
2428 foreach ($cookies as $cookie)
\r
2430 // glue together all received cookies, using a comma to separate them
\r
2431 // (same as php does with getallheaders())
\r
2432 if (isset($GLOBALS['_xh']['headers'][$header_name]))
\r
2433 $GLOBALS['_xh']['headers'][$header_name] .= ', ' . trim($cookie);
\r
2435 $GLOBALS['_xh']['headers'][$header_name] = trim($cookie);
\r
2436 // parse cookie attributes, in case user wants to correctly honour them
\r
2437 // feature creep: only allow rfc-compliant cookie attributes?
\r
2438 // @todo support for server sending multiple time cookie with same name, but using different PATHs
\r
2439 $cookie = explode(';', $cookie);
\r
2440 foreach ($cookie as $pos => $val)
\r
2442 $val = explode('=', $val, 2);
\r
2443 $tag = trim($val[0]);
\r
2444 $val = trim(@$val[1]);
\r
2445 /// @todo with version 1 cookies, we should strip leading and trailing " chars
\r
2448 $cookiename = $tag;
\r
2449 $GLOBALS['_xh']['cookies'][$tag] = array();
\r
2450 $GLOBALS['_xh']['cookies'][$cookiename]['value'] = urldecode($val);
\r
2454 if ($tag != 'value')
\r
2456 $GLOBALS['_xh']['cookies'][$cookiename][$tag] = $val;
\r
2464 $GLOBALS['_xh']['headers'][$header_name] = trim($arr[1]);
\r
2467 elseif(isset($header_name))
\r
2469 /// @todo version1 cookies might span multiple lines, thus breaking the parsing above
\r
2470 $GLOBALS['_xh']['headers'][$header_name] .= ' ' . trim($line);
\r
2474 $data = substr($data, $bd);
\r
2476 if($this->debug && count($GLOBALS['_xh']['headers']))
\r
2479 foreach($GLOBALS['_xh']['headers'] as $header => $value)
\r
2481 print htmlentities("HEADER: $header: $value\n");
\r
2483 foreach($GLOBALS['_xh']['cookies'] as $header => $value)
\r
2485 print htmlentities("COOKIE: $header={$value['value']}\n");
\r
2490 // if CURL was used for the call, http headers have been processed,
\r
2491 // and dechunking + reinflating have been carried out
\r
2492 if(!$headers_processed)
\r
2494 // Decode chunked encoding sent by http 1.1 servers
\r
2495 if(isset($GLOBALS['_xh']['headers']['transfer-encoding']) && $GLOBALS['_xh']['headers']['transfer-encoding'] == 'chunked')
\r
2497 if(!$data = decode_chunked($data))
\r
2499 error_log('XML-RPC: '.__METHOD__.': errors occurred when trying to rebuild the chunked data received from server');
\r
2500 $r = new xmlrpcresp(0, $GLOBALS['xmlrpcerr']['dechunk_fail'], $GLOBALS['xmlrpcstr']['dechunk_fail']);
\r
2505 // Decode gzip-compressed stuff
\r
2506 // code shamelessly inspired from nusoap library by Dietrich Ayala
\r
2507 if(isset($GLOBALS['_xh']['headers']['content-encoding']))
\r
2509 $GLOBALS['_xh']['headers']['content-encoding'] = str_replace('x-', '', $GLOBALS['_xh']['headers']['content-encoding']);
\r
2510 if($GLOBALS['_xh']['headers']['content-encoding'] == 'deflate' || $GLOBALS['_xh']['headers']['content-encoding'] == 'gzip')
\r
2512 // if decoding works, use it. else assume data wasn't gzencoded
\r
2513 if(function_exists('gzinflate'))
\r
2515 if($GLOBALS['_xh']['headers']['content-encoding'] == 'deflate' && $degzdata = @gzuncompress($data))
\r
2517 $data = $degzdata;
\r
2519 print "<PRE>---INFLATED RESPONSE---[".strlen($data)." chars]---\n" . htmlentities($data) . "\n---END---</PRE>";
\r
2521 elseif($GLOBALS['_xh']['headers']['content-encoding'] == 'gzip' && $degzdata = @gzinflate(substr($data, 10)))
\r
2523 $data = $degzdata;
\r
2525 print "<PRE>---INFLATED RESPONSE---[".strlen($data)." chars]---\n" . htmlentities($data) . "\n---END---</PRE>";
\r
2529 error_log('XML-RPC: '.__METHOD__.': errors occurred when trying to decode the deflated data received from server');
\r
2530 $r = new xmlrpcresp(0, $GLOBALS['xmlrpcerr']['decompress_fail'], $GLOBALS['xmlrpcstr']['decompress_fail']);
\r
2536 error_log('XML-RPC: '.__METHOD__.': the server sent deflated data. Your php install must have the Zlib extension compiled in to support this.');
\r
2537 $r = new xmlrpcresp(0, $GLOBALS['xmlrpcerr']['cannot_decompress'], $GLOBALS['xmlrpcstr']['cannot_decompress']);
\r
2542 } // end of 'if needed, de-chunk, re-inflate response'
\r
2544 // real stupid hack to avoid PHP complaining about returning NULL by ref
\r
2551 * Parse the xmlrpc response contained in the string $data and return an xmlrpcresp object.
\r
2552 * @param string $data the xmlrpc response, eventually including http headers
\r
2553 * @param bool $headers_processed when true prevents parsing HTTP headers for interpretation of content-encoding and consequent decoding
\r
2554 * @param string $return_type decides return type, i.e. content of response->value(). Either 'xmlrpcvals', 'xml' or 'phpvals'
\r
2555 * @return xmlrpcresp
\r
2558 function &parseResponse($data='', $headers_processed=false, $return_type='xmlrpcvals')
\r
2562 //by maHo, replaced htmlspecialchars with htmlentities
\r
2563 print "<PRE>---GOT---\n" . htmlentities($data) . "\n---END---\n</PRE>";
\r
2568 error_log('XML-RPC: '.__METHOD__.': no response received from server.');
\r
2569 $r = new xmlrpcresp(0, $GLOBALS['xmlrpcerr']['no_data'], $GLOBALS['xmlrpcstr']['no_data']);
\r
2573 $GLOBALS['_xh']=array();
\r
2575 $raw_data = $data;
\r
2576 // parse the HTTP headers of the response, if present, and separate them from data
\r
2577 if(substr($data, 0, 4) == 'HTTP')
\r
2579 $r =& $this->parseResponseHeaders($data, $headers_processed);
\r
2582 // failed processing of HTTP response headers
\r
2583 // save into response obj the full payload received, for debugging
\r
2584 $r->raw_data = $data;
\r
2590 $GLOBALS['_xh']['headers'] = array();
\r
2591 $GLOBALS['_xh']['cookies'] = array();
\r
2596 $start = strpos($data, '<!-- SERVER DEBUG INFO (BASE64 ENCODED):');
\r
2599 $start += strlen('<!-- SERVER DEBUG INFO (BASE64 ENCODED):');
\r
2600 $end = strpos($data, '-->', $start);
\r
2601 $comments = substr($data, $start, $end-$start);
\r
2602 print "<PRE>---SERVER DEBUG INFO (DECODED) ---\n\t".htmlentities(str_replace("\n", "\n\t", base64_decode($comments)))."\n---END---\n</PRE>";
\r
2606 // be tolerant of extra whitespace in response body
\r
2607 $data = trim($data);
\r
2609 /// @todo return an error msg if $data=='' ?
\r
2611 // be tolerant of junk after methodResponse (e.g. javascript ads automatically inserted by free hosts)
\r
2612 // idea from Luca Mariano <luca.mariano@email.it> originally in PEARified version of the lib
\r
2613 $pos = strrpos($data, '</methodResponse>');
\r
2614 if($pos !== false)
\r
2616 $data = substr($data, 0, $pos+17);
\r
2619 // if user wants back raw xml, give it to him
\r
2620 if ($return_type == 'xml')
\r
2622 $r = new xmlrpcresp($data, 0, '', 'xml');
\r
2623 $r->hdrs = $GLOBALS['_xh']['headers'];
\r
2624 $r->_cookies = $GLOBALS['_xh']['cookies'];
\r
2625 $r->raw_data = $raw_data;
\r
2629 // try to 'guestimate' the character encoding of the received response
\r
2630 $resp_encoding = guess_encoding(@$GLOBALS['_xh']['headers']['content-type'], $data);
\r
2632 $GLOBALS['_xh']['ac']='';
\r
2633 //$GLOBALS['_xh']['qt']=''; //unused...
\r
2634 $GLOBALS['_xh']['stack'] = array();
\r
2635 $GLOBALS['_xh']['valuestack'] = array();
\r
2636 $GLOBALS['_xh']['isf']=0; // 0 = OK, 1 for xmlrpc fault responses, 2 = invalid xmlrpc
\r
2637 $GLOBALS['_xh']['isf_reason']='';
\r
2638 $GLOBALS['_xh']['rt']=''; // 'methodcall or 'methodresponse'
\r
2640 // Since parsing will fail if charset is not specified in the xml prologue,
\r
2641 // the encoding is not UTF8 and there are non-ascii chars in the text, we try to work round that...
\r
2642 // The following code might be better for mb_string enabled installs, but
\r
2643 // makes the lib about 200% slower...
\r
2644 //if (!is_valid_charset($resp_encoding, array('UTF-8')))
\r
2645 if (!in_array($resp_encoding, array('UTF-8', 'US-ASCII')) && !has_encoding($data)) {
\r
2646 if ($resp_encoding == 'ISO-8859-1') {
\r
2647 $data = utf8_encode($data);
\r
2649 if (extension_loaded('mbstring')) {
\r
2650 $data = mb_convert_encoding($data, 'UTF-8', $resp_encoding);
\r
2652 error_log('XML-RPC: ' . __METHOD__ . ': invalid charset encoding of received request: ' . $resp_encoding);
\r
2657 $parser = xml_parser_create();
\r
2658 xml_parser_set_option($parser, XML_OPTION_CASE_FOLDING, true);
\r
2659 // G. Giunta 2005/02/13: PHP internally uses ISO-8859-1, so we have to tell
\r
2660 // the xml parser to give us back data in the expected charset.
\r
2661 // What if internal encoding is not in one of the 3 allowed?
\r
2662 // we use the broadest one, ie. utf8
\r
2663 // This allows to send data which is native in various charset,
\r
2664 // by extending xmlrpc_encode_entitites() and setting xmlrpc_internalencoding
\r
2665 if (!in_array($GLOBALS['xmlrpc_internalencoding'], array('UTF-8', 'ISO-8859-1', 'US-ASCII')))
\r
2667 xml_parser_set_option($parser, XML_OPTION_TARGET_ENCODING, 'UTF-8');
\r
2671 xml_parser_set_option($parser, XML_OPTION_TARGET_ENCODING, $GLOBALS['xmlrpc_internalencoding']);
\r
2674 if ($return_type == 'phpvals')
\r
2676 xml_set_element_handler($parser, 'xmlrpc_se', 'xmlrpc_ee_fast');
\r
2680 xml_set_element_handler($parser, 'xmlrpc_se', 'xmlrpc_ee');
\r
2683 xml_set_character_data_handler($parser, 'xmlrpc_cd');
\r
2684 xml_set_default_handler($parser, 'xmlrpc_dh');
\r
2686 // first error check: xml not well formed
\r
2687 if(!xml_parse($parser, $data, 1))
\r
2689 // thanks to Peter Kocks <peter.kocks@baygate.com>
\r
2690 if((xml_get_current_line_number($parser)) == 1)
\r
2692 $errstr = 'XML error at line 1, check URL';
\r
2696 $errstr = sprintf('XML error: %s at line %d, column %d',
\r
2697 xml_error_string(xml_get_error_code($parser)),
\r
2698 xml_get_current_line_number($parser), xml_get_current_column_number($parser));
\r
2700 error_log($errstr);
\r
2701 $r=new xmlrpcresp(0, $GLOBALS['xmlrpcerr']['invalid_return'], $GLOBALS['xmlrpcstr']['invalid_return'].' ('.$errstr.')');
\r
2702 xml_parser_free($parser);
\r
2707 $r->hdrs = $GLOBALS['_xh']['headers'];
\r
2708 $r->_cookies = $GLOBALS['_xh']['cookies'];
\r
2709 $r->raw_data = $raw_data;
\r
2712 xml_parser_free($parser);
\r
2713 // second error check: xml well formed but not xml-rpc compliant
\r
2714 if ($GLOBALS['_xh']['isf'] > 1)
\r
2718 /// @todo echo something for user?
\r
2721 $r = new xmlrpcresp(0, $GLOBALS['xmlrpcerr']['invalid_return'],
\r
2722 $GLOBALS['xmlrpcstr']['invalid_return'] . ' ' . $GLOBALS['_xh']['isf_reason']);
\r
2724 // third error check: parsing of the response has somehow gone boink.
\r
2725 // NB: shall we omit this check, since we trust the parsing code?
\r
2726 elseif ($return_type == 'xmlrpcvals' && !is_object($GLOBALS['_xh']['value']))
\r
2728 // something odd has happened
\r
2729 // and it's time to generate a client side error
\r
2730 // indicating something odd went on
\r
2731 $r=new xmlrpcresp(0, $GLOBALS['xmlrpcerr']['invalid_return'],
\r
2732 $GLOBALS['xmlrpcstr']['invalid_return']);
\r
2738 print "<PRE>---PARSED---\n";
\r
2739 // somehow htmlentities chokes on var_export, and some full html string...
\r
2740 //print htmlentitites(var_export($GLOBALS['_xh']['value'], true));
\r
2741 print htmlspecialchars(var_export($GLOBALS['_xh']['value'], true));
\r
2742 print "\n---END---</PRE>";
\r
2745 // note that using =& will raise an error if $GLOBALS['_xh']['st'] does not generate an object.
\r
2746 $v =& $GLOBALS['_xh']['value'];
\r
2748 if($GLOBALS['_xh']['isf'])
\r
2750 /// @todo we should test here if server sent an int and a string,
\r
2751 /// and/or coerce them into such...
\r
2752 if ($return_type == 'xmlrpcvals')
\r
2754 $errno_v = $v->structmem('faultCode');
\r
2755 $errstr_v = $v->structmem('faultString');
\r
2756 $errno = $errno_v->scalarval();
\r
2757 $errstr = $errstr_v->scalarval();
\r
2761 $errno = $v['faultCode'];
\r
2762 $errstr = $v['faultString'];
\r
2767 // FAULT returned, errno needs to reflect that
\r
2771 $r = new xmlrpcresp(0, $errno, $errstr);
\r
2775 $r=new xmlrpcresp($v, 0, '', $return_type);
\r
2779 $r->hdrs = $GLOBALS['_xh']['headers'];
\r
2780 $r->_cookies = $GLOBALS['_xh']['cookies'];
\r
2781 $r->raw_data = $raw_data;
\r
2790 var $_php_class=null;
\r
2793 * @param mixed $val
\r
2794 * @param string $type any valid xmlrpc type name (lowercase). If null, 'string' is assumed
\r
2796 function __construct($val=-1, $type='')
\r
2798 /// @todo: optimization creep - do not call addXX, do it all inline.
\r
2799 /// downside: booleans will not be coerced anymore
\r
2800 if($val!==-1 || $type!='')
\r
2802 // optimization creep: inlined all work done by constructor
\r
2807 $this->me['string']=$val;
\r
2814 case 'dateTime.iso8601':
\r
2818 $this->me[$type]=$val;
\r
2822 $this->me['array']=$val;
\r
2826 $this->me['struct']=$val;
\r
2829 error_log("XML-RPC: ".__METHOD__.": not a known type ($type)");
\r
2835 if($GLOBALS['xmlrpcTypes'][$type]==1)
\r
2837 $this->addScalar($val,$type);
\r
2839 elseif($GLOBALS['xmlrpcTypes'][$type]==2)
\r
2841 $this->addArray($val);
\r
2843 elseif($GLOBALS['xmlrpcTypes'][$type]==3)
\r
2845 $this->addStruct($val);
\r
2853 function xmlrpcval($val=-1, $type='')
\r
2855 self::__construct($val, $type);
\r
2859 * Add a single php value to an (unitialized) xmlrpcval
\r
2860 * @param mixed $val
\r
2861 * @param string $type
\r
2862 * @return int 1 or 0 on failure
\r
2864 function addScalar($val, $type='string')
\r
2866 $typeof=@$GLOBALS['xmlrpcTypes'][$type];
\r
2869 error_log("XML-RPC: ".__METHOD__.": not a scalar type ($type)");
\r
2873 // coerce booleans into correct values
\r
2874 // NB: we should either do it for datetimes, integers and doubles, too,
\r
2875 // or just plain remove this check, implemented on booleans only...
\r
2876 if($type==$GLOBALS['xmlrpcBoolean'])
\r
2878 if(strcasecmp($val,'true')==0 || $val==1 || ($val==true && strcasecmp($val,'false')))
\r
2888 switch($this->mytype)
\r
2891 error_log('XML-RPC: '.__METHOD__.': scalar xmlrpcval can have only one value');
\r
2894 error_log('XML-RPC: '.__METHOD__.': cannot add anonymous scalar to struct xmlrpcval');
\r
2897 // we're adding a scalar value to an array here
\r
2898 //$ar=$this->me['array'];
\r
2899 //$ar[]=new xmlrpcval($val, $type);
\r
2900 //$this->me['array']=$ar;
\r
2901 // Faster (?) avoid all the costly array-copy-by-val done here...
\r
2902 $this->me['array'][]=new xmlrpcval($val, $type);
\r
2905 // a scalar, so set the value and remember we're scalar
\r
2906 $this->me[$type]=$val;
\r
2907 $this->mytype=$typeof;
\r
2913 * Add an array of xmlrpcval objects to an xmlrpcval
\r
2914 * @param array $vals
\r
2915 * @return int 1 or 0 on failure
\r
2918 * @todo add some checking for $vals to be an array of xmlrpcvals?
\r
2920 function addArray($vals)
\r
2922 if($this->mytype==0)
\r
2924 $this->mytype=$GLOBALS['xmlrpcTypes']['array'];
\r
2925 $this->me['array']=$vals;
\r
2928 elseif($this->mytype==2)
\r
2930 // we're adding to an array here
\r
2931 $this->me['array'] = array_merge($this->me['array'], $vals);
\r
2936 error_log('XML-RPC: '.__METHOD__.': already initialized as a [' . $this->kindOf() . ']');
\r
2942 * Add an array of named xmlrpcval objects to an xmlrpcval
\r
2943 * @param array $vals
\r
2944 * @return int 1 or 0 on failure
\r
2947 * @todo add some checking for $vals to be an array?
\r
2949 function addStruct($vals)
\r
2951 if($this->mytype==0)
\r
2953 $this->mytype=$GLOBALS['xmlrpcTypes']['struct'];
\r
2954 $this->me['struct']=$vals;
\r
2957 elseif($this->mytype==3)
\r
2959 // we're adding to a struct here
\r
2960 $this->me['struct'] = array_merge($this->me['struct'], $vals);
\r
2965 error_log('XML-RPC: '.__METHOD__.': already initialized as a [' . $this->kindOf() . ']');
\r
2970 // poor man's version of print_r ???
\r
2972 function dump($ar)
\r
2974 foreach($ar as $key => $val)
\r
2976 echo "$key => $val<br />";
\r
2977 if($key == 'array')
\r
2979 foreach($val as $key2 => $val2)
\r
2981 echo "-- $key2 => $val2<br />";
\r
2988 * Returns a string containing "struct", "array" or "scalar" describing the base type of the value
\r
2994 switch($this->mytype)
\r
3013 function serializedata($typ, $val, $charset_encoding='')
\r
3016 switch(@$GLOBALS['xmlrpcTypes'][$typ])
\r
3021 case $GLOBALS['xmlrpcBase64']:
\r
3022 $rs.="<${typ}>" . base64_encode($val) . "</${typ}>";
\r
3024 case $GLOBALS['xmlrpcBoolean']:
\r
3025 $rs.="<${typ}>" . ($val ? '1' : '0') . "</${typ}>";
\r
3027 case $GLOBALS['xmlrpcString']:
\r
3028 // G. Giunta 2005/2/13: do NOT use htmlentities, since
\r
3029 // it will produce named html entities, which are invalid xml
\r
3030 $rs.="<${typ}>" . xmlrpc_encode_entitites($val, $GLOBALS['xmlrpc_internalencoding'], $charset_encoding). "</${typ}>";
\r
3032 case $GLOBALS['xmlrpcInt']:
\r
3033 case $GLOBALS['xmlrpcI4']:
\r
3034 $rs.="<${typ}>".(int)$val."</${typ}>";
\r
3036 case $GLOBALS['xmlrpcDouble']:
\r
3037 // avoid using standard conversion of float to string because it is locale-dependent,
\r
3038 // and also because the xmlrpc spec forbids exponential notation.
\r
3039 // sprintf('%F') could be most likely ok but it fails eg. on 2e-14.
\r
3040 // The code below tries its best at keeping max precision while avoiding exp notation,
\r
3041 // but there is of course no limit in the number of decimal places to be used...
\r
3042 $rs.="<${typ}>".preg_replace('/\\.?0+$/','',number_format((double)$val, 128, '.', ''))."</${typ}>";
\r
3044 case $GLOBALS['xmlrpcDateTime']:
\r
3045 if (is_string($val))
\r
3047 $rs.="<${typ}>${val}</${typ}>";
\r
3049 else if(is_a($val, 'DateTime'))
\r
3051 $rs.="<${typ}>".$val->format('Ymd\TH:i:s')."</${typ}>";
\r
3053 else if(is_int($val))
\r
3055 $rs.="<${typ}>".strftime("%Y%m%dT%H:%M:%S", $val)."</${typ}>";
\r
3059 // not really a good idea here: but what shall we output anyway? left for backward compat...
\r
3060 $rs.="<${typ}>${val}</${typ}>";
\r
3063 case $GLOBALS['xmlrpcNull']:
\r
3064 if ($GLOBALS['xmlrpc_null_apache_encoding'])
\r
3074 // no standard type value should arrive here, but provide a possibility
\r
3075 // for xmlrpcvals of unknown type...
\r
3076 $rs.="<${typ}>${val}</${typ}>";
\r
3081 if ($this->_php_class)
\r
3083 $rs.='<struct php_class="' . $this->_php_class . "\">\n";
\r
3087 $rs.="<struct>\n";
\r
3089 foreach($val as $key2 => $val2)
\r
3091 $rs.='<member><name>'.xmlrpc_encode_entitites($key2, $GLOBALS['xmlrpc_internalencoding'], $charset_encoding)."</name>\n";
\r
3092 //$rs.=$this->serializeval($val2);
\r
3093 $rs.=$val2->serialize($charset_encoding);
\r
3094 $rs.="</member>\n";
\r
3100 $rs.="<array>\n<data>\n";
\r
3101 for($i=0; $i<count($val); $i++)
\r
3103 //$rs.=$this->serializeval($val[$i]);
\r
3104 $rs.=$val[$i]->serialize($charset_encoding);
\r
3106 $rs.="</data>\n</array>";
\r
3115 * Returns xml representation of the value. XML prologue not included
\r
3116 * @param string $charset_encoding the charset to be used for serialization. if null, US-ASCII is assumed
\r
3120 function serialize($charset_encoding='')
\r
3122 // add check? slower, but helps to avoid recursion in serializing broken xmlrpcvals...
\r
3123 //if (is_object($o) && (get_class($o) == 'xmlrpcval' || is_subclass_of($o, 'xmlrpcval')))
\r
3125 $val = reset($this->me);
\r
3126 $typ = key($this->me);
\r
3127 return '<value>' . $this->serializedata($typ, $val, $charset_encoding) . "</value>\n";
\r
3132 function serializeval($o)
\r
3134 // add check? slower, but helps to avoid recursion in serializing broken xmlrpcvals...
\r
3135 //if (is_object($o) && (get_class($o) == 'xmlrpcval' || is_subclass_of($o, 'xmlrpcval')))
\r
3137 $val = reset($o->me);
\r
3138 $typ = key($o->me);
\r
3139 return '<value>' . $this->serializedata($typ, $val) . "</value>\n";
\r
3144 * Checks whether a struct member with a given name is present.
\r
3145 * Works only on xmlrpcvals of type struct.
\r
3146 * @param string $m the name of the struct member to be looked up
\r
3150 function structmemexists($m)
\r
3152 return array_key_exists($m, $this->me['struct']);
\r
3156 * Returns the value of a given struct member (an xmlrpcval object in itself).
\r
3157 * Will raise a php warning if struct member of given name does not exist
\r
3158 * @param string $m the name of the struct member to be looked up
\r
3159 * @return xmlrpcval
\r
3162 function structmem($m)
\r
3164 return $this->me['struct'][$m];
\r
3168 * Reset internal pointer for xmlrpcvals of type struct.
\r
3171 function structreset()
\r
3173 reset($this->me['struct']);
\r
3177 * Return next member element for xmlrpcvals of type struct.
\r
3178 * @return xmlrpcval
\r
3180 * @deprecated this will be removed in future versions
\r
3182 function structeach()
\r
3184 return @each($this->me['struct']);
\r
3187 // this code looks like it is very fragile and has not been fixed
\r
3188 // for a long long time. Shall we remove it for 2.0?
\r
3193 $b = reset($this->me);
\r
3194 // contributed by I Sofer, 2001-03-24
\r
3195 // add support for nested arrays to scalarval
\r
3196 // i've created a new method here, so as to
\r
3197 // preserve back compatibility
\r
3201 foreach($b as $id => $cont)
\r
3203 $b[$id] = $cont->scalarval();
\r
3207 // add support for structures directly encoding php objects
\r
3210 $t = get_object_vars($b);
\r
3211 foreach($t as $id => $cont)
\r
3213 $t[$id] = $cont->scalarval();
\r
3215 foreach($t as $id => $cont)
\r
3225 * Returns the value of a scalar xmlrpcval
\r
3229 function scalarval()
\r
3231 $b = reset($this->me);
\r
3236 * Returns the type of the xmlrpcval.
\r
3237 * For integers, 'int' is always returned in place of 'i4'
\r
3241 function scalartyp()
\r
3244 $a = key($this->me);
\r
3245 if($a==$GLOBALS['xmlrpcI4'])
\r
3247 $a=$GLOBALS['xmlrpcInt'];
\r
3253 * Returns the m-th member of an xmlrpcval of struct type
\r
3254 * @param integer $m the index of the value to be retrieved (zero based)
\r
3255 * @return xmlrpcval
\r
3258 function arraymem($m)
\r
3260 return $this->me['array'][$m];
\r
3264 * Returns the number of members in an xmlrpcval of array type
\r
3268 function arraysize()
\r
3270 return count($this->me['array']);
\r
3274 * Returns the number of members in an xmlrpcval of struct type
\r
3278 function structsize()
\r
3280 return count($this->me['struct']);
\r
3288 * Given a timestamp, return the corresponding ISO8601 encoded string.
\r
3290 * Really, timezones ought to be supported
\r
3291 * but the XML-RPC spec says:
\r
3293 * "Don't assume a timezone. It should be specified by the server in its
\r
3294 * documentation what assumptions it makes about timezones."
\r
3296 * These routines always assume localtime unless
\r
3297 * $utc is set to 1, in which case UTC is assumed
\r
3298 * and an adjustment for locale is made when encoding
\r
3300 * @param int $timet (timestamp)
\r
3301 * @param int $utc (0 or 1)
\r
3304 function iso8601_encode($timet, $utc=0)
\r
3308 $t=strftime("%Y%m%dT%H:%M:%S", $timet);
\r
3312 if(function_exists('gmstrftime'))
\r
3314 // gmstrftime doesn't exist in some versions
\r
3316 $t=gmstrftime("%Y%m%dT%H:%M:%S", $timet);
\r
3320 $t=strftime("%Y%m%dT%H:%M:%S", $timet-date('Z'));
\r
3327 * Given an ISO8601 date string, return a timet in the localtime, or UTC
\r
3328 * @param string $idate
\r
3329 * @param int $utc either 0 or 1
\r
3330 * @return int (datetime)
\r
3332 function iso8601_decode($idate, $utc=0)
\r
3335 if(preg_match('/([0-9]{4})([0-9]{2})([0-9]{2})T([0-9]{2}):([0-9]{2}):([0-9]{2})/', $idate, $regs))
\r
3339 $t=gmmktime($regs[4], $regs[5], $regs[6], $regs[2], $regs[3], $regs[1]);
\r
3343 $t=mktime($regs[4], $regs[5], $regs[6], $regs[2], $regs[3], $regs[1]);
\r
3350 * Takes an xmlrpc value in PHP xmlrpcval object format and translates it into native PHP types.
\r
3352 * Works with xmlrpc message objects as input, too.
\r
3354 * Given proper options parameter, can rebuild generic php object instances
\r
3355 * (provided those have been encoded to xmlrpc format using a corresponding
\r
3356 * option in php_xmlrpc_encode())
\r
3357 * PLEASE NOTE that rebuilding php objects involves calling their constructor function.
\r
3358 * This means that the remote communication end can decide which php code will
\r
3359 * get executed on your server, leaving the door possibly open to 'php-injection'
\r
3360 * style of attacks (provided you have some classes defined on your server that
\r
3361 * might wreak havoc if instances are built outside an appropriate context).
\r
3362 * Make sure you trust the remote server/client before eanbling this!
\r
3364 * @author Dan Libby (dan@libby.com)
\r
3366 * @param xmlrpcval $xmlrpc_val
\r
3367 * @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
\r
3370 function php_xmlrpc_decode($xmlrpc_val, $options=array())
\r
3372 switch($xmlrpc_val->kindOf())
\r
3375 if (in_array('extension_api', $options))
\r
3377 $val = reset($xmlrpc_val->me);
\r
3378 $typ = key($xmlrpc_val->me);
\r
3381 case 'dateTime.iso8601':
\r
3382 $xmlrpc_val->scalar = $val;
\r
3383 $xmlrpc_val->xmlrpc_type = 'datetime';
\r
3384 $xmlrpc_val->timestamp = iso8601_decode($val);
\r
3385 return $xmlrpc_val;
\r
3387 $xmlrpc_val->scalar = $val;
\r
3388 $xmlrpc_val->type = $typ;
\r
3389 return $xmlrpc_val;
\r
3391 return $xmlrpc_val->scalarval();
\r
3394 if (in_array('dates_as_objects', $options) && $xmlrpc_val->scalartyp() == 'dateTime.iso8601')
\r
3396 // we return a Datetime object instead of a string
\r
3397 // since now the constructor of xmlrpcval accepts safely strings, ints and datetimes,
\r
3398 // we cater to all 3 cases here
\r
3399 $out = $xmlrpc_val->scalarval();
\r
3400 if (is_string($out))
\r
3402 $out = strtotime($out);
\r
3406 $result = new Datetime();
\r
3407 $result->setTimestamp($out);
\r
3410 elseif (is_a($out, 'Datetime'))
\r
3415 return $xmlrpc_val->scalarval();
\r
3417 $size = $xmlrpc_val->arraysize();
\r
3419 for($i = 0; $i < $size; $i++)
\r
3421 $arr[] = php_xmlrpc_decode($xmlrpc_val->arraymem($i), $options);
\r
3425 $xmlrpc_val->structreset();
\r
3426 // If user said so, try to rebuild php objects for specific struct vals.
\r
3427 /// @todo should we raise a warning for class not found?
\r
3428 // shall we check for proper subclass of xmlrpcval instead of
\r
3429 // presence of _php_class to detect what we can do?
\r
3430 if (in_array('decode_php_objs', $options) && $xmlrpc_val->_php_class != ''
\r
3431 && class_exists($xmlrpc_val->_php_class))
\r
3433 $obj = @new $xmlrpc_val->_php_class;
\r
3434 while(list($key,$value)=$xmlrpc_val->structeach())
\r
3436 $obj->$key = php_xmlrpc_decode($value, $options);
\r
3443 while(list($key,$value)=$xmlrpc_val->structeach())
\r
3445 $arr[$key] = php_xmlrpc_decode($value, $options);
\r
3450 $paramcount = $xmlrpc_val->getNumParams();
\r
3452 for($i = 0; $i < $paramcount; $i++)
\r
3454 $arr[] = php_xmlrpc_decode($xmlrpc_val->getParam($i));
\r
3460 // This constant left here only for historical reasons...
\r
3461 // it was used to decide if we have to define xmlrpc_encode on our own, but
\r
3462 // we do not do it anymore
\r
3463 if(function_exists('xmlrpc_decode'))
\r
3465 define('XMLRPC_EPI_ENABLED','1');
\r
3469 define('XMLRPC_EPI_ENABLED','0');
\r
3473 * Takes native php types and encodes them into xmlrpc PHP object format.
\r
3474 * It will not re-encode xmlrpcval objects.
\r
3476 * Feature creep -- could support more types via optional type argument
\r
3477 * (string => datetime support has been added, ??? => base64 not yet)
\r
3479 * If given a proper options parameter, php object instances will be encoded
\r
3480 * into 'special' xmlrpc values, that can later be decoded into php objects
\r
3481 * by calling php_xmlrpc_decode() with a corresponding option
\r
3483 * @author Dan Libby (dan@libby.com)
\r
3485 * @param mixed $php_val the value to be converted into an xmlrpcval object
\r
3486 * @param array $options can include 'encode_php_objs', 'auto_dates', 'null_extension' or 'extension_api'
\r
3487 * @return xmlrpcval
\r
3489 function php_xmlrpc_encode($php_val, $options=array())
\r
3491 $type = gettype($php_val);
\r
3495 if (in_array('auto_dates', $options) && preg_match('/^[0-9]{8}T[0-9]{2}:[0-9]{2}:[0-9]{2}$/', $php_val))
\r
3496 $xmlrpc_val = new xmlrpcval($php_val, $GLOBALS['xmlrpcDateTime']);
\r
3498 $xmlrpc_val = new xmlrpcval($php_val, $GLOBALS['xmlrpcString']);
\r
3501 $xmlrpc_val = new xmlrpcval($php_val, $GLOBALS['xmlrpcInt']);
\r
3504 $xmlrpc_val = new xmlrpcval($php_val, $GLOBALS['xmlrpcDouble']);
\r
3506 // <G_Giunta_2001-02-29>
\r
3507 // Add support for encoding/decoding of booleans, since they are supported in PHP
\r
3509 $xmlrpc_val = new xmlrpcval($php_val, $GLOBALS['xmlrpcBoolean']);
\r
3511 // </G_Giunta_2001-02-29>
\r
3513 // PHP arrays can be encoded to either xmlrpc structs or arrays,
\r
3514 // depending on wheter they are hashes or plain 0..n integer indexed
\r
3515 // A shorter one-liner would be
\r
3516 // $tmp = array_diff(array_keys($php_val), range(0, count($php_val)-1));
\r
3517 // but execution time skyrockets!
\r
3521 foreach($php_val as $key => $val)
\r
3523 $arr[$key] = php_xmlrpc_encode($val, $options);
\r
3524 if(!$ko && $key !== $j)
\r
3532 $xmlrpc_val = new xmlrpcval($arr, $GLOBALS['xmlrpcStruct']);
\r
3536 $xmlrpc_val = new xmlrpcval($arr, $GLOBALS['xmlrpcArray']);
\r
3540 if(is_a($php_val, 'xmlrpcval'))
\r
3542 $xmlrpc_val = $php_val;
\r
3544 else if(is_a($php_val, 'DateTime'))
\r
3546 $xmlrpc_val = new xmlrpcval($php_val->format('Ymd\TH:i:s'), $GLOBALS['xmlrpcStruct']);
\r
3551 foreach($php_val as $k => $v)
\r
3553 $arr[$k] = php_xmlrpc_encode($v, $options);
\r
3555 $xmlrpc_val = new xmlrpcval($arr, $GLOBALS['xmlrpcStruct']);
\r
3556 if (in_array('encode_php_objs', $options))
\r
3558 // let's save original class name into xmlrpcval:
\r
3559 // might be useful later on...
\r
3560 $xmlrpc_val->_php_class = get_class($php_val);
\r
3565 if (in_array('extension_api', $options))
\r
3567 $xmlrpc_val = new xmlrpcval('', $GLOBALS['xmlrpcString']);
\r
3569 else if (in_array('null_extension', $options))
\r
3571 $xmlrpc_val = new xmlrpcval('', $GLOBALS['xmlrpcNull']);
\r
3575 $xmlrpc_val = new xmlrpcval();
\r
3579 if (in_array('extension_api', $options))
\r
3581 $xmlrpc_val = new xmlrpcval((int)$php_val, $GLOBALS['xmlrpcInt']);
\r
3585 $xmlrpc_val = new xmlrpcval();
\r
3587 // catch "user function", "unknown type"
\r
3589 // giancarlo pinerolo <ping@alt.it>
\r
3590 // it has to return
\r
3591 // an empty object in case, not a boolean.
\r
3592 $xmlrpc_val = new xmlrpcval();
\r
3595 return $xmlrpc_val;
\r
3599 * Convert the xml representation of a method response, method request or single
\r
3600 * xmlrpc value into the appropriate object (a.k.a. deserialize)
\r
3601 * @param string $xml_val
\r
3602 * @param array $options
\r
3603 * @return mixed false on error, or an instance of either xmlrpcval, xmlrpcmsg or xmlrpcresp
\r
3605 function php_xmlrpc_decode_xml($xml_val, $options=array())
\r
3607 $GLOBALS['_xh'] = array();
\r
3608 $GLOBALS['_xh']['ac'] = '';
\r
3609 $GLOBALS['_xh']['stack'] = array();
\r
3610 $GLOBALS['_xh']['valuestack'] = array();
\r
3611 $GLOBALS['_xh']['params'] = array();
\r
3612 $GLOBALS['_xh']['pt'] = array();
\r
3613 $GLOBALS['_xh']['isf'] = 0;
\r
3614 $GLOBALS['_xh']['isf_reason'] = '';
\r
3615 $GLOBALS['_xh']['method'] = false;
\r
3616 $GLOBALS['_xh']['rt'] = '';
\r
3618 // 'guestimate' encoding
\r
3619 $val_encoding = guess_encoding('', $xml_val);
\r
3621 // Since parsing will fail if charset is not specified in the xml prologue,
\r
3622 // the encoding is not UTF8 and there are non-ascii chars in the text, we try to work round that...
\r
3623 // The following code might be better for mb_string enabled installs, but
\r
3624 // makes the lib about 200% slower...
\r
3625 //if (!is_valid_charset($val_encoding, array('UTF-8')))
\r
3626 if (!in_array($val_encoding, array('UTF-8', 'US-ASCII')) && !has_encoding($xml_val)) {
\r
3627 if ($val_encoding == 'ISO-8859-1') {
\r
3628 $xml_val = utf8_encode($xml_val);
\r
3630 if (extension_loaded('mbstring')) {
\r
3631 $xml_val = mb_convert_encoding($xml_val, 'UTF-8', $val_encoding);
\r
3633 error_log('XML-RPC: ' . __METHOD__ . ': invalid charset encoding of received request: ' . $val_encoding);
\r
3638 $parser = xml_parser_create();
\r
3639 xml_parser_set_option($parser, XML_OPTION_CASE_FOLDING, true);
\r
3640 // What if internal encoding is not in one of the 3 allowed?
\r
3641 // we use the broadest one, ie. utf8!
\r
3642 if (!in_array($GLOBALS['xmlrpc_internalencoding'], array('UTF-8', 'ISO-8859-1', 'US-ASCII')))
\r
3644 xml_parser_set_option($parser, XML_OPTION_TARGET_ENCODING, 'UTF-8');
\r
3648 xml_parser_set_option($parser, XML_OPTION_TARGET_ENCODING, $GLOBALS['xmlrpc_internalencoding']);
\r
3650 xml_set_element_handler($parser, 'xmlrpc_se_any', 'xmlrpc_ee');
\r
3651 xml_set_character_data_handler($parser, 'xmlrpc_cd');
\r
3652 xml_set_default_handler($parser, 'xmlrpc_dh');
\r
3653 if(!xml_parse($parser, $xml_val, 1))
\r
3655 $errstr = sprintf('XML error: %s at line %d, column %d',
\r
3656 xml_error_string(xml_get_error_code($parser)),
\r
3657 xml_get_current_line_number($parser), xml_get_current_column_number($parser));
\r
3658 error_log($errstr);
\r
3659 xml_parser_free($parser);
\r
3662 xml_parser_free($parser);
\r
3663 if ($GLOBALS['_xh']['isf'] > 1) // test that $GLOBALS['_xh']['value'] is an obj, too???
\r
3665 error_log($GLOBALS['_xh']['isf_reason']);
\r
3668 switch ($GLOBALS['_xh']['rt'])
\r
3670 case 'methodresponse':
\r
3671 $v =& $GLOBALS['_xh']['value'];
\r
3672 if ($GLOBALS['_xh']['isf'] == 1)
\r
3674 $vc = $v->structmem('faultCode');
\r
3675 $vs = $v->structmem('faultString');
\r
3676 $r = new xmlrpcresp(0, $vc->scalarval(), $vs->scalarval());
\r
3680 $r = new xmlrpcresp($v);
\r
3683 case 'methodcall':
\r
3684 $m = new xmlrpcmsg($GLOBALS['_xh']['method']);
\r
3685 for($i=0; $i < count($GLOBALS['_xh']['params']); $i++)
\r
3687 $m->addParam($GLOBALS['_xh']['params'][$i]);
\r
3691 return $GLOBALS['_xh']['value'];
\r
3698 * decode a string that is encoded w/ "chunked" transfer encoding
\r
3699 * as defined in rfc2068 par. 19.4.6
\r
3700 * code shamelessly stolen from nusoap library by Dietrich Ayala
\r
3702 * @param string $buffer the string to be decoded
\r
3705 function decode_chunked($buffer)
\r
3711 // read chunk-size, chunk-extension (if any) and crlf
\r
3712 // get the position of the linebreak
\r
3713 $chunkend = strpos($buffer,"\r\n") + 2;
\r
3714 $temp = substr($buffer,0,$chunkend);
\r
3715 $chunk_size = hexdec( trim($temp) );
\r
3716 $chunkstart = $chunkend;
\r
3717 while($chunk_size > 0)
\r
3719 $chunkend = strpos($buffer, "\r\n", $chunkstart + $chunk_size);
\r
3721 // just in case we got a broken connection
\r
3722 if($chunkend == false)
\r
3724 $chunk = substr($buffer,$chunkstart);
\r
3725 // append chunk-data to entity-body
\r
3727 $length += strlen($chunk);
\r
3731 // read chunk-data and crlf
\r
3732 $chunk = substr($buffer,$chunkstart,$chunkend-$chunkstart);
\r
3733 // append chunk-data to entity-body
\r
3735 // length := length + chunk-size
\r
3736 $length += strlen($chunk);
\r
3737 // read chunk-size and crlf
\r
3738 $chunkstart = $chunkend + 2;
\r
3740 $chunkend = strpos($buffer,"\r\n",$chunkstart)+2;
\r
3741 if($chunkend == false)
\r
3743 break; //just in case we got a broken connection
\r
3745 $temp = substr($buffer,$chunkstart,$chunkend-$chunkstart);
\r
3746 $chunk_size = hexdec( trim($temp) );
\r
3747 $chunkstart = $chunkend;
\r
3753 * xml charset encoding guessing helper function.
\r
3754 * Tries to determine the charset encoding of an XML chunk received over HTTP.
\r
3755 * NB: according to the spec (RFC 3023), if text/xml content-type is received over HTTP without a content-type,
\r
3756 * we SHOULD assume it is strictly US-ASCII. But we try to be more tolerant of unconforming (legacy?) clients/servers,
\r
3757 * which will be most probably using UTF-8 anyway...
\r
3759 * @param string $httpheader the http Content-type header
\r
3760 * @param string $xmlchunk xml content buffer
\r
3761 * @param string $encoding_prefs comma separated list of character encodings to be used as default (when mb extension is enabled)
\r
3764 * @todo explore usage of mb_http_input(): does it detect http headers + post data? if so, use it instead of hand-detection!!!
\r
3766 function guess_encoding($httpheader='', $xmlchunk='', $encoding_prefs=null)
\r
3768 // discussion: see http://www.yale.edu/pclt/encoding/
\r
3769 // 1 - test if encoding is specified in HTTP HEADERS
\r
3772 // LWS: (\13\10)?( |\t)+
\r
3773 // token: (any char but excluded stuff)+
\r
3774 // quoted string: " (any char but double quotes and cointrol chars)* "
\r
3775 // header: Content-type = ...; charset=value(; ...)*
\r
3776 // where value is of type token, no LWS allowed between 'charset' and value
\r
3777 // Note: we do not check for invalid chars in VALUE:
\r
3778 // this had better be done using pure ereg as below
\r
3779 // Note 2: we might be removing whitespace/tabs that ought to be left in if
\r
3780 // the received charset is a quoted string. But nobody uses such charset names...
\r
3782 /// @todo this test will pass if ANY header has charset specification, not only Content-Type. Fix it?
\r
3783 $matches = array();
\r
3784 if(preg_match('/;\s*charset\s*=([^;]+)/i', $httpheader, $matches))
\r
3786 return strtoupper(trim($matches[1], " \t\""));
\r
3789 // 2 - scan the first bytes of the data for a UTF-16 (or other) BOM pattern
\r
3790 // (source: http://www.w3.org/TR/2000/REC-xml-20001006)
\r
3791 // NOTE: actually, according to the spec, even if we find the BOM and determine
\r
3792 // an encoding, we should check if there is an encoding specified
\r
3793 // in the xml declaration, and verify if they match.
\r
3794 /// @todo implement check as described above?
\r
3795 /// @todo implement check for first bytes of string even without a BOM? (It sure looks harder than for cases WITH a BOM)
\r
3796 if(preg_match('/^(\x00\x00\xFE\xFF|\xFF\xFE\x00\x00|\x00\x00\xFF\xFE|\xFE\xFF\x00\x00)/', $xmlchunk))
\r
3800 elseif(preg_match('/^(\xFE\xFF|\xFF\xFE)/', $xmlchunk))
\r
3804 elseif(preg_match('/^(\xEF\xBB\xBF)/', $xmlchunk))
\r
3809 // 3 - test if encoding is specified in the xml declaration
\r
3811 // SPACE: (#x20 | #x9 | #xD | #xA)+ === [ \x9\xD\xA]+
\r
3812 // EQ: SPACE?=SPACE? === [ \x9\xD\xA]*=[ \x9\xD\xA]*
\r
3813 if (preg_match('/^<\?xml\s+version\s*=\s*'. "((?:\"[a-zA-Z0-9_.:-]+\")|(?:'[a-zA-Z0-9_.:-]+'))".
\r
3814 '\s+encoding\s*=\s*' . "((?:\"[A-Za-z][A-Za-z0-9._-]*\")|(?:'[A-Za-z][A-Za-z0-9._-]*'))/",
\r
3815 $xmlchunk, $matches))
\r
3817 return strtoupper(substr($matches[2], 1, -1));
\r
3820 // 4 - if mbstring is available, let it do the guesswork
\r
3821 // NB: we favour finding an encoding that is compatible with what we can process
\r
3822 if(extension_loaded('mbstring'))
\r
3824 if($encoding_prefs)
\r
3826 $enc = mb_detect_encoding($xmlchunk, $encoding_prefs);
\r
3830 $enc = mb_detect_encoding($xmlchunk);
\r
3832 // NB: mb_detect likes to call it ascii, xml parser likes to call it US_ASCII...
\r
3833 // IANA also likes better US-ASCII, so go with it
\r
3834 if($enc == 'ASCII')
\r
3836 $enc = 'US-'.$enc;
\r
3842 // no encoding specified: as per HTTP1.1 assume it is iso-8859-1?
\r
3843 // Both RFC 2616 (HTTP 1.1) and 1945 (HTTP 1.0) clearly state that for text/xxx content types
\r
3844 // this should be the standard. And we should be getting text/xml as request and response.
\r
3845 // BUT we have to be backward compatible with the lib, which always used UTF-8 as default...
\r
3846 return $GLOBALS['xmlrpc_defencoding'];
\r
3851 * Helper function: checks if an xml chunk as a charset declaration (BOM or in the xml declaration)
\r
3853 * @param string $xmlChunk
\r
3856 function has_encoding($xmlChunk)
\r
3858 // scan the first bytes of the data for a UTF-16 (or other) BOM pattern
\r
3859 // (source: http://www.w3.org/TR/2000/REC-xml-20001006)
\r
3860 if (preg_match('/^(\x00\x00\xFE\xFF|\xFF\xFE\x00\x00|\x00\x00\xFF\xFE|\xFE\xFF\x00\x00)/', $xmlChunk))
\r
3864 elseif (preg_match('/^(\xFE\xFF|\xFF\xFE)/', $xmlChunk))
\r
3868 elseif (preg_match('/^(\xEF\xBB\xBF)/', $xmlChunk))
\r
3873 // test if encoding is specified in the xml declaration
\r
3875 // SPACE: (#x20 | #x9 | #xD | #xA)+ === [ \x9\xD\xA]+
\r
3876 // EQ: SPACE?=SPACE? === [ \x9\xD\xA]*=[ \x9\xD\xA]*
\r
3877 if (preg_match('/^<\?xml\s+version\s*=\s*' . "((?:\"[a-zA-Z0-9_.:-]+\")|(?:'[a-zA-Z0-9_.:-]+'))" .
\r
3878 '\s+encoding\s*=\s*' . "((?:\"[A-Za-z][A-Za-z0-9._-]*\")|(?:'[A-Za-z][A-Za-z0-9._-]*'))/",
\r
3879 $xmlChunk, $matches))
\r
3888 * Checks if a given charset encoding is present in a list of encodings or
\r
3889 * if it is a valid subset of any encoding in the list
\r
3890 * @param string $encoding charset to be tested
\r
3891 * @param mixed $validlist comma separated list of valid charsets (or array of charsets)
\r
3894 function is_valid_charset($encoding, $validlist)
\r
3896 $charset_supersets = array(
\r
3897 'US-ASCII' => array ('ISO-8859-1', 'ISO-8859-2', 'ISO-8859-3', 'ISO-8859-4',
\r
3898 'ISO-8859-5', 'ISO-8859-6', 'ISO-8859-7', 'ISO-8859-8',
\r
3899 'ISO-8859-9', 'ISO-8859-10', 'ISO-8859-11', 'ISO-8859-12',
\r
3900 'ISO-8859-13', 'ISO-8859-14', 'ISO-8859-15', 'UTF-8',
\r
3901 'EUC-JP', 'EUC-', 'EUC-KR', 'EUC-CN')
\r
3903 if (is_string($validlist))
\r
3904 $validlist = explode(',', $validlist);
\r
3905 if (@in_array(strtoupper($encoding), $validlist))
\r
3909 if (array_key_exists($encoding, $charset_supersets))
\r
3910 foreach ($validlist as $allowed)
\r
3911 if (in_array($allowed, $charset_supersets[$encoding]))
\r
git://git.onelab.eu / plcapi.git / blob